5，结构型模式

5.6 组合模式

5.6.1 概述

对于这个图片肯定会非常熟悉，上图我们可以看做是一个文件系统，对于这样的结构我们称之为树形结构。在树形结构中可以通过调用某个方法来遍历整个树，当我们找到某个叶子节点后，就可以对叶子节点进行相关的操作。可以将这颗树理解成一个大的容器，容器里面包含很多的成员对象，这些成员对象即可是容器对象也可以是叶子对象。但是由于容器对象和叶子对象在功能上面的区别，使得我们在使用的过程中必须要区分容器对象和叶子对象，但是这样就会给客户带来不必要的麻烦，作为客户而已，它始终希望能够一致的对待容器对象和叶子对象。

定义：

又名部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。

5.6.2 结构

组合模式主要包含三种角色：

• 抽象根节点（Component）：定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性。
• 树枝节点（Composite）：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。
• 叶子节点（Leaf）：叶子节点对象，其下再无分支，是系统层次遍历的最小单位。

5.6.3 案例实现

【例】软件菜单

如下图，我们在访问别的一些管理系统时，经常可以看到类似的菜单。一个菜单可以包含菜单项（菜单项是指不再包含其他内容的菜单条目），也可以包含带有其他菜单项的菜单，因此使用组合模式描述菜单就很恰当，我们的需求是针对一个菜单，打印出其包含的所有菜单以及菜单项的名称。

要实现该案例，我们先画出类图：

代码实现：

不管是菜单还是菜单项，都应该继承自统一的接口，这里姑且将这个统一的接口称为菜单组件。

​x
1
//菜单组件  不管是菜单还是菜单项，都应该继承该类
2
public abstract class MenuComponent {
3
​
4
    protected String name;
5
    protected int level;
6
​
7
    //添加菜单
8
    public void add(MenuComponent menuComponent){
9
        throw new UnsupportedOperationException();
10
    }
11
​
12
    //移除菜单
13
    public void remove(MenuComponent menuComponent){
14
        throw new UnsupportedOperationException();
15
    }
16
​
17
    //获取指定的子菜单
18
    public MenuComponent getChild(int i){
19
        throw new UnsupportedOperationException();
20
    }
21
​
22
    //获取菜单名称
23
    public String getName(){
24
        return name;
25
    }
26
​
27
    public void print(){
28
        throw new UnsupportedOperationException();
29
    }
30
}

这里的MenuComponent定义为抽象类，因为有一些共有的属性和行为要在该类中实现，Menu和MenuItem类就可以只覆盖自己感兴趣的方法，而不用搭理不需要或者不感兴趣的方法，举例来说，Menu类可以包含子菜单，因此需要覆盖add()、remove()、getChild()方法，但是MenuItem就不应该有这些方法。这里给出的默认实现是抛出异常，你也可以根据自己的需要改写默认实现。

xxxxxxxxxx
37
1
public class Menu extends MenuComponent {
2
​
3
    private List<MenuComponent> menuComponentList;
4
​
5
    public Menu(String name,int level){
6
        this.level = level;
7
        this.name = name;
8
        menuComponentList = new ArrayList<MenuComponent>();
9
    }
10
​
11
    @Override
12
    public void add(MenuComponent menuComponent) {
13
        menuComponentList.add(menuComponent);
14
    }
15
​
16
    @Override
17
    public void remove(MenuComponent menuComponent) {
18
        menuComponentList.remove(menuComponent);
19
    }
20
​
21
    @Override
22
    public MenuComponent getChild(int i) {
23
        return menuComponentList.get(i);
24
    }
25
​
26
    @Override
27
    public void print() {
28
​
29
        for (int i = 1; i < level; i++) {
30
            System.out.print("--");
31
        }
32
        System.out.println(name);
33
        for (MenuComponent menuComponent : menuComponentList) {
34
            menuComponent.print();
35
        }
36
    }
37
}

Menu类已经实现了除了getName方法的其他所有方法，因为Menu类具有添加菜单，移除菜单和获取子菜单的功能。

xxxxxxxxxx
15
1
public class MenuItem extends MenuComponent {
2
​
3
    public MenuItem(String name,int level) {
4
        this.name = name;
5
        this.level = level;
6
    }
7
​
8
    @Override
9
    public void print() {
10
        for (int i = 1; i < level; i++) {
11
            System.out.print("--");
12
        }
13
        System.out.println(name);
14
    }
15
}

MenuItem是菜单项，不能再有子菜单，所以添加菜单，移除菜单和获取子菜单的功能并不能实现。

5.6.4 组合模式的分类

在使用组合模式时，根据抽象构件类的定义形式，我们可将组合模式分为透明组合模式和安全组合模式两种形式。

• 透明组合模式

  透明组合模式中，抽象根节点角色中声明了所有用于管理成员对象的方法，比如在示例中 MenuComponent 声明了 add、remove 、getChild 方法，这样做的好处是确保所有的构件类都有相同的接口。透明组合模式也是组合模式的标准形式。

  透明组合模式的缺点是不够安全，因为叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一个层次的对象，即不可能包含成员对象，因此为其提供 add()、remove() 等方法是没有意义的，这在编译阶段不会出错，但在运行阶段如果调用这些方法可能会出错（如果没有提供相应的错误处理代码）

• 安全组合模式

  在安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点 Menu 类中声明并实现这些方法。安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别地对待叶子构件和容器构件。

  

5.6.5 优点

• 组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
• 客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。
• 在组合模式中增加新的树枝节点和叶子节点都很方便，无须对现有类库进行任何修改，符合“开闭原则”。
• 组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子节点和树枝节点的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。

5.6.6 使用场景

组合模式正是应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方。比如：文件目录显示，多级目录呈现等树形结构数据的操作。

5.7 享元模式

5.7.1 概述

定义：

运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销，从而提高系统资源的利用率。

5.7.2 结构

享元（Flyweight ）模式中存在以下两种状态：

1. 内部状态，即不会随着环境的改变而改变的可共享部分。
2. 外部状态，指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

享元模式的主要有以下角色：

• 抽象享元角色（Flyweight）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。
• 具体享元（Concrete Flyweight）角色 ：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。
• 非享元（Unsharable Flyweight)角色 ：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
• 享元工厂（Flyweight Factory）角色 ：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

5.7.3 案例实现

【例】俄罗斯方块

下面的图片是众所周知的俄罗斯方块中的一个个方块，如果在俄罗斯方块这个游戏中，每个不同的方块都是一个实例对象，这些对象就要占用很多的内存空间，下面利用享元模式进行实现。

先来看类图：

代码如下：

俄罗斯方块有不同的形状，我们可以对这些形状向上抽取出AbstractBox，用来定义共性的属性和行为。

xxxxxxxxxx
7
1
public abstract class AbstractBox {
2
    public abstract String getShape();
3
​
4
    public void display(String color) {
5
        System.out.println("方块形状：" + this.getShape() + " 颜色：" + color);
6
    }
7
}

接下来就是定义不同的形状了，IBox类、LBox类、OBox类等。

xxxxxxxxxx
23
1
public class IBox extends AbstractBox {
2
​
3
    @Override
4
    public String getShape() {
5
        return "I";
6
    }
7
}
8
​
9
public class LBox extends AbstractBox {
10
​
11
    @Override
12
    public String getShape() {
13
        return "L";
14
    }
15
}
16
​
17
public class OBox extends AbstractBox {
18
​
19
    @Override
20
    public String getShape() {
21
        return "O";
22
    }
23
}

提供了一个工厂类（BoxFactory），用来管理享元对象（也就是AbstractBox子类对象），该工厂类对象只需要一个，所以可以使用单例模式。并给工厂类提供一个获取形状的方法。

xxxxxxxxxx
26
1
public class BoxFactory {
2
​
3
    private static HashMap<String, AbstractBox> map;
4
​
5
    private BoxFactory() {
6
        map = new HashMap<String, AbstractBox>();
7
        AbstractBox iBox = new IBox();
8
        AbstractBox lBox = new LBox();
9
        AbstractBox oBox = new OBox();
10
        map.put("I", iBox);
11
        map.put("L", lBox);
12
        map.put("O", oBox);
13
    }
14
​
15
    public static final BoxFactory getInstance() {
16
        return SingletonHolder.INSTANCE;
17
    }
18
​
19
    private static class SingletonHolder {
20
        private static final BoxFactory INSTANCE = new BoxFactory();
21
    }
22
​
23
    public AbstractBox getBox(String key) {
24
        return map.get(key);
25
    }
26
}

5.7.5 优缺点和使用场景

1，优点

• 极大减少内存中相似或相同对象数量，节约系统资源，提供系统性能
• 享元模式中的外部状态相对独立，且不影响内部状态

2，缺点：

为了使对象可以共享，需要将享元对象的部分状态外部化，分离内部状态和外部状态，使程序逻辑复杂

3，使用场景：

• 一个系统有大量相同或者相似的对象，造成内存的大量耗费。
• 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。
• 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。

5.7.6 JDK源码解析

Integer类使用了享元模式。我们先看下面的例子：

xxxxxxxxxx
13
1
public class Demo {
2
    public static void main(String[] args) {
3
        Integer i1 = 127;
4
        Integer i2 = 127;
5
​
6
        System.out.println("i1和i2对象是否是同一个对象？" + (i1 == i2));
7
​
8
        Integer i3 = 128;
9
        Integer i4 = 128;
10
​
11
        System.out.println("i3和i4对象是否是同一个对象？" + (i3 == i4));
12
    }
13
}

运行上面代码，结果如下：

为什么第一个输出语句输出的是true，第二个输出语句输出的是false？通过反编译软件进行反编译，代码如下：

xxxxxxxxxx
10
1
public class Demo {
2
    public static void main(String[] args) {
3
        Integer i1 = Integer.valueOf((int)127);
4
        Integer i2 Integer.valueOf((int)127);
5
        System.out.println((String)new StringBuilder().append((String)"i1\u548ci2\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i1 == i2)).toString());
6
        Integer i3 = Integer.valueOf((int)128);
7
        Integer i4 = Integer.valueOf((int)128);
8
        System.out.println((String)new StringBuilder().append((String)"i3\u548ci4\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i3 == i4)).toString());
9
    }
10
}

上面代码可以看到，直接给Integer类型的变量赋值基本数据类型数据的操作底层使用的是 valueOf() ，所以只需要看该方法即可

xxxxxxxxxx
38
1
public final class Integer extends Number implements Comparable<Integer> {
2
    
3
    public static Integer valueOf(int i) {
4
        if (i >= IntegerCache.low && i <= IntegerCache.high)
5
            return IntegerCache.cache[i + (-IntegerCache.low)];
6
        return new Integer(i);
7
    }
8
    
9
    private static class IntegerCache {
10
        static final int low = -128;
11
        static final int high;
12
        static final Integer cache[];
13
​
14
        static {
15
            int h = 127;
16
            String integerCacheHighPropValue =
17
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
18
            if (integerCacheHighPropValue != null) {
19
                try {
20
                    int i = parseInt(integerCacheHighPropValue);
21
                    i = Math.max(i, 127);
22
                    // Maximum array size is Integer.MAX_VALUE
23
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
24
                } catch( NumberFormatException nfe) {
25
                }
26
            }
27
            high = h;
28
            cache = new Integer[(high - low) + 1];
29
            int j = low;
30
            for(int k = 0; k < cache.length; k++)
31
                cache[k] = new Integer(j++);
32
            // range [-128, 127] must be interned (JLS7 5.1.7)
33
            assert IntegerCache.high >= 127;
34
        }
35
​
36
        private IntegerCache() {}
37
    }
38
}

可以看到 Integer 默认先创建并缓存 -128 ~ 127 之间数的 Integer 对象，当调用 valueOf 时如果参数在 -128 ~ 127 之间则计算下标并从缓存中返回，否则创建一个新的 Integer 对象。

6，行为型模式

行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。

行为型模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性。

行为型模式分为：

• 模板方法模式
• 策略模式
• 命令模式
• 职责链模式
• 状态模式
• 观察者模式
• 中介者模式
• 迭代器模式
• 访问者模式
• 备忘录模式
• 解释器模式

以上 11 种行为型模式，除了模板方法模式和解释器模式是类行为型模式，其他的全部属于对象行为型模式。

6.1 模板方法模式

6.1.1 概述

在面向对象程序设计过程中，程序员常常会遇到这种情况：设计一个系统时知道了算法所需的关键步骤，而且确定了这些步骤的执行顺序，但某些步骤的具体实现还未知，或者说某些步骤的实现与具体的环境相关。

例如，去银行办理业务一般要经过以下4个流程：取号、排队、办理具体业务、对银行工作人员进行评分等，其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的，可以在父类中实现，但是办理具体业务却因人而异，它可能是存款、取款或者转账等，可以延迟到子类中实现。

定义：

定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

6.1.2 结构

模板方法（Template Method）模式包含以下主要角色：

• 抽象类（Abstract Class）：负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。

  • 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。

  • 基本方法：是实现算法各个步骤的方法，是模板方法的组成部分。基本方法又可以分为三种：

    • 抽象方法(Abstract Method) ：一个抽象方法由抽象类声明、由其具体子类实现。

    • 具体方法(Concrete Method) ：一个具体方法由一个抽象类或具体类声明并实现，其子类可以进行覆盖也可以直接继承。

    • 钩子方法(Hook Method) ：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。

      一般钩子方法是用于判断的逻辑方法，这类方法名一般为isXxx，返回值类型为boolean类型。

• 具体子类（Concrete Class）：实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的组成步骤。

6.1.3 案例实现

【例】炒菜

炒菜的步骤是固定的，分为倒油、热油、倒蔬菜、倒调料品、翻炒等步骤。现通过模板方法模式来用代码模拟。类图如下：

代码如下：

xxxxxxxxxx
73
1
public abstract class AbstractClass {
2
    
3
    public final void cookProcess() {
4
        //第一步：倒油
5
        this.pourOil();
6
        //第二步：热油
7
        this.heatOil();
8
        //第三步：倒蔬菜
9
        this.pourVegetable();
10
        //第四步：倒调味料
11
        this.pourSauce();
12
        //第五步：翻炒
13
        this.fry();
14
    }
15
​
16
    public void pourOil() {
17
        System.out.println("倒油");
18
    }
19
​
20
    //第二步：热油是一样的，所以直接实现
21
    public void heatOil() {
22
        System.out.println("热油");
23
    }
24
​
25
    //第三步：倒蔬菜是不一样的（一个下包菜，一个是下菜心）
26
    public abstract void pourVegetable();
27
​
28
    //第四步：倒调味料是不一样
29
    public abstract void pourSauce();
30
​
31
​
32
    //第五步：翻炒是一样的，所以直接实现
33
    public void fry(){
34
        System.out.println("炒啊炒啊炒到熟啊");
35
    }
36
}
37
​
38
public class ConcreteClass_BaoCai extends AbstractClass {
39
​
40
    @Override
41
    public void pourVegetable() {
42
        System.out.println("下锅的蔬菜是包菜");
43
    }
44
​
45
    @Override
46
    public void pourSauce() {
47
        System.out.println("下锅的酱料是辣椒");
48
    }
49
}
50
​
51
public class ConcreteClass_CaiXin extends AbstractClass {
52
    @Override
53
    public void pourVegetable() {
54
        System.out.println("下锅的蔬菜是菜心");
55
    }
56
​
57
    @Override
58
    public void pourSauce() {
59
        System.out.println("下锅的酱料是蒜蓉");
60
    }
61
}
62
​
63
public class Client {
64
    public static void main(String[] args) {
65
        //炒手撕包菜
66
        ConcreteClass_BaoCai baoCai = new ConcreteClass_BaoCai();
67
        baoCai.cookProcess();
68
​
69
        //炒蒜蓉菜心
70
        ConcreteClass_CaiXin caiXin = new ConcreteClass_CaiXin();
71
        caiXin.cookProcess();
72
    }
73
}

注意：为防止恶意操作，一般模板方法都加上 final 关键词。

6.1.3 优缺点

优点：

• 提高代码复用性

  将相同部分的代码放在抽象的父类中，而将不同的代码放入不同的子类中。

• 实现了反向控制

  通过一个父类调用其子类的操作，通过对子类的具体实现扩展不同的行为，实现了反向控制 ，并符合“开闭原则”。

缺点：

• 对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象。
• 父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。

6.1.4 适用场景

• 算法的整体步骤很固定，但其中个别部分易变时，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现。
• 需要通过子类来决定父类算法中某个步骤是否执行，实现子类对父类的反向控制。

6.1.5 JDK源码解析

InputStream类就使用了模板方法模式。在InputStream类中定义了多个 read() 方法，如下：

xxxxxxxxxx
37
1
public abstract class InputStream implements Closeable {
2
    //抽象方法，要求子类必须重写
3
    public abstract int read() throws IOException;
4
​
5
    public int read(byte b[]) throws IOException {
6
        return read(b, 0, b.length);
7
    }
8
​
9
    public int read(byte b[], int off, int len) throws IOException {
10
        if (b == null) {
11
            throw new NullPointerException();
12
        } else if (off < 0 || len < 0 || len > b.length - off) {
13
            throw new IndexOutOfBoundsException();
14
        } else if (len == 0) {
15
            return 0;
16
        }
17
​
18
        int c = read(); //调用了无参的read方法，该方法是每次读取一个字节数据
19
        if (c == -1) {
20
            return -1;
21
        }
22
        b[off] = (byte)c;
23
​
24
        int i = 1;
25
        try {
26
            for (; i < len ; i++) {
27
                c = read();
28
                if (c == -1) {
29
                    break;
30
                }
31
                b[off + i] = (byte)c;
32
            }
33
        } catch (IOException ee) {
34
        }
35
        return i;
36
    }
37
}

从上面代码可以看到，无参的 read() 方法是抽象方法，要求子类必须实现。而 read(byte b[]) 方法调用了 read(byte b[], int off, int len) 方法，所以在此处重点看的方法是带三个参数的方法。

在该方法中第18行、27行，可以看到调用了无参的抽象的 read() 方法。

总结如下： 在InputStream父类中已经定义好了读取一个字节数组数据的方法是每次读取一个字节，并将其存储到数组的第一个索引位置，读取len个字节数据。具体如何读取一个字节数据呢？由子类实现。

6.2 策略模式

6.2.1 概述

先看下面的图片，我们去旅游选择出行模式有很多种，可以骑自行车、可以坐汽车、可以坐火车、可以坐飞机。

作为一个程序猿，开发需要选择一款开发工具，当然可以进行代码开发的工具有很多，可以选择Idea进行开发，也可以使用eclipse进行开发，也可以使用其他的一些开发工具。

定义：

该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

6.2.2 结构

策略模式的主要角色如下：

• 抽象策略（Strategy）类：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
• 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现或行为。
• 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

6.2.3 案例实现

【例】促销活动

一家百货公司在定年度的促销活动。针对不同的节日（春节、中秋节、圣诞节）推出不同的促销活动，由促销员将促销活动展示给客户。类图如下：

代码如下：

定义百货公司所有促销活动的共同接口

xxxxxxxxxx
3
1
public interface Strategy {
2
    void show();
3
}

定义具体策略角色（Concrete Strategy）：每个节日具体的促销活动

xxxxxxxxxx
23
1
//为春节准备的促销活动A
2
public class StrategyA implements Strategy {
3
​
4
    public void show() {
5
        System.out.println("买一送一");
6
    }
7
}
8
​
9
//为中秋准备的促销活动B
10
public class StrategyB implements Strategy {
11
​
12
    public void show() {
13
        System.out.println("满200元减50元");
14
    }
15
}
16
​
17
//为圣诞准备的促销活动C
18
public class StrategyC implements Strategy {
19
​
20
    public void show() {
21
        System.out.println("满1000元加一元换购任意200元以下商品");
22
    }
23
}

定义环境角色（Context）：用于连接上下文，即把促销活动推销给客户，这里可以理解为销售员

xxxxxxxxxx
13
1
public class SalesMan {                        
2
    //持有抽象策略角色的引用                              
3
    private Strategy strategy;                 
4
                                               
5
    public SalesMan(Strategy strategy) {       
6
        this.strategy = strategy;              
7
    }                                          
8
                                               
9
    //向客户展示促销活动                                
10
    public void salesManShow(){                
11
        strategy.show();                       
12
    }                                          
13
}                                              

6.2.4 优缺点

1，优点：

• 策略类之间可以自由切换

  由于策略类都实现同一个接口，所以使它们之间可以自由切换。

• 易于扩展

  增加一个新的策略只需要添加一个具体的策略类即可，基本不需要改变原有的代码，符合“开闭原则“

• 避免使用多重条件选择语句（if else），充分体现面向对象设计思想。

2，缺点：

• 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
• 策略模式将造成产生很多策略类，可以通过使用享元模式在一定程度上减少对象的数量。

6.2.5 使用场景

• 一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。
• 一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。
• 系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时。
• 系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构。
• 多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。

6.2.6 JDK源码解析

Comparator 中的策略模式。在Arrays类中有一个 sort() 方法，如下：

xxxxxxxxxx
12
1
public class Arrays{
2
    public static <T> void sort(T[] a, Comparator<? super T> c) {
3
        if (c == null) {
4
            sort(a);
5
        } else {
6
            if (LegacyMergeSort.userRequested)
7
                legacyMergeSort(a, c);
8
            else
9
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
10
        }
11
    }
12
}

Arrays就是一个环境角色类，这个sort方法可以传一个新策略让Arrays根据这个策略来进行排序。就比如下面的测试类。

xxxxxxxxxx
13
1
public class demo {
2
    public static void main(String[] args) {
3
​
4
        Integer[] data = {12, 2, 3, 2, 4, 5, 1};
5
        // 实现降序排序
6
        Arrays.sort(data, new Comparator<Integer>() {
7
            public int compare(Integer o1, Integer o2) {
8
                return o2 - o1;
9
            }
10
        });
11
        System.out.println(Arrays.toString(data)); //[12, 5, 4, 3, 2, 2, 1]
12
    }
13
}

这里我们在调用Arrays的sort方法时，第二个参数传递的是Comparator接口的子实现类对象。所以Comparator充当的是抽象策略角色，而具体的子实现类充当的是具体策略角色。环境角色类（Arrays）应该持有抽象策略的引用来调用。那么，Arrays类的sort方法到底有没有使用Comparator子实现类中的 compare() 方法吗？让我们继续查看TimSort类的 sort() 方法，代码如下：

xxxxxxxxxx
37
1
class TimSort<T> {
2
    static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
3
                         T[] work, int workBase, int workLen) {
4
        assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
5
​
6
        int nRemaining  = hi - lo;
7
        if (nRemaining < 2)
8
            return;  // Arrays of size 0 and 1 are always sorted
9
​
10
        // If array is small, do a "mini-TimSort" with no merges
11
        if (nRemaining < MIN_MERGE) {
12
            int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
13
            binarySort(a, lo, hi, lo + initRunLen, c);
14
            return;
15
        }
16
        ...
17
    }   
18
        
19
    private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,Comparator<? super T> c) {
20
        assert lo < hi;
21
        int runHi = lo + 1;
22
        if (runHi == hi)
23
            return 1;
24
​
25
        // Find end of run, and reverse range if descending
26
        if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
27
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
28
                runHi++;
29
            reverseRange(a, lo, runHi);
30
        } else {                              // Ascending
31
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
32
                runHi++;
33
        }
34
​
35
        return runHi - lo;
36
    }
37
}

上面的代码中最终会跑到 countRunAndMakeAscending() 这个方法中。我们可以看见，只用了compare方法，所以在调用Arrays.sort方法只传具体compare重写方法的类对象就行，这也是Comparator接口中必须要子类实现的一个方法。

6.3 命令模式

6.3.1 概述

日常生活中，我们出去吃饭都会遇到下面的场景。

定义：

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行存储、传递、调用、增加与管理。

6.3.2 结构

命令模式包含以下主要角色：

• 抽象命令类（Command）角色： 定义命令的接口，声明执行的方法。
• 具体命令（Concrete Command）角色：具体的命令，实现命令接口；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
• 实现者/接收者（Receiver）角色： 接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
• 调用者/请求者（Invoker）角色： 要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。

6.3.3 案例实现

将上面的案例用代码实现，那我们就需要分析命令模式的角色在该案例中由谁来充当。

服务员： 就是调用者角色，由她来发起命令。

资深大厨： 就是接收者角色，真正命令执行的对象。

订单： 命令中包含订单。

类图如下：

代码如下：

xxxxxxxxxx
116
1
public interface Command {
2
    void execute();//只需要定义一个统一的执行方法
3
}
4
​
5
public class OrderCommand implements Command {
6
​
7
    //持有接受者对象
8
    private SeniorChef receiver;
9
    private Order order;
10
​
11
    public OrderCommand(SeniorChef receiver, Order order){
12
        this.receiver = receiver;
13
        this.order = order;
14
    }
15
​
16
    public void execute()  {
17
        System.out.println(order.getDiningTable() + "桌的订单：");
18
        Set<String> keys = order.getFoodDic().keySet();
19
        for (String key : keys) {
20
            receiver.makeFood(order.getFoodDic().get(key),key);
21
        }
22
​
23
        try {
24
            Thread.sleep(100);//停顿一下 模拟做饭的过程
25
        } catch (InterruptedException e) {
26
            e.printStackTrace();
27
        }
28
​
29
​
30
        System.out.println(order.getDiningTable() + "桌的饭弄好了");
31
    }
32
}
33
​
34
public class Order {
35
    // 餐桌号码
36
    private int diningTable;
37
​
38
    // 用来存储餐名并记录份数
39
    private Map<String, Integer> foodDic = new HashMap<String, Integer>();
40
​
41
    public int getDiningTable() {
42
        return diningTable;
43
    }
44
​
45
    public void setDiningTable(int diningTable) {
46
        this.diningTable = diningTable;
47
    }
48
​
49
    public Map<String, Integer> getFoodDic() {
50
        return foodDic;
51
    }
52
​
53
    public void setFoodDic(String name, int num) {
54
        foodDic.put(name,num);
55
    }
56
}
57
​
58
// 资深大厨类 是命令的Receiver
59
public class SeniorChef {
60
​
61
    public void makeFood(int num,String foodName) {
62
        System.out.println(num + "份" + foodName);
63
    }
64
}
65
​
66
public class Waitor {
67
​
68
    private ArrayList<Command> commands;//可以持有很多的命令对象
69
​
70
    public Waitor() {
71
        commands = new ArrayList();
72
    }
73
    
74
    public void setCommand(Command cmd){
75
        commands.add(cmd);
76
    }
77
​
78
    // 发出命令 喊 订单来了，厨师开始执行
79
    public void orderUp() {
80
        System.out.println("美女服务员：叮咚，大厨，新订单来了.......");
81
        for (int i = 0; i < commands.size(); i++) {
82
            Command cmd = commands.get(i);
83
            if (cmd != null) {
84
                cmd.execute();
85
            }
86
        }
87
    }
88
}
89
​
90
public class Client {
91
    public static void main(String[] args) {
92
        //创建2个order
93
        Order order1 = new Order();
94
        order1.setDiningTable(1);
95
        order1.getFoodDic().put("西红柿鸡蛋面",1);
96
        order1.getFoodDic().put("小杯可乐",2);
97
​
98
        Order order2 = new Order();
99
        order2.setDiningTable(3);
100
        order2.getFoodDic().put("尖椒肉丝盖饭",1);
101
        order2.getFoodDic().put("小杯雪碧",1);
102
​
103
        //创建接收者
104
        SeniorChef receiver=new SeniorChef();
105
        //将订单和接收者封装成命令对象
106
        OrderCommand cmd1 = new OrderCommand(receiver, order1);
107
        OrderCommand cmd2 = new OrderCommand(receiver, order2);
108
        //创建调用者 waitor
109
        Waitor invoker = new Waitor();
110
        invoker.setCommand(cmd1);
111
        invoker.setCommand(cmd2);
112
​
113
        //将订单带到柜台 并向厨师喊 订单来了
114
        invoker.orderUp();
115
    }
116
}

6.3.4 优缺点

1，优点：

• 降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦。
• 增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，它满足“开闭原则”，对扩展比较灵活。
• 可以实现宏命令。命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令。
• 方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合，实现命令的撤销与恢复。

2，缺点：

• 使用命令模式可能会导致某些系统有过多的具体命令类。
• 系统结构更加复杂。

6.3.5 使用场景

• 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。
• 系统需要在不同的时间指定请求、将请求排队和执行请求。
• 系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作。

6.3.6 JDK源码解析

Runable是一个典型命令模式，Runnable担当命令的角色，Thread充当的是调用者，start方法就是其执行方法

xxxxxxxxxx
31
1
//命令接口(抽象命令角色)
2
public interface Runnable {
3
    public abstract void run();
4
}
5
​
6
//调用者
7
public class Thread implements Runnable {
8
    private Runnable target;
9
    
10
    public synchronized void start() {
11
        if (threadStatus != 0)
12
            throw new IllegalThreadStateException();
13
​
14
        group.add(this);
15
​
16
        boolean started = false;
17
        try {
18
            start0();
19
            started = true;
20
        } finally {
21
            try {
22
                if (!started) {
23
                    group.threadStartFailed(this);
24
                }
25
            } catch (Throwable ignore) {
26
            }
27
        }
28
    }
29
    
30
    private native void start0();
31
}

会调用一个native方法start0(),调用系统方法，开启一个线程。而接收者是对程序员开放的，可以自己定义接收者。

xxxxxxxxxx
14
1
/**
2
 * jdk Runnable 命令模式
3
 *      TurnOffThread ： 属于具体
4
 */
5
public class TurnOffThread implements Runnable{
6
     private Receiver receiver;
7
    
8
     public TurnOffThread(Receiver receiver) {
9
        this.receiver = receiver;
10
     }
11
     public void run() {
12
        receiver.turnOFF();
13
     }
14
}

xxxxxxxxxx
11
1
/**
2
 * 测试类
3
 */
4
public class Demo {
5
     public static void main(String[] args) {
6
         Receiver receiver = new Receiver();
7
         TurnOffThread turnOffThread = new TurnOffThread(receiver);
8
         Thread thread = new Thread(turnOffThread);
9
         thread.start();
10
     }
11
}

6.4 责任链模式

6.4.1 概述

在现实生活中，常常会出现这样的事例：一个请求有多个对象可以处理，但每个对象的处理条件或权限不同。例如，公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据自己要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这增加了难度。这样的例子还有很多，如找领导出差报销、生活中的“击鼓传花”游戏等。

定义：

又名职责链模式，为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

6.4.2 结构

职责链模式主要包含以下角色:

• 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
• 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
• 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

6.4.3 案例实现

现需要开发一个请假流程控制系统。请假一天以下的假只需要小组长同意即可；请假1天到3天的假还需要部门经理同意；请求3天到7天还需要总经理同意才行。

类图如下：

代码如下：

xxxxxxxxxx
138
1
//请假条
2
public class LeaveRequest {
3
    private String name;//姓名
4
    private int num;//请假天数
5
    private String content;//请假内容
6
​
7
    public LeaveRequest(String name, int num, String content) {
8
        this.name = name;
9
        this.num = num;
10
        this.content = content;
11
    }
12
​
13
    public String getName() {
14
        return name;
15
    }
16
​
17
    public int getNum() {
18
        return num;
19
    }
20
​
21
    public String getContent() {
22
        return content;
23
    }
24
}
25
​
26
//处理者抽象类
27
public abstract class Handler {
28
    protected final static int NUM_ONE = 1;
29
    protected final static int NUM_THREE = 3;
30
    protected final static int NUM_SEVEN = 7;
31
​
32
    //该领导处理的请假天数区间
33
    private int numStart;
34
    private int numEnd;
35
​
36
    //领导上面还有领导
37
    private Handler nextHandler;
38
​
39
    //设置请假天数范围 上不封顶
40
    public Handler(int numStart) {
41
        this.numStart = numStart;
42
    }
43
​
44
    //设置请假天数范围
45
    public Handler(int numStart, int numEnd) {
46
        this.numStart = numStart;
47
        this.numEnd = numEnd;
48
    }
49
​
50
    //设置上级领导
51
    public void setNextHandler(Handler nextHandler){
52
        this.nextHandler = nextHandler;
53
    }
54
​
55
    //提交请假条
56
    public final void submit(LeaveRequest leave){
57
        if(0 == this.numStart){
58
            return;
59
        }
60
​
61
        //如果请假天数达到该领导者的处理要求
62
        if(leave.getNum() >= this.numStart){
63
            this.handleLeave(leave);
64
​
65
            //如果还有上级 并且请假天数超过了当前领导的处理范围
66
            if(null != this.nextHandler && leave.getNum() > numEnd){
67
                this.nextHandler.submit(leave);//继续提交
68
            } else {
69
                System.out.println("流程结束");
70
            }
71
        }
72
    }
73
​
74
    //各级领导处理请假条方法
75
    protected abstract void handleLeave(LeaveRequest leave);
76
}
77
​
78
//小组长
79
public class GroupLeader extends Handler {
80
    public GroupLeader() {
81
        //小组长处理1-3天的请假
82
        super(Handler.NUM_ONE, Handler.NUM_THREE);
83
    }
84
​
85
    @Override
86
    protected void handleLeave(LeaveRequest leave) {
87
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
88
        System.out.println("小组长审批：同意。");
89
    }
90
}
91
​
92
//部门经理
93
public class Manager extends Handler {
94
    public Manager() {
95
        //部门经理处理3-7天的请假
96
        super(Handler.NUM_THREE, Handler.NUM_SEVEN);
97
    }
98
​
99
    @Override
100
    protected void handleLeave(LeaveRequest leave) {
101
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
102
        System.out.println("部门经理审批：同意。");
103
    }
104
}
105
​
106
//总经理
107
public class GeneralManager extends Handler {
108
    public GeneralManager() {
109
        //部门经理处理7天以上的请假
110
        super(Handler.NUM_SEVEN);
111
    }
112
​
113
    @Override
114
    protected void handleLeave(LeaveRequest leave) {
115
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
116
        System.out.println("总经理审批：同意。");
117
    }
118
}
119
​
120
//测试类
121
public class Client {
122
    public static void main(String[] args) {
123
        //请假条来一张
124
        LeaveRequest leave = new LeaveRequest("小花",5,"身体不适");
125
​
126
        //各位领导
127
        GroupLeader groupLeader = new GroupLeader();
128
        Manager manager = new Manager();
129
        GeneralManager generalManager = new GeneralManager();
130
​
131
        groupLeader.setNextHandler(manager);//小组长的领导是部门经理
132
        manager.setNextHandler(generalManager);//部门经理的领导是总经理
133
        //之所以在这里设置上级领导，是因为可以根据实际需求来更改设置，如果实战中上级领导人都是固定的，则可以移到领导实现类中。
134
​
135
        //提交申请
136
        groupLeader.submit(leave);
137
    }
138
}

6.4.4 优缺点

1，优点：

• 降低了对象之间的耦合度

  该模式降低了请求发送者和接收者的耦合度。

• 增强了系统的可扩展性

  可以根据需要增加新的请求处理类，满足开闭原则。

• 增强了给对象指派职责的灵活性

  当工作流程发生变化，可以动态地改变链内的成员或者修改它们的次序，也可动态地新增或者删除责任。

• 责任链简化了对象之间的连接

  一个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。

• 责任分担

  每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

2，缺点：

• 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
• 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
• 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

6.4.5 源码解析

在javaWeb应用开发中，FilterChain是职责链（过滤器）模式的典型应用，以下是Filter的模拟实现分析:

• 模拟web请求Request以及web响应Response

  xxxxxxxxxx
  7
  1
  public interface Request{
  2
   
  3
  }
  4
  ​
  5
  public interface Response{
  6
   
  7
  }
  

• 模拟web过滤器Filter

  xxxxxxxxxx
  3
  1
   public interface Filter {
  2
      public void doFilter(Request req,Response res,FilterChain c);
  3
   }
  

• 模拟实现具体过滤器

  xxxxxxxxxx
  25
  1
  public class FirstFilter implements Filter {
  2
      @Override
  3
      public void doFilter(Request request, Response response, FilterChain chain) {
  4
  ​
  5
          System.out.println("过滤器1 前置处理");
  6
  ​
  7
          // 先执行所有request再倒序执行所有response
  8
          chain.doFilter(request, response);
  9
  ​
  10
          System.out.println("过滤器1 后置处理");
  11
      }
  12
  }
  13
  ​
  14
  public class SecondFilter  implements Filter {
  15
      @Override
  16
      public void doFilter(Request request, Response response, FilterChain chain) {
  17
  ​
  18
          System.out.println("过滤器2 前置处理");
  19
  ​
  20
          // 先执行所有request再倒序执行所有response
  21
          chain.doFilter(request, response);
  22
  ​
  23
          System.out.println("过滤器2 后置处理");
  24
      }
  25
  }
  

• 模拟实现过滤器链FilterChain

  xxxxxxxxxx
  21
  1
  public class FilterChain {
  2
  ​
  3
      private List<Filter> filters = new ArrayList<Filter>();
  4
  ​
  5
      private int index = 0;
  6
  ​
  7
      // 链式调用
  8
      public FilterChain addFilter(Filter filter) {
  9
          this.filters.add(filter);
  10
          return this;
  11
      }
  12
  ​
  13
      public void doFilter(Request request, Response response) {
  14
          if (index == filters.size()) {
  15
              return;
  16
          }
  17
          Filter filter = filters.get(index);
  18
          index++;
  19
          filter.doFilter(request, response, this);
  20
      }
  21
  }
  

• 测试类

  xxxxxxxxxx
  10
  1
  public class Client {
  2
      public static void main(String[] args) {
  3
          Request  req = null;
  4
          Response res = null ;
  5
  ​
  6
          FilterChain filterChain = new FilterChain();
  7
          filterChain.addFilter(new FirstFilter()).addFilter(new SecondFilter());
  8
          filterChain.doFilter(req,res);
  9
      }
  10
  }