The front controller software design pattern is listed in several pattern catalogs and is 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.
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 assign individual pages responsibility for navigation.
The front controller may be implemented as a Java object, or as a script in a scripting language such as PHP, Raku, Python or Ruby that is called for every request of a web session. This script 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 required tasks.
The alternative to a front controller is the usage of page controllers mapped to each site page or path. Although this may cause each individual controller to contain duplicate code, the page-controller approach delivers a high degree of specialization.
Several web-tier application frameworks implement the front controller pattern:
Front controllers may divided into three components:
On the view side, the helper collects data and sometimes stores data as an intermediate station. Helpers do certain preprocesses such as formatting of the data to web content or providing direct access to the raw data. Multiple helpers can collaborate with one view for most conditions. Additionally, a helper works as a transformer that adapts and converts the model into a suitable format.
The front controller implemented in Java code:[3]
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); } }
There are three primary benefits associated with the front controller pattern.[4]
The front controller pattern may incur performance issues because the single controller is performing a great deal of work, and handlers may introduce bottlenecks if they involve database or document queries. The front controller approach is also more complex than that of page controllers.
The page-controller pattern is an alternative to the front controller approach in the MVC model.
{{cite web}}