| Course Code: |
IN 1061 |
| Course Abstract: |
This course gives the experienced Java developer a thorough grounding in Enterprise JavaBeans -- the Java EE standard for scalable, secure, and transactional business components. EJB 3.0 has reinvigorated this area of Java enterprise development, with dramatic improvements in ease of use and smooth integration with servlet-based or JSF web applications. This course treats the 3.0 specification, with a few notes on 2.1 compatibility but an emphasis on doing things the 3.0 way.
Participants get an overview of the EJB rationale and architecture, and then dive right into creating session beans and entities. The new dependency-injection features of EJB3 cause perhaps the most confusion, so we work through a chapter devoted explicitly to DI and JNDI, and basically how components find each other to make an application. We study entities and the Java Persistence API in depth, and get a look at message-driven beans as well. The latter phase of the course covers advanced topics including transactions, security, and interceptors
A bridge module is also available that illustrates how JavaServer Faces (JSF) web applications can work with EJBs and Java Persistence API entities; this brief presentation can easily be added to the end of the class and works especially well to cap off a week of training using this course and one of our JSF courses.
|
| Audience: |
This course is designed for individuals who are programmers.
|
| Duration: |
5 days |
| Learning Outcomes: |
Upon completion of this course, the participant will be able to:
> Know the role of EJB in the broader Java EE platform.
> Describe the features that are implemented by an EJB container on behalf of application components.
> Build stateless session beans as part of a service layer or SOA.
> Build JPA entities to represent persistent data records within the Java application.
> Develop systems of entities to manage complex data models including 1:1, 1:N, and N:N associations.
> Manage transactional behavior of the application through declarative and programmatic techniques.
> Invoke EJB sessions from Java web applications.
> Use dependency injection and JNDI names to assemble complex web/EJB systems with minimal fuss and maximal flexibility.
> Implement message-driven beans to process queued messages asynchronously.
> Declare and/or program transaction boundaries, persistence
contexts, and exception handling to properly control persistence logic.
> Apply role-based authorization policies to EJBs.
> Build interceptors to perform generic processing before, after, or around EJB business-method invocations.
> Use EJB timers to defer processing or establish regularly scheduled tasks. |
| Course Topics: |
Overview
Enterprise Applications
Containers and Objects
Three Containers
Remote Connectivity
Scalability and Availability
Security
Transaction Control
Architecture
What is an EJB?
Types of Beans
Inversion of Control
The Bean-Type Annotations
Dependency Injection
The @EJB Annotation
Development Cycle and Roles
Session Beans
Interface/Implementation Split
Stateful vs. Stateless
The @Stateless Annotation
Lifecycle and State Transitions
Session Context
The @Stateful Annotation
State Transitions
Singletons and Pools
Entities
The Java Persistence API
Persistence Annotations
Configuration by Exception
ORM Annotations
The EntityManager
Acquiring and Using the EntityManager
persistence.xml
@Enumerated and @Temporal Types
Associations
Associations, Cardinality, and Ownership
Annotations
Unidirectional vs. Bidirectional
The @Embedded Annotation
Java Persistence Query Language
OO Query Languages
The FROM Clause and Directionality
The WHERE Clause
The SELECT Clause
Joins
Aggregates and Grouping
Ordering
Dependency Injection
Interdependent Systems
The Factory Pattern
The Service Locator Pattern
Dependency Injection
Injection by Magic?
Injection by Type
Injection by Name
The Component Environment
Deployment Descriptors
Impact on Stateful Session Beans
JNDI
Connecting to a Remote Bean
Using mappedName
Who Can Declare Dependencies
Message-Driven Beans
Asynchronous Messaging
The Java Message Service
Message-Driven Beans
Message Types
Injecting JMS Queues
Transactions
ACID Transactions
The EntityTransaction Interface
EJB Transaction Attributes
Persistence Contexts
Extended Persistence Contexts
Isolation Levels
Application-Managed Persistence
The SessionSynchronization Interface
Impact on JMS and MDBs
Exception Handling
Java Exceptions
Remote Exceptions
EJB Exception Handling
System Exceptions
Application Exceptions
Transaction Control
Security
Authentication and Authorization
Declarative Authorization
Abstract Roles
Concrete Realms
Programmatic Authorization
Run-As Identity
Interceptors
EJB and AOP
The Intercepting Filter Pattern
EJB Interceptors
Annotating Interceptor Classes
The InvocationContext Interface
Binding Interceptors to Targets
Shared Lifecycle and Context
Interceptors and MDBs
Timers
The EJB Timer Service
The TimerService Interface
The Timer Interface
Timeout Methods
Timer Handles
Transactions and Timers
Appendix A. Learning Resources
Appendix B. Quick Reference: Java EE Annotations |
| Prerequisites: |
Solid Java programming skills and understanding of OO Java and Java-5 language features is essential. Experience with developing Java web applications is very helpful for this course, but not strictly required.
Some knowledge of XML will be useful for writing the occasional deployment descriptor, but is not required.
|