前言
本文首先介绍了责任链的基本原理，并附带一个例子说明责任链模式，确保能够理解责任链的前提下，在进行Spring AOP执行责任链的源码分析。责任链模式允许将多个处理对象连接成链，请求沿着链传递，直到被处理或结束。每个处理者可以选择处理请求或传递给下一个。
Spring AOP的拦截器链，拦截器或者过滤器链，都是典型的责任链应用。比如，当一个方法被调用时，多个拦截器按顺序执行，每个拦截器可以决定是否继续执行链中的下一个。
深入Spring AOP的源码部分，特别是拦截器链的执行过程。比如，在Spring AOP中，当调用一个被增强的方法时，会创建一个MethodInvocation对象，其中包含拦截器链。每个拦截器都是一个Advice，比如MethodInterceptor。这时候，责任链模式的应用可能体现在拦截器的依次调用上，每个拦截器处理完后调用下一个，直到最后一个拦截器执行实际的方法。
具体分析Spring的源码，比如ReflectiveMethodInvocation类的proceed方法。这个方法可能负责按顺序调用拦截器链中的每个拦截器，直到所有拦截器处理完毕，最后调用目标方法。这个流程是否符合责任链模式的结构？是的，每个拦截器处理请求，并决定是否传递下去。
可能还需要比较责任链模式的不同变体，比如纯的责任链（每个处理者必须处理请求）和不纯的（可以传递）。Spring AOP的拦截器链属于后者，每个拦截器都可以选择是否继续传递，或者在处理前后执行某些操作，然后继续传递。
另外，Spring AOP的基本原理不在本文中介绍了，详情请看以往文章，有更加详细的表述，有理论和源码的解析。文章：Spring AOP源码解析
实际应用场景本文也涉及到，如何自定义拦截器，如何调整拦截器链的顺序，或者如何利用责任链模式实现类似的功能。这些实际应用案例可以增强回答的实用性。
最后，确保回答结构清晰，先解释责任链模式，再结合Spring源码详细说明，最后总结其优势和应用场景。需要避免过于冗长的代码分析，而是突出重点部分，比如关键类和方法的调用流程。
责任链模式原理详解与源码实例
一、责任链模式（Chain of Responsibility Pattern）原理
核心思想：将多个处理对象连成一条链，请求沿链传递，直到有一个处理对象处理它或链结束。每个处理对象可选择处理请求或传递给下一个对象。
1. 模式结构
| 角色 | 职责 |
|---|---|
| Handler（抽象处理者） | 定义处理请求的接口，通常包含指向下一个处理者的引用（nextHandler）。 |
| ConcreteHandler | 具体处理者，实现处理逻辑，或决定是否将请求传递到下一个处理者。 |
| Request | 请求对象，封装请求的上下文数据。 |
2. 类图
+----------------+ +-------------------+
| Handler | <|-------| ConcreteHandlerA |
+----------------+ +-------------------+
| +nextHandler | | +handleRequest() |
| +handleRequest()| +-------------------+
+----------------+ ^
| |
| |
+-------------------+
| ConcreteHandlerB |
+-------------------+
| +handleRequest() |
+-------------------+
3. 执行流程
- 客户端将请求发送到责任链的第一个处理者。
- 每个处理者决定是否处理该请求：
- 若处理，则终止传递。
- 若不处理，则调用
nextHandler.handleRequest()。
- 请求沿链传递，直到被处理或链结束。
二、责任链模式源码实例
1. 抽象处理者（Handler）
public abstract class Handler {
protected Handler nextHandler; // 指向下一个处理者
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
public abstract void handleRequest(Request request);
}
2. 具体处理者（ConcreteHandler）
public class ConcreteHandlerA extends Handler {
@Override
public void handleRequest(Request request) {
if (canHandle(request)) {
System.out.println("ConcreteHandlerA 处理请求: " + request.getData());
} else if (nextHandler != null) {
nextHandler.handleRequest(request); // 传递给下一个处理者
}
}
private boolean canHandle(Request request) {
return request.getType().equals("A");
}
}
public class ConcreteHandlerB extends Handler {
@Override
public void handleRequest(Request request) {
if (canHandle(request)) {
System.out.println("ConcreteHandlerB 处理请求: " + request.getData());
} else if (nextHandler != null) {
nextHandler.handleRequest(request); // 传递给下一个处理者
}
}
private boolean canHandle(Request request) {
return request.getType().equals("B");
}
}
3. 请求对象（Request）
public class Request {
private String type; // 请求类型
private String data; // 请求数据
public Request(String type, String data) {
this.type = type;
this.data = data;
}
public String getType() { return type; }
public String getData() { return data; }
}
4. 客户端调用
public class Client {
public static void main(String[] args) {
// 创建责任链
Handler handlerA = new ConcreteHandlerA();
Handler handlerB = new ConcreteHandlerB();
handlerA.setNextHandler(handlerB);
// 发送请求
Request request1 = new Request("A", "请求1");
Request request2 = new Request("B", "请求2");
handlerA.handleRequest(request1); // 由 ConcreteHandlerA 处理
handlerA.handleRequest(request2); // 由 ConcreteHandlerB 处理
}
}
输出结果：
ConcreteHandlerA 处理请求: 请求1
ConcreteHandlerB 处理请求: 请求2
三、Spring AOP 拦截器链中的责任链模式
Spring AOP 通过 拦截器链（Interceptor Chain） 实现方法增强（如事务、日志），其核心设计正是基于责任链模式。
1. 核心组件
| 组件 | 职责 |
|---|---|
| MethodInvocation | 封装被代理方法的调用上下文（类似 Request）。 |
| MethodInterceptor | 拦截器接口（类似 Handler），定义增强逻辑。 |
| ReflectiveMethodInvocation | 具体责任链实现，管理拦截器链的调用顺序。 |
2. 源码解析
（1）拦截器链的创建
在生成代理对象时，Spring 会将所有匹配的拦截器（如 MethodInterceptor）按顺序组合成链。
入口：AdvisedSupport#getInterceptorsAndDynamicInterceptionAdvice
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
// 获取所有拦截器（包括事务、日志等）
List<Object> interceptorList = new ArrayList<>();
for (Advisor advisor : this.advisors) {
if (advisor instanceof PointcutAdvisor) {
// 匹配拦截器是否适用于当前方法
if (((PointcutAdvisor) advisor).getPointcut().getMethodMatcher().matches(method, targetClass)) {
interceptorList.add(advisor.getAdvice());
}
}
}
return interceptorList;
}
（2）责任链的触发
代理对象调用方法时，触发 ReflectiveMethodInvocation#proceed()，按顺序执行拦截器链。该方法类似于递归执行，递归方法也是有终止条件的，请注意区分。
源码：ReflectiveMethodInvocation
public class ReflectiveMethodInvocation implements ProxyMethodInvocation {
private final Object target; // 目标对象
private final Method method; // 目标方法
private final Object[] arguments; // 方法参数
private final List<Object> interceptorsAndDynamicMethodMatchers; // 拦截器链
private int currentInterceptorIndex = -1; // 当前拦截器索引
public Object proceed() throws Throwable {
// 1. 所有拦截器执行完毕，调用原始方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
// 2. 获取下一个拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
// 3. 执行拦截器逻辑
if (interceptorOrInterceptionAdvice instanceof MethodInterceptor) {
MethodInterceptor mi = (MethodInterceptor) interceptorOrInterceptionAdvice;
return mi.invoke(this); // 将当前 MethodInvocation 传递给拦截器
} else {
// 动态匹配器处理（略）
}
}
// 调用原始方法
protected Object invokeJoinpoint() throws Throwable {
return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
}
}
（3）拦截器的执行逻辑
每个 MethodInterceptor 拦截器决定是否继续传递链（调用 proceed()）或终止。
示例：Spring 事务拦截器 TransactionInterceptor
public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor {
public Object invoke(MethodInvocation invocation) throws Throwable {
// 1. 开启事务
TransactionInfo txInfo = createTransactionIfNecessary(invocation.getMethod(), targetClass);
try {
// 2. 继续执行拦截器链（责任链传递）
Object retVal = invocation.proceed();
// 3. 提交事务
commitTransactionAfterReturning(txInfo);
return retVal;
} catch (Throwable ex) {
// 4. 回滚事务
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
}
}
四、责任链模式在 Spring AOP 中的设计优势
-
灵活扩展
新增拦截器只需实现MethodInterceptor并注册到链中，无需修改现有代码。 -
逻辑解耦
每个拦截器专注单一职责（如事务、日志），通过链式调用组合功能。 -
动态控制流程
拦截器可决定是否继续调用链（如权限校验失败时直接抛出异常终止流程）。 -
执行顺序可控
拦截器链的顺序可通过@Order注解或实现Ordered接口调整。
五、实际应用场景与自定义拦截器
1. 自定义拦截器示例
public class LoggingInterceptor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("方法调用前: " + invocation.getMethod().getName());
Object result = invocation.proceed(); // 继续链
System.out.println("方法调用后: " + invocation.getMethod().getName());
return result;
}
}
2. 配置拦截器链
在 Spring 配置中注册拦截器：
<bean id="loggingInterceptor" class="com.example.LoggingInterceptor"/>
<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor"/>
<aop:config>
<aop:advisor advice-ref="loggingInterceptor" order="1"/>
<aop:advisor advice-ref="transactionInterceptor" order="2"/>
</aop:config>
3. 执行顺序
拦截器按 order 值从小到大依次执行：
LoggingInterceptor（前置日志） → TransactionInterceptor（事务管理） → 目标方法
六、总结
- 责任链模式核心：解耦请求发送者与处理者，允许多个对象按链式处理请求。
- Spring AOP 实现：通过
ReflectiveMethodInvocation管理拦截器链，每个MethodInterceptor按责任链模式依次执行。 - 优势：灵活扩展、职责分离、动态流程控制。
- 应用场景：事务管理、日志记录、权限校验、性能监控等切面功能。
