JSF is a specification to build a web user interface from a component model. It encompasses a MVC and templating framework. JSF is a standard library of the Java EE platform. The Java Community Process (JCP) controls the specifications, and the current version is JSF 2.2, which is defined by Java Specification Request (JSR) 334 (https://www.jcp.org/en/jsr/detail?id=344).

Originally, the promise behind JSF was to bring rapid user interface development to server-side Java. This statement was true when JSF was first conceived; but of course, it is still useful if you would rather not write a lot of JavaScript code and hand crafted boilerplate so as to handle the transformation of an HTTP request to the Java invocations and back-to-page responses. Web technology and, in particular, digital development has leaped off the web pages since JSF 1.0 was conceived in 2004. Back then, JavaScript was not taken as a programming language so seriously as it is now; there was no responsive...

The MVC design describes a set of design patterns that aim to separate the concerns of a user interface from the application logic that semantically binds them. The Model describes the business logic. The View denotes the presentation—the abstract surface that the user senses and also interacts with. The Controller denotes the component that handles the interaction between the model and view. The original idea of MVC stemmed from Trygve Reenskaug, who introduced the concept in the Smalltalk programming language during the 1970s. The pattern was subsequently implemented and popularized in the Smalltalk-80 before it was adopted in the wider software engineering community. MVC is famous for its ideas about the division of labor and the separation of responsibilities between the components.

We call it MVC patterns because the plural term describes a set of related derivatives of the classic pattern as group patterns.

The MVC pattern has subsequently evolved, giving rise...

The JSF specification defines a View Declaration Language (VDL) to render the output of the pages. In JSF 1.0, this was JavaServer Pages; but in JSF 2.0, the VDL was changed to Facelets by default. Facelets are the default view handler for JSF 2.0 and are defined as XHTML files.

Facelets can be used in a templating situation. A Facelets file can reference a master template as a composition, and the view can provide the content that will look like a cookie cutter being supplied to the template. A Facelet that utilizes a reference template is known as a template client. The placeholder content in the template client will override the default content in the master template. In this way, Facelets can be reused in order to share the content. The template clients may become master templates and thus, a hierarchy of views can be derived.

Facelets also provide reuse by the custom tags. It is possible for engineers to write their own custom tags through the XHTML files and metadata. The designer...

JSF has a request-response processing lifecycle that is built around the HTTP protocol. JSF is built on top of the Java Servlet specification that takes care of translating the request user agent, which in the majority of the cases, is a web browser to a known endpoint. For JSF, the first port of call is javax.faces.webapp.FacesServlet. This servlet will simply dispatch the incoming request to the controller, and this component can elect to generate a response or delegate the output to the internal JSF controller implementation.

There are three circumstances for JSF in the request processing lifecycle. The first is the invocation to the JSF controller with a Faces request, which ultimately generates a Faces response.

The second is a request to retrieve a resource such as a CSS or JavaScript file or image or some other media file. However, a Faces resource request, which does not require the execution of logic, causes the JSF framework to furnish the output...

We have covered just enough theory on the JSF framework. I think it is time for my readers to see some code. The first code is the XHTML file to display a basic web page on a site. The source code is available on the book's website in the author's public GitHub account at http://github.com/peter_pilgrim/digital_javaee7.

Here is the XHTML source code for the initial Facelets view, and the file is called index.xhtml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://xmlns.jcp.org/jsf/html"
      xmlns:ui="http://xmlns.jcp.org/jsf/facelets"
      xmlns:f="http://xmlns.jcp.org/jsf/core">

  <h:head>
    <title>Digital Java EE 7 - Sample JSF</title>
  </h:head>
  <h:body>
    This is the simplest JSF example possible.

    <h:form>
      <h:commandButton...