Software Architecture: UML, MVC, and Enterprise Patterns

In 2-tier architecture, changes to one tier (client or server) typically require changes to the other due to tight coupling. The central server represents a single point of failure - if it goes down, the entire system fails. These architectures are also more manageable than distributed n-tier systems due to simpler deployment and monitoring.

Model-View-Controller version 2 (MVC2) architecture uses a controller servlet to handle requests and delegate to appropriate views, which removes the page-centric nature found in traditional model 1 architectures. Therefore, the statement is true.

The jsp:useBean standard action supports four scope values: page, request, session, and application. Page scope is default and lasts only for the current page. Request scope lasts for the duration of the HTTP request. Session scope persists across multiple requests from the same user. Application scope is shared across all users and sessions. Since all four are valid options, 'All' is correct.

This statement is false, so the claimed answer is correct. Neither MVC1 nor MVC2 is inherently limited to small or large-scale applications. The choice between them depends on architectural requirements, maintainability needs, and team preferences - not application scale. MVC2 is generally preferred for complex applications due to better separation of concerns, but both can scale appropriately.

In MVC1 architecture, the JSP page acts as the controller, handling both request processing and presentation. The JSP directly receives requests, contains business logic or calls helper beans, and generates the response. This page-centric approach mixes concerns but simplifies development for simple applications. A separate servlet controller is not used in MVC1.

MVC2 uses a servlet as a central controller, making it servlet-centric architecture. A single controller servlet receives all requests, determines the appropriate handler, invokes business logic, and selects the view for rendering. This separation provides better maintainability and testability compared to page-centric approaches.

In MVC2 architecture, a servlet serves as the controller component. The controller servlet receives HTTP requests, delegates business logic processing to appropriate components (often JavaBeans or EJBs), manages session state, and selects the appropriate JSP view for rendering the response. This clear separation of concerns is a key advantage of MVC2.

MVC1 is page-centric because JSP pages handle both presentation and control logic. In MVC1, the JSP directly processes requests, contains business logic or makes calls to helper objects, and generates the HTML response. This combines view and controller responsibilities in a single component, making it page-centric by design.

MVC (Model-View-Controller) is a software design pattern that separates an application into three main components: the Model (data), the View (UI), and the Controller (logic). It's not a complete framework itself, though many frameworks implement it. Architecture is a broader concept, and MVC is one specific pattern within software architecture.

Events are not a core UML construct; they are state machine diagram elements, not general UML concepts. Actors (roles external to the system), Use Cases (system functionality), and Stakeholders (people with interests in the system) are all fundamental UML modeling elements.

In UML use case diagrams, use cases are represented as ovals (ellipses) with the use case name inside. This distinctive oval shape makes use cases easily recognizable and distinguishes them from actors (stick figures) and system boundaries (rectangles).

This is the standard definition of a use case in UML, a sequence of actions a system performs that delivers value to actors. Use cases capture functional requirements by describing system interactions from user perspectives, focusing on observable results rather than internal implementation.

UML was created by combining three object-oriented methodologies: Grady Booch's Booch method, James Rumbaugh's OMT (Object Modeling Technique), and Ivar Jacobson's OOSE (Object-Oriented Software Engineering). These three programmers are recognized as the primary designers of UML.

UML consists of three main components: views (structural and behavioral perspectives of the system), diagrams (graphical representations like class diagrams, sequence diagrams), and model elements (basic building blocks like classes, objects, relationships). All three are essential parts of UML.

Entity beans represent persistent data stored in a database and can survive server crashes because their state persists in storage. Stateful session beans maintain conversational state with a specific client only in memory and lose that state if the server crashes. Session beans typically handle business logic and make calls on entity beans for data operations, not the reverse.

EJB 2.0 local client views allow beans in the same JVM to communicate without remote call overhead. Local clients were introduced to improve performance by eliminating RMI/IIOP overhead when client and bean are co-located. Local interfaces are required for beans in the same container, not merely on the same machine.

ORM frameworks require developers skilled in both the application language and ORM tooling, creating a specialized resource requirement. This is a real disadvantage since such developers are harder to find and hire than general-purpose programmers.