Front controller

The front controller software design pattern is listed in several pattern catalogs and related to the design of web applications. It is "a controller that handles all requests for a website",^[1] which is a useful structure for web application developers to achieve flexibility and reuse without code redundancy.

Instruction[]

A typical front controller structure.

Front controllers are often used in web applications to implement workflows. While not strictly required, it is much easier to control navigation across a set of related pages (for instance, multiple pages used in an online purchase) from a front controller than it is to make the individual pages responsible for navigation.

The front controller may be implemented as a Java object, or as a script in a script language like PHP, Raku, Python or Ruby that is called on every request of a web session. This script, for example an index.php, would handle all tasks that are common to the application or the framework, such as session handling, caching, and input filtering. Based on the specific request, it would then instantiate further objects and call methods to handle the particular task(s) required.

The alternative to a front controller would be individual scripts like login.php and order.php that would each then satisfy the type of request. Each script would have to duplicate code or objects that are common to all tasks. However, each script might also have more flexibility to implement the particular task required.

Examples[]

Several web-tier application frameworks implement the front controller pattern, among them:

• Apache Struts
• ASP.NET MVC
• Cairngorm framework in Adobe Flex
• Cro [1] or Bailador [2] frameworks in Raku
• Drupal
• MVC frameworks written in PHP. For example, Yii, CakePHP, Laravel, Symfony, CodeIgniter and Laminas
• Spring Framework^[2]
• Yesod (web framework) written in Haskell

Implementation[]

To better understand front controller pattern, there is an example to implement front controller in Java.^[3] It can be defined in 3 components:

1. XML Mapping: files that map requests to the class that will handle the request processing.
2. Request Processor: used for dealing with the request processing (and modifying or retrieving the appropriate model).
3. Flow Manager: first get the request and the output of the processing, then determine what will show on the next page.

Participants and responsibilities[]

Demo implementation in Java[]

Here is part of a demo code to implement front controller.^[4]

private void doProcess(HttpServletRequest request,
                       HttpServletResponse response)
    throws IOException, ServletException {
    ...
    try {
        getRequestProcessor().processRequest(request);
        getScreenFlowManager().forwardToNextScreen(request, response);
    } catch (Throwable ex) {
        String className = ex.getClass().getName();
        nextScreen = getScreenFlowManager().getExceptionScreen(ex);
        // Put the exception in the request
        request.setAttribute("javax.servlet.jsp.jspException", ex);
        if (nextScreen == null) {
            // Send to general error screen
            ex.printStackTrace();
            throw new ServletException("MainServlet: unknown exception: " +
                className);
        }
    }

Benefits and liabilities[]

There are three benefits for using front controller pattern.^[5]

• Centralized control. Front controller handles all the requests to the web application. This implementation of centralized control that avoids using multiple controllers is desirable for enforcing application-wide policies such as users tracking and security.
• Thread-safety. A new command object arises when receiving a new request and the command objects are not meant to be thread safe. Thus, it will be safe in the command classes. Though safety is not guaranteed when threading issues are gathered, codes that act with command is still thread safe.
• Configurability. Since only one front controller is needed in web application, the configuration of web applications implementation is largely simplified. The handler accomplishes the rest of dispatching so that it is not required to change anything before adding new commands with dynamic ones.

In terms of liability, front controllers that determine the following activities by searching the database or XML documents, performance might be decreased. And implementation of front controller to existed systems always involving replacing the current ones, which makes it harder for beginners to start with.

Relationship with MVC pattern[]

1. In order to improve system reliability and maintainability, duplicated codes should be avoided and centralized when they are of the same common logic through the whole system.
2. The data for the application is better to be handled in one location, thus there will be no need to duplicate database retrieval code.
3. Different roles in the MVC pattern should be separated to increase testability, which is also true for controller part in the MVC pattern.

Comparison[]

Page controller is an alternative to front controller in MVC model.

See also[]

• Design pattern (computer science).
• Mediator pattern (note: the front controller pattern is a specialized kind of mediator pattern)

References[]

Notes[]

• Alur, Deepak; John Crup; Dan Malks (2003). Core J2EE Patterns, Best Practices and Design Strategies, 2nd Ed. Sun Microsystems Press. pp. 650pp. ISBN 0-13-142246-4.
• Fowler, Martin (2003). Patterns of Enterprise Application Architecture. pp. 560pp. ISBN 978-0-321-12742-6.

External links[]

• Bear Bibeault's Front Man™, a lightweight Java implementation.