定义
责任链模式(Chain of Responsibility Pattern)：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。职责链模式是一种对象行为型模式。
用通俗的话就是推卸责任某件事，我们去解决，找到A，结果A踢皮球，说这不关我的事，去找B解决，然后我们就去找B，结果B也说，这跟我没关系，快去找C，就这样，我们就被踢来踢去，这就是责任链模式的思想。
角色
Handler（抽象处理者）：它定义了处理请求的接口、一般设计成抽象类，持有一个处理器的引用，如果自己无法处理请求，则转给下一个处理器。因此在抽象处理者中定义了一个抽象处理者类型的对象，作为其对下家的引用。通过该引用，处理者可以连成一条链。
ConcreteHandler（具体处理者）：它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发。
纯责任链模式
- 一个具体处理对象只能选择选择其中一个处理器：要么承担全部责任，要么把处理责任推给下家，不允许出现某个处理器处理了部分又继续向下传递。
- 一个请求必须被某一个处理者对象所接收，不能出现某个请求未被任何一个处理者对象处理的情况
不纯的责任链模式
- 允许某个请求被一个具体处理器处理后再向下传递
- 一个具体处理器处理完某请求后还可以继续处理该请求。
- 一个请求最终可以不被任何处理器所处理。
代码示例
纯责任链模式
现在模拟一个场景请求，当数字符合奇数、指定数字、某个下限等可处理，否则就处理失败。
首先我们定义抽象处理器，以及处理方法模板,定义了当前请求哪些可以处理，不能处理就转给next。
package com.zero.headfirst.chain.support; import java.util.Objects; /** * 抽象处理器：定义了抽象请求处理方法，持有一个抽象处理器的引用，用于生成一条处理链 */ public abstract class AbstractSupport { private String name; private AbstractSupport next; /** * 定义处理请求的算法模板 */ public final void process(NumberData numberData) { if (resolve(numberData)) { done(numberData); } else if (Objects.nonNull(next)) { next.process(numberData); } else { fail(numberData); } } /** * 无法处理 * @param numberData */ protected void fail(NumberData numberData) { System.out.println(numberData + " cannot be resolved."); } /** * 成功处理 * @param numberData */ protected void done(NumberData numberData) { System.out.println(numberData + " is resolved by " + this + "."); } /** * 判断是否能处理，子类重写 * @param numberData * @return */ protected abstract boolean resolve(NumberData numberData); public AbstractSupport setNext(AbstractSupport next) { this.next = next; return next; } public AbstractSupport(String name) { this.name = name; } @Override public String toString() { return "AbstractSupport{" + "name='" + name + '\'' + '}'; } }
然后定义我们的具体处理器，NoSupport 是一个永远不解决，只管推卸责任的类。
package com.zero.headfirst.chain.support; /** * 永远不解决,返回false */ public class NoSupport extends AbstractSupport { public NoSupport(String name) { super(name); } @Override protected boolean resolve(NumberData numberData) { return false; } }
LimitSupport 解决指定范围的请求
package com.zero.headfirst.chain.support; /** * 解决指定区间 */ public class LimitSupport extends AbstractSupport { private Integer limit; public LimitSupport(String name, Integer limit) { super(name); this.limit = limit; } @Override protected boolean resolve(NumberData numberData) { return numberData.getNumber() < limit; } }
OddSupport 类,解决奇数的问题
package com.zero.headfirst.chain.support; /** * 奇数处理 */ public class OddSupport extends AbstractSupport { public OddSupport(String name) { super(name); } @Override protected boolean resolve(NumberData numberData) { return numberData.getNumber() % 2 == 1; } }
SpecialSupport 指定数字处理器
package com.zero.headfirst.chain.support; /** * 指定数字特殊处理 */ public class SpecialSupport extends AbstractSupport { private Integer number; public SpecialSupport(String name, Integer number) { super(name); this.number = number; } @Override protected boolean resolve(NumberData numberData) { return numberData.getNumber().equals(number); } }
最后我们定义一个客户端去组装我们的责任链，将所有的处理器连在一起，并且模拟请求
package com.zero.headfirst.chain.support; public class ChainTest { public static void main(String[] args) { AbstractSupport alice = new NoSupport("Alice"); AbstractSupport jams = new OddSupport("jams"); AbstractSupport bob = new LimitSupport("Bob", 100); AbstractSupport charlie = new SpecialSupport("Charlie", 429); //定义责任链 alice.setNext(jams).setNext(bob).setNext(charlie); for (int i = 0; i < 500; i += 33) { alice.process(new NumberData(i)); } } }
我们的打印结果：除了我们定义处理器能处理的数字可以处理完成，其他数字无法处理。
NumberData{number=0} is resolved by AbstractSupport{name='Bob'}. NumberData{number=33} is resolved by AbstractSupport{name='jams'}. NumberData{number=66} is resolved by AbstractSupport{name='Bob'}. NumberData{number=99} is resolved by AbstractSupport{name='jams'}. NumberData{number=132} cannot be resolved. NumberData{number=165} is resolved by AbstractSupport{name='jams'}. NumberData{number=198} cannot be resolved. NumberData{number=231} is resolved by AbstractSupport{name='jams'}. NumberData{number=264} cannot be resolved. NumberData{number=297} is resolved by AbstractSupport{name='jams'}. NumberData{number=330} cannot be resolved. NumberData{number=363} is resolved by AbstractSupport{name='jams'}. NumberData{number=396} cannot be resolved. NumberData{number=429} is resolved by AbstractSupport{name='jams'}. NumberData{number=462} cannot be resolved. NumberData{number=495} is resolved by AbstractSupport{name='jams'}.
不纯的责任链模式
比如说公司请假需要审批，举个不恰当的例子，如果请假小于3天，主管审批；4-10天的， 经理审批；11-30天的，总经理审批；超过30天的，不批准等等。这就得一步步去判断， 如果撇开设计模式不看的话，那么我们可以使用if…else…把它解决了，但是问题可想而知， 实际中的复杂程度远远超过这个例子的。
现在我们用责任链设计模式解决，将每种角色连接起来处理请假数据流。
抽象处理器
package com.zero.design.actions.dutychain; /** * 责任链抽象类，包含核心处理方法，以及后继责任处理器设置.由不同的处理器继承 */ public abstract class AbstractLeaderHandler { protected String handlerName; /** * 责任链上的后继对象，即这个对象无法处理，就转移给下一个Leader */ protected AbstractLeaderHandler nextLeaderHandler; public AbstractLeaderHandler(String handlerName) { this.handlerName = handlerName; } /** * 处理请求的核心的业务方法 * 需要不同继承该类的处理器自己实现 * @param request */ public abstract void handleRequest(LeaveRequest request); /** * 设定责任链上的后继对象 * @param nextLeaderHandler */ public AbstractLeaderHandler setNextLeaderHandler(AbstractLeaderHandler nextLeaderHandler) { this.nextLeaderHandler = nextLeaderHandler; return nextLeaderHandler; } }
具体处理器-主任处理器
负责处理 3 天以下的假期，大于三天的递交给主管
package com.zero.design.actions.dutychain; /** * 主任处理器，继承抽象处理器接口,处理相应业务或设置下一个处理器 */ public class DirectorHandler extends AbstractLeaderHandler { public DirectorHandler(String handlerName) { super(handlerName); } @Override public void handleRequest(LeaveRequest request) { int days = request.getLeaveDays(); //获取请假天数 String name = request.getName(); //获取请假人姓名 String reason = request.getReason(); // 获取请假理由 if (days <= 3) { //如果满足3天内的要求，主任直接审批 System.out.println("员工" + name + "请假" + days + "天，理由：" + reason); System.out.println("主任" + this.handlerName + "审批通过"); } else { System.out.println("请假天数过多，主任" + this.handlerName + "处理结束，还要交给经理处理"); if(this.nextLeaderHandler != null) { //否则，如果链上存在下一个Leader，就让他处理 this.nextLeaderHandler.handleRequest(request); } } } }
经理处理器
处理小于10天的假期，大于10则递交给总办
package com.zero.design.actions.dutychain; /** * 经理处理器 */ public class ManagerHandler extends AbstractLeaderHandler { public ManagerHandler(String handlerName) { super(handlerName); } @Override public void handleRequest(LeaveRequest request) { int days = request.getLeaveDays(); //获取请假天数 String name = request.getName(); //获取请假人姓名 String reason = request.getReason(); // 获取请假理由 if(days <= 10) { //如果满足10天内的要求，经理直接审批 System.out.println("员工" + name + "请假" + days + "天，理由：" + reason); System.out.println("经理" + this.handlerName + "审批通过"); } else { System.out.println("请假天数过多，经理" + this.handlerName + "处理结束，交给总办处理"); if(this.nextLeaderHandler != null) { //否则，如果链上存在下一个Leader，就让他处理 this.nextLeaderHandler.handleRequest(request); } } } }
总办处理器
处理大于 10 天假期的请求
package com.zero.design.actions.dutychain; /** * 总办处理器 */ public class GeneralManagerHandler extends AbstractLeaderHandler { public GeneralManagerHandler(String handlerName) { super(handlerName); } @Override public void handleRequest(LeaveRequest request) { int days = request.getLeaveDays(); //获取请假天数 String name = request.getName(); //获取请假人姓名 String reason = request.getReason(); // 获取请假理由 if(days <= 30) { //如果满足10天内的要求，经理直接审批 System.out.println("员工" + name + "请假" + days + "天，理由：" + reason); System.out.println("总办" + this.handlerName + "审批通过"); } else { System.out.println("请假天数过多，总办" + this.handlerName + "没法处理"); if(this.nextLeaderHandler != null) { //否则，如果链上存在下一个Leader，就让他处理 this.nextLeaderHandler.handleRequest(request); } else { System.out.println("请假不成功"); } } } }
客户端角色
声明一条处理链，模拟请假数据流
package com.zero.design.actions.dutychain; /** * 模拟请求： * 他们处理请求的条件是不同的，而且只要不是自己处理范围之内的，就会将请求传给链上的下一位来处理 */ public class Client { public static void main(String[] args) { //初始化责任链，应该使用单例 AbstractLeaderHandler directorHandler = new DirectorHandler("张胜男"); AbstractLeaderHandler managerHandler = new ManagerHandler("李四"); AbstractLeaderHandler generalManagerHndler = new GeneralManagerHandler("赵王"); //组织好责任对象关系 directorHandler.setNextLeaderHandler(managerHandler).setNextLeaderHandler(generalManagerHndler); //开始请假操作 LeaveRequest request = new LeaveRequest("倪升武", 15, "在家睡觉"); directorHandler.handleRequest(request); } }
最后我们看打印结果
请假天数过多，主任张胜男处理结束，还要交给经理处理 请假天数过多，经理李四处理结束，交给总办处理 员工倪升武请假15天，理由：在家睡觉 总办赵王审批通过
总结
责任链模式的优点
- 对象仅需知道该请求会被处理即可，且链中的对象不需要知道链的结构，由客户端负责链的创建，降低了系统的耦合度
- 请求处理对象仅需维持一个指向其后继者的引用，而不需要维持它对所有的候选处理者的引用，可简化对象的相互连接
- 在给对象分派职责时，职责链可以给我们更多的灵活性，可以在运行时对该链进行动态的增删改，改变处理一个请求的职责
- 新增一个新的具体请求处理者时无须修改原有代码，只需要在客户端重新建链即可，符合 "开闭原则"
缺点
- 一个请求可能因职责链没有被正确配置而得不到处理
- 对于比较长的职责链，请求的处理可能涉及到多个处理对象，系统性能将受到一定影响，且不方便调试
- 可能因为职责链创建不当，造成循环调用，导致系统陷入死循环
使用场景
- Netty 中的
Pipeline和ChannelHandler通过责任链设计模式来组织代码逻辑 - Tomcat 过滤器中的责任链模式。
- Mybatis 中的 Plugin 机制使用了责任链模式，配置各种官方或者自定义的 Plugin，与 Filter 类似，可以在执行 Sql 语句的时候做一些操作
- 有多个对象可以处理同一个请求，具体哪个对象处理该请求待运行时刻再确定，客户端只需将请求提交到链上，而无须关心请求的处理对象是谁以及它是如何处理的
- 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求
- 可动态指定一组对象处理请求，客户端可以动态创建职责链来处理请求，还可以改变链中处理者之间的先后次序
