Spring注解驱动开发学习总结14：AOP原理 - AnnotationAwareAspectJAutoProxyCreator后置处理器的调用步骤

回顾下前两篇AOP原理分析的内容：
１、Spring注解驱动开发学习总结12：AOP原理 - @EnableAspectJAutoProxy注解作用分析
分析了配置类上添加@EnableAspectJAutoProxy注解，最终会给容器中注册了一个id为internalAutoProxyCreator，类型为AnnotationAwareAspectJAutoProxyCreator的组件。

２、Spring注解驱动开发学习总结13：AOP原理 - AnnotationAwareAspectJAutoProxyCreator后置处理器注入容器的步骤
分析了AnnotationAwareAspectJAutoProxyCreator后置处理器注入ioc容器的步骤。

既然AnnotationAwareAspectJAutoProxyCreator后置处理器已经注入了IOC容器，那么IOC容器是在什么时候调用的它，调用它的大致步骤是什么？这是本文AOP原理分析的重点。

1、AnnotationAwareAspectJAutoProxyCreator后置处理器的调用步骤

1.1 查看方法栈调用信息

接着前面两篇AOP原理打的断点位置继续调试：
１）当程序断点到了AbstractAutoProxyCreator类的241行的postProcessBeforeInstantiation方法暂停；
２）程序还是开始于IocTest类的128行的testAop方法；

中间就是后置处理器的调用步骤，其中有些步骤会与上一篇Spring注解驱动开发学习总结13：AOP原理 - AnnotationAwareAspectJAutoProxyCreator后置处理器注入容器的步骤相同，因此重复的步骤会省略。

1.2 方法栈调用分析

１、运行testAop方法
　　1.1 构建ioc容器：
　　AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
２、运行AnnotationConfigApplicationContext方法
　　2.1 注册配置类：register(annotatedClasses);
　　2.2 刷新ioc容器：refresh();
３、运行refresh方法中的第528行registerBeanPostProcessors方法
　　该方法会将AnnotationAwareAspectJAutoProxyCreator后置处理器注入到ioc容器中，这个在上一篇中已详细分析了，这里不再分析。本文的重点是，既然AnnotationAwareAspectJAutoProxyCreator后置处理器已经注入了容器，那么是在什么时候调用的它，调用它的大致步骤是什么？
４、运行refresh方法中的第543行finishBeanFactoryInitialization方法
　　该方法会完成beanFactory的初始化工作，创建剩下的单实例bean（比如有些bean是后置处理器，在528行就已经创建了）。

接下里继续分析refresh方法中的第543行finishBeanFactoryInitialization方法
４.1 finishBeanFactoryInitialization方法
　　该方法会在867行调用beanFactory的preInstantiateSingletons方法，实例化剩下的所有的单实例的bean

接着继续查看preInstantiateSingletons方法
４、运行finishBeanFactoryInitialization方法–>运行preInstantiateSingletons方法
　　4.1 先在735行获取容器中所有的bean的定义名称，然后循环遍历，在761行依次创建对象：
　　　　getBean(beanName) --> doGetBean(name, null, null, false)

接着4.1查看doGetBean方法：
　　4.1.1 在243-244, 254行，先从缓存中获取当前bean，如果能获取到，说明之前已创建过，可以直接使用。否则在302行，需要再创建bean实例：getSingleton(beanName)。该方法会createBean(beanName)方法来创建bean实例。

接着继续分析4.1.1中的createBean方法
4.1.1 创建bean对象
　　4.1.1.1 在473行，调用resolveBeforeInstantiation(beanName)方法，给后置处理器一个机会返回一个代理对象，来替代这个bean实例（Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.）。这里大致就可以猜到了，ioc容器就是在这里对每一个bean创建了一个动态代理对象，使得AOP的切面方法能够在指定bean的方法的前后来执行，这样就可以实现AOP的功能了。。
　　4.1.1.2 在483行，如果上面一步没有返回代理对象，那么就创建一个bean对象：doCreateBean(beanName);

接着继续分析4.1.1.1 里的resolveBeforeInstantiation(beanName)方法。
4.1.1.1 resolveBeforeInstantiation(beanName)方法
　　4.1.1.1.1 在473行，调用resolveBeforeInstantiation(beanName)方法，给后置处理器一个机会返回一个代理对象，来替代这个bean实例。
　　　　4.1.1.1.1.1 在1011-1014行，调用该对象的postProcessorsBeforeInstantiation方法，如果该对象不为空的话，
　　　　　　则再调用bean的postProcessorsAfterInitialization方法。

在上一篇中注册到容器的AnnotationAwareAspectJAutoProxyCreator类，我们在Spring注解驱动开发学习总结12：AOP原理 - @EnableAspectJAutoProxy注解作用分析的文章中，就已经分析了该类的继承关系。

可以看到AnnotationAwareAspectJAutoProxyCreator后置处理器是AbstractAutoProxyCreator的子类，而AbstractAutoProxyCreator类中就有postProcessBeforeInstantiation和postProcessAfterInitialization方法。因此到这里，本文就已经找到了AnnotationAwareAspectJAutoProxyCreator后置处理器的调用时机和一个大概的调用步骤。

继承关系	后置处理方法	setBeanFactory方法
AnnotationAwareAspectJAutoProxyCreator	无重写	１、initBeanFactory
AspectJAwareAdvisorAutoProxyCreator	无重写	无重写
AbstractAdvisorAutoProxyCreator	无重写	１、setBeanFactory -> initBeanFactory
AbstractAutoProxyCreator	１、postProcessBeforeInstantiation； ２、postProcessAfterInitialization	１、setBeanFactory

1.3 本文小结

１、Spring注解驱动开发学习总结12：AOP原理 - @EnableAspectJAutoProxy注解作用分析
分析了配置类上添加@EnableAspectJAutoProxy注解，最终会给容器中注册了一个id为internalAutoProxyCreator，类型为AnnotationAwareAspectJAutoProxyCreator的组件。

２、Spring注解驱动开发学习总结13：AOP原理 - AnnotationAwareAspectJAutoProxyCreator后置处理器注入容器的步骤
分析了AnnotationAwareAspectJAutoProxyCreator后置处理器注入ioc容器的步骤。

３、在AnnotationAwareAspectJAutoProxyCreator后置处理器在注入容器之后，本文分析了ioc容器调用它的大致步骤。

总结合并文章1,2,3后的小结如下：

1.3.1 @EnableAspectJAutoProxy注解作用分析

再次回顾下上一篇博文的小结：
１、使用AOP功能，要在配置类上加@EnableAspectJAutoProxy注解，而@@EnableAspectJAutoProxy注解类上加了@Import(AspectJAutoProxyRegistrar.class)，也就是导入了一个AspectJAutoProxyRegistrar类。

２、AspectJAutoProxyRegistrar类中的registerBeanDefinitions方法，最终给容器中注册了一个id为internalAutoProxyCreator，类型为AnnotationAwareAspectJAutoProxyCreator的组件。

３、注册了类型为AnnotationAwareAspectJAutoProxyCreator的组件，我们理论上分析了该类的父类和所实现的接口，分析出该类在spring使用aop功能时，可能会运行的后置处理方法、以及setBeanFactory方法，并且也通过测试进行了验证。

继承关系	后置处理方法	setBeanFactory方法
AnnotationAwareAspectJAutoProxyCreator	无重写	１、initBeanFactory
AspectJAwareAdvisorAutoProxyCreator	无重写	无重写
AbstractAdvisorAutoProxyCreator	无重写	１、setBeanFactory -> initBeanFactory
AbstractAutoProxyCreator	１、postProcessBeforeInstantiation； ２、postProcessAfterInitialization	１、setBeanFactory

1.3.2 AnnotationAwareAspectJAutoProxyCreator后置处理器的调用步骤

１、运行testAop方法，构建ioc容器：
　　AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
２、运行AnnotationConfigApplicationContext方法
　　2.1 注册配置类：register(annotatedClasses);
　　2.2 刷新ioc容器：refresh();
３、运行refresh方法中的registerBeanPostProcessors方法：给容器中注册后置处理器组件，比如AnnotationAwareAspectJAutoProxyCreator组件
　　3.1 先获取ioc容器已经定义了的所有BeanPostProcessor类型的id名称
　　3.2 遍历所有的BeanPostProcessor，根据是否是优先排序、排序、无排序分别加入到对应的容器中；
　　3.3 获取BeanPostProcessor，然后根据id名称获取bean：
　　　　BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);，
　　　　其中ppName=internalAutoProxyCreator。
　　　　这一步应该就是创建并获取bean的后置处理器，等会要着重进来看一下这一步里面是怎么创建
　　　　id为internalAutoProxyCreator，类型为AnnotationAwareAspectJAutoProxyCreator类的bean。
　　　　3.3.1 先创建bean的实例：instanceWrapper = createBeanInstance(beanName, mbd, args);，
　　　　　　　其中beanName=internalAutoProxyCreator。
　　　　3.3.2 给bean的属性赋值：populateBean(beanName, mbd, instanceWrapper);
　　　　3.3.3 初始化bean：exposedObject = initializeBean(beanName, exposedObject, mbd);
　　　　　　3.3.3.1 在处理Aware接口的方法回调：invokeAwareMethods(beanName, bean)。
　　　　　　　　　再查看invokeAwareMethods方法，如果是BeanFactoryAware的类，
　　　　　　　　　会调用setBeanFactory方法，这就和上一篇博文分析的是一致了。
　　　　　　3.3.3.2 执行后置处理器的beanPostProcessorsBeforeInitialization方法。这也和上一篇博文分析
　　　　　　　　　 的是一致的。
　　　　　　3.3.3.3 执行初始化方法：invokeInitMethods(beanName, wrappedBean, mbd);
　　　　　　3.3.3.4 执行后置处理器的beanPostProcessorsAfterInitialization方法
　　3.4 把创建好的banPostProcessor注册到beanFactory中：
　　　　registerBeanPostProcessors(beanFactory, internalAutoProxyCreator);　
　　　　beanFactory.addBeanPostProcessor
４、运行refresh方法中的finishBeanFactoryInitialization方法：该方法会完成beanFactory的初始化工作，创建剩下的单实例bean（比如有些bean是后置处理器，在第3步中就已经创建了）。
　　finishBeanFactoryInitialization方法会调用beanFactory的preInstantiateSingletons方法。
　　4.1 在preInstantiateSingletons方法中，会先获取容器中所有的bean的定义名称，然后循环
　　　　遍历，依次创建对象：
　　　　getBean(beanName) --> doGetBean(name)
　　　　4.1.1 在doGetBean方法中，先从缓存中获取当前bean，如果能获取到，说明之前已创
　　　　　　建过，可以直接使用。否则需要再创建bean实例：getSingleton(beanName)。该方法
　　　　　　会再调用createBean(beanName)方法来创建bean实例。
　　　　　　4.1.1.1 在createBean方法中，会调用resolveBeforeInstantiation(beanName)方法，
　　　　　　　　给后置处理器一个机会返回一个代理对象，来替代这个bean实例（
　　　　　　　　Give BeanPostProcessors a chance to return a proxy instead of the
　　　　　　　　target bean instance.）。这里大致就可以猜到了，ioc容器就是在这里对每一
　　　　　　　　个bean创建了一个动态代理对象，使得AOP的切面方法能够在指定bean的方法
　　　　　　　　的前后来执行，这样就可以实现AOP的功能了。。
　　　　　　　　　　4.1.1.1.1 在resolveBeforeInstantiation方法中，调用该对象
　　　　　　　　　　的postProcessorsBeforeInstantiation方法，如果该对象不为空的话，则再调
　　　　　　　　　　用bean的postProcessorsAfterInitialization方法。
　　　　　　　　　　而AnnotationAwareAspectJAutoProxyCreator后置处理器是
　　　　　　　　　　AbstractAutoProxyCreator的子类，
　　　　　　　　　　AbstractAutoProxyCreator类中就有postProcessorsBeforeInstantiation
　　　　　　　　　　和postProcessorsAfterInitialization方法。
　　　　　　　　　　因此到这里，本文就已经找到了
　　　　　　　　　　AnnotationAwareAspectJAutoProxyCreator后置处理器的调用时机和一个大
　　　　　　　　　　概的调用步骤。
　　　　　　4.1.1.2 在createBean方法中，如果上面一步没有返回代理对象，那么就创建一个
　　　　　　　　bean对象：doCreateBean(beanName);