定义

使多个对象都有机会处理请求，从而避免了请求的发送者和接收者致敬的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

使用场景

• 多个对象可以处理同一请求，但是具体有哪个来处理则在运行时动态决定
• 在请求处理者不明确的情况下向多个对象中的一个提交请求
• 需要动态指定一组对象处理请求
• 代码中存在多个if-else语句的情况下，此时可以考虑使用责任链模式来对代码进行重构。

结构

• AbstractHandler

  抽象处理角色，声明了处理对象处理请求的方法，并在其中保存一个对下一个处理节点AbstractHandler的引用

• AbstractRequest

  抽象请求者或者具体请求者，根据不同需求可以选择性采取策略

简单实现

模拟请假流程

public abstract class Leader {

  /**
   * 下一节点上的处理者对象
   */
  protected Leader nextHandler;

  /**
   * 处理请求
   *
   * @param request 请求对象
   */
  public final void handlerRequest(LeaveRequest request) {
    if (request.getDay() <= limit()) {
      handle(request);
    } else {
      if (null != nextHandler) {
        nextHandler.handlerRequest(request);
      }
    }
  }

  /**
   * 请求处理
   *
   * @param request 请求条件
   */
  protected abstract void handle(LeaveRequest request);

  /**
   * 有权审批的最大天数
   *
   * @return 最大天数
   */
  public abstract int limit();
}

Leader类充当AbstractHandler的角色，负责主要的逻辑实现；责任转发的逻辑交由handlerRequest（）实现，声明了一个获取限制条件的limit（）抽象方法

public class LeaveRequest {

  private String name;
  private int day;

  public LeaveRequest(String name, int day) {
    this.name = name;
    this.day = day;
  }
     //get set 省略
     ...
     
  }

LeaveRequest为请求者的信息，这里为了简单，没有使用抽象类

public class TeamLeader extends Leader {

  private String name;

  public TeamLeader(String name) {
    this.name = name;
  }

  @Override protected void handle(LeaveRequest request) {
    System.out.println(name + "审批员工" + request.getName() + " 的请假条，请假天数为" + request.getDay() + "天");
  }

  @Override public int limit() {
    return 3;
  }
}

public class Manager extends Leader {

  private String name;

  public Manager(String name) {
    this.name = name;
  }

  @Override protected void handle(LeaveRequest request) {
    System.out.println(name + "审批员工" + request.getName() + " 的请假条，请假天数为" + request.getDay() + "天");
  }

  @Override public int limit() {
    return 10;
  }
}

public class Director extends Leader {

  private String name;

  public Director(String name) {
    this.name = name;
  }

  @Override protected void handle(LeaveRequest request) {
    System.out.println(name + "审批员工" + request.getName() + " 的请假条，请假天数为" + request.getDay() + "天");
  }

  @Override public int limit() {
    return 15;
  }
}

public class Boss extends Leader {

  private String name;

  public Boss(String name) {
    this.name = name;
  }

  @Override protected void handle(LeaveRequest request) {
    System.out.println(name + "审批员工 " + request.getName() + " 的请假条，请假天数为" + request.getDay() + "天");
  }

  @Override public int limit() {
    return Integer.MAX_VALUE;
  }
}

具体的几个处理者对象，各自负责各自功能的实现

public class Test {

  public static void main(String[] args) {

    // 处理者对象
    Leader handler1 = new TeamLeader("沙僧");
    Leader handler2 = new Manager("八戒");
    Leader handler3 = new Director("悟空");
    Leader handler4 = new Boss(" 唐僧");

    //  请求者对象
    LeaveRequest request1 = new LeaveRequest("张三", 2);
    LeaveRequest request2 = new LeaveRequest("李四", 5);
    LeaveRequest request3 = new LeaveRequest("王五", 11);
    LeaveRequest request4 = new LeaveRequest("赵六", 18);
    LeaveRequest request5 = new LeaveRequest("赵六", 30);

    //设置责任节点链
    handler1.nextHandler = handler2;
    handler2.nextHandler = handler3;
    handler3.nextHandler = handler4;

    System.out.println("---------request1---------------");
    handler1.handlerRequest(request1);

    System.out.println("----------request2--------------");
    handler1.handlerRequest(request2);

    System.out.println("-----------request3-------------");
    handler1.handlerRequest(request3);

    System.out.println("-----------request4-------------");
    handler1.handlerRequest(request4);

    System.out.println("-----------request5-------------");
    handler1.handlerRequest(request5);

    System.out.println("-----------request1-------------");
    handler3.handlerRequest(request1);

    System.out.println("-----------request4-------------");
    handler3.handlerRequest(request4);
  }
}

测试类及结果

---------request1---------------
沙僧审批员工张三 的请假条，请假天数为2天
----------request2--------------
八戒审批员工李四 的请假条，请假天数为5天
-----------request3-------------
悟空审批员工王五 的请假条，请假天数为11天
-----------request4-------------
 唐僧审批员工 赵六 的请假条，请假天数为18天
-----------request5-------------
 唐僧审批员工 赵六 的请假条，请假天数为30天
-----------request1-------------
悟空审批员工张三 的请假条，请假天数为2天
-----------request4-------------
 唐僧审批员工 赵六 的请假条，请假天数为18天

思考

责任链模式理解起来比较简单，核心的思想就是在AbstractHandler中保留一个AbstractHandler的引用来进行处理

责任链模式的主要优点在于可以降低系统耦合度，简化对象的相互连接，同时增强给对象指派职责的灵活性，增加新的处理类也很方便

对于比较长的责任链，请求的处理可能涉及多个对象，对性能可能会有一定影响

不能保证请求一定被接收，下游的请求无法传递给上游处理