DT offers a core set of courses aimed at covering the Application Lifecycle, from requirements gathering, analysis and design to development, testing, process and project management.

Writing Advanced EJB 2.1 Applications Developer's Workshop - Application Lifecycle Trainin

Course Overview
This course is "the" EJB2.1 course available. It covers everything you need to know to develop Enterprise Java Beans applications. Session Beans, Entity Beans, Message Driven Beans, Web Service endpoint Session Beans are all covered in great depth. Not a single technology from the specification is left out. All technologies used are portrait on their architectural role. Best practices and patterns are explained throughout the course. The exercises are all around an online shopping cart for an Outdoor store. Use the web application server of your choice to develop and deploy EJB's.
 

What will I learn?
This an intermediate to advanced level Java training course, designed for developers who need to get up and running with advanced EJB programming skills immediately.

Ideally, advanced EJB students should have at least one year of application development experience, preferably in two and three tier distributed application, as well as some familiarity with the architecture of client-server systems. Experience with developing database applications will be helpful.
Detailed description

Designed for enterprise developers who wish to implement server-side business objects in Java, this lab-intensive training provides students with a solid understanding of the essential of EJB using sound coding techniques and best programming practices.

Our training is technology centric. Although a specific application server product will be used throughout the course, the comprehensive labs and lessons geared towards teaching advanced EJB programming techniques, rather than focusing on the finer points of the tools in use.

This course is currently offered using any EJB2.1 or 2.0 compliant Application Server (BEA® WebLogic® Application Server; Borland Application Server; iPlanet; JBoss; Sun Microsystems™’ J2EE Reference Implementation or IBM WebSphere, with or without the WSAD) . If your team is reviewing or using another server technology, we can modify our labs to run in the environment of your choice. Our dedicated curriculum development team can easily customize our offerings to best suit your specific requirements. If your team is reviewing or using another server technology, we can modify our labs to run in the environment of your choice. Our dedicated curriculum development team can easily customize our offerings to best suit your specific requirements.
 

Course Style
Throughout this five-day workshop students will be led through a series of progressively advanced topics, where each topic consists of lecture, group discussion, comprehensive hands-on lab exercises, and lab review. This training is about 50% hands-on lab and 50% lecture. Over 20 complete lab projects are laced throughout the course, designed to reinforce fundamental skills and concepts learned in the lessons. Because these lessons, labs and projects are presented in a building block fashion, students will gain a solid understanding of not only the core concepts, but also how all the pieces fit together in a complete multi-tier internet business application.

Course Contents
Session: Enterprise Architectures and a Justification for using J2EE

* Lesson: The Technical Enterprise Architecture
* Lesson: J2EE as a Candidate Framework for your Architecture
* Lesson: J2EE vendors and market

Session: Java Naming and Directory Interface™ overview

* Lesson: Introduction to JNDI

Session: Introduction Enterprise JavaBeans

* Lesson: Introducing Enterprise JavaBeans™
* Lesson: Components of EJB Architecture

Session: Writing a Session Bean

* Lesson: Writing Remote Interfaces for remote client view
* Lesson: Writing the Bean Class
* Lesson: Exception Handling
* Lesson: Writing Local Interfaces for local client view (Optional)
* Lesson: Deploying a Session Bean
* Lesson: Timer Service (optional)
* Lesson: Writing and deploying a Session Bean as a Web service (Optional)

Session: Using EJB from the Web tier

* Lesson: Writing an EJB Client
* Lesson: The Business Delegate pattern (Optional)

Session: Writing Entity Beans

* Lesson: Introduction to Entity Beans
* Lesson: Writing BMP Entity Beans
* Lesson: Writing CMP Entity Beans
* Lesson: Container Managed Relationships (Advanced)

Session: J2EE Transactions

* Lesson: Fundamentals of Transactions
* Lesson: Container-managed Transactions
* Lesson: Bean-managed Transactions

Session: Security

* Lesson: Enterprise Java Beans Security

Session: Messaging

* Lesson: Introduction to JMS
* Lesson: Programming JMS
* Lesson: EJB2.1 Message-Driven Beans

Detailed overview
Enterprise Architectures and a Justification for using J2EE
Lesson: The Technical Enterprise Architecture

* Define the Enterprise (Technical) Architecture and its relationship to Project Architectures.
* List the four technical characteristics/requirements of an Technical Enterprise Architecture.
* Understand how the non-functional requirements find their way through the Technical Architecture.
* For each of the four requirements list possible solutions.
* For each of these solutions, list possible technical approaches.
* Understand the challenges involved with these approaches.
* Understand the nature and reason for the technical challenges that were created.
* Explain what Middleware can address and what other challenges it brings to the table.
* Explain the need for a Framework.
* Introduce two Frameworks: .Net and J2EE

Lesson: J2EE as a Candidate Framework for your Architecture

* Get a brief introduction of the J2EE Framework within this context.
* Recap the J2EE Framework architecture.
* Recap the Technical Architecture challenges and recap the technical solutions.
* For each of the technical solutions previously described, understand how J2EE can address these (or help you).
* Main goal of this part is to determine a foundation for choosing J2EE as the technical framework for your project or EA.
* Overview of the complete architecture briefly touching all tiers and their associated J2EE and J2SE technologies.

Lesson: J2EE vendors and market

* List some of the important players in the J2EE Application Server region
* Through the list of players, describe the different types of Servers
* Discuss criteria for choosing an Application Server

Java Naming and Directory Interface™ overview
Lesson: Introduction to JNDI

* Understand what JNDI is intended for
* Understand what a Naming service is
* Understand what a Directory service is
* Understand the overall architecture of JNDI
* Understand what is bundled in JNDI
* Understand what you can store in N&D services.
* Understand the JNDI terminology
* Get a feeling on where to apply JNDI

Introduction Enterprise JavaBeans
Lesson: Introducing Enterprise JavaBeans™

* Position J2EE and Enterprise JavaBeans
* Explain the need for Enterprise JavaBeans
* Define purpose of Enterprise JavaBeans.
* Understand the key features of the EJB Specification.
* Explain how EJB and CORBA relate
* Explain how EJBs relate to "ordinary" JavaBeans.

Lesson: Components of EJB Architecture

* List the four client types
* List the primary components in an EJB server.
* List services the container may provide to the bean.
* List the four components the EJB developer is responsible for providing.
* Describe ways session, entity and message driven beans differ.
* Describe the relationship between Web Services and Enterprise Java Beans
* Describe the purpose of the EJB jar file.
* List the mandatory four objects per bean included in an EJB jar file.

Writing a Session Bean
Lesson: Writing Remote Interfaces for remote client view

* List the super classes for your home and remote interfaces.
* Understand the life-cycle of a session bean
* Add a session bean in WSAD
* Describe the four methods provided to clients by the superclass to your home interface.
* Describe the five methods provided to clients by the superclass to your remote interface.
* Name the one exception that all methods in both interfaces must declare, and explain why.
* Explain why a bean does not implement these interfaces.

Lesson: Writing the Bean Class

* List the four methods in the SessionBean interface.
* List the sequence of six steps that are performed to create a session bean instance in the server.
* Describe the difference between a stateful and a stateless session bean.
* Explain how the bean provider specifies the state management type.
* Explain one advantage of stateful session beans.
* Explain one advantage of stateless session beans.

Lesson: Exception Handling

* Explain the differences between a system error and an application error.
* Explain which exceptions should be thrown to indicate system errors.
* Explain which exceptions should be thrown to indicate application errors.
* Describe how the container handles exceptions thrown by a bean.

Lesson: Writing Local Interfaces for local client view (Optional)

* Write local interfaces for an enterprise bean.
* Name two advantages of local interface access.
* Name one disadvantage of local interface access.

Lesson: Deploying a Session Bean

* Name the four significant values that make up the structural information for a bean.
* Show how to add environment information to the deployment descriptor.
* Add bean and resource factory references.
* Show how to provide assembly information, resolving references to external beans, web services and resource factories.
* List three values the deployer cannot change.
* Write a deployment descriptor for a session bean.
* Successfully deploy a session bean to a server.
* Control sessionbean lifetimes in WebSphere
* Manage bean caching strategies in WebSphere
* Define WebSphere's Activty sessions

Lesson: Timer Service (optional)

* Understand the concept of Timer Services
* Introduce the API

Lesson: Writing and deploying a Session Bean as a Web service (Optional)

* Show an example of how to implement a web service as a Stateless Session Bean
* Show how to write the web service endpoint
* Show how to write the Session Bean implementation for a web service endpoint
* Understand the restrictions placed upon the arguments and return types.
* Understand which clients can access your bean
* Understand the relationship between JSR109 and JSR153

Using EJB from the Web tier
Lesson: Writing an EJB Client

* How to locate the home object.
* Create a session bean instance using the home object.
* Invoke the bean's business methods.
* How to pass and return values.
* Correctly handle bean exceptions in the client.

Lesson: The Business Delegate pattern (Optional)

* Understand the Business Delegate Pattern
* Understand the benefits of the Business Delegate pattern
* Understand how to implement the Business Delegate pattern

Writing Entity Beans
Lesson: Introduction to Entity Beans

* List and explain the two persistence management techniques.
* List the two additional methods in the Entity Bean interface, and explain their purpose.
* Describe what it means to load and store a bean.
* Explain the five requirements for defining a primary key.

Lesson: Writing BMP Entity Beans

* Write a BMP entity bean that correctly maintains the state.
* Correctly define finder methods in your bean.
* Correctly declare finder methods in your home interface.
* Write a deployment descriptor that represents your entity bean.

Lesson: Writing CMP Entity Beans

* Write a CMP Entity bean that correctly maintains the state.
* Write a deployment descriptor that represents your entity bean.
* Name the language used to describe queries.
* Name the two method types that rely on this query language.
* Understand this language

Lesson: Container Managed Relationships (Advanced)

* Describe container managed relationships
* Explain types of relationships
* Explain a bidirectional relationship
* Explain a unidirectional relationship
* Explain cascade delete
* Understand how to traverse over relationships in EJB-QL

J2EE Transactions
Lesson: Fundamentals of Transactions

* Describe the need for transaction control.
* Explain isolation levels.
* List the four isolation levels.
* Explain which isolation levels should be used.
* List the three styles of transaction management.

Lesson: Container-managed Transactions

* List the six transaction attributes.
* Name the tag/value pair used in DD to specify CMT.
* List which methods of session/entity beans require transaction attributes to be specified in DD.
* Explain how a bean would roll back a transaction.
* Explain how transactions influence the container-managed transaction.
* Explain the purpose of the SessionSynchronization interface.
* Describe how each of the three methods in this interface provides transaction control to your bean.

Lesson: Bean-managed Transactions

* Correctly indicate in the DD that the bean will be managing its own transactional state.
* Use the appropriate API in the bean to create and terminate transactions.
* Explain the issues of BMT with stateful/stateless session beans.
* Explain the issues of BMT with entity beans.

Security
Lesson: Enterprise Java Beans Security

* Define users, principals and roles.
* Describe what security information is placed in DD.
* Explain how container may provide security implementation.
* List the supported security domains in WebSphere
* Understand how to bound roles to users/groups in WebSphere

Messaging
Lesson: Introduction to JMS

* Understand what JMS is
* Understand what JMS can be used for

Lesson: Programming JMS

* Understand the JMS API
* Know the different message Domains
* Understand the difference between Queues and Topics
* See how to program a queue sender and receiver
* Know the different messages
* Understand message acknowledgment
* Understand JMS Transactions
* Understand the message header
* Understand how to implement different messaging models

Lesson: EJB2.1 Message-Driven Beans

* Name the two interfaces implemented by message-driven beans.
* Explain why message-driven beans do not have home or remote interfaces.

Hands-on lab exercises

1. Write the Membership bean remote interfaces-Learn how to write the remote interfaces of a Session Bean
2. Write the Session Bean-Learn how to write the bean implementation
3. Deploying the Session Bean -The objective of this exercise is to understand Session Bean deployment.
4. Accessing an EJB from a Web tier-The objective of this (optional) exercise is understand how to write an EJB client. It will also recap JSP and Servlet Development using the Model2 architecture.
5. Implement a BMP Entity Bean-Understand how to develop a BMP Entity Bean
6. Write the CMP Member Bean-Understand how to write and deploy a CMP Entity Bean.
7. Implement CMR-Understand how to use CMR
8. Apply CMT to the realization of two use-cases.-Understand how to configure CMT in a real-life application
9. Create a Producer and Consumer JMS Clients-To understand how to write a consumer and a producer JMS client
10. Develop and Deploy a MDB-Understand how to write and deploy a MDB
 

Prerequisites
This an intermediate to advanced level Java training course, designed for developers who need to get up and running with advanced EJB programming skills immediately. Ideally, advanced EJB students should have at least one year of application development experience, preferably in two and three tier distributed application, as well as some familiarity with the architecture of client-server systems. Experience with developing database applications will be helpful. We will explore the database APIs, but the more you know coming in, the better off you will be. Students with less than two years of Java programming experience who are seeking less complex EJB exercises may wish to consider the Fast Track to Writing Core EJB Applications workshop, which is a three-day subset of this course.

Recommended Follow-On Courses
This course covers advanced EJB topics, so you may wish to cover other essential components of the J2EE technology such as Java Servlets & JavaServer Pages, or simply survey these technologies in our Fast Track to J2EE course.

Duration
5 days