Spring高手之路23——AOP触发机制与代理逻辑的执行

文章目录

1. 从整体视角学习Bean是如何被AOP代理的
2. AOP代理的触发机制
- 2.1 postProcessAfterInitialization方法源码分析
- 2.2 wrapIfNecessary方法源码分析
- 2.3 时序图演示触发机制
3. AOP代理逻辑的执行
- 3.1 AOP代理如何使用拦截器
- 3.2 proceed方法源码分析
- 3.3 时序图

1. 从整体视角学习Bean是如何被AOP代理的

为了全面理解Bean是如何被AOP代理的，我们把前面几篇文章串联一下，需要关注以下几点，并针对每个关键点学习相应的源码部分：

1. AOP代理的触发机制（本章需要讲解的）
理解Spring如何决定哪些Bean需要被代理。

关键点：

BeanPostProcessor接口：Spring AOP的自动代理创建器实现了这个接口，通过它在Bean初始化的前后进行处理。

源码部分：
AbstractAutoProxyCreator（位于org.springframework.aop.framework.autoproxy包中）

方法：postProcessAfterInitialization
方法：wrapIfNecessary

2. 确定哪些Bean需要代理（前面已讲）
理解Spring如何确定哪些Bean需要被代理，这通常涉及到扫描和匹配切面。

这部分内容在Spring高手之路21——深入剖析Spring AOP代理对象的创建的第2节“匹配增强器Advisors（源码分析+时序图说明）”已经讲解，可自行前往翻阅学习。

关键点：

Advisor和Advice：这些是Spring AOP中的切面和通知。

源码部分：

AbstractAdvisorAutoProxyCreator的方法：getAdvicesAndAdvisorsForBean（位于org.springframework.aop.framework.autoproxy包中）

3. 创建代理对象（前面已讲）
理解Spring如何创建代理对象，包括使用JDK动态代理和CGLIB代理。

这部分内容在Spring高手之路22——AOP切面类的封装与解析的第3.2节“TargetSource 的构建”有提到，可自行前往翻阅学习。

关键点：

代理工厂（ProxyFactory）：用于创建代理对象。
动态代理实现（JDK动态代理和CGLIB）。

源码部分：

ProxyFactory的方法：getProxy（位于org.springframework.aop.framework包中）
JdkDynamicAopProxy的方法：invoke（位于org.springframework.aop.framework包中）
CglibAopProxy的方法：getProxy（位于org.springframework.aop.framework包中）

4. 代理对象的配置（前面已讲）
理解如何配置代理对象的属性，如切入点和通知。

这部分内容在Spring高手之路22——AOP切面类的封装与解析的第3.2节“TargetSource 的构建”有提到，可自行前往翻阅学习。

关键点：

AdvisedSupport类：包含了代理配置的相关信息。

源码部分：

AdvisedSupport（位于org.springframework.aop.framework包中）

5. 执行代理逻辑（本章需要讲解的）
理解代理对象在运行时如何拦截方法调用并执行通知逻辑。

关键点：

拦截器链：代理对象通过拦截器链来执行切面逻辑。

源码部分：

ReflectiveMethodInvocation的方法：proceed（位于org.springframework.aop.framework包中）

推荐学习路径

从高层理解代理触发机制

查看AbstractAutoProxyCreator类，特别是wrapIfNecessary和postProcessAfterInitialization方法，理解代理触发的整体流程。

深入理解切面和通知的获取

查看AbstractAdvisorAutoProxyCreator类，特别是getAdvicesAndAdvisorsForBean方法，理解如何获取适用于目标Bean的切面和通知。

代理对象的创建细节

查看ProxyFactory类，特别是getProxy方法，理解代理对象的具体创建过程。

理解动态代理的实现

查看JdkDynamicAopProxy和CglibAopProxy类，理解JDK动态代理和CGLIB代理的具体实现细节。

配置代理对象

查看AdvisedSupport类，理解代理对象的配置和管理。

执行代理逻辑

查看ReflectiveMethodInvocation类，特别是proceed方法，理解代理对象在运行时如何拦截方法调用并执行切面逻辑。

2. AOP代理的触发机制

还记得BeanPostProcessor接口吗？这在“Spring高手之路13——BeanFactoryPostProcessor与BeanDefinitionRegistryPostProcessor解析”有讲到。

BeanPostProcessor接口提供了两个方法：

postProcessBeforeInitialization：在Bean初始化之前调用。
postProcessAfterInitialization：在Bean初始化之后调用。

Spring AOP利用postProcessAfterInitialization方法在Bean初始化完成后，检查并决定是否需要对这个Bean进行代理。

2.1 postProcessAfterInitialization方法源码分析

本节源码基于 spring-aop-5.3.16。

在这里插入图片描述

代码提出来分析

/**
 * 如果该bean被子类标识为需要代理的bean，则使用配置的拦截器创建一个代理。
 * @see #getAdvicesAndAdvisorsForBean
 */
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    // 如果bean不为空
    if (bean != null) {
        // 获取缓存键，通常是bean的类和名称的组合，用于在缓存中存取与该bean相关的元数据
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // 从earlyProxyReferences集合中移除缓存键，如果当前bean不在该集合中，表示需要代理该bean
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 如果需要的话，对bean进行包装（代理）
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    // 如果bean为null或不需要代理，直接返回原始bean
    return bean;
}

这个方法主要功能：

确定代理需求：该方法的主要目的是确定是否需要为Bean创建代理。如果需要，wrapIfNecessary方法将负责实际的代理创建过程。
优化性能：通过缓存键和earlyProxyReferences集合，可以避免重复处理同一个Bean，提高性能。
集成AOP功能：为需要代理的Bean创建代理对象，使得AOP切面能够在Bean的方法调用前后执行。

2.2 wrapIfNecessary方法源码分析

代码提出来分析

/**
 * 如果需要，对给定的bean进行包装（代理），即如果它符合被代理的条件。
 * @param bean 原始的bean实例
 * @param beanName bean的名称
 * @param cacheKey 用于元数据访问的缓存键
 * @return 包装（代理）后的bean，或原始的bean实例
 */
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // 如果beanName不为空且targetSourcedBeans集合包含这个beanName，直接返回原始bean
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    // 如果advisedBeans缓存中显示这个bean不需要代理，直接返回原始bean
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    // 如果bean的类是基础设施类（如Spring内部使用的类）或应该跳过代理
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        // 将这个bean标记为不需要代理
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // 获取适用于这个bean的通知和切面
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    // 如果有通知和切面，则创建代理
    if (specificInterceptors != DO_NOT_PROXY) {
        // 将这个bean标记为需要代理
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 创建代理对象
        Object proxy = createProxy(
                bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        // 缓存代理对象的类型
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }

    // 如果没有适用于这个bean的通知和切面，将这个bean标记为不需要代理
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

wrapIfNecessary方法的主要功能是检查给定的Bean是否需要进行AOP代理，并在必要时为其创建代理对象。该方法在Bean初始化后被调用，以确保符合条件的Bean能够被AOP代理，从而使AOP切面能够在Bean的方法调用前后执行。

2.3 时序图演示触发机制

在这里插入图片描述

详细分析和说明：

Caller请求Bean实例：

Caller调用BeanFactory来获取Bean实例。
这一步表示应用程序或其他Bean调用者需要获取一个Bean实例。

BeanFactory创建Bean实例：

BeanFactory创建Bean实例，准备进行初始化。
这包括通过Spring的依赖注入机制构造Bean实例。

调用postProcessAfterInitialization：

BeanFactory调用AOPProxy的postProcessAfterInitialization方法。
这是Spring AOP框架用于在Bean初始化后进行处理的关键步骤。

获取缓存键：

AOPProxy获取缓存键(cacheKey)，通常是Bean的类和名称的组合。
缓存键用于在缓存中存取与Bean相关的元数据。

检查earlyProxyReferences集合：

AOPProxy检查earlyProxyReferences集合，判断当前Bean是否已经处理过。
这是为了避免重复处理同一个Bean，提高性能。

判断Bean是否需要代理：

通过检查earlyProxyReferences集合，决定是否需要继续代理。
如果Bean需要代理，进入wrapIfNecessary方法。

调用wrapIfNecessary：

wrapIfNecessary方法负责实际的代理创建过程。
包括进一步的检查和代理对象的创建。

检查targetSourcedBeans集合：

判断Bean是否在targetSourcedBeans集合中，如果是，直接返回原始Bean。
targetSourcedBeans集合用于存储一些特殊的Bean，不需要代理。

targetSourcedBeans 集合主要用于管理那些使用动态目标源的 Bean。在创建代理时，如果一个 Bean在这个集合中，Spring 会进行特殊处理，通常直接返回原始 Bean，而不是创建新的代理对象。这种机制确保了特殊 Bean的正确处理和高效运行。

检查advisedBeans集合：

检查缓存中是否已经标记了该Bean不需要代理，如果是，直接返回原始Bean。
提高处理效率，避免重复检查。

检查基础设施类和跳过条件：

判断Bean是否为Spring的基础设施类或是否有其他跳过条件。
基础设施类通常不需要代理，因为它们是框架内部使用的。

获取通知和切面：

调用getAdvicesAndAdvisorsForBean方法，获取适用于该Bean的通知（Advice）和切面（Advisor）。
Advisor对象包含了切面逻辑，Advice对象包含了实际的通知逻辑。

检查是否有specificInterceptors：

判断是否有适用于该Bean的通知和切面。
如果有，继续创建代理对象。

创建代理对象：

调用createProxy方法，通过ProxyFactory创建代理对象。
代理对象将拦截方法调用，并应用切面逻辑。

返回代理对象：

代理对象创建完成后，返回给AOPProxy。
AOPProxy将代理对象返回给BeanFactory。

返回原始Bean或代理对象：

如果Bean不需要代理，返回原始Bean。
如果需要代理，返回代理对象。

BeanFactory返回结果：

BeanFactory将最终的Bean实例（可能是原始Bean或代理对象）返回给Caller。

3. AOP代理逻辑的执行

3.1 AOP代理如何使用拦截器

当AOP代理拦截方法调用时，它会依次调用配置的拦截器链。每个拦截器都通过invoke方法处理方法调用。整个流程如下：

方法调用被代理拦截：当一个方法被调用时，AOP代理会首先拦截这个调用。
拦截器链处理：调用会被传递给拦截器链中的第一个拦截器。
执行拦截器链：每个拦截器的invoke方法都会执行其逻辑，并决定是否调用下一个拦截器。
目标方法执行：如果所有拦截器都允许，最终会调用目标方法本身。
返回结果或处理异常：目标方法执行完成后，结果或异常会逐个传递回拦截器链，直到返回给最初调用方法的客户端。

比如给个简单拦截器的例子：

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 在目标方法执行前
        System.out.println("Before method: " + invocation.getMethod().getName());

        // 调用目标方法
        Object result = invocation.proceed();

        // 在目标方法执行后
        System.out.println("After method: " + invocation.getMethod().getName());

        return result;
    }
}

在这个示例中，invoke方法是拦截器的核心。

当方法被调用时，invoke方法会先打印“方法调用前”，然后调用invocation.proceed()执行目标方法，最后在方法执行后或发生异常时打印相应的信息。
invocation.proceed()方法用于继续调用拦截器链中的下一个拦截器，直到最终调用目标方法。

3.2 proceed方法源码分析

在这里插入图片描述

代码提出来分析：

/**
 * 逐个调用拦截器链中的拦截器，并在最后执行目标方法（连接点）。
 * @return 调用链中最后一个拦截器或目标方法的返回值
 * @throws Throwable 如果拦截器或目标方法抛出异常
 */
@Override
@Nullable
public Object proceed() throws Throwable {
    // 我们从索引 -1 开始，并提前递增索引。
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        // 如果当前拦截器索引等于拦截器链的最后一个索引，则调用目标方法
        return invokeJoinpoint();
    }

    // 获取当前索引的拦截器或拦截建议
    Object interceptorOrInterceptionAdvice =
            this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    // 检查是否是 InterceptorAndDynamicMethodMatcher 类型
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        // 如果是，评估动态方法匹配器
        InterceptorAndDynamicMethodMatcher dm =
                (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        // 获取目标类的 Class 对象
        Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
        // 检查方法是否匹配
        if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
            // 如果匹配成功，调用拦截器的 invoke 方法
            return dm.interceptor.invoke(this);
        } else {
            // 动态匹配失败，跳过这个拦截器并调用链中的下一个
            return proceed();
        }
    } else {
        // 如果是普通拦截器，直接调用其 invoke 方法
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

/**
 * 使用反射调用连接点。
 * 子类可以重写此方法以使用自定义调用。
 * 
 * @return 连接点的返回值
 * @throws Throwable 如果调用连接点导致异常
 */
@Nullable
protected Object invokeJoinpoint() throws Throwable {
    // 使用反射调用目标对象的目标方法，并传递参数
    return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
}

proceed方法和invokeJoinpoint方法共同实现了AOP拦截器链的执行逻辑。proceed方法依次执行拦截器链中的每个拦截器，并在链的末尾调用目标方法。invokeJoinpoint方法通过反射调用目标方法并返回其结果。这两个方法结合起来，使得AOP能够在目标方法执行前后插入各种横切关注点，如事务管理、日志记录等。

这里判断动态方法匹配器是干嘛的？