develop EJB components

A two-day course on developing distributed enterprise applications with the Java 2 Enterprise Edition (J2EE) platform and Enterprise Java Bean (EJB) components. Enterprise systems have never been easier to build than on the J2EE platform. This course focuses on how to be most productive with the J2EE APIs and specifications. It shows how the platform encapsulates the difficult system-level operations such as security and transaction control. Using these essential services is easy as setting properties during deployment.

All the main issues of building Java-based distributed systems are covered:

  • divide and distribute an application by business logic roles
  • control component lifecycle for scalability, performance, and reliability
  • use the advanced services of container management — CORBA benefits without the headaches
  • make component design choices - proven EJB patterns, and how to partition your applications
  • wrapper old and new legacy systems

Duration: 2 days


  • review J2EE architectures; in particular, the interaction between Web and enterprise components
  • understand the key concepts of EJB types, their composition, and behaviour
  • create, and deploy EJBs
  • examine issues of distributed components, such as lifecycle, security, and transactions
  • build an application with the J2EE SDK
  • face enterprise application design issues, such as how to decouple the data source
  • explore how to overcome limitations with EJB specific patterns

target audience

The course is suitable for Java developers/analysts who wish to extend their skills into this new and dominant market. This course is based on the J2EE platform, and the development language used is of course Java.


Ideally this course would be preceded by one or all of: design and develop Java applications, J2EE application architectures, and develop Web applications with JSP and Servlets,.

Enterprise Beans (EJBs)

Complete technical review that covers all the necessary syntax and semantics for both Entity and Session Beans.

  • standard server-side component model
  • Java RMI basis
  • home / remote interfaces and implementation
  • entity and session beans
  • container management
  • EJB as business logic nirvana
  • stateless and stateful EJBs
  • passivation

Migration to EJB

Convert from server to Enterprise Beans

  • interaction between EJB and Web tiers
  • directory services and object buses
  • registering a JNDI context
  • location transparency
  • J2EE specification for EJB containers

The role of Session Beans

Separate business logic from application control with Session Beans

  • client sessions
  • benefits of stateless Session Beans
  • business logic encapsulation
  • modelling user interaction
  • command beans: a high performance alternative
  • data access objects
  • value objects
  • fašade to Entity Beans

Using Entity Beans

Separate data from the application with Entity Beans

  • data and rules encapsulation
  • Enterprise Information Systems (EISs)
  • one row Entity Beans (single table mapping)
  • joins, views, and database issues
  • updating the model in MVC architecture
  • persisting transactions

J2EE distributed computing

Divide and distribute business logic for performance, reliability, and scalability.

  • comparisons between CORBA, DCOM, and Java RMI
  • RMI-IIOP and JavaIDL
  • lifecycle, access, and permanent storage
  • glue technologies
  • database access with JDBC and future connectors
  • object access with JNDI
  • remote access with RMI and RMI-IIOP
  • the role an OODBMS can play
  • the 'Object Web' ideal
  • basics of Component Based Design (CBD)
  • component reuse and ability to change
  • distributed object patterns: Factory, Observer, Call-back, Multiple Instance, Command and Value Object, and Reference Counting

J2EE distributed services

Manage lifecycle, transactions, and security with Enterprise Beans

  • bean managed persistence
  • component transaction management
  • Java Transaction API (JTA) and Java Transaction Service (JTS)
  • root CORBA OTS mechanics
  • accessing multiple databases: support for two-phase commit
  • transactions in Web components and initiating from the client
  • isolation levels
  • security and roles
  • serialization control

J2EE containers

Convert to using the distributed services of EJB containers

  • common business object requirements
  • container management mechanics
  • migrate from bean-managed to container-managed persistence
  • declarative Vs programmatic authorization

J2EE deployment

Create applications that can be configured during deployment to J2EE platform.

  • deployment packaging
  • JAR
  • WAR
  • EAR
  • web.xml
  • deployment descriptors
  • application Deployment Tool
  • JNDI contexts
  • adapting to a system's security architecture
  • authentication and encryption
  • J2EE connectors

Please note, when taught at your site, this course is customizable. Modules can be adapted, removed, added from other courses, or even created.


Day 1

  • Enterprise Beans (EJBs)
  • Migration to EJB
  • The role of Session Beans
  • Using Entity Beans

Day 2

  • J2EE distributed computing
  • J2EE distributed Services
  • EJB containers
  • J2EE deployment

course instructor

The course is presented by one of our senior consultants, each of whom has at least ten years' experience in software development, and at least three years' experience as a trainer and consultant in a diverse range of application areas.

print     printer-friendly version