死磕Spring之AOP篇 - Spring AOP自动代理（一）入口

  • Z时代
  • 2024-01-10
  • 分类：综合

本文内容纲要：

- 如何激活 AOP 模块？
- 类图
- AbstractAutoProxyCreator
- 总结

该系列文章是本人在学习 Spring 的过程中总结下来的，里面涉及到相关源码，可能对读者不太友好，请结合我的源码注释 Spring 源码分析 GitHub 地址 进行阅读。

Spring 版本：5.1.14.RELEASE

在开始阅读 Spring AOP 源码之前，需要对 Spring IoC 有一定的了解，可查看我的 《死磕Spring之IoC篇 - 文章导读》 这一系列文章

了解 AOP 相关术语，可先查看 《Spring AOP 常见面试题） 》 这篇文章

该系列其他文章请查看：《死磕 Spring 之 AOP 篇 - 文章导读》

通过上一篇文章《Spring AOP 总览》我们对 Spring AOP 有了一个整体的认识，那么从本篇文章开始，我们一起来看看 Spring AOP 和 Spring IoC 是如何整合的，自动代理的过程做了哪些事情？

首先我们得清楚 Bean 的加载过程，整个过程中会调用相应的 BeanPostProcessor 对正在创建 Bean 进行处理，例如：

  1. 在 Bean 的实例化前，会调用 InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation(..) 方法进行处理

  2. 在 Bean 出现循环依赖的情况下，会调用 SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference(..) 方法对提前暴露的 Bean 进行处理

  3. 在 Bean 初始化后，会调用 BeanPostProcessor#postProcessAfterInitialization(..) 方法对初始化好的 Bean 进行处理

Spring AOP 则是通过上面三个切入点进行创建代理对象，实现自动代理。

  • 在 Spring AOP 中主要是通过第 3 种 BeanPostProcessor 创建代理对象，在 Bean 初始化后，也就是一个“成熟态”，然后再尝试是否创建一个代理对象；

  • 第 2 种方式是为了解决 Bean 循环依赖的问题，虽然 Bean 仅实例化还未初始化，但是出现了循环依赖，不得不在此时创建一个代理对象；

  • 第 1 种方式是在 Bean 还没有实例化的时候就提前创建一个代理对象（创建了则不会继续后续的 Bean 的创建过程），例如 RPC 远程调用的实现，因为本地类没有远程能力，可以通过这种方式进行拦截。

对于 Bean 的加载过程不清楚的小伙伴可以查看我的《死磕Spring之IoC篇 - 文章导读》这篇文章，或者直接查看《死磕Spring之IoC篇 - Bean 的创建过程》 这篇文章

Spring AOP 自动代理的实现主要由 AbstractAutoProxyCreator 完成，它实现了 BeanPostProcessor、SmartInstantiationAwareBeanPostProcessor 和 InstantiationAwareBeanPostProcessor 三个接口，那么这个类就是 Spring AOP 的入口，在这里将 Advice 织入我们的 Bean 中，创建代理对象。

如何激活 AOP 模块？

如何开启 Spring 的 AOP 模块，首先我们需要引入 spring-aop 和 aspectjweaver 两个模块，然后通过下面的方式开启 AOP：

  • 添加 @EnableAspectJAutoProxy 注解

  • 添加 <aop:aspectj-autoproxy /> XML 配置

备注：在 Spring Boot 中使用 AOP 可以不需要上面两种配置，因为在 Spring Boot 中当你引入上面两个模块后，默认开启，可以看到下面这个配置类：

package org.springframework.boot.autoconfigure.aop;
@Configuration
@ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class, AnnotatedElement.class })
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
	@Configuration
	@EnableAspectJAutoProxy(proxyTargetClass = false)
	@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = false)
	public static class JdkDynamicAutoProxyConfiguration {}
	@Configuration
	@EnableAspectJAutoProxy(proxyTargetClass = true)
	@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = true)
	public static class CglibAutoProxyConfiguration {}
}

只要存在 EnableAspectJAutoProxy、Aspect、Advice、AnnotatedElement 四个 Class 对象，且 spring.aop.auto 配置为 true（没有配置则为 true），那么就会加载 AopAutoConfiguration 当前这个 Bean，而内部又使用了 @EnableAspectJAutoProxy 注解，那么表示开启 AOP。

至于这个注解或者 XML 配置的方式为什么就开启 AOP，是因为会引入 AbstractAutoProxyCreator 这个对象，具体怎么引入的，在后续文章进行分析????

类图

简单描述：

  • 【重点】org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator：AOP 自动代理的抽象类，完成主要的逻辑实现，提供一些骨架方法交由子类完成

  • org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator：仅支持指定 List<String> beanNames 完成自动代理，需要指定 interceptorNames 拦截器

  • 【重点】org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator：支持从当前 Spring 上下文获取所有 Advisor 对象，存在能应用与 Bean 的 Advisor 则创建代理对象

  • org.springframework.aop.framework.autoproxy.InfrastructureAdvisorAutoProxyCreator：仅支持获取 Spring 内部的 Advisor 对象（BeanDefinition 的角色为 ROLE_INFRASTRUCTURE）

  • org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator：支持配置前缀，只能获取名称已该前缀开头的 Advisor 对象

  • 【重点】org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator：支持按照 AspectJ 的方式对 Advisor 进行排序

  • 【重点】org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator：支持从带有 @AspectJ 注解 Bean 中解析 Advisor 对象

我们主要关注上面**【重点】的几个对象，因为 Sping AOP 推荐使用 AspectJ 里面的注解进行 AOP 的配置，你牢牢记住AbstractAutoProxyCreator这个自动代理**类。

AbstractAutoProxyCreator

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator：AOP 自动代理的抽象类，完成主要的逻辑实现，提供一些骨架方法交由子类完成

相关属性

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
	/** 空对象，表示不需要进行代理 */
	@Nullable
	protected static final Object[] DO_NOT_PROXY = null;
	/**
	 * 空的数组，表示需要进行代理，但是没有解析出 Advice
	 * 查看 {@link BeanNameAutoProxyCreator#getAdvicesAndAdvisorsForBean} 就知道其用途
	 */
	protected static final Object[] PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS = new Object[0];
	/** DefaultAdvisorAdapterRegistry 单例，Advisor适配器注册中心 */
	private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();
	/** 是否冻结代理对象 */
	private boolean freezeProxy = false;
	/** 公共的拦截器对象 */
	private String[] interceptorNames = new String[0];
	/** 是否将 `interceptorNames` 拦截器放在最前面 */
	private boolean applyCommonInterceptorsFirst = true;
    /** 自定义的 TargetSource 创建器 */
	@Nullable
	private TargetSourceCreator[] customTargetSourceCreators;
	@Nullable
	private BeanFactory beanFactory;
	/**
	 * 保存自定义 {@link TargetSource} 对象的 Bean 的名称
	 */
	private final Set<String> targetSourcedBeans = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
	/**
	 * 保存提前创建代理对象的 Bean
	 * key：cacheKey（Bean 的名称或者 Class 对象）
	 * value：Bean 对象
	 *
	 * Spring AOP 的设计之初是让 Bean 在完全创建好后才完成 AOP 代理，如果出现了循环依赖，则需要提前（实例化后还未初始化）创建代理对象
	 * 那么需要先保存提前创建代理对象的 Bean，这样在后面可以防止再次创建代理对象
	 */
	private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);
	/**
	 * 保存代理对象的 Class 对象
	 * key：cacheKey（Bean 的名称或者 Class 对象）
	 * value：代理对象的 Class 对象（目标类的子类）
	 *
	 */
	private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<>(16);
	/**
	 * 保存是否需要创建代理对象的信息
	 * key：cacheKey（Bean 的名称或者 Class 对象）
	 * value：是否需要创建代理对象，false 表示不需要创建代理对象，true 表示已创建代理对象
	 */
	private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);
}

上面的每个属性都已经注释，先简单理解即可，具体在后面的方法可查看其用途

getEarlyBeanReference 方法

getEarlyBeanReference(Object bean, String beanName)，用于处理早期暴露的对象，如果有必要的话会创建一个代理对象，该方法定义在 SmartInstantiationAwareBeanPostProcessor 中，实现如下：

/**
 * 该方法对早期对象（提前暴露的对象，已实例化还未初始化）进行处理
 * 参考 {@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#getEarlyBeanReference }
 *
 * @param bean     the raw bean instance
 * @param beanName the name of the bean
 * @return 早期对象（可能是一个代理对象）
 */
@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
    // <1> 获取这个 Bean 的缓存 Key，默认为 Bean 的名称，没有则取其对应的 Class 对象
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    /*
     * <2> 将当前 Bean 保存至 earlyProxyReferences 集合（早期的代理应用对象）
     * 也就是说当这个 Bean 出现循环依赖了，在实例化后就创建了代理对象（如果有必要）
     */
    this.earlyProxyReferences.put(cacheKey, bean);
    // <3> 为这个 Bean 创建代理对象（如果有必要的话）
    return wrapIfNecessary(bean, beanName, cacheKey);
}

该方法的处理过程如下：

  1. 获取这个 Bean 的缓存 Key，默认为 Bean 的名称，没有则取其对应的 Class 对象

  2. 将当前 Bean 保存至 earlyProxyReferences 集合（早期的代理应用对象），也就是说当这个 Bean 出现循环依赖了，在实例化后就创建了代理对象（如果有必要），可以防止后续初始化后再次创建代理对象

  3. **【重点】**调用 wrapIfNecessary(..) 方法，为这个 Bean 创建代理对象（如果有必要的话），该方法在后面分析????‍????

对于 getEarlyBeanReference(..) 方法在哪被调用，可能你已经忘记了，这里来回顾一下：

// 在 AbstractAutowireCapableBeanFactory#doCreateBean 创建 Bean 的过程中，实例化后会执行下面步骤
/**
 * <3.2>
 * 创建一个 ObjectFactory 实现类，用于返回当前正在被创建的 `bean`，提前暴露，保存在 `singletonFactories` （**三级 Map**）缓存中
 *
 * 可以回到前面的 {@link AbstractBeanFactory#doGetBean#getSingleton(String)} 方法
 * 加载 Bean 的过程会先从缓存中获取单例 Bean，可以避免单例模式 Bean 循环依赖注入的问题
 */
addSingletonFactory(beanName,
        // ObjectFactory 实现类
        () -> getEarlyBeanReference(beanName, mbd, bean));
// 获取早期暴露的对象时候的处理，会调用 SmartInstantiationAwareBeanPostProcessor#getEarlyBeanReference(..) 方法
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() // RootBeanDefinition 不是用户定义的（由 Spring 解析出来的）
            && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

上面这个过程是为了处理循环依赖的问题，在 Bean 实例化后就提前暴露这个对象，如果真的出现了循环依赖，如果这个 Bean 需要进行代理，那么就不得不提前为它创建一个代理对象，虽然这个 Bean 还未初始化，不是一个“成熟态”。

关于 Spring 如何处理循环依赖的过程，如果你不熟悉可查看我的另一篇文章《死磕Spring之IoC篇 - 单例 Bean 的循环依赖处理》

postProcessBeforeInstantiation 方法

postProcessBeforeInstantiation(Class<?> beanClass, String beanName)，Bean 的创建过程中实例化前置处理，也就是允许你在创建 Bean 之前进行处理。如果该方法返回的不为 null，后续 Bean 加载过程不会继续，也就是说这个方法可用于获取一个 Bean 对象。通常这里用于创建 AOP 代理对象，或者 RPC 远程调用的实现（因为本地类没有远程能力，可以通过这种方式进行拦截）。

该方法定义在 InstantiationAwareBeanPostProcessor 中，实现如下：

/**
 * 在加载 Bean 的过程中，Bean 实例化的前置处理
 * 如果返回的不是 null 则不会进行后续的加载过程，也就是说这个方法用于获取一个 Bean 对象
 * 通常这里用于创建 AOP 代理对象，返回的对象不为 null，则会继续调用下面的 {@link this#postProcessAfterInitialization} 方法进行初始化后置处理
 * 参考 {@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation}
 *
 * @param beanClass the class of the bean to be instantiated
 * @param beanName  the name of the bean
 * @return 代理对象或者空对象
 */
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    // <1> 获取这个 Bean 的缓存 Key，默认为 Bean 的名称，没有则取其对应的 Class 对象
    Object cacheKey = getCacheKey(beanClass, beanName);
    // <2> 如果没有 beanName 或者没有自定义生成 TargetSource
    if (!StringUtils.hasLength(beanName) // 没有 beanName
            || !this.targetSourcedBeans.contains(beanName)) // 没有自定义生成 TargetSource
    {
        /*
         * <2.1> 已创建代理对象（或不需要创建），则直接返回 null，进行后续的 Bean 加载过程
         */
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        /*
         * <2.2>不需要创建代理对象，则直接返回 null，进行后续的 Bean 加载过程
         */
        if (isInfrastructureClass(beanClass) // 如果是 Spring 内部的 Bean（Advice、Pointcut、Advisor 或者 AopInfrastructureBean 标记接口）
                || shouldSkip(beanClass, beanName)) // 应该跳过
        {
            // 将这个 Bean 不需要创建代理对象的结果保存起来
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }
    /*
     * <3> 通过自定义 TargetSourceCreator 创建自定义 TargetSource 对象
     * 默认没有 TargetSourceCreator，所以这里通常都是返回 null
     */
    TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
    /*
     * <4> 如果 TargetSource 不为空，表示需要创建代理对象
     */
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            // <4.1> 将当前 beanName 保存至集合，表示这个 Bean 已自定义生成 TargetSource 对象
            this.targetSourcedBeans.add(beanName);
        }
        // <4.2> 获取能够应用到当前 Bean 的所有 Advisor（已根据 @Order 排序）
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        // <4.3> 创建代理对象，JDK 动态代理或者 CGLIB 动态代理
        Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
        // <4.4> 将代理对象的 Class 对象（目标类的子类）保存
        this.proxyTypes.put(cacheKey, proxy.getClass());
        // <4.5> 返回代理对象
        return proxy;
    }
    // <5> 否则，直接返回 null，进行后续的 Bean 加载过程
    return null;
}

该方法的处理过程如下：

  1. 获取这个 Bean 的缓存 Key，默认为 Bean 的名称，没有则取其对应的 Class 对象

  2. 如果没有 beanName 或者没有自定义生成 TargetSource

    1. 已创建代理对象（或不需要创建），则直接返回 null，进行后续的 Bean 加载过程

    2. 满足下面其中一个条件表示不需要创建代理对象，则直接返回 null，并将这个 Bean 不需要创建代理对象的结果保存至 advisedBeans 中

      • 如果是 Spring 内部的 Bean（Advice、Pointcut、Advisor 或者 AopInfrastructureBean 标记接口）

      • 应该跳过

  3. 通过自定义 TargetSourceCreator 创建自定义 TargetSource 对象，默认没有 TargetSourceCreator，所以这里通常都是返回 null

    @Nullable
    protected TargetSource getCustomTargetSource(Class<?> beanClass, String beanName) {
        if (this.customTargetSourceCreators != null &&
                this.beanFactory != null && this.beanFactory.containsBean(beanName)) {
            for (TargetSourceCreator tsc : this.customTargetSourceCreators) {
                // 通过 TargetSourceCreator 获取 `beanName` 的自定义 TargetSource
                TargetSource ts = tsc.getTargetSource(beanClass, beanName);
                if (ts != null) {
                    return ts;
                }
            }
        }
        return null;
    }

  4. 如果 TargetSource 不为空，表示需要创建代理对象

    1. 将当前 beanName 保存至 targetSourcedBeans 集合，表示这个 Bean 已自定义生成 TargetSource 对象

    2. 调用 getAdvicesAndAdvisorsForBean(..) 方法，获取能够应用到当前 Bean 的所有 Advisor（已根据 @Order 排序），在后面进行分析????‍????

    3. 调用 createProxy(..) 方法，创建代理对象，JDK 动态代理或者 CGLIB 动态代理，在后面进行分析????‍????

    4. 将代理对象的 Class 对象（目标类的子类）保存至 proxyTypes

    5. 返回代理对象

  5. 否则，直接返回 null，进行后续的 Bean 加载过程

这里先解释一下 TargetSource，这个对象表示目标类的来源，用于获取代理对象的目标对象，上面如果存在 TargetSourceCreator，表示可以创建自定义的 TargetSource，也就需要进行 AOP 代理。默认情况下是没有 TargetSourceCreator 的，具体使用场景目前还没有接触过。

上面的 4.2 和 4.3 两个方法非常复杂，放在后面进行分析????

同样对于 postProcessBeforeInstantiation(..) 方法在哪被调用，可能你已经忘记了，这里来回顾一下：

// 在 AbstractAutowireCapableBeanFactory#createBean 创建 Bean 的过程中，开始前会执行下面步骤
/**
 * <3> 在实例化前进行相关处理，会先调用所有 {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation}
 * 注意，如果这里返回对象不是 `null` 的话，不会继续往下执行原本初始化操作，直接返回，也就是说这个方法返回的是最终实例对象
 * 可以通过这种方式提前返回一个代理对象，例如 AOP 的实现，或者 RPC 远程调用的实现（因为本地类没有远程能力，可以通过这种方式进行拦截）
 */
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
    return bean;
}
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        // Make sure bean class is actually resolved at this point.
        // 如果 RootBeanDefinition 不是用户定义的（由 Spring 解析出来的），并且存在 InstantiationAwareBeanPostProcessor 处理器
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                 // 实例化前置处理
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    // 后置处理
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

上面过程是提供一种扩展点，可以让你在 Bean 创建之前进行相关处理，例如进行 AOP 代理，或者 RPC 远程调用的实现（因为本地类没有远程能力，可以通过这种方式进行拦截）。

关于 Spring Bean 的创建过程，如果你不熟悉可查看我的另一篇文章《死磕Spring之IoC篇 - Bean 的创建过程》

postProcessAfterInitialization 方法

postProcessAfterInitialization(@Nullable Object bean, String beanName)，Bean 的初始化后置处理，在 Bean 初始化后，已经进入一个“成熟态”，那么此时就可以创建 AOP 代理对象了，如果有必要的话。

该方法定义在 BeanPostProcessor 中，实现如下：

/**
 * 在加载 Bean 的过程中，Bean 初始化的后置处理
 * 参考 {@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(String, Object, RootBeanDefinition)}
 */
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    // <1> 如果 bean 不为空则进行接下来的处理
    if (bean != null) {
        // <1.1> 获取这个 Bean 的缓存 Key，默认为 Bean 的名称，没有则取其对应的 Class 对象
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        /*
         * <1.2> 移除 `earlyProxyReferences` 集合中保存的当前 Bean 对象（如果有的话）
         * 如果 earlyProxyReferences 集合中没有当前 Bean 对象，表示在前面没有创建代理对象
         */
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 这里尝试为这个 Bean 创建一个代理对象（如果有必要的话）
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    // <2> 直接返回 bean 对象
    return bean;
}

该方法的处理过程如下：

  1. 如果 bean 不为空则进行接下来的处理

    1. 获取这个 Bean 的缓存 Key，默认为 Bean 的名称，没有则取其对应的 Class 对象

    2. 移除 earlyProxyReferences 集合中保存的当前 Bean 对象（如果有的话），如果 earlyProxyReferences 集合中没有当前 Bean 对象，表示在前面没有创建代理对象

      **【重点】**那么调用 wrapIfNecessary(..) 方法，尝试为这个 Bean 创建一个代理对象（如果有必要的话），该方法在后面分析????‍????

  2. 直接返回 bean 对象

对于 postProcessAfterInitialization(..) 方法在哪被调用，可能你已经忘记了，这里来回顾一下：

// 在 AbstractAutowireCapableBeanFactory#doCreateBean#initializeBean 创建 Bean 的过程中，属性填充后会进行初始化，初始化后会执行下面的操作
/**
 * <4> **初始化**阶段的**后置处理**，执行所有 BeanPostProcessor 的 postProcessAfterInitialization 方法
 *
 * 在 {@link AbstractApplicationContext#prepareBeanFactory} 方法中会添加 {@link ApplicationListenerDetector} 处理器
 * 如果是单例 Bean 且为 ApplicationListener 类型，则添加到 Spring 应用上下文，和 Spring 事件相关
 */
if (mbd == null || !mbd.isSynthetic()) {
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {
    Object result = existingBean;
    // 遍历所有 BeanPostProcessor
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        // 初始化的后置处理，返回 `current` 处理结果
        Object current = processor.postProcessAfterInitialization(result, beanName);
        // 处理结果为空，则直接返回 `result`
        if (current == null) {
            return result;
        }
        // 否则，`result` 复制 `current`
        result = current;
    }
    return result;
}

上面这个过程在 Bean 初始化后，提供一个扩展点允许对这个 Bean 进行后置处理，此时 Bean 进入一个 “成熟态”，在这里则可以进行 AOP 代理对象的创建

关于 Spring Bean 的初始化过程，如果你不熟悉可查看我的另一篇文章《死磕Spring之IoC篇 - Bean 的创建过程》

wrapIfNecessary 方法

wrapIfNecessary(Object bean, String beanName, Object cacheKey)，该方法用于创建 AOP 代理对象，如果有必要的话

上面的 getEarlyBeanReference(..) 和 postProcessAfterInitialization(..) 方法都会调用这个方法，如下：

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    /*
     * <1> 如果当前 Bean 已经创建过自定义 TargetSource 对象
     * 表示在上面的**实例化前置处理**中已经创建代理对象，那么直接返回这个对象
     */
    if (StringUtils.hasLength(beanName)
            && this.targetSourcedBeans.contains(beanName))
    {
        return bean;
    }
    // <2> `advisedBeans` 保存了这个 Bean 没有必要创建代理对象，则直接返回
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    /*
     * <3> 不需要创建代理对象，则直接返回当前 Bean
     */
    if (isInfrastructureClass(bean.getClass()) // 如果是 Spring 内部的 Bean（Advice、Pointcut、Advisor 或者 AopInfrastructureBean 标记接口）
            || shouldSkip(bean.getClass(), beanName)) // 应该跳过
    {
        // 将这个 Bean 不需要创建代理对象的结果保存起来
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
    // Create proxy if we have advice.
    // <4> 获取能够应用到当前 Bean 的所有 Advisor（已根据 @Order 排序）
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    // <5> 如果有 Advisor，则进行下面的动态代理创建过程
    if (specificInterceptors != DO_NOT_PROXY) {
        // <5.1> 将这个 Bean 已创建代理对象的结果保存至 `advisedBeans`
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // <5.2> 创建代理对象，JDK 动态代理或者 CGLIB 动态代理
        // 这里传入的是 SingletonTargetSource 对象，可获取代理对象的目标对象（当前 Bean）
        Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        // <5.3> 将代理对象的 Class 对象（目标类的子类）保存
        this.proxyTypes.put(cacheKey, proxy.getClass());
        // <5.4> 返回代理对象
        return proxy;
    }
    // <6> 否则，将这个 Bean 不需要创建代理对象的结果保存起来
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    // <7> 返回这个 Bean 对象
    return bean;
}

该方法处理过程如下：

  1. 如果当前 Bean 已经创建过自定义 TargetSource 对象，表示在上面的实例化前置处理中已经创建代理对象，那么直接返回这个对象

  2. 如果 advisedBeans 保存了这个 Bean 没有必要创建代理对象，则直接返回这个对象

  3. 如果满足下面其中一个条件，表示不需要创建代理对象，则直接返回当前 Bean，并将这个 Bean 不需要创建代理对象的结果保存至 advisedBeans 中

    • 如果是 Spring 内部的 Bean（Advice、Pointcut、Advisor 或者 AopInfrastructureBean 标记接

    • 应该跳过

  4. 调用 getAdvicesAndAdvisorsForBean(..) 方法，获取能够应用到当前 Bean 的所有 Advisor（已根据 @Order 排序），在后面进行分析????‍????

  5. 如果有 Advisor，则进行下面的动态代理创建过程

    1. 将这个 Bean 已创建代理对象的结果保存至 advisedBeans

    2. 调用 createProxy(..) 方法，创建代理对象，JDK 动态代理或者 CGLIB 动态代理，在后面进行分析????‍????

      注意，这里传入的是 SingletonTargetSource 对象，可获取代理对象的目标对象（当前 Bean）

    3. 将代理对象的 Class 对象（目标类的子类）保存至 proxyTypes

    4. 返回代理对象

  6. 否则，将这个 Bean 不需要创建代理对象的结果保存至 advisedBeans

  7. 返回这个 Bean 对象

到这里，getEarlyBeanReference(..)、postProcessBeforeInstantiation(..) 和 postProcessAfterInitialization(..) 三个方法的 AOP 自动代理过程主要分为两步：

  1. 调用 getAdvicesAndAdvisorsForBean(..) 方法，获取能够应用到当前 Bean 的所有 Advisor（已根据 @Order 排序）

  2. 调用 createProxy(..) 方法，根据找到的 Advisor 创建一个代理对象，JDK 动态代理或者 CGLIB 动态代理

上面的流程看起来并不复杂，看着好像就调用两个方法，不过不要被表象所迷惑，这只是冰山一角。

总结

Spring AOP 自动代理是通过实现 Spring IoC 中的几种 BeanPostProcessor 处理器，在 Bean 的加载过程中进行扩展，如果有必要的话（找到了能够应用于这个 Bean 的 Advisor）则创建 AOP 代理对象， JDK 动态代理或者 CGLIB 动态代理。

AbstractAutoProxyCreator 则是自动代理的入口，实现了三种 BeanPostProcessor 处理器，SmartInstantiationAwareBeanPostProcessor、InstantiationAwareBeanPostProcessor 和 BeanPostProcessor，实现的三个方法：

  1. getEarlyBeanReference(..)：用于处理早期暴露的对象，如果有必要的话会创建一个代理对象

  2. postProcessBeforeInstantiation(..)：Bean 的创建过程中实例化前置处理，允许你在创建 Bean 之前进行处理。如果该方法返回的不为 null，后续 Bean 加载过程不会继续，也就是说这个方法可用于获取一个 Bean 对象。通常这里用于创建 AOP 代理对象，或者 RPC 远程调用的实现（因为本地类没有远程能力，可以通过这种方式进行拦截）。

  3. postProcessAfterInitialization(..)：Bean 的初始化后置处理，在 Bean 初始化后，已经进入一个“成熟态”，那么此时就可以创建 AOP 代理对象了，如果有必要的话。

详细过程参考上面的方法，我们主要是通过第 3 种方法创建代理对象，这三种方法的处理过程主要分为以下两步：

  1. 调用 getAdvicesAndAdvisorsForBean(..) 方法，筛选出合适的 Advisor 对象们

  2. 调用 createProxy(..) 方法，根据找到的 Advisor 创建一个代理对象，JDK 动态代理或者 CGLIB 动态代理

由于这两个步骤都比较复杂，考虑到文章的可读性，所以另起两篇文章分别分析

本文内容总结：如何激活 AOP 模块？，类图，AbstractAutoProxyCreator，总结，

原文链接：https://www.cnblogs.com/lifullmoon/p/14677287.html

以上是 死磕Spring之AOP篇 - Spring AOP自动代理（一）入口 的全部内容， 来源链接： utcz.com/z/362546.html

回到顶部