彻底讲透Spring AOP动态代理，原理源码深度剖析！

時間：2021-06-28 19:07:09 阅读：0 評論：0 收藏：0 [點我收藏+]

標簽：end lex 使用 key 日志 build 創建對象 enable ebean

1、AOP：【動態代理】定義

指在程序運行期間動態的將某段代碼切入到指定方法指定位置進行運行的編程方式；

2、基于注解aop的開發流程

1、导入aop模块；Spring AOP：(spring-aspects)
2、定義一個業務邏輯類（MathCalculator）；在業務邏輯運行的時候將日志進行打印（方法之前、方法運行結束、方法出現異常，xxx）
3、定義一個日志切面類（LogAspects）：切面類裏面的方法需要動態感知MathCalculator.div運行到哪裏然後執行；
通知方法：
前置通知(@Before)：logStart：在目標方法(div)運行之前運行
後置通知(@After)：logEnd：在目標方法(div)運行結束之後運行（無論方法正常結束還是異常結束）
返回通知(@AfterReturning)：logReturn：在目標方法(div)正常返回之後運行
異常通知(@AfterThrowing)：logException：在目標方法(div)出現異常以後運行
環繞通知(@Around)：動態代理，手動推進目標方法運行（joinPoint.procced()）
給切面類的目標方法標注何時何地運行（通知注解）；
將切面類和業務邏輯類（目標方法所在類）都加入到容器中;
必須告訴Spring哪個類是切面類(給切面類上加一個注解：@Aspect)
给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】
在Spring中很多的 @EnableXXX;

總結：三步：
1）、將業務邏輯組件和切面類都加入到容器中；告訴Spring哪個是切面類（@Aspect）
2）、在切面類上的每一個通知方法上標注通知注解，告訴Spring何時何地運行（切入點表達式）
3）、開啓基于注解的aop模式；@EnableAspectJAutoProxy

3、AOP原理：【看給容器中注冊了什麽組件，這個組件什麽時候工作，這個組件的功能是什麽？】

注解aop開發，我們在配置類中加入了@EnableAspectJAutoProxy這個注解

我們來看一下@EnableAspectJAutoProxy是什麽？

@Import(AspectJAutoProxyRegistrar.class)：給容器中導入AspectJAutoProxyRegistrar
利用AspectJAutoProxyRegistrar自定義給容器中注冊bean；BeanDefinetion
internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
給容器中注冊一個AnnotationAwareAspectJAutoProxyCreator；
所以这个注解式给容器中注入了AnnotationAwareAspectJAutoProxyCreator这样一个注解切面自动代理創建對象

通过类的层级分析 AnnotationAwareAspectJAutoProxyCreator：

AnnotationAwareAspectJAutoProxyCreator
->AspectJAwareAdvisorAutoProxyCreator
->AbstractAdvisorAutoProxyCreator
->AbstractAutoProxyCreator
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware，下面是AnnotationAwareAspectJAutoProxyCreator类的继承关系图：

我们可以清楚的看到其实它是属于InstantiationAwareBeanPostProcessor 类型的后置处理器和BeanFactoryAware；我在之前分析过IOC源码的记载过程，知道InstantiationAwareBeanPostProcessor 会在bean的初始化之前，普通后置处理器执行之前创建代理对象。BeanFactoryAware是自动装配BeanFactory，可以给容器动态注入一个我们自定的bean;

所以我們關注後置處理器（在bean初始化完成前後做事情）、自動裝配BeanFactory

AbstractAutoProxyCreator.setBeanFactory()
AbstractAutoProxyCreator.有後置處理器的邏輯；
AbstractAdvisorAutoProxyCreator.setBeanFactory()-》initBeanFactory()
AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()
流程：
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；給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);
=======以上是創建和注冊AnnotationAwareAspectJAutoProxyCreator的過程========
AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor
4）、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作；創建剩下的單實例bean
1）、遍历获取容器中所有的Bean，依次創建對象getBean(beanName);
getBean->doGetBean()->getSingleton()->
2）、創建bean
【AnnotationAwareAspectJAutoProxyCreator在所有bean創建之前會有一個攔截，InstantiationAwareBeanPostProcessor，會調用postProcessBeforeInstantiation()】
1）、先從緩存中獲取當前bean，如果能獲取到，說明bean是之前被創建過的，直接使用，否則再創建；
只要創建好的Bean都會被緩存起來
2）、createBean（）;創建bean；
AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例
【BeanPostProcessor是在Bean對象創建完成初始化前後調用的】
【InstantiationAwareBeanPostProcessor是在創建Bean實例之前先嘗試用後置處理器返回對象的】
1）、resolveBeforeInstantiation(beanName, mbdToUse);解析BeforeInstantiation
希望後置處理器在此能返回一個代理對象；如果能返回代理對象就使用，如果不能就繼續
1）、後置處理器先嘗試返回對象；
bean = applyBeanPostProcessorsBeforeInstantiation（）：
拿到所有後置處理器，如果是InstantiationAwareBeanPostProcessor;
就執行postProcessBeforeInstantiation
if (bean != null) {bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);}
2）、doCreateBean(beanName, mbdToUse, args);真正的去创建一个bean实例；和3.6流程一样；
AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】的作用：
1）、每一個bean創建之前，調用postProcessBeforeInstantiation()；
關心MathCalculator和LogAspect的創建
1）、判斷當前bean是否在advisedBeans中（保存了所有需要增強bean）
2）、判斷當前bean是否是基礎類型的Advice、Pointcut、Advisor、AopInfrastructureBean，
或者是否是切面（@Aspect）
3）、是否需要跳過
1）、获取候选的增强器（切面里面的通知方法）【List<Advisor> candidateAdvisors】
每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；
判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true
2）、永遠返回false
2）、創建對象
postProcessAfterInitialization；
return wrapIfNecessary(bean, beanName, cacheKey);//包装如果需要的情况下
1）、获取当前bean的所有增强器（通知方法） Object[] specificInterceptors
1、找到候選的所有的增強器（找哪些通知方法是需要切入當前bean方法的）
2、獲取到能在bean使用的增強器。
3、給增強器排序
2）、保存當前bean在advisedBeans中；
3）、如果當前bean需要增強，創建當前bean的代理對象；
1）、獲取所有增強器（通知方法）
2）、保存到proxyFactory
3）、創建代理對象：Spring自動決定
JdkDynamicAopProxy(config);jdk動態代理；
ObjenesisCglibAopProxy(config);cglib的動態代理；
4）、給容器中返回當前組件使用cglib增強了的代理對象；
5）、以後容器中獲取到的就是這個組件的代理對象，執行目標方法的時候，代理對象就會執行通知方法的流程；
3）、目标方法执行；
容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了詳細信息（比如增强器，目标对象，xxx）；
1）、CglibAopProxy.intercept();攔截目標方法的執行
2）、根據ProxyFactory對象獲取將要執行的目標方法攔截器鏈；
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
1）、List<Object> interceptorList保存所有拦截器 5
一个默认的ExposeInvocationInterceptor 和 4个增强器；
2）、遍曆所有的增強器，將其轉爲Interceptor；
registry.getInterceptors(advisor);
3）、將增強器轉爲List<MethodInterceptor>；
如果是MethodInterceptor，直接加入到集合中
如果不是，使用AdvisorAdapter將增強器轉爲MethodInterceptor；
轉換完成返回MethodInterceptor數組；
3）、如果沒有攔截器鏈，直接執行目標方法;
攔截器鏈（每一個通知方法又被包裝爲方法攔截器，利用MethodInterceptor機制）
4）、如果有攔截器鏈，把需要執行的目標對象，目標方法，
拦截器链等信息传入创建一个 CglibMethodInvocation 对象，
并调用 Object retVal = mi.proceed();
5）、攔截器鏈的觸發過程;
1)、如果沒有攔截器執行執行目標方法，或者攔截器的索引和攔截器數組-1大小一樣（指定到了最後一個攔截器）執行目標方法；
2)、鏈式獲取每一個攔截器，攔截器執行invoke方法，每一個攔截器等待下一個攔截器執行完成返回以後再來執行；
攔截器鏈的機制，保證通知方法與目標方法的執行順序；
總結：
1）、 @EnableAspectJAutoProxy 开启AOP功能
2）、 @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator
3）、AnnotationAwareAspectJAutoProxyCreator是一個後置處理器；
4）、容器的創建流程：
1）、registerBeanPostProcessors（）注冊後置處理器；創建AnnotationAwareAspectJAutoProxyCreator對象
2）、finishBeanFactoryInitialization（）初始化剩下的單實例bean
1）、創建業務邏輯組件和切面組件
2）、AnnotationAwareAspectJAutoProxyCreator攔截組件的創建過程
3）、組件創建完之後，判斷組件是否需要增強
是：切面的通知方法，包裝成增強器（Advisor）;給業務邏輯組件創建一個代理對象（cglib）；
5）、執行目標方法：
1）、代理對象執行目標方法
2）、CglibAopProxy.intercept()；
1）、得到目標方法的攔截器鏈（增強器包裝成攔截器MethodInterceptor）
2）、利用攔截器的鏈式機制，依次進入每一個攔截器進行執行；
3）、效果：
正常執行：前置通知-》目標方法-》後置通知-》返回通知
出現異常：前置通知-》目標方法-》後置通知-》異常通知