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
|
WA1701 
Online Virtual Class