1

JAVA DP

JAVA Design pattern

What is the design pattern?

If a problem occurs over and over again, a solution to that problem has been used
effectively. That solution is described as a pattern. The design patterns are
language-independent strategies for solving common object-oriented design
problems. When you make a design, you should know the names of some common
solutions. Learning design patterns is good for people to communicate each other
effectively. In fact, you may have been familiar with some design patterns, you
may not use well-known names to describe them. SUN suggests GOF (Gang Of
Four--four pioneer guys who wrote a book named "Design Patterns"- Elements of
Reusable Object-Oriented Software), so we use that book as our guide to describe
solutions. Please make you be familiar with these terms and learn how other people
solve the code problems.

Do I have to use the design pattern?

If you want to be a professional Java developer, you should know at least some
popular solutions to coding problems. Such solutions have been proved efficient
and effective by the experienced developers. These solutions are described as so-
called design patterns. Learning design patterns speeds up your experience
accumulation in OOA/OOD. Once you grasped them, you would be benefit from
them for all your life and jump up yourselves to be a master of designing and
developing. Furthermore, you will be able to use these terms to communicate with
your fellows or assessors more effectively.

Many programmers with many years experience don't know design patterns, but as
an Object-Oriented programmer, you have to know them well, especially for new
Java programmers. Actually, when you solved a coding problem, you have used a
design pattern. You may not use a popular name to describe it or may not choose
an effective way to better intellectually control over what you built. Learning how
the experienced developers to solve the coding problems and trying to use them in
your project are a best way to earn your experience and certification.

Remember that learning the design patterns will really change how you design
your code; not only will you be smarter but will you sound a lot smarter, too.

How many design patterns?

 2
JAVA DP

Many. A site says at least 250 existing patterns are used in OO world, including
Spaghetti which refers to poor coding habits. The 23 design patterns by GOF are
well known, and more are to be discovered on the way.

Note that the design patterns are not idioms or algorithms or components.

What is the relationship among these patterns?

Generally, to build a system, you may need many patterns to fit together. Different
designer may use different patterns to solve the same problem. Usually:

 Some patterns naturally fit together

 One pattern may lead to another
 Some patterns are similar and alternative
 Patterns are discoverable and documentable
 Patterns are not methods or framework
 Patterns give you hint to solve a problem effectively

J2EE Patterns:--

1.MVC:

Definition:The Model/View/Controller(MVC) is an architecture design pattern.

Model means data, View means representation and Controller works on data and
representation. MVC focuses on decouple the triad relationships among data,
representation and controller.

Where to use & benefits

 Application architecture design.

 Any data related design, including non-visual application.
 Decouple complex object to improve maintainability.
 Increase object reusability.
 Achieve design flexibility
 Related patterns include
 Almost all patterns can be used with MVC.

History
 3
JAVA DP

The Model/View/Controller(MVC) originates from Smalltalk, an OO

programming language.

Core issue

MVC consists of three kind of objects. The Model is an internal representation of

the data, the View is the screen presentation of GUI, and the Controller coordinates
changes between the Model and View.

SCJD project design

To achieve the MVC architecture in your project, you have to decouple View and
Model by Controller. Your GUI as View should be designed as a module. It can be
launched separately. Your data related classes as Model should be treated as a
module too. Your controller classes should response to any data change on the
GUI. Such design will increase reusability and flexibility.

Try to visualize that the user reacts with the GUI, a DataManager(Controller)
listens to the GUI's call. If the user needs to load data, such request is sent to the
DataManager, the DataManager starts loading, searching and extracting the
requested data from the server and sends it back to the GUI. GUI is responsible to
display data.

Here the server acts as Model, the DataManager acts as Controller and GUI acts as
View. The DataManager can be used for both remote and local modes (design two
constructors for both modes), the GUI can be replaced with any design and the data
related classes can be packaged together and put on local and server sides. All of
the three objects can be reused for other projects with little code alteration.

If you grasp such concept and skill, you will save a lot of time in designing and
developing your projects in the future. This is the so-called OOA/OOD.

2.Business Delegate:-

Definition

An intermediate class decouples between presentation-tier clients and business

services.

Where to use & benefits

 4
JAVA DP

 Simplify the complicated relationship.

 Reduce coupling.
 Cache results and references to remote business services.
 Cut potentially costly round trips
 Hide the underlying implementation details of business service.
 Related patterns include
 Proxy combined to simplify the complexity.

Example

Make a class deal with lookups and exception, acting as a representative of the
client components

3.Composite Entity:-

Definition

Use a coarse-grained interface to manage interactions between fine-grained or

coarse-grained and dependent objects internally. The Composite Entity is a coarse-
grained entity bean. It may be the coarse-grained object or hold a reference to the
coarse-grained object. Also known as Aggregate Entity.

Where to use & benefits

 Combine coarse-grained object and its related dependent objects into a

single entity bean.
 Multiple clients share persistent objects.
 Model a network of related business entities.
 In both local and distributed environment, use remote entity beans to model
dependent business objects or fine-grained objects.
 Improve performance by eliminating the parameter and return value
serialization and data transmission costs.
 Eliminate inter-entity relationships
 Improve manageability by reducing entity beans.
 Improve network performance
 Reduce database schema dependency
 Increase object granularity
 Facilitate composite transfer object creation.
 Overhead of multi-level dependent object graphs.
 5
JAVA DP

 Related patterns include

 Transfer Object used to return to client and also used to serialize the
coarse-grained and dependent objects tree, or part of the tree, as required.
 Session Facade used to manage the inter-entity-bean relationships.

Transfer Object:

Definition:Using a serializable class to act as data carrier, grouping related

attributes, forming a composite value and working as a return type from remote
business method. Also known as Value object.

Where to use & benefits

 Get related values from remote business method.

 Fetch multiple values in one trip.
 Decrease network traffic.
 Minimize latency and server resource usage.
 Related patterns include
 Composite view

Example

In the J2EE server, the client tier may make several calls to retrieve data from the
enterprise bean. Even in the same machine, the every call from the client tier to the
server tier is a remote method call. Think about use Transfer Object design pattern
to retrieve related attributes and return a single object instead of each call just for
retrieving a single attribute value. The transfer object is passed by value to the
client. All calls to the transfer object instance are local calls to the client, so such
design saves a lot of network traffic.

Let's say that you have a remote banking system. If the user has five requests one
time, you should design your system to give response once, not five times. You
may need to group all return values from these five requests to an object carrier
and then return to client just once. Once the client program receives the instance of
this object, it invokes the accessors and gets value to display. The total network
traffic for one user just once.

Session Façade
 6
JAVA DP

Definition:Provide a simple class or component that represents or contains

interactions between complex components

Where to use & benefits

 EJB session bean

 Provides a single & simple interface for complex system or components
 Simplify the process
 Clarify design
 Flexible and comprehensible
 Loosely coupling
 Related patterns include
 Facade make a complex system simpler by providing a unified or general
interface, which is a higher layer.

Example:Provide a step by step process for a complex system. For example, let a
component or user access a complex system by exposing a simple or a unified
interface to hide complexity to reach a loose coupling and flexible interaction.

4.Data Access Object:--

Definition

Adapt a uniform interface to access multiple databases like relational, unrelational,

object-oriented, etc.

Where to use & benefits

 Need to access multiple data sources like legacy systems, B2B, LDAP, and
so forth.
 Lack of uniform APIs to address the requirements to access disparate
systems.
 Persistent storage APIs vary depending on the product vendor.
 Adapt and encapsulate all access to the data source.
 Hide the data source implementation details from its clients.
 More portable and less code dependencies in components.
 Solve differences in the APIs which is used to access different persistent
storage mechanisms.
 Not useful for container-managed persistence.
 7
JAVA DP

 Related patterns include

 factory method -- used to deal with different data sources.
 abstract factory -- used to make an abstract layer of access to data sources.
 transfer object -- used to transport data to and from its clients.

5.Front Controller

Definition:Using a single component to process application requests.

Where to use & benefits

 JSP or Servlet.
 Design request handling component.
 Channel all requests through a single controller.
 Centralize request processing and view selection.
 Reduce business logic in a view
 Improve manageability of security
 Promote code reuse across requests
 Avoid code duplication
 Related patterns include
 Command combined with multiple requests.
 Intercepting Filter both centralize control of certain types of request
processing.
 Page Controller -- an alternative way.

6.Intercepting Filter

Definition:A pluggable component design to intercept incomming requests and

outgoing responses, provide common services in a standard manner
(independently) without changing core processing code.

Where to use & benefits

 Logging and authentication.

 Enhance security.
 Add additional function to existing web application.
 8
JAVA DP

 Decorate main process.

 Debug.
 Pre-processing or post-processing for specific clients.
 Uncompress incoming request.
 Convert input encoding schema.
 Being added or removed transparently or declaratively and triggered
automatically
 Improve reusability
 Deployment-time composability
 Each filter is loosely coupled
 Inefficient for information sharing.
 Related patterns include
 Front Control better suited to handling core processing.
 Template good for template filter strategy
 Decorator providing for dynamically pluggable wrappers.

Example:To create a basic filter, you need to:

1. implement Filter interface

2. implement doFilter method
3. call doFilter from FilterChain object
4. register the filter with the appropriate servlets and JSP pages
5. Mapping the filter to specific pages
6. disable the invoker servlet

General skeleton program

import javax.servlet.*;
import javax.servlet.http.*;
public class MyFilter implements Filter {
public void doFilter(ServletRequest request,
ServletResponse resonse,
FilterChain chain)
throws ServletException, IOException {
//work on request and response
chain.doFilter(request, response);
}
public void init(FilterConfig config) throws ServletException {
//work on config
 9
JAVA DP

}
public void destroy() {
//work on clean up
}
}

Register and filter mapping

//in web.xml file

<web-app>
...
Before the servlet description
<filter>
<filter-name>MyFilter</filter-name>
<display-name>MyCoolFilter</display-name>
<description>This is my cool filter</description>
<filter-class>somePackage.MyFilter</filter-class>
<init-param>
<param-name>yyy</param-name>
<param-value>/xxx/zzz</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>MyFilter</filter-name>
<url-pattern>/xxx.jsp</url-pattern>
</filter-mapping>

<!-- also apply to another servlet -->

<filter-mapping>
<filter-name>MyFilter</filter-name>
<servlet-name>xxx</servlet-name>
</filter-mapping>
...
</web-app>

You may use filter mapping and servlet mapping in web.xml file to diable the
invoker servlet to apply the filter.

7.Service Locator
 10
JAVA DP

Definition:Centralizing distributed service object lookups, providing a centralized

point of control, acting as a cache that eliminates redundant lookups.

Where to use & benefits

 Lookup object in JNDI, RMI, JMS, etc.

 Encapsulate any vendor-specific features of lookup process
 Simplify the lookup process
 Improve the performance
 Related patterns include
 Singlton combined with service locator to make sure only one lookup object
exists.

Example:Use a container as cache to hold the lookup object. One application only
lookups same object once. Doing so will dramatically improve performance. Make
sure the container used is thread-safe.

8.Transfer Object

Definition:Using a serializable class to act as data carrier, grouping related

attributes, forming a composite value and working as a return type from remote
business method. Also known as Value object.

Where to use & benefits

 Get related values from remote business method.

 Fetch multiple values in one trip.
 Decrease network traffic.
 Minimize latency and server resource usage.
 Related patterns include
o Composite view

Example:In the J2EE server, the client tier may make several calls to retrieve data
from the enterprise bean. Even in the same machine, the every call from the client
tier to the server tier is a remote method call. Think about use Transfer Object
design pattern to retrieve related attributes and return a single object instead of
each call just for retrieving a single attribute value. The transfer object is passed by
value to the client. All calls to the transfer object instance are local calls to the
client, so such design saves a lot of network traffic.
 11
JAVA DP

Let's say that you have a remote banking system. If the user has five requests one
time, you should design your system to give response once, not five times. You
may need to group all return values from these five requests to an object carrier
and then return to client just once. Once the client program receives the instance of
this object, it invokes the accessors and gets value to display. The total network
traffic for one user just once.

http://www.javacamp.org/designPattern/