Front Controller

Avijeet Dash and Satyabrata

Dash

This Front Controller in a generic way delegates the functionalities like

validation of user data, calling of business services to a command or a helper

component.

The presentation-tier request handling mechanism must control and coordinate

processing of each user across multiple requests. Such control mechanisms may be

managed in either a centralized or decentralized manner.

If managed in a decentralized manner, it will lead to code duplication for

the common set of functionalities like content retrieval, view management, and

navigation.

Typically we write specific servlets for specific request handling. These

servlets do validation of the data entered, and error handling if data entered

is in valid, and if everything is fine they create some sort of data object

containing the data entered by the user and invoke the business service method

to do the necessary action and then forward the request to specific view to

display the results to the user.

Front Controller suggests a different approach, where we have only one

servlet centralizing the handling of all requests. We can have multiple Front

Controllers in a system, each mapping to a set of distinct services.

This Front Controller in a generic way delegates the functionalities like

validation of user data, calling of business services to a command or a helper

component. It delegates the functionality of choosing the next view to a

Dispatch component either contained in the Front Controller as a method or used

as a different component.

The controller manages the handling of the request including invoking

security services such as authentication and authorization, delegation business

processing, managing appropriate view, handling errors and managing the

selection of the content creation strategy.

Sequence diagram of Front

Controller

Controller

The FrontController is the initial contact point for handling all requests in

the system. The FrontController typically interacts with the Dispatcher. The

Front Controller may delegate to a Helper to complete authentication and

authorization of a user, or to initiate content retrieval.

Dispatcher

A Dispatcher is responsible for view management and navigation, managing the

choice of the next View to present to the user and providing the mechanism for

vectoring control to this resource.

A Dispatcher can be encapsulated within a Controller or can be a separate

component working in coordination. The Dispatcher can provide static dispatching

to the View or may provide a more sophisticated dynamic dispatching mechanism.

The Dispatcher will use the RequestDispatcher object (supported in the

Servlet specification) and will encapsulate some additional processing.

Helper

A Helper is responsible for helping a View or Controller complete its

processing. Thus, Helpers have numerous responsibilities, including gathering

data required by the View and adapting this data model

for use by the View. Helpers can service requests for data from the View by

simply providing access to the raw data or by formatting the data as web

content.

A View may work with any number of Helpers, which are typically implemented

as JavaBeans^TM (JSP^TM 1.0) and Custom Tags (JSP 1.1+).

Additionally, a Helper may represent a Command object, a Delegate (see Business

Delegate pattern), or an XSL Transformer, which is used in combination with a

stylesheet to adapt and convert the model into the appropriate form.

View

A View represents and displays information to the client. The information

that is used in a display is retrieved from a model. Helpers support Views by

encapsulating and adapting a model for use in a display

Example Servlet Front Strategy Sample Code

public class EmployeeController extends HttpServlet {
  // Initializes the servlet.
  public void init(ServletConfig config) throws
    ServletException {
    super.init(config);
  }

  // Destroys the servlet.
  public void destroy() {
  }

  /** Processes requests for both HTTP
   * GET and POST methods.
   * @param request servlet request
   * @param response servlet response
   */
  protected void processRequest(HttpServletRequest
    request, HttpServletResponse response)
    throws ServletException, java.io.IOException {
    String page;

    /**ApplicationResources provides a simple API
     * for retrieving constants and other
     * preconfigured values**/
    ApplicationResources resource =
      ApplicationResources.getInstance();
    try {

      // Use a helper object to gather parameter
      // specific information.
      RequestHelper helper = new
         RequestHelper(request);

      Command cmdHelper= helper.getCommand();

      // Command helper perform custom operation
      page = cmdHelper.execute(request, response);

    }
    catch (Exception e) {
      LogManager.logMessage(
        "EmployeeController:exception : " +
        e.getMessage());
      request.setAttribute(resource.getMessageAttr(),
        "Exception occurred : " + e.getMessage());
      page = resource.getErrorPage(e);
    }
    // dispatch control to view
    dispatch(request, response, page);
  }

  /** Handles the HTTP GET method.
   * @param request servlet request
   * @param response servlet response
   */
  protected void doGet(HttpServletRequest request,
    HttpServletResponse response)
    throws ServletException, java.io.IOException {
      processRequest(request, response);
  }

  /** Handles the HTTP POST method.
   * @param request servlet request
   * @param response servlet response
   */
  protected void doPost(HttpServletRequest request,
    HttpServletResponse response)
    throws ServletException, java.io.IOException {
        processRequest(request, response);
  }

  /** Returns a short description of the servlet */
  public String getServletInfo() {
    return "Front Controller Pattern" +
      " Servlet Front Strategy Example";
  }

  protected void dispatch(HttpServletRequest request,
    HttpServletResponse response,
    String page)
  throws  javax.servlet.ServletException,
    java.io.IOException {
    RequestDispatcher dispatcher =
      getServletContext().getRequestDispatcher(page);
    dispatcher.forward(request, response);
  }
}

Command and Controller Strategy - Struts

Based on the Command pattern , the Command and Controller

Strategy suggests providing a generic interface to the helper components to

which the controller may delegate responsibility, minimizing the coupling among

these components (See the ViewHelper pattern for more information on

Helper components). Adding to or changing the work that needs to be completed by

these helpers does not require any changes to the interface between the

controller and the helpers, but rather to the type and/or content of the

commands. This provides a flexible and easily extensible mechanism for

developers to add request handling behaviors.

Finally, because the command processing is not coupled to the command

invocation, the command processing mechanism may be reused with various types of

clients, not just web browsers. This strategy also facilitates the creation of

composite commands (see Composite Pattern ).

Struts is a

good example of Command and Controller strategy

 Struts includes the following primary areas of functionality:

• A controller servlet that dispatches requests to appropriate Action
  
  classes provided by the application developer.
• JSP custom tag libraries, and associated support in the controller
  
  servlet, that assists developers in creating interactive form-based
  
  applications.
• Utility classes to support XML parsing, automatic population of
  
  JavaBeans properties based on the Java reflection APIs, and
  
  internationalization of prompts and messages.

Front Controller centralizes control providing a central place to handle

system services and business logic across multiple requests. The Front

Controller pattern in conjunction with the View Helper pattern, describes

factoring business logic out of the view and providing a central point of

control and dispatch. Flow logic is factored forward into the controller and

data handling code moves back into helpers.

 

Reference:

Core J2EE Patterns, Deepak Alur, John Crupi, Dan Malks

http://developer.java.sun.com/developer/technicalArticles/J2EE/patterns/