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.

JSF 2.0

Many of the third-party JSF enhancements discussed in this chapter have made their way into the upcoming JSF 2.0 specification, so this chapter will help you with JSF 2.0 migration. Using Seam and the frameworks mentioned here, you can experience the JSF 2.0 productivity today!

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).

The Potential Conflict between JSF and JSP

In our Hello World example, we used JSP files (e.g., the hello.jsp file) to create the web pages in the JSF application. The JSP container processes those files at the same time they are processed by the JSF engine. That raises some potential conflicts between the JSP 2.0 container and JSF 1.1 runtime in JBoss AS 4.x. For a detailed explanation of the problems and examples, refer to Hans Bergsten's excellent article "Improving JSF by Dumping JSP" (www.onjava.com/pub/a/onjava/2004/06/09/jsf.html).

Those conflicts are resolved in JBoss AS 5.x, which supports JSP 2.1+ and JSF 1.2+. However, if you need to use JBoss 4.x for now, the best solution is to avoid JSP altogether and use Facelets instead.

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.

The Case for JSP

If Facelets is this good, why do we bother to use JSP with JSF at all? Well, JSP is a standard technology in the Java EE stack, whereas Facelets is not yet a standard. That means JSP is supported everywhere, while Facelets might have integration issues with third-party JSF components. In the meantime, the JSP spec committee is certainly learning its lessons from Facelets. The next-generation JSPs will work a lot better with JSF.

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:

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.

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.

Actually, we were not entirely accurate when we mentioned that the template is a "single" source for layout knowledge in an application. Facelets is flexible in managing template pages. In a Facelets application, you can have multiple template pages for alternative themes or for different sections of the web site. Yet, the basic idea of abstracting layout information to avoid duplicated code still applies.

Extensive Use of CSS

All pages in the Seam Hotel Booking example, including the template.xhtml page, are styled using CSS. We highly recommend using CSS in Seam/Facelet applications because it's concise and easy to understand. Even more importantly, CSS separates the styling from page content. With CSS, the web designer does not even need to understand the JSF/Seam symbols and tags in the page.

Of course, if you prefer to use XHTML tables to lay out your page, you can still do so in the template.xhtml file. Just make sure that you place the <ui:insert> tags in the right places within the nested tables.

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.

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: