Java Servlets, JSP, and MVC Architecture

Among executable web technologies, Servlets offer high performance because they are loaded once and run as lightweight threads within the web container. This avoids the overhead of spawning new processes (like Perl/CGI) or the initial translation and compilation delay associated with JSPs on their first invocation.

To retrieve data sent from an HTML page (like form inputs or query parameters), the servlet uses request.getParameter(String name). Methods on the response object are used for sending data back to the client, and there is no standard setParameter() method on the HTTP request object.

Static variables are stored in the JVM memory space and are shared only within the same JVM instance and classloader. Since the servlet is deployed on multiple separate servers, each runs in its own JVM, meaning they do not share the static variable, making the statement false.

In the Model-View-Controller (MVC) architectural pattern, the Controller acts as an interface that mediates between the View (presentation layer) and the Model (data/business logic). It processes user input, coordinates interactions between the View and Model, and manages the application's response flow.

ActionServlet is the core controller class of the Struts 1 framework, acting as the central servlet that intercepts incoming client requests and routes them to appropriate actions. Other options like ActionClass or ActionJsp are either incorrect terms or helper structures, not the central core class.

A key drawback of Struts framework is its single controller servlet architecture (ActionServlet). All requests must route through one servlet, which can create bottlenecks and scaling issues in high-traffic applications. Modern frameworks like Spring MVC support multiple controllers. The other options (backward/forward overflow) are not recognized drawbacks of Struts.

A controller is indeed the link between a user and the system in MVC (Model-View-Controller) architecture. The controller receives user requests, processes them, interacts with the model, and selects the appropriate view to render. This separation of concerns is fundamental to MVC design patterns used in web applications.

MVC stands for Model-View-Controller, a design pattern separating application logic into three interconnected components. Model handles data, View handles presentation, and Controller handles user input.

Struts framework is based on MVC2 architecture (Model 2), where a single controller servlet handles requests and dispatches to views. MVC2 improves on MVC1 by separating controller logic from views.

MVC1 architecture is tightly coupled because view and controller logic often mix in the same component (typically JSPs), making separation of concerns difficult. MVC2 improves this with a clear front controller.

The Model component includes business logic and data representation, commonly implemented as JavaBeans. HTML, Servlets, and JSPs belong to the View or Controller layers, not the Model.

The View component handles presentation and is typically implemented using JSP (JavaServer Pages). Beans and EJBs belong to the Model, while Servlets are Controllers.

The Controller component processes user requests and coordinates Model and View, typically implemented as Servlets. HTML is markup, JSPs are View components, and Beans are Model components.

MVC2 architecture uses a Front Controller pattern where a single servlet (the controller) receives all requests and dispatches them to appropriate handlers. This centralizes request processing.

The MVC design pattern separates application logic into Model, View, and Controller, promoting code reusability and easier support/maintenance. It is expressive as it clearly separates responsibilities, while "not easy to use" is generally a disadvantage or misconception rather than an advantage.

Cookies are small pieces of information sent by the web server to the client browser, which are then stored and sent back with subsequent requests. While browsers store and send cookies, they originate from the server.

Sensitive data should be sent using POST requests via the doPost() method because POST data is sent in the request body, not in the URL like GET requests. This prevents data from appearing in logs or browser history.

JavaMail API (Java Mail Service) is the standard Java library for sending emails from applications including Servlets. 'Mail Service' and 'Mail Protocol' are too generic, and 'Simple Mail Protocol' refers to SMTP which is used under the hood.

Servlets offer the highest performance because they are pre-compiled Java classes executing directly on the JVM. JSPs are compiled to servlets on first access (adding overhead), Perl is interpreted, and HTML is static markup.