JSF Training Course

JSF course extends the knowledge of basic Java web site development with Servlets and JSPs into the realm of event-driven, component-oriented, rich Java web applications with the JavaServer Faces technology.

Through a hands-on delivery students learn the concepts behind the JSF technology, including its architecture, API, life-cycle, components, converters, validators, renderers, listeners, event-handling, expression language, configuration, deployment, integration, and its relationship to Servlets/JSPs and other MVC frameworks.

In addition to using standard off-the-shelf JSF components (e.g. tables), students also gain skills necessary to build custom components, validators/converters, and AJAX-enabled user interfaces - all while applying best-practices in their overall application design.

Students also learn to take advantage of IDE support for JSF as well as libraries that facilitate JSF development such as Facelets, Sturts Shale, and JBoss Seam.

After successfully completing this course, students will be able to:

• Utilize component-oriented development techniques
• Work with standard JSF components
• Develop custom components, validators, and converters
• Take advantage of third-party components, IDEs, and open-source projects such as JBoss Seam, Struts Shale and Facelets
• Put it all together in a JSF application
• Build AJAX-enabled user interfaces
• Work with third-party component suites
• Integrate JSF with existing applications and frameworks (e.g. Struts)
• Apply best-practices to JSF projects

Experienced Java web developers, architects, and team leads who want to learn about JavaServer Faces technology.

Students must be familiar with the Java programming language and have a basic understanding of Java web application development concepts, including Servlets and JSPs.

Prior familiarity with other MVC frameworks such as Struts is not required but can be helpful.

This course is typically taught using Eclipse IDE and Tomcat Servlet engine. Other IDEs (e.g. NetBeans) and application servers (e.g. JBoss) are also supported, but have to be explicitly requested.

Day 1: Introduction

• An introduction to JSF
  • Overview
  • Servlets, JSP, and Frameworks
  • Web frameworks use the MVC pattern
  • Web frameworks use the MVC pattern
  • Many different frameworks
  • What is JavaServer Faces?
  • JSF and Struts
  • JSF Application Architecture
  • The IDE Effect
  • Key JSF Concepts
    • User interface (UI) components
    • Renderers
    • Backing beans
    • Validators
    • Converters
    • Events and listeners
    • Navigation
    • Expression language (EL)
    • Messages
  • Application Requirements
  • Developing an Application
  • Demonstration: Hello, world! with a WYSIWYG JSF IDE
  • Summary
• Exploring the JSF landscape
  • Overview
  • Java web development: the old daze
  • Flip Side: Components and ASP.NET
  • Rise of the JSF Ecosystem
    • Stats: Products
    • Stats: Articles & Books
    • Stats: Resources
    • Ecosystem players
    • Implementations
    • Development tools
    • Components
    • Frameworks built on JSF
    • Integration
    • Open source/free tools
    • JSP alternatives
  • Comparing markets
  • Summary
• Getting Started with JSF
  • Overview
  • Key JSF Concepts Revisited
  • Key artifacts
  • High-level Architecture
  • JSF Applications are Web Applications
    • Front Controller Pattern
    • JSF Front Controller
    • Configuration – web.xml
  • JSF Configuration Files
  • JSF Navigation
    • Navigation Elements
    • JSF Navigation Interactions
    • Navigation Rule Editors
    • Example Navigation Rules
  • Developing the view
    • Configuring a JSF Welcome Page
    • Developing Views with JSP
  • Lab 1
  • Summary

Day 2: Standard Features

• Creating Backing Beans and using Managed Beans
• Overview
• The JSF Expression Language
• JSF EL vs JSP EL
• The EL in JSF 1.1 vs 1.2
• Managed Beans
• Managed Bean Configuration
• JSP <usebean> vs JSF Managed Bean
• Managed Properties
• List Properties
• Map Properties
• Lists and Maps as Managed Beans
• Advantages of Managed Beans
• Wiring up Beans with the EL
• Backing Beans → Managed Beans
• Backing Beans
• Bean Development Tips
• Writing a Backing Bean
• Configuring a Backing Bean
• Lab 2
• Summary
• Exploring the Standard Components
• Overview
• The Standard Component Set
• Using HTML Attributes
• Understanding Facets
• Common UI Component Properties
• Output Component Family
• Panel Component Family
• Form Component Family
• Input Component Family
• SelectBoolean Component Family
• SelectItem Component Family
• SelectMany Component Family
• SelectOne Component Family
• Command Component Family
• Data Component Family
• Lab 3
• Summary
• Internationalization, Validators, and Converters
• Overview
• Internationalization in JSF
• Definitions
• Internationalizing and Localizing an Application
• Validation
• Validator Methods
• Using Validators
• Standard Validators
• Handing type Conversion
• Using Converters
• Standard Converters
• Customizing Messages
• Lab 4
• Summary

Day 3: Application Development

• Developing with JSF
• Overview
• Key JSF Objects
• Key Application Objects
• Key Context Objects
• Key Event Objects
• Writing ActionListeners
• Writing ActionListener Methods
• Writing ValueChangeListeners
• Writing ValueChangeListener Methods
• Securing Web Applications
• Container Based Security
• Disadvantages of Container Security
• Custom Security - Authorization
• Integrating the Web Tier
• Integrating Other Tiers
• Don't Forget the Servlet API
• Development Tips
• Lab 5
• Summary
• Inside the JSF Architecture
• Overview
• Powerful Architecture
• The Request Processing Lifecycle
• Phase Listeners
• Pluggable Extension Points
• Extension Point Overview
• Configuring Pluggable Classes
• Decorating a Pluggable Class
• Replacing a Pluggable Class
• Lab 6
• Summary
• Writing Custom Components, Validators, and Converters
• Overview
• UI Extensions
• Developing UI Components
• When to write a UI Component
• UI Component Artifacts
• Developing Renderers
• When to write a Renderer
• Renderer Artifacts
• Developing Validators
• When to write a Validator
• Validator Artifacts
• Developing Converters
• When to write a Converter
• Converter Artifacts
• Lab 7
• Summary

Day 4: Extensions and Integration

• Component Frameworks Overview
• Overview
• Why use Third-party components?
• Ajaxian Faces
• Open Source Component Suites
• ICEsoft ICEfaces
• Apache MyFaces Tomahawk
• Apache MyFaces Trinidad
• Apache MyFaces Tobago
• Commercial Component Suites
• Simplica ECruiser
• Infragistics NetAdvantage for JSF
• TeampDev QuipuKit
• SoftAspects WebGalileo Faces
• Can’t we all get along?
• Which one?
• Summary
• Using Apache Shale (appendix)
• Overview
• Which Struts is Which?
• What is Shale?
• Shale Infrastructure
• Key Shale Features
• Apache Commons Chain
• Chain integration with Shale
• View Controllers
• View Controller Example
• Shale Dialogs
• Shale Dialog Key Concepts
• Using Shale Dialogs
• Remoting
• Remoting Example
• Testing Framework
• Client-side validation
• Using client-side validation
• Clay Plugin
• Using Clay – JSP syntax
• Using Clay – HTML syntax
• Using Clay - clay-config.xml
• Java 5 Annotation support
• Odds and Ends
• Lab 8
• Summary
• Migrating from Struts (appendix)
• Overview
• When to use JSF with other Frameworks
• Migration and Integration Barriers
• Component-only Migration
• Incremental Migration
• Full Migration
• The Struts-Faces Integration Library
• Implementation Details
• Installation
• Migrating Struts JSP tags
• Using JSF action methods and managed beans
• Invoking Struts Actions from JSF event handlers
• Summary
• Using JBoss Seam (appendix)
• Overview
• What is Seam?
• Components, components, components
• Seam Applications
• Key Features
• Dependency Bijection
• JSF and EJB3 Integration
• Conversational Contexts
• JSF Enhancements
• Transaction Management
• CRUD Framework
• Security
• Other Goodies
• Why should you use Seam?
• Lab
• Future Directions
• Summary
• Summary and Future Directions