Embed Size (px)
Citation preview
OUTLINE
Adapter
Factory
Singleton
Strategy
Composition
Facade
Observer
Adapter
问题：如何解决接口不兼容问题，几个类似的构件接口不同，如何为其提供稳定的接口 ?
解决：通过中间的适配器对象，将构件原有接口转换成另一个接口
support external third-party services, tax calculators
support external third-party services, credit authorization services,
support external third-party services,
inventory systems,
support external third-party services,
accounting systems,
Adapter pattern 是 GRASP building blocks 的特例It offers Protected Variations from changing external interfaces or third-party packages through the use of an Indirection object that applies interfaces and Polymorphism.
" Analysis" Discoveries During Design: Domain
Modela list of tax line items are associated with a sale, such as state tax, federal tax, and so forth
OUTLINE
Adapter
Factory
Singleton
Strategy
Composition
Facade
Observer
Factory
who creates the adapters?a domain object (such as a Register)?
如何确定创建哪种 adapter? such as TaxMaster-Adapter or GoodAsGoldTaxProAdapter?
another fundamental design principle
Design to maintain a separation of concerns.一般作为 architectural design principleone of the essential principles in software
engineering modularize or separate distinct concerns
into different areas, so that each has a cohesive purpose.
domain layer 软件对象相对强调纯应用逻辑的职责另一组软件对象负责与外部系统的连接
Context I Problem
当有特殊考虑时如何创建对象 ? ( 如创建对象的逻辑很复杂，或想将创建对象的职责分离出来以获得更高的内聚度等 )
Solution
Create a Pure Fabrication object called a Factory that handles the creation.
public class Factory{ public static Sample creator(){ .... if (which==1) return new MySample(); else if (which==2) return new HisSample(); }}
Sample s;s=Factory.creator();s.xxx();
Factory objects have several advantages: the responsibility of complex creation 分离
到高内聚的 helper objects 中将潜在的复杂的创建对象的逻辑隐藏可进而引入增强性能的内存管理策略，如
object caching or recycling.
Also is an example of a partial data-driven design通过改变属性值来选择创建不同的 adapter
对象Protected Variations ： Adapter 的实现类在变化
OUTLINE
Adapter
Factory
Singleton
Strategy
Composition
Facade
Observer
Singleton (GoF)
who creates the factory itself, and how is it accessed?整个过程只需要一个 factory 实例代码中各个地方都可能需要调用 factory 中
的方法来创建实例 -- 〉 Thus, there is a visibility problem: how to get visibility to this single ServicesFactory instance?
Con text I Problem
只允许创建一个实例— it is a “singleton.”需要为对象提供全局的、单点访问
Solution
Define a static method of the class that returns the singleton.
lazy initializaition// Singleton.javapublic class Singleton{
private static Singleton _instance = null;private Singleton(){}
public static Singleton getInstance(){
if (null==_instance)_instance = new Singleton();
return _instance;}
}
保存全类唯一的实例
对客户隐藏构造器
客户只能从此处获得实例
eager initializaition
public class Singleton {
private static Singleton _instance = new Singleton();
public static Singleton getInstance() {
return _instance;
}
}
使用
UML 表示
Fig. 26.7
:Register1
:ServicesFactory
aa = getAccountingAdapterinitialize
...
the ‘1’ indicates that visibility to this instance was achieved via the Singleton pattern
Conclusion
综合使用 Adapter, Factory, and Singleton patterns ，针对外部系统 (tax calculators, accounting systems 等 ) 的各种接口变化提供了 PV
Fig. 26.8
:Register accountingAdapter : SAPAccountingAdapter
postSale ( sale )
makePayment
SOAP over HTTP
xxx
:Register
1:ServicesFactory
accountingAdapter = getAccountingAdapter
:Store
createcreate
: SAPAccountingAdapter
: Paymentcreate (cashTendered )
«actor»: SAPSystem
create
OUTLINE
Adapter
Factory
Singleton
Strategy
Composition
Facade
Observer
Strategy (GoF)
如何提供复杂的 pricing logic （圣诞促销、会员价 ,……)
The pricing strategy(a rule, policy, or algorithm) can vary during different period
Context / Problem
对于变化着的、但又相关的算法和策略如何设计 ? 如何设计才能改变这些算法和策略 ?
Solution
将每个 algorithm/policy/strategy 定义在具有共同接口的不同的类中 .
Fig. 26.10
:PercentDiscountPricingStrategy
s : Sale
st = getSubtotal
t = getTotal
lineItems[ i ] :SalesLineItem
t = getTotal( s )
pdt = getPreDiscountTotal
{ t = pdt * percentage }
note that the Sale s is passed to the Strategy so that it has parameter visibility to it for further collaboration
loop
Creating a Strategy with a Factory
Fig. 26.13
:Sale
1:PricingStrategyFactory
ps =getSalePricingStrategy
:Register
makeNewSalecreate
create(percent) ps : PercentDiscountPricingStrategy
public class Sale{ ISalePricingStrategy pricingStrategy ； double predicounttotal;
double getTotal(){...
predicounttotal=… pricingStrategy=PricingStrategyFactory.getSalePricingStrategy();
return pricingStrategy.getTotal( this ) // pricingStrategy got from PricingStrategyFactory
}}
public interface ISalePricingStrategy { public double getTotal(Sale s);}
public class PricingStrategyFactory{ public ISalePricingStrategy getSalePricingStrategy(){
//… by "salepricingstrategy.class.name" return strategy;
}}
public class PercentDiscountPricingStrategy implements ISalePricingStrategy { public double getTotal( s:Sale ){
return s.getPreDiscountTotal() * percentage }
}
Reading and Initializing the Percentage Value初始值从外部数据源如关系数据库中读取，
以便容易修改
Summary
通过 Strategy and Factory patterns 获得针对定价策略变化的 PV.
对象设计中，基于 Polymorphism and interfaces 的策略模式允许可 pluggable algorithms
策略通常通过 Factory 模式创建
Strategy 和 Factory 有一定的类似 , Strategy 相对简单容易理解 , 并且可以在运行时刻自由切换。 Factory 重点是用来创建对象
Define a family of algorithms
Encapsulate each algorithm
Make the algorithms interchangeable
Let the algorithm vary independently from clients that use it
OUTLINE
Adapter
Factory
Singleton
Strategy
Composition
Facade
Observer
Composition(GoF)
对于多个冲突的定价策略如何处理 ?高级会员打 8 折超过 XXX 元打 8.5 折星期一购买超过 XXX 元立即返还 XX 元买 1 盒龙井，则买所有商品都打 8.5 折
影响 Sale 的定价策略有三个要素
1. time period (Monday)
2. customer type (senior)
3. a particular line item product ( 买 1 盒龙井，则买所有商品都打 8.5 折 )
Context / Problem如何将组合结构和原子结构的对象进行同样
的处理Solution
Define classes for composite and atomic objects so that they implement the same interface.
Fig. 26.15
:CompositeBestForCustomerPricingStrategy
s : Sale
st = getSubtotal
t = getTotal
lineItems[ i ] :SalesLineItem
t = getTotal( s )
the Sale object treats a Composite Strategy that contains other strategies just like any other ISalePricingStrategy
x = getTotal( s )
strategies[ j ] :: ISalePricingStrategy
UML: ISalePricingStrategy is an interface, not a class; this is the way in UML 2 to indicate an object of an unknown class, but that implements this interface
{ t = min(set of all x) }
loop
loop
将对象组合成树形结构以表示“部分 -整体”的层次结构。 C o m p o s i t e 使得用户对单个对象和组合对象的使用具有一致性
Creating Multiple SalePricingStrategies
什么时候创建这些策略 ?Current store-defined discount
added when the sale is created.Customer type discount,
added when the customer type is communicated to the POS.
Product type discountadded when the product is entered to the sale.
:Sale
1:PricingStrategyFactory
ps =getSale
PricingStrategy
:Register
makeNewSale create
create ps :CompositeBestForCustomerPricingStrategy
create( percent ) s : PercentageDiscountPricingStrategy
add( s )
Customer Type DiscountUse Case : Process Sale
5b. Customer says they are eligible for a discount
1. Cashier signals discount request
2. Cashier enters Customer identification
3. System presents discount total
Introducing the new system operation,
enterCustomerForDiscount(custId)
s :Sale:Register
enterCustomerForDiscount( custID )
by Controllerby Expert and IDs to Objects
:Store
c = getCustomer( custID )
enterCustomerForDiscount( c : Customer )
by Expert
ref Enter CustomerFor Discount
s :Sale
<<singleton>>:PricingStrategy
Factory
addCustomerPricingStrategy( s )
ps :CompositeBestForCustomerPricingStrategy
ISalePricingStrategy
create( pct ) s : PercentageDiscountPricingStrategy
ISalePricingStrategy
add( s )
by Expert
enterCustomerForDiscount( c : Customer
)
originates inanother diagram
c :=getCustomer()
by Factory andHigh Cohesion
by Expert ps := getPricingStrategy()
pct :=getCustomer
Percentage( c )
by High Cohesion
by Factory and Composite
PassAggregateObject asParameter
s :Sale
1:PricingStrategy
Factory
addCustomerPricingStrategy( s )
ps :CompositeBestForCustomerPricingStrategy
create( pct ) s : PercentageDiscountPricingStrategy
add( s )
by Expert
enterCustomerForDiscount( c : Customer )
c = getCustomer
by Factory and High Cohesion
by Expert ps = getPricingStrategy
pct = getCustomer
Percentage( c )
by High Cohesion
by Factory and Composite
Pass Aggregate Object as Parameter
sd Enter Customer For Discount
OUTLINE
Adapter
Factory
Singleton
Strategy
Composition
Facade
Observer
Facade (GoF)
NextGen POS Requirementspluggable business rules.
用例场景可预测的点上（如 Process Sale 的makeNewSale, enterItem 等），不同顾客的行为略有不同
如 when a new sale is created,礼券payment type of change duescharitable donation rules
Analysis and Design the specific scenario points across all use
cases must be identified (enterItem, chooseCashChange, ...) 本次只考虑 enterltem
low impact on the existing software components
may want to experiment with different solutions
Context/Problem需要为不同的实现或子系统内部的接口提供公共的、统一的接口 .
外界对子系统内部有很多耦合，或子系统的实现可能会改变
Solution为子系统设计单点访问
– a facade object that wraps the subsystem. The facade object 代表单一的、统一的接口
Creating facade object and calling operations in facade objectFacades are often accessed via a
singleton factory. Calls to the facade should be placed near
the start of the methods that have been defined as the points for pluggable rules
public class Sale
{
public void makeLineItem (ProductSpecification spec, int quantity)
{
SalesLineItem sli = new SalesLineItem(spec, quantity);
if (POSRuleEngineFacade.getInstance().isInvalid(sli, this))
return;
.....
}
...
}
Domain
+ Sale + Register ...
POSRuleEngine
<<interface>>- IRule
...
- Rule1
...
- Rule2
...
...
package name may beshown in the tab
visibility of the package element (tooutside the package) can be shownby preceding the element name with avisibility symbol
+ POSRuleEngineFacade
instance : RuleEngineFacade
getInstance() : RuleEngineFacade
isInvalid( SalesLineItem, Sale )isInvalid( Payment, Sale )...
*1
Observer/Publish-Subscribe/Delegation
Event Model
Goal: When the total of the salechanges, refresh the display withthe new value
Sale
total...
setTotal( newTotal )...
Context/Problem不同的 subscriber 对某个 publisher 的状态变化
和事件感兴趣，当 publisher 生成事件时，每个subscriber 用各自独有的方式响应
Publisher 和 subscribers之间希望低耦合Solution
定义一个 subscriber or listener 接口Subscribers 实现这个接口 .Publisher 可动态地将对自己感兴趣的
subscribers 进行登记事件发生时， notify 所有登记的 subscribers
<<interface>>PropertyListener
onPropertyEvent( source, name, value )
SaleFrame1
onPropertyEvent( source, name, value )
initialize( Sale sale )...
javax.swing.JFrame
...setTitle()setVisible()...
{ if ( name.equals("sale.total") ) saleTextField.setText( value.toString() );}
Sale
addPropertyListener( PropertyListener lis )publishPropertyEvent( name, value )
setTotal( Money newTotal )...
*propertyListeners
{ total = newTotal; publishPropertyEvent( "sale.total", total); }
{ propertyListeners.add( lis );}
{ for each PropertyListener pl in propertyListeners pl.onPropertyEvent( this, name, value ); }
{ sale.addPropertyListener( this ) ...}
Subject
Observer
具体的Observer
update( )
update( )
Subscribing Listener Objects
s :Salesf :SaleFrame1
initialize( s : Sale)
addPropertyListener( sf)
PropertyListener
propertylisteners:Object
add( sf)
PropertyListener UML notation: Recall that
there is no such thing as aninstance of an interface.Therefore, we can generalize(or be vague) and simplyindicate the instances as typeObject, which is assumed tobe the superclass of allclasses. This approach can beused even if the language(such as C++) does notliterally define a root Objectsuperclass.
Fig. 26.23
s : Salesf : SaleFrame1
initialize( s : Sale )
addPropertyListener( sf )
propertyListeners : List<PropertyListener>
add( sf )
Publishing an event(Sale total change)
s :Sale
setTotal( total)
* : onPropertyEvent( s, "sale.total", total)
UML notation: Since themembers of this collection aretyped to the interfacePropertyListener, it is not legal toshow an implementationresponse, such as furthermessaging, since the responsecan vary, depending on the classimplementing this interface.
Therefore, "stop" the messagingat this point, and showimplementions on differentdiagrams.
publishPropertyEvent( "sale.total", total )
propertylisteners:Object
PropertyListener
Fig. 26.24
s :Sale
setTotal( total )
onPropertyEvent( s, "sale.total", total )
publishPropertyEvent( "sale.total", total )
propertylisteners[ i ] : PropertyListener
loop
Receiving event notification
:SaleFrame1
onPropertyEvent( source, name, value)
PropertyListener
saleTextField: JTextField
setText( value.toString())
Since this is a polymorphic operationimplemented by this class, show a newinteraction diagram that starts with thispolymorphic version
UML notation: Note this little expression within theparameter. This is legal and consise.
<<interface>>AlarmListener
onAlarmEvent( source, time )
Beeper
onAlarmEvent( source, time )...
{ display notification dialogbox}
AlarmClock
addAlarmnListener( AlarmListener lis )publishAlarmEvent( time )
setTime( newTime )...
*alarmListeners
{ time = newTime; if ( time == alarmTime ) publishAlarmEvent( time ); }
{ alarmListeners.add( lis );}
{ for each AlarmListener al in alarmListeners al.onAlarmEvent( this, time ); }
AlarmWindow
onAlarmEvent( source, time )...
javax.swing.JFrame
...setTitle()setVisible()...
ReliabilityWatchDog
onAlarmEvent( source, time )...
{ beep}
{ check that all required processes are executing normally}
补充内容
OUTLINE
Adapter
Factory
Singleton
Strategy
Composition
Facade
Observer
Existing class
class Employee{ //... public void youAreFired() { // lots of code }}a lot of code scattered through the system that looks something like this Employee fred = new Employee(); //... fred.youAreFired();
must-change-all-new-invocations problem
1 Create an interface that has the same name as the existing class, like so:interface Employee{ void youAreFired();}2 Rename the existing class, like so:class Peon implements Employee // used to be Employee{ public void youAreFired() { // lots of code }}3. ?
Factory 1 public interface Employee 2 { void youAreFired(); 3 } 4 5 public static class EmployeeFactory 6 { private Factory(){/*empty*/} 7 8 public static Employee create() 9 { return new Peon();10 }11 }
/*package*/ class Peon implements Employee14 { public void youAreFired()15 { // lots of code16 }17 }
restrict access to the concrete class even further public static class EmployeeFactory{ private EmployeeFactory(){/*empty*/} public static Employee create() { return new Peon(); } private static class Peon implements Employee { public void youAreFired() { // lots of code } }}
anonymous-inner-class version of the factory
public static class EmployeeFactory{ private Factory(){/*empty*/} public static Employee create() { return new Employee() { public void youAreFired() { // lots of code } } }}
Runtime runtimeEnvironment = Runtime.getRuntime();
ButtonPeer peer = Toolkit.getDefaultToolkit().createButton(b);
Thread Problem
1 class Singleton 2 { private static Singleton instance = null; 3 public static instance() 4 { if( instance == null ) 5 { instance = new Singleton(); 6 } 7 return instance; 8 } 9 //...10 }
The easy solution is to use a static initializer
class Singleton2
{ private static Singleton instance = new Singleton();
public instance() { return instance; }
//...
}
The only time the static -initializer approach isn't workable
public static void main( String[] args ){ //... Connection.pointAt( new URL(args[i]) ); //...}
Connection c = Connection.instance();
class Connection{ private static URL server; public static pointAt( URL server ){ this.server = server; } private Connection() { //... establishConnectionTo( server ); //... } private static Connection instance; public synchronized static Connection instance() { if( instance == null ) instance = new Connection(); return connection(); }}
Double-Checked Locking 1 class DoubleChecked 2 { private static volatile DoubleChecked instance = null; 3 private static Object lock = new Object(); 4 5 public static DoubleChecked instance() 6 { if( instance == null ) 7 { synchronized( lock ) 8 { if( instance == null ) 9 instance = new DoubleChecked();10 }11 }12 return instance;13 }14 }
Game of Life
Game of Life
对于处在”生态的格 ,若八个邻居中有 2 个或 3 个”生” ,则继续存活 ,否则将因过于孤独或过于拥挤而死亡 .
对于处在”死”态的空格 ,若八个邻格中有 3 个”生” , 则该格转变为”生” ( 代表繁衍过程 ),否则继续空着 .
Observer Pattern
ObserverObserver uses an anonymous inner class as the Concrete Subject/Subscriber
class Client{ volatile boolean menuItemSelected = false;
public Client( JMenu topMenu ) { // Add an item to the topMenu, and arrange to be notified when it // is selected:
JMenuItem myItem = new JMenuItem( "Hello" ); myItem.addActionListener ( new ActionListener() { public void actionPerformed( ActionEvent e ) { menuItemSelected = true; // process selection } } );
topMenu.add( myItem ); }}
Universe——Observerclass Universe{…Clock.instance().addClockListener( new Clock.Listener() { public void tick() { // code to handle a clock tick goes here } });
}
Clock——Timer 13 public class Clock{ 14 private Timer clock = new Timer(); 15 private TimerTask tick = null; 16
21 private Clock() 22 { createMenus(); 23 }
39 public void startTicking( int millisecondsBetweenTicks ) 40 { if(tick != null) 41 { tick.cancel(); 42 tick=null; 43 } 44 45 if( millisecondsBetweenTicks > 0 ) 46 { tick = new TimerTask() 47 { public void run(){ tick(); } 48 }; 49 clock.scheduleAtFixedRate( tick, 0, millisecondsBetweenTicks); 50 } 51 }
97 public void tick(){ …
Implementing Observer: The Publisher Classclass Publisher1
{ ArrayList subscribers = new ArrayList();
public synchronized void subscribe( Runnable subscriber ) { subscribers.add( subscriber ); }
public synchronized void cancelSubscription( Runnable subscriber ) { subscribers.remove( subscriber); }
private synchronized void fireEvent() // notify all subscribers { for( int i = 0; i < subscribers.size(); ++i ) ((Runnable) subscribers.get(i) ).run(); }}
