Home > Articles > Programming > Java

Recommended JSF Enhancements

  • Print
  • + Share This
This chapter explores how additional frameworks improve your JSF development experience. It also discusses how to develop applications with Facelets and Seam UI libraries.
This chapter is from the book

The Hello World example in Chapter 2 demonstrates how to build a Seam application with standard EJB3 and JSF. Seam chooses JSF as its web framework for many reasons. JSF is a standard technology in Java EE 5.0 and has a large ecosystem of users and vendors. All Java application servers support it. JSF is fully component-based and has a vibrant vendor community for components. JSF also has a powerful and unified expression language (EL, using the #{...} notation) that can be used in web pages, workflow descriptions, and component configuration files throughout the application. JSF also enjoys great support by visual GUI tools in leading Java IDEs.

However, JSF also has its share of problems and awkwardness. JSF has been criticized for being too verbose and too component-centric (i.e., not transparent to HTTP requests). Being a standard framework, JSF innovates more slowly than grassroots open source projects such as Seam itself and is therefore less agile when it comes to correcting design issues and adding new features. For these reasons, Seam works with other open source projects to improve and enhance JSF. For Seam applications, we strongly recommend that you use the following JSF enhancements:

  • Use the Facelets framework for web pages. Write your web pages as Facelets XHTML files instead of JSP files. Facelets provides many benefits over the standard JSP in JSF; see Section 3.1.1 for more details.
  • Use the Seam JSF component library for special JSF tags that take advantage of Seam-specific UI features, as well as Seam's extended EL for JSF.
  • Set up Seam filters to capture and manage JSF redirects, error messages, debugging information, and so on.

Throughout the rest of the book, we assume that you already have these three JSF enhancements installed and enabled (see Section 3.3 for instructions). In Section 8.1.1, we explain how Seam supports lazy loading in JSF page rendering and expands the use of JSF messages beyond simple error messages. In Part III, we will cover integration of data components directly into the JSF web pages. Such direct integration allows Seam to add important features to JSF, including end-to-end validators (Chapter 12), easy-to-use data tables (Chapter 13), bookmarkable URLs (Chapter 15), and custom error pages (Chapter 17). In Part IV, we will discuss how to incorporate third-party AJAX UI widgets in Seam applications. In Section 24.5, we discuss how to use the jBPM business process to manage pageflows in JSF/Seam applications. This allows you to use EL expressions in page navigation rules and to have navigation rules that are dependent on the application state.

In this chapter, we will first explore how those additional frameworks improve your JSF development experience. You will see how to develop applications with Facelets and Seam UI libraries. Then, in Section 3.3, we will list the changes you need to make in the Hello World example to support the Facelets and Seam UI components. The new example is in the betterjsf project in the book's source code bundle. Feel free to use it as a starting point for your own applications.

3.1 An Introduction to Facelets

JavaServer Pages (JSP) is the de-facto "view" technology in JavaServer Faces (JSF). In a standard JSF application, the web pages containing JSF tags and visual components are typically authored as JSP files. However, JSP is not the only choice for authoring JSF web pages. An open source project called Facelets (https://facelets.dev.java.net) allows you to write JSF web pages as XHTML files with significantly improved page readability, developer productivity, and runtime performance compared to equivalent pages authored in JSP. Although Facelets is not yet a Java Community Process (JCP) standard, we highly recommend that you use it in your Seam applications whenever possible.

3.1.1 Why Facelets?

First, Facelets improves JSF performance by 30 to 50 percent by bypassing the JSP engine and using XHTML pages directly as the view technology. By avoiding JSP, Facelets also avoids potential conflicts between JSF 1.1 and JSP 2.4 specifications, which are the specifications supported in JBoss AS 4.x (see the accompanying sidebar for details).

Second, you can use any XHTML tags in Facelets pages. It eliminates the need to enclose XHTML tags and free text in the <f:verbatim> tags. These <f:verbatim> tags make JSP-based JSF pages tedious to write and hard to read.

Third, Facelets provides debugging support from the browser. If an error occurs when Facelets renders a page, it gives you the exact location of that error in the source file and provides context information around the error (see Section 17.5). It is much nicer than digging into a stack trace when a JSP/JSF error occurs.

Last, and perhaps most important, Facelets provides a template framework for JSF. With Facelets, you can use a Seam-like dependency injection model to assemble pages instead of manually including page header, footer, and sidebar components in each page.

3.1.2 A Facelets Hello World

As we discussed, a basic Facelets XHTML page is not all that different from the equivalent JSP page. To illustrate this point, we ported the Hello World sample application (see Chapter 2) from JSP to Facelets. The new application is in the betterjsf project. Below is the JSP version of the hello.jsp page:

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

<html>
<body>
<f:view>

<f:verbatim>
<h2>Seam Hello World</h2>
</f:verbatim>

<h:form>
<f:verbatim>
Please enter your name:<br/>
</f:verbatim>

<h:inputText value="#{person.name}" size="15"/><br/>
<h:commandButton type="submit" value="Say Hello"
                 action="#{manager.sayHello}"/>
</h:form>

</f:view>
</body>
</html>

Compare that with the Facelets XHTML version of the hello.xhtml page:

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core">
<body>

<h2>Seam Hello World</h2>

<h:form>
Please enter your name:<br/>
<h:inputText value="#{person.name}" size="15"/>
<br/>
<h:commandButton type="submit" value="Say Hello"
                 action="#{manager.sayHello}"/>
</h:form>

</body>
</html>

It is pretty obvious that the Facelets XHTML page is cleaner and easier to read than the JSP page since the XHTML page is not cluttered up with <f:verbatim> tags. The namespace declarations in the Facelets XHTML page conform to the XHTML standard. Other than that, however, the two pages look similar. All the JSF component tags are identical.

3.1.3 Use Facelets as a Template Engine

For most developers, the ability to use XHTML templates is probably the most appealing feature of Facelets. Let's see how it works.

A typical web application consists of multiple web pages with a common layout. They usually have the same header, footer, and sidebar menu. Without a template engine, you must repeat all those elements for each page. That's a lot of duplicated code with complex HTML formatting tags. Worse, if you need to make a small change to any of the elements (e.g., change a word in the header), you have to edit all pages. From all we know about the software development process, this type of copy-and-paste editing is very inefficient and error-prone.

The solution, of course, is to abstract out the layout information into a single source and thus avoid the duplication of the same information on multiple pages. In Facelets, the template page is the single source of layout information. The template.xhtml file in the Seam Hotel Booking example (the booking project in source code) is a template page.

<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:h="http://java.sun.com/jsf/html">
<head>
  <title>JBoss Suites: Seam Framework</title>
  <link href="css/screen.css" rel="stylesheet" type="text/css" />
</head>
<body>

<div id="document">
  <div id="header">
    <div id="title">...</div>
    <div id="status">
      ... Settings and Log in/out ...
    </div>
  </div>
  <div id="container">
    <div id="sidebar">
      <ui:insert name="sidebar"/>
    </div>
    <div id="content">
      <ui:insert name="content"/>
    </div>
  </div>
  <div id="footer">...</div>
</div>
</body>
</html>

The template.xhtml file defines the layout of the page header, footer, sidebar, and main content area (Figure 3.1). Obviously, the sidebar and main content area have different content for each page, so we use the <ui:insert> tags as placeholders in the template. In each Facelets page, we tag UI elements accordingly to tell the engine how to fill the template placeholders with content.

Figure 3.1

Figure 3.1 The template layout

Each Facelets page corresponds to a web page. It "injects" contents for the <ui:insert> placeholders into the template. Below is the main.xhtml page of the Seam Hotel Booking example application.

<ui:composition xmlns="http://www.w3.org/1999/xhtml"
                xmlns:ui="http://java.sun.com/jsf/facelets"
                xmlns:h="http://java.sun.com/jsf/html"
                xmlns:f="http://java.sun.com/jsf/core"
                template="template.xhtml">

  <ui:define name="content">
    <ui:include src="conversations.xhtml" />

    <div class="section">
      <h:form>
        <h1>Search Hotels</h1>
        ... ...
      </h:form>
    </div>

    <div class="section">
      <h:dataTable value="#{hotels}" ...>
        ... ...
      </h:dataTable>
    </div>

    <div class="section">
      <h1>Current Hotel Bookings</h1>
    </div>

    <div class="section">
      <h:dataTable value="#{bookings}" ...>
        ... ...
      </h:dataTable>
    </div>
  </ui:define>

  <ui:define name="sidebar">
    <h1>Stateful and contextual components</h1>
    <p>... ...</p>
  </ui:define>
</ui:composition>

At the beginning of the main.xhtml file, the code declares that the template.xhtml template is used to format the layout. The <ui:define> elements correspond to the <ui:insert> placeholders of the same names in the template. You can arrange those <ui:define> elements in any order, and at runtime, the Facelets engine renders the web pages according to the template.

3.1.4 Data List Component

One of the biggest omissions in the current JSF specification is that it lacks a standard component to iterate over a data list. The <h:dataTable> component displays a data list as an HTML table, but it is not a generic iteration component.

Facelets remedies this problem by providing a <ui:repeat> component to iterate over any data list. For instance, the following Facelets page snippet displays a list in a table-less format:

<ui:repeat value="#{fans} var="fan">
  <div class="faninfo">#{fan.name}</div>
</ui:repeat>

In Section 3.4.1 and Section 3.4.2, you will see that the Facelets <ui:repeat> component can be used in completely non-HTML environments.

In this section, we just scratched the surface of what Facelets can do. We encourage you to explore Facelets (https://facelets.dev.java.net/) and make the most out of this excellent framework.

  • + Share This
  • 🔖 Save To Your Account