Core JavaServer™ Faces

Core JavaServer™ Faces

Chapter 1 - Getting Started
   - Why JavaServer Faces
   - Software Installation
   - A Simple Example
   - Sample Application Analysis
   - Visual Development Environments
   - JSF Framework Services
   - Behind the Scenes
   - Automation of the Build Process with Ant

Chapter 2 - Managed Beans
   - Definition of a Bean
   - Message Bundles
   - A Sample Application
   - Backing Beans
   - Bean Scopes
   - Configuring Beans
   - The Syntax of Value Binding Expressions

Chapter 3 - Navigation
   - Static Navigation
   - Dynamic Navigation
   - Advanced Navigation Issues

Chapter 4 - Standard JSF Tags
   - An Overview of the JSF Core Tags
   - An Overview of the JSF HTML Tags
   - Forms
   - Text Fields and Text Areas
   - Buttons and Links
   - Selection Tags
   - Messages
   - Panels

Chapter 5 - Data Tables
   - The Data Table Tag
   - A Simple Table
   - h:dataTable Attributes
   - Headers and Footers
   - JSF Components in Table Cells
   - Editing Table Cells
   - Styles for Rows and Columns
   - Database Tables
   - Table Models
   - Scrolling Techniques

Chapter 6 - Conversion and Validation
   - Overview of the Conversion and Validation Process
   - Using Standard Converters
   - Using Standard Validators
   - Programming with Custom Converters and Validators
   - Implementing Custom Tags

Chapter 7 - Event Handling
   - Life-Cycle Events
   - Value Change Events
   - Action Events
   - Event Listener Tags
   - Immediate Components
   - Phase Events
   - Putting It All Together

Chapter 8 - Subviews and Tiles
   - Common Layouts
   - A Book Viewer and a Library
   - The Book Viewer
   - Content Inclusion in the Book Viewer
   - The Library

Chapter 9 - Custom Components
   - Implementing Custom Components with Classes
   - Encoding: Generating Markup
   - Decoding: Processing Request Values
   - Implementing Custom Component Tags
   - Revisiting the Spinner
   - Encoding JavaScript to Avoid Server Roundtrips
   - Using Child Components and Facets

Chapter 10 - External Services
   - Accessing a Database
   - Using LDAP for Authentication
   - Managing Configuration Information
   - Using Web Services

Chapter 11 - Wireless Clients
   - Rendering Technologies for Mobile Clients
   - MIDP Basics
   - Mobile Communication and Control Flow
   - Component Implementation for Mobile Clients
   - The Battleship Game

Chapter 12 - How Do I…
   - Web User Interface Design
   - Validation
   - Programming
   - Debugging and Logging

The first half of the book, extending to the middle of Chapter 6, focuses on the JSF tags. These tags are similar to HTML form tags. They are the basic building blocks for JSF user interfaces. No programming is required for use of to use the tags. We only assume only basic HTML skills for web pages and standard Java programming for the business logic.

The first part of the book covers these topics:

• Setting up your programming environment (Chapter 1)
• Connecting JSF tags to application logic (Chapter 2)
• Navigating between pages (Chapter 3)
• Using the standard JSF tags (Chapters 4 and 5)
• Converting and validating input (Chapter 6)

Starting with the final sections of Chapter 6, we begin JSF programming in earnest. You will learn how to perform advanced tasks, and how to extend the JSF framework. Here are the main topics of the second part:

• Implementing custom converters and validators (Chapter 6)
• Event handling (Chapter 7)
• Including common content among multiple pages (Chapter 8)
• Implementing custom components (Chapter 9)
• Connecting to databases and other external services (Chapter 10)
• Supporting wireless clients (Chapter 11)

We end the book with a chapter that aims to answer common questions of the form "How do I….?" We encourage you to have a peek at that chapter as soon as you become comfortable with the basics of JSF. There are helpful notes on debugging and logging, and we also give you implementation details and working code for features that are missing from JSF 1.0, such as file uploads, popup menus, and a pager component for long tables.

JSF is built on top of servlets and JSP, but from the point of view of the JSF developer, these technologies merely form the low-level plumbing. While it can't hurt to be familiar with other web technologies such as servlets, JSP, or Struts, we do not assume any such knowledge.