在现实生活中，一个事件需要经过多个对象处理是很常见的场景。例如，采购审批流程、请假流程等。公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据需要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这无疑增加了难度。
在计算机软硬件中也有相关例子，如总线网中数据报传送，每台计算机根据目标地址是否同自己的地址相同来决定是否接收；还有异常处理中，处理程序根据异常的类型决定自己是否处理该异常；还有 Struts2 的拦截器、JSP 和 Servlet 的 Filter 等，所有这些，都可以考虑使用责任链模式来实现。

定义

责任链（Chain Of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
责任链模式也叫职责链模式。在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，请求会自动进行传递。所以责任链将请求的发送者和请求的处理者解耦。

优点

降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理请求以及链的结构，发送者和接收者也无须拥有对方的明确信息
增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则
增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任
责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if…else 语句
责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则

缺点
不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理
对比较长的职责链，请求的处理可能涉及到多个处理对象，系统性能将受到一定影响
职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用

结构
通常情况下，可以通过数据链表来实现职责链模式的数据结构。
职责链模式主要包含以下角色：
抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接
具体处理者（ConcreteHandler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者
客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程

责任链模式 - 图1

package chainOfResponsibility;
public class ChainOfResponsibilityPattern {
    public static void main(String[] args) {
        //组装责任链
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        handler1.setNext(handler2);
        //提交请求
        handler1.handleRequest("two");
    }
}
//抽象处理者角色
abstract class Handler {
    private Handler next;
    public void setNext(Handler next) {
        this.next = next;
    }
    public Handler getNext() {
        return next;
    }
    //处理请求的方法
    public abstract void handleRequest(String request);
}
//具体处理者角色1
class ConcreteHandler1 extends Handler {
    public void handleRequest(String request) {
        if (request.equals("one")) {
            System.out.println("具体处理者1负责处理该请求！");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(request);
            } else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}
//具体处理者角色2
class ConcreteHandler2 extends Handler {
    public void handleRequest(String request) {
        if (request.equals("two")) {
            System.out.println("具体处理者2负责处理该请求！");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(request);
            } else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}

程序运行结果如下：

具体处理者2负责处理该请求！

在上面的代码中，我们把消息硬编码成 String 类型，而在真实业务中，消息是具备多样性的，可以是 int、String 或者自定义类型。因此，在上面代码的基础上，可以对消息类型进行抽象 Request，增强了信息的兼容性。

应用实例

【例】用责任链模式设计一个请假条审批模块。
分析：假如规定学生请假小于等于2天，班主任可以批准；小于等于7天，系主任可以批准；小于等于10天，院长可以批准；其他情况不予批准；这个实例适合使用责任链模式实现。
首先，定义一个领导类（Leader），它是抽象处理者，包含了一个只想下一位领导的指针 next 和一个处理假条的抽象方法 handleRequest(int LeaveDays)；然后，定义班主任类（ClassAdviser）、系主任类（DepartmentHead）和院长类（Dean），它们是抽象处理者的子类，是具体处理者，必须根据自己的权力去实现父类的 handleRequest(int leaveDays) 方法，如果无权处理就将假条交给下一位具体处理者，知道最后；客户类负责创建处理链，并将假条交给链头的具体处理者（班主任）。
责任链模式 - 图2

public class Client {
  public static void main(String[] args) {
    Leader classAdviser = new ClassAdviser();
    Leader departmentHead = new DepartmentHead();
    Leader dean = new Dean();
    Leader deanOfStudies = new DeanOfStudies();
    classAdviser.setNext(departmentHead);
    departmentHead.setNext(dean);
    dean.setNext(deanOfStudies);
    classAdviser.handleRequest(new Request(8));
  }
}

public class Request {
  private int leaveDays;
  public Request() {}
  public Request(int leaveDays) {
    this.leaveDays = leaveDays;
  }
  public int getLeaveDays() {
    return leaveDays;
  }
  public void setLeaveDays(int leaveDays) {
    this.leaveDays = leaveDays;
  }
}

public abstract class Leader {
  private Leader next;
  protected abstract boolean support(Request request);
  public void handleRequest(Request request) {
    if (this.support(request)) {
      System.out.println(this.getClass().getSimpleName() + "批准你请假" + request.getLeaveDays() + "天");
    } else {
      if (next == null) {
        System.out.println("请假天数太多，没有人批准该假条！");
      } else {
        next.handleRequest(request);
      }
    }
  }
  public Leader getNext() {
    return next;
  }
  public void setNext(Leader next) {
    this.next = next;
  }
}

/** 班主任 */
public class ClassAdviser extends Leader {
  @Override
  protected boolean support(Request request) {
    return request.getLeaveDays() <= 2;
  }
}

/** 系主任 */
public class DepartmentHead extends Leader {
  @Override
  protected boolean support(Request request) {
    return request.getLeaveDays() <= 7;
  }
}

/** 院长 */
public class Dean extends Leader {
  @Override
  protected boolean support(Request request) {
    return request.getLeaveDays() <= 10;
  }
}

程序运行结果：

院长批准您请假8天。

假如增加一个教务处长类，可以批准学生请假20天，也非常简单，代码如下：

/** 教务处长 */
public class DeanOfStudies extends Leader {
  @Override
  protected boolean support(Request request) {
    return request.getLeaveDays() <= 20;
  }
}

应用场景

前面已经讲述了关于责任链模式的结构与特点，下面介绍其应用场景，责任链模式通常在以下几种情况使用。

多个对象可以处理一个请求，但具体由哪个对象处理该请求在运行时自动确定
可动态指定一组对象处理请求，或添加新的处理者
需要在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求

扩展
责任链模式存在以下两种情况：
纯的责任链模式：一个请求必须被某一个处理者对象所接收，且一个具体处理者对某个请求的处理只能采用以下两种行为之一：自己处理（承担责任）；把责任推给下家处理
不纯的责任链模式：允许出现某一个具体处理者对象在承担了请求的一部分责任后又将剩余的责任传给下家的情况，且一个请求可以最终不被任何接收端对象所接收

责任链模式

定义

优点

缺点

结构

应用实例

应用场景

扩展