【设计模式】责任链模式教你如何优雅地分发任务

概述

在实际生存中，常常会出现这样的事例：一个请求有多个对象可以处理，但每个对象的处理条件或权限不同。比方，公司员工告假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据自己要告假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地点等信息，这增加了难度。这样的例子还有很多，如找领导出差报销、生存中的“伐鼓传花”游戏等。
定义：
又名职责链模式，为了避免请求发送者与多个请求处理者耦合在一起，将全部请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链通报，直到有对象处理它为止。
结构

职责链模式主要包罗以下角色:

• 抽象处理者（Handler）角色：定义一个处理请求的接口，包罗抽象处理方法和一个后继连接。
  
• 详细处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
  
• 客户类（Client）角色：创建处理链，并向链头的详细处理者对象提交请求，它不关心处理细节和请求的通报过程。
  

案例实现

现需要开发一个告假流程控制系统。告假一天以下的假只需要小组长同意即可；告假1天到3天的假还需要部门经理同意；请求3天到7天还需要总经理同意才行。
类图如下：

代码如下：

1. //请假条
2. public class LeaveRequest {
3.     private String name;//姓名
4.     private int num;//请假天数
5.     private String content;//请假内容
7.     public LeaveRequest(String name, int num, String content) {
8.         this.name = name;
9.         this.num = num;
10.         this.content = content;
11.     }
13.     public String getName() {
14.         return name;
15.     }
17.     public int getNum() {
18.         return num;
19.     }
21.     public String getContent() {
22.         return content;
23.     }
24. }
26. //处理者抽象类
27. public abstract class Handler {
28.     protected final static int NUM_ONE = 1;
29.     protected final static int NUM_THREE = 3;
30.     protected final static int NUM_SEVEN = 7;
32.     //该领导处理的请假天数区间
33.     private int numStart;
34.     private int numEnd;
36.     //领导上面还有领导
37.     private Handler nextHandler;
39.     //设置请假天数范围 上不封顶
40.     public Handler(int numStart) {
41.         this.numStart = numStart;
42.     }
44.     //设置请假天数范围
45.     public Handler(int numStart, int numEnd) {
46.         this.numStart = numStart;
47.         this.numEnd = numEnd;
48.     }
50.     //设置上级领导
51.     public void setNextHandler(Handler nextHandler){
52.         this.nextHandler = nextHandler;
53.     }
55.     //提交请假条
56.     public final void submit(LeaveRequest leave){
57.         if(0 == this.numStart){
58.             return;
59.         }
61.         //如果请假天数达到该领导者的处理要求
62.         if(leave.getNum() >= this.numStart){
63.             this.handleLeave(leave);
65.             //如果还有上级 并且请假天数超过了当前领导的处理范围
66.             if(null != this.nextHandler && leave.getNum() > numEnd){
67.                 this.nextHandler.submit(leave);//继续提交
68.             } else {
69.                 System.out.println("流程结束");
70.             }
71.         }
72.     }
74.     //各级领导处理请假条方法
75.     protected abstract void handleLeave(LeaveRequest leave);
76. }
78. //小组长
79. public class GroupLeader extends Handler {
80.     public GroupLeader() {
81.         //小组长处理1-3天的请假
82.         super(Handler.NUM_ONE, Handler.NUM_THREE);
83.     }
85.     @Override
86.     protected void handleLeave(LeaveRequest leave) {
87.         System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
88.         System.out.println("小组长审批：同意。");
89.     }
90. }
92. //部门经理
93. public class Manager extends Handler {
94.     public Manager() {
95.         //部门经理处理3-7天的请假
96.         super(Handler.NUM_THREE, Handler.NUM_SEVEN);
97.     }
99.     @Override
100.     protected void handleLeave(LeaveRequest leave) {
101.         System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
102.         System.out.println("部门经理审批：同意。");
103.     }
104. }
106. //总经理
107. public class GeneralManager extends Handler {
108.     public GeneralManager() {
109.         //部门经理处理7天以上的请假
110.         super(Handler.NUM_SEVEN);
111.     }
113.     @Override
114.     protected void handleLeave(LeaveRequest leave) {
115.         System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
116.         System.out.println("总经理审批：同意。");
117.     }
118. }
120. //测试类
121. public class Client {
122.     public static void main(String[] args) {
123.         //请假条来一张
124.         LeaveRequest leave = new LeaveRequest("小花",5,"身体不适");
126.         //各位领导
127.         GroupLeader groupLeader = new GroupLeader();
128.         Manager manager = new Manager();
129.         GeneralManager generalManager = new GeneralManager();
131.         groupLeader.setNextHandler(manager);//小组长的领导是部门经理
132.         manager.setNextHandler(generalManager);//部门经理的领导是总经理
133.         //之所以在这里设置上级领导，是因为可以根据实际需求来更改设置，如果实战中上级领导人都是固定的，则可以移到领导实现类中。
135.         //提交申请
136.         groupLeader.submit(leave);
137.     }
138. }

复制代码

优缺点

优点：

• 降低了对象之间的耦合度：该模式降低了请求发送者和接收者的耦合度。
  
• 加强了系统的可扩展性：可以根据需要增加新的请求处理类，满足开闭原则。
  
• 加强了给对象指派职责的灵活性：当工作流程发生变革，可以动态地改变链内的成员或者修改它们的序次，也可动态地新增或者删除责任。
  
• 责任链简化了对象之间的连接：一个对象只需保持一个指向其后继者的引用，不需保持其他全部处理者的引用，这避免了使用浩繁的 if 或者 if···else 语句。
  
• 责任分担：每个类只需要处理自己该处理的工作，不能处理的通报给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。
  

2，缺点：

• 不能保证每个请求肯定被处理。由于一个请求没有明确的接收者，所以不能保证它肯定会被处理，该请求可能一直传到链的末了都得不到处理。
  
• 对比力长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到肯定影响。
  
• 职责链创建的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统堕落，如可能会造成循环调用。
  

源码解析 - FilterChain

在javaWeb应用开发中，FilterChain是职责链（过滤器）模式的典型应用，以下是Filter的模拟实现分析:

• 模拟web请求Request以及web响应Response
  

1. public interface Request{
3. }
5. public interface Response{
7. }

复制代码

• 模拟web过滤器Filter
  

1. public interface Filter {
2.      public void doFilter(Request req,Response res,FilterChain c);
3. }

复制代码

• 模拟实现详细过滤器
  

1. public class FirstFilter implements Filter {
2.     @Override
3.     public void doFilter(Request request, Response response, FilterChain chain) {
5.         System.out.println("过滤器1 前置处理");
7.         // 先执行所有request再倒序执行所有response
8.         chain.doFilter(request, response);
10.         System.out.println("过滤器1 后置处理");
11.     }
12. }
14. public class SecondFilter  implements Filter {
15.     @Override
16.     public void doFilter(Request request, Response response, FilterChain chain) {
18.         System.out.println("过滤器2 前置处理");
20.         // 先执行所有request再倒序执行所有response
21.         chain.doFilter(request, response);
23.         System.out.println("过滤器2 后置处理");
24.     }
25. }

复制代码

• 模拟实现过滤器链FilterChain
  

1. public class FilterChain {
3.     private List<Filter> filters = new ArrayList<Filter>();
5.     private int index = 0;
7.     // 链式调用
8.     public FilterChain addFilter(Filter filter) {
9.         this.filters.add(filter);
10.         return this;
11.     }
13.     public void doFilter(Request request, Response response) {
14.         if (index == filters.size()) {
15.             return;
16.         }
17.         Filter filter = filters.get(index);
18.         index++;
19.         filter.doFilter(request, response, this);
20.     }
21. }

复制代码

• 测试类
  

1. public class Client {
2.     public static void main(String[] args) {
3.         Request  req = null;
4.         Response res = null ;
6.         FilterChain filterChain = new FilterChain();
7.         filterChain.addFilter(new FirstFilter()).addFilter(new SecondFilter());
8.         filterChain.doFilter(req,res);
9.     }
10. }

复制代码

往期推荐

• 《SpringBoot》EasyExcel实现百万数据的导入导出
  
• 《SpringBoot》史上最全SpringBoot相关注解介绍
  
• Spring框架IoC核心详解
  
• 万字长文带你窥探Spring中全部的扩展点
  
• 如何实现一个通用的接口限流、防重、防抖机制
  
• 万字长文带你深入Redis底层数据结构
  
• volatile关键字最全原理剖析
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。