6.4 责任链模式

6.4 责任链模式

6.4.1 概述

在现实生活中，常常会出现这样的事例：一个请求有多个对象可以处理，但每个对象的处理条件或权限不同。例如，公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据自己要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这增加了难度。这样的例子还有很多，如找领导出差报销、生活中的“击鼓传花”游戏等。

定义：

又名职责链模式，为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

🧠 理论理解
责任链模式是一种行为型设计模式，核心思想是：
让多个处理者串成一条链，请求沿链传递，直到某个处理者接手。这样请请求发送者和接收者解耦，请求者不需要知道具体由谁处理，只需要交给链头。
这种模式特别适用于有顺序、有层次的处理流程，比如审批流、拦截器、日志、权限等。

🏢 企业实战理解
在大厂实际应用中，责任链广泛出现在：

• 阿里：审批工作流（如请假、报销、合同流转），用责任链串起各个审批节点。

• 字节：内容风控拦截链，依次经过敏感词检测、机器审核、人工审核。

• Google Cloud：API Gateway 的拦截链，按顺序经过认证、限流、路由、熔断等模块。
  这些场景都要求灵活扩展、动态调整，责任链提供了极好的结构化支持。

 

面试题 1

什么是责任链模式？适用于哪些场景？

✅ 答案：
责任链模式是一种行为型设计模式，核心思想是：
把多个处理者串成一条链，请求沿链传递，直到某个处理者处理它或走到链尾。

适用场景：

• 多个处理者可处理同类请求，最终由谁处理取决于运行时条件。

• 希望请求发送者和接收者解耦，不用在代码中写 if/else、switch。

• 系统需要灵活调整处理流程、扩展处理节点。

常见应用：审批流、日志处理、过滤器链、事件传播、中间件处理链等。

 

场景题 1

你在字节跳动负责内容审核平台，平台采用责任链串联多级审核（如：敏感词过滤 → 机器审核 → 人工复审 → 法务抽检）。最近发现某个节点偶尔超时，导致整条链卡住，影响上线。请问你怎么优化？

✅ 答案：
分析：责任链模式是同步串行执行，某个节点慢会拖慢整体。
优化方案：
1️⃣ 设置节点超时机制（如机器审核 200ms，超时自动跳过或兜底）。
2️⃣ 允许部分节点异步化（如法务抽检独立触发，不阻塞主链）。
3️⃣ 给每个节点加监控，分析慢节点原因（CPU、内存、外部依赖）。
4️⃣ 把链拆分成并行小段，比如机器审核 + 法务抽检并行跑，最后汇总结果。
字节大规模流量场景常用异步、分段、熔断等手段优化链路。

6.4.2 结构

职责链模式主要包含以下角色:

• 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。

• 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。

• 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

🧠 理论理解
责任链模式的三大角色：
✅ 抽象处理者（Handler）：定义接口，保存下一个处理者引用。
✅ 具体处理者（ConcreteHandler）：实现实际处理逻辑。
✅ 客户端（Client）：构造链，并发起请求。
请求从链头传入，处理者逐个尝试，如果不能处理则交给下一个，直到链尾。

🏢 企业实战理解
在大厂项目里，责任链往往用链表、数组或配置驱动实现，支持：

• 动态调整处理者顺序（比如上线、下线某个模块）

• 插拔式扩展（比如新增埋点、灰度分流、实验模块）

• 分布式链路（跨多个服务的分布式责任链）
  这类设计让系统具备强大的可维护性和可扩展性。

场景题 2

你在阿里负责合同审批流系统，现在需求变更，要在小组长和经理之间插入一个财务专员审批节点。你怎么用责任链模式支持这种扩展，保证系统可维护？

✅ 答案：
方案：
1️⃣ 每个审批节点实现抽象 Handler 接口。
2️⃣ 审批链用配置文件（或数据库、配置中心）动态管理节点顺序。
3️⃣ 插入新节点时，只需在配置中声明顺序，不改动客户端或其他节点代码。
4️⃣ 提供链路初始化工具，按配置自动组装责任链。

阿里中台系统大量采用配置驱动责任链，让业务、审批规则由业务方自助管理，而非写死在代码中。

 

面试题 2

责任链模式相比 if-else、switch 有什么优势？有没有代价？

✅ 答案：
优势：

• 降低耦合：请求发送者无需知道接收者是谁。

• 灵活扩展：新增或调整处理节点，只需改链，不改客户端代码。

• 符合单一职责原则，每个处理者只管自己部分。

代价：

• 性能：链太长时，层层传递增加开销。

• 不保证处理：请求可能整个链走完没人处理。

• 调试复杂：链路配置错误、循环引用容易导致 bug。

 

6.4.3 案例实现

现需要开发一个请假流程控制系统。请假一天以下的假只需要小组长同意即可；请假1天到3天的假还需要部门经理同意；请求3天到7天还需要总经理同意才行。

类图如下：

 

代码如下：

//请假条
public class LeaveRequest {
    private String name;//姓名
    private int num;//请假天数
    private String content;//请假内容
​
    public LeaveRequest(String name, int num, String content) {
        this.name = name;
        this.num = num;
        this.content = content;
    }
​
    public String getName() {
        return name;
    }
​
    public int getNum() {
        return num;
    }
​
    public String getContent() {
        return content;
    }
}
​
//处理者抽象类
public abstract class Handler {
    protected final static int NUM_ONE = 1;
    protected final static int NUM_THREE = 3;
    protected final static int NUM_SEVEN = 7;
​
    //该领导处理的请假天数区间
    private int numStart;
    private int numEnd;
​
    //领导上面还有领导
    private Handler nextHandler;
​
    //设置请假天数范围 上不封顶
    public Handler(int numStart) {
        this.numStart = numStart;
    }
​
    //设置请假天数范围
    public Handler(int numStart, int numEnd) {
        this.numStart = numStart;
        this.numEnd = numEnd;
    }
​
    //设置上级领导
    public void setNextHandler(Handler nextHandler){
        this.nextHandler = nextHandler;
    }
​
    //提交请假条
    public final void submit(LeaveRequest leave){
        if(0 == this.numStart){
            return;
        }
​
        //如果请假天数达到该领导者的处理要求
        if(leave.getNum() >= this.numStart){
            this.handleLeave(leave);
​
            //如果还有上级 并且请假天数超过了当前领导的处理范围
            if(null != this.nextHandler && leave.getNum() > numEnd){
                this.nextHandler.submit(leave);//继续提交
            } else {
                System.out.println("流程结束");
            }
        }
    }
​
    //各级领导处理请假条方法
    protected abstract void handleLeave(LeaveRequest leave);
}
​
//小组长
public class GroupLeader extends Handler {
    public GroupLeader() {
        //小组长处理1-3天的请假
        super(Handler.NUM_ONE, Handler.NUM_THREE);
    }
​
    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("小组长审批：同意。");
    }
}
​
//部门经理
public class Manager extends Handler {
    public Manager() {
        //部门经理处理3-7天的请假
        super(Handler.NUM_THREE, Handler.NUM_SEVEN);
    }
​
    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("部门经理审批：同意。");
    }
}
​
//总经理
public class GeneralManager extends Handler {
    public GeneralManager() {
        //部门经理处理7天以上的请假
        super(Handler.NUM_SEVEN);
    }
​
    @Override
    protected void handleLeave(LeaveRequest leave) {
        System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
        System.out.println("总经理审批：同意。");
    }
}
​
//测试类
public class Client {
    public static void main(String[] args) {
        //请假条来一张
        LeaveRequest leave = new LeaveRequest("小花",5,"身体不适");
​
        //各位领导
        GroupLeader groupLeader = new GroupLeader();
        Manager manager = new Manager();
        GeneralManager generalManager = new GeneralManager();
​
        groupLeader.setNextHandler(manager);//小组长的领导是部门经理
        manager.setNextHandler(generalManager);//部门经理的领导是总经理
        //之所以在这里设置上级领导，是因为可以根据实际需求来更改设置，如果实战中上级领导人都是固定的，则可以移到领导实现类中。
​
        //提交申请
        groupLeader.submit(leave);
    }
}

面试题 3

在阿里、字节、Google 这样的分布式系统中，责任链模式有哪些实际应用？

✅ 答案：

• 阿里：审批工作流（合同、报销）、网关拦截链、日志埋点链。

• 字节：内容审核链（机器审核 → 人工审核）、推荐流拦截链、AB 实验链。

• Google Cloud：API Gateway 的流量控制链、Istio 网关的策略执行链。

• OpenAI：多模型推理管线，串联预处理、模型调用、后处理各环节。

这些场景都用责任链封装复杂、多步骤的处理过程，并让流程可配置、可扩展、可监控。

场景题 3

你在 Google Cloud 团队，负责 API Gateway。现在要在请求链中按顺序插入认证、鉴权、限流、路由、熔断模块。如何用责任链模式设计，确保高并发和可扩展？

✅ 答案：
设计方案：
✅ 每个模块实现统一 Handler 接口，暴露 handle() 方法。
✅ Gateway 用责任链串起模块，保证请求顺序流转。
✅ 每个模块独立可插拔，支持开关、顺序调整（通过配置管理）。
✅ 对高并发场景：

• 各模块只读请求上下文，减少共享锁。

• 串行必须做的模块（认证、鉴权）串行处理，其他可并行（限流、监控）。
  ✅ 提供分布式跟踪和日志，方便定位链路瓶颈。

Google Cloud 这样的云平台产品需要保证链路的动态配置、并行优化、观测能力。

 

6.4.4 优缺点

1，优点：

• 降低了对象之间的耦合度

  该模式降低了请求发送者和接收者的耦合度。

• 增强了系统的可扩展性

  可以根据需要增加新的请求处理类，满足开闭原则。

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

  当工作流程发生变化，可以动态地改变链内的成员或者修改它们的次序，也可动态地新增或者删除责任。

• 责任链简化了对象之间的连接

  一个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。

• 责任分担

  每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

2，缺点：

• 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。

• 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。

• 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

🧠 理论理解
✅ 优点：

• 降低耦合：请求者不用关心具体由谁处理。

• 灵活扩展：可以动态调整链、增删节点。

• 符合单一职责：每个处理者专注自己的工作。

❌ 缺点：

• 不保证请求一定被处理（可能走完整条链都没人接手）。

• 链过长时，传递消耗多、性能受影响。

• 合理性依赖客户端保证（链的配置必须正确，避免死循环）。

🏢 企业实战理解
阿里、字节的责任链系统通常有：

• 配置化驱动：链路顺序、启停由配置中心控制，热更新。

• 监控链路：链中每个节点都挂接监控指标（QPS、RT、异常率）。

• 超时保护：链路中各节点设置超时阈值，避免链卡死。
  这些都是大厂用责任链时的工程化加强版。

面试题 4

如何动态调整责任链上的节点？如果一个节点需要上下文信息，怎么传递？

✅ 答案：
动态调整：

• 用配置中心（如 Nacos、Zookeeper、Consul）管理链路节点启停、顺序，热加载更新。

• 用依赖注入（如 Spring）自动装配链，按配置组装。

上下文传递：

• 定义统一的 Context 对象（包含请求、响应、共享参数等），沿链传递。

• 每个节点都从 Context 里取需要的信息，并可修改或附加新数据。
  这种上下文模式在 Spring 的 HandlerInterceptor、Netty 的 ChannelHandler 中大量应用。

---

面试题 5

责任链和拦截器链、过滤器链的区别和联系是什么？

✅ 答案：
联系：

• 本质都是责任链模式的应用。

• 都能在链上顺序、逆序地对请求或响应进行加工、拦截、放行。

区别：

• 过滤器链（FilterChain）：Java Servlet 规范定义，针对原始 HTTP 请求、响应。

• 拦截器链（InterceptorChain）：框架层（如 Spring）定义，针对 Controller 调用前后。

• 责任链：更通用的设计模式概念，不限于 Web 或网络层。

在大厂系统中，这三者通常结合使用：Filter 做全局前置处理，Interceptor 做业务前置、后置处理，业务内部则用责任链拆解复杂流程。

---

面试题 6

责任链模式在高并发、分布式系统下可能遇到哪些挑战？如何优化？

✅ 答案：
挑战：

• 链路太长 → 延迟高、性能低。

• 链中节点分布在不同服务 → 网络调用、分布式事务复杂。

• 错误传播难 → 某个节点出错，难以定位、隔离。

优化方案：

• 用短链 + 分段链组合，减少单链长度。

• 链中节点按功能拆成独立微服务，链路用消息、事件驱动解耦。

• 引入链路追踪（如 OpenTelemetry、SkyWalking），监控每个节点的耗时、状态。

• 用超时、熔断、降级机制保护链路尾部，避免雪崩。

 

场景题 4

你在腾讯负责广告系统，需要用责任链实现广告请求的处理链：分发 → 定向筛选 → 竞价排序 → 模板渲染。遇到以下挑战，你怎么优化？

1️⃣ 定向筛选数据量大，耗时高。
2️⃣ 竞价排序涉及外部调用，偶尔超时。
3️⃣ 模板渲染部分逻辑可异步。

✅ 答案：
优化方案：

• 定向筛选：用缓存（如 Redis 命中人群标签），减少实时计算。

• 竞价排序：加超时熔断、降级（用历史最高价兜底），避免拖慢主链。

• 模板渲染：切分成异步模块，不阻塞主链返回。

• 整体：责任链按功能拆段，主链只跑核心路径，非核心任务异步分离。

腾讯广告业务在核心链路上特别强调快速响应（毫秒级），通常用分段链、异步化、降级兜底来保障性能。

---

场景题 5

你在 OpenAI 团队负责多模型推理管线：预处理 → 模型 A → 模型 B → 后处理 → 结果汇总。由于模型 B 很重，有时导致整体超时，用户体验下降。怎么用责任链优化？

✅ 答案：
优化思路：
✅ 责任链不要求所有节点都必须串行。

• 判断是否可以模型 A 和 B 并行跑，或按条件选择性跑（不是每个请求都需要 B）。
  ✅ 模型 B 独立为异步任务，主链用上次结果兜底返回，稍后补发更新。
  ✅ 给模型 B 节点加熔断保护，连续超时后暂停调用。
  ✅ 在责任链中引入优雅降级策略，让主链可在部分模块失败时继续返回部分结果。

OpenAI 这种 AI 任务链，典型特征是重计算、复杂依赖，工程上需要责任链 + 异步化 + 熔断 + 缓存多层优化。

6.4.5 源码解析

在javaWeb应用开发中，FilterChain是职责链（过滤器）模式的典型应用，以下是Filter的模拟实现分析:

🧠 理论理解
Java Web 中的 FilterChain 就是责任链的经典实现：

• 一个请求进入服务器后，按顺序经过多个过滤器。

• 每个过滤器可以决定是否放行、是否中断请求。

• 最终让主处理器（如 Servlet、Controller）获得干净、经过预处理的请求。

🏢 企业实战理解
在大厂项目中：

• Spring 框架中的 HandlerInterceptorChain（拦截器链）用于权限、日志、异常拦截。

• Netty 中的 ChannelPipeline 也是责任链，负责 I/O 流的解码、编码、业务处理。

• Google Cloud 的 Istio 网关中，用责任链串起认证、流控、遥测、策略等模块，保证流量在进出服务网格前被层层控制。
  这些应用场景表明，责任链不仅是模式，更是一种系统级架构能力。

 

• 模拟web请求Request以及web响应Response

  public interface Request{
   
  }
  ​
  public interface Response{
   
  }

• 模拟web过滤器Filter

   public interface Filter {
      public void doFilter(Request req,Response res,FilterChain c);
   }

• 模拟实现具体过滤器

  public class FirstFilter implements Filter {
      @Override
      public void doFilter(Request request, Response response, FilterChain chain) {
  ​
          System.out.println("过滤器1 前置处理");
  ​
          // 先执行所有request再倒序执行所有response
          chain.doFilter(request, response);
  ​
          System.out.println("过滤器1 后置处理");
      }
  }
  ​
  public class SecondFilter  implements Filter {
      @Override
      public void doFilter(Request request, Response response, FilterChain chain) {
  ​
          System.out.println("过滤器2 前置处理");
  ​
          // 先执行所有request再倒序执行所有response
          chain.doFilter(request, response);
  ​
          System.out.println("过滤器2 后置处理");
      }
  }

• 模拟实现过滤器链FilterChain

  public class FilterChain {
  ​
      private List<Filter> filters = new ArrayList<Filter>();
  ​
      private int index = 0;
  ​
      // 链式调用
      public FilterChain addFilter(Filter filter) {
          this.filters.add(filter);
          return this;
      }
  ​
      public void doFilter(Request request, Response response) {
          if (index == filters.size()) {
              return;
          }
          Filter filter = filters.get(index);
          index++;
          filter.doFilter(request, response, this);
      }
  }