United States flagCanada flag1 877 849 1850 International flag +1 678 648 311
Please contact us
for GSA pricing.
GSA
Contract #
GS-35F-0307T

Java Training: Building Web Applications with JSF, Spring Web Flow, and Spring Faces

Course Number: JAV-220
Duration: 5 days
view course outline

Java Training Overview

This course teaches attendees how to build well-architected JSF, Web Flow, and Spring Faces web applications using JSF, Spring Web Flow, and Spring Faces.

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.

Java Training Prerequisites

Java programming experience is essentialJSP authoring experience is requiredServlets programming experience is recommended but not required. Familiarity with Spring's core module is expected, though we review it briefly during the course. Basic knowledge of XML will be helpful, as will any previous experience with HTML.

Hands-on/Lecture Ratio

This Java training course is 60% hands-on, 40% lecture, with the longest lecture segments lasting for 30 minutes.

Java Training Materials

All attendees receive comprehensive courseware covering all topics shown.

Software Needed on Each Student PC

  • Eclipse IDE for Java EE Developers (we may be able to accommodate other IDEs upon request)
  • JBoss Application Server, GlassFish, WebLogic, or WebSphere (other application servers potentially accommodated upon request)
  • Related lab files (please contact us for a detailed setup sheet)

Java Training Objectives

  • 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 the JSF custom tag libraries to build JSF views as JSPs.
  • 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.
  • Instantiate, configure, and assemble systems of Java objects using Spring's "IoC" container.
  • Develop coherent web flows using Spring Web Flow's view states, transitions, and actions.
  • Use SWF's custom scopes (flash, view, flow, conversation) effectively.
  • Blend SWF and JSF techniques for a single web architecture, using Spring Faces.

Java Training Outline

  • Overview of JSF
    • Java EE and Web Applications
    • Perspectives: Servlets and JSP
    • The Model/View/Controller Pattern
    • Perspectives: MVC Frameworks
    • The Command Pattern
    • Perspectives: AWT and JFC
    • JSF Value Proposition
    • JSF Configuration
  • Lifecycle and Page Navigation
    • The JSF Request/Response Cycle
    • Lifecycle Phases
    • The FacesContext Class
    • Who Does What
    • View Selection
    • Navigation Rules
    • Outcomes
  • User Interface Components
    • The Composite View Pattern
    • The UIComponent Class
    • Behavioral Interfaces
    • The Core and HTML Tag Libraries
    • Relationship to CSS
    • ID, Client ID, and Label
    • The UISelectItem(s) Class
    • Navigating the UI Tree
  • Managed Beans
    • JavaBeans and JSF
    • Backing Beans
    • The Factory Pattern
    • Managed Beans
    • Coarse-Grained Beans
    • The Unified Expression Language
    • Value Expressions
    • Dependency Injection
    • Bean Scopes
  • Events and Controllers
    • The Observer Pattern
    • JSF Event Model
    • Event Types and Timing
    • Event Queueing
    • ActionEvent and ActionListener
    • Action Methods
    • Connecting Controllers to Beans
    • Dynamic Outcomes
    • ValueChangeEvent and ValueChangeListener
    • Limitations of FacesListeners
  • Converters
    • The Adapter Pattern
    • The Converter Interface
    • Standard Converters
    • Working with Enumerated Types
    • Timing of Conversion
    • Custom Converters
    • Configuring Converters
  • Validators
    • Validating Input
    • The Validator Interface
    • Standard Validators
    • Producing Error Messages
    • Message Keys
    • Presenting Error Messages
    • Custom Validators
    • Validating Multiple Inputs
    • Using a PhaseListener
  • Review of Spring (informal, drawn from our Spring core training)
    • Containers and Beans
    • Configuring Beans
    • Dependency Injection
    • Managing Collections and Maps
    • Auto-Detecting @Components
    • Autowiring and @Autowiring
    • Validation
  • Introduction to the Spring Web Module
    • The DispatcherServlet
    • Web Application Contexts
    • The HandlerMapping
    • Controllers and @Controllers
    • The ViewResolver
  • Overview of Spring Web Flow
    • The Need for Flow
    • Spring Web Flow
    • Relationship to Spring
    • Flows and States
    • Model Beans
    • POST-REDIRECT-GET
    • Development Process
  • Defining Flows
    • View States
    • Transitions
    • Encoding Commands in HTML Views
    • Variables
    • Web Flow Scopes
    • Expression Language(s)
    • Actions
    • Using Spring Beans
    • Using Flash Scope
    • Action States and Decision States
    • View State vs. View
  • Binding and Validation
    • Binding to a Model
    • Required Fields
    • Reporting Error Messages
    • Converters
    • Registering Custom Converters
    • Validation
    • The ValidationContext
    • The MessageBuilder
    • Registering a Validator
  • Connecting Flows
    • Flow Input and Output
    • Subflows
    • Reading Flow Output
    • Using Conversation Scope
    • Flow Inheritance
    • State Inheritance
  • Spring Faces
    • JSF and Spring: Likely Partners
    • JSF and Spring: Who Should Rule?
    • Making Spring Beans Available to JSF
    • Spring Faces
    • Statless vs. Stateful Views
    • Putting JSF at Web Flow's Service
    • Maintaining JSF Views
    • Meshing Message Architectures
  • Conclusion