JavaServer Faces: The Fundamentals

							JavaServer Faces:
The Fundamentals
                    Compiled from
         Sun TechDays workshops
  (JSF Basics, Web-Tier Codecamp:
                 JavaServer Faces,
     Java Studio Creator; IBM RAD)
JavaServer Faces (JSF)
 is a “server side user interface component
  framework for Java™ technology-based web
  applications”
 is a specification and reference implementation
  for a web application development framework
  Components
  Events
  Validators
  Back-end-data integration
 is designed to be leveraged by tools
  NetBeans, RAD (Rational Application Developer),
   Eclipse, JDeveloper, etc.
Why JSF?
 MVC for web applications
 Easy to use
 Extensible Component and Rendering
  architecture
 Support for client device independence
 Standard
 Huge vendor and industry support
 Built-in UI component model (unlike JSP and
  Servlet)
Why JSF? (cont’d)

Offers finer-grained separation of behavior
 and presentation than JSP
  Component-specific event handling
  UI elements as stateful objects on the server
UI-component and Web-tier concepts
 without limiting you to a particular scripting
 technology or markup language
  Can work with any presentation technology
   including JSP
JSF is a UI Framework for Java Web
Applications
JSF Architecture
Important Basic Capabilities
 Extensible UI component model
 Flexible rendering model
 Events-based interaction model (as opposed to
  the old “request/response” model)
 Validation framework
 Basic page navigation support
 Internationalization
 Accessibility
How the JSF Specification Fits In
(prior to Facelets)
Facelets
 Facelets is a powerful but lightweight page declaration
  language that is used to build JavaServer Faces views
  using HTML style templates and to build component
  trees.
 Facelets features include the following:
    Use of XHTML for creating web pages
    Support for Facelets tag libraries in addition to JavaServer Faces
     and JSTL tag libraries
    Support for the Expression Language (EL)
    Templating for components and pages
Facelets (cont’d)
 Advantages of Facelets for large-scale development
  projects include the following:
    Support for code reuse through templating and composite
     components
    Functional extensibility of components and other server-side objects
     through customization
    Faster compilation time
    Compile-time EL validation
    High-performance rendering


 In short, the use of Facelets reduces the time and
  effort that needs to be spent on development and
  deployment.
                                    Source: Java EE 6 Tutorial
JSF Developer Roles
Roles Definition
 Page Author
  Creates the user interface of a web application
  Familiar with markup language(s) to be used
  Assembler of prebuilt components
 Component Writer
  Creates reusable components, renderers, and libraries
  Components – Render-independent properties
  Renderers – Render-dependent properties
Roles Definition
 Application Developer
  Creates the server-side functionality of a web
   application not directly related to the user interface
  Business logic components implemented in standard
   J2EE ways (EJBs, JavaBeans, Connectors)
  Persistence tier components implemented in standard
   J2EE ways (EJBs, JDBC, Connectors)
  Model data exposed to user interface via JavaBean
   programming model
  Validator, Converter, Event handler
Roles Definition
 Tool Provider
  Creates tools to assist page authors, component writers,
   and application developers
  GUI-oriented page development tools
  IDEs to facilitate creation of components
  Application generators (from high level description)
  Web application frameworks that utilize JSF
   components for their user interface
 JSF Implementor
  Provides runtime environment to execute JSF webapps
   J2EE SDK 1.4
Criteria for choosing Struts or
JavaServer Faces
                      JSF                           JSP                          JSP and Struts

Components            Rich UI-data-bound           Standard tags (JSTL) that   Struts-specific tag library
                      components with events        are non-UI and very basic    Only very basic, form-
                      provided                      Custom components           bean-bound components
                      Custom components            through tag libraries        provided
Device independence   Reader kits that provide     None                        None
                      device independence

Error handling and    Validation framework         None                        Validation framework
validation            Many predefined                                           driven by an XML file
                      validators                                                 (validation.xml)

Scripting             Scripts can be attached to   Embedded Java™ in the       Scripts written in Java
                      events                        page                         Action classes
                      All components                                            Form data but not
                      accessible from scripts                                    components accessible

Page flow             Simple navigation file       None                        Sophisticated, flexible
                      (faces-config.xml)                                         framework
                                                                                 XML file based
Session and object    Automatic                    Manual                      Manual
management