【设计模式系列】行为型之责任链模式

矫情吗；* 2022-10-18 11:24 121阅读 0赞

### 目录 ###

*  背景
 *  理论
 *  实践
 *  总结

# 背景 #

责任链模式，小编在自己项目迭代过程也参与了维护和设计实现；本篇博文主要针对该设计模型进行总结和实践；  
简单举例日常生活或者工作中能够接触的责任链模式场景：采购审批流程，请假流程，软件开发中的异常处理流程，web请求处理流程等各种各样的流程；  
本文中主要借助比较常见的场景OA请假流程：  
**作为底层员工的溪源同学发起一个请假申请；  
1.当溪源请假天数小于3天时，只需要得到上级主管批准即可；  
2.当溪源请假天数大于3天时，主管批准后还需要提交给经理审批即可；  
3.当溪源确实有事需要请假超过7天时（比如，度个蜜月啦，哈哈~）那经理审批通过，肯定要进一步提交给总经理审批。**  
相信这个场景大家应该可以非常轻松的能够理解；  
简单的一个流程图如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1YW5fbHU_size_16_color_FFFFFF_t_70]

# 理论 #

官方套话

*  定义：**责任链模式(Chain of Responsibility Pattern)**：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。职责链模式是一种对象行为型模式。
 *  角色：  
    **- Handler（抽象处理者）**：它定义了一个处理请求的接口，一般设计为抽象类，由于不同的具体处理者处理请求的方式不同，因此在其中定义了抽象请求处理方法。因为每一个处理者的下家还是一个处理者，因此在抽象处理者中定义了一个抽象处理者类型的对象，作为其对下家的引用。通过该引用，处理者可以连成一条链。  
    **- ConcreteHandler（具体处理者）**：它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限(此处就是基于自己实际业务场景开发实现逻辑) ；  
    如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发。

# 实践 #

基于上面的角色介绍，溪源先分享出实现的类图，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1YW5fbHU_size_16_color_FFFFFF_t_70 1]

*  抽象类：  
    顶层抽象处理者类 Handler，维护一个 nextHandler 属性，该属性为当前处理者的下一个处理者的引用；

/** 公共抽象类*/
    public abstract class AbstractHandler { 
        /** 抽象父类中可以随意定义子类中共用的变量:定义每个领导允许的请假天数*/
        //为了保证后期审批权限的调整，此处不定义具体天数
    // protected int supervisorDay;
    //
    // protected int divisionManagerDay;
    
        protected int permissionDay;
        /** 领导名*/
        protected String leaderName;
    
        public AbstractHandler(int permissionDay, String leaderName) { 
            this.permissionDay = permissionDay;
            this.leaderName = leaderName;
        }
    
        /** 下一个处理者*/
        private AbstractHandler nextHandler;
    
    
        public AbstractHandler getNextHandler() { 
            return nextHandler;
        }
    
        public void setNextHandler(AbstractHandler nextHandler) { 
            this.nextHandler = nextHandler;
        }
    
        public String getLeaderName() { 
            return leaderName;
        }
    
        /** 抽象方法，子类实现具体业务逻辑*/
        public abstract void handleRequest(int day);
    }

*  上级主管

/** * 上级主管处理者 */
    public class SupervisorManagerHandler extends AbstractHandler{ 
        public SupervisorManagerHandler(int permissionDay, String leaderName) { 
            super(permissionDay, leaderName);
        }
    
        @Override
        public void handleRequest(int day) { 
            if (day <= permissionDay) { 
                System.out.println("请" + day + "天的假期，" + "上级主管：" + getLeaderName() + "审批通过，流程结束");
            } else { 
                System.out.println("上级主管已同意审批结束，但由于请假天数长，需流转到下一节点处理");
                getNextHandler().handleRequest(day);
            }
        }
    }

*  部门经理

/** * 部门经理处理 */
    public class DivisionManagerHandler extends AbstractHandler { 
        public DivisionManagerHandler(int permissionDay, String leaderName) { 
            super(permissionDay, leaderName);
        }
    
        @Override
        public void handleRequest(int day) { 
            if (day <= permissionDay) { 
                System.out.println("请" + day + "天的假期，" + "部门经理：" + getLeaderName() + "审批通过，流程结束");
            } else { 
                System.out.println("部门经理已同意审批结束，但由于请假天数长，需流转到下一节点处理");
                getNextHandler().handleRequest(day);
            }
        }
    }

*  总经理

/** * 总经理处理 */
    public class GeneralManagerHandler extends AbstractHandler{ 
        public GeneralManagerHandler(int permissionDay, String leaderName) { 
            super(permissionDay, leaderName);
        }
    
        @Override
        public void handleRequest(int day) { 
            if (day <= permissionDay) { 
                System.out.println("请" + day + "天的假期，" + "总经理：" + getLeaderName() + "审批通过，流程结束");
            } else { 
                System.out.println("请假时间过长," + "总经理:" +getLeaderName() + "允许你提交辞职流程");
    // getNextHandler().handleRequest(day);
            }
        }
    }

*  客户端

public class Client { 
        public static void main(String[] args) { 
            SupervisorManagerHandler supervisorManagerHandler = new SupervisorManagerHandler(3, "张三");
            DivisionManagerHandler divisionManagerHandler = new DivisionManagerHandler(7, "李四");
            GeneralManagerHandler generalManagerHandler = new GeneralManagerHandler(10, "夏天");
    
            supervisorManagerHandler.setNextHandler(divisionManagerHandler);
            divisionManagerHandler.setNextHandler(generalManagerHandler);
    
            supervisorManagerHandler.handleRequest(50);
    
        }
    }

*  运行：

分别从三级单测运行结果如下：
    ---- 1天：主管审批；
    请1天的假期，上级主管：张三审批通过，流程结束
    
    Process finished with exit code 0
    
    ---- 6天:部门经理；
    上级主管已同意审批结束，但由于请假天数长，需流转到下一节点处理
    请6天的假期，部门经理：李四审批通过，流程结束
    
    Process finished with exit code 0
    
    
    ---- 10天，总经理；
    上级主管已同意审批结束，但由于请假天数长，需流转到下一节点处理
    部门经理已同意审批结束，但由于请假天数长，需流转到下一节点处理
    请10天的假期，总经理：夏天审批通过，流程结束
    
    Process finished with exit code 0
    
    ---- 20天，不通过辞职；
    上级主管已同意审批结束，但由于请假天数长，需流转到下一节点处理
    部门经理已同意审批结束，但由于请假天数长，需流转到下一节点处理
    请假时间过长,总经理:夏天允许你提交辞职流程

# 总结 #

*  优点：  
    1.对象仅需知道该请求会被处理即可，且链中的对象不需要知道链的结构，由客户端负责链的创建，降低了系统的耦合度;  
    2.请求处理对象仅需维持一个指向其后继者的引用，而不需要维持它对所有的候选处理者的引用，可简化对象的相互连接;  
    3.在给对象分派职责时，职责链可以给我们更多的灵活性，可以在运行时对该链进行动态的增删改，改变处理一个请求的职责;  
    4.新增一个新的具体请求处理者时无须修改原有代码，只需要在客户端重新建链即可，符合 “开闭原则”；
 *  缺点：  
    1.一个请求可能因职责链没有被正确配置而得不到处理；  
    2.对于比较长的职责链，请求的处理可能涉及到多个处理对象，系统性能将受到一定影响，且不方便调试；  
    3.可能因为职责链创建不当，造成循环调用，导致系统陷入死循环；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1YW5fbHU_size_16_color_FFFFFF_t_70]: /images/20221014/1fada9e6c50f47d681e93b0058b0dde7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1YW5fbHU_size_16_color_FFFFFF_t_70 1]: /images/20221014/f882af4687424075b30ff616efa26188.png