责任链由多个节点（处理器）组成。在行为上有两种

  1. （经典责任链模式）遍历链条上的节点，直到找到对应节点，然后处理为止。（基于数组的遍历）
  2. （变种责任链）由各个节点依次处理，共享负担责任的一部分（通过引用组成链表）

类图

image.png

设计一个缓存模块

方案一

  1. 简单
  2. 耦合性高

方案二

复杂度很高

经典责任链

Trouble

  1. /**
  2.  * 问题类
  3.  **/
  4. public class Trouble {
  5.     private int number;
  6.     public Trouble(int number){
  7.         this.number=number;
  8.     }
  10.     public int getNumber() {
  11.         return number;
  12.     }
  14.     @Override
  15.     public String toString() {
  16.         return "[Trouble "+ number +
  17.                 ']';
  18.     }
  19. }

Support

  1. /**
  2.  * @author chenxinwei
  3.  * @date 2021/5/17 11:00
  4.  **/
  5. public abstract class Support {
  6.     private String name;
  7.     private Support next;
  9.     public Support(String name) {
  10.         this.name = name;
  11.     }
  13.     protected Support setNext(Support next) {
  14.         this.next = next;
  15.         return next;
  16.     }
  18.     public Support Support(Support next) {
  19.         this.next = next;
  20.         return next;
  21.     }
  23.     public final void support(Trouble trouble) {
  24.         if (resolve(trouble)) {
  25.             done(trouble);
  26.         } else if (next != null) {
  27.             next.support(trouble);
  28.         } else {
  29.             fail(trouble);
  30.         }
  31.     }
  33.     protected abstract boolean resolve(Trouble trouble);
  35.     protected void done(Trouble trouble) {
  36.         System.out.println(trouble + " is resolved by " + this + " .");
  37.     }
  39.     protected void fail(Trouble trouble) {
  40.         System.out.println(trouble + " cannot be resolved. ");
  41.     }
  43.     @Override
  44.     public String toString() {
  45.         return "[" + name + "]";
  46.     }
  47. }

LimitSupport

  1. /**
  2.  * 解决编号小于limit值的问题
  3.  **/
  4. public class LimitSupport extends Support {
  5.     private int limit;
  7.     public LimitSupport(String name, int limit) {
  8.         super(name);
  9.         this.limit = limit;
  10.     }
  12.     @Override
  13.     protected boolean resolve(Trouble trouble) {
  14.         if (trouble.getNumber() < limit) {
  15.             return true;
  16.         } else {
  17.             return false;
  18.         }
  19.     }
  20. }

NoSupport

  1. /**
  2.  * 永远不解决问题的类
  3.  **/
  4. public class NoSupport extends Support{
  5.     public NoSupport(String name) {
  6.         super(name);
  7.     }
  9.     @Override
  10.     protected boolean resolve(Trouble trouble) {
  11.         return false;
  12.     }
  13. }

OddSupport

  1. /**
  2.  * 解决奇数编号的问题
  3.  **/
  4. public class OddSupport extends Support {
  6.     public OddSupport(String name) {
  7.         super(name);
  8.     }
  10.     @Override
  11.     protected boolean resolve(Trouble trouble) {
  12.         if (trouble.getNumber() % 2 == 0) {
  13.             return false;
  14.         } else {
  15.             return true;
  16.         }
  17.     }
  18. }

SpecialSupport

  1. /**
  2.  * 只解决指定编号的问题
  3.  **/
  4. public class SpecialSupport extends Support {
  5.     private int number;
  7.     public SpecialSupport(String name, int number) {
  8.         super(name);
  9.         this.number = number;
  10.     }
  12.     @Override
  13.     protected boolean resolve(Trouble trouble) {
  14.         if (trouble.getNumber() == number) {
  15.             return true;
  16.         } else {
  17.             return false;
  18.         }
  19.     }
  20. }

类图

LimitSupport.png

解决363号问题的时序图

image.png

责任链中的某一个节点负责处理

image.png

变种责任链

MyBatis缓存使用Cache实现

image.png

链末尾的Cache先执行

image.png

MyBatis调用链

责任链每个点处理一种业务
image.png

练习

基于以下场景设计一个经典的责任链模式

请假审批流程： 1天以内由HR直接审批，2~3天由部门主管审批，三天以上由经理审批。