J2EE Design Patterns

What is a Pattern?

Patterns are a software engineering problem-solving discipline that emerged from the object-oriented community

GoF Design Patterns

The GoF described patterns as “a solution to a problem in a context.” These three elements—problem, solution, and context—are the essence of a pattern.
GoF Creational Design Patterns

Creational design patterns are concerned with the way objects are created.

Abstract Factory, Builder, Factory Method, Prototype, Singleton

GoF Structural Design Patterns

Structural patterns are concerned with composition or the organization of classes and objects, how classes inherit from each other, and how they are composed from other classes.

Adapter, Bridge, Composite, Decorator, Facade

GoF Behavioral Design Patterns

Behavioral patterns are concerned with the interaction and responsibility of objects.

Chain of Responsibility
Command, Interpreter, Iterator, Mediator, Memento, Observer
State, Strategy, Template Method, Visitor

Creational Design Patterns

Abstract Factory (Kit)

The Abstract Factory pattern’s intent is to provide an interface to use for creating families of related or dependent objects without actually specifying their concrete classes.
SCENARIO

The system needs to be independent of how its objects are created, composed, and represented.

J2EE Technology Features and J2SE API Association

J2EE Technology

Data Access Object (Sun)
Value Object Assembler (Sun)

Factory Method (Virtual Constructor)

The Factory Method pattern’s intent is to define an interface for creating an object but letting the subclass decide which class to instantiate.
In other words, the class defers instantiation to subclasses.
The client of the Factory Method never needs to know the concrete class that has been instantiated and returned. Its client needs to know only about the published abstract interface.
J2EE Technology Features and J2SE API Associations

J2EE Technology

javax.ejb.EJBHome
javax.ejb.EJBLocalHome
javax.jms.QueueConnectionFactory
javax.jms.TopicConnectionFactory

Singleton

The Singleton pattern’s intent is to ensure that a class has only one instance and provides a global point of access to it. It ensures that all objects that use an instance of this class are using the same instance.

SessionFactory in Hibernate,
Connection in JDBC

GoF Structural Design Patterns

Decorator (Wrapper)

An alternative to sub classing to extend functionality, the Decorator pattern’s intent is to attach flexible additional responsibilities to an object dynamically. The Decorator pattern uses composition instead of inheritance to extend the functionality of an object at runtime.

Facade

The Facade pattern’s intent is to provide a unified and simplified interface to a set of interfaces in a subsystem. The Facade pattern describes a higher level interface that makes the subsystem(s) easier to use. Practically every Abstract Factory is a type of Facade.

Proxy (Surrogate)

The Proxy pattern’s intent is to provide a surrogate or placeholder for another object to control access to it. The most common implementations are remote and virtual proxy.

GoF Behavioral Design Patterns

Chain of Responsibility

The Chain of Responsibility pattern’s intent is to avoid coupling the sender of a request to its receiver by giving multiple objects a chance to handle the request. The request is passed along the chain of receiving objects until an object processes it.
J2EE Technology Feature

RequestDispatcher in the servlet/JSP API

Command (Action or Transaction)

The Command pattern’s intent is to encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support rollback types of operations.
J2EE Technology Feature

MessageBeans

Iterator

The Iterator pattern’s intent is to provide a way to access the elements of an aggregate object sequentially without exposing its underlying implementation.
J2EE Technology Feature and J2SE API Association

J2EE Technology Feature

ValueListHandler

J2SE API

java.util.Enumeration
java.util.Iterator

Observer (Dependents or Publish-Subscribe)

The Observer pattern’s intent is to define a one-to-many dependency so that when one object changes state, all its dependents are notified and updated automatically.
J2EE Technology Feature and J2SE API Association

J2EE Technology

JMS (Java Message Server) Publish/Subscribe Model.

J2SE APIs

java.lang.Observable
java.lang.Observer

J2EE Patterns

The J2EE Patterns are broken down into the various sections that address the tiers (or layers) that make up an application:

Presentation Tier

The presentation tier encapsulates the logic required to service the clients accessing a system.

Business Tier

The business tier provides the services required by application clients and contains the business data and logic.

Integration Tier

This tier is responsible for accessing external resources and systems, such as relational and no relational data stores and any legacy applications.

Presentation Tier Patterns

The presentation tier encapsulates the logic required to service the clients accessing a system.
Presentation tier patterns intercept a client request and then provide facilities such as single sign-on, management of the client session, and access to services in the business tier before constructing and delivering the response back to the client
The patterns currently available for the presentation layer follow:

Composite View
Dispatcher View
Front Controller
Intercepting Filter
Service To Worker
View Helper

Business Tier Patterns

The business tier provides the services required by application clients and contains the business data and logic.
All business processing for the application is gathered and placed into this tier. Enterprise JavaBean (EJB) components are one of the ways to implement business processing in this tier.
Here are the patterns available for the business tier:

Aggregate Entity
Business Delegate
Composite Entity
Service Locator
Session Façade
Transfer Object
Transfer Object Assembler
Value List Handler
Value Object Assembler
Value Object

Integration Tier Patterns

This tier is responsible for accessing external resources and systems, such as relational and nonrelational data stores and any legacy applications.
A business tier object uses the integration tier when it requires data or services that reside at the resource level.
The components in this tier can use JDBC, J2EE connector technology, or some other proprietary software to access data at the resource level.
Here are the patterns available for the integration tier:

Data Access Object
Service Activator

Presentation Tier Patterns

Intercepting Filter

Forces

Each service request and response requires common pre-processing and post-processing

logging, authentication, caching, compression, data transformation

Adding and removing these “pre” and “post” processing components should be flexible

deployment time installation/configuration

Solution

Create pluggable and chainable filters to process common services such that

Filters intercept incoming and outgoing requests and responses
Flexible to be added and removed without requiring changes to other part of the application

Examples

Servlet filters for HTTP requests/responses
Message handlers for SOAP requests/responses

Front Controller

Forces

There is a need for centralized controller for view selection and navigation (Model 2)

based on user entered data
business logic processing
client type

Common system services are typically rendered to each request, so having a single point of entry is desirable

Example: Authentication, authorization, Logging
Can leverage filter pattern

Solution

Use a controller as an centralized point of contact for all requests

Promote code reuse for invoking common system services

Can have multiple front controllers, each mapping to a set of distinct services
Works with other patterns

– Filter, Command, Dispatcher, View Helper

View helper pattern

View helper pattern means that any logic that is not related to presentation formatting are encapsulated into helper components.

Composite view pattern

Composite view pattern means creating an aggregate view from atomic subcomponents.

Service to worker pattern

Service to worker pattern combines a dispatcher component with the front controller and view helper patterns

Business-Tier Design Patterns

Business Delegate Pattern

Forces

Business service interface (Business service APIs) change as business requirements evolve
Coupling between the presentation tier components and business service tier (business services) should be kept to minimum
It is desirable to reduce network traffic between client and business services

Solution

Use a Business Delegate to

Reduce coupling between presentation-tier and business service components
Hide the underlying implementation details of the business service components
Cache references to business services components
Cache data
Translate low level exceptions to application level exceptions

Service Locator Pattern

Forces

? Service lookup and creation involves complex interfaces and network operations

JNDI operation is complex
ex) PortableRemoteObject.narrow(.., ..)

? Service lookup and creation operations are resource intensive and redundant

Getting JNDI context

Solution

? Use a Service Locator to

– Abstract naming service usage
– Shield complexity of service lookup and creation
– Enable optimize service lookup and creation functions

? Usually called within Business Delegate object

Implementation Strategies

? Implementation strategies for Service Locator

– EJB Service Locator Strategy
– JMS Queue Service Locator Strategy
– JMS Topic Service Locator Strategy
– Combined EJB and JMS Service Locator Strategy

Data Transfer Object (Value Object)

Data Transfer Object, DTO in short, used to be called Value object. Data transfer object is an ordinary Java object that can be exchanged between tiers in order to exchange information. For example, when EJB client needs some information from EJB beans, the data should be returned in the form of Data transfer object intead of entity beans.

Data Transfer Object Assembler pattern

Data Transfer Object Assembler pattern assembles a composite value object from multiple data sources.

Composite entity pattern

Composite entity pattern represents a best practice for designing coarsegrained entity beans by grouping parent-dependent objects into a single entity bean.

Value List handler

Value List handler manages query execution, result caching, and results processing.

Integration-Tier Patterns

Data Access Object pattern

Data Access Object pattern provides an abstract layer between application and data source so that applications are shielded from data store specifics.