Document Information


Part I Introduction

1.  Overview

2.  Using the Tutorial Examples

Part II The Web Tier

3.  Getting Started with Web Applications

4.  Java Servlet Technology

5.  JavaServer Pages Technology

6.  JavaServer Pages Documents

7.  JavaServer Pages Standard Tag Library

8.  Custom Tags in JSP Pages

9.  Scripting in JSP Pages

10.  JavaServer Faces Technology

11.  Using JavaServer Faces Technology in JSP Pages

Setting Up a Page

Using the Core Tags

Adding UI Components to a Page Using the HTML Component Tags

UI Component Tag Attributes

The id Attribute

The immediate Attribute

The rendered Attribute

The style and styleClass Attributes

The value and binding Attributes

Adding a Form Component

Using Text Components

Rendering a Text Field with the inputText Tag

Rendering a Label with the outputLabel Tag

Rendering a Hyperlink with the outputLink Tag

Displaying a Formatted Message with the outputFormat Tag

Rendering a Password Field with the inputSecret Tag

Using Command Components for Performing Actions and Navigation

Rendering a Button with the commandButton Tag

Rendering a Hyperlink with the commandLink Tag

Using Data-Bound Table Components

Adding Graphics and Images with the graphicImage Tag

Laying Out Components with the UIPanel Component

Rendering Components for Selecting One Value

Displaying a Check Box Using the selectBooleanCheckbox Tag

Displaying a Menu Using the selectOneMenu Tag

Rendering Components for Selecting Multiple Values

The UISelectItem, UISelectItems, and UISelectItemGroup Components

Using the selectItems Tag

Using the selectItem Tag

Displaying Error Messages with the message and messages Tags

Using Localized Data

Loading a Resource Bundle

Referencing Localized Static Data

Referencing Error Messages

Using the Standard Converters

Converting a Component's Value

Using DateTimeConverter

Using NumberConverter

Registering Listeners on Components

Registering a Value-Change Listener on a Component

Registering an Action Listener on a Component

Using the Standard Validators

Validating a Component's Value

Using the LongRangeValidator

Binding Component Values and Instances to External Data Sources

Binding a Component Value to a Property

Binding a Component Value to an Implicit Object

Binding a Component Instance to a Bean Property

Binding Converters, Listeners, and Validators to Backing Bean Properties

Referencing a Backing Bean Method

Referencing a Method That Performs Navigation

Referencing a Method That Handles an Action Event

Referencing a Method That Performs Validation

Referencing a Method That Handles a Value-change Event

Using Custom Objects

Using a Custom Converter

Using a Custom Validator

Using a Custom Component

12.  Developing with JavaServer Faces Technology

13.  Creating Custom UI Components

14.  Configuring JavaServer Faces Applications

15.  Internationalizing and Localizing Web Applications

Part III Web Services

16.  Building Web Services with JAX-WS

17.  Binding between XML Schema and Java Classes

18.  Streaming API for XML

19.  SOAP with Attachments API for Java

Part IV Enterprise Beans

20.  Enterprise Beans

21.  Getting Started with Enterprise Beans

22.  Session Bean Examples

23.  A Message-Driven Bean Example

Part V Persistence

24.  Introduction to the Java Persistence API

25.  Persistence in the Web Tier

26.  Persistence in the EJB Tier

27.  The Java Persistence Query Language

Part VI Services

28.  Introduction to Security in the Java EE Platform

29.  Securing Java EE Applications

30.  Securing Web Applications

31.  The Java Message Service API

32.  Java EE Examples Using the JMS API

33.  Transactions

34.  Resource Connections

35.  Connector Architecture

Part VII Case Studies

36.  The Coffee Break Application

37.  The Duke's Bank Application

Part VIII Appendixes

A.  Java Encoding Schemes

B.  About the Authors



The Example JavaServer Faces Application

The JavaServer Faces technology chapters of this tutorial primarily use a rewritten version of the Duke’s Bookstore example to illustrate the basic concepts of JavaServer Faces technology. This version of the Duke’s Bookstore example includes several JavaServer Faces technology features:

  • The JavaServer Faces implementation provides FacesServlet, whose instances accept incoming requests and pass them to the implementation for processing. Therefore, the application does not need to include a servlet (such as the Dispatcher servlet) that processes request parameters and dispatches to application logic, as do the other versions of Duke’s Bookstore.

  • A custom image map component that allows you to select the locale for the application.

  • Navigation configured in a centralized application configuration resource file. This eliminates the need to calculate URLs, as other versions of the Duke’s Bookstore application must do.

  • Backing beans associated with the pages. These beans hold the component data and perform other processing associated with the components. This processing includes handling the event generated when a user clicks a button or a hyperlink.

  • The table that displays the books from the database and the shopping cart are rendered with the dataTable tag, which is used to dynamically render data in a table. The dataTable tag on tut-install/javaeetutorial5/examples/web/bookstore6/web/bookshowcart.jsp also includes input components.

  • The table that displays the books from the database uses a c:forEach JSTL tag, demonstrating that you can easily use JavaServer Faces component tags with JSTL tags.

  • A custom validator and a custom converter are registered on the credit card field of the bookcashier.jsp page.

  • A value-change listener is registered on the Name field of bookcashier.jsp. This listener saves the name in a parameter so that tut-install/javaeetutorial5/examples/web/bookstore6/web/bookreceipt.jsp can access it.

This version of Duke’s Bookstore includes the same pages listed in Table 5-1. It also includes the tut-install/javaeetutorial5/examples/web/bookstore6/web/chooselocale.jsp page, which displays the custom image map that allows you to select the locale of the application. This page is displayed first and advances directly to the bookstore.jsp page after the locale is selected.

The packages of the Duke’s Bookstore application are:

  • backing: Includes the backing bean classes

  • components: Includes the custom UI component classes

  • converters: Includes the custom converter class

  • listeners: Includes the event handler and event listener classes

  • model: Includes a model bean class

  • renderers: Includes the custom renderers

  • resources: Includes custom error messages for the custom converter and validator

  • taglib: Includes custom tag handler classes

  • util: Includes a message factory class

  • validators: Includes a custom validator class

Chapter 12, Developing with JavaServer Faces Technology describes how to program backing beans, custom converters and validators, and event listeners. Chapter 13, Creating Custom UI Components describes how to program event handlers, custom components, renderers, and tag handlers.

The source code for the application is located in the tut-install/javaeetutorial5/examples/web/bookstore6/ directory.

To deploy and run the application using NetBeans IDE, follow these steps:

  1. Perform all the operations described in Accessing Databases from Web Applications.

  2. In NetBeans 5.5, select File→Open Project.

  3. In the Open Project dialog, navigate to:

  4. Select the bookstore6 folder.

  5. Select the Open as Main Project check box and the Open Required Projects check box.

  6. Click Open Project.

  7. In the Projects tab, right-click the bookstore6 project, and select Undeploy and Deploy.

  8. To run the application, open the bookstore URL http://localhost:8080/bookstore6.

To deploy and run the application using Ant, follow these steps:

  1. In a terminal window, go to tut-install/javaeetutorial5/examples/web/bookstore6/.

  2. Type ant. This target will spawn any necessary compilations, copy files to the tut-install/javaeetutorial5/examples/web/bookstore6/build/ directory, and create a WAR file and copy it to the tut-install/javaeetutorial5/examples/web/bookstore6/dist/ directory.

  3. Start the Application Server.

  4. Perform all the operations described in Creating a Data Source in the Application Server.

  5. To deploy the example, type ant deploy. The deploy target outputs a URL for running the application. Ignore this URL, and instead use the one shown in the next step.

  6. To run the application, open the bookstore URL http://localhost:8080/bookstore6/.

To learn how to configure the example, refer to the web.xml file, which includes the following elements:

  • A display-name element that specifies the name that tools use to identify the application.

  • A context-param element that specifies that the javax.faces.STATE_SAVING_METHOD parameter has a value of client, meaning that state is saved on the client.

  • A listener element that identifies the ContextListener class used to create and remove the database access.

  • A servlet element that identifies the FacesServlet instance.

  • A servlet-mapping element that maps FacesServlet to a URL pattern.

  • Nested inside a jsp-config element is a jsp-property-group element, which sets the properties for the group of pages included in this version of Duke’s Bookstore. See Setting Properties for Groups of JSP Pages for more information.

To run the example, open the URL http://localhost:8080/bookstore6 in a browser.