Transcript Design Patterns - u

Design Patterns
based on book of Gang of Four (GoF)
Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides
Elements of Reusable Object-Oriented Software
Robert Papp ([email protected])
INTRODUCTION
2
UML class diagram recall
Interface
ClassName
Abstract
field list
Concrete
method list
Base
Derived
derived
aggregator
creator
caller/user
Aggregate
e
Product
base
# private
* protected
+ public
static
# private()
* protected()
+ public()
abstract()
static()
name(Type1, Type2) : RetType
Package
Class1
Class2
ClassN
code
aggregatee
product
callee/used
3
What is a Design Pattern?
A design pattern is a general reusable
solution to a commonly occurring problem in
software design. A design pattern is not a
finished design that can be transformed
directly into code. It is a description or
template for how to solve a problem that can
be used in many different situations. Objectoriented design patterns typically show
relationships and interactions between
classes or objects, without specifying the final
application classes or objects that are involved.
4
OK, but what is it?
Pattern Name and Classification: A descriptive and unique name that helps
in identifying and referring to the pattern.
Intent: A description of the goal behind the pattern and the reason for using it.
Also Known As: Other names for the pattern.
Motivation (Forces): A scenario consisting of a problem and a context in
which this pattern can be used.
Applicability: Situations in which this pattern is usable; the context for the
pattern.
Structure: A graphical representation of the pattern. Class diagrams and
Interaction diagrams may be used for this purpose.
Participants: A listing of the classes and objects used in the pattern and their
roles in the design.
Collaboration: A description of how classes and objects used in the pattern
interact with each other.
Consequences: A description of the results, side effects, and trade offs caused
by using the pattern.
Implementation: A description of an implementation of the pattern; the
solution part of the pattern.
Sample Code: An illustration of how the pattern can be used in a
programming language.
Known Uses: Examples of real usages of the pattern.
Related Patterns: Other patterns that have some relationship with the
pattern; discussion of the differences between the pattern and similar patterns. 5
Classification
Creational
Structural
Behavioral
Abstract Factory
Adapter
Null Object
Factory method
Bridge
Command
Builder
Composite
Interpreter
Lazy instantiation
Decorator
Iterator
Object pool
Façade
Mediator
Prototype
Flyweight
Memento
Singleton
Proxy
Observer
Multiton
State
Resource acquisition is
initialization
Chain of responsibility
Strategy
Specification
Template method
Visitor
6
Classification / 2
Concurrency
J2EE
Architectural
Active Object
Business Delegate
Layers
Balking
Composite Entity
Presentation-abstraction-control
Double checked locking
Composite View
Three-tier
Guarded suspension
Data Access Object
Pipeline
Monitor object
Fast Lane Reader
Implicit invocation
Reactor
Front Controller
Blackboard system
Read/write lock
Intercepting Filter
Peer-to-peer
Scheduler
Model-View-Controller
Event-Based Asynchronous
Service Locator
Service-oriented architecture
Thread pool
Session Facade
Naked objects
Thread-specific storage
Transfer Object
Value List Handler
View Helper
7
Contents
• Simple patterns
•
•
•
•
•
•
Singleton
Template Method
Factory Method
Adapter
Proxy
Iterator
• Complex patterns
•
•
•
•
Abstract Factory
Strategy
Mediator
Façade
• J2EE patterns
•
•
•
•
Data Access Objects
Model-View-Controller
Session Façade
Front Controller
8
SIMPLE PATTERNS
9
Singleton
Ensure a class has only one instance, and
provide a global point of access to it.
public class Singleton {
private Singleton() {}
private static Singleton _instance = null;
public static Singleton getInstance () {
if (_instance == null) _instance = new Singleton();
return _instance;
}
...
}
Lazy instantiation
Tactic of delaying the creation of an
object, the calculation of a value, or
some other expensive process until
the first time it is needed.
return _instance;
Singleton
# _instance : Singleton
# Singleton()
+ getInstance() : Singleton
10
Template Method
Define the skeleton of an algorithm in an
operation, deferring some steps to
subclasses. Template Method lets subclasses
redefine certain steps of an algorithm
without changing the algorithm's structure.
Generic
...
operation1();
...
operation2();
...
operationN();
...
+ TemplateMethod()
# operation1()
# operation2()
…
# operationN()
Specific1
# operation1()
# operation2()
…
# operationN()
Specific2
# operation1()
# operation2()
…
# operationN()
SpecificM
# operation1()
# operation2()
…
# operationN()
11
Factory Method
Define an interface for creating an object, but
let subclasses decide which class to
instantiate. Factory Method lets a class defer
instantiation to subclasses.
Product
Creator
+ CreateProduct() : Product
+ SomeOperation()
ConcreteProduct
...
Product product =
CreateProduct();
...
ConcreteCreator
+ CreateProduct() : Product
return new ConcreteProduct();
12
Adapter
Convert the interface of a class into another
interface clients expect. Adapter lets classes
work together that couldn't otherwise
because of incompatible interfaces.
Client
Target
+ Request()
Adaptee
+ SpecificRequest()
Adapter
# _adaptee : Adaptee
+ Request()
_adaptee.SpecificRequest();
13
Proxy
Provide a surrogate or placeholder for
another object to control access to it.
AbstractService
+ someOperation()
Client
Service
+ someOperation()
ServiceProxy
# _realService
+ someOperation()
_realService.someOperation();
14
Iterator
Provide a way to access the elements of an
aggregate object sequentially without
exposing its underlying representation.
Aggregate
+ CreateIterator() : Iterator
ConcreteAggregate
+ CreateIterator() : Iterator
return ConcreteIterator(this);
Iterator
+ First()
+ Next()
+ IsDone() : bool
+ CurrentItem() : object
ConcreteIterator
+ First()
+ Next()
+ IsDone() : bool
+ CurrentItem() : object
15
COMPLEX EXAMPLES
16
Abstract Factory
Provide an interface for creating families of
related or dependent objects without
specifying their concrete classes.
AbstractFactory
+ CreateProductA() : AbstractProductA
+ CreateProductB() : AbstractProductB
ConcreteFactory1
ConcreteFactory2
+ CreateProductA()
+ CreateProductB()
+ CreateProductA()
+ CreateProductB()
Client
AbstractProductA
ProductA2
ProductA1
AbstractProductB
return new ProductA1();
return new ProductA2();
return new ProductB1();
return new ProductB2();
ProductB2
ProductB1
17
Strategy
Define a family of algorithms, encapsulate
each one, and make them interchangeable.
Strategy
lets
the
algorithm
vary
independently from clients that use it.
Client
Context
# _strategy : Strategy
+ RegisterStrategy(s : Strategy)
+ AlgorithmOperation()
Strategy
+ Algorithm()
ConcreteStrategy1
_strategy.Algorithm();
+ Algorithm()
ConcreteStrategy2
+ Algorithm()
18
Mediator
Define an object that encapsulates how a set
of objects interact. Mediator promotes loose
coupling by keeping objects from referring to
each other explicitly, and it lets you vary
their interaction independently.
Mediator
Colleague
* _mediator : Mediator
ConcreteMediator
ConcreteColleague1
ConcreteColleague2
19
Façade
Provide a unified interface to a set of
interfaces in a subsystem. Façade defines a
higher-level interface that makes the
subsystem easier to use.
Package1
Class1
Package2
Class3
Package3
Class2
Façade
Client1
doSomething()
Client2
Class c1 = new Class1();
Class c2 = new Class2();
Class c3 = new Class3();
c1.doStuff(c2);
c3.setProp(c1.getProp2());
return c3.doStuff2();
20
http://java.sun.com/blueprints/patterns/catalog.html
J2EE PATTERN
EXAMPLES
21
Data Access Objects (DAO)
Code that depends on specific features of
data resources ties together business logic
with data access logic. This makes it difficult
to replace or modify an application's data
resources.
This pattern
• separates a data resource's client interface
from its data access mechanisms;
• adapts a specific data resource's access API to
a generic client interface;
• allows data access mechanisms to change
independently of the code that uses the data.
22
Data Access Objects (DAO) / 2
BusinessObject: represents the data client.
DataAccessObject: abstracts the underlying data
access implementation for the BusinessObject to enable
transparent access to the data source.
DataSource: represents a data source implementation.
TransferObject: the data carrier, DAO may use it to
return data to the client.
BusinessObject
DataAccessObject
DataSource
+ CRUD methods
TransferObject
23
Model-View-Controller (MVC)
Application presents content to users in
numerous ways containing various data. The
engineering team responsible for designing,
implementing, and maintaining the application
is composed of individuals with different skill
sets.
Classic Web
customer
Mobile
customer
Rich Web
customer
Administrator
Supplier
B2B agent
HTML
web view
WML
web view
RAP web
view
JFC/Swing
view
Web
Service
Enterprise information system
24
Model-View-Controller / 2
Model
•Encapsulates application state
•Responds to state queries
•Exposes application functionality
•Notifies views of changes
State query
State change
Change notification
View
•Renders the models
•Requests updates from models
•Sends gestures to controller
•Allows controller to select view
View selection
Controller
•Defines application behavior
•Maps user actions to model updates
•Selects view for response
•One for each functionality
User gestures
25
Front Controller
The
presentation-tier
request
handling
mechanism must control and coordinate
processing of each user across multiple
requests. Such control mechanisms may be
managed in either a centralized or decentralized
manner.
Problems:
◦ Each view is required to provide its own system
services, often resulting in duplicate code.
◦ View navigation is left to the views. This may result
in commingled view content and view navigation.
◦ Distributed control is more difficult to maintain:
changes will need to be made in numerous places.
26
Front Controller / 2
incoming
request
handle
request
Front
controller
Controller
model
return
response
delegate
rendering of
response
return
control
model
View
template
create model
render
response
Web container
27
Session Façade
Enterprise beans encapsulate business logic
and business data and expose their
interfaces, and thus the complexity of the
distributed services, to the client tier.
• Tight coupling, which leads to direct
dependence between clients and business
objects;
• Too many method invocations between client
and server, leading to network performance
problems;
• Lack of a uniform client access strategy,
exposing business objects to misuse.
28
Session Façade / 2
Client: the object which needs access to the business service.
This client can be another session bean (Session Facade) in the
same business tier or a business delegate in another tier.
SessionFacade: a session bean which manages the relationships
between numerous BusinessObjects and provides a higher level
abstraction to the client.
BusinessObject: a role object that facilitates applying different
strategies, such as session beans, entity beans and a DAO. A
BusinessObject provides data and/or some services.
Client
SessionFacade
BusinessObject
BusinessEntity
BusinessSession
DataAccessObject
29
OUTRODUCTION
30
Revision
• Simple patterns
•
•
•
•
•
•
Singleton
Template Method
Factory Method
Adapter
Proxy
Iterator
• Complex patterns
•
•
•
•
Abstract Factory
Strategy
Mediator
Façade
• J2EE patterns
•
•
•
•
Data Access Objects
Model-View-Controller
Session Façade
Front Controller
31
Questions?
32
Sources
http://www.amazon.com/Design-Patterns-Object-Oriented-Addison-WesleyProfessional/dp/0201633612
http://en.wikipedia.org/wiki/Design_pattern_(computer_science)
http://en.wikipedia.org/wiki/Architectural_pattern_(computer_science)
http://java.sun.com/blueprints/patterns/catalog.html
◦ http://java.sun.com/blueprints/patterns/DAO.html
◦ http://java.sun.com/blueprints/corej2eepatterns/Patterns/DataAccessObject.html
◦ http://java.sun.com/blueprints/patterns/MVC.html
◦ http://java.sun.com/blueprints/patterns/SessionFacade.html
◦ http://java.sun.com/blueprints/corej2eepatterns/Patterns/SessionFacade.html
◦ http://java.sun.com/blueprints/patterns/FrontController.html
◦ http://java.sun.com/blueprints/corej2eepatterns/Patterns/FrontController.html
33