【设计模式】之责任链模式

概念

责任链，顾名思义，就是用来处理相关事务责任的一条执行链，执行链上有多个节点，每个节点都有机会（条件匹配）处理请求事务，如果某个节点处理完了就可以根据实际业务需求传递给下一个节点继续处理或者返回处理完毕。

场景

现实中，请假的OA申请，请假天数如果是半天到1天，可能直接主管批准即可；
如果是1到3天的假期，需要部门经理批准；
如果是3天到30天，则需要总经理审批；
大于30天，正常不会批准。

类图

为了实现上述场景，我们可以采用责任链设计模式。

员工提交请求类：LeaveRequest。
抽象的请假责任处理类：AbstractLeaveHandler。
直接主管审批处理类：DirectLeaderLeaveHandler。
部门经理处理类：DeptManagerLeaveHandler。
总经理处理类： GManagerLeaveHandler。

员工请求发起申请到抽象的责任处理类中，根据员工的请假天数，对应的处理类完成处理。
每一个责任处理类设置下面的节点。自身处理不了则传递给下一个节点处理。

实现

LeaveRequest.java:

 1 @Setter
 2 @Getter
 3 @NoArgsConstructor
 4 @AllArgsConstructor
 5 @Builder
 6 public class LeaveRequest {
 7     /**天数*/
 8     private int leaveDays;
 9 
10     /**姓名*/
11     private String name;
12 }

AbstractLeaveHandler.java:

 1 /**
 2  * @program: cookbook
 3  * @description: 请假责任链抽象处理类
 4  * @author: Byron
 5  * @create: 2019/07/11 09:34
 6  */
 7 public class AbstractLeaveHandler {
 8     /**直接主管审批处理的请假天数*/
 9     protected int MIN = 1;
10     /**部门经理处理的请假天数*/
11     protected int MIDDLE = 3;
12     /**总经理处理的请假天数*/
13     protected int MAX = 30;
14 
15     /**领导名称*/
16     protected String handlerName;
17 
18     /**下一个处理节点（即更高级别的领导）*/
19     protected AbstractLeaveHandler nextHandler;
20 
21     /**设置下一节点*/
22     protected void setNextHandler(AbstractLeaveHandler handler){
23         this.nextHandler = handler;
24     }
25 
26     /**处理请假的请求，子类实现*/
27     protected void handlerRequest(LeaveRequest request){
28 
29     }
30 
31 
32 }

DirectLeaderLeaveHandler.java:

 1 /**
 2  * @program: cookbook
 3  * @description: 直接主管处理类
 4  * @author: Byron
 5  * @create: 2019/07/11 09:46
 6  */
 7 public class DirectLeaderLeaveHandler extends AbstractLeaveHandler{
 8     public DirectLeaderLeaveHandler(String name) {
 9         this.handlerName = name;
10     }
11 
12     @Override
13     protected void handlerRequest(LeaveRequest request) {
14         if(request.getLeaveDays() <= this.MIN){
15             System.out.println("直接主管:" + handlerName + ",已经处理;流程结束。");
16             return;
17         }
18 
19         if(null != this.nextHandler){
20             this.nextHandler.handlerRequest(request);
21         }else{
22             System.out.println("审批拒绝！");
23         }
24 
25     }
26 }

DeptManagerLeaveHandler.java：

 1 /**
 2  * @program: cookbook
 3  * @description: 部门经理处理类
 4  * @author: Byron
 5  * @create: 2019/07/11 09:48
 6  */
 7 public class DeptManagerLeaveHandler extends AbstractLeaveHandler {
 8 
 9     public DeptManagerLeaveHandler(String name) {
10         this.handlerName = name;
11     }
12 
13     @Override
14     protected void handlerRequest(LeaveRequest request) {
15         if(request.getLeaveDays() >this.MIN && request.getLeaveDays() <= this.MIDDLE){
16             System.out.println("部门经理:" + handlerName + ",已经处理;流程结束。");
17             return;
18         }
19 
20         if(null != this.nextHandler){
21             this.nextHandler.handlerRequest(request);
22         }else{
23             System.out.println("审批拒绝！");
24         }
25     }
26 }

GManagerLeaveHandler.java：

 1 /**
 2  * @program: cookbook
 3  * @description: 总经理处理类
 4  * @author: Byron
 5  * @create: 2019/07/11 09:49
 6  */
 7 public class GManagerLeaveHandler extends AbstractLeaveHandler {
 8     public GManagerLeaveHandler(String name) {
 9         this.handlerName = name;
10     }
11 
12     @Override
13     protected void handlerRequest(LeaveRequest request) {
14         if(request.getLeaveDays() > this.MIDDLE && request.getLeaveDays() <= this.MAX){
15             System.out.println("总经理:" + handlerName + ",已经处理;流程结束。");
16             return;
17         }
18 
19         if(null != this.nextHandler){
20             this.nextHandler.handlerRequest(request);
21         }else{
22             System.out.println("审批拒绝！");
23         }
24     }
25 }

演示

ResponsibilityTest.java：

 1 public class ResponsibilityTest {
 2     public static void main(String[] args) {
 3         LeaveRequest request = LeaveRequest.builder().leaveDays(20).name("小明").build();
 4 
 5 
 6         AbstractLeaveHandler directLeaderLeaveHandler = new DirectLeaderLeaveHandler("县令");
 7         DeptManagerLeaveHandler deptManagerLeaveHandler = new DeptManagerLeaveHandler("知府");
 8         GManagerLeaveHandler gManagerLeaveHandler = new GManagerLeaveHandler("京兆尹");
 9 
10         directLeaderLeaveHandler.setNextHandler(deptManagerLeaveHandler);
11         deptManagerLeaveHandler.setNextHandler(gManagerLeaveHandler);
12 
13         directLeaderLeaveHandler.handlerRequest(request);
14 
15 
16     }
17 }

20天，运行输出：总经理:京兆尹,已经处理;流程结束。
1天，运行输出：直接主管:县令,已经处理;流程结束。
3天，运行输出：部门经理:知府,已经处理;流程结束。
35天，运行输出：审批拒绝！

总结

责任链主要重在责任分离处理，让各个节点各司其职。
责任链上的各个节点都有机会处理事务，但是也可能不会受理请求。
责任链比较长，调试时可能会比较麻烦。
责任链一般用于处理流程节点之类的实际业务场景中。
Spring拦截器链、servlet过滤器链等都采用了责任链设计模式

链接： https://www.jianshu.com/p/9f7d9775bdda

posted on 2020-11-10 09:14 仒丙阅读(135) 评论(0) 收藏举报