162. Introduction to EJB Version 3.0 This course introduces the experienced Java developer to Enterprise JavaBeans -- the Java EE standard for scalable, secure, and transactional Java 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. Students 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 then study entities and the Java Persistence API more deeply, and get a look at message-driven beans as well. 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 our JSF course. Prerequisites * Solid Java programming skills and understanding of OO Java and Java-5.0 language features is essential. Course 103 is excellent preparation for this course. * Experience with developing Java web applications is very helpful for this course, but not strictly required. Course 115 on JavaServer Faces makes an excellent one-week pairing with this course. * Some knowledge of XML will be useful for writing the occasional deployment descriptor, but is not required. Course 501 is recommended for those who would like to get more familiar with XML before pursuing this course. Learning Objectives * Understand 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. Timeline: 3 days. * Solid Java programming skills and understanding of OO Java and Java-5.0 language features is essential. Course 103 is excellent preparation for this course. * Experience with developing Java web applications is very helpful for this course, but not strictly required. Course 115 on JavaServer Faces makes an excellent one-week pairing with this course. * Some knowledge of XML will be useful for writing the occasional deployment descriptor, but is not required. Course 501 is recommended for those who would like to get more familiar with XML before pursuing this course. IDE Support: Eclipse 3.2 In addition to the primary lab files, an optional overlay is available that adds support for Eclipse 3.2. Students can code and compile from within the IDE; final build and deploy is done from DOS using Ant, and applications are tested using a local web browser. See also our orientation to Using Capstone's Eclipse Overlays, and please be advised that this is an optional feature; it is not a separate version of the course, and the course itself does not contain explicit Eclipse-specific lab instructions. Chapter 1. Overview Enterprise Applications Containers and Objects Three Containers Remote Connectivity Scalability and Availability Security Transaction Control Chapter 2. Architecture What is an EJB? Types of Beans Inversion of Control The Bean-Type Annotations Dependency Injection The @EJB Annotation Development Cycle and Roles Chapter 3. 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 Chapter 4. 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 Chapter 5. Associations Associations, Cardinality, and Ownership Annotations Unidirectional vs. Bidirectional The @Embedded Annotation Chapter 6. Java Persistence Query Language OO Query Languages The FROM Clause and Directionality The WHERE Clause The SELECT Clause Joins Aggregates and Grouping Ordering Chapter 7. 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 Chapter 8. Message-Driven Beans (Optional) Asynchronous Messaging The Java Message Service Message-Driven Beans Message Types Injecting JMS Queues Appendix A. Learning Resources Appendix B. Quick Reference: Java EE Annotations System Requirements Hardware, Minimum: 1 GHz, 512 meg RAM, 1 gig disk space. Hardware, Recommended: 2 GHz, 1 gig RAM, 1 gig disk space. Operating System: Tested on Windows XP Professional. Course software should be viable on all systems which support the Java EE 5.0 SDK. Network and Security: Limited privileges required -- please see our standard security requirements at http://capcourse.com/Guides/Security.gen.html. Software Requirements: All free downloadable tools.