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

🕗 发布于 2024-09-20 07:14 spring java Spring AOP AOP代理面向切面编程

文章目录

1. 从整体视角学习Bean是如何被AOP代理的
2. AOP代理的触发机制
3. AOP代理逻辑的执行

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能够在目标方法执行前后插入各种横切关注点，如事务管理、日志记录等。

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

静态方法匹配器：在编译时或配置时确定方法是否匹配，例如方法名、参数类型等。这种匹配是静态的，无法根据实际调用时的参数值进行判断。
动态方法匹配器：在方法调用时动态评估方法匹配条件，例如根据实际传递的参数值判断是否匹配。这种匹配是动态的，可以提供更灵活的控制。

普通的AOP通常使用静态匹配，这里不用深究动态匹配器。

3.3 时序图

在这里插入图片描述

时序图详细说明：

Caller调用代理方法：

Caller调用代理对象的方法，开始AOP的执行过程。
代理对象是通过AOP创建的，包含了拦截器链。

创建ReflectiveMethodInvocation实例：

在代理对象内部，Spring AOP创建一个ReflectiveMethodInvocation实例。该实例封装了目标方法、拦截器链以及方法参数。
ReflectiveMethodInvocation负责处理方法调用的整个过程。

调用proceed()：

代理对象调用ReflectiveMethodInvocation的proceed()方法，开始执行拦截器链。

遍历拦截器链：

ReflectiveMethodInvocation遍历拦截器链中的每个拦截器。
对每个拦截器，ReflectiveMethodInvocation调用其invoke(this)方法。
拦截器在调用目标方法之前和之后执行自定义逻辑。

调用invokeJoinpoint()：

如果拦截器链中没有拦截器或所有拦截器已经执行完毕，ReflectiveMethodInvocation直接调用invokeJoinpoint()方法。
invokeJoinpoint()通过反射调用目标方法。

调用目标方法：

ReflectiveMethodInvocation通过反射调用实际的目标方法。
目标方法执行并返回结果。

返回结果：

目标方法执行完成后，结果返回给ReflectiveMethodInvocation。
ReflectiveMethodInvocation将结果返回给所有拦截器，依次向上返回。

代理对象返回最终结果：

ReflectiveMethodInvocation最终将结果返回给代理对象。
代理对象将结果返回给Caller。

欢迎一键三连~

有问题请留言，大家一起探讨学习

----------------------Talk is cheap, show me the code-----------------------

原文地址：https://blog.csdn.net/qq_34115899/article/details/139395388

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：介绍一些免费的 html 5模版网站和配色网站
下一篇：Redis 哨兵模式的选举算法是什么？

【python笔记02】面向对象思想
面向对象的核心思想是：不仅仅是简单的将功能进行封装（封装成函数），更是对调用该功能的主体进行封装，实现某个主体拥有多个功能，在使用的过程中，先得到对应的主体，再使用主体去实现相关的功能！计算机语言的语
阅读更多2024-11-18
《Django 5 By Example》阅读笔记：p211-p236
adv. without any interruption(连续地).
阅读更多2024-11-18
【Android】IPC机制—Serializable、Parcelable、Binder用法
Serializable是Java所提供的一个序列化接口，它是一个空接口，为对象提供标准的序列化和反序列化操作。serialVersionUID也并不是必须的，不声明serialVersionUID也
阅读更多2024-11-18
大麦抢票科技
大麦演唱会
阅读更多2024-11-18
力扣（leetcode）面试经典150题——27. 移除元素
给你一个数组nums和一个值val，你需要移除所有数值等于val的元素。元素的顺序可能发生改变。然后返回nums中与val不同的元素的数量。假设nums中不等于val的元素数量为knumsnumskv
阅读更多2024-11-18
Mongo-BI（bi-connector）配置
补充 mongosql 加到开启自启动。官网提供的配置说明-太复杂。其他人的配置-简单清晰。
阅读更多2024-11-18
【C#】C#编程基础：探索控制台应用与数据操作
本文旨在为C#语言的初学者提供一个全面的入门指南，涵盖了控制台项目的基本使用、数据类型的转换、字符串与数组的操作、引用类型与值类型的区别、常量与枚举的使用等多个方面。通过详细的代码示例和解释，读者可以
阅读更多2024-11-18
1116蓝桥杯算法双周赛小白入门赛4.5.6题题解
除了自己以外,给每个人带一块钱 ========> 自己少一块钱 ========>nums[pos]--本人是很普通的大学生,算法水平并不高,不能保证解答一定
阅读更多2024-11-18
Scala-注释、标识符、变量与常量-用法详解
Scala初步
阅读更多2024-11-18
信捷 XDH PLC C语言 Ethercat 简易绝对运动 BMC_A_DRVA_BODY函数
/全局变量给定时器的线圈通电。（1）DRVA_PAR_array是类型为BMC_A_DRVA，长度为3的数组。（3）T_MoveOK_array是类型为BMC_A_Stop，长度为3的数组。（2）st
阅读更多2024-11-18

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 时序图

相关文章