设计模式10 行为型模式4-策略+职责链22. 策略模式上面说的 1 的问题，其实是继承带来的问题：对类的局部改动，尤

完整设计模式学习笔记请戳

22. 策略模式

编写鸭子项目，具体要求如下:

有各种鸭子(比如野鸭、北京鸭、水鸭等，鸭子有各种行为，比如叫、飞行等)
显示鸭子的信息

传统方式解决问题类图

传统的方式实现的问题分析和解决方案

其它鸭子，都继承了 Duck 类，所以 fly 让所有子类都会飞了，这是不正确的
上面说的 1 的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改动，会影响其他部分。会有溢出效应
为了改进 1 问题，我们可以通过覆盖 fly 方法来解决 => 覆盖解决
问题又来了，如果我们有一个玩具鸭子 ToyDuck, 这样就需要 ToyDuck 去覆盖 Duck 的所有实现的方法 => 解决思路 -> 策略模式 (strategy pattern)

基本介绍

策略模式（Strategy Pattern）中，定义算法族（策略组），分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户
这算法体现了几个设计原则，第一、把变化的代码从不变的代码中分离出来；第二、针对接口编程而不是具体类（定义了策略接口）；第三、多用组合/聚合，少用继承（客户通过组合方式使用策略）

说明：从上图可以看到，客户 context 有成员变量 strategy 或者其他的策略接口 ,至于需要使用到哪个策略，我们可以在构造器中指定

代码实现

① 行为接口

public interface FlyBehavior {
    void fly();
}

② 具体行为

public class GoodFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("自由飞翔，飞翔能力max");
    }
}


public class BadFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("飞翔技术不太行");
    }
}


public class NoFlyBehavior implements FlyBehavior {
    @Override
    public void fly() {
        System.out.println("不会飞");
    }
}

③ 行为执行者组合不同的行为

public class WildDuck extends Duck {

    public WildDuck() {
        flyBehavior = new GoodFlyBehavior();
    }

    @Override
    void display() {
        System.out.println("野鸭子");
    }

}


public class PekingDuck extends Duck {

    public PekingDuck() {
        flyBehavior = new BadFlyBehavior();
    }

    @Override
    void display() {
        System.out.println("北京鸭");
    }

}


public class ToyDuck extends Duck{

    public ToyDuck() {
        flyBehavior = new NoFlyBehavior();
    }

    @Override
    void display() {
        System.out.println("玩具鸭");
    }

}

④ 客户端测试

public class Client {
    public static void main(String[] args) {
        WildDuck wildDuck = new WildDuck();
        wildDuck.display();
        wildDuck.fly();
        PekingDuck pekingDuck = new PekingDuck();
        pekingDuck.display();
        pekingDuck.fly();
    }
}

策略模式在 JDK-Arrays 应用的源码分析

JDK 的 Arrays 的 Comparator 就使用了策略模式

public class Strategy {
    public static void main(String[] args) {
        //数组
        Integer[] data = {9, 1, 2, 8, 4, 3};
        // 实现降序排序，返回-1 放左边，1 放右边，0 保持不变
        // 说 明
        // 1.  实现了 Comparator 接口（策略接口） , 匿名类 对象 new Comparator<Integer>(){..}
        // 2.  对象 new Comparator<Integer>(){..}  就是实现了 策略接口 的对象
        // 3. public int compare(Integer o1, Integer o2){} 指定具体的处理方式
        Comparator<Integer> comparator = new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                if (o1 > o2) {
                    return -1;
                } else {
                    return 1;
                }
            }

            ;
        };

        // 说 明
        /*
        public static <T> void sort(T[] a, Comparator<? super T> c) {
            if (c == null) {
                sort(a);
            } else {
                if (LegacyMergeSort.userRequested)
                    legacyMergeSort(a, c);
                else
                    TimSort.sort(a, 0, a.length, c, null, 0, 0);
            }
        }
         */

        //方式 1
        Arrays.sort(data, comparator);
        System.out.println(Arrays.toString(data)); // 降序排序

        //方式 2- 同时 lambda 表达式实现 策略模式
        Integer[] data2 = {19, 11, 12, 18, 14, 13};
        Arrays.sort(data2, (var1, var2) -> {
            if (var1.compareTo(var2) > 0) {
                return -1;
            } else {
                return 1;
            }
        });

        System.out.println("data2=" + Arrays.toString(data2));

    }
}

2)在Android中，使用ListView时都需要设置一个Adapter，而这个Adapter根据我们实际的需求可以用ArrayAdapter、SimpleAdapter等等，这里就运用到策略模式。

策略模式的注意事项和细节

策略模式的关键是：分析项目中变化部分与不变部分
策略模式的核心思想是：多用组合/聚合少用继承；用行为类组合，而不是行为的继承。更有弹性
体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略（或者行为）即可，避免了使用多重转移语句（if..else if..else）
提供了可以替换继承关系的办法：策略模式将算法封装在独立的 Strategy 类中使得你可以独立于其 Context 改变它，使它易于切换、易于理解、易于扩展
需要注意的是：每添加一个策略就要增加一个类，当策略过多是会导致类数目庞

23. 职责链模式

需求：学校 OA 系统的采购审批项目
采购员采购教学器材

如果金额小于等于 5000, 由教学主任审批（0<=x<=5000）
如果金额小于等于 10000, 由院长审批 (5000<x<=10000)
如果金额小于等于 30000, 由副校长审批 (10000<x<=30000)
如果金额超过 30000 以上，有校长审批 ( 30000<x) 请设计程序完成采购审批项目

传统设计方案：

传统方案解决 OA 系统审批问题分析

传统方式是：接收到一个采购请求后，根据采购金额来调用对应的 Approver (审批人)完成审批。
传统方式的问题分析 : 客户端这里会使用到分支判断(比如 switch) 来对不同的采购请求处理，这样就存在如下问题 (1) 如果各个级别的人员审批金额发生变化，在客户端的也需要变化 (2) 客户端必须明确的知道有多少个审批级别和访问
这样对一个采购请求进行处理和 Approver (审批人) 就存在强耦合关系，不利于代码的扩展和维护
解决方案 => 职责链模式

基本介绍

职责链模式（Chain of Responsibility Pattern）, 又叫责任链模式，为请求创建了一个接收者对象的链(简单示意图)。这种模式对请求的发送者和接收者进行解耦。
职责链模式通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。
这种类型的设计模式属于行为型模式

对原理类图的说明-即(职责链模式的角色及职责)

Handler : 抽象的处理者, 定义了一个处理请求的接口, 同时含义另外 Handler
ConcreteHandlerA , B 是具体的处理者, 处理它自己负责的请求，可以访问它的后继者(即下一个处理者), 如果可以处理当前请求，则处理，否则就将该请求交个后继者去处理，从而形成一个职责链
Request ，含义很多属性，表示一个请求

代码实现

① 编写请求（Request角色）

public class PurchaseRequest {
    private int type = 0;
    private float price = 0.0f;
    private int id = 0;

    public PurchaseRequest(int id, int type, float price) {
        this.type = type;
        this.id = id;
        this.price = price;
    }

    public int getType() {
        return type;
    }

    public float getPrice() {
        return price;
    }

    public int getId() {
        return id;
    }
}

② 抽象的请求处理者（Handler角色）

public abstract class Approver {

    protected Approver approver;//下一个处理者
    protected String name;//名字

    public Approver(String name) {
        this.name = name;
    }

    public void setApprover(Approver approver) {
        this.approver = approver;
    }

    abstract void processRequest(PurchaseRequest request);
}

③ 具体的请求处理者（ConcreteHandler角色）

public class DepartmentApprover extends Approver{

    public DepartmentApprover(String name) {
        super(name);
    }


    @Override
    void processRequest(PurchaseRequest request) {
        if (request.getPrice()<=5000){
            System.out.println("请求编号id="+request.getId()+" 被 "+this.name+"处理");
        }else {
            System.out.println(this.name+"无法处理，交给上一级处理 -> "+approver.name);
            approver.processRequest(request);
        }
    }

}


public class CollegeApprover extends Approver{

    public CollegeApprover(String name) {
        super(name);
    }
    
    @Override
    void processRequest(PurchaseRequest request) {
        if (request.getPrice()>5000&&request.getPrice()<=10000){
            System.out.println("请求编号id="+request.getId()+" 被 "+this.name+"处理");
        }else {
            System.out.println(this.name+"无法处理，交给上一级处理 -> "+approver.name);
            approver.processRequest(request);
        }
    }
}

public class ViceSchoolMasterApprover extends Approver{

    public ViceSchoolMasterApprover(String name) {
        super(name);
    }

    @Override
    void processRequest(PurchaseRequest request) {
        if (request.getPrice()>10000&&request.getPrice()<=30000){
            System.out.println("请求编号id="+request.getId()+" 被 "+this.name+"处理");
        }else {
            System.out.println(this.name+"无法处理，交给上一级处理 -> "+approver.name);
            approver.processRequest(request);
        }
    }

}


public class SchoolMasterApprover extends Approver{

    public SchoolMasterApprover(String name) {
        super(name);
    }

    @Override
    void processRequest(PurchaseRequest request) {
        if (request.getPrice()>30000){
            System.out.println("请求编号id="+request.getId()+" 被 "+this.name+"处理");
        }else {
            System.out.println(this.name+"无法处理，交给下一级处理 -> "+approver.name);
            approver.processRequest(request);
        }
    }

}

④ 客户端调用

public class Client {
    public static void main(String[] args) {
    
        //创建一个审批请求
        PurchaseRequest request = new PurchaseRequest(1,1,13200);
        //创建相关的审批人
        DepartmentApprover departmentApprover = new DepartmentApprover("主任");
        CollegeApprover collegeApprover = new CollegeApprover("院长");
        ViceSchoolMasterApprover viceSchoolMasterApprover = new ViceSchoolMasterApprover("副校长");
        SchoolMasterApprover schoolMasterApprover = new SchoolMasterApprover("校长");
        //需要将各个审批节点的下一级设置好
        departmentApprover.setApprover(collegeApprover);
        collegeApprover.setApprover(viceSchoolMasterApprover);
        viceSchoolMasterApprover.setApprover(schoolMasterApprover);
        schoolMasterApprover.setApprover(departmentApprover);
        //处理请求
        departmentApprover.processRequest(request);

    }
}

输出

主任无法处理，交给上一级处理 -> 院长
院长无法处理，交给上一级处理 -> 副校长
请求编号id=1 被 副校长处理

职责链应用

Android中的事件分发机制就是类似于责任链模式。
另外，OKhttp中对请求的处理也是用到了责任链模式。

职责链模式的注意事项和细节

将请求和处理分开，实现解耦，提高系统的灵活性
简化了对象，使对象不需要知道链的结构
性能会受到影响，特别是在链比较长的时候，因此需控制链中最大节点数量，一般通过在 Handler 中设置一个最大节点数量，在 setNext()方法中判断是否已经超过阀值，超过则不允许该链建立，避免出现超长链无意识地破坏系统性能
调试不方便。采用了类似递归的方式，调试时逻辑可能比较复杂
最佳应用场景：有多个对象可以处理同一个请求时，比如：多级请求、请假/加薪等审批流程、Java Web 中 Tomcat 对 Encoding 的处理、拦截器

设计模式学习代码及笔记）

【代码】
github.com/willShuhuan…
【笔记】
设计模式01 七大原则
 设计模式02 类关系与UML类图
 设计模式03 创建型模式1-单例+工厂
 设计模式04 创建型模式2-原型+建造者
 设计模式05 结构型模式1-适配器+桥接+装饰者
 设计模式06 结构型模式2-组合+外观+享元+代理
 设计模式07 行为型模式1-模板方法+命令+访问者
 设计模式08 行为型模式2-迭代器+观察者+中介者
 设计模式09 行为型模式3-备忘录+解释器+状态
 设计模式10 行为型模式4-策略+职责链