Spring源码分析系列（三）--从@EnableAspectJAutoProxy分析Spring AOP加载过程

朱雀 2021-12-09 23:37 348阅读 0赞

AOP是面向切面编程，是相当于OOP面向对象编程而言的。Spring的AOP存在的目的是为了解耦。AOP可以让一组类共享相同的行为。而OOP中只能通过继承类和实现接口来实现，但是这样的缺点是会使代码的耦合度增加，且类继承只能为单继承，阻碍更多行为添加到一组类上，AOP的出现弥补了OOP的不足。  
  使用@EnableAspectJAutoProxy注解开启Spring对AspectJ的支持。  
  添加@EnableAspectJAutoProxy注解，表示开启AOP代理自动配置，如果使用@EnableAspectJAutoProxy注解，表示使用cglib进行代理对象的生成。设置@EnableAspectJAutoProxy(exposeProxy=true)表示通过AOP框架暴露该代理对象，aopContext能够访问。  
  下面看一下@EnableAspectJAutoProxy这个类的源码

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(AspectJAutoProxyRegistrar.class)
    public @interface EnableAspectJAutoProxy { 
    
        /** * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed * to standard Java interface-based proxies. The default is {@code false}. */
        // true--使用CGLIB基于类创建代理，false--使用java接口创建代理
        boolean proxyTargetClass() default false;
    
        /** * Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal} * for retrieval via the {@link org.springframework.aop.framework.AopContext} class. * Off by default, i.e. no guarantees that {@code AopContext} access will work. * @since 4.3.1 */
        // 是否通过aop矿建暴露该代理对象，aopContext能够访问
        boolean exposeProxy() default false;
    
    }

通过上面的代码可以看出@EnableAspectJProxy把AspectJAutoProxyRegistrar.class对象导入到了容器中。利用AspectJAutoProxyRegistrar给容器中注册了一个AnnotationAwareAspectAutoProxyCreator。

# AspectJAutoProxyRegistrar #

AspectAutoProxyRegistrar类中的registerBeanDefinitions方法主要实现了两个功能：

*  1.注册AnnontationAwareAspectJAutoProxyCreator
 *  2.获取@EnableAspectJAutoProxy注解的属性信息

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar { 
        /** * Register, escalate, and configure the AspectJ auto proxy creator based on the value * of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing * {@code @Configuration} class. */
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { 
            //注册AnnotationAwareAspectJAutoProxyCreator
            AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
            //获取@EnableAspectJAutoProxy注解的属性信息
            AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata,EnableAspectJAutoProxy.class);
            if (enableAspectJAutoProxy != null) { 
                if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) { 
                    AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                }
                if (enableAspectJAutoProxy.getBoolean("exposeProxy")) { 
                    AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
                }
            }
        }
    }

# 总结 #

大致流程如下：  
  1、传入配置类，创建IOC容器  
  2、注册配置类，调用refresh()刷新容器  
  3、registerBeanPostProcessors(beanFactory)：注册bean的后置处理器来方便拦截创建bean的创建  
    1）先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor  
    2）给容器中加别的BeanPostProcessor  
    3）优先注册实现了PriorityOrdered接口的BeanPostProcessor  
    4）再给容器中注册实现了Ordered接口的BeanPostProcessor  
    5）注册没实现优先级接口的BeanPostProcessor  
    6）注册BeanPostProcessor。实际上就是创建BeanPostProcessor对象，保存在容器中  
      创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】  
      1）创建Bean实例  
      2）populateBean(beanName,mbd,instanceWrapper);给bean的各种属性赋值  
      3）initializeBean：初始化bean  
        1）invokeAwareMethods():处理Aware接口的方法回调  
        2）applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization()  
        3）invokeInitMethods()：执行自定义的初始化方法  
        4）applyBeanPostProcessorsAfterInitialization()：执行后置处理器的postProcessAfterInitialization()  
      4）BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功：–》aspectJAdvisorsBuilder  
    7）把BeanPostProcessor注册到BeanFactory中：beanFactory.addBeanPostProcessor(postProcessor);  
  4、finishBeanFactoryInitialIization(beanFactory);完成BeanFactory初始化工作；创建剩下的单实例bean  
    1）遍历获取容器中所有的Bean，依次创建对象getBean(beanName);  
      getBean->doGetBean()->getSingleton()  
    2）创建bean  
      1）先从缓存中获取当前bean，如果能获取到，说明是被创建过的，直接使用，否则再创建  
        只要创建好的Bean都会被缓存起来  
      2）createBean();创建bean  
        【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】  
        【InstantiationAwareBeanPostProcessor是在创建Bean实例之前先尝试用后置处理器返回对象的】  
        1）resolveBeforeInstantiation(beanName, mbdToUse); 解析BeforeInstantiation  
          希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续  
          1）后置处理器先尝试返回对象  
             bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);  
            拿到所有后置处理器，如果是InstantiationAwareBeanPostProcessor就执行postProcessorsBeforeInstantiation

if (bean != null) { 
    				bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
    			}

2）doCreateBean(beanName, mbdToUse, args); 真正去创建一个bean实例；和3.6流程一样