UMBC Training Centers logo

EJB 3.0 Programming Using RAD 7.5

 

Course Description | Outline | IT Home

1. Java Enterprise Edition (EE) Overview
* Objectives
* 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

2. Introduction to Rational Application Developer (RAD) v7.5
* Objectives
* 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
* Code Completion, Templates and Snippets
* Searching
* Setup Compiler Class Path
* JRE Switching
* Refactoring
* Changing Class Name
* Changing Method Name
* Changing Variable Name
* Moving a Class to a Different Package
* Extracting Code to a Method
* Pull Up and Push Down Methods
* Migrating Workspace from RAD v6 or WSAD v5.1.2
* Project Interchange Feature
* Summary

3. Enterprise JavaBeans (EJBs) Overview
* Objectives
* 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

4. Stateless Session Beans
* Objectives
* 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

5. Stateful Session Beans
* Objectives
* 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

6. EJB References and Dependency Injection
* Objectives
* Dependency Injection
* Annotation Injection
* Example: Field Level Injection
* Example: Method Level Injection
* Deployment Descriptor Injection
* Example: Deployment Descriptor Injection
* EJBContext
* JNDI Lookup with EJBContext
* Overriding Reference Annotations
* Default Reference Name
* Resolving References
* mappedName Attribute
* Overloaded Reference Names
* EJB References
* EJB Reference Annotations
* Multiple EJB References
* EJB References in Deployment Descriptors
* Resource References
* Resource Reference Annotations
* Multiple Resource References
* Resource References in Deployment Descriptors
* Reference Lookup
* Summary

7. Entities and Java Persistence API
* Objectives
* 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
* 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
* Life-Cycle Callbacks
* Example: Internal callback
* External Callback Class
* Listener Class - Example
* Synchronizing with Databases
* Entity Lookup
* JPAQL (JPA Query Language)
* Summary
* Creating Entities
* JPA Project
* Creating An Entity
* Generated Entity Class
* Code the Entity
* JPA Tooling
* Dependencies

8. Java Persistence Query Language (JPA QL)
* Objectives
* 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

9. Entity Relationship
* Objectives
* 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
* Traversing the Relationship
* One-To-Many and Many-To-One
* Many-to-One Unidirectional
* Creating Entity Instances
* Traversing the Relationship
* Modeling One-to-Many
* Creating Entity Instances
* Traversing the Relationship
* Many-to-Many
* Modeling Many-to-Many
* 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
* Problems with Lazy Initialization
* Fetch Join Query
* Summary

10. Entity Inheritance
* Objectives
* Inheritance
* Inheritance Example
* Inheritance and Entities
* Inheritance Strategies
* Inheritance Strategy 1: Single Table Per Class Hierarchy
* Single Table Per Class Hierarchy
* Table Structure: Single Table Per Class Hierarchy
* Pros and Cons
* Strategy 2: Table Per Concrete Class
* Table Per Concrete Class
* Table Per Concrete Class: JBoss Warning
* Table Per Concrete Class
* Table Structure: Table Per Concrete Class
* Table Per Concrete Class: Pros and Cons
* Strategy 3: Joined Subclasses
* Joined Subclasses
* Table Structure: Joined Subclasses
* Joined Subclasses: Pros and Cons
* Which Approach To Use?
* Summary

11. Message-Driven Beans
* Objectives
* 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
* 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 Beans
* Summary
* References
* Configuring JMS
* Creating an MDB In RAD
* Coding the MDB
* Specifying The Destination
* Editing WebSphere Bindings
* Set the Activation Spec

12. EJB Security
* Objectives
* Introduction
* How EJB Security Works
* Protecting Web Resources
* Setting Method Permission
* Defining Roles
* Defining Roles Using Annotations
* Specify Methods Permission
* Disable Security Check
* Excludes List
* RunAs Security Identity
* RunAs Security Identity Configuration
* Programmatic EJB Security
* Security Role Reference
* Summary

13. Web Service Access to EJBs
* Objectives
* Web Services
* Operation and Implementation
* WSDL
* Typical Development Workflow
* Advantages of Web Services
* Web Services and EJB
* Web Service Clients
* JAX-WS Overview
* JAX-WS Framework
* Java to XML Data Conversion
* Main Goals of JAX-WS
* JAX-WS Server
* WSDL Overview
* WSDL Document Tags
* Web Service EJBs
* Annotate The Session Bean
* Annotate the Methods
* Service Endpoint Interface
* Package and Deploy
* Summary

14. EJB Timer Service
* Objectives
* Container Managed Timer Service
* EJB Timer Service
* Interaction between Timer Service and EJB
* Timer Service API
* The TimerService Interface
* Obtaining the Timer Service
* Creating a Timer
* Getting All Timers
* The Timeout Callback method
* The Timer Interface
* Example: TimerTestBean
* Timer and Transaction
* Limitations of EJB Timer Service
* Summary

15. Transactions
* Objectives
* Need for Transactions
* Transactions
* ACID Properties
* Transaction Components
* Distributed Transactions
* Distributed Transaction Components - Two Phase Commit
* Java Transaction API (JTA)
* Object Transaction
* EJB Transaction Basics
* Transaction Propagation
* Transaction Outcome
* Container Managed Transaction
* Container Managed Transaction Settings
* Interacting with Container Managed Transactions
* Container Managed Transaction - Example
* Transaction Attributes Support
* Bean Managed Transaction
* Bean Managed Transaction - Example
* Client Managed Transaction
* Transaction Isolation
* Isolation Level
* Summary

16. Interceptors
* Objectives
* Introduction
* Interceptors
* Internal Interceptor
* Example: Internal Interceptor
* External Interceptors
* Default Interceptor - Example
* Another Example
* Class-Level Interceptor - Example
* Setting Class Level Interceptors
* Pre & Post Processing with Interceptors - Example
* Excluding Default and Class Level Interceptors
* Interceptors on Lifecycle Callbacks
* Blocking Calls to Business Method Example
* Summary

17. EJB Deployment
* Packaging EJB JAR File
* The Bean Classes
* Dependent Classes
* Business Interfaces
* Client JAR File
* The Deployment Descriptor
* Basic Deployment Descriptor
* Configuring a Session EJB
* Configure Assembly Description

18. EJB 3 Design Patterns
* Objectives
* Introduction
* Session Fa ade Pattern
* JPA and Session Fa ade Pattern
* Fa ade Example
* Message Fa ade Pattern
* Message Fa ade Using JMS
* Message Fa ade Using Timer Service
* Additional Notes About Message Fa ade
* The Command Pattern
* Implementing Command Pattern
* Example Command Pattern
* Data Transfer Object (DTO) Pattern
* JPA Entity as DTO
* Problem With JPA Entity as DTO
* Version Number pattern
* JPA and Version Number Pattern
* Primary Key Generation
* JPA and Primary Key Generation
* Fast Lane Pattern
* JPA and Fast Lane Pattern
* Summary