Spring注解驱动开发学习总结17：AOP原理总结

回顾前面５篇关于AOP文章的内容
１、Spring注解驱动开发学习总结11：AOP功能使用
构建了一个数学计算器的业务类（MathCalculator），该业务类添加了一个除法方法（div）。
然后给div方法添加AOP的通知方法：前置通知（@Before）、后置通知（@After）、返回通知（@AfterReturning）、异常通知（@AfterThrowing）。

后面的AOP原理分析，针对这种业务场景对AOP原理进行了分析。注意我们使用的spring-aspects的版本是：4.3.12.RELEASE。

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

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

４、Spring注解驱动开发学习总结14：AOP原理 - AnnotationAwareAspectJAutoProxyCreator后置处理器的调用步骤分析了AnnotationAwareAspectJAutoProxyCreator后置处理器的调用时机和调用步骤。

５、Spring注解驱动开发学习总结15：AOP原理 - AnnotationAwareAspectJAutoProxyCreator后置处理器返回代理对象的步骤分析了AnnotationAwareAspectJAutoProxyCreator后置处理器给div方法添加AOP通知方法，并返回代理对象的步骤。

６、Spring注解驱动开发学习总结16：AOP原理 - AOP通知方法执行的步骤
分析了mathCalculator类的div方法前后调用AOP通知方法的具体步骤。

1、AOP原理总结

1.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.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.1.1.1 分析applyBeanPostProcessorsBeforeInstantiation方法
　　　　　　　　　　　　　　　１）在applyBeanPostProcessorsBeforeInstantiation方法中，只
　　　　　　　　　　　　　　　会调用InstantiationAwareBeanPostProcessor类的后置处理器，
　　　　　　　　　　　　　　　而我们分析的AnnotationAwareAspectJAutoProxyCreator就是该
　　　　　　　　　　　　　　　类的，此时的beanName=mathCalculator。
　　　　　　　　　　　　　　　２）因此进入postProcessBeforeInstantiation方法。在
　　　　　　　　　　　　　　　postProcessBeforeInstantiation方法中，如果是建议bean
　　　　　　　　　　　　　　　（advisedBeans）的话直接返回null，也就是不用代理。
　　　　　　　　　　　　　　　判断是否是建议bean（advisedBeans）的逻辑：会先判断下是否
　　　　　　　　　　　　　　　是基础设施类：Advice、Pointcut、Advisor、
　　　　　　　　　　　　　　　AopInfrastructureBean这些类，如果是这些类的话，说明是IOC
　　　　　　　　　　　　　　　的基础设施类，不需要AOP进行代理，所以返回null。
　　　　　　　　　　　　　　　３）可以看到当类为mathCalculator时，返回了null，也就是没有
　　　　　　　　　　　　　　　返回代理。由于返回了空，因此4.1.1.1.1 中的
　　　　　　　　　　　　　　　postProcessorsAfterInitialization方法也就不会执行，那
　　　　　　　　　　　　　　　么IOC容器到底是怎么给mathCalculator类添加通知方法的呢？这
　　　　　　　　　　　　　　　里可以接着4.1.1.2.1看。
　　　　　　4.1.1.2 在createBean方法中，如果上面一步没有返回代理对象，那么就创建一个
　　　　　　　　bean对象：doCreateBean(beanName);
　　　　　　　　4.1.1.2.1 在doCreateBean方法中，先实例化bean，然后再初始化bean：
　　　　　　　　　　　initializeBean，该方法会调用
　　　　　　　　　　　applyBeanPostProcessorsAfterInitialization方法。
　　　　　　　　　　　4.1.1.2.1.1 分析applyBeanPostProcessorsAfterInitialization方法
　　　　　　　　　　　　　　１）在applyBeanPostProcessorsAfterInitialization方法中，先遍历
　　　　　　　　　　　　　　每一个后置处理器，然后调用后置处理器的
　　　　　　　　　　　　　　postProcessAfterInitialization方法。
　　　　　　　　　　　　　　２）在postProcessAfterInitialization方法中，会调用
　　　　　　　　　　　　　　AnnotationAwareAspectJAutoProxyCreator类的wrapIfNecessary方
　　　　　　　　　　　　　　法，即如果有必要的话就进行包装。
　　　　　　　　　　　　　　３）在wrapIfNecessary方法中，先获取bean的增强方法，可以看
　　　　　　　　　　　　　　到获取到了mathCalculator类的４个增强方法。当增强方法不为
　　　　　　　　　　　　　　空，就调用createProxy方法，该方法之后会调用createAopProxy方
　　　　　　　　　　　　　　法。
　　　　　　　　　　　　　　４）在createAopProxy方法中，如果目标类是接口或者代理类，那
　　　　　　　　　　　　　　么就创建JDK动态代理：JdkDynamicAopProxy。如果不是，那么
　　　　　　　　　　　　　　就创建cglib动态代理：ObjenesisCglibAopProxy。
　　　　　　　　　　　　　　５）到这里，就分析出了：添加了AOP方法的
　　　　　　　　　　　　　　mathCalculator类，它并不是在4.1.1.1的
　　　　　　　　　　　　　　resolveBeforeInstantiation方法中创建的aop的代理对象，而是在
　　　　　　　　　　　　　　4.1.1.2.1中的创建对象的初始化方法：initializeBean，才最终创建
　　　　　　　　　　　　　　了包含aop方法的代理对象。

1.3 AOP通知方法的调用步骤

我们之前给mathCalculator类的div方法添加了AOP的：前置通知（@Before）、后置通知（@After）、返回通知（@AfterReturning）、异常通知（@AfterThrowing）。
下面分析下mathCalculator类的div方法前后调用AOP通知方法的具体步骤。

1 进入mathCalculator类的div方法后，下一步首先会进入intercept方法
　　1.1 在intercept方法中，在659行，会先通过getInterceptorsAndDynamicInterceptionAdvice方
　　　　法获取拦截器链chain，如果拦截器链为空，说明该方法没有任何增强，那么直接执行目标
　　　　方法。
　　　　1.1.1 分析getInterceptorsAndDynamicInterceptionAdvice方法，在55行会先创建一个拦截
　　　　　　器列表，在60-61行，然后再遍历所有的增强器，如果是切面类增强器，则直接加入增
　　　　　　强器链。运行结束后，interceptorList共包含５个拦截器
　　1.2 在intercept方法中，在673行，如果拦截器链不为空，那么就会执行CGLIB的代理方法：
　　　　retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain,
　　　　　　　　methodProxy).proceed();
　　　　1.2.1 分析proceed方法，在156-157行，拦截器索引初始值为-1，会先判断当前拦截器
　　　　　　索引是否到拦截器的最后一个：
　　　　　　this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size()
　　　　　　interceptorsAndDynamicMethodMatchers的值为ExposeInvocationInterceptor + 我们
　　　　　　自定义的４个AOP方法，
　　　　　　所以this.interceptorsAndDynamicMethodMatchers.size()-1的值为４
　　　　　　1.2.1.1 如果到了最后一个，则直接执行切点方法：invokeJoinpoint()。
　　　　　　1.2.1.2 如果没到最后一个，那么取下一个拦截器：
　　　　　　ExposeInvocationInterceptor(index=0),并执行它的invoke方法
　　　　　　　　　1.2.1.2.1 分析ExposeInvocationInterceptor的invoke方
　　　　　　　　　　　　法，
　　　　　　　　　　　　１）在92行，会再调用该方法的proceed方法。会再次跳转到1.2.1中的
　　　　　　　　　　　　　　proceed方法，只是此时的拦截器索引值变为了0。
　　　　　　　　　　　　　　在156行，此时还是没有达到拦截器的最后一个位置4，那么拦截器
　　　　　　　　　　　　　　索引值+1，继续取下一个拦截器：
　　　　　　　　　　　　　　AspectJAfterThrowingAdvice（index=1），
　　　　　　　　　　　　　　然后再次调用AspectJAfterThrowingAdvice
　　　　　　　　　　　　　　的invoke方法。
　　　　　　　　　1.2.1.2.2 分析AspectJAfterThrowingAdvice的invoke方法
　　　　　　　　　　　　１）在62行，会再调用该方法的proceed方法。会再次跳转到1.2.1中的
　　　　　　　　　　　　　　proceed方法，只是此时的拦截器索引值变为了１。
　　　　　　　　　　　　　　此时还是没有达到拦截器的最后一个位置4，那么拦截器索引值
　　　　　　　　　　　　　　+1，继续取下一个拦截器：
　　　　　　　　　　　　　　AspectJAfterReturningAdvice（index=２），
　　　　　　　　　　　　　　然后再次调用AspectJAfterReturningAdvice的invoke方法。
　　　　　　　　　　　　２）在66-68行，如果该方法执行报错，那么会执行AOP的异常通知方
　　　　　　　　　　　　　　法@AfterThrowing或者抛出异常。
　　　　　　　　　1.2.1.2.3 分析AspectJAfterReturningAdvice的invoke方法
　　　　　　　　　　　　１）在52行，会再调用该方法的proceed方法。会再次跳转到1.2.1中的
　　　　　　　　　　　　　　proceed方法，只是此时的拦截器索引值变为了2。
　　　　　　　　　　　　　　此时还是没有达到拦截器的最后一个位置4，那么拦截器索引值
　　　　　　　　　　　　　　+1，继续取下一个拦截器：
　　　　　　　　　　　　　　AspectJAfterAdvice（index=3），
　　　　　　　　　　　　　　然后再次调用AspectJAfterAdvice的invoke方法。
　　　　　　　　　　　　２）如果该方法执行成功，那么会接着执行AOP的返回通知方法
　　　　　　　　　　　　　　　　@AfterReturning；
　　　　　　　　　　　　　　如果该方法执行失败，那么就不会执行AOP的返回通知方法
　　　　　　　　　　　　　　　　@AfterReturning。
　　　　　　　　　1.2.1.2.4 分析AspectJAfterAdvice的invoke方法
　　　　　　　　　　　　１）在47行，会再调用该方法的proceed方法。会再次跳转到1.2.1中的
　　　　　　　　　　　　　　proceed方法，只是此时的
　　　　　　　　　　　　　　拦截器索引值变为了3。
　　　　　　　　　　　　　　此时还是没有达到拦截器的最后一个位置4，那么拦截器索引值
　　　　　　　　　　　　　　+1，继续取下一个拦截器：
　　　　　　　　　　　　　　AspectJMethodBeforeAdvice（index=４），
　　　　　　　　　　　　　　然后再次调用AspectJMethodBeforeAdvice的invoke方法。
　　　　　　　　　　　　２）无论该方法是否成功，都会finally执行该AOP的后置通知方法
　　　　　　　　　　　　　　@After。
　　　　　　　　　1.2.1.2.5 分析AspectJMethodBeforeAdvice的invoke方法
　　　　　　　　　　　　１）在51行，会先执行AOP的前置通知方法@Before。
　　　　　　　　　　　　２）在52行，会再调用该方法的proceed方法。会再次跳转到1.2.1中的
　　　　　　　　　　　　　　proceed方法，只是此时的
　　　　　　　　　　　　　　拦截器索引值变为了4。
　　　　　　　　　　　　　　在156行，此时终于达到拦截器的最后一个位置4，那么此时直接就
　　　　　　　　　　　　　　调用该切点的方法，也就是mathCalculator中被AOP加强的方法
　　　　　　　　　　　　　　了。
　　　　　　　　　　　　　　执行完之后，然后再倒回去执行1.2.1.2.4，1.2.1.2.3，1.2.1.2.2，
　　　　　　　　　　　　　　1.2.1.2.1中程序剩下的通知方法。