J2EE Patterns

Code: J2EEP

Duration: Days 3

Delivery methods:

Price per delegate: $750.00

Trained over 60000 delegates

Delivered by world class instructors

Highly competitive pricing

Capped class sizes

Post course support

Course Description

A Pattern-Based Approach to Effective Java EE Application Design. There is a lot of technology in the Java 2 Enterprise Edition (Java EE) platform. To successfully design applications for the Java EE platform requires a good understanding of these technologies from Enterprise JavaBeans through to JavaServer Pages. However, it is not enough just knowing the mechanics of the different technologies. As people have deployed Java EE-based applications, many good practices have been identified (and quite a few bad ones). These good practices have been encapsulated in several Java EE pattern catalogs and blueprints. This training course examines the primary patterns from these catalogs and explores how Java EE applications can be built around these patterns.

Target Student:

Architects, designers and developers who need to design and implement Java EE applications.

Prerequisites:

Familiarity with the Java Programming Language
Experience with the Java EE platform

Delivery Method: Instructor led, group-paced, classroom-delivery learning model with structured hands-on activities.

The training course combines lectures with practical exercises that help the delegates to put what they have learned on the training course into practice. The exercises specifically build on what has been recently taught and are built up as the training course progresses.

Performance-Based Objectives

At the end of this training course, students should be able to:

List many of the principal Java EE patterns
Assess the suitability of a particular pattern in a given context
Describe how these patterns can be implemented
Use Java EE patterns as part of application design
Describe the Java EE Blueprints and how these use patterns
Understand the current state of Java EE patterns and list the major Java EE pattern resources

Course Content

Context of Java EE Applications

Java EE technology quick refresher
Target application types for Java EE
Java EE application architecture
Hardware context: layers and tiers
Improving the "ilities" (scalability, availability, etc.)

2. Java EE Patterns and Blueprints

Pattern forms and relationships
Why the GoF (and POSA, etc.) are not enough
Benefits and dangers of patterns
Java EE patterns and where they fit in
Quick tour of major Java EE patterns
Patterns and refactoring
Java EE blueprints: what are they and why are they there?

3. Distributed Pattern Principles

Why are distributed systems different?
Reducing data flow: Data Transfer Object
Minimizing roundtrips: Batch Method and Combined Method
Proxies, decoupling and caching
Flexibility through dynamic discovery: Service Locator
Server-side decoupling: Remote Facade

4. Web Presentation Patterns

Applying the Web processing model
What can go bad in the Presentation Layer: a bad example
Factoring out: Front Controller, View Helper, Template View
Model View Controller in a Java EE Web application
MVC variations: Page Controller, Dispatcher View, Service to Worker, Intercepting Filter
Building the output: Composite View, Two Step View, Transform View
Controlling the flow: Application Controller
Session state: the issue, Client Session State, Server Session State, Database Session State
Bad example refactored

5. Business Component Patterns

Business components and the Java EE model
What can go bad in the Business Layer: another bad example
Splitting domain and business logic: Transaction Script, Domain Model, Service Layer
Business components, EJBs and transactions
Distribution and decoupling: Session Faï¿½ade, Business Interface
Asynchronous interaction: Message Faï¿½ade, Service Activator
Client interaction: Business Delegate, EJB Command
Managing business data: Composite Entity
Data in and out: Data Transfer Object Factory
Bad example refactored

6. Persistence and Integration Patterns

What can go bad in the Persistence Layer: yet another bad example
Types of data
Structuring data access: Data Access Object, Row Data Gateway, Active Record, Data Mapper,
Object to relational mapping patterns
Primary key generation patterns
Improving performance: Fast Lane Reader, Value List Handler, Lazy Load
State, updates and transactions: Unit of Work
Distributed locking: Optimistic Offline Lock, Pessimistic Offline Lock
Enterprise application integration: Channel patterns, message patterns, routing patterns
Bad example refactored

7. Applications, Java EE Blueprints and Patterns