定义

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.Chain the receiving objects and pass the request along the chain until an object handles it.（使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。） -设计模式之禅　第２版

我的理解是，将处理请求的多个方式链式化．来避免代码臃肿．举个例子，判断是否进行处理或者说选择合适的处理方式．可以用if,switch.对于处理方式少的．而且业务简单的，当然没问题．但是一旦数量增多，维护起来就比较麻烦．而且对于是否处理的判断也不够灵活．

实现

既然是多个请求，而且是链表的结构，那么可以抽象出一些共同方法与属性．

  • 方法
    • 判断条件
    • 判断：是自己的就处理，不是就传递
    • 设置下一个节点
    • 节点要进行的任务
  • 属性
    • 下一个节点

这个判断条件应该是由抽象类决定的．比如按照级别处理，按照名称处理

所以，其实就两个角色

  • 抽象处理者
  • 实际处理者
  • 组装者

举例使用一下：

某物资管理系统中物资采购需要分级审批，主任可以审批1万元及以下的采购单，某部门经理可以审批5万元以下的采购单，副总经理可以审批10万元及以下的采购单，总经理可以审批20万元及以下的采购单，20万元以上的采购单需要开会确定

抽象一个处理对象，这里就是采购清单java bean

  1. @AllArgsConstructor
  2. @NoArgsConstructor
  3. @Getter
  4. @Setter
  5. public class PurchaseOrder {
  6.     /**
  7.      * 总价格
  8.      */
  9.     BigDecimal totalPrice;
  10.     /**
  11.      * 是否通过审核
  12.      */
  13.     boolean pass;
  14.     /**
  15.      * 商品单价
  16.      */
  17.     BigDecimal unitPrice;
  18.     /**
  19.      * 商品总量
  20.      */
  21.     long quantity;
  22.     /**
  23.      * 备注信息
  24.      */
  25.     String note;
  26. }

抽象一个处理类：

  1. public abstract class AbstractHandler {
  3.     private AbstractHandler nextHandler;
  4.     @Getter
  5.     @Setter
  6.     @AllArgsConstructor
  7.     @NoArgsConstructor
  8.     @ToString
  9.     class Result{
  10.         private String msg;
  11.         private boolean pass;
  12.     }
  13.     public final Result handle(PurchaseOrder purchaseOrder){
  14.         Result result = new Result();
  15.         if(judge(purchaseOrder.totalPrice)){
  16.             examine(purchaseOrder,result);
  17.         }else{
  18.             if(this.nextHandler != null){
  19.                 result = this.nextHandler.handle(purchaseOrder);
  20.             }
  21.         }
  22.         return result;
  23.     }
  25.     /**
  26.      * 进行具体的事务
  27.      * @param purchaseOrder 采购清单
  28.      * @param result 是否通过，以及备注
  29.      */
  30.     protected abstract void examine(PurchaseOrder purchaseOrder,Result result);
  32.     public void setNext(AbstractHandler _nextHandler){
  33.         this.nextHandler = _nextHandler;
  34.     }
  37.     /**
  38.      * 判断自己是否可以处理
  39.      * @param totalPrice 商品总价
  40.      * @return 可以处理返回true
  41.      */
  42.     protected abstract boolean judge(BigDecimal totalPrice);
  44. }

然后是各种处理类

  • 主任 ```java public class DirectorHandler extends AbstractHandler{ @Override protected void examine(PurchaseOrder purchaseOrder, Result result) {

    1.   purchaseOrder.setPass(true);
    2.   result.setMsg("主任：通过");
    3.   result.setPass(true);

    }

    /**

    • 主任，可审批1万及以下的采购单
    • @param totalPrice 商品总价
    • @return */ @Override protected boolean judge(BigDecimal totalPrice) { int HANDLE_LEVEL = 10_000; return totalPrice.compareTo(new BigDecimal(HANDLE_LEVEL)) < 1; }

}


- 部门经理
```java
public class DMHandler extends AbstractHandler{
    @Override
    protected void examine(PurchaseOrder purchaseOrder, Result result) {
        result.setPass(true);
        result.setMsg("部门经理：通过了");
    }

    /**
     *  部门经理可以审批5万元一下的采购单
     * @param totalPrice 商品总价
     * @return
     */
    @Override
    protected boolean judge(BigDecimal totalPrice) {
        int HANDLE_LEVEL = 50_000;
        return totalPrice.compareTo(new BigDecimal(HANDLE_LEVEL)) < 0;
    }

}
  • 副总经理 ```java public class VGMHandler extends AbstractHandler{
@Override
protected void examine(PurchaseOrder purchaseOrder, Result result) {
    result.setPass(true);
    result.setMsg("副总经理：审批通过");
}

/**
 * 副总经理审批10万及以下采购单
 * @param totalPrice 商品总价
 * @return
 */
@Override
protected boolean judge(BigDecimal totalPrice) {
    int HANDLE_LEVEL = 100_000;
    return totalPrice.compareTo(new BigDecimal(HANDLE_LEVEL)) < 1;
}

}


- 总经理
```java
public class GMHandler extends AbstractHandler{
    @Override
    protected void examine(PurchaseOrder purchaseOrder, Result result) {
        purchaseOrder.setPass(true);
        result.setPass(true);
        result.setMsg("总经理：同意");
    }

    /**
     * 总经理可以审批20万元及以下的采购单
     * @param totalPrice 商品总价
     * @return
     */
    @Override
    protected boolean judge(BigDecimal totalPrice) {
        int HANDLE_LEVEL = 200_000;
        return totalPrice.compareTo(new BigDecimal(HANDLE_LEVEL)) < 1;
    }
}

  • 默认（最后一个节点）

    public class DefaultHandler extends AbstractHandler{
  @Override
  protected void examine(PurchaseOrder purchaseOrder, Result result) {
      purchaseOrder.setPass(false);
      result.setPass(false);
      result.setMsg("管理者讨论，不予通过，别问，问就是权限狗");
  }

  /**
   * 大于20万的由三者共同讨论,也就相当于最后的兜底处理了，直接返回true就行
   * @param totalPrice 商品总价
   * @return
   */
  @Override
  protected boolean judge(BigDecimal totalPrice) {
      return true;
  }
}

  • 组装，返回组装好的责任链头节点

    public class Chain {
  public static AbstractHandler getHandler(){
      AbstractHandler handler1 = new DirectorHandler();
      AbstractHandler handler2 = new DMHandler();
      AbstractHandler handler3 = new VGMHandler();
      AbstractHandler handler4 = new GMHandler();
      AbstractHandler handler5 = new DefaultHandler();
      handler1.setNext(handler2);
      handler2.setNext(handler3);
      handler3.setNext(handler4);
      handler4.setNext(handler5);
      return handler1;
  }
}

类图如下：

责任链模式 - 图1