Design Patterns

(source: Core J2EE Patterns

written by Alur, Crupi, Malks)

1
 Sang Shin
sang.shin@sun.com

Technology Evangelist
Sun Microsystems, Inc.
2
Agenda
● Presentation tier design patterns
● Business tier design patterns
● Integration tier design patterns

3
Core J2EE Patterns

J2EE Pattern Catalog

4
Three Tiers

Presentation Business Integration

Tier Tier Tier

5
Presentation-Tier Patterns
● Intercepting Filter
● Front Controller
● View Helper
● Composite View
● Service to Worker

6
Business-Tier Patterns
● Business Delegate
● Service Locator
● Session Facade
● Data Transfer Object (DTO)
– (was Value Object)
● Data Transfer Object Assembler
– (was Value Object Assembler)
● Composite Entity
● Value List Handler
7
Integration-Tier Patterns
● Connector
● Data Access Object
● Service Activator

8
Presentation-Tier
Design Patterns

9
Presentation Tier Processing

Pre/Post- Control
Client Display Business
Processor Logic Service

Intercepting
Filter

10
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
11
Intercepting Filter: 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

12
Intercepting Filter:
Class Diagram
Target_Resource
Consumer

Service request intercepted FilterManager

by FilterManager

Filter One

FilterChain
Filter Two

13
Intercepting Filter Pattern
Sequence Diagram
Compression
Consumer SecurityFilter LoggingFilter FrontController
Filter

Incoming
Request
Apply

Forward request

Apply

Forward request
Complete Request
Processing
Response

Apply
Forward response

Outgoing Apply
response

14
 Intercepting Filter Pattern
Sample code for writing Servlet 2.3 Filter
Public final class SecurityFilter implements Filter{
Sample Deployment Descriptor
public void doFilter(ServletRequest req,
ServletResponse res,
FilterChain chain)
throws IOException, ServletException{
// Perform security checks here
.....

// Complete the filter processing by either passing the control

// to the next servlet filter in chain or to the target URI.
chain.doFilter(modified_req, modified_res);
}
}

<filter-mapping>
<filter-name>SecurityFilter</filter-name>
<servlet-name>ControllerServlet</servlet-name>
</filter-mapping>
15
 Presentation Tier Processing

Pre/Post- Control
Client Display Business
Processor Logic Service

Intercepting Front
Filter Controller

16
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
17
Front Controller: 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

18
Front Controller:
Implementation Strategy
Consumer Controller
Sends Service request

<<JSP Front Strategy>> <<Servlet Front Strategy>>

JSPController ServletController

19
Front Controller Sample Code
Servlet-based Implementation
Public class EmployeeController extends HttpServlet{
Sample Deployment Descriptor
//Initializes the servlet
public void init(ServletConfig config) throws ServletException{
super.init(config);
}
//Destroys the servlet
public void destroy(){}

//Handles the HTTP GET Requests

protected void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, java.io.IOException{
processRequest (request, response);
}

//Handles the HTTP POST Requests

protected void doPost(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException{
processRequest (request, response);
}
20
Front Controller Sample Code
Servlet Front Controller with Command Pattern
Sample Deployment Descriptor
//Processes requests for HTTP Posts and Gets
protected void processRequest(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException{
String resultPage;

// Create a RequestHelper object that represent the client request specific information
RequestHelper reqHelper = new RequestHelper(request);

/********************************************************************
* Create a Command object. Command object is an implementation of the Command
* Pattern. Behind the scenes, implementation of getCommand() method would be like
* Command command = CommandFactory.create(request.getParameter("op"));
********************************************************************/
Command command= reqHelper.getCommand();

// Command performs the actual operation

resultPage = command.execute(request, response);

// Dispatch control to the view

dispatch(request, response, resultPage);
}

21
Front Controller Sample Code
Servlet Front Strategy with Dispatch Pattern
//Implement the dispatch method
Sample Deployment Descriptor
protected void dispatch(HttpServletRequest request,
HttpServletResponse response, String page)
throws ServletException, IOException {
RequestDispatcher dispatcher
= getServletContext().getRequestDispatcher(page);
dispatcher.forward(request, response);
}
}

22
 Business-Tier
Design Patterns

23
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
24
Business Delegate Pattern:
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
25
Business Delegate Pattern:
Class Diagram
BusinessDelegate BusinessService
1 Uses 1..*

LookupService
Lookup / create

26
Business Delegate Pattern
Sequence Diagram
Business Lookup Business
Client Delegate Service Service

1. Create
1.1 Get service
1.1.1 Lookup
1.1.2 Return business
service

2. Invoke
2.1 Invoke

2.2 Invoke

27
Business Delegate Pattern
Implementation Strategies
● Delegate Adapter Strategy
– Integrating two disparate systems require an
Adapter
● ex) Adaptor changes XML request to native

request
● Delegate Proxy Strategy
– Business Delegate proxies to the Session bean it is
encapsulating
– May cache necessary data such as home or remote
object handles to improve performance
28
Business Delegate Pattern
Sample Code using Delegate Proxy
public class ResourceDelegate{

// Reference to Session facade EJB object

private ResourceSession objResourceSession;

// Session facade's home object class

private static final Class homeClass
= myExamples.resourcesession.ResourceSessionHome.class;

// Default constructor. Looks up Session facade home object

// and then creates Session facade EJB object
public ResourceDelegate() throws ResourceException{
try{
ResourceSessionHome resourceSessionHome =
(ResourceSessionHome)ServiceLocator.getInstance().getHome(
"Resource", homeClass);
objResourceSession = resourceSessionHome.create();
}catch(ServiceLocatorException ex){
//Translate ServiceLocator Exception into an Application Exception
throw new ResourceException(...);
}
... 29
Business Delegate Pattern
Sample Code using Delegate Proxy
// Another constructor that accepts a Handle ID and reconnects to the a priori
// obtained session bean instead of creating new one
public ResourceDelegate(String id) throws ResourceException{
super();
reconnect(id);
}

// Method to reconnect using Session facade EJB object

public void reconnect(String id) throws ResourceException{
try{
//Obtain an instance of ServiceLocator object
ServiceLocator objServiceLocator = ServiceLocator.getInstance();

// Obtain the service that corresponds to the given ID. Each ID

// corresponds to serialized EJBObject handle
objResourceSession
= (ResourceSession)ServiceLocator.getService(id);
}catch(ServiceLocatorException ex){
//Translate the Remote Exception into an Application Exception
throw new ResourceException(...);
}
} 30
Business Delegate Pattern
Sample Code using Delegate Proxy
// Business methods proxied to the Session Facade. If any service exception arises, these methods
// convert them into application specific exceptions such as ResourceException, SkillSetException, etc.
public ResourceVO setCurrentResource(String resourceId) throws ResourceException{
try{
return objResourceSession.setCurrentResource(resourceId);
}catch(RemoteException ex){
throw new ResourceException(...);
}
}

public ResourceVO getResourceDetails() throws ResourceException{

try{
return objResourceSession.getResourceDetails();
}catch(RemoteException ex){
throw new ResourceException(...);
}
}

//Remaining proxy methods to session facade ResourceSession

...
}

31
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

32
Service Locator Pattern:
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
33
Service Locator Pattern:
Class Diagram
Client <<Singleton>>
Component ServiceLocator
1 Uses 1..*

Creates
Uses

InitialContext

Uses
Uses

Lookup
BusinessService
Uses ServiceFactory

Lookup / create

34
Service Locator Pattern:
Sequence Diagram
Client ServiceLocator InitialContext ServiceFactory BusinessService

1. Get Instance 1.1 Create

2. Get Service
2.1. Lookup

2.1.1 Create
2.1.2 Return

EJBHome

2.2 Get Service

2.2.1 Creates
2.3 Return
service

35
Service Locator Pattern:
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

36
Service Locator Pattern
Sample code using EJB Service Locator
public class ServiceLocator
{
private static ServiceLocator me;
InitialContext context = null;

private ServiceLocator() throws ServiceLocatorException{

try{
context = new InitialContext();
}catch(NamingException ex){
throw new ServiceLocatorException(...);
}
}

// Returns the instance of ServiceLocator class (singleton)

public static ServiceLocator getInstance() throws ServiceLocatorException{
if (me == null){
me = new ServiceLocator();
}
return me;
}

37
Service Locator Pattern: Sample code
using EJB Service Locator Strategy
// Convert the given string into EJB Handle and then to EJB Object
public EJBObject getService(String Id) throws ServiceLocatorException {
if (Id == null){
throw new ServiceLocatorException(...);
}

try{
byte[] bytes = new String(Id).getBytes();
InputStream io = new ByteArrayInputStream(bytes);
ObjectInputStream is = new ObjectInputStream(io);
javax.ejb.Handle handle = (javax.ejb.Handle)is.readObject();
return handle.getEJBObject();
}catch(Exception ex){
throw new ServiceLocatorException(...);
}
}

// Returns the string Id that represents the given EJBObject's handle

// in serialized format
public String getId(EJBObject session) throws ServiceLocatorException {
...
} 38
Service Locator Pattern
Sample code using EJB Service Locator Strategy
// Converts the serialized string into EJBHandle and then to EJBObject
public EJBHome getHome(String name, Class homeClass)
throws ServiceLocatorException{
try{
Object objRef = context.lookup(name);
EJBHome home
= (EJBHome)PortableRemoteObject.narrow(objRef,
homeClass);
return home;
}catch(NamingException ex){
throw new ServiceLocatorException(...);
}
}

// Other methods pertaining to getting service using a string ID or

// getting a string ID based on the given service
...
}

39
Service Locator Pattern
Client code using EJB Service Locator
public class SampleServiceLocatorClient{
public static void main(String[] args){
ServiceLocator objServiceLocator = ServiceLocator.getInstance();
try{
ResourceSessionHome objResourceSessionHome
= (ResourceSessionHome)objServiceLocator.getHome(
myExamples.resourcesession.ResourceSessionHome.class);
}catch(ServiceLocatorException ex){
// Client handles exception
...
}
}
}

40
Ways to use Patterns
● 11. Building new architectures
● 22. Analyzing existing architectures
● 33. Refactoring existing architectures
●
44. Evangelizing Technology using
patterns

41
BuildBuilding New Architectures:
eBay.com
Service Business
Request Handler
Interface Service
Request

Client
Navigation & Dispatch

XML
Response

View Processor XSL

42
Build
1 eBay.Com: Decomposition
Request Handler
Pre & Post
Processor Command Service Business
Processor Interface Service
Request
Request Processor

Navigation & Dispatch

Client
Request
Navigator
Dispatcher
XML
Response
View Processor

View Preparer View Creator XSL

43
Build
1 eBay.com: Applied Patterns
Request Handler Service
Interface
Intercepting Front Business Business
Filter Controller Command Service
Delegate
Request

Navigation & Dispatch Service

Client
Locator
Navigator Dispatcher

Response View Processor XML

View Core J2EE

Intercepting Transformer
Processor XSL Pattern
Filter Helper
Strategy
44
 Analyzing Existing Architectures:
Anlyz
Struts Framework

Action Action
Action
Servlet Mapping
Request

Client

uses
Response

Action Action
JSP View
Forward Form

45
Anlyz Struts: Patterns Implemented
Front Controller Command

Action Action
Action
Servlet Mapping
Request

Client

uses
Response

Action Action
JSP View
Forward Form
Composite View Helper
View

46
Refac Refactoring Existing Architectures:
Ford
Session
Servlet Loader Request Manager

Context

Request Response

47
Refac Ford: No clear responsibilities

What is it managing?
Session
Servlet Loader Request Manager

Context
What does this do?
Request Response Leave 'em alone!

These are not what you think they are...

48
Refac Ford: Refactored Solution
We know what Request Helper Clear responsibilities
this does now!
Session
Front Controller Command Factory

Context

Customized
wrappers Control View
Command Command Extensible, reusable,
Request Wrapper pluggable commands!

Business View Helper

Response Wrapper
Delegate Bean

49
Thank You!

50