本文共 5173 字，大约阅读时间需要 17 分钟。

意图

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

---

适用场景

1、有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定；

2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求； 3、处理一个请求的对象集合应被动态指定。

---

结构图

职责链模式角色

•Handler（抽象处理者）：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法，以设定和返回对下家的引用。这个角色通常由一个抽象类或接口实现。

•ConcreteHandler（具体处理者）：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。 •Client: 客户端

---

优缺点

职责链模式的优点

• 降低耦合度

• 可简化对象的相互连接

• 增强给对象指派职责的灵活性

• 增加新的请求处理类很方便

职责链模式的缺点

•不能保证请求一定被接收。

•系统性能将受到一定影响，而且在进行代码调试时不太方便；可能会造成循环调用。

---

实现

// 全局变量，接口类型  /**   * 使用Java中的interface定义全局变量，可根据具体需要在    * 具体的包中使用静态导入相关的全局变量，语法如下：    *  import static package01.package02.*;   */ interface Levels {      public static final int LEVEL_01 = 1;      public static final int LEVEL_02 = 2;      public static final int LEVEL_03 = 3;  }

// 抽象请求类  abstract class AbstractRequest {
         private String content = null;      public AbstractRequest(String content) {          this.content = content;      }      public String getContent() {          return this.content;      }      // 获得请求的级别      public abstract int getRequestLevel();  } // 具体请求类01  class Request01 extends AbstractRequest {
         public Request01(String content) {          super(content);      }      @Override     public int getRequestLevel() {          return Levels.LEVEL_01;      }  }  // 具体请求类02  class Request02 extends AbstractRequest {
         public Request02(String content) {          super(content);      }      @Override     public int getRequestLevel() {          return Levels.LEVEL_02;      }  }  // 具体请求类03  class Request03 extends AbstractRequest {
         public Request03(String content) {          super(content);      }      @Override     public int getRequestLevel() {          return Levels.LEVEL_03;      }  }

// 抽象处理者类，  abstract class AbstractHandler {
         // 责任链的下一个节点，即处理者      private AbstractHandler nextHandler = null;      // 捕获具体请求并进行处理，或是将请求传递到责任链的下一级别      public final void handleRequest(AbstractRequest request) {          // 若该请求与当前处理者的级别层次相对应，则由自己进行处理          if (this.getHandlerLevel() == request.getRequestLevel()) {              this.handle(request);          } else {              // 当前处理者不能胜任，则传递至职责链的下一节点              if (this.nextHandler != null) {                  System.out.println("当前 处理者-0" + this.getHandlerLevel()                          + " 不足以处理 请求-0" + request.getRequestLevel());                  // 这里使用了递归调用                  this.nextHandler.handleRequest(request);              } else {                  System.out.println("职责链上的所有处理者都不能胜任该请求...");              }          }      }      // 设置责任链中的下一个处理者      public void setNextHandler(AbstractHandler nextHandler) {          this.nextHandler = nextHandler;      }      // 获取当前处理者的级别      protected abstract int getHandlerLevel();      // 定义链中每个处理者具体的处理方式      protected abstract void handle(AbstractRequest request);  } // 具体处理者-01  class Handler01 extends AbstractHandler {
         @Override     protected int getHandlerLevel() {          return Levels.LEVEL_01;      }      @Override     protected void handle(AbstractRequest request) {          System.out.println("处理者-01 处理 " + request.getContent() + "\n");      }  }  // 具体处理者-02  class Handler02 extends AbstractHandler {
         @Override     protected int getHandlerLevel() {          return Levels.LEVEL_02;      }      @Override     protected void handle(AbstractRequest request) {          System.out.println("处理者-02 处理 " + request.getContent()+ "\n");      }  }  // 具体处理者-03  class Handler03 extends AbstractHandler {
         @Override     protected int getHandlerLevel() {          return Levels.LEVEL_03;      }      @Override     protected void handle(AbstractRequest request) {          System.out.println("处理者-03 处理 " + request.getContent()+ "\n");      }  }

// 测试类  public class Client {      public static void main(String[] args) {          // 创建指责链的所有节点          AbstractHandler handler01 = new Handler01();          AbstractHandler handler02 = new Handler02();          AbstractHandler handler03 = new Handler03();          // 进行链的组装，即头尾相连，一层套一层          handler01.setNextHandler(handler02);          handler02.setNextHandler(handler03);          // 创建请求并提交到指责链中进行处理          AbstractRequest request01 = new Request01("请求-01");          AbstractRequest request02 = new Request02("请求-02");          AbstractRequest request03 = new Request03("请求-03");          // 每次提交都是从链头开始遍历          handler01.handleRequest(request01);          handler01.handleRequest(request02);          handler01.handleRequest(request03);      }  }

---

总结

行为型模式是对在不同的对象之间划分责任和算法的抽象化。行为型模式不仅仅关注类和对象的结构，而且重点关注它们之间的相互作用。通过行为型模式，可以更加清晰地划

分类与对象的职责，并研究系统在运行时实例对象之间的交互。行为型模式可以分为类行为型模式和对象行为型模式两种。

职责链模式可以避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。它是一种对象行为型模式。

职责链模式包含两个角色：抽象处理者定义了一个处理请求的接口；具体处理者是抽象处理者的子类，它可以处理用户请求。

在职责链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知

道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。

职责链模式的主要优点在于可以降低系统的耦合度，简化对象的相互连接，同时增强给对象指派职责的灵活性，增加新的请求处理类也很方便；其主要缺点在于不能保证请求一 定被接收，且对于比较长的职责链，请求的处理可能涉及到多个处理对象，系统性能将受到一定影响，而且在进行代码调试时不太方便。

职责链模式适用情况包括：有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定；在不明确指定接收者的情况下，向多个对象中的一个提交一个请求；可动态指定一组对象处理请求。