JSF Training with Custom Components and Ajax

Delivery Options

• Live eLearning (5 days): $2,625.00 (Register)

» Register Now

» Free Demo

» Watch Presentation

» Contact Education Consultant

• Customized Onsite Training (5 days): Request a Proposal

Class Date and Time	Price Volume Discounts Students Discounts 2 5% 3-4 10% 5 or more 15% GSA Price: $2,493.75	Register
May 3 - 7, 2010 10:00 AM - 5:00 PM ET	$2,625.00 or 5 vouchers	Register
May 24 - 28, 2010 10:00 AM - 5:00 PM ET	$2,625.00 or 5 vouchers	Register

Class Description

Class Overview

Class Goals

• Understand 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 managed beans to encapsulate not only server-side form handling but also client-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
• Use custom component libraries.
• Develop custom components for a variety of purposes, including composite components.
• Use custom components to encapsulate and deliver JavaScript content.
• Develop Ajax applications using JSF and DWR.
• Develop Ajax applications using RichFaces.

Class Outline

1. JavaServer Faces
   1. Overview
      1. Java EE and Web Applications
      2. Perspectives: Servlets and JSP
      3. The Model/View/Controller Pattern
      4. Perspectives: MVC Frameworks
      5. The Command Pattern
      6. Perspectives: AWT and JFC
      7. JSF Value Proposition
      8. JSF Configuration
   2. Lifecycle and Page Navigation
      1. The JSF Request/Response Cycle
      2. Lifecycle Phases
      3. The FacesContext Class
      4. Who Does What
      5. View Selection
      6. Navigation Rules
      7. Outcomes
   3. User Interface Components
      1. The Composite View Pattern
      2. The UIComponent Class
      3. Behavioral Interfaces
      4. The Core and HTML Tag Libraries
      5. Relationship to CSS
      6. ID, Client ID, and Label
      7. The UISelectItem(s) Class
      8. Navigating the UI Tree
   4. Managed Beans
      1. JavaBeans and JSF
      2. Backing Beans
      3. The Factory Pattern
      4. Managed Beans
      5. Coarse-Grained Beans
      6. The Unified Expression Language
      7. Value Expressions
      8. Dependency Injection
      9. Bean Scopes
   5. Events and Controllers
      1. The Observer Pattern
      2. JSF Event Model
      3. Event Types and Timing
      4. Event Queueing
      5. ActionEvent and ActionListener
      6. Action Methods
      7. Connecting Controllers to Beans
      8. Dynamic Outcomes
      9. ValueChangeEvent and ValueChangeListener
      10. Limitations of FacesListeners
   6. Converters
      1. The Adapter Pattern
      2. The Converter Interface
      3. Standard Converters
      4. Working with Enumerated Types
      5. Timing of Conversion
      6. Custom Converters
      7. Configuring Converters
   7. Validators
      1. Validating Input
      2. The Validator Interface
      3. Standard Validators
      4. Producing Error Messages
      5. Message Keys
      6. Presenting Error Messages
      7. Custom Validators
      8. Validating Multiple Inputs
      9. Using a PhaseListener
   8. Data Tables
      1. Managing Tabular Data
      2. The JSF Data Table
      3. Columns
      4. Facets
      5. Limitations and Strategies
      6. Nesting Tables
2. Custom Components
   1. Using Custom Components
      1. Component Libraries
      2. Deployment Model
      3. Apache Tomahawk
   2. Developing Custom Components
      1. The Components of a Component
      2. Custom Tags and CSS vs. Custom Components
      3. The UIComponent Class
      4. The Renderer Class
      5. Encoding and Decoding
      6. The UIComponentELTag Class
      7. Using the Default Renderer
      8. State-Saving Concerns
   3. Composites
      1. Composite Components
      2. JSF Composite vs. HTML Composite
      3. Composite vs. Shell
      4. Creating, Configuring, and Assembling
   4. Delivering JavaScript
      1. Client-Side Scripting
      2. HTML Events and the HTML DOM
      3. Encoding Scripts
      4. JSF and Script Libraries
      5. Encoding Scripts Once
      6. Encoding Scripts Uniquely
   5. Ajax Applications
      1. What is Ajax?
      2. Request Formats
      3. Means of Triggering HTTP Requests
      4. Asynchronous Response Handling
      5. Direct Web Remoting
      6. Server-Side Strategies
      7. Invoking Managed Beans
   6. Ajax Components
      1. Server-Side Strategies: Another Look
      2. Model/View/Controller for Ajax
      3. JSF Lifecycle and Partial Page Rendering
      4. RichFaces
      5. Triggering Ajax Requests
      6. Re-Rendering
      7. Input Validation
      8. Customizing Custom Components

Class Materials

All students receive a course manual or book and all the class examples.

Students in private onsite classes will also receive:

• Technical Reference Library

Class Prerequisites

Experience in the following areas is required:

• This course is intended primarily for experienced Java application developers. Page authors, component developers, and others who may have little or no Java experience (but perhaps are stronger on HTML and JSP) may well find this to be a valuable training experience, though without solid Java skills many of the coding exercises will be difficult to follow.
• Java programming experience is essential to understanding the JSF API as presented here
• JSP page-authoring experience is required
• Servlets programming experience is recommended but not required
• Basic knowledge of XML will be helpful, as will any previous experience with HTML.

Technical Requirements

Our computer technical requirements and setup process is easy, with support just a click away.

• Course technical requirements and setup instructions.

• Java ^®, all Java-based marks, Hibernate ^®, and all Hibernate-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. or its subsidiaries in the U.S. and other countries.