Complete JavaServer Faces




Complete JavaServer Faces Training Class Summary

This comprehensive five-day course shows Java programmers how to build web applications with JavaServer Faces 2.0. We develop the best-practice concepts that are formalized by the JSF architecture, from model/view/controller to the UI component framework and request-handling lifecycle. Students start to discover that there is a "JSF way" of doing things, and learn not just APIs and tag libraries but the habit of slicing application logic into its most reusable forms: managed beans, event listeners, converters, validators, and more. Students also acquire a firm command of JSF development, learning to work with JSF's list and table components, building reusable composite components, and building Ajax applications. Simple, high-level Ajax functionality is covered, and students work more directly with JSF's JavaScript API and resource-management framework.

Audience: Java programmers wishing to learn JavaServer Faces.

Prerequisites: Java programming experience is required. A general understanding of Servlets and JSP is recommended. Basic knowledge of XML and HTML is helpful.

Class Length: 5 days

Complete JavaServer Faces Training Class Objectives
  • Describe the purpose and scope of the JSF architecture.
  • Build web applications using JSF’s FacesServlet, faces-config.xml, and the JSF request/response lifecycle.
  • Use Facelets tag libraries to build JSF views.
  • Use managed beans to encapsulate form handling and server-side presentation logic.
  • Implement control logic as JSF event listeners or action methods.
  • Use validators and converters to implement a validation phase for a JSF application.
  • Build composite UI fragments or custom components using Facelets.
  • Build Ajax applications with JSF: client-side behaviors and partial requests and responses followed by DOM updates.
Complete JavaServer Faces Training Class Detailed Outline
  1. Overview
    • Java EE and Web Applications
    • Perspectives: Servlets and JSP
    • Perspectives: MVC Frameworks
    • Perspectives: AWT and JFC
    • JSF Value Proposition
    • JSF Configuration
    • Issues with JSP and JSF
    • Facelets
  2. Lifecycle
    • The JSF Request/Response Cycle
    • Lifecycle Phases
    • Phase Listeners
    • The FacesContext Class
    • Who Does What
    • Partial Request Cycles
  3. UI Components
    • The UIComponent Class
    • Behavioral Interfaces
    • The Core and HTML Tag Libraries
    • Relationship to CSS
    • ID vs. Client ID vs. Label
    • The UISelectItem(s)
    • Navigating the UI Tree
    • The binding Attribute
  4. Page Navigation
    • View Selection
    • Navigation Rules
    • Implicit Navigation
    • Problems with POSTback
    • Post/Redirect/Get
    • Support for HTTP GET
    • Conditional Navigation
  5. Managed Beans
    • JavaBeans and JSF
    • Backing Beans
    • Configuring Managed Beans
    • @ManagedBean and Related Annotations
    • The Unified Expression Language
    • Value and Method Expressions
    • Implicit Objects
  6. Scopes
    • Managed-Bean Scopes
    • Lifecycle Annotations
    • View Parameters
    • Passing Request Parameters
  7. Dependency Injection
    • Managed Properties
    • Values, Lists, and Maps
    • Using Dynamic Expressions
    • Dependencies and Bean Scopes
    • The @ManagedProperty Annotation
  8. Facelets
    • Migrating from JSP
    • View Definition Languages
    • Facelets
    • Tag Libraries
    • Writing and Using Custom Tags
  9. Events and Listeners
    • The JSF Event Model
    • Event Types and Timing
    • Event Queueing
    • ActionEvent and ActionListener
    • Action Methods
    • Connecting Controllers to Beans
    • ValueChangeEvent and ValueChangeListener
    • Deferring Event Processing
    • Limitations of FacesListeners
  10. Lists and Tables
    • Working with Collections
    • Why We Don’t Use <c:anything> <c:anyMore>
    • <ui:repeat> vs. <c:forEach>
    • <h:dataTable>
    • Defining Columns and Facets
    • One Command per Row
    • Reading the Row Number
    • Pseudo-Maps
    • Working with Persistent Data
    • Concurrency and Caching
    • Limiting the Scope of Queries
    • Paging
  11. Converters
    • The Converter Interface
    • Life of a Datum
    • Standard Converters
    • Custom Converters
    • The @FacesConverter Annotation
    • Timing of Conversion
    • Representing Persistent Objects by ID
  12. Validators
    • The Validator Interface
    • Standard Validators
    • Using Regular Expressions
    • Producing Error Messages
    • Message Keys
    • Presenting Error Messages
    • Posting Error Messages from Anywhere
    • Custom Validators
    • The @FacesValidator Annotation
    • Validating Multiple Inputs
    • JSR-303 Support: “Bean Validation”
  13. Resources
    • Resource Libraries
    • Deploying Images, Scripts, and Stylesheets
    • Addressing Resources
  14. Composites
    • Limitations of Custom Tags
    • Composite Components
    • Encapsulation
    • Deploying and Using Composites
    • Interface and Implementation
    • Impact on the UI Tree
    • Attributes
    • Retargeting
  15. Ajax
    • What is Ajax?
    • The XMLHttpRequest Object
    • Ajax and the JSF Lifecycle
    • Using <f:ajax>
    • execute and render Attributes
    • Ajax Listeners
  16. The JSF JavaScript API
    • The JSF JavaScript API
    • Triggering Ajax Requests
    • Refining <f:ajax> with Callbacks
    • onevent and onerror Atributes
    • The Ajax Request/Response Process
    • Using Hidden Inputs
    • Other JavaScript Functions