Overview
Designed for experienced enterprise Java JEE developers, this course is a lab-intensive training course that explores the various sophisticated JEE-oriented design patterns and how to use these patterns to develop solid, robust and re-usable JEE applications. The design patterns have been significantly affected by technologies such as JPA, EJB3 and frameworks such as Spring, web services, rich interfaces, etc. The course explores basic patterns as well as advanced patterns that have now evolved into more robust solutions for secure, stable and scalable enterprise applications.
What You'll Learn
- Key patterns in different JEE layers
- How to use patterns to build robust, reusable JEE applications
- Cross-cutting patterns to address issues such as security, transactions and auditing
- Compare and contrast different JEE patterns
- Advantages and disadvantages of using certain patterns for explicit development functions in the JEE framework
- Presentation tier patterns
- Business tier patterns
- Integration tier patterns
Curriculum
- Patterns: Basics
- Why choose a design pattern?
- Patterns: What is not a pattern?
- Anti-patterns
- ‘Gang of four’ patterns
- JEE base patterns
- Patterns and principles
- Gang of four patterns
- Synopsis of GoF patterns
- Factory method
- AbstractFactory
- Singleton
- Singleton: Multithreading
- Exercise: Factory method pattern – connection
- Exercise: AbstractFactory pattern – Vehicle assembly
- Exercise: Singleton pattern – Instance counting
- Exercise: Singleton pattern – Permanent instance
- Façade
- Composite
- Adapter
- Proxy
- Exercise: Façade pattern – scanning and parsing
- Exercise: Façade pattern – timer
- Exercise: Composite pattern – display arithmetic
- Exercise: Adapter pattern – legacy connections
- Exercise: Proxy pattern – build a calculator
- Iterator
- Observer
- Command
- Exercise: Iterator pattern – DVD collection
- Exercise: Observer pattern – classroom
- Exercise: Observer pattern – cloak
- Exercise: Command pattern – change of contact
- Base patterns and GoF patterns
- Gateway
- Separated interface
- Registry
- Special case
- Exercise: Gateway pattern – awkward system
- Exercise: Separated interface pattern
- Exercise: Registry pattern – format registry
- Exercise: Special case pattern – bank account factory
- Domain model pattern
- Service locator
- Dependency injection
- Service locator vs. dependency injection
- Business delegate
- Session façade
- Application service
- Identity map pattern
- Exercise: Setup Derby
- Exercise: Domain model patterns
- Exercise: Identity map pattern
- Remote façade pattern
- Data transfer object
- Data access object
- DAO and DTO in JEE – Java persistence API
- Service activator
- Web service broker
- Exercise: DTO pattern
Model view controller pattern
- Front Controller
- Application Controller
- Combining Patterns
- Exercise: Controller Patterns
- Context Object
- Intercepting Filter
- Exercise: InterceptingFilter Pattern
- View Helper
- Composite View
- Exercise: View Helper Pattern
- Service to Worker
- Dispatcher View
- Authentication Enforcer
- Authorization Enforcer
- Intercepting Validator
- Secure Base Action
- Secure Logger
- Secure Pipe
- Secure Service Proxy
- Intercepting Web Agent
- Usefulness of Patterns
- Selecting the Right Pattern
- Adapting an Existing Pattern
- Creating a New Pattern
- Language Considerations
- Patterns and Productivity
- Frameworks
- Introduction to Spring
- What is Struts?
- Overview of the Struts 2.0 Architecture
- Exercise: Patterns Project
Who should attend
The course is geared towards intermediate-level Java EE developers and is highly recommended for –
- Backend developers
- Java developers
- Java programmers
- Software engineers
- Software programmers
- Software developers
- Application developers
Prerequisites
Participants need to have extensive working knowledge of developing basic Java applications.
