Please contact us
for GSA pricing.

Contract #

Please see our complete list of Microsoft Official Courses

JSF 2 Training: Building Web and Ajax Applications with JavaServer Faces 2

4.6 out of 5 (68 reviews)

Course Number: JSF-106
Duration: 5 days
view course outline

JSF 2 Training Overview

In Accelebrate's Building Web and Ajax Applications with JavaServer Faces 2 training class, attendees learn how to rapidly build Web and Ajax applications using the core of JSF 2 and special implementations such as RichFaces and ICEfaces.

Location and Pricing

Most Accelebrate courses are delivered as private, customized, on-site training at our clients' locations worldwide for groups of 3 or more attendees and are custom tailored to their specific needs. Please visit our client list to see organizations for whom we have delivered private in-house training. These courses can also be delivered as live, private online classes for groups that are geographically dispersed or wish to save on the instructor's or students' travel expenses. To receive a customized proposal and price quote for private training at your site or online, please contact us.

In addition, some courses are available as live, online classes for individuals. See a schedule of online courses.

JSF 2 Training Prerequisites

All attendees should have a solid foundation in Java programming and OO principles.

Hands-on/Lecture Ratio

This class is 60% hands-on, 40% lecture, with the longest lecture segments lasting for 25 minutes.

JSF 2 Training Materials

All JSF training students receive a copy of Prentice-Hall's Core JavaServer Faces, related courseware, and copies of all files developed during the class.

Software Needed on Each Student PC

  • JDK 1.6 or later
  • Lab files that Accelebrate will provide (which include Tomcat, a database, code files, and more)
  • Modern web browser
  • Other free software - please contact us if you have purchased this class

JSF 2 Training Objectives

  • Understand the lifecycle phases of a JSF application request and response, and effectively use different events within a JSF application
  • Create and maintain JSF component classes and tags within Facelets in response pages
  • Understand and use the JSF Expression Language (EL)
  • Develop and maintain JSF managed beans
  • Manage navigation with Action methods and Listeners
  • Use validators and type conversion in JSF applications
  • Create a customized JSF GUI component
  • Create Facelets templates to implement a common look-and-feel for JSF applications
  • Identify and implement composition components for reusable display elements
  • Create a simple Ajax application to receive data from a server and modify the web page asynchronously
  • create a custom JSF component that will implement basic Ajax functionality
  • Use RichFaces tags to implement Ajax functionality within an existing web application
  • Use ICEfaces components the add Ajax functionality to a web application

JSF 2 Training Outline

  • JSF Overview
    • Model View Controller
    • JSF elements - web.xml and faces-config.xml
    • The power of Facelets
      • tile-like composition
      • debugging/error handling
      • custom logic tags and expressions
      • XHTML
    • JSF 2  - quick summary of features
    • Annotations - a review
  • GUI Components 1
    • Component Families
    • UIViewRoot and the FacesContext
    • The JSF lifecycle
      • GET vs. POST (JSF 2)
    • Facelets pages
    • Output components - text and labels
    • Forms
    • Formatting output
    • Inputting text and passwords
    • Messages and severity
  • Navigation in JSF applications
    • Navigation rules and cases via annotations
    • Static vs. dynamic actions
    • Declaring navigation in faces-config.xml
    • JSF Expression Language
      • Comparison to JSP EL
      • Basic syntax
      • Array, Map and List access in JSF EL
      • JSF EL Operators
      • JSF EL Implicit Objects
  • Backing Beans
    • The uses of backing beans
    • Declaring managed beans and properties via annotations
      • Managed beans and properties in faces-config.xml
    • Lists and Maps properties in Managed Beans
    • Using the FacesContext
    • Action methods in backing beans
    • Connecting to back-end services
      • business logic
      • persistence
  • Conversion and Validation
    • Conversion and Validation in the JSF Lifecycle
    • Implicit and explicit conversion
    • Date/Time conversion
    • Number conversion
    • Standard input validators
    • Implementing validation in backing beans
    • Displaying conversion/validation error messages
    • Custom converters and validators
    • Client-side validation
  • JSF Events
    • The phases of JSF
      • Restore View
      • Apply Request Values
      • Process Validations
      • Update Model Values
      • Invoke Application
      • Render Response
    • GET vs. POST
      • creating the view tree
      • rendering the existing view tree
    • Page actions (JSF 2)
    • Action Events
      • Action methods and Action Listeners
      • Methods of ActionEvent and UIComponent
    • Value Change Events
      • Methods of ValueChangeEvent
    • Phase Events
      • Registering a Phase Listener
      • Specifying which requests are handled by the Phase Listener
    • Data Model Events
  • GUI Components 2
    • Selecting items from lists
    • Checkboxes and radio buttons
    • Command Buttons and Command links
    • Panel Group and Panel Grid
    • Data Tables
      • display-only data tables
      • "interactive" data tables
    • New JSF 2.1 components - Date Picker, Tabbed View, Tree and File Upload
  • Writing Custom Components
    • The makeup of a Custom Component
    • Using the component in a JSP
    • Using attributes with a custom tag
    • Custom components that provide input
  • Page composition using Facelets
    • Templating
      • creating a Facelets template
      • creating a Facelets client page
      • creating a Facelets content page
    • Passing parameters to pages
    • Facelets and JSTL
    • Facelets composition components
      • defining a composition component
      • using a composition component
      • tips and tricks
    • Using other tag libraries
      • taglibs supporting Facelets
  • Ajax Overview
    • XMLHttpRequest
    • GET vs. POST requests
    • Leveraging Ajax in web applications
    • Connecting to the server - ready state and status
    • Updating the Document Object Model for the page
  • Ajax in the JSF 2 lifecycle
    • On the client page - jsf.ajax.request( )
    • PartialViewContext
    • Request and response payloads
      • standardized for compatibility across libraries
    • The <f:ajax> tag
    • Ajax requests in the JSF lifecycle
  • Existing Ajax strategies for JavaServer Faces
    • RichFaces
      • ajax4jsf tags
      • updating regions
      • Ajax-aware RichFaces components
    • ICEfaces
      • Ajax-aware library components
  • Conclusion