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
The course is suitable for Java developers.
Ideally this training should be preceded by the course:
design and develop Java applications.
- evolution of multi-tier systems
- J2EE technology
- Servlets and JSP
- review of JDBC
- 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
- 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
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
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
Create applications that can be configured during deployment to J2EE platform.
- deployment packaging
- 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.
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.