天天看点
返回

策略模式、职责链模式

策略模式、职责链模式

策略模式

将原本继承的方式，换成组合、聚合，让算法变化(策略)与算法客户(对象)分离

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

1)有各种鸭子(比如 野鸭、北京鸭、水鸭等， 鸭子有各种行为，比如 叫、飞行等)

2)显示鸭子的信息

二、传统方案解决鸭子问题的分析和代码实现

1)传统的设计方案(类图)

策略模式、职责链模式

2)类图

策略模式、职责链模式

3)代码实现

Duck抽象类

public abstract class Duck {<!-- -->
    public Duck() {<!-- -->}
    
    public abstract void display();//显示鸭子信息
    
    public void quack() {<!-- -->
        System.out.println("鸭子嘎嘎叫~~");
    }

    public void swim() {<!-- -->
        System.out.println("鸭子会游泳~~");
    }

    public void fly() {<!-- -->
        System.out.println("鸭子会飞翔~~~");
    }
}

PekingDuck

public class PekingDuck extends Duck {<!-- -->
    @Override
    public void display() {<!-- -->
        System.out.println("~~北京鸭~~~");
    }

    //因为北京鸭不能飞翔，因此需要重写 fly 
    @Override
    public void fly() {<!-- -->
        System.out.println("北京鸭不能飞翔");
    }
}

ToyDuck

public class ToyDuck extends Duck{<!-- -->
    @Override
    public void display() {<!-- -->
        System.out.println("玩具鸭");
    }
    
    //需要重写父类的所有方法 
    @Override
    public void quack() {<!-- -->
        System.out.println("玩具鸭不能叫~~");
    }

    @Override
    public void swim() {<!-- -->
        System.out.println("玩具鸭不会游泳~~");
    }

    @Override
    public void fly() {<!-- -->
        System.out.println("玩具鸭不会飞翔~~~");
    }
    
}

WildDuck

public class WildDuck extends Duck {<!-- -->
    @Override
    public void display() {<!-- -->
        System.out.println(" 这是野鸭 ");
    }
}

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

1)其它鸭子，都继承了 Duck 类，所以 fly 让所有子类都会飞了，这是不正确的

2)上面说的 1 的问题，其实是继承带来的问题：对类的局部改动，尤其超类的局部改动，会影响其他部分。如果

基类改变

，那么就会有

溢出效应

3)为了改进 1 问题，我们可以通过覆盖 fly 方法来解决 =; 覆盖解决

4)问题又来了，如果我们有一个玩具鸭子 ToyDuck, 这样就需要 ToyDuck 去覆盖 Duck 的所有实现的方法 ===; 解决思路 -》

策略模式 (strategy pattern)

我们的子类需要用到基类的内容，但又不想重写那么就可以使用策略模式

四、 策略模式基本介绍

1)策略模式（Strategy Pattern）中， 定义算法族（策略组），分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户

2)这算法体现了几个设计原则：

第一、把变化的代码从不变的代码中分离出来； 第二、针对接口编程而不是具体类（定义了策略接口）； 第三、

多用组合/聚合，少用继承

（客户通过组合方式使用策略）。

五、类图

策略模式、职责链模式

**说明**：

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

六、 策略模式解决鸭子问题

1)应用实例要求

编写程序完成前面的鸭子项目，要求使用策略模式

2)思路分析(类图)

抽象鸭子每一个动作为一个行为接口（策略接口），鸭子生物抽象一个抽象类（content类）

策略模式：

分别封装行为接口，实现算法族，超类里放行为接口对象，在子类里具体设定行为对象。原则就是： 分离变化部分，封装接口，基于接口编程各种功能。此模式让行为的变化独立于算法的使用者

策略模式、职责链模式

3)代码实现

BadFlyBehavior

public class BadFlyBehavior implements FlyBehavior {<!-- -->
    @Override
    public void fly() {<!-- -->
        System.out.println(" 飞翔技术一般 ");
    }
}

主函数

public class Client {<!-- -->
    public static void main(String[] args) {<!-- -->
        WildDuck wildDuck = new WildDuck(); 
        wildDuck.fly();//
        ToyDuck toyDuck = new ToyDuck(); 
        toyDuck.fly();
        PekingDuck pekingDuck = new PekingDuck(); 
        pekingDuck.fly();

        //动态改变某个对象的行为, 北京鸭 不能飞
        pekingDuck.setFlyBehavior(new NoFlyBehavior());
        System.out.println("北京鸭的实际飞翔能力");
        pekingDuck.fly();
    }
}

Duck抽象类

public abstract class Duck {<!-- -->
    //属性, 策略接口
    FlyBehavior flyBehavior;//聚合关系
    //其它属性;-;策略接口
    QuackBehavior quackBehavior;

    public Duck() {<!-- -->}
    public abstract void display();//显示鸭子信息
    public void quack() {<!-- -->
        System.out.println("鸭子嘎嘎叫~~");
    }

    public void swim() {<!-- -->
        System.out.println("鸭子会游泳~~");
    }

    public void fly() {<!-- -->
        //改进
        if(flyBehavior != null) {<!-- --> 
            flyBehavior.fly();
        }
    }
    
    public void setFlyBehavior(FlyBehavior flyBehavior) {<!-- --> 
        this.flyBehavior = flyBehavior;
    }

    public void setQuackBehavior(QuackBehavior quackBehavior) {<!-- --> 
        this.quackBehavior = quackBehavior;
    }
}

FlyBehavior接口，鸭子飞翔策略接口

public interface FlyBehavior {<!-- -->
    void fly(); //  子类具体实现
}

GoodFlyBehavior

public class GoodFlyBehavior implements FlyBehavior {<!-- -->    @Override    public void fly() {<!-- -->        System.out.println(" 飞翔技术高超 ~~~");    }}

NoFlyBehavior

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

PekingDuck

public class PekingDuck extends Duck {<!-- -->    //假如北京鸭可以飞翔，但是飞翔技术一般     public PekingDuck() {<!-- -->        flyBehavior = new BadFlyBehavior();    }    @Override    public void display() {<!-- -->        System.out.println("~~北京鸭~~~");    }}

QuackBehavior鸭叫抽象类，鸭子叫的策略接口

public interface QuackBehavior {<!-- -->     void quack();//子类实现}

ToyDuck

public class ToyDuck extends Duck{<!-- -->    public ToyDuck() {<!-- -->        flyBehavior = new NoFlyBehavior();    }    @Override    public void display() {<!-- -->        System.out.println("玩具鸭");    }        //需要重写父类的所有方法     public void quack() {<!-- -->        System.out.println("玩具鸭不能叫~~");    }    public void swim() {<!-- -->        System.out.println("玩具鸭不会游泳~~");    }}

WildDuck

public class WildDuck extends Duck {<!-- -->    //构造器，传入 FlyBehavor 的对象    public	WildDuck() {<!-- -->        flyBehavior = new GoodFlyBehavior();    }    @Override    public void display() {<!-- -->        System.out.println(" 这是野鸭 ");    }}

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

1)策略模式的关键是：分析项目中变化部分与不变部分

2)策略模式的核心思想是：

多用组合/聚合 少用继承

；用行为类组合，而不是行为的继承。更有弹性

3)体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略（或者行为） 即可，避免了使用多重转移语句（if…else if…else）

4)提供了可以替换继承关系的办法： 策略模式将算法封装在独立的 Strategy 类中使得你可以独立于其 Context 改变它，使它易于切换、易于理解、易于扩展

5)需要注意的是：每添加一个策略就要增加一个类，当策略过多是会导致类数目庞，

类爆炸

职责链模式

避免通过if/elseif/else，来大量耦合代码，使用链路环形调用，每一个处理者处理，不能处理就交给下一个处理

一、学校 OA 系统的采购审批项目需求

采购员采购教学器材

1)如果金额 小于等于 5000, 由教学主任审批 （0;=x;=5000）

2)如果金额 小于等于 10000, 由院长审批 (5000;x;=10000)

3)如果金额 小于等于 30000, 由副校长审批 (10000;x;=30000)

4)如果金额 超过 30000 以上，有校长审批 ( 30000;x)

请设计程序完成采购审批项目

二、设计方案(类图)

策略模式、职责链模式

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

1)传统方式是：接收到一个采购请求后，根据采购金额来调用对应的 Approver (审批人)完成审批。

2)传统方式的问题分析 : 客户端这里会使用到

分支判断(比如 switch)

来对不同的采购请求处理， 这样就存在如下问题 (1) 如果各个级别的人员审批金额发生变化，在客户端的也需要变化 (2) 客户端必须明确的知道 有多少个审批级别和访问

3)这样 对一个采购请求进行处理 和 Approver (审批人) 就存在

强耦合关系

，不利于代码的扩展和维护

4)解决方案 =》

职责链模式

四、职责链模式基本介绍

基本介绍职责链模式（Chain of Responsibility Pattern）, 又叫 责任链模式，为请求创建了一个接收者对象的链(简单示意图)。这种模式对请求的发送者和接收者进行解耦。

2)职责链模式通常

每个接收者都包含对另一个接收者的引用

。如果

一个对象不能处理该请求

，那么它会把

相同的请求传给下一个接收者

，依此类推。

这种类型的设计模式属于

行为型模式

五、职责链模式的原理类图

策略模式、职责链模式

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

**1)Handler** : 抽象的处理者, 定义了一个处理请求的接口, 同时`包含另外 Handler`

2)ConcreteHandlerA , B ：是具体的处理者, 处理它

自己负责的请求

， 可以

访问它的后继者

(即下一个处理者), 如果可以处理当前请求，则处理，否则就将该请求交个后继者去处理，从而

形成一个职责链

3)Request ： 含义很多属性，表示一个

请求

六、职责链模式解决 OA 系统采购审批

1)应用实例要求

编写程序完成学校 OA 系统的采购审批项目：需求采购员采购教学器材

如果金额 小于等于 5000, 由教学主任审批如果金额 小于等于 10000, 由院长审批

如果金额 小于等于 30000, 由副校长审批如果金额 超过 30000 以上，有校长审批

2)思路分析和图解(类图)

策略模式、职责链模式

3)代码实现

Approver抽象类，请求处理人员抽象类

public abstract class Approver {<!-- -->    Approver approver;	//下一个处理者     String name; // 处理人名    public Approver(String name) {<!-- -->        this.name = name;    }    //设置下一个处理者    public void setApprover(Approver approver) {<!-- -->         this.approver = approver;    }    //处理审批请求的方法，得到一个请求结果, 处理是由子类完成，因此该方法做成抽象    public abstract void processRequest(PurchaseRequest purchaseRequest);}

主函数

public class Client {<!-- -->    public static void main(String[] args) {<!-- -->        //创建一个请求        PurchaseRequest purchaseRequest = new PurchaseRequest(1, 31000, 1);        //创建相关的审批人        DepartmentApprover departmentApprover = new DepartmentApprover("张主任");         CollegeApprover collegeApprover = new CollegeApprover("李院长");        ViceSchoolMasterApprover viceSchoolMasterApprover = new ViceSchoolMasterApprover("王副校");         SchoolMasterApprover schoolMasterApprover = new SchoolMasterApprover("佟校长");        //需要将各个审批级别的下一个设置好 (处理人构成环形: ) 		//构成环形,构成环形,构成环形,构成环形,构成环形,构成环形!!!        //保证不会报NOP!!!        departmentApprover.setApprover(collegeApprover);         collegeApprover.setApprover(viceSchoolMasterApprover);         viceSchoolMasterApprover.setApprover(schoolMasterApprover);         schoolMasterApprover.setApprover(departmentApprover);        departmentApprover.processRequest(purchaseRequest);     }}

环装处理！！！！

策略模式、职责链模式

CollegeApprover

public class CollegeApprover extends Approver {<!-- -->    public CollegeApprover(String name) {<!-- -->        super(name);    }    @Override    public void processRequest(PurchaseRequest purchaseRequest) {<!-- -->        if(purchaseRequest.getPrice() ; 5000 &amp;&amp; purchaseRequest.getPrice() ;= 10000) {<!-- -->            System.out.println(" 请求编号 id= " + purchaseRequest.getId() + " 被 " + this.name + " 处理");        }else {<!-- -->            //处理不了，就交给下一个处理者            approver.processRequest(purchaseRequest);        }    }}

DepartmentApprover系处理者

public class DepartmentApprover extends Approver {<!-- -->    public DepartmentApprover(String name) {<!-- -->        super(name);    }        @Override    public void processRequest(PurchaseRequest purchaseRequest) {<!-- -->        if(purchaseRequest.getPrice() ;= 5000) {<!-- -->            System.out.println(" 请求编号 id= " + purchaseRequest.getId() + " 被 " + this.name + " 处理");        }else {<!-- -->            //处理不了，就交给下一个处理者            approver.processRequest(purchaseRequest);        }    }}

PurchaseRequest请求类

//请求类public class PurchaseRequest {<!-- -->    private int type = 0; //请求类型    private float price = 0.0f; //请求金额    private int id = 0;    //构造器    public PurchaseRequest(int type, float price, int id) {<!-- -->         this.type = type;        this.price = price;        this.id = id;    }        public int getType() {<!-- -->         return type;    }        public float getPrice() {<!-- -->         return price;    }        public int getId() {<!-- -->         return id;    }}

SchoolMasterApprover

public class SchoolMasterApprover extends Approver {<!-- -->    public SchoolMasterApprover(String name) {<!-- -->        super(name);    }    @Override    public void processRequest(PurchaseRequest purchaseRequest) {<!-- -->        if(purchaseRequest.getPrice() ; 30000) {<!-- -->            System.out.println(" 请求编号 id= " + purchaseRequest.getId() + " 被 " + this.name + " 处理");        }else {<!-- -->            //处理不了，就交给下一个处理者            approver.processRequest(purchaseRequest);        }    }    }

ViceSchoolMasterApprover

public class ViceSchoolMasterApprover extends Approver {<!-- -->    public ViceSchoolMasterApprover(String name) {<!-- -->        super(name);    }    @Override    public void processRequest(PurchaseRequest purchaseRequest) {<!-- -->        if(purchaseRequest.getPrice() ; 10000 &amp;&amp; purchaseRequest.getPrice() ;= 30000) {<!-- -->            System.out.println(" 请求编号 id= " + purchaseRequest.getId() + " 被 " + this.name + " 处理");        }else {<!-- -->            //处理不了，就交给下一个处理者            approver.processRequest(purchaseRequest);        }    }    }

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

1)将

请求和处理分开，实现解耦，提高系统的灵活性

2)简化了对象，使对象不需要知道链的结构

3)

性能会受到影响

 ，特别是在链比较长的时候，因此

需控制链中最大节点数量

，一般通过在 Handler 中设置一个最大节点数量，在 setNext()方法中判断是否已经超过阀值，超过则不允许该链建立，避免出现超长链无意识地破坏系统性能

4)

调试不方便

。采用了类似递归的方式，调试时逻辑可能比较复杂

5)最佳应用场景：

有多个对象可以处理同一个请求时，比如：多级请求、请假/加薪等

审批流程

 、Java Web 中 Tomcat对 Encoding 的处理、

拦截器

。

这个处理不了，下个继续处理，知道没有处理器能处理就完了

上一篇: JAVA设计模式六大原则个人理解【上】
下一篇: 今天心血来潮，把自己的一亩三分地收拾下太多前辈留下的宝藏，不知道叫啥名字，有知道的吗？图一游标卡尺，这种不带表的我能用，