责任链模式原理详解和源码实例以及Spring AOP拦截器链的执行源码如何使用责任链模式？

发布于：2025-02-22 ⋅ 阅读:(13) ⋅ 点赞:(0)

前言

  本文首先介绍了责任链的基本原理，并附带一个例子说明责任链模式，确保能够理解责任链的前提下，在进行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. 执行流程
  1. 客户端将请求发送到责任链的第一个处理者。
  2. 每个处理者决定是否处理该请求：
    • 若处理，则终止传递。
    • 若不处理，则调用 nextHandler.handleRequest()。
  3. 请求沿链传递，直到被处理或链结束。
二、责任链模式源码实例
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 中的设计优势

  1. 灵活扩展
    新增拦截器只需实现 MethodInterceptor 并注册到链中，无需修改现有代码。

  2. 逻辑解耦
    每个拦截器专注单一职责（如事务、日志），通过链式调用组合功能。

  3. 动态控制流程
    拦截器可决定是否继续调用链（如权限校验失败时直接抛出异常终止流程）。

  4. 执行顺序可控
    拦截器链的顺序可通过 @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 按责任链模式依次执行。
  • 优势：灵活扩展、职责分离、动态流程控制。
  • 应用场景：事务管理、日志记录、权限校验、性能监控等切面功能。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布