设计模式（3）

策略者模式

定义：定义一组算法，将每个算法都封装起来，并且使他们之间可以互换。

类型：行为类模式

类图：

       策略模式是对算法的封装，把一系列的算法分别封装到对应的类中，并且这些类实现相同的接口，相互之间可以替换。在前面说过的行为类模式中，有一种模式也是关注对算法的封装——模版方法模式，对照类图可以看到，策略模式与模版方法模式的区别仅仅是多了一个单独的封装类Context，它与模版方法模式的区别在于：在模版方法模式中，调用算法的主体在抽象的父类中，而在策略模式中，调用算法的主体则是封装到了封装类Context中，抽象策略Strategy一般是一个接口，目的只是为了定义规范，里面一般不包含逻辑。其实，这只是通用实现，而在实际编程中，因为各个具体策略实现类之间难免存在一些相同的逻辑，为了避免重复的代码，我们常常使用抽象类来担任Strategy的角色，在里面封装公共的代码，因此，在很多应用的场景中，在策略模式中一般会看到模版方法模式的影子。

 

策略模式的结构

• 封装类：也叫上下文，对策略进行二次封装，目的是避免高层模块对策略的直接调用。
• 抽象策略：通常情况下为一个接口，当各个实现类中存在着重复的逻辑时，则使用抽象类来封装这部分公共的代码，此时，策略模式看上去更像是模版方法模式。
• 具体策略：具体策略角色通常由一组封装了算法的类来担任，这些类之间可以根据需要自由替换。

策略模式代码实现

[java] view plain copy

1. interface IStrategy {  
2.     public void doSomething();  
3. }  
4. class ConcreteStrategy1 implements IStrategy {  
5.     public void doSomething() {  
6.         System.out.println("具体策略1");  
7.     }  
8. }  
9. class ConcreteStrategy2 implements IStrategy {  
10.     public void doSomething() {  
11.         System.out.println("具体策略2");  
12.     }  
13. }  
14. class Context {  
15.     private IStrategy strategy;  
16.       
17.     public Context(IStrategy strategy){  
18.         this.strategy = strategy;  
19.     }  
20.       
21.     public void execute(){  
22.         strategy.doSomething();  
23.     }  
24. }  
25.   
26. public class Client {  
27.     public static void main(String[] args){  
28.         Context context;  
29.         System.out.println("-----执行策略1-----");  
30.         context = new Context(new ConcreteStrategy1());  
31.         context.execute();  
32.   
33.         System.out.println("-----执行策略2-----");  
34.         context = new Context(new ConcreteStrategy2());  
35.         context.execute();  
36.     }  
37. }  

 

策略模式的优缺点

       策略模式的主要优点有：

• 策略类之间可以自由切换，由于策略类实现自同一个抽象，所以他们之间可以自由切换。
• 易于扩展，增加一个新的策略对策略模式来说非常容易，基本上可以在不改变原有代码的基础上进行扩展。
• 避免使用多重条件，如果不使用策略模式，对于所有的算法，必须使用条件语句进行连接，通过条件判断来决定使用哪一种算法，在上一篇文章中我们已经提到，使用多重条件判断是非常不容易维护的。

       策略模式的缺点主要有两个：

• 维护各个策略类会给开发带来额外开销，可能大家在这方面都有经验：一般来说，策略类的数量超过5个，就比较令人头疼了。
• 必须对客户端（调用者）暴露所有的策略类，因为使用哪种策略是由客户端来决定的，因此，客户端应该知道有什么策略，并且了解各种策略之间的区别，否则，后果很严重。例如，有一个排序算法的策略模式，提供了快速排序、冒泡排序、选择排序这三种算法，客户端在使用这些算法之前，是不是先要明白这三种算法的适用情况？再比如，客户端要使用一个容器，有链表实现的，也有数组实现的，客户端是不是也要明白链表和数组有什么区别？就这一点来说是有悖于迪米特法则的。

 

适用场景

        做面向对象设计的，对策略模式一定很熟悉，因为它实质上就是面向对象中的继承和多态，在看完策略模式的通用代码后，我想，即使之前从来没有听说过策略模式，在开发过程中也一定使用过它吧？至少在在以下两种情况下，大家可以考虑使用策略模式，

• 几个类的主要逻辑相同，只在部分逻辑的算法和行为上稍有区别的情况。
• 有几种相似的行为，或者说算法，客户端需要动态地决定使用哪一种，那么可以使用策略模式，将这些算法封装起来供客户端调用。

       策略模式是一种简单常用的模式，我们在进行开发的时候，会经常有意无意地使用它，一般来说，策略模式不会单独使用，跟模版方法模式、工厂模式等混合使用的情况比较多。

 

  迭代模式

迭代模式相当于自定义一个迭代器+一个容器。为了模板性，我们还是引入了一个接口，一个迭代器接口一个容器接口。容器接口必须有add,remove两个方法，而迭代器则必须有next,hasnext,return三个方法。

应用，可以给简单的给数组或者一些没有迭代功能的集合制作迭代器，并可以完成一些简单算法排序

高级应用：迭代器模式的真正作用是将数据结构和操作数据结构的算法分离开

备忘录模式

定义：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样就可以将该对象恢复到原先保存的状态

类型：行为类

类图：

        我们在编程的时候，经常需要保存对象的中间状态，当需要的时候，可以恢复到这个状态。比如，我们使用Eclipse进行编程时，假如编写失误（例如不小心误删除了几行代码），我们希望返回删除前的状态，便可以使用Ctrl+Z来进行返回。这时我们便可以使用备忘录模式来实现。

 

备忘录模式的结构

• 发起人：记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据。
• 备忘录：负责存储发起人对象的内部状态，在需要的时候提供发起人需要的内部状态。
• 管理角色：对备忘录进行管理，保存和提供备忘录。

 

通用代码实现

[java] view plain copy

1. class Originator {  
2.     private String state = "";  
3.       
4.     public String getState() {  
5.         return state;  
6.     }  
7.     public void setState(String state) {  
8.         this.state = state;  
9.     }  
10.     public Memento createMemento(){  
11.         return new Memento(this.state);  
12.     }  
13.     public void restoreMemento(Memento memento){  
14.         this.setState(memento.getState());  
15.     }  
16. }  
17.   
18. class Memento {  
19.     private String state = "";  
20.     public Memento(String state){  
21.         this.state = state;  
22.     }  
23.     public String getState() {  
24.         return state;  
25.     }  
26.     public void setState(String state) {  
27.         this.state = state;  
28.     }  
29. }  
30. class Caretaker {  
31.     private Memento memento;  
32.     public Memento getMemento(){  
33.         return memento;  
34.     }  
35.     public void setMemento(Memento memento){  
36.         this.memento = memento;  
37.     }  
38. }  
39. public class Client {  
40.     public static void main(String[] args){  
41.         Originator originator = new Originator();  
42.         originator.setState("状态1");  
43.         System.out.println("初始状态:"+originator.getState());  
44.         Caretaker caretaker = new Caretaker();  
45.         caretaker.setMemento(originator.createMemento());  
46.         originator.setState("状态2");  
47.         System.out.println("改变后状态:"+originator.getState());  
48.         originator.restoreMemento(caretaker.getMemento());  
49.         System.out.println("恢复后状态:"+originator.getState());  
50.     }  
51. }  

        代码演示了一个单状态单备份的例子，逻辑非常简单：Originator类中的state变量需要备份，以便在需要的时候恢复；Memento类中，也有一个state变量，用来存储Originator类中state变量的临时状态；而Caretaker类就是用来管理备忘录类的，用来向备忘录对象中写入状态或者取回状态。

 

多状态多备份备忘录

       通用代码演示的例子中，Originator类只有一个state变量需要备份，而通常情况下，发起人角色通常是一个javaBean，对象中需要备份的变量不止一个，需要备份的状态也不止一个，这就是多状态多备份备忘录。实现备忘录的方法很多，备忘录模式有很多变形和处理方式，像通用代码那样的方式一般不会用到，多数情况下的备忘录模式，是多状态多备份的。其实实现多状态多备份也很简单，最常用的方法是，我们在Memento中增加一个Map容器来存储所有的状态，在Caretaker类中同样使用一个Map容器才存储所有的备份。下面我们给出一个多状态多备份的例子：

[java] view plain copy

1. class Originator {  
2.     private String state1 = "";  
3.     private String state2 = "";  
4.     private String state3 = "";  
5.   
6.     public String getState1() {  
7.         return state1;  
8.     }  
9.     public void setState1(String state1) {  
10.         this.state1 = state1;  
11.     }  
12.     public String getState2() {  
13.         return state2;  
14.     }  
15.     public void setState2(String state2) {  
16.         this.state2 = state2;  
17.     }  
18.     public String getState3() {  
19.         return state3;  
20.     }  
21.     public void setState3(String state3) {  
22.         this.state3 = state3;  
23.     }  
24.     public Memento createMemento(){  
25.         return new Memento(BeanUtils.backupProp(this));  
26.     }  
27.       
28.     public void restoreMemento(Memento memento){  
29.         BeanUtils.restoreProp(this, memento.getStateMap());  
30.     }  
31.     public String toString(){  
32.         return "state1="+state1+"state2="+state2+"state3="+state3;  
33.     }  
34. }  
35. class Memento {  
36.     private Map<String, Object> stateMap;  
37.       
38.     public Memento(Map<String, Object> map){  
39.         this.stateMap = map;  
40.     }  
41.   
42.     public Map<String, Object> getStateMap() {  
43.         return stateMap;  
44.     }  
45.   
46.     public void setStateMap(Map<String, Object> stateMap) {  
47.         this.stateMap = stateMap;  
48.     }  
49. }  
50. class BeanUtils {  
51.     public static Map<String, Object> backupProp(Object bean){  
52.         Map<String, Object> result = new HashMap<String, Object>();  
53.         try{  
54.             BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());  
55.             PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();  
56.             for(PropertyDescriptor des: descriptors){  
57.                 String fieldName = des.getName();  
58.                 Method getter = des.getReadMethod();  
59.                 Object fieldValue = getter.invoke(bean, new Object[]{});  
60.                 if(!fieldName.equalsIgnoreCase("class")){  
61.                     result.put(fieldName, fieldValue);  
62.                 }  
63.             }  
64.               
65.         }catch(Exception e){  
66.             e.printStackTrace();  
67.         }  
68.         return result;  
69.     }  
70.       
71.     public static void restoreProp(Object bean, Map<String, Object> propMap){  
72.         try {  
73.             BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());  
74.             PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();  
75.             for(PropertyDescriptor des: descriptors){  
76.                 String fieldName = des.getName();  
77.                 if(propMap.containsKey(fieldName)){  
78.                     Method setter = des.getWriteMethod();  
79.                     setter.invoke(bean, new Object[]{propMap.get(fieldName)});  
80.                 }  
81.             }  
82.         } catch (Exception e) {  
83.             e.printStackTrace();  
84.         }  
85.     }  
86. }  
87. class Caretaker {  
88.     private Map<String, Memento> memMap = new HashMap<String, Memento>();  
89.     public Memento getMemento(String index){  
90.         return memMap.get(index);  
91.     }  
92.       
93.     public void setMemento(String index, Memento memento){  
94.         this.memMap.put(index, memento);  
95.     }  
96. }  
97. class Client {  
98.     public static void main(String[] args){  
99.         Originator ori = new Originator();  
100.         Caretaker caretaker = new Caretaker();  
101.         ori.setState1("中国");  
102.         ori.setState2("强盛");  
103.         ori.setState3("繁荣");  
104.         System.out.println("===初始化状态===\n"+ori);  
105.           
106.         caretaker.setMemento("001",ori.createMemento());  
107.         ori.setState1("软件");  
108.         ori.setState2("架构");  
109.         ori.setState3("优秀");  
110.         System.out.println("===修改后状态===\n"+ori);  
111.           
112.         ori.restoreMemento(caretaker.getMemento("001"));  
113.         System.out.println("===恢复后状态===\n"+ori);  
114.     }  
115. }  

备忘录模式的优缺点和适用场景

备忘录模式的优点有：

• 当发起人角色中的状态改变时，有可能这是个错误的改变，我们使用备忘录模式就可以把这个错误的改变还原。
• 备份的状态是保存在发起人角色之外的，这样，发起人角色就不需要对各个备份的状态进行管理。

备忘录模式的缺点：

• 在实际应用中，备忘录模式都是多状态和多备份的，发起人角色的状态需要存储到备忘录对象中，对资源的消耗是比较严重的。

如果有需要提供回滚操作的需求，使用备忘录模式非常适合，比如jdbc的事务操作，文本编辑器的Ctrl+Z恢复等。