AOP 原理解析 跳转逻辑 代码演示
文章目录
建议大家先看“三、总结”,有一个总体认识比较好
一、AOP功能测试

如果都放在了MathCalculator代码里,那就是一种耦合的方式

所以定义一个日志切面类(LogAspects):切面类里面的方法需要动态感知MathCalculator.div运行到哪里,然后执行

通知方法:
* 前置通知(@Before):logStart:在目标方法(div)运行之前运行
* 后置通知(@After):logEnd:在目标方法(div)运行结束之后运行(无论方法正常结束还是异常结束)
* 返回通知(@AfterReturning):logReturn:在目标方法(div)正常返回之后运行
* 异常通知(@AfterThrowing):logException:在目标方法(div)出现异常以后运行
先不用环绕通知,尝试前面4个。注意不是Junit的@Before,@After
是org.aspectj.lang.annotation.After;
@Before("top.p3wj.aop.MathCalculator.div")
如果想切MathCalculator的所有方法(且不区分参数,加"…"),即MathCalculator.*(…)
1.1

但是看起来非常繁琐,有公共的切入点,所以可以提取出来。定义一个方法

1.2 加入到容器中

1.3 告诉哪一个类是切面类

1.4 但是最后记住还要开启AspectJ。给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】

1.5 测试一下是否成功

发现并没有输出相应的东西,这是因为这是我们自己new的,只要容器中的组件才可以使用切面的功能
1.5.1 带异常

这下就有了
1.5.2 不带异常

2.1 那么怎么拿到运行时的信息呢?JoinPoint
2.1.1
JoinPoint.getSignature获得方法签名

获得方法名

参数列表

2.1.2
怎么获得返回值呢?returning属性

returning指定谁来封装这个返回值,比如我们用Object result来接受所有的返回值

2.1.3 获得异常,通过throwing
也跟returning一样要指定

不然会报红色,

这个也一样,如果不指定,spring不知道这个exception要干什么
加上后用1/0看一下结果

那么没有这个@AfterThrowing呢?

我们发现是对这个异常没有进行我们的一个处理的,并没有输出那一句话。
2.1.4 JoinPoint位置

我们发现,JoinPotin如果不放在第一个参数,spring是无法解析的
看一下异常:
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'org.springframework.context.event.internalEventListenerProcessor': Initialization of bean failed; nested exception is java.lang.IllegalArgumentException: error at ::0 formal unbound in pointcut
放在第一位就正常了


二、AOP原理
2.1- @EnableAspectJAutoProxy
AOP就是从@EnableAspectJAutoProxy开始的,加了就有AOP,不加就没有

我们点进去看一下

发现有ImportBeanDefinitionRegistrar,这是之前学的可以给容器bean中自定义注册

英文不好,我就用Translation插件翻译了,大家可以在plugins中搜索安装
可以自定义地来注册,给BeanDefinitionRegistry
我们回到以前看看以前怎么做的,回到MainConfig2

ImportSelector

ImportBeanDefinitionRegistrar


那么AspectJAutoProxyRegistrar注册了什么bean呢?我们打一个断点debug一下


注册这个组件,如果需要的情况下

调用另一个方法,并传了AnnotationAwareAspectJAutoProxyCreator.class,我们step into进去瞧瞧

3.1 判断是否容器中包含org.springframework.aop.config.internalAutoProxyCreator
3.2 包含则取得这个org.springframework.aop.config.internalAutoProxyCreator
3.3判断这个名字是否等于

对应的他想注册这个

AnnotationAwareAspectJAutoProxyCreator
他这个是判断有了就:

但是我们没有。。。第一次
所以进行了else

3.4
定义一个bean

3.5

然后这个bean的名就叫org.springframework.aop.config.internalAutoProxyCreator
4.1好了,这个beanDefinition就返回了,我们进行下一步

把@EnableAspectJAutoProxy这个注解的信息拿来
4.2 拿来看这个proxyTargetClass,exposeProxy属性是否为true

4.3 这个后来再说
如果为true,就做一些什么操作。
那么,重点就在于他给容器注册了一个AnnotationAwareAspectJAutoProxyCreator,把这个的功能研究出来了,那么AOP功能就出来了。以后也一样的,看见有@EnableXX的注解,就再去看看他给容器注册了什么组件,再去看这些组件的功能是什么

5.那我们就来看一下AnnotationAwareAspectJAutoProxyCreator
5.1 它有很多的继承关系,大家可以放大看一下


注意XXBeanPostProcessor,bean的后置处理器
BeanFactoryAware,能把工厂传进来的

2.2- AnnotationAwareAspectJAutoProxy
只要分析清楚作为后置处理器和BeanFactory做了哪些工作,整个aop的流畅我们就清楚了
因为是从AbstractAutoProxyCreator开始实现SmartInstantiationAwareBeanPostProcessor和BeanFactoryAware接口的
我们点进去看一下

我们发现是它进行setBeanFactory的,我们把断点打在这

只要是postProcessXX乱七八糟的,都是跟后置处理器有关的

我们把所有跟后置处理器有关的逻辑都打上断点
直接返回,或返回空方法的我们就不管了

打上断点:
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

注意有的方法名字有点像,

一个是postProcessBeforeInstantiation,一个是postProcessBeforeInitialization
一些不是重写的,自己定义的我们就不打断点了,例如

我们继续上一层:

我们发现,在AbstractAdvisorAutoProxyCreator中,

又把setBeanFactory重写了

它会在setBeanFactory里边init一个BeanFactory

我们再看看有没有跟后置处理器有关的,额。。。。没有。
4.我们再继续上面一层,

前面是抽象的,这个是专门针对呀AspectJ的
我们发现,。。。。这个类不是跟beanpost这些有关的,我们把它跳过
5.我们继续上一层
AnnotationAwareAspectJAutoProxyCreator


我们发现,它重写了它父亲的父亲的initBeanFactory
相当于还得调用它,其他的就没有跟后置处理器有关的了。我们再给他打上断点

再给他父类的setBeanFactory打上断点(它爷爷)

2.3- 注册AnnotationAwareAspectJAutoProxy
通过前面的分析打上了断点,我们再在这打上断点

我们来启动debug一下

启动,先来到了setBeanFactory
那么怎么来的呢?

我们从这里开始看
1.创建IOC容器

调用一个有参的构造器,就是下面这个,它分为三步

a)首先无参构造器创建对象。
b)再把我们这个配置类注册进来

c)调用refresh
refresh之前的文章有介绍,刷新容器的作用,即把容器中的bean全部创建出来

2.这个bean注册拦截器逻辑是怎样的呢?(其实之前spring-annotation文章有讲过)

3.再往前走

我们来看看这个大方法是什么

在beanFactory容器中拿到我们所有要创建的后置处理器。为什么我们已经定义了呢?因为我们那个test文件中传入了配置类,然后配置类里边有一个**@EnableAspectJAutoProxy**


之前说过这个注解会为我们容器注入一个AnnotationAwareAspectJAutoProxyCreator,包括容器中某人的一些后置处理器的定义。来到这一步的时候,只是有这么一些定义,还没有创建对象
4.我们继续,看看有哪些后置处理器

发现有internalAutoProxyCreator
但当时注册的也是beanDefinetion,即当时注册的是bean的定义信息
bean的定义信息的类型就是AnnotationAwareAspectJAutoProxyCreator。这个之前有讲

可发现他还给beanFactory中加了其他的一些BeanPostProcessor


拿到这些所有的beanProcessor。它来看是不是这个PriorityOrdered下的接口

它是有一个优先级排序,即这些beanPostProcessor首先这个接口来判断优先级,谁在前,谁在后

5.排序


普通的就是没有实现优先级接口的
那么所谓的注册是什么呢?

我们现在要注册这个
它其实就是它,因为之前的bean定义

我们来看一下它

注意在左上方,是实现了Ordered接口的

它拿到这个名字,然后从beanFactory中获取
就调到了这里

又调用doGetBean

这个doGetBean有点长,只截取了一部分
因为是第一次,容器中肯定没有


然后又回到了AbstractBeanFactory


现在就是来创建bean
7.那么我们就来看一下

如何创建名字叫它的beanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】



可以看到这个bean是有的。
这个bean的创建在上面,可以来看一下

我们来看下创建的是什么


可以看见创建的是名为internalAutoProxyCreator的,类型为AnnotationAwareAspectJAutoProxyCreator的bean

赋值是什么鬼?进去看一下

就是bean的一些属性,name啊这些,下面我们依次点进去看一下。可能有点长。

我们看见有一个BeanDefinitionHolder

里面有一个BeanDefinition

我们看见,就是这些属性
所以spring的对象创建是将Bean的定义信息存储到这个BeanDefinition相应的属性中,后面对Bean的操作就直接对BeanDefinition进行,例如拿到这个BeanDefinition后,可以根据里面的类名、构造函数、构造函数参数,使用反射进行对象initializeBean。
10.这时候创建好了,该初始化了,这里要注意,我们的beanPostProcessor就是在初始化的前后进行工作的

这里面有个这个,其实在spring-annotation那篇博客中有涉及到

看是不是这些Aware接口的,是就调用这些方法——Aware接口的方法回调
因为我们这个类型 的bean是BeanFactoryAware接口的。怕你忘了,我再贴一下图


所以进入了这个方法。我们倒回去,看看这个Aware的执行完了会是什么

applyBeanPostProcessorsBeforeInitialization
在初始化之前应用Bean后处理器
看一看。。。

它是调用所有的后置处理器,调用他们的postProcessBeforeInitialization
所以后置处理器在Aware之后,后置处理器又在初始化之前
我们继续再来看这个3

invokeInitMethods
这个英文简单,执行初始化方法。在哪自己@Bean的时候可以指定初始化方法。
我们还是进去看一下吧:

执行完这个3后,又有一个4

初始化后应用Bean后置处理器,再点进去

也是跟之前的后置处理器一样,一个是Before,一个是After,在初始化的前后。
11.我们还是回到我们的方法栈
之前说它实现了BeanFactoryAware的


最终就来到了我们的AbstractAutoProxyCreator.setBeanFctory()
即:

13.我们又倒回去看看,setBeanFactory执行完后又是怎样的。step over来到下面这个initBeanFactory

看,调到了AnnotationAwareAspectJAutoProxyCreator
也就是我们要给容器中创建的这个AspectJAutoProxyCreator的这个init方法,
它创建了两个东西,一个ReflectiveAspectJAdvisorFactory反射的AcpectJ工厂,BeanFactoryAspectJAdvisorsBuilderAdapter通知构建器的适配器。相当于把aspectJAdvisorFactory和beanFactory重新包装了一下
那么此时AnnotationAwareAspectJAutoProxyCreator就创建成功,并调用了它的initBeanFactory方法
小结:

2.4- AnnotationAwareAspectJAutoProxy执行时机
上面介绍了AnnotationAwareAspectJAutoProxyCreator就可以拦截到这些创建过程
我们来看一下它作为后置处理器接下来做了什么
来到这里

postProcessBeforeInstantiation
看看BeanPostProcessor呢

postProcessBeforeInitialization
其实在前面有提到两者名字有一点像,那么他们的区别是什么呢?
往上看,我们实现的 后置处理器是



注意一下。
那么为什么来到这呢?

我们也来探究一下。回到之前的这个:

是从之前的栈桢这里来的
然后是getBean->doGetBean,我们去看一下doGetBean

这个sharedInstance得翻到上面

spring是通过这个机制来保证单实例只被创建一次,所有被创建的bean都会被缓存起来。这里建议大家看视频

就到了创建bean的createBean,查看bean的一些定义信息
好,下面是AOP的重点!!!,小伙子们打起精神

希望后置处理器在此能返回一个代理对象:
如果能返回这个bean即!=null,它就直接返回。
如果不能,

这里有一个doCreateBean,我们点进去

前面内容有了,这里就不赘述了。和3.6流畅一样
我们现在是停到resolveBeforeInstantiation了,我们点进去看一下
后置处理器先尝试返回对象

我们先看看applyBeanPostProcessorsBeforeInstantiation是干什么的,点进去

如果说是InstantiationAwareBeanPostProcessor,就调用postProcessBeforeInstantiation方法
区别:BeanPostProcessor是在Bean对象创建完成初始化前后调用
InstantiationAwareBeanPostProcessor书在创建Bean实例之前先尝试用后置处理器返回对象的
不是以前学的postProcessBeforeInitialization
之前说了,我们的AnnotationAwareAspectJAutoProxyCreator就是InstantiationAwareBeanPostProcessor后置处理器
创建Bean,AnnotationAwareAspectJAutoProxyCreator会在任何bean创建之前先尝试返回bean的实例。它在所有bean创建之前会进行拦截,因为它是这个InstantiationAwareBeanPostProcessor后置处理器

小结:

2.5- 创建AOP代理
我们来看看
InstantiationAwareBeanPostProcessor做了什么,我们来重新debug
AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】

现在是创建容器中第一个bean,这是一个循环创建的过程
再放行

再放行,下面就一直方向了

出了点问题,我直接截视频里的了。

到了我们的计算器

adviseBeans,已经增强的bean


等等。判断我们的calculator是否在adviseBeans里面

判断是否是基础的类型,点进去看一下。

即是不是Advice,PointCut,Advisor,AopInfrastructureBean这些接口
点进去看还会判断是否为切面



判断是否有切面这个注解.即实现和注解都算作切面

判断是否需要跳过,即不处理这个bean

findCandidateAdvisors找到候选的增强器
现在有4个增强器(就是我们切面里面的通知方法)

第一个:

下一个

下面就展示了,就是4个通知方法
每一个通知方法的增强器是InstantiationModelAwarePointcutAdvisor

最终又调用父类的shouldSkip
接着就到了Initialization

这里有一个

wrapIfNecessary。包装,如果需要的情况下

这一节建议先自己看多看几遍源码,不然看视频也跟不走
跟之前一样,也是判断是否为isInfrastructureClass等等

findEligibleAdvisors找到可用的增强器

来找到增强其可以应用到beanClass
找到能在当前bean使用的增强器(找哪些通知方法是需要切入当前bean方法的),怎么找呢?

用这个AopUtils来找到这个findAdvisorsThatConApply
来看一下:

先整一个能用的一个LinkedList
通过for循环判断每一个增强器是不是

类型。

下面还有一个for循环
canApply是用来判断是否能用,怎么叫能用呢?我们apply进去

用切面表达式算一下每一个方法是否匹配
找到后还做了一个排序:

即调用哪些通知方法都是有顺序的,继续就走到了这:

然后就是这

我们这些已经指定好的拦截器,我们增强器就是要拦截目标方法执行的

把增强器拿到,然后把当前bean已经增强过了,放到缓存里面保存一下
即:如果该bean是需要增强的就会来到这一步


这是获取到的增强器
插入一句
直接贴的视频中的图是因为我打断点进入不了视频中的方法,原因在于我没有把它标示为spring项目,导致我的切面并没有真正的识别到方法
当你的方法旁边的提升不是

而是
This advice advises no method就会出现这样的问题
解决方法:
打开Project Strusture

添加就可以了
这个代理对象怎么创建呢?

还是拿到这个增强器,保存到代理工程proxyFactory

用我们这个代理工程
来创建对象
来看看这个AOP怎么创建的
返回回来后


先来得到AOP代理的创建工厂,然后创建AOP(为这个this对象)
现在来创建AOP代理
会有两种形式的代理对象

一种JdkDynamicAopProxy,一种是ObjenesisCglibAopProxy
这是spring自动决定
如果这个类是实现接口的能用jdk代理就用jdk代理。如果没有实现,例如我们的MathCalculator就用Cglib。我们也可以强制使用Cglib,这个后面再说
会为我们创建一个代理对象

可以看见是使用Cglib增强的代理
相当于wrap的方法就用完了,给容器返回增强了代理的对象
组件想要执行方法,Cglib就会提枪调用那些我们保存了的通知
以后容器获取到的就是这个组件的代理对象,执行目标方法的时候,这个代理对象就会这个切面通知方法的流程


在bean的创建前后会做一些事情,会判断这个对象是否需要包装,即需要被切入(增强),就会创建代理对象,容器拿到的就是一个代理对象。对象执行方法就是这个代理对象在执行方法。
2.6- 获得拦截器链-MethodInterceptor
来说说目标方法的执行
我们来打上断点进行debug


确定是Cglib增强过的

里面还封装了5个增强器

比如第一个增强方法他是这个AspectAfterThrowingAdvice
相当于容器中放的这个代理对象放了我们通知方法的信息,切入哪个方法 的信息

确认MathCalculator类
来到CglibAopProxy.intercept

拦截目标方法的执行(即让AOP代理先来拦截一下)
来看看他的逻辑。这里有一个chain
1.获取拦截器链

根据这个对象获取拦截器链

获取目标方法的拦截器链

如果这个链是空的,就methodProxy.invoke。就是没有拦截器链,直接执行目标方法
如果有,它创建一个CglibMethodInvocation对象,然后调用它的proceed方法,

把这些等等都传入进来
核心就来到了这个拦截器链该怎么获取,它是来做什么的。听起来像是在目标方法执行之前进行拦截的,但是在目标方法执行时我们是要执行通知方法的。所以我们猜测这个拦截器是来告诉通知方法怎么执行,再来执行目标方法。

我们step into 进来

这些都是缓存,缓存就是保存起来,方便下一次用。
它通过advisorChainFactory的getInterceptorsAndDynamicInterceptionAdvice来获取拦截器链
如果获取到了,就把这个cached返回。怎么获取的呢,我们step into 进去



再返回
所以整个拦截器链被封装在list中
ListinterceptorList保存所有拦截器。注意,list创建的时候已经赋值好了长度



一个是我们默认(ExposeInvocationInterceptor)的,剩下的就是我们的通知方法,
我们继续往下走

它拿到每一个advisor,判断如果是一个需要切面切入的增强器

包装成一个interceptors

再加入进来

如果是其他类型,也一样的操作.又或者直接传进来,然后addAll
一句话,遍历所有的增强器,再将其转为interceptor

主要是调用这句话

那么为什么需要转呢
我们来看一下,第一个advisor是

下来,它是这个PointcutAdvisor

还有一些适配器,做一些转化再加进来
即如果是MethodInterceptor直接加入到集合中,如果不是(虽然这里没有不是的逻辑,待会我们可以debug走一下)就一个for循环,使用增强器的适配器转为MethodInterceptor加入到集合中

我们来打一个断点,并放行

这是一个AspectJAfterThrowingAdvice,我们来看一下这个

发现它是这个MethodInterceptor

然后这3个适配器,我们点击下一步,

都没满足if的条件,即

然后返回。
再来看看第二个:

是这个AspectJAfterreturningAdvicem,它不是MethodInterceptor

直接来到了for

第一个是MethodBeforeAdviceAdapter,专门用来转前置通知的,它肯定是不支持我们这个afterReturning的,所以

if就没有成功。
再来看第二个AfterReturningAdviceAdapter


进来了,它是支持的。我们进去这个AfterReturningAdviceAdapter,这个advisorAdapter看看它是怎么转的

实际上就是把这个advice拿过来给他包装一个AfterReturningAdviceInterceptor

即是这个MethodInterceptor就直接放,不是就给包装过来
第三个后置通知也是直接ok的。

第四个是这个前置通知

前置通知不是,用adapter转换
我们让它全部走完,现在全部转为了

MethodInterceptor
最终回来,可以知道AfterReturningAdviceInterceptor跟MethodBeforeAdviceInterceptor是用adaptor转过来的

转完过后,其实拦截器链就出来了,拦截器链里面就是每一个通知方法

接下来往下走

new Cglib,

然后.proceed()来执行我们的拦截器
小结

2.7- 链式调用通知方法
下面来探究这个proceed方法
记录下拦截器链中有哪些内容

如果拦截器链是空的就创建一个,我们就不看了,直接来到else


之前有讲,进去看一眼

所以我们执行的是CglibMethodInvocaltion的proceed
可以看见,这里有一个索引


它默认是-1,这里做了一个判断即如果“-1 == this.interceptorsAndDynamicMethodMatchers.size() - 1”
这个size是什么呢?

正好是这个拦截器。假如没有拦截器链,就相等了。
我们点进去看一下如果没有发生了什么?


其实就为反射创建。method.invoke()
currentInterceptorIndex记录当前拦截器的索引,如果当前是第四个拦截器了,当前索引为4。当前拦截器大小正好是5-1=4
它有两种情况:
1.如果没有拦截器,直接执行目标方法,或者执行拦截器的索引和数组大小-1大小一样(指定到了最后一个拦截器),一会儿来看这个过程。反正currentInterceptorIndex是用来记录索引

现在索引是-1,拦截器有5个

第0号就是这个ExposeInvocationinterceptor
3.拿到之后怎么做呢?step into

它会调用invoke方法,然后把(this)传进来,这个this就是ExposeInvocationInterceptor对象。我们点进去:
4.

它是先从invocation里面get,点进去看一下invocaiton

它是一个ThreadLocal,TreadLocal就是同一条线程共享数据的,它把这个MethodInvocation共享。
第一次还没有共享,所以它把这个MethodInvocation先放进去

放进去后,执行Cglib的proceed
为什么呢,因为是这么过来的,它是Cglib

5.我们继续

咦,同样的流程,只是索引从之前的-1变成了0
它又自增一些,索引为1


即:

它就是这么个执行的。我们接下来继续

可以看见它又调用这个invoke(this),所有拦截器都会调用这个invoke(this)
进来,

它又是调这个mi.proceed
mi就是我们的Cglib,调这个又是索引自增一次,又是拿下一个。所以流程是这么下来的

现在是1了。

自增一个变2
再来看他,

还是调invoke(this),我们step into

那就又是一样了。无限套娃,后面就不掩饰了
通过链式的方式锁定到下一个拦截器
我们来到MethodBeforeAdviceInterceptor

它先调advice.beforem,调用前置通知的通知方法


这个interceptor总算做了一些事了
即这个MethodBeforeAdviceInterceptor在invoke的时候是先来调前置通知
它调完了才又进行之前的下一次
现在拦截器的index跟5-1一样长了
我这里直接赋值4了

11.来到了这里,invokeJoinpotint

这个目标方法一执行完就return了
前置通知调完再调用目标方法

然后这是一个递归因为,MethodBeforeAdviceInterceptor一调用完又返回到AspectAfterAdvice了

不管是否有异常,都来执行通知方法,即我们的后置通知,因为这是我们后置通知的拦截器,有点像springMVC中的拦截器
如果方法没有抛异常就来到AfterReturningAdviceInterceptor。只不过我们的方法抛了异常,即1/0,
Returning也不做什么处理的,就抛给上层AspectAfterThrowingAdvice

所以你看来到了AfterThrowingAdvice

我们来看一下AfterReturningAdviceInterceptor

只有你的proceed执行没有问题,它才会执行afterReturning
所以说我们的这个 返回通知 是在方法执行没有问题才执行
这么说:
现在在这里有1/0有错误

就抛到了AspectAfterThrowingAdvice,且afterReturning没有执行

Throwing这里拿到这个异常



且如果有异常,这个异常就抛出去了。有人处理就处理,没有就抛给虚拟机
这就是我们的AOP流程:
- 先来执行我们的前置通知
- 执行我们的目标方法
- 在执行后置通知
- 如果有异常,执行异常通知
- 如果没有异常,执行返回通知

再看一下我们的代码
MathCalculator

LogAspects

如果1/1

如果1/0

可以看见有异常AfterReturning就没了

来看这张图理解理解

三、总结
这一节原理还是很多,建议大家还是多看看视频,跟着多debug。下面做一下总结:
我们来看在创建这个容器对象的时候

会调用refresh()刷新容器

之前讲过,这里只是回忆一下

有一步是注册后置处理器。在这一步会创建后置处理器对象
后面一步就是初始化单实例bean

如果要初始化剩下的单实例bean,那么我们的

都在这了
组件创建完后就判断是否需要增强(即创建完后有一个postProcessAfterInitialization):
return wrapIfNessary(bean,beanName,cacheKey)来判断是否需要包装(增强)。
是的话就将我们的通知方法包装成增强器(Advisor),给业务逻辑组件创建一个代理对象(Cglib),如果你有接口,它也可以创建jdk动态代理
而代理对象里面就有我们的增强器。代理对象创建完后,我们的容器就创建完了。
执行目标方法其实就是代理对象执行目标方法。它是用CglibAopProxy.intercept()这个方法进行拦截。拦截过程:1.得到目标方法的拦截器链(也就是以前的增强器包装成拦截器MethodInterceptor)。2.利用拦截器的链式机制,依次进入每一个拦截器进行执行。
3.执行效果我们就有两套:
正常执行:前置通知-》目标方法-〉后置通知—》返回通知
出现一次:前置通知-》目标方法-〉后置通知—》异常通知
AOP的源码是spring里较重要的。大家多走几遍,来加深理解。以上只是为大家提供走源代码的一个思路并做下笔记帮助大家加深记忆。
###再来看一下流程

/**
* 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())
* 4、给切面类的目标方法标注何时何地运行(通知注解);
* 5、将切面类和业务逻辑类(目标方法所在类)都加入到容器中;
* 6、必须告诉Spring哪个类是切面类(给切面类上加一个注解:@Aspect)
* [7]、给配置类中加 @EnableAspectJAutoProxy 【开启基于注解的aop模式】
* 在Spring中很多的 @EnableXXX;
*
* 三步:
* 1)、将业务逻辑组件和切面类都加入到容器中;告诉Spring哪个是切面类(@Aspect)
* 2)、在切面类上的每一个通知方法上标注通知注解,告诉Spring何时何地运行(切入点表达式)
* 3)、开启基于注解的aop模式;@EnableAspectJAutoProxy
*
* AOP原理:【看给容器中注册了什么组件,这个组件什么时候工作,这个组件的功能是什么?】
* @EnableAspectJAutoProxy;
* 1、@EnableAspectJAutoProxy是什么?
* @Import(AspectJAutoProxyRegistrar.class):给容器中导入AspectJAutoProxyRegistrar
* 利用AspectJAutoProxyRegistrar自定义给容器中注册bean;BeanDefinetion
* internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
*
* 给容器中注册一个AnnotationAwareAspectJAutoProxyCreator;
*
* 2、 AnnotationAwareAspectJAutoProxyCreator:
* AnnotationAwareAspectJAutoProxyCreator
* ->AspectJAwareAdvisorAutoProxyCreator
* ->AbstractAdvisorAutoProxyCreator
* ->AbstractAutoProxyCreator
* implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
* 关注后置处理器(在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流程一样;
* 3)、
*
*
* 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)、效果:
* 正常执行:前置通知-》目标方法-》后置通知-》返回通知
* 出现异常:前置通知-》目标方法-》后置通知-》异常通知
2824



被折叠的 条评论
为什么被折叠?



