1. 概念:

责任链模式 - 图1
责任链模式的核心: 使多个对象(一组服务)都有机会处理同一个请求, 并且这一组服务在执行处理的时候要有先后关系. 咱们公司在发布项目的需要各级大佬审批, 其实就可以使用责任链实现。
责任链模式 - 图2

2. 一坨代码实现:

责任链模式 - 图3
这里从上到下分别判断了在指定时间范围内由不同的人员进行审批，这样实现起来比较简单，但这样的实现就很难进行扩展。

3. 责任链模式重构代码:

下图是责任链结构的核心部分, 实现了统一抽象类的不同规则, 再进行编排, 就形成了一条链路.
责任链模式 - 图4

3.1 链路抽象类定义:

  1. public abstract class ApprovalLink {
  2.     protected SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 时间格式化
  3.     protected String levelUserName;                         // 级别人员姓名
  4.     private ApprovalLink next;                                  // 责任链
  6.     public ApprovalLink(String levelUserName) {
  7.         this.levelUserName = levelUserName;
  8.     }
  10.     public ApprovalLink next() {
  11.         return next;
  12.     }
  14.     public ApprovalLink appendNext(ApprovalLink next) {
  15.         this.next = next;
  16.         return this;
  17.     }
  19.     /*抽象审批方法*/
  20.     public abstract void approval(String publishId, Date publishDate);
  22.     /**
  23.      * 链路入口
  24.      *
  25.      * @param publishId
  26.      * @param publishDate
  27.      * @return
  28.      */
  29.     public Result run(String publishId, Date publishDate) {
  30.         try {
  31.             approval(publishId, publishDate);
  32.             ApprovalLink link = this;
  33.             while (true) {
  34.                 link = link.next();
  35.                 if (link == null) {
  36.                     return new Result("200", "单号：", publishId, " 状态：审批完成");
  37.                 }
  38.                 link.approval(publishId, publishDate);
  39.             }
  40.         } catch (RuntimeException e) {
  41.             return new Result("500", "单号：", publishId, " 状态: " + e.getMessage());
  42.         }
  43.     }
  44. }

3.2 审批实现类:

  1. // 三级审批
  2. public class FirstApprovalLink extends ApprovalLink {
  4.     public FirstApprovalLink(String levelUserName) {
  5.         super(levelUserName);
  6.     }
  8.     @Override
  9.     public void approval(String publishId, Date publishDate) {
  10.         // 三级审批人
  11.         log.info("三级审批开始...并自动通过 发布单id:{},审批人:{},审批时间:{};", publishId, levelUserName, publishDate);
  12.     }
  13. }
  15. // 二级审批
  16. public class SecondAuthLink extends ApprovalLink {
  18.     private Date beginDate = f.parse("2021-04-01 00:00:00");
  19.     private Date endDate = f.parse("2021-04-29 23:59:59");
  21.     public SecondAuthLink(String levelUserName) throws ParseException {
  22.         super(levelUserName);
  23.     }
  25.     @Override
  26.     public void approval(String publishId, Date publishDate) {
  27.         log.info("二级审批开始... 发布单id:{},审批人:{},审批时间:{};", publishId, levelUserName, publishDate);
  28.         if (publishDate.before(beginDate) || publishDate.after(endDate)) {
  29.             log.info("二级审批通过... 发布单id:{},审批人:系统自动通过,审批时间:{};", publishId, publishDate);
  30.             return;
  31.         }
  32.         if (ThreadLocalRandom.current().nextInt(0, 2) == 0) {
  33.             log.info("二级审批未通过");
  34.             throw new RuntimeException("二级审批未通过");
  35.         }
  36.         log.info("二级审批通过... 发布单id:{},审批人:{},审批时间:{};", publishId, levelUserName, publishDate);
  37.     }
  38. }
  40. // 一级审批
  41. public class ThirdAuthLink extends ApprovalLink {
  43.     private Date beginDate = f.parse("2021-04-20 00:00:00");
  44.     private Date endDate = f.parse("2021-04-22 23:59:59");
  46.     public ThirdAuthLink(String levelUserName) throws ParseException {
  47.         super(levelUserName);
  48.     }
  50.     @Override
  51.     public void approval(String publishId, Date publishDate) {
  52.         log.info("一级审批开始... 发布单id:{},审批人:{},审批时间:{};", publishId, levelUserName, publishDate);
  53.         if (publishDate.before(beginDate) || publishDate.after(endDate)) {
  54.             log.info("一级审批通过... 发布单id:{},审批人:系统自动通过,审批时间:{};", publishId, publishDate);
  55.             return;
  56.         }
  57.         if (ThreadLocalRandom.current().nextInt(0, 2) == 0) {
  58.             log.info("一级审批未通过");
  59.             throw new RuntimeException("一级审批未通过");
  60.         }
  61.         log.info("一级审批通过... 发布单id:{},审批人:{},审批时间:{};", publishId, levelUserName, publishDate);
  62.     }
  63. }

3.3 测试验证:

  1. public void method() throws ParseException {
  2.     ApprovalLink first = new FirstApprovalLink("组长");
  3.     ApprovalLink second = new SecondAuthLink("总监");
  4.     ApprovalLink third = new ThirdAuthLink("CTO");
  5.     second.appendNext(third);
  6.     first.appendNext(second);
  7.     log.info("测试结果：{}", JSON.toJSONString(first.run("202104251730010001", new Date())));
  8. }

4. 项目中使用:

责任链模式 - 图5
责任链模式 - 图6
责任链模式 - 图7

5. Servlet中的Filter

filter也是典型的责任链模式,是基于回调函数执行的, 在每一个过滤器执行完业务逻辑之后，都会调用FilterChain类, 而FilterChain中也会显示的调用下一个过滤器。
责任链模式 - 图8

5.1 处理器接口定义:

  1. public interface AqrHandler<T> {
  2.     void doHandler(T t, AqrHandlerChain chain, String trace);
  3. }

5.2 处理器实现类:

  1. public class Handler1 implements AqrHandler<List<Integer>> {
  3.     @Override
  4.     public void doHandler(List<Integer> integers, AqrHandlerChain chain, String trace) {
  5.         Iterator<Integer> iterator = integers.iterator();
  6.         while (iterator.hasNext()) {
  7.             Integer next = iterator.next();
  8.             if (next == 3) {
  9.                 iterator.remove();
  10.             }
  11.         }
  12.         chain.doHandler(integers,trace);
  13.     }
  14. }
  15. public class Handler2 implements AqrHandler<List<Integer>> {
  17.     @Override
  18.     public void doHandler(List<Integer> integers, AqrHandlerChain chain, String trace) {
  19.         Iterator<Integer> iterator = integers.iterator();
  20.         while (iterator.hasNext()) {
  21.             Integer next = iterator.next();
  22.             if (next == 6) {
  23.                 iterator.remove();
  24.             }
  25.         }
  26.         chain.doHandler(integers,trace);
  27.     }
  28. }
  29. public class Handler3 implements AqrHandler<List<Integer>> {
  31.     @Override
  32.     public void doHandler(List<Integer> integers, AqrHandlerChain chain, String trace) {
  33.         Iterator<Integer> iterator = integers.iterator();
  34.         while (iterator.hasNext()) {
  35.             Integer next = iterator.next();
  36.             if (next == 9) {
  37.                 iterator.remove();
  38.             }
  39.         }
  40.         chain.doHandler(integers,trace);
  41.     }
  42. }

5.3 责任链:

  1. public class AqrHandlerChain<T> {
  2.     /**
  3.      * 处理器集合
  4.      */
  5.     private List<AqrHandler> handlers = new ArrayList<>();
  6.     /**
  7.      * 处理器索引下标
  8.      */
  9.     private int idx = 0;
  11.     /**
  12.      * 添加处理器
  13.      *
  14.      * @param filter
  15.      */
  16.     public void add(AqrHandler filter) {
  17.         handlers.add(filter);
  18.     }
  20.     public void doHandler(T t, String trace) {
  21.         if (idx >= handlers.size()) {
  22.             /*责任链结束*/
  23.             return;
  24.         }
  25.         handlers.get(idx++).doHandler(t, this, trace);
  26.     }
  27. }

5.4 测试验证:

public void method() {
    AqrHandlerChain chain = new AqrHandlerChain();
    chain.add(new Handler1());
    chain.add(new Handler2());
    chain.add(new Handler3());

    List<Integer> lists = Lists.newArrayList();
    for (int i = 0; i < 10; i++) {
        lists.add(ThreadLocalRandom.current().nextInt(0, 10));
    }
    System.out.println("method1 before --> " + JSON.toJSONString(lists));
    chain.doHandler(lists, "trace");
    System.out.println("method1 after --> " + JSON.toJSONString(lists));
}

6. 总结:

责任链模式很好的处理单一职责和开闭原则，简单了耦合也使对象关系更加清晰，而且外部的调用方并不需要关心责任链是如何进行处理的。但也需要是适当的场景才进行使用，避免造成性能以及编排混乱调试测试疏漏问题。(不知道请求被哪些责任链对象处理，不利于排错)