Enterprise JavaBeans (EJB) Training (5 days)

Enterprise JavaBeans Overview

This course offers the Java programmer a grounding in the Enterprise JavaBeans (EJB) architecture and the skills to develop EJBs effectively for enterprise development efforts. EJB's position at the heart of the Java Enterprise platform and the use of EJB application servers as the backbone of large-scale distributed systems are studied. We consider the advantages of the application server architecture -- transaction control, security, persistence, scalability through pooling and clustering -- and study the development process for entity and session beans in depth. The J2EE reference implementation is used for all demo and lab work, and we emphasize portable EJB 2.1 code.

The focus for the first module is on end-to-end connectivity. The module follows a path roughly from the data layer to the presentation layer, so we look at entity beans first, and work demos and exercises in both Bean-Managed and Container-Managed Persistent Beans. Then the EJB session layer is considered, and both stateless and stateful session beans are developed. As part of the lab work, these are hooked to provided JSPs to illustrate the complete system and typical architecture.

NOTE: Our JSP and Servlets courses are excellent companions to this course, and in fact the primary lab track for this module is an extension of the JSP module's labs.

Students then proceed to the second module, which begins with some 2.x-specific features, such as message-driven beans and the features of 2.x container-managed persistence. Two EJB applications are connected via JMS messaging, one sending messages with raw JMS code, and one using a message-driven bean to receive and handle those messages by updating an accounting database. Design implications of CMP are discussed, as are the new capabilities for EJB design: home and select methods.

Students then move on to study declarative and programmatic transaction control. The EJB security architecture is also considered, and a simple role-based authorization design applied to the course's main lab project. A short chapter on exception handling in EJB clarifies the standards for exception propagation and transaction control.

The next chapter introduces the new features in EJB 2.1 for implementing SOAP-based Web services, using the JAX-RPC mappings between Java and WSDL. Also new for 2.1, there is a short chapter on using the EJB timer service. The course concludes with a chapter on best-practice EJB development: optimizations, design patterns and implementation techniques.

The course software also includes an optional overlay of workspace and project files to support use of the Eclipse IDE in the classroom. (This requires that the instructor be experienced in use of Eclipse and able to walk students through basic tasks in the IDE.)

Enterprise JavaBeans Course Goals

• Understand the role of Enterprise JavaBeans in enterprise-level systems development, and its relationship to other J2EE technologies such as JSP, servlets, JMS, CORBA, and XML.
• Understand the EJB architecture: the role of the EJB container in mediating contact between the client and the bean, transaction control, authorization control, and the importance of object pooling.
• Understand the development cycle for EJBs: Java source code and compilation, XML deployment descriptors, EJB compilation and deployment, and use by an application server.
• Understand the role of entity beans, session beans, and message-driven beans: their lifecycle and interactions with the container.
• Develop and test BMP and CMP entity beans and understand the importance of each of the entity-bean methods in assisting the container in pooling.
• Develop and test stateless and stateful session beans and effectively manage passivation/activation cycles.
• Use the bean context interfaces to assist with persistence code and to correctly establish bean-to-bean communication.
• Use 2.x container-managed persistence and make intelligent design choices based on the practical implications of BMP and CMP features.
• Implement 2.x CMP entity bean relationships.
• Understand the EJB transaction architecture and apply transaction attributes to EJB systems, using both declarative and programmatic approaches.
• Understand the EJB security architecture and apply roles and authorization attributes to EJB systems -- again, using both declarative and programmatic techniques.
• Implement SOAP-based Web services using stateless session beans and JAX-RPC, and understand the relationship between JAXM and message-driven beans.
• Create and respond to EJB timers in bean code.
• Tune EJB application servers and EJB code for performance.
• Understand and apply design patterns that are important to common distributed systems and EJB systems in particular.

Enterprise JavaBeans Course Prerequisites

Experience in the following areas is required:

• Solid Java programming experience is a must. Our Java Programming
• Some experience with distributed systems development, especially object-based systems such as Java RMI, CORBA, or COM is a plus.
• Some knowledge of JDBC is helpful in understanding the EJB persistence model. Understanding of XML is a plus but is not needed.

Enterprise JavaBeans Course Outline

1. Introduction to EJB
   1. The EJB Architecture
      1. EJB and the Java Enterprise Platform
      2. EJB and CORBA
      3. EJB Costs and Benefits
      4. What is an EJB?
      5. Entity, Session, and Message-Driven Beans
      6. EJB Roles
      7. The EJB Container
      8. The Home and EJB Objects
      9. EJB Development
      10. Remote Interface
      11. Home Interface
      12. Bean Class
      13. Remote, Local, and Web-Service Component Interfaces
      14. Multiple Maintenance Points
      15. Using JNDI in EJB
   2. Entity Beans: Bean-Managed Persistence
      1. Persistence Mechanism
      2. Instance versus Incarnation -- Similarities to the CORBA PSS
      3. EntityBean Interface and Responsibilities
      4. Entity Bean Interactions, Lifecycle and State Transitions
      5. Primary Keys
      6. EntityContext Interface and Discovering the Primary Key
      7. Creation and Removal
      8. Load and Store
      9. Finder Methods
      10. Eager vs. Lazy Persistence
   3. Entity Beans: Container-Managed Persistence
      1. Two Contracts for Persistence
      2. Declaring a Data Source
      3. Declaring Persistent Fields
      4. Implementing Finder Methods
      5. What the Container Does
      6. 1.1 Architecture
      7. 2.0 Architecture
      8. CMP Limitations
   4. Stateless Session Beans
      1. Session Beans and the Presentation Layer
      2. Stateful vs. Stateless Sessions
      3. Stateful Session Bean Interactions, Lifecycle and State Transitions
      4. Stateless Session Bean Interactions, Lifecycle and State Transitions
      5. Finding Entity Beans
      6. Passing Value Objects
   5. Stateful Session Beans
      1. Stateful Session Beans
      2. Object Pooling and Passivation/Activation
      3. Activation and Passivation
      4. Choosing Between Stateful and Stateless
2. Effective EJB
   1. Message-Driven Beans
      1. Asynchronous Messaging
      2. The Java Message Service
      3. Message-Driven Beans
      4. Lifecycle of a Message-Driven Bean
      5. Implementing Message-Driven Beans
      6. Messages and Transactions
      7. Message-Driven Beans and Transactions
   2. Persistence
      1. BMP and CMP
      2. Container-Managed Relationships
      3. EJB Query Language
      4. Declaring Finder Methods
      5. Declaring Select Methods
      6. Calling ejbSelect Methods from Bean Code
      7. Home Methods
      8. Design Considerations
   3. Security
      1. The Need for Security
      2. Authentication
      3. Authorization Model
      4. Declarative Authorization and Roles
      5. Abstract Roles and Application Assembly
      6. Actual Roles and Deployment
      7. Programmatic Authorization
      8. Identifying the Caller
   4. Transactions
      1. The Need for Transactions
      2. ACID Properties
      3. Declarative Transactions
      4. Transaction Attributes and Isolation Levels
      5. Scenarios
      6. Programmatic Transactions
      7. EJB Context and Monitoring the Transaction
      8. SessionSynchronization Interface
   5. Web Services and EJB
      1. SOAP-Based Web Services
      2. WSDL
      3. JAX-RPC
      4. EJB 2.1 and JAX-RPC
      5. Session Beans as Web Service Endpoints
      6. How It Works -- Build Time and Runtime
      7. The Bean's Service Endpoint Interface
      8. SOAP as an RMI Transport
      9. Adding a SOAP Interface to a Session Bean
      10. Generating From WSDL
      11. "Gotchas"
      12. J2EE and Web Services
   6. Exception Handling
      1. Java Exceptions
      2. Remote Exceptions
      3. EJB Exceptions
      4. Application Exceptions
      5. Propagation to the Client
      6. System Exceptions
      7. Automatic Transaction Rollback
   7. The Timer Service
      1. Uses for Timers
      2. The EJB Timer Service
      3. Service, TimedObject and Timer Interfaces
      4. Timer Handles
      5. Creating a Timer
      6. Implementing ejbTimeout
      7. Timers and Transactions
   8. Best Practices
      1. The Bean Environment
      2. Expressing UML Designs for EJB
      3. Creation and Finder Semantics
      4. Designing for Latency
      5. Value Object Pattern
      6. Local vs. Remote Beans and the Façade Pattern
      7. Transaction Models
      8. When Not to Use EJB
      9. Flyweight Pattern versus EJB Pooling
      10. Entity Bean Performance Optimizations

Enterprise JavaBeans Course Materials

In addition to a comprehensive set of materials, including course notes and all the programming examples, each student will also receive a one-year subscription to Webucator's online reference library, which contains hundreds of the most current electronic technology books - a $149.95 per student value.

Enterprise JavaBeans Technical Requirements

Complete Setup Instructions