develop service-based web applications

This course covers the collaborations between the elements of the J2EE platform. In particular, how JSP and Servlet-based Web applications link with enterprise components in EJB. The result is service-based Web applications. All the main issues of building service-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: 3 days


  • uncover the essentials of the Java solution to building service-based Web applications
  • show the role of Java Web and enterprise technologies - Servlets, JSP, JNDI, and EJB
  • code interactions between Java Web components 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
  • 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.


Ideally this training should be preceded by the course: design and develop Java applications.

J2EE platform

  • evolution of multi-tier systems
  • J2EE technology
    • Servlets and JSP
    • review of JDBC
    • EJB
    • JNDI
  • the rise and rise of application servers

Web and enterprise architectures

  • Web-based applications with Servlets and JSP
  • EJB enterprise component architecture
  • state management
  • life-cycle of J2EE objects

J2EE technology collaborations

  • the common language solution
  • Servlet chains
  • JSP tag libraries
  • EJB accessibility

Distributed application design

  • EJB properties
    • security
    • persistence
    • built in performance, e.g. load balancing
    • transaction control
    • setting properties at deploy time
  • overview of EJB design patterns
  • wider issues of remote invocation

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

  • J2EE platform
  • Web and enterprise architectures
  • J2EE technology collaborations
  • Distributed application design

Day 2

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

Day 3

  • J2EE distributed computing
  • J2EE distributed services
  • EJB containers
  • J2EE deployment

course instructor

The course is extremely practical, developed and taught by consultants with at least ten years' experience in software design. When taught at your site, this modular course can be adapted to your situation and requirements.

print     printer-friendly version