Spring笔记(3) - debug源码AOP原理解析

1. 案例

   @EnableAspectJAutoProxy//开启基于注解的aop模式
   @Configuration
   public class AOPConfig {
       //业务逻辑类加入容器中
       @Bean
       public MathCalculator mathCalculator() {
           return new MathCalculator();
       }
       //切面类加入容器中
       @Bean
       public LogAspects logAspects() {
           return new LogAspects();
       }
   }
   /**
    * AOP[动态代理]：指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；
    * @Aspect 告诉Spring当前类是切面类
    */
   @Aspect
   public class LogAspects {
       /**
        * 抽取公共的切入点表达式
        * 1.本类引用：pointcut()
        * 2.引用其他切面类：全名【com.hrh.config.LogAspects.pointcut()】
        */
       @Pointcut("execution(public int com.hrh.config.MathCalculator.*(..))")
       public void pointcut() {
   
       }
       //在目标方法(div)运行之前运行
       @Before("com.hrh.config.LogAspects.pointcut()")
       public void LogStart(JoinPoint joinPoint) {
           //获取传入目标方法的参数对象
           Object[] args = joinPoint.getArgs();
           //Signature getSignature();获取封装了署名信息的对象,在该对象中可以获取到目标方法名,所属类的Class等信息
           System.out.println("方法名：【" + joinPoint.getSignature().getName() + "】运行@Before，参数是:" + Arrays.asList(args));
       }
       //在目标方法(div)运行之后运行
       @After("pointcut()")
       public void LogEnd(JoinPoint joinPoint) {
           System.out.println("方法名：【" + joinPoint.getSignature().getName() + "】运行@After");
       }
   
       /**
        * 获得目标方法(div)运行的结果
        * @param joinPoint 必须是参数列表第一位,封装了SpringAop中切面方法的信息
        * @param result    返回值
        */
       @AfterReturning(value = "pointcut()", returning = "result")
       public void LogReturn(JoinPoint joinPoint, Object result) {
           System.out.println("方法名：【" + joinPoint.getSignature().getName() + "】的返回值:" + result);
       }
       //获得目标方法(div)运行的异常信息
       @AfterThrowing(value = "pointcut()", throwing = "e")
       public void LogException(JoinPoint joinPoint, Exception e) {
           System.out.println("方法名：【" + joinPoint.getSignature().getName() + "】的异常信息：" + e);
       }
   }
   public class MathCalculator {
       public int div(int i,int j){
           return i/j;
       }
   }
       AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AOPConfig.class);
       MathCalculator bean = context.getBean(MathCalculator.class);
       bean.div(1, 1);

2. 在探究下面的原理前，请带着下面的流程总结进行学习：

   1. @EnableAspectJAutoProxy开启AOP功能(SpringBoot会默认开启，所以不需要该注解)；

   2. @EnableAspectJAutoProxy会给容器注册一个AnnotationAwareAspectJAutoProxyCreator，它是一个后置处理器，会在组件的创建之前进行拦截；

   3. 容器的创建流程：

      1. registerBeanPostProcessors注册后置处理器，创建AnnotationAwareAspectJAutoProxyCreator；

      2. finishBeanFactoryInitialization初始化剩下的单实例bean；

         1. 创建业务逻辑组件和切面组件；

         2. AnnotationAwareAspectJAutoProxyCreator会拦截组件的创建过程；

         3. 组件创建完成之后，wrapIfNecessary判断组件是否需要增强；

            • 如果是，将通知方法包装成增强器，给目标对象即业务逻辑创建一个代理对象，代理对象有各种增强器；

   4. 执行目标方法，调用CglibAopProxy.intercept进行拦截；

      1. 得到目标方法的拦截器链，利用拦截器的链式机制进行递归，调用proceed()依次进入每一个拦截器进行执行各种通知方法和目标方法；

      2. 效果：

         1. 正常执行：前置通知 -> 目标方法 -> 后置通知 -> 返回通知

         2. 出现异常：前置通知 -> 目标方法 -> 后置通知 -> 异常通知

3. 原理

   1. @EnableAspectJAutoProxy注解探究，需要启用该注解AOP才会生效

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

      1. AspectJAutoProxyRegistrar：AspectJ自动代理注册器，实现了registerBeanDefinitions()自定义给容器注册bean

         class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
            @Override
            public void registerBeanDefinitions(
                  AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
                 //给容器添加AUTO_PROXY_CREATOR_BEAN_NAME=AnnotationAwareAspectJAutoProxyCreator
               AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
               ....
            }
         }
         public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
             return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
         }
         public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
             BeanDefinitionRegistry registry, @Nullable Object source) {
         //注册AnnotationAwareAspectJAutoProxyCreator
         return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
         }

      2. registerOrEscalateApcAsRequired

         private static BeanDefinition registerOrEscalateApcAsRequired(
                 Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {
         
             Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
             //registry注册中第一次是不包含AUTO_PROXY_CREATOR_BEAN_NAME=internalAutoProxyCteator，走下面注册代码
             if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
                 BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
                 if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
                     int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                     int requiredPriority = findPriorityForClass(cls);
                     if (currentPriority < requiredPriority) {
                         apcDefinition.setBeanClassName(cls.getName());
                     }
                 }
                 return null;
             }
             //创建获得AnnotationAwareAspectJAutoProxyCreator的定义信息（该对象还没创建），然后注册到容器DefaultListableBeanFactory中，名字叫AUTO_PROXY_CREATOR_BEAN_NAME
             RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
             beanDefinition.setSource(source);
             beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
             beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
             registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
             return beanDefinition;
         }

      3. 从上面代码可以看出下面的流程：

         1. @EnableAspectJAutoProxy注解导入AspectJAutoProxyRegistrar类

         2. AspectJAutoProxyRegistrar类最后给容器添加AnnotationAwareAspectJAutoProxyCreator

      4. 下面是AnnotationAwareAspectJAutoProxyCreator：AspectJ自动代理创建器的类关系情况，从中可以看到该类实现了BeanPostProcessor(后置处理器)和BeanFacotryAware(给该类添加BeanFactory组件）对应的方法postProcessBeforeInstantiation()、postProcessAfterInitialization()、setBeanFactory()，所以研究后置处理器在bean创建前后所做的事情和自动装配BeanFactory就可以了。

         AnnotationAwareAspectJAutoProxyCreator
             -> extends AspectJAwareAdvisorAutoProxyCreator
                 -> extends AbstractAdvisorAutoProxyCreator
                     -> extends AbstractAutoProxyCreator
                         -> implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
                            -> SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor
                              -> InstantiationAwareBeanPostProcessor extends BeanPostProcessor

   2. 开启Debug模式探究AnnotationAwareAspectJAutoProxyCreator的创建和注册实现流程

      1. 分别在AOPConfig的@Bean注解处、AnnotationAwareAspectJAutoProxyCreator的initBeanFactory()、AbstractAdvisorAutoProxyCreator的setBeanFactory()、AbstractAutoProxyCreator的postProcessBeforeInstantiation()和postProcessAfterInitialization()处打断点

      2. 方法流程：

         1. 传入配置类，创建ioc容器；
         2. 注册配置类，调用refresh刷新容器；
         3. 注册bean的后置处理器来拦截bean的创建；
            1. 先从容器中获取已经定义了需要创建对象的BeanPostProcessor；
            2. 给容器添加其他的BeanPostProcessor；
            3. 优先注册实现了PriorityOrdered接口的BeanPostProcessor；
            4. 再给容器注册实现了Ordered接口的BeanPostProcessor；
            5. 注册其他的BeanPostProcessor；
            6. 注册BeanPostProcessor，实际就是创建BeanPostProcessor对象(internalAutoProxyCreator)，保存在容器中；
               1. 调用beanFactory.getBean()；
               2. 调用doGetBean()，第一次调用对象是null，需要创建createBean()；
               3. 调用doCreateBean()：createBeanInstance创建实例，populateBean()属性赋值，initializeBean()初始化实例；
               4. initializeBean()初始化实例：
                  1. invokeAwareMethods()设置factoryBean；
                  2. applyBeanPostProcessorsBeforeInitialization()执行所有的postProcessBeforeInitialization方法，即AbstractAutoProxyCreator的postProcessBefforeInstantiation()；
                  3. invokeInitMethods()执行自定义初始化方法；
                  4. applyBeanPostProcessorsAfterInitialization()执行所有的postProcessAfterInitialization方法；
               5. 创建完再次获取对象getSingleton()，加入到bean集合中；
            7. 创建完获取加入到容器中registerBeanPostProcessors()：beanFactory.addBeanPostProcessor(postProcessor);

      3. 代码流程：

         1)AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AOPConfig.class);
         2)AnnotationConfigApplicationContext:refresh()
         3)AbstractApplicationContext:refresh()
             @Override
             public void refresh() throws BeansException, IllegalStateException {
                 synchronized (this.startupShutdownMonitor) {
                     ...
                     //注册bean的后置处理器来拦截bean的创建
                     registerBeanPostProcessors(beanFactory);
                     ...
                     //注册其他BeanPostProcessor
                     finishBeanFactoryInitialization(beanFactory);
                     ...
                 }
             }
         4)PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);

         5) public static void registerBeanPostProcessors(
                  ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
                 //先从容器中获取已经定义了需要创建对象的BeanPostProcessor，比如下面的值
                 //org.springframework.context.annotation.internalAutowiredAnnotationProcessor
                 //org.springframework.context.annotation.internalCommonAnnotationProcessor
                 //org.springframework.aop.config.internalAutoProxyCreator【EnableAspectJAutoProxy注解已经定义了给容器添加internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator】
               String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
               int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
               //给容器添加其他的BeanPostProcessor
               beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
               // 分离实现了PriorityOrdered,Ordered和其他接口的BeanPostProcessor
               List priorityOrderedPostProcessors = new ArrayList<>();
               List internalPostProcessors = new ArrayList<>();
               List orderedPostProcessorNames = new ArrayList<>();
               List nonOrderedPostProcessorNames = new ArrayList<>();
               for (String ppName : postProcessorNames) {
                   //实现了PriorityOrdered(有优先级排序)接口的添加到priorityOrderedPostProcessors中
                  if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                     BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                     priorityOrderedPostProcessors.add(pp);
                     //如果是MergedBeanDefinitionPostProcessor添加到internalPostProcessors中
                     if (pp instanceof MergedBeanDefinitionPostProcessor) {
                        internalPostProcessors.add(pp);
                     }
                  }
                  else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                     //实现了Ordered接口的添加到orderedPostProcessorNames中
                     orderedPostProcessorNames.add(ppName);
                  }
                  else {
                      //其他添加到nonOrderedPostProcessorNames中
                     nonOrderedPostProcessorNames.add(ppName);
                  }
               }
         
               //排序
               sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
               // 优先注册实现了PriorityOrdered的BeanPostProcessor
               registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
         
               //然后注册实现了Ordered的BeanPostProcessor
               List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
               //遍历所有的internalAutoProxyCreator[AnnotationAwareAspectJAutoProxyCreator实现了Ordered]
               for (String ppName : orderedPostProcessorNames) {
                  //获得BeanPostProcessor
                  BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                  orderedPostProcessors.add(pp);
                  if (pp instanceof MergedBeanDefinitionPostProcessor) {
                     internalPostProcessors.add(pp);
                  }
               }
               sortPostProcessors(orderedPostProcessors, beanFactory);
               //注册，加入到beanFactory中
               registerBeanPostProcessors(beanFactory, orderedPostProcessors);
         
               //注册其他的nonOrderedPostProcessors
               List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
               for (String ppName : nonOrderedPostProcessorNames) {
                  BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                  nonOrderedPostProcessors.add(pp);
                  if (pp instanceof MergedBeanDefinitionPostProcessor) {
                     internalPostProcessors.add(pp);
                  }
               }
               registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
         
               // 最后注册internalPostProcessors
               sortPostProcessors(internalPostProcessors, beanFactory);
               registerBeanPostProcessors(beanFactory, internalPostProcessors);
         
               // Re-register post-processor for detecting inner beans as ApplicationListeners,
               // moving it to the end of the processor chain (for picking up proxies etc).
               beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
            }
            
             //注册
             private static void registerBeanPostProcessors(
                     ConfigurableListableBeanFactory beanFactory, List postProcessors) {
                 //遍历加入到beanFactory中
                 for (BeanPostProcessor postProcessor : postProcessors) {
                     beanFactory.addBeanPostProcessor(postProcessor);
                 }
             }

         6)beanFactory.getBean:
             public  T getBean(String name, Class requiredType) throws BeansException {
               return doGetBean(name, requiredType, null, false);
             }
         7)protected  T doGetBean(final String name, @Nullable final Class requiredType,
                  @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
                  ....
                 // 创建bean实例
                 if (mbd.isSingleton()) {
                    //第一次获取是null，需要创建实例
                    sharedInstance = getSingleton(beanName, () -> {
                       try {
                          return createBean(beanName, mbd, args);//创建实例
                       }
                       ...
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                 }
               ....
            }
         8)public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
                 ....
                 try {
                    //获得对象，第一次是null,走createBean方法创建实例，创建完后重新过来获取
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                 }
                 ....
                 if (newSingleton) {
                    addSingleton(beanName, singletonObject);//添加到bean集合中
                 }
                 ....
           }

         9) protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
                  throws BeanCreationException {
               ....
               try {
                  //创建实例org.springframework.aop.config.internalAutoProxyCreator
                  Object beanInstance = doCreateBean(beanName, mbdToUse, args);
                  if (logger.isTraceEnabled()) {
                     logger.trace("Finished creating instance of bean '" + beanName + "'");
                  }
                  return beanInstance;
               }
               ....
            }
         
         10)protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
                      throws BeanCreationException {
         
                   // 定义实例
                   BeanWrapper instanceWrapper = null;
                   if (mbd.isSingleton()) {
                      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
                   }
                   if (instanceWrapper == null) {
                      instanceWrapper = createBeanInstance(beanName, mbd, args);//创建实例internalAutoProxyCreator
                   }
                   //获得bean实例internalAutoProxyCreator
                   final Object bean = instanceWrapper.getWrappedInstance();
                   ....
                   // 初始化bean实例
                   Object exposedObject = bean;
                   try {
                      //对bean进行属性赋值
                      populateBean(beanName, mbd, instanceWrapper);
                      //初始化实例org.springframework.aop.config.internalAutoProxyCreator
                      exposedObject = initializeBean(beanName, exposedObject, mbd);
                   }
                   ....
                }

         11)protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
               ....
               else {
                  //设置beanFactory
                  invokeAwareMethods(beanName, bean);
               }
         
               Object wrappedBean = bean;
               if (mbd == null || !mbd.isSynthetic()) {
                  //执行所有的postProcessBeforeInitialization方法，即AbstractAutoProxyCreator的postProcessBefforeInstantiation()
                  wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
               }
         
               try {
                  invokeInitMethods(beanName, wrappedBean, mbd);//执行初始化方法
               }
               catch (Throwable ex) {
                  throw new BeanCreationException(
                        (mbd != null ? mbd.getResourceDescription() : null),
                        beanName, "Invocation of init method failed", ex);
               }
               if (mbd == null || !mbd.isSynthetic()) {
                  //执行所有的postProcessAfterInitialization方法
                  wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
               }
         
               return wrappedBean;
            }

         12)private void invokeAwareMethods(final String beanName, final Object bean) {
               if (bean instanceof Aware) {
                  if (bean instanceof BeanNameAware) {
                     ((BeanNameAware) bean).setBeanName(beanName);
                  }
                  if (bean instanceof BeanClassLoaderAware) {
                     ClassLoader bcl = getBeanClassLoader();
                     if (bcl != null) {
                        ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
                     }
                  }
                  //设置beanFactory,后面调用AbstractAdvisorAutoProxyCreator的setBeanFactory()，给AbstractAdvisorAutoProxyCreator添加BeanFactory并且初始化BeanFactory
                  if (bean instanceof BeanFactoryAware) {
                     ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
                  }
               }
             }

   3. 在第3步registerBeanPostProcessors完成AnnotationAwareAspectJAutoProxyCreator的注册后（作为一个后置处理器，接下来探讨它的执行时机），执行finishBeanFactoryInitialization注册其他的Bean，比如internalAutowiredAnnotationProcessor等

      1.  方法流程：从下面第4步可以看出在创建任何bean之前会进行拦截，获取AnnotationAwareAspectJAutoProxyCreator的postProcessBeforeInstantiation进行执行

         1. finishBeanFactoryInitialization注册其他的bean

         2. preInstantiateSingletons遍历容器中所有bean名字，创建对象getBean()

         3. getBen() -> doGetBean() -> getSingleton()获取单实例 -> createBean()
            1. doGetBean会从缓存中查找，如果能获取，说明已经被创建过，直接获取，不行再getSingleton()获取单实例 -> createBean()
         4. create()创建实例前调用resolveBeforeInstantiation进行解析BeforeInstantiation，希望后置处理器能返回一个代理对象，如果能获取返回该bean（AnnotationAwareAspectJAutoProxyCreator）
         5. 如果第4步解析不能返回bean，调用doCreateBean进行创建

      2. 代码流程：

         1） protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
                 ...
                 /*bean:
                  *   org.springframework.context.annotation.internalConfigurationAnnotationProcessor
                  *   org.springframework.context.annotation.internalAutowiredAnnotationProcessor
                  *   org.springframework.context.annotation.internalCommonAnnotationProcessor
                  *   org.springframework.context.event.internalEventListenerProcessor
                  *   org.springframework.context.event.internalEventListenerFactory
                  *   AOPConfig、mathCalculator、logAspects
                  *   org.springframework.aop.config.internalAutoProxyCreator
                  */
                  ....
                 //实例化其他单实例(上面的bean)
                 beanFactory.preInstantiateSingletons();
             }

         2）  public void preInstantiateSingletons() throws BeansException {
                 ....
                 //获取所有默认的其他bean，即上面注释的bean
                 List beanNames = new ArrayList<>(this.beanDefinitionNames);
                 // 遍历容器中所有定义的bean名字
                 for (String beanName : beanNames) {
                     RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
                     if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                         //是工厂bean
                         if (isFactoryBean(beanName)) {
                             Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                             if (bean instanceof FactoryBean) {
                                 final FactoryBean factory = (FactoryBean) bean;
                                 boolean isEagerInit;
                                 if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                                     isEagerInit = AccessController.doPrivileged((PrivilegedAction)
                                                     ((SmartFactoryBean) factory)::isEagerInit,
                                             getAccessControlContext());
                                 }
                                 else {
                                     isEagerInit = (factory instanceof SmartFactoryBean &&
                                             ((SmartFactoryBean) factory).isEagerInit());
                                 }
                                 if (isEagerInit) {
                                     getBean(beanName);
                                 }
                             }
                         }
                         else {//不是工厂bean
                             getBean(beanName);//获取bean,比如internalEventListenerProcessor
                         }
                     }
                 }
             
                 for (String beanName : beanNames) {
                     Object singletonInstance = getSingleton(beanName);
                     if (singletonInstance instanceof SmartInitializingSingleton) {
                         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                         if (System.getSecurityManager() != null) {
                             AccessController.doPrivileged((PrivilegedAction