常用设计模式：职责链模式

news/2025/11/15 16:38:32/文章来源:https://www.cnblogs.com/guangzan/p/19225743

根据 ChatGPT 的描述，后端项目中出现频率最高的前 6 名设计模式是：

排名	模式	典型应用
🥇 1	单例模式	数据库连接、缓存客户端、全局配置
🥈 2	工厂模式	动态加载不同实现（如多租户、支付、存储）
🥉 3	代理模式 / AOP	事务、日志、鉴权、缓存
4	策略模式	不同业务策略（支付、路由、计算方式）
5	模板方法模式	标准化业务流程
6	职责链模式	请求处理流水线、过滤器链（如 Spring FilterChain）

今天是周六，周末愉快！更新常用设计模式系列最后一篇：职责链模式，本周写作任务也算圆满完成。

简介

职责链模式（Chain of Responsibility）是一种行为设计模式，它允许将请求沿着处理者链传递，直到被处理。适用于日志记录、权限验证等场景，避免请求发送者和接收者耦合。

核心思想

每个处理者决定是否处理请求，或传递给下一个。
链式结构，提高灵活性。

优点

降低耦合度：请求发送者无需知道哪个对象会处理它的请求，只需要将请求发送到链上即可。
增强灵活性：可以动态地改变链中处理者的顺序，或者增加、删除处理者。
简化对象职责：每个处理者只需要处理自己职责范围内的工作，不符合的请求直接转发。
便于扩展：新增处理者非常容易，符合开闭原则。

适用场景

职责链模式在以下场景中特别有用：

多级处理系统：如审批流程、异常处理、事件冒泡
不确定处理者的场景：需要动态指定处理对象
可插拔的处理逻辑：如中间件、过滤器链

TypeScript 示例

假设审批流程：员工请假，经理->总监->CEO。

classDiagramclass Handler {-successor: Handler+setSuccessor(successor: Handler)+handleRequest(days: number)*}class Manager {+handleRequest(days: number)}class Director {+handleRequest(days: number)}class CEO {+handleRequest(days: number)}Handler <|-- ManagerHandler <|-- DirectorHandler <|-- CEOHandler o--> "0..1" Handler : successor

// 处理者抽象类
abstract class Handler {protected successor: Handler | null = null;setSuccessor(successor: Handler): void {this.successor = successor;}abstract handleRequest(days: number): void;
}// 具体处理者：经理
class Manager extends Handler {handleRequest(days: number): void {if (days <= 3) {console.log(`经理批准${days}天假`);} else if (this.successor) {this.successor.handleRequest(days);} else {console.log("无法批准");}}
}// 总监
class Director extends Handler {handleRequest(days: number): void {if (days <= 7) {console.log(`总监批准${days}天假`);} else if (this.successor) {this.successor.handleRequest(days);} else {console.log("无法批准");}}
}// CEO
class CEO extends Handler {handleRequest(days: number): void {if (days <= 30) {console.log(`CEO批准${days}天假`);} else {console.log("无法批准");}}
}// 使用
const manager = new Manager();
const director = new Director();
const ceo = new CEO();manager.setSuccessor(director);
director.setSuccessor(ceo);manager.handleRequest(2);  // 经理批准2天假
manager.handleRequest(5);  // 总监批准5天假
manager.handleRequest(20); // CEO批准20天假
manager.handleRequest(40); // 无法批准

真实案例

alibaba/Sentinel

alibaba/Sentinel 面向云原生微服务的高可用流控防护组件。

Sentinel 的核心机制之一，就是依靠 Slot Chain（槽链）构建的一条完整职责链，用于处理限流、熔断、热点参数、系统规则等逻辑。

这一套体系是典型的职责链模式工程化实现：
每个 Slot 是一个 Handler，SlotChain 是责任链，具体 Slot 按顺序依次执行，某些 Slot 可以中断链。

1. 抽象节点：AbstractLinkedProcessorSlot

这是所有 Slot 的抽象父类，职责链核心结构就在这里。

public abstract class AbstractLinkedProcessorSlot<T> implements ProcessorSlot<T> {private ProcessorSlot<T> next;@Overridepublic void setNext(ProcessorSlot<T> next) {this.next = next;}@Overridepublic void entry(Context context, ResourceWrapper resourceWrapper, Object... args) throws Throwable {// 当前 Slot 的处理逻辑（留给子类 override）fireEntry(context, resourceWrapper, args);}protected void fireEntry(Context context, ResourceWrapper resourceWrapper, Object... args) throws Throwable {if (next != null) {next.entry(context, resourceWrapper, args);}}@Overridepublic void exit(Context context, ResourceWrapper resourceWrapper, Object... args) {// 当前 Slot 的 exit 逻辑fireExit(context, resourceWrapper, args);}protected void fireExit(Context context, ResourceWrapper resourceWrapper, Object... args) {if (next != null) {next.exit(context, resourceWrapper, args);}}
}

这是典型 CoR：每个节点既处理，也决定是否继续传递。

next 指向下一个 Slot → 链结构
当前 Slot 做完自己的逻辑后调用 next.entry() → 请求向后传递
如果某个 Slot 不调用 fireEntry，链会被中断（比如限流时抛出异常）

2. 责任链容器：ProcessorSlotChain

负责保存 slot 链的头节点，并按顺序执行 entry/exit。

public class ProcessorSlotChain extends AbstractLinkedProcessorSlot<Object> {private ProcessorSlot<Object> first = null;private ProcessorSlot<Object> end = null;public void addFirst(ProcessorSlot<?> slot) {slot.setNext(first);first = (ProcessorSlot<Object>) slot;if (end == null) {end = first;}}public void addLast(ProcessorSlot<?> slot) {if (first == null) {first = end = (ProcessorSlot<Object>) slot;} else {end.setNext(slot);end = (ProcessorSlot<Object>) slot;}}@Overridepublic void entry(Context context, ResourceWrapper resourceWrapper, Object... args) throws Throwable {if (first != null) {first.entry(context, resourceWrapper, args);}}@Overridepublic void exit(Context context, ResourceWrapper resourceWrapper, Object... args) {if (first != null) {first.exit(context, resourceWrapper, args);}}
}

这是职责链容器的标准实现:

first、end 维护了一条链表结构
addLast / addFirst 构造责任链
entry() 执行链首，之后顺链传递

3. 链构造器：DefaultSlotChainBuilder

负责按照既定顺序将各种 Slot 串成链。

public class DefaultSlotChainBuilder implements SlotChainBuilder {@Overridepublic ProcessorSlotChain build() {ProcessorSlotChain chain = new ProcessorSlotChain();// 1. 选择调用链chain.addLast(new NodeSelectorSlot());// 2. 统计调用数据chain.addLast(new ClusterBuilderSlot());// 3. 流控规则检查chain.addLast(new FlowSlot());// 4. 熔断规则检查chain.addLast(new DegradeSlot());// 5. 系统规则chain.addLast(new SystemSlot());return chain;}
}

职责链逻辑说明

这是固定顺序的 Slot pipeline
每个 Slot 是职责链中的一个 “处理节点”
每个 Slot 的功能独立、解耦
添加顺序决定了处理流程
完全符合 GoF CoR 的链构建方式

4. 一个典型 Slot 示例：FlowSlot

这里是限流规则检查。限流发生时直接中断链。

public class FlowSlot extends AbstractLinkedProcessorSlot<DefaultNode> {@Overridepublic void entry(Context context, ResourceWrapper resourceWrapper, Object... args) throws Throwable {// 检查是否触发限流FlowRuleChecker.checkFlow(resourceWrapper, context, args);// 没有被限流：继续到下一个 slotfireEntry(context, resourceWrapper, args);}
}

职责链行为说明

FlowRuleChecker.checkFlow 若触发限流会抛异常
链处理被终止（典型 CoR：某节点可终止请求处理）
未限流 → 调用 fireEntry() → 继续下一个 slot

这是职责链里典型的“拦截节点”。

5. 请求进入链：Sentinel 核心调用逻辑

CtSph.entry() 调用 slot 链的入口

ProcessorSlotChain chain = SlotChainProvider.newSlotChain();chain.entry(context, resourceWrapper, args);

请求进入链首
逐个 slot 执行
期间任何 slot 抛 BlockException → 链终止

总结

flowchart LRC(Context) --> PSC[ProcessorSlotChain]PSC --> NS[NodeSelectorSlot]NS --> CB[ClusterBuilderSlot]CB --> FS[FlowSlot]FS --> DS[DegradeSlot]DS --> SS[SystemSlot]SS --> E(Exit)

Handler（处理节点）: ProcessorSlot & 各种具体 Slot（FlowSlot、DegradeSlot…）
Handler 基类: AbstractLinkedProcessorSlot
链（责任链）: ProcessorSlotChain
链构造器: DefaultSlotChainBuilder
请求入口: CtSph.entry() 调用 SlotChain

Sentinel 通过 SlotChain 实现：

可插拔 Slot
多个 Slot 组成 pipeline
Slot 可决定是否继续传递请求（关键的 CoR 特征）
Slot 之间松耦合，遵循开闭原则
真实工程中的高复杂度职责链，结构清晰可扩展

poppinss/middleware

poppinss/middleware本身就是一个 CoR（middleware pipeline）的实现。

import Middleware from '@poppinss/middleware'
import { NextFn } from '@poppinss/middleware/types'const context = {}
type MiddlewareFn = (ctx: typeof context, next: NextFn) => void | Promise<void>const middleware = new Middleware<MiddlewareFn>()middleware.add((ctx, next) => {console.log('executing fn1')await next()
})middleware.add((ctx, next) => {console.log('executing fn2')await next()
})await middleware.runner().run((fn, next) => fn(context, next))

const middleware = new Middleware<MiddlewareFn>()：创建一个 Middleware 实例。这个类正是 CoR 的核心 — 它管理一个链（chain）。
middleware.add((ctx, next) => { ... })：通过 add 方法将一个中间件处理函数加入链中。对应 CoR 模式里“将一个处理器（handler）加入链”。
await next()：在中间件内部调用 next()，表示把控制权传给链上的下一个处理器。正是 CoR “传递请求给下一个处理者”的机制。
.runner().run((fn, next) => fn(context, next))：创建一个 runner 来依次触发链上的处理器。run 方法遍历整个链，调度每一个中间件。