JavaServer Faces (JSF)

Leveraging JavaServer Faces (JSF)

JSF architecture

1. Identifying the JSF core components
2. Exploring the request processing cycle
3. Managing application flow using the JSF navigation model

Constructing a JSF application

1. Creating views with JSF custom tags
2. Handling user events with backing beans

Enhancing functionality using JSF services

1. Applying server-side data validation
2. Taking advantage of the Unified Expression Language

Generating Rich User Interfaces (UI) with JSF Component Technology

Building views with standard HTML components

1. Defining the functionality of the HTML component set
2. Arranging the UI component layout
3. Localizing messages using Resource Bundles

Creating custom UI components

1. Developing the custom component class
2. Writing the custom tag handler
3. Deploying the custom component

Leveraging Ajax to improve the user experience

1. Sharpening response with the asynchronous Web model
2. Combining Ajax functionality with JSF
3. Utilizing pre-built Ajax-enabled JSF components

Implementing the Business Tier with EJB 3

Stateless and stateful beans

1. Encapsulating scalable business logic with JavaBeans
2. Accessing session beans remotely
3. Constructing effective stateful services

Applying advanced strategies of session beans

1. Adding behaviors with method interceptors
2. Linking services with annotation-based resource injection
3. Triggering timer-based services

Obtaining asynchronous communication with JMS

1. Decoupling client interaction with the Java Message Service
2. Transmitting and receiving messages with JMS

Unleashing Message Driven Beans (MDB)

1. Simplifying robust message receivers with MDB
2. Generalizing message reception with Java connectors

Opening Access with Web Services

Achieving interoperability with JAX-WS

1. Coding and packaging a service endpoint
2. Packaging and deploying the service

Accessing services with JAX-WS clients

1. Analyzing the client contract
2. Binding and exchanging valid data types

Mapping with Java Persistence API (JPA)

Demystifying the JPA architecture

1. Identifying the major components of JPA
2. Establishing access with the EntityManager

Applying JPA core operations

1. Developing the persistence class
2. Storing Java objects
3. Holding conversational state across requests

Handling Complex Object Relationships

Effectively representing object associations

1. Capturing single and multivalued associations
2. Representing Java collections

Choosing appropriate inheritance strategies

1. Employing techniques for class-to-database mapping
2. Auditing operations with Callbacks and Listeners

Working with JPQL

1. Initiating data access with the Java Persistence Query Language (JPQL) and API
2. Selecting Entity and relationship properties

Enhancing application structure and performance

1. Improving structure with named queries
2. Augmenting JPQL with native optimized SQL

Preserving Integrity with Enterprise Services

1. Approaches to working with Java Transaction API (JTA)
2. Managing transaction strategies with annotations
3. Securing each tier in a multitier architecture
4. Configuring roles and access control