设计模式---职责链模式（Chain of Responsibility Pattern）

た入场券 2022-11-27 12:19 157阅读 0赞

**目录**

1、学校 OA系统采购审批需求

2、传统方式解决审批流程

3、传统 方式 问题分析

4、职责链模式基本介绍

5、职责链模式原理类图

6、职责链模式解决OA采购审批

7、职责链模式在SpringMVC源码中的应用

8、注意事项和细节

--------------------

# 1、学校 OA系统采购审批需求 #

采购员采购教学器材，审批流程如下 ：

1.  金额小于5000，由教学主任审批。
2.  金额大于等于5000小于10000，由院长审批。
3.  金额大于等于1000小于30000，由副校长审批。
4.  金额大于等于30000，由校长审批。

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

# 2、传统方式解决审批流程 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70][]

# 3、传统 方式 问题分析 #

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

# 4、职责链模式基本介绍 #

*  职责链模式（Chain of Resposibility Pattern）,又叫责任链模式，为请求创建了一个接收者对象的链，这种模式对请求的发送者和接收者进行解耦。
 *  职责链模式通常每个接收者都包含对另一个接收者的引用，如果当前对象不能处理请求，那么他会把请求传给下一个接收者，以此类推。
 *  这种类型的设计模式属于行为模式。

# 5、职责链模式原理类图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70 1][]

*  Handler:抽象的处理者，定义了一个处理请求的接口，同时含有另外一个Handler.
 *  ConcreteHandlerA,B：是具体的处理者，处理它自己负责的请求，可以访问它的后继者（即下一个处理者），如果可以处理当前请求，则处理，如果处理不了，则交给下一个处理者进行处理，以此类推，从而形成一个职责链。
 *  Request:含有很多属性，表示一个请求。
 *

# 6、职责链模式解决OA采购审批 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70 2][]

代码实现：

package com.mayun.study.designpattern.responsibilitychain;
    
    /**
     * 处理者抽象类
     */
    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);
    }

package com.mayun.study.designpattern.responsibilitychain;
    
    /**
     * 请求类
     */
    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;
        }
    }

package com.mayun.study.designpattern.responsibilitychain;
    
    /**
     * 系级别的处理者实现类
     */
    public class DepartmentApprover extends Approver {
    
        public DepartmentApprover(String name) {
            super(name);
        }
    
        @Override
        public void processRequest(PurchaseRequest purchaseRequest) {
            if (purchaseRequest.getPrice() < 5000) {
    
                System.out.println("请求编号" + purchaseRequest.getId() + "被" + this.name + "处理了");
            }else{
                approver.processRequest(purchaseRequest);
    
            }
    
        }
    }

package com.mayun.study.designpattern.responsibilitychain;
    
    /**
     * 处理者：院长
     */
    public class CollegeApprover extends Approver {
    
        public CollegeApprover(String name) {
            super(name);
        }
    
        @Override
        public void processRequest(PurchaseRequest purchaseRequest) {
            if (5000 < purchaseRequest.getPrice() && purchaseRequest.getPrice() <= 10000) {
    
                System.out.println("请求编号" + purchaseRequest.getId() + "被" + this.name + "处理了");
            } else {
                approver.processRequest(purchaseRequest);
    
            }
        }
    }

package com.mayun.study.designpattern.responsibilitychain;
    
    /**
     * 处理者:副校长
     */
    public class ViceShcoolMasterApprover extends Approver {
        public ViceShcoolMasterApprover(String name) {
            super(name);
        }
    
        @Override
        public void processRequest(PurchaseRequest purchaseRequest) {
            if (10000 < purchaseRequest.getPrice() && purchaseRequest.getPrice() <= 30000) {
                System.out.println("请求编号" + purchaseRequest.getId() + "被" + this.name + "处理了");
            } else {
                approver.processRequest(purchaseRequest);
            }
        }
    }

package com.mayun.study.designpattern.responsibilitychain;
    
    /**
     * 处理者：校长类
     */
    public class SchoolMasterApprover extends Approver {
        public SchoolMasterApprover(String name) {
            super(name);
        }
    
        @Override
        public void processRequest(PurchaseRequest purchaseRequest) {
            if (purchaseRequest.getPrice() > 30000) {
    
                System.out.println("请求编号" + purchaseRequest.getId() + "被" + this.name + "处理了");
            }else{
                approver.processRequest(purchaseRequest);
    
            }
        }
    }

package com.mayun.study.designpattern.responsibilitychain;
    
    public class Client {
        public static void main(String[] args) {
            //创建请求
            PurchaseRequest purchaseRequest = new PurchaseRequest(1, 31000, 1);
    
            //创建相关的处理人
            DepartmentApprover deparmentApprover = new DepartmentApprover("张主任");
            CollegeApprover collegeApprover = new CollegeApprover("李院长");
            ViceShcoolMasterApprover viceShcoolMasterApprover = new ViceShcoolMasterApprover("王副校");
            SchoolMasterApprover schoolMasterApprover = new SchoolMasterApprover("高校长");
    
            //将各个审批的下一个处理者设定好(处理人构成环形)
            deparmentApprover.setApprover(collegeApprover);
            collegeApprover.setApprover(viceShcoolMasterApprover);
            viceShcoolMasterApprover.setApprover(schoolMasterApprover);
            schoolMasterApprover.setApprover(deparmentApprover);
    
            //开始 处理
            deparmentApprover.processRequest(purchaseRequest);
    
        }
    }

# 7、职责链模式在SpringMVC源码中的应用 #

SpringMVC中的 HandlerExcutionChain类就使用了职责链模式。

# 8、注意事项和细节 #

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70]: /images/20221124/c30b134f06d949f6b3ddb05a06c186d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70 1]: /images/20221124/cd63180247f14a9c8e947a39fc409c86.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70 2]: /images/20221124/e134d23cfe6849cea45a78432cc8056f.png