AOP 原理解析 跳转逻辑 代码演示

SpringAOP:Spring AOP示例 SpringAOP Spring AOP(面向方面​​的编程)用于模块化“横截面”服务。 用一种简单的方式,我们可以说它是一个旨在拦截某些进程的组件,例如,在执行某个方法时,Spring AOP可以审核该执行方法,并在该方法执行之前和/或之后添加额外的功能。 在Spring AOP中,可以审核4个“时刻”: 事件之前(在方法执行之前执行“某些操作”) 返回之后(在某种方法的结果返回之后执行一些操作) 引发异常之后(在方法异常之后执行一些操作) 事件周围(合并以上三个事件。) 以下示例将向您展示其工作原理 立即下载

AOP 原理解析 跳转逻辑 代码演示

建议大家先看“三、总结”,有一个总体认识比较好

视频总比文章更好理解

一、AOP功能测试

image-20200529222027235

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

image-20200529222119307

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

image-20200529223257175

 通知方法:
* 前置通知(@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

image-20200529224223102

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

image-20200529233816416

1.2 加入到容器中

image-20200529225252909

1.3 告诉哪一个类是切面类

image-20200529231426671

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

image-20200529230229273

1.5 测试一下是否成功

image-20200529234453223

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

1.5.1 带异常

image-20200529234643728

这下就有了

1.5.2 不带异常

image-20200529234849476

2.1 那么怎么拿到运行时的信息呢?JoinPoint

2.1.1

JoinPoint.getSignature获得方法签名

image-20200529235918427

获得方法名

image-20200529235944269

参数列表

image-20200530000140392

2.1.2

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

image-20200530000332367

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

image-20200601091041227

2.1.3 获得异常,通过throwing

也跟returning一样要指定

image-20200601092640346

不然会报红色,

image-20200601092728808

这个也一样,如果不指定,spring不知道这个exception要干什么

加上后用1/0看一下结果

image-20200601093132330

那么没有这个@AfterThrowing呢?

image-20200601093242622

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

2.1.4 JoinPoint位置

image-20200601093603512

我们发现,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 

放在第一位就正常了

image-20200601095034789

image-20200601095227532

二、AOP原理

2.1- @EnableAspectJAutoProxy

AOP就是从@EnableAspectJAutoProxy开始的,加了就有AOP,不加就没有

image-20200601095551805

我们点进去看一下

image-20200601095644226

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

image-20200601095738427

英文不好,我就用Translation插件翻译了,大家可以在plugins中搜索安装

可以自定义地来注册,给BeanDefinitionRegistry

我们回到以前看看以前怎么做的,回到MainConfig2

image-20200601103527154

ImportSelector

image-20200601103554549

ImportBeanDefinitionRegistrar

image-20200601103627304

image-20200601103704464

那么AspectJAutoProxyRegistrar注册了什么bean呢?我们打一个断点debug一下
在这里插入图片描述

image-20200601104144543

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

image-20200601104347510

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

image-20200601104610923

3.1 判断是否容器中包含org.springframework.aop.config.internalAutoProxyCreator

3.2 包含则取得这个org.springframework.aop.config.internalAutoProxyCreator

3.3判断这个名字是否等于

image-20200601104811458

对应的他想注册这个

image-20200601104852093

AnnotationAwareAspectJAutoProxyCreator

他这个是判断有了就:

image-20200601105132380

但是我们没有。。。第一次

所以进行了else

image-20200601105150595

3.4

定义一个bean

image-20200601105307014

3.5

image-20200601105350821

然后这个bean的名就叫org.springframework.aop.config.internalAutoProxyCreator

4.1好了,这个beanDefinition就返回了,我们进行下一步

image-20200601105642399

把@EnableAspectJAutoProxy这个注解的信息拿来

4.2 拿来看这个proxyTargetClass,exposeProxy属性是否为true

image-20200601105853715

4.3 这个后来再说

如果为true,就做一些什么操作。

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

image-20200601110455241

5.那我们就来看一下AnnotationAwareAspectJAutoProxyCreator

5.1 它有很多的继承关系,大家可以放大看一下

AnnotationAwareAspectJAutoProxyCreator

image-20200601110940446

注意XXBeanPostProcessor,bean的后置处理器

BeanFactoryAware,能把工厂传进来的

image-20200601111108286

2.2- AnnotationAwareAspectJAutoProxy

只要分析清楚作为后置处理器和BeanFactory做了哪些工作,整个aop的流畅我们就清楚了

因为是从AbstractAutoProxyCreator开始实现SmartInstantiationAwareBeanPostProcessor和BeanFactoryAware接口的

我们点进去看一下

image-20200601112854708

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

image-20200601113005975

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

image-20200601113426892

我们把所有跟后置处理器有关的逻辑都打上断点

直接返回,或返回空方法的我们就不管了

image-20200601113228756

打上断点:

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException

image-20200601122232476

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

image-20200601122324655

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

image-20200601122409855

一个是postProcessBeforeInstantiation,一个是postProcessBeforeInitialization

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

image-20200601122602218

我们继续上一层:
image-20200601122927278

我们发现,在AbstractAdvisorAutoProxyCreator中,

image-20200601123031587

又把setBeanFactory重写了

image-20200601123249073

它会在setBeanFactory里边init一个BeanFactory

image-20200601123332094

我们再看看有没有跟后置处理器有关的,额。。。。没有。

4.我们再继续上面一层,

image-20200601163600563

前面是抽象的,这个是专门针对呀AspectJ的

我们发现,。。。。这个类不是跟beanpost这些有关的,我们把它跳过

5.我们继续上一层

AnnotationAwareAspectJAutoProxyCreator

image-20200601164247986

image-20200601164054126

我们发现,它重写了它父亲的父亲的initBeanFactory

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

image-20200601164341022

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

image-20200601164503945

2.3- 注册AnnotationAwareAspectJAutoProxy

通过前面的分析打上了断点,我们再在这打上断点

image-20200601164628529

我们来启动debug一下

image-20200601165006499

启动,先来到了setBeanFactory

那么怎么来的呢?

image-20200601165052253

我们从这里开始看

1.创建IOC容器

image-20200601165132511

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

image-20200601165246027

a)首先无参构造器创建对象。

b)再把我们这个配置类注册进来

image-20200601165436945

c)调用refresh

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

image-20200601165708541

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

image-20200601170057869

3.再往前走

image-20200601170217811

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

image-20200601170259348

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

image-20200601170507034

image-20200601170523781

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

4.我们继续,看看有哪些后置处理器

image-20200601172126436

发现有internalAutoProxyCreator

但当时注册的也是beanDefinetion,即当时注册的是bean的定义信息

bean的定义信息的类型就是AnnotationAwareAspectJAutoProxyCreator。这个之前有讲

image-20200601204421466

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

image-20200601204759012

image-20200601204838447

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

image-20200601205040832

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

image-20200601205216131

5.排序

image-20200601205451006

image-20200601205545331

普通的就是没有实现优先级接口的

那么所谓的注册是什么呢?

image-20200601210452243

我们现在要注册这个

它其实就是它,因为之前的bean定义

image-20200601210558489

我们来看一下它

image-20200601210558490

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

image-20200601210911491

它拿到这个名字,然后从beanFactory中获取

就调到了这里

image-20200601211100325

又调用doGetBean

image-20200601211227068

这个doGetBean有点长,只截取了一部分

因为是第一次,容器中肯定没有

image-20200601211605142

image-20200601212849824

然后又回到了AbstractBeanFactory

image-20200601211826775

image-20200601211857249

现在就是来创建bean

7.那么我们就来看一下

image-20200601213056575

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

image-20200602091327443

image-20200602091357784

image-20200602091538538

可以看到这个bean是有的。

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

image-20200602091918049

我们来看下创建的是什么

image-20200602091953552

image-20200602092016208

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

image-20200602092326769

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

image-20200602092434131

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

image-20200602093318908

我们看见有一个BeanDefinitionHolder

image-20200602093426622

里面有一个BeanDefinition

image-20200602093659428

我们看见,就是这些属性

所以spring的对象创建是将Bean的定义信息存储到这个BeanDefinition相应的属性中,后面对Bean的操作就直接对BeanDefinition进行,例如拿到这个BeanDefinition后,可以根据里面的类名、构造函数、构造函数参数,使用反射进行对象initializeBean。

10.这时候创建好了,该初始化了,这里要注意,我们的beanPostProcessor就是在初始化的前后进行工作的

image-20200602094241694

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

image-20200602094438247

看是不是这些Aware接口的,是就调用这些方法——Aware接口的方法回调

因为我们这个类型 的bean是BeanFactoryAware接口的。怕你忘了,我再贴一下图

image-20200602094644217

image-20200602094719547

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

image-20200602095018184

applyBeanPostProcessorsBeforeInitialization

在初始化之前应用Bean后处理器

看一看。。。

image-20200602095110943

它是调用所有的后置处理器,调用他们的postProcessBeforeInitialization

所以后置处理器在Aware之后,后置处理器又在初始化之前

我们继续再来看这个3

image-20200602095326410

invokeInitMethods

这个英文简单,执行初始化方法。在哪自己@Bean的时候可以指定初始化方法。

我们还是进去看一下吧:

image-20200602100020139

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

image-20200602100204786

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

image-20200602100316462

也是跟之前的后置处理器一样,一个是Before,一个是After,在初始化的前后。

11.我们还是回到我们的方法栈

之前说它实现了BeanFactoryAware的

image-20200602100532916

image-20200602100600394

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

即:

image-20200602101049725

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

image-20200602101749138

看,调到了AnnotationAwareAspectJAutoProxyCreator

也就是我们要给容器中创建的这个AspectJAutoProxyCreator的这个init方法,

它创建了两个东西,一个ReflectiveAspectJAdvisorFactory反射的AcpectJ工厂,BeanFactoryAspectJAdvisorsBuilderAdapter通知构建器的适配器。相当于把aspectJAdvisorFactory和beanFactory重新包装了一下

那么此时AnnotationAwareAspectJAutoProxyCreator就创建成功,并调用了它的initBeanFactory方法

小结:

image-20200602110043679

2.4- AnnotationAwareAspectJAutoProxy执行时机

上面介绍了AnnotationAwareAspectJAutoProxyCreator就可以拦截到这些创建过程

我们来看一下它作为后置处理器接下来做了什么

来到这里

image-20200602110706471

postProcessBeforeInstantiation

看看BeanPostProcessor呢

image-20200602110747386

postProcessBeforeInitialization

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

image-20200602110939104

image-20200602110957139

image-20200602111024089

注意一下。

那么为什么来到这呢?

image-20200602111119631

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

image-20200602111316858

是从之前的栈桢这里来的

然后是getBean->doGetBean,我们去看一下doGetBean

image-20200602111748656

这个sharedInstance得翻到上面

image-20200602111853837

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

image-20200602112257063

就到了创建bean的createBean,查看bean的一些定义信息

好,下面是AOP的重点!!!,小伙子们打起精神

image-20200602112641687

希望后置处理器在此能返回一个代理对象:

如果能返回这个bean即!=null,它就直接返回。

如果不能,

image-20200602112821983

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

image-20200602113013638

前面内容有了,这里就不赘述了。和3.6流畅一样

我们现在是停到resolveBeforeInstantiation了,我们点进去看一下

后置处理器先尝试返回对象

image-20200602113336903

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

image-20200602113540714

如果说是InstantiationAwareBeanPostProcessor,就调用postProcessBeforeInstantiation方法

区别:BeanPostProcessor是在Bean对象创建完成初始化前后调用

InstantiationAwareBeanPostProcessor书在创建Bean实例之前先尝试用后置处理器返回对象的

不是以前学的postProcessBeforeInitialization

之前说了,我们的AnnotationAwareAspectJAutoProxyCreator就是InstantiationAwareBeanPostProcessor后置处理器

创建Bean,AnnotationAwareAspectJAutoProxyCreator会在任何bean创建之前先尝试返回bean的实例。它在所有bean创建之前会进行拦截,因为它是这个InstantiationAwareBeanPostProcessor后置处理器

image-20200602143306027

小结:

image-20200602143713411

2.5- 创建AOP代理

我们来看看

InstantiationAwareBeanPostProcessor做了什么,我们来重新debug

 AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】

image-20200602143846668

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

再放行

image-20200602144219610

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

image-20200602144407667

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

image-20200602145209906

到了我们的计算器

image-20200602145228503

adviseBeans,已经增强的bean

image-20200602145330724

image-20200602145352529

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

image-20200602145647680

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

image-20200602145723272

即是不是Advice,PointCut,Advisor,AopInfrastructureBean这些接口

点进去看还会判断是否为切面

image-20200602145939243

image-20200602145916600

image-20200602150013202

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

image-20200602150315932

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

image-20200602150402489

findCandidateAdvisors找到候选的增强器

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

image-20200602150526309

第一个:

image-20200602150611155

下一个

image-20200602150630819

下面就展示了,就是4个通知方法

每一个通知方法的增强器是InstantiationModelAwarePointcutAdvisor

image-20200602154719051

最终又调用父类的shouldSkip

接着就到了Initialization

image-20200602155252213

这里有一个

image-20200602155404736

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

image-20200602155735187

这一节建议先自己看多看几遍源码,不然看视频也跟不走

跟之前一样,也是判断是否为isInfrastructureClass等等

image-20200602155956659

findEligibleAdvisors找到可用的增强器

image-20200602160156699

来找到增强其可以应用到beanClass

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

image-20200602160827479

用这个AopUtils来找到这个findAdvisorsThatConApply

来看一下:

image-20200602161056746

先整一个能用的一个LinkedList

通过for循环判断每一个增强器是不是

image-20200602161242503

类型。

image-20200602161315289

下面还有一个for循环

canApply是用来判断是否能用,怎么叫能用呢?我们apply进去

image-20200602161433194

用切面表达式算一下每一个方法是否匹配

找到后还做了一个排序:

image-20200602162801774

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

image-20200602162835062

然后就是这

在这里插入图片描述

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

20200602163127562
把增强器拿到,然后把当前bean已经增强过了,放到缓存里面保存一下

即:如果该bean是需要增强的就会来到这一步

image-20200602163327845

image-20200602163403986

这是获取到的增强器

插入一句image-20200602164512430

直接贴的视频中的图是因为我打断点进入不了视频中的方法,原因在于我没有把它标示为spring项目,导致我的切面并没有真正的识别到方法

当你的方法旁边的提升不是

image-20200602164650081

而是

This advice advises no method就会出现这样的问题

解决方法:

打开Project Strusture

image-20200602164905189

添加就可以了

这个代理对象怎么创建呢?

image-20200602173218614

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

image-20200602173321010

用我们这个代理工程image-20200602192401258来创建对象

来看看这个AOP怎么创建的

返回回来后

image-20200602192526842

image-20200602173407429

先来得到AOP代理的创建工厂,然后创建AOP(为这个this对象)

现在来创建AOP代理

会有两种形式的代理对象

image-20200602192831361

一种JdkDynamicAopProxy,一种是ObjenesisCglibAopProxy

这是spring自动决定

如果这个类是实现接口的能用jdk代理就用jdk代理。如果没有实现,例如我们的MathCalculator就用Cglib。我们也可以强制使用Cglib,这个后面再说

会为我们创建一个代理对象

image-20200602193233863

可以看见是使用Cglib增强的代理

相当于wrap的方法就用完了,给容器返回增强了代理的对象

组件想要执行方法,Cglib就会提枪调用那些我们保存了的通知

以后容器获取到的就是这个组件的代理对象,执行目标方法的时候,这个代理对象就会这个切面通知方法的流程

image-20200602193703020

image-20200602193724811

在bean的创建前后会做一些事情,会判断这个对象是否需要包装,即需要被切入(增强),就会创建代理对象,容器拿到的就是一个代理对象。对象执行方法就是这个代理对象在执行方法。

2.6- 获得拦截器链-MethodInterceptor

来说说目标方法的执行

我们来打上断点进行debug

image-20200602195042707

image-20200602195101713

确定是Cglib增强过的

image-20200602195203850

里面还封装了5个增强器

在这里插入图片描述

比如第一个增强方法他是这个AspectAfterThrowingAdvice

相当于容器中放的这个代理对象放了我们通知方法的信息,切入哪个方法 的信息

在这里插入图片描述

确认MathCalculator类

来到CglibAopProxy.intercept

image-20200602200811474

拦截目标方法的执行(即让AOP代理先来拦截一下)

来看看他的逻辑。这里有一个chain

1.获取拦截器链

image-20200602201117192

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

image-20200602201301273

获取目标方法的拦截器链

image-20200602201417113

如果这个链是空的,就methodProxy.invoke。就是没有拦截器链,直接执行目标方法

如果有,它创建一个CglibMethodInvocation对象,然后调用它的proceed方法,

image-20200602202041266

把这些等等都传入进来

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

image-20200602202502819

我们step into 进来

image-20200602202745406

这些都是缓存,缓存就是保存起来,方便下一次用。

它通过advisorChainFactory的getInterceptorsAndDynamicInterceptionAdvice来获取拦截器链

如果获取到了,就把这个cached返回。怎么获取的呢,我们step into 进去

image-20200602212612436

image-20200602212644850

image-20200602212700159

再返回

所以整个拦截器链被封装在list中

ListinterceptorList保存所有拦截器。注意,list创建的时候已经赋值好了长度

image-20200602221856135

image-20200603101709247

image-20200603101820800

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

我们继续往下走

image-20200603103315435

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

image-20200603105304968

包装成一个interceptors

image-20200603105413372

再加入进来

image-20200603105454246

如果是其他类型,也一样的操作.又或者直接传进来,然后addAll

一句话,遍历所有的增强器,再将其转为interceptor

image-20200603105645957

主要是调用这句话

image-20200603105734260

那么为什么需要转呢

我们来看一下,第一个advisor是

image-20200603110250477

下来,它是这个PointcutAdvisor

在这里插入图片描述

还有一些适配器,做一些转化再加进来

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

image-20200603123521489

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

在这里插入图片描述

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

image-20200603125832249

发现它是这个MethodInterceptor

image-20200603125936719

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

image-20200603130031081

都没满足if的条件,即

image-20200603130124289

然后返回。

再来看看第二个:

image-20200603130242908

是这个AspectJAfterreturningAdvicem,它不是MethodInterceptor

image-20200603130411713

直接来到了for

image-20200603130510308

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

image-20200603130711233

if就没有成功。

再来看第二个AfterReturningAdviceAdapter

image-20200603130746035

image-20200603130829762

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

image-20200603131222692

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

image-20200603131344731

即是这个MethodInterceptor就直接放,不是就给包装过来

第三个后置通知也是直接ok的。

image-20200603131619405

第四个是这个前置通知

image-20200603131643995

前置通知不是,用adapter转换

我们让它全部走完,现在全部转为了

image-20200603131812000

MethodInterceptor

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

image-20200603132207212

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

image-20200603132433834

接下来往下走

image-20200603134012772

new Cglib,

image-20200603134041904

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

小结

image-20200603134659132

2.7- 链式调用通知方法

下面来探究这个proceed方法

记录下拦截器链中有哪些内容

image-20200603135222611

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

image-20200603135400755

image-20200603135552029

之前有讲,进去看一眼

image-20200603140121853

所以我们执行的是CglibMethodInvocaltion的proceed

可以看见,这里有一个索引

image-20200603144824796

image-20200603144901293

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

这个size是什么呢?
image-20200603145015273

正好是这个拦截器。假如没有拦截器链,就相等了。

我们点进去看一下如果没有发生了什么?
image-20200603145129137

image-20200603145211152

其实就为反射创建。method.invoke()

currentInterceptorIndex记录当前拦截器的索引,如果当前是第四个拦截器了,当前索引为4。当前拦截器大小正好是5-1=4

它有两种情况:
1.如果没有拦截器,直接执行目标方法,或者执行拦截器的索引和数组大小-1大小一样(指定到了最后一个拦截器),一会儿来看这个过程。反正currentInterceptorIndex是用来记录索引

image-20200603155834512

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

image-20200603155938280

第0号就是这个ExposeInvocationinterceptor

3.拿到之后怎么做呢?step into

image-20200603160418639

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

image-20200603161019517

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

image-20200603161208761

它是一个ThreadLocal,TreadLocal就是同一条线程共享数据的,它把这个MethodInvocation共享。

第一次还没有共享,所以它把这个MethodInvocation先放进去

image-20200603164515065

放进去后,执行Cglib的proceed

为什么呢,因为是这么过来的,它是Cglibimage-20200603164644716

image-20200603164734893

5.我们继续

image-20200603164814683

咦,同样的流程,只是索引从之前的-1变成了0

它又自增一些,索引为1

image-20200603164919022

image-20200603165027067

即:

image-20200603165115148

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

image-20200603165217874

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

进来,

image-20200603165340735

它又是调这个mi.proceed

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

image-20200603165523024

现在是1了。

image-20200603165545370

自增一个变2

再来看他,

image-20200603165636935

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

image-20200603165730600

那就又是一样了。无限套娃,后面就不掩饰了

也就是责任链模式,你可以点击查看还有其他模式举例

通过链式的方式锁定到下一个拦截器

我们来到MethodBeforeAdviceInterceptor

image-20200603170415273

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

image-20200603170645520

image-20200603170712335

这个interceptor总算做了一些事了

即这个MethodBeforeAdviceInterceptor在invoke的时候是先来调前置通知

它调完了才又进行之前的下一次

现在拦截器的index跟5-1一样长了

我这里直接赋值4了

image-20200603171446331

11.来到了这里,invokeJoinpotint

image-20200603171548852

这个目标方法一执行完就return了

前置通知调完再调用目标方法

image-20200603182943299

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

image-20200603183417962

不管是否有异常,都来执行通知方法,即我们的后置通知,因为这是我们后置通知的拦截器,有点像springMVC中的拦截器

如果方法没有抛异常就来到AfterReturningAdviceInterceptor。只不过我们的方法抛了异常,即1/0,

Returning也不做什么处理的,就抛给上层AspectAfterThrowingAdvice

image-20200603183728249

所以你看来到了AfterThrowingAdvice

image-20200603183756602

我们来看一下AfterReturningAdviceInterceptor

image-20200603183903442

只有你的proceed执行没有问题,它才会执行afterReturning

所以说我们的这个 返回通知 是在方法执行没有问题才执行

这么说:
现在在这里有1/0有错误

image-20200603184212344

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

image-20200603184322356

Throwing这里拿到这个异常

image-20200603184358754

image-20200603184427268

image-20200603184447259

且如果有异常,这个异常就抛出去了。有人处理就处理,没有就抛给虚拟机

这就是我们的AOP流程:

  1. 先来执行我们的前置通知
  2. 执行我们的目标方法
  3. 在执行后置通知
  4. 如果有异常,执行异常通知
  5. 如果没有异常,执行返回通知

image-20200603184704703

再看一下我们的代码

MathCalculator

image-20200603184731945

LogAspects

image-20200603185037975

如果1/1

image-20200603185104068

如果1/0

image-20200603185135896

可以看见有异常AfterReturning就没了

image-20200603200555705

来看这张图理解理解

image-20200603200631349

三、总结

这一节原理还是很多,建议大家还是多看看视频,跟着多debug。下面做一下总结:

我们来看在创建这个容器对象的时候

image-20200603202944993

会调用refresh()刷新容器

image-20200603203026247

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

image-20200603203102325

有一步是注册后置处理器。在这一步会创建后置处理器对象

后面一步就是初始化单实例bean

image-20200603203220302

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

image-20200603203253263

都在这了

组件创建完后就判断是否需要增强(即创建完后有一个postProcessAfterInitialization):

return wrapIfNessary(bean,beanName,cacheKey)来判断是否需要包装(增强)。

是的话就将我们的通知方法包装成增强器(Advisor),给业务逻辑组件创建一个代理对象(Cglib),如果你有接口,它也可以创建jdk动态代理

而代理对象里面就有我们的增强器。代理对象创建完后,我们的容器就创建完了。

执行目标方法其实就是代理对象执行目标方法。它是用CglibAopProxy.intercept()这个方法进行拦截。拦截过程:1.得到目标方法的拦截器链(也就是以前的增强器包装成拦截器MethodInterceptor)。2.利用拦截器的链式机制,依次进入每一个拦截器进行执行。

3.执行效果我们就有两套:

正常执行:前置通知-》目标方法-〉后置通知—》返回通知

出现一次:前置通知-》目标方法-〉后置通知—》异常通知

AOP的源码是spring里较重要的。大家多走几遍,来加深理解。以上只是为大家提供走源代码的一个思路并做下笔记帮助大家加深记忆。

###再来看一下流程
img-20200603223505557

/**
 * 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)、效果:
 *                 正常执行:前置通知-》目标方法-》后置通知-》返回通知
 *                 出现异常:前置通知-》目标方法-》后置通知-》异常通知
开发Spring的过程中出现Eclipse不能识别标签 开发Spring的过程中出现Eclipse不能识别标签,需要引用 spring-tx标签,spring-tx-4.0.xsd 可以解决标签不识别的问题 立即下载

相关推荐

java简单方法顺序调用注解

java提供的注解技术,这里很基础的提供了注解的简单实现样例,SpringMVC采用了很多的注解,基本简单案例展现想了解下注解的同学,对类的方法进行顺序注解后,可以按照注解自动按照顺序调用方法。

aop: This advice advises no methods with annotations

debug了半天,都开始怀疑是不是因为 代理方法的返回值是 object, 而real method的返回值是 List 类型不一致导致的无法找到(虽然这是不可能的,List也是object)原因: https://blog.csdn.net/J080624/article/details/69485899。在写aop的注解后,兴冲冲的放到了real methods上,然后发现并没有执行代理的方法。额,,这个时候就彻底忘记了aop的实现也是 cglib,,

31415926535x的博客 2824

【初阶】手把手教你轻松上手Denodo | 连接数据库并创建基本视图 (二)

在本教程的第二部分,我们将涵盖:连接到数据库,与创建基本视图。

Denodo的博客 1121

记一次使用SpringAOP遇到的问题

记一次使用SpringAOP遇到的问题 1、在需要被切的方法上,加入切点,该方法是使用在service中,需要在Interface中也创建,impl中实现接口。否则调用不到,idea会提示报错:the advice advices no methods; @Override @Pointcut("execution(* com.xxx.methods(java.lang.String)) && args(param)") public void methods(String param){

YongXiong1的博客 2410

硬件开发流程

研发流程在一个有一定规模的企业中起到了非常重要的作用,也是一个产品或者项目成功量产出货依赖的平台体系,作为工程师如果想要走的更远,就必须了解流程体系,了解如何对产品的开发质量进行更好的管控。...

weixin_44126796的博客 8390

ubuntu20.04开机黑屏卡在/dev/sda1:clean,***files,***blocks,解决心得记录

这个问题如果你百度,会发现目前有很多种解决方法。 有更新显卡驱动的,有卸载上一次安装软件的,还有各种奇奇怪怪的故障原因。 如果你是属于上述情况,那么按照百度和论坛的各种指引操作一般都能解决。 但我这里主要说一种特殊情况,就是我什么也没有操作,我什么也没干。就是正常使用系统关了机突然就报错了。 这也是自己亲自遇到的问题,做个小记录方便以后自己回顾。 上一次出现这种情况我重装系统了,这次用了两个月又出现了,重装成本太高,我接受不了,于是找到解决办法。 首先找个终端进入,进入终端的方法很多,用安装u盘

qq_41517017的博客 2万+

透过现象看原理:详解 Spring 中 Bean 的 this 调用导致 AOP 失效的原因

前言在我们使用Spring时,可能有前辈教导过我们,在bean中不要使用this来调用被@Async、@Transactional、@Cacheable等注解标注的方法,this下注解是不生效的。那么大家可曾想过以下问题为何致this调用的方法,注解会不生效这些注解生效的原理又是什么如果确实需要调用本类方法,且还需要注解生效,该怎么做?代理是否可以做到this调用注解就直接生效?通过本文,上面...

qq_39951411的博客 1767

Win11任务栏图标消失?快速恢复指南

任务栏图标消失是Windows 11操作系统中常见的问题之一,但通过上述方法,用户通常可以轻松解决这一问题。无论是重启Windows资源管理器、使用命令提示符修复、检查系统更新和设置,还是考虑重装系统,都可以帮助用户恢复任务栏图标的正常显示。希望本文的介绍能对用户有所帮助,让Windows 11的使用更加顺畅和愉快。

mmoo_python的博客 5416

aop的实现原理_你必须要懂的 Spring:Aop

(给ImportNew加星标,提高Java技能)作者:饭谈编程/稀饭下雪(本文系作者投稿)在实际研发中,Spring是我们经常会使用的框架,毕竟它们太火了,也因此Spring相关的知识点也是面试必问点,今天我们就大话Aop。特地在周末推文,因为该篇文章阅读起来还是比较轻松诙谐的,当然了,更主要的是周末的我也在充电学习,希望有追求的朋友们也尽量不要放过周末时间,适当充电,为了走上人生巅峰,...

weixin_33565558的博客 178

AI 模型训练核心方法论:零基础也能落地的 8 个关键阶段

本文是为 AI 零基础学习者打造的模型训练入门指南,以生活化语言拆解核心概念,规避专业术语壁垒。内容先通俗阐释模型训练、监督学习、数据集划分等基础概念,再按问题定义、数据准备、模型选择、环境搭建、训练、评估、调参、部署 8 个阶段,拆解完整训练流程,搭配 PyTorch 代码示例与实战案例,同时提供资源预算、常见问题解决方案及学习路径。指南强调数据的核心重要性,推荐新手优先使用迁移学习和免费 GPU 资源,兼顾理论与实操,帮助学习者快速上手,避开训练误区,独立完成从模型搭建到部署的全流程。

weixin_52741870的博客 470

AniME框架深度体验:用AI自动生成《修真小说》动画全流程记录

本文详细记录了使用开源多智能体框架AniME,结合其核心动画生成模型AniSora V3,将一段修真小说文本自动转化为风格统一动画视频的全流程实战。文章深入解析了从环境搭建、导演智能体任务分解,到多智能体协作生成分镜、角色、动画及最终合成的每一步操作与挑战,为AI驱动的长视频创作提供了宝贵的实践经验与流程优化思路。

ol789012345的博客 629

AOP实现原理

【转自】http://blog.csdn.net/kaz33/article/details/4545753        面向方面编程(Aspect Oriented Programming,简称AOP)是一种声明式编程(Declarative Programming)。声明式编程是和命令式编程(Imperative Programming)相对的概念。我们平时使用的编程语言,比如C+

zuyi532的专栏 9973

再见 n8n?Google Opal 实测:一句话生成 APP,这才是 AI 的正确打开方式!

Google Opal深度评测:这款自然语言生成工作流的AI工具,通过三个实战案例(科技早报生成器、冰箱食谱助手、爆款文案转译机)展示了其零代码开发的强大能力。它凭借Gemini 3.0 Pro和Google生态的无缝集成,将自动化门槛降至新低,预示着一个“意图驱动开发”的新时代。

莫潇羽的个人博客 856

读懂Spring AOP中通知的执行原理

读懂Spring AOP中通知的执行原理前言定义一个切面执行结果图解通知的执行流程 前言 这个代理类是AOP基于JDK动态代理生成的,当使用代理类调用目标方法时,会执行到org.springframework.aop.framework.JdkDynamicAopProxy#invoke方法中去,后面的调用链也在这里面。 定义一个切面 切面包含了环绕通知(前)、前置通知、增强方法、环绕通知(后、后置通知、带返回值后置通知、异常通知 /** * 增强计算器的切面 */ @Component @Aspect

lq6812574的博客 1039

【微服务】SpringBoot 4.0 新特性整合项目实战应用详解

SpringBoot 4.0 新特性整合项目实战应用详解

congge 4597

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

AOP实现原理:从命令式编程和声明式编程说起

面向方面编程(Aspect Oriented Programming,简称AOP)是一种声明式编程(Declarative Programming)。声明式编程是和命令式编程(Imperative Programming)相对的概念。我们平时使用的编程语言,比如C++、Java、Ruby、Python等,都属命令式编程。命令式编程的意思是,程序员需要一步步写清楚程序需要如何做什么(How to d

我的学习历程 1630

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

简单描述对AOP和IOC的理解

(1) ioc,意思是Inversion ofcontrol,(反转控制),控制反转,就是交换控制权的意思。现在一般不使用这个词,一般使用dependencyinjection(依赖注入)。依赖注入就是将依赖 注入进去。 (2)这么来说吧,在一个动作或者事件中,比如说,你现在想写字(Action),那么你需要笔,于是乎,你new了一个笔来写字,这里,你用了new笔,你这个动作和笔有了关联,没了笔...

qq_38259355的博客 1892

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

C# 12拦截器异常全解析,深度解读编译时AOP的致命短板

深入解析C# 12拦截器异常处理机制,揭示编译时AOP在实际应用中的局限与应对策略。涵盖拦截器的工作原理、异常捕获时机及绕过风险,帮助开发者规避运行时陷阱。掌握这些关键细节,提升代码健壮性,值得收藏。

FastProceed的博客 879

Spring AOP

3.1 Spring AOP简介 3.1.1 什么是AOP 3.1.2 AOP术语 3.2 动态代理 3.3 基于代理类的AOP实现 3.4 AspectJ开发

RuanLiyufei的博客 412

Spring-AOP,JDBCTemplate,事务管理

文章目录AOP底层原理与代码实现AOP(AOP术语)AOP操作(准备)*AOP操作(AsectJ注解方式)AOP操作(AsectJ配置文件方式)JDBCTemplate准备工作JdbcTemplate操作数据库(添加)JdbcTemplate操作数据库(修改和删除)JdbcTemplate操作数据库(三种查询)JdbcTemplate操作数据库(批量操作)事务事例:银行的转账事务操作过程在spring配置文件中配置事务管理器在spring配置文件,开启事务注解在service类的方法上面添加事务注解@Tra

weixin_44919936的博客 702

HoRain云--SpringAOP动态代理原理全解析

摘要: Spring AOP通过动态代理实现横切关注点(如日志、事务)与业务逻辑的分离,核心依赖JDK动态代理(基于接口)和CGLIB动态代理(基于继承)。JDK代理要求目标类实现接口,通过InvocationHandler织入逻辑;CGLIB通过生成子类代理普通类,但无法处理final方法。Spring默认按目标类是否实现接口选择代理方式,但Spring Boot 2.x起强制使用CGLIB以支持更灵活的注解驱动开发。理解两者差异(性能、限制)有助于优化AOP应用及排查问题。

sinat_57153473的博客 413

HoRain云--SpringBoot AOP

本文介绍了面向切面编程(AOP)的概念及其在Spring框架中的应用。AOP通过将跨领域关注点(如日志、安全、验证等)模块化为"切面"来提高代码模块化,避免代码分散。文章详细解析了AOP的核心术语:切面(Aspect)、切入点(Pointcut)、通知(Advice)等,并比较了Spring AOP与AspectJ的差异。重点介绍了五种通知类型:前置通知(Before)、后置通知(After)、环绕通知(Around)等。最后提供了Spring Boot集成AOP所需的依赖配置,为开发者

2401_86544677的博客 762

HoRain云--SpringBoot AOP入门:优雅解耦指南

本文介绍了SpringBoot AOP(面向切面编程)的核心概念和使用方法。AOP通过将横切关注点(如日志、事务、安全等)与核心业务逻辑分离,提升代码的可维护性和整洁度。文章详细讲解了5种通知类型:前置通知(@Before)、后置通知(@After)、返回通知(@AfterReturning)、异常通知(@AfterThrowing)和环绕通知(@Around),并提供了实际应用场景和代码示例。同时,文章还分享了SpringBoot中快速集成AOP的步骤,强调AOP与IoC共同构成了Spring框架的两大核

2401_86544677的博客 881

Spring AOP 和IOC是什么,分别的使用场景

Spring AOP 和IOC是什么,分别的使用场景 AOP:面向切面编程。 即在一个功能模块中新增其他功能,比方说你要下楼取个快递,你同事对你说帮我也取一下呗,你就顺道取了。在工作中如果系统中有些包和类中没有使用AOP,例如日志,事务和异常处理,那么就必须在每个类和方法中去实现它们。 代码纠缠每个类和方法中都包含日志,事务以及异常处理甚至是业务逻辑。在一个这样的方法中,很难分清代码中实际做的是什么处理。AOP 所做的就是将所有散落各处的事务代码集中到一个事务切面中。 场景 比方说我现在要弄一个日志,记录某

m0_49229693的博客 7420
上一篇: JVM详解(八)堆空间
下一篇: 反射方法 的简单使用
修理工皮师傅
博客等级 码龄11年 128粉丝 19原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址