WA1701 Java EE 5 Programming with JSF, EJB 3.0 and JPA Using Rational Application Developer 7.5 Training Outline

Chapter 1. Java Enterprise Edition (EE) Overview
	Introduction to Java Platform Java Community Process (JCP) Introduction to Java EE Why Move to Java EE Java EE - New and Enhanced Features Java EE Software Packaging Java EE Technologies Summary

Chapter 2. Introduction to Rational Application Developer (RAD) v7.5
	The RAD 7.5 Product Eclipse Platform Rational Web Developer Rational Application Developer Key Features in RAD v7.5 Views, Perspective, and Editor Areas Basic Operations with RAD Views and Perspectives The Java Perspective The Debug Perspective Navigator View Package Explorer Outline View Task and Problems View Build and Validation Import and Export Project Project Interchange Feature Code Completion, Templates and Snippets Searching Setup Compiler Class Path JRE Switching Migrating Workspace from RAD v6.0 or RAD v7.0 Backward Compatibility with RAD v7.0 References Summary

Chapter 3. Introduction to JavaServer Faces
	What is JavaServer Faces (JSF)? Why Use JSF? Nature of a JSF Application The Sun Reference Implementation (RI) JSF and MVC Faces Servlet Managed Bean The View A Simple JSF Application The Input Form: form.jsp The Result: thanks.jsp The Controller: AddressBean Page Flow or Navigation Rule How Does the Application Work? Under the Covers: The Rendered Form HTML Under the Covers: The Layout Tree

Chapter 4. Managed Bean
	What is a Managed Bean? Why Do You Need Managed Beans? Managed Bean As a Controller Registering a Managed Bean Lifecycle of a Managed Bean Initializing a Managed Bean What Scope to Use? Value Binding Property Data Conversion Advanced Property Types Component Binding Other Binding Types Basic Input Processing Advanced Input Processing JSF Expression Language Language Basics Use of Expression in JSF Basic Expression Property Access Expression Map Access Expression Complex Access Expression Predefined Objects Operators

Chapter 5. User Interface Components
	JSF UI Components JSF Component Tag Libraries Using the Tag Libraries HTML Tag Library Identifying Components Component Identifier Client Identifier Form Input Field Names Define a Form Labels and Images Buttons Links Adding Parameters to Links Text Input Simple Check Box Check Box Group Check Box Group Example Radio Button List Boxes Dynamic List Box Example Another Example JSF Core Library JSF Core Library - Components JSF Component Model Base Class Hierarchy Useful Base Classes Useful HTML Classes

Chapter 6. JSF Event Handling
	Request Processing Phases Action Request Processing Phases JSF Event & Listener Model… JSF Event Classes Event Classes Event Classes: Hierarchy Action Event Handling Action Event: Example Action Listener Value Change Event Value Change Event Handler Listener Classes Listener Interfaces Listener Classes: Hierarchy Action Listener Class Value Change Listener Class Phase Event Listener Request Processing Lifecycle Phase Identifiers

Chapter 7. JSF Navigation
	JSF Navigation Example Action Listener faces-config.xml File JSF Navigation Navigation Rules: Example Choosing Between Redirect & Direct Rendering Navigation: Scenarios

Chapter 8. Validation
	Introduction Validation Standard Validators <f:validateLength> <f:validateDoubleRange> <f:validateLongRange> Checking for Required Values Showing Validation Error Messages Customizing Standard Error Messages Standard Validation Error Messages Validation Process Sequence Diagram Bypassing Validation Immediate Command Components Immediate Input Components Accessing User Input Immediate Command Component Example Immediate Input Component Example Advanced Field Validation Model Layer Error Handling

Chapter 9. Advanced GUI Components
	HTML Panel Applying Styles Grouping Components Data Table Using a Data Table Data Table Model Using a Data Table Displaying a Header and Footer Row Applying Styles Adding Links to a Row Using Component Binding Handling Action Using the Data Table Model Handling Action

Chapter 10. JSF Techniques
	A Typical Application The Create Form Create Action Method Listing Items Editing an Item Adding the Edit Link The Edit Form Update Item Things to Keep in Mind

Chapter 11. Enterprise JavaBeans (EJBs) Overview
	Need for EJBs Distributed Computing Distributed Transaction Distributed Security What are EJBs? Main Characteristics of EJBs EJB Remote Method Call EJB Architecture Components EJB Client EJB JAR File EJB Container EJB Server Enterprise JavaBeans Session Beans Entity Beans Java Persistence API - Entities Message-Driven Beans (MDBs) EJB Specification Summary

Chapter 12. Stateless Session Beans
	Session Beans Stateless Session Bean Stateless Session Bean Pooling Stateless Session Bean Examples Stateful Session Bean Stateful Session Bean Examples Annotations Stateless Session Bean Components Example: Business Interface Example: Bean Class Alternative Example JNDI - Overview Example: The Client Business Interface Details Bean Class Details Session Bean Lifecycle Stateless Session Bean Lifecycle Summary Creating A Session Bean Creating An EJB Project The Client JAR EJB Projects Creating an EJB Creating the EJB Coding the Bean Updating Interfaces Dependencies

Chapter 13. Stateful Session Beans
	Stateful Session Bean Stateful Session Beans Session Bean Lifecycle Stateful Session Bean Lifecycle Stateful Session Bean Components Stateful Session Bean Example Stateful Session Bean Client Removing the Bean Summary

Chapter 14. Entities and Java Persistence API
	Data Persistence Java Persistence API Entities Session Beans Vs Entities Entities Persisting and Retrieving Data Accessing Entities EntityManager & Persistence Unit Persistence Context Entities - Example persistence.xml – Hibernate Provider persistence.xml – Open JPA Provider persistence.xml - Toplink Entity Instance Lifecycle Creating EntityManager in Session EJB Creating EntityManager in a Plain Java Class Working With the EntityManager Interface Transaction Basics Summary Creating Entities JPA Project Creating An Entity Generated Entity Class Code the Entity JPA Tooling Dependencies

Chapter 15. JPA Entity Lifecycle
	Entity Lifecycle When is an Entity Managed or Detached? Implementing the CRUD Pattern Accessing Entities Using Stateless Session Beans Inserting Data Retrieving Data Updating Data Deleting Data Merging Entities Merging Entities (example) Life-Cycle Callbacks Example: Internal callback External Callback Class Listener Class - Example Synchronizing with Databases Entity Lookup JPAQL (JPA Query Language) Summary

Chapter 16. References and Dependency Injection
	Role of References EJB Reference Annotations Resource Reference Annotations Dependency Injection Annotation Injection Example: Field Level Injection Example: Method Level Injection Deployment Descriptor Injection Example: Deployment Descriptor Injection Class Level References Multiple References EJB References in Deployment Descriptors Resource References in Deployment Descriptors Reference Lookup EJBContext JNDI Lookup with EJBContext Overriding Reference Annotations Default Reference Name Resolving References mappedName Attribute Overloaded Reference Names Reference Best Practices Summary

Chapter 17. Java Persistence Query Language (JPA QL)
	JPA Query Language Basic JPAQL Syntax Simple SELECT Examples Example of Using JPAQL The SELECT clause Reading Data from Code The WHERE Clause Example Using JPAQL from Session EJB Named Query Multiple Named Queries Bulk Updates Bulk Delete Running Native SQL Query Native SELECT Query Native SQL Delete and Insert Named Native Query Summary

Chapter 18. Basic Entity Relationships
	Relationship Between Entities Anatomy of a Relationship Foreign Key Example Schema One-to-One Unidirectional Creating Entity Instances Traversing the Relationship The Cascade Behavior One-to-One Bidirectional Maintaining Bidirectional Links Simplifying Bidirectional Links Traversing the Relationship Summary

Chapter 19. Complex Entity Relationships
	One-To-Many and Many-To-One Many-to-One Unidirectional Creating Entity Instances Traversing the Relationship Modeling One-to-Many Maintaining Bidirectional Links Creating Entity Instances Traversing the Relationship Many-to-Many Modeling Many-to-Many Maintaining Bidirectional Links Creating Entity Instances Traversing Relationship Unidirectional One-to-Many Modeling Unidirectional One-to-Many Creating Entity Instances Traversing the Relationship Relationship in JPA QL Fetching Optimizations Lazy vs. Eager Initialization Lazy Initialization Various Problems with Lazy Initialization Fetch Join Query Summary

Chapter 20. Message-Driven Beans
	The Trouble with RMI/IIOP Messaging to the Rescue Messaging Features Message-Oriented Middleware Messaging Domains Publish/Subscribe Point-to-Point Java Message Service JMS Programming: Overview JMS Programming: Overview… The JMS Interfaces Integrating JMS and EJB Message-Driven Beans Are Different From Other EJBs Message-Driven Beans Cannot Talk to Their Clients Message-Driven Beans are Stateless Durable Subscription Message-Driven Bean Interfaces javax.jms.MessageListener javax.jms.Message Specialized Message Types Lifecycle Message Driven Bean - Example Message Driven Bean - Client Example (JSP) Transactions Security Load Balancing Clustering and Topics Clustering and Queues A Few Tips Poison Messages How the Programmer Can Avoid Poison Messages How the System Administrator Can Avoid Poison Messages Building a Response Potential Problems A Simple Alternative Type Checking and Messages Testing Message-Driven Bean Summary References Configuring JMS Creating an MDB In RAD Coding the MDB Specifying The Destination Editing WebSphere Bindings Set the Activation Spec

Chapter 21. JSF, EJB 3 and JPA Integration
	Integrating JSF EJB 3 JPA Putting It All Together Simple Application Code the JPA Entity The Managed Bean Managed Bean Option 1 Managed Bean Option 2 Accessing the Entity Manager Local Entity Manager Remote – Session Bean EM Entity As DTO Managed Bean Scope Summary

Chapter 22. Introduction to JAX-WS
	What is JAX-WS? Advantages of JAX-WS Why Do We Need a Programming Model? Basic Java to WSDL Mapping Developing a Service Provider The Service Implementation Class The Service Endpoint Interface (SEI) Service Implementation Options Developing a Consumer Static Client Development The Service Class The BindingProvider Interface Summary

Chapter 23. JEE Application Deployment
	Overview Generate Deployed Code Export EAR Separate Client side code Export EJB Client JAR Export Utility JAR JEE Deployment WebSphere Profiles Creating Profiles for RAD Administrative Console Environment Variable Security Resources Creating JDBC provider Creating Data Source WebSphere MQ JMS Configuration WebSphere MQ JMS Provider Connection Factory Destination Activation Specification Installing Applications Starting an Application Scripting in RAD Script Configuration Command Assistance Notifications Summary

Home

Training

Mentoring

WA1701 Java EE 5 Programming with JSF, EJB 3.0 and JPA Using Rational Application Developer 7.5 Training Outline

Chapter 1. Java Enterprise Edition (EE) Overview

Chapter 2. Introduction to Rational Application Developer (RAD) v7.5

Chapter 3. Introduction to JavaServer Faces

Chapter 4. Managed Bean

Chapter 5. User Interface Components

Chapter 6. JSF Event Handling

Chapter 7. JSF Navigation

Chapter 8. Validation

Chapter 9. Advanced GUI Components

Chapter 10. JSF Techniques

Chapter 11. Enterprise JavaBeans (EJBs) Overview

Chapter 12. Stateless Session Beans

Chapter 13. Stateful Session Beans

Chapter 14. Entities and Java Persistence API

Chapter 15. JPA Entity Lifecycle

Chapter 16. References and Dependency Injection

Chapter 17. Java Persistence Query Language (JPA QL)

Chapter 18. Basic Entity Relationships

Chapter 19. Complex Entity Relationships

Chapter 20. Message-Driven Beans

Chapter 21. JSF, EJB 3 and JPA Integration

Chapter 22. Introduction to JAX-WS

Chapter 23. JEE Application Deployment