A Guide to the Front Controller Pattern in Java

1. Overview

In this tutorial we’ll be digging deeper into the Front Controller Pattern, part of the Enterprise Patterns as defined in Martin Fowler‘s book “Patterns of Enterprise Application Architecture”.

Front Controller is defined as “a controller that handles all requests for a Web site”. It stands in front of a web-application and delegates requests to subsequent resources. It also provides an interface to common behavior such as security, internationalization and presenting particular views to certain users.

This enables an application to change its behavior at runtime. Furthermore it helps to read and maintain an application by preventing code duplication.

The Front Controller consolidates all request handling by channeling requests through a single handler object.

2. How Does It Work?

The Front Controller Pattern is mainly divided into two parts. A single dispatching controller and a hierarchy of commands. The following UML depicts class relations of a generic Front Controller implementation:

This single controller dispatches requests to commands in order to trigger behavior associated with a request.

To demonstrate its implementation, we’ll implement the controller in a FrontControllerServlet and commands as classes inherited from an abstract FrontCommand.

3. Setup

3.1. Maven Dependencies

First, we’ll setup a new Maven WAR project with javax.servlet-api included:

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.0-b01</version>
    <scope>provided</scope>
</dependency>

as well as jetty-maven-plugin:

<plugin>
    <groupId>org.eclipse.jetty</groupId>
    <artifactId>jetty-maven-plugin</artifactId>
    <version>9.4.0.M1</version>
    <configuration>
        <webApp>
            <contextPath>/front-controller</contextPath>
        </webApp>
    </configuration>
</plugin>

3.2. Model

Next, we’ll define a Model class and a model Repository. We’ll use the following Book class as our model:

public class Book {
    private String author;
    private String title;
    private Double price;

    // standard constructors, getters and setters
}

This will be the repository, you can lookup the source code for concrete implementation or provide one on your own:

public interface Bookshelf {
    default void init() {
        add(new Book("Wilson, Robert Anton & Shea, Robert", 
          "Illuminati", 9.99));
        add(new Book("Fowler, Martin", 
          "Patterns of Enterprise Application Architecture", 27.88));
    }

    Bookshelf getInstance();

    <E extends Book> boolean add(E book);

    Book findByTitle(String title);
}

3.3. FrontControllerServlet

The implementation of the Servlet itself is fairly simple. We’re extracting the command name from a request, creating dynamically a new instance of a command class and executing it.

This allows us to add new commands without changing a code base of our Front Controller.

Another option is to implement the Servlet using static, conditional logic. This has the advantage of compile-time error checking:

public class FrontControllerServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, 
      HttpServletResponse response) {
        FrontCommand command = getCommand(request);
        command.init(getServletContext(), request, response);
        command.process();
    }

    private FrontCommand getCommand(HttpServletRequest request) {
        try {
            Class type = Class.forName(String.format(
              "com.baeldung.enterprise.patterns.front." 
              + "controller.commands.%sCommand",
              request.getParameter("command")));
            return (FrontCommand) type
              .asSubclass(FrontCommand.class)
              .newInstance();
        } catch (Exception e) {
            return new UnknownCommand();
        }
    }
}

3.4. FrontCommand

Let’s implement an abstract class called FrontCommand, which is holding the behavior common to all commands.

This class has access to the ServletContext and its request and response objects. Furthermore, it’ll handle view resolution:

public abstract class FrontCommand {
    protected ServletContext context;
    protected HttpServletRequest request;
    protected HttpServletResponse response;

    public void init(
      ServletContext servletContext,
      HttpServletRequest servletRequest,
      HttpServletResponse servletResponse) {
        this.context = servletContext;
        this.request = servletRequest;
        this.response = servletResponse;
    }

    public abstract void process() throws ServletException, IOException;

    protected void forward(String target) throws ServletException, IOException {
        target = String.format("/WEB-INF/jsp/%s.jsp", target);
        RequestDispatcher dispatcher = context.getRequestDispatcher(target);
        dispatcher.forward(request, response);
    }
}

A concrete implementation of this abstract FrontCommand would be a SearchCommand. This will include conditional logic for cases where a book was found or when book is missing:

public class SearchCommand extends FrontCommand {
    @Override
    public void process() throws ServletException, IOException {
        Book book = new BookshelfImpl().getInstance()
          .findByTitle(request.getParameter("title"));
        if (book != null) {
            request.setAttribute("book", book);
            forward("book-found");
        } else {
            forward("book-notfound");
        }
    }
}

If the application is running, we can reach this command by pointing our browser to http://localhost:8080/front-controller/?command=Search&title=patterns.

The SearchCommand resolves to two views, the second view can be tested with the following request http://localhost:8080/front-controller/?command=Search&title=any-title.

To round up our scenario we’ll implement a second command, which is fired as fallback in all cases, a command request is unknown to the Servlet:

public class UnknownCommand extends FrontCommand {
    @Override
    public void process() throws ServletException, IOException {
        forward("unknown");
    }
}

This view will be reachable at http://localhost:8080/front-controller/?command=Order&title=any-title or by completely leaving out the URL parameters.

4. Deployment

Because we decided to create a WAR file project, we’ll need a web deployment descriptor. With this web.xml we’re able to run our web-application in any Servlet container:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
  http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
  version="3.1">
    <servlet>
        <servlet-name>front-controller</servlet-name>
        <servlet-class>
            com.baeldung.enterprise.patterns.front.controller.FrontControllerServlet
        </servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>front-controller</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

As the last step we’ll run ‘mvn install jetty:run’ and inspect our views in a browser.

5. Conclusion

As we’ve seen so far, we now should be familiar with the Front Controller Pattern and its implementation as Servlet and command hierarchy.

As usual, you’ll find the sources on GitHub.

Persistence

REST

Security