Spring--原理--AOP

心已赠人 2022-10-31 00:49 12阅读 0赞

原文网址：[Spring--原理--AOP\_IT利刃出鞘的博客-CSDN博客][Spring--_--AOP_IT_-CSDN]

# 其他网址 #

[Spring AOP源码详细解析\_my java博客园-CSDN博客][Spring AOP_my java_-CSDN]  
[Spring5AOP——AbstractAutoProxyCreator横切逻辑织入目标Bean中 | 码农家园][Spring5AOP_AbstractAutoProxyCreator_Bean_ _]  
[面试官：Spring AOP是怎么实现的？\_小识的博客-CSDN博客][Spring AOP_-CSDN]  
[最简 Spring AOP 源码分析 - 云+社区 - 腾讯云][Spring AOP _ - _ -]  
[spring AOP @EnableAspectJAutoProxy原理\_sjtu\_chenchen的专栏-CSDN博客][spring AOP _EnableAspectJAutoProxy_sjtu_chenchen_-CSDN]  
[从@EnableAspectJAutoProxy分析Spring AOP原理\_zhoushimiao1990的博客-CSDN博客][EnableAspectJAutoProxy_Spring AOP_zhoushimiao1990_-CSDN]  
[AOP系列（三）SpringBoot中 AOP实现原理][AOP_SpringBoot_ AOP]

# 简介 #

**版本**

> 本文的版本：springboot：2.3.0.RELEASE；Spring：5.2.6.RELEASE。

**说明**

> Spring AOP本质是用的代理模式，其基于[BeanPostProcessor][]实现，从而能够与IOC结合起来。

**AOP的核心类的分类**

> advisorCreator，继承 spring ioc的扩展接口 BeanPostProcessor，主要用来扫描获取 advisor。  
> advisor：通知者，封装了spring aop中的切点和通知。 就是我们常用的@Aspect 注解标记的类。  
> advice： 通知，也就是aop中增强的方法。

**AnnotationAwareAspectJAutoProxyCreator**

> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70][]
> 
> 实现了Order接口，所以先于普通的BeanPostProcessor注册，并对普通BeanPostProcessor也能起作用。
> 
> 实现了InstantiationAwareBeanPostProcessor接口，所以会在Bean被创建之前被调用。
> 
> Spring Aop主要是通过AbstractAutoProxyCreator实现的BeanPostProcessor、InstantiationAwareBeanPostProcessor以及SmartInstantiationAwareBeanPostProcessor接口里面的后置处理器方法，来介入到Spring IOC容器的Bean的实例化以及初始化的过程中对Bean进行AOP的处理的。所以AbstractAutoProxyCreator类实现的容器级别的后置处理器方法是介入分析的点。

**总览**

> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1][]
> 
> AbstractAutoProxyCreator：Spring 为Spring AOP 模块暴露的可扩展抽象类，也是 AOP 中**最核心**的抽象类。
> 
> BeanNameAutoProxyCreator：根据指定名称创建代理对象（阿里连接池框架druid也基于此类做了扩展）。通过设置 advisor，可以对指定的 beanName 进行代理。支持模糊匹配。
> 
> AbstractAdvisorAutoProxyCreator：功能比较强大，默认扫描所有Advisor的实现类。相对于根据Bean名称匹配，该类更加灵活。动态的匹配每一个类，判断是否可以被代理，并寻找合适的增强类，以及生成代理类。
> 
> DefaultAdvisorAutoProxyCreator：AbstractAdvisorAutoProxyCreator的默认实现类。可以单独使用，在框架中使用AOP，尽量不要手动创建此对象。
> 
> AspectJAwareAdvisorAutoProxyCreator：Aspectj的实现方式，也是Spring Aop中最常用的实现方式，如果用注解方式，则用其子类AnnotationAwareAspectJAutoProxyCreator。
> 
> AnnotationAwareAspectJAutoProxyCreator：目前最常用的AOP使用方式。spring aop 开启注解方式之后，该类会扫描所有@Aspect()注释的类，生成对应的advisor。目前SpringBoot框架中默认支持的方式，自动配置。本文我们就分析此类。

# 简要流程 #

**开启AOP功能**

> AopAutoConfiguration实现Aop的自动装配，配置好依赖就能直接使用。此时有@EnableAspectJAutoProxy,开启AspectJ的代理功能。  
> AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar，实现registerBeanDefinitions方法  
> registerBeanDefinitions方法：向容器中注册bean：org.springframework.aop.config.internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator

**创建代理类对象**

> AnnotationAwareAspectJAutoProxyCreator实现生命周期监听，后置处理AspectJ切入的类，查找缓存所有的Advisors，创建代理类对象。
> 
> 1.  解析和加载横切逻辑：AbstractAutoProxyCreator\#postProcessBeforeInstantiation方法，在Bean实例化之前被调用。
> 2.  创建代理类：AopProxy创建代理类，代理类里面会插入Advisor注解的方法中的代码,并返回代理对象
> 3.  将横切逻辑织入目标Bean：AbstractAutoProxyCreator\#postProcessAfterInitialization方法，在Bean实例化之后被调用。
> 
> DefaultAopProxyFactory提供代理策略，接口走JDK代理，类走Cglib代理。SpringBoot默认走Cglib代理。

**执行目标方法**

> 代理对象中的proxyFactory包含增强器和目标对象。  
> 目标方法执行=> CglibAopProxy.intercept()=> 遍历所有的增强器，将其转为Interceptor，利用MethodInterceptor机制生成拦截器链，  
> 如果有拦截器链，把需要执行的目标对象，目标方法，拦截器链等信息传入创建一个 CglibMethodInvocation 对象，  
> 调用mi.proceed()，链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；  
> 拦截器链的机制，保证通知方法与目标方法的执行顺序

# 1.启用AOP #

**简介**

> spring-boot-starter-aop如何做到自动配置的？见：[SpringBoot原理--自动配置\_feiying0canglang的博客-CSDN博客][SpringBoot_--_feiying0canglang_-CSDN]
> 
> 要使用AOP，首先要引入包。如果引入的是spring-aop包，则需要使用@EnableAspectJAutoProxy开启aop功能；如果引入的是spring-boot-starter-aop，则AOP就直接可以用了，无需加注解之类的开启它。
> 
> 实际上，spring-boot-starter-aop是自动用了@EnableAspectJAutoProxy，所以我们还是从@EnableAspectJAutoProxy开始。

## @EnableAspectJAutoProxy ##

EnableAspectJAutoProxy注解类上用了： @Import(\{AspectJAutoProxyRegistrar.class\})

@Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import({AspectJAutoProxyRegistrar.class})
    public @interface EnableAspectJAutoProxy {
        boolean proxyTargetClass() default false;
    
        boolean exposeProxy() default false;
    }

*  proxyTargetClass 指定是否使用CGLIB的方式创建实现接口的目标对象的代理。缺省值为true，使用CGLIB方式创建对象的代理。
 *  exposeProxy 标记代理对象是否应该被aop框架通过AopContext以ThreadLocal的形式暴露出去。当一个代理对象需要调用它自己的另外一个代理方法时，这个属性将非常有用。默认是是false，以避免不必要的拦截。

## AspectJAutoProxyRegistrar ##

**总结**

> AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar，实现registerBeanDefinitions方法
> 
> 向容器中注册bean：org.springframework.aop.config.internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator

### 注册AnnotationAwareAspectJAutoProxyCreator ###

**追踪：AspectJAutoProxyRegistrar\#registerBeanDefinitions //**从名字就可以看出来，它是注册BeanDefinition用的。

> registerBeanDefinitions //AspectJAutoProxyRegistrar  
> AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry); //AspectJAutoProxyRegistrar.java  
> registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, (Object)null); //AopConfigUtils.class  
> registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source); //AopConfigUtils.class

> AopConfigUtils\#registerOrEscalateApcAsRequired
> 
>     private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
>         Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
>         if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
>             BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
>             if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
>                 int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
>                 int requiredPriority = findPriorityForClass(cls);
>                 if (currentPriority < requiredPriority) {
>                     apcDefinition.setBeanClassName(cls.getName());
>                 }
>             }
>     
>             return null;
>         } else {
>             RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
>             beanDefinition.setSource(source);
>             beanDefinition.getPropertyValues().add("order", -2147483648);
>             beanDefinition.setRole(2);
>             registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
>             return beanDefinition;
>         }
>     }
> 
> 开始的时候AutoProxyCreator类不存在,RootBeanDefinition初始化AnnotationAwareAspectJAutoProxyCreator类，注册类到IOC容器。

### 创建AnnotationAwareAspectJAutoProxyCreator ###

**相关网址**

> [refresh()][refresh]、[BeanPostProcessor][]

**总结**

> AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessor接口与Ordered接口（值为32位int的最大值），它在registerBeanPostProcessors()中处理，最终被实例化、设置属性、初始化。

**分析**

> 在上边“重要的类”可以得出：AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessor接口与Ordered接口（值为32位int的最大值），那它会在registerBeanPostProcessors()中处理：
> 
> AbstractApplicationContext\#refresh()  
> registerBeanPostProcessors(beanFactory) //AbstractApplicationContext  
> PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);  
> BeanPostProcessor pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);  
> getBean(String name, Class<T> requiredType) //AbstractBeanFactory  
> doGetBean(name, requiredType, null, false) //AbstractBeanFactory  
> createBean(beanName, mbd, args); //AbstractAutowireCapableBeanFactory  
> doCreateBean(beanName, mbdToUse, args); //AbstractAutowireCapableBeanFactory
> 
> AbstractAutowireCapableBeanFactory\#doCreateBean(beanName, mbdToUse, args); 主要做了如下几件事：
> 
> 创建bean ：createBeanInstance(beanName, mbd, args)  
> 给bean中的属性赋值：populateBean(beanName, mbd, instanceWrapper)  
> 初始化bean：initializeBean(beanName, exposedObject, mbd)
> 
>     protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
>             throws BeanCreationException {
>     
>         // Instantiate the bean.
>         // 实例化bean
>         BeanWrapper instanceWrapper = null;
>         if (mbd.isSingleton()) {
>             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
>         }
>         if (instanceWrapper == null) {
>             instanceWrapper = createBeanInstance(beanName, mbd, args);
>         }
>         final Object bean = instanceWrapper.getWrappedInstance();
>         Class<?> beanType = instanceWrapper.getWrappedClass();
>         if (beanType != NullBean.class) {
>             mbd.resolvedTargetType = beanType;
>         }
>     
>         // Allow post-processors to modify the merged bean definition.
>         // 允许post-processors来修改合并的bean定义
>         synchronized (mbd.postProcessingLock) {
>             if (!mbd.postProcessed) {
>                 try {
>                     applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
>                 } catch (Throwable ex) {
>                     throw new BeanCreationException(mbd.getResourceDescription(), beanName,
>                             "Post-processing of merged bean definition failed", ex);
>                 }
>                 mbd.postProcessed = true;
>             }
>         }
>     
>         // Eagerly cache singletons to be able to resolve circular references
>         // even when triggered by lifecycle interfaces like BeanFactoryAware.
>         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
>                 isSingletonCurrentlyInCreation(beanName));
>         if (earlySingletonExposure) {
>             if (logger.isTraceEnabled()) {
>                 logger.trace("Eagerly caching bean '" + beanName +
>                         "' to allow for resolving potential circular references");
>             }
>             addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
>         }
>     
>         // Initialize the bean instance.
>         // 初始化bean
>         Object exposedObject = bean;
>         try {
>             populateBean(beanName, mbd, instanceWrapper);
>             exposedObject = initializeBean(beanName, exposedObject, mbd);
>         }
>         catch (Throwable ex) {
>             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
>                 throw (BeanCreationException) ex;
>             } else {
>                 throw new BeanCreationException(
>                         mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
>             }
>         }
>     
>         if (earlySingletonExposure) {
>             Object earlySingletonReference = getSingleton(beanName, false);
>             if (earlySingletonReference != null) {
>                 if (exposedObject == bean) {
>                     exposedObject = earlySingletonReference;
>                 } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
>                     String[] dependentBeans = getDependentBeans(beanName);
>                     Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
>                     for (String dependentBean : dependentBeans) {
>                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
>                             actualDependentBeans.add(dependentBean);
>                         }
>                     }
>                     if (!actualDependentBeans.isEmpty()) {
>                         throw new BeanCurrentlyInCreationException(beanName,
>                                 "Bean with name '" + beanName + "' has been injected into other beans [" +
>                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
>                                 "] in its raw version as part of a circular reference, but has eventually been " +
>                                 "wrapped. This means that said other beans do not use the final version of the " +
>                                 "bean. This is often the result of over-eager type matching - consider using " +
>                                 "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
>                     }
>                 }
>             }
>         }
>     
>         // Register bean as disposable.
>         try {
>             registerDisposableBeanIfNecessary(beanName, bean, mbd);
>         } catch (BeanDefinitionValidationException ex) {
>             throw new BeanCreationException(
>                     mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
>         }
>     
>         return exposedObject;
>     }

# 2.生成代理对象 #

# 3.执行目标方法 #

[Spring--_--AOP_IT_-CSDN]: https://knife.blog.csdn.net/article/details/113886504
[Spring AOP_my java_-CSDN]: https://blog.csdn.net/xc123_java/article/details/90448446
[Spring5AOP_AbstractAutoProxyCreator_Bean_ _]: https://www.codenong.com/jsb21cd2b66c4f/
[Spring AOP_-CSDN]: https://blog.csdn.net/zzti_erlie/article/details/106976850
[Spring AOP _ - _ -]: https://cloud.tencent.com/developer/article/1512235
[spring AOP _EnableAspectJAutoProxy_sjtu_chenchen_-CSDN]: https://blog.csdn.net/sjtu_chenchen/article/details/80641518
[EnableAspectJAutoProxy_Spring AOP_zhoushimiao1990_-CSDN]: https://blog.csdn.net/zhoushimiao1990/article/details/89853368
[AOP_SpringBoot_ AOP]: https://juejin.cn/post/6844903977553920007
[BeanPostProcessor]: https://blog.csdn.net/feiying0canglang/article/details/114438458
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70]: /images/20221024/63381f2395134cdc8618446cd02edb83.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1]: /images/20221024/9b1c1ab8573b4aa6be8db19a0e7c6c2c.png
[SpringBoot_--_feiying0canglang_-CSDN]: https://blog.csdn.net/feiying0canglang/article/details/113533013
[refresh]: https://blog.csdn.net/feiying0canglang/article/details/110534892