【方舟透视源码】【在线建站平台+源码】【c# 源码大全】spring aop的源码解析_spring aop 源码解析

2024-11-25 05:48:49 来源:element源码视频 分类:时尚

1.spring aop代理对象创建以及调用invoke源码
2.76 张图,源码p源剖析 Spring AOP 源码,解析小白居然也能看懂,码解大神,源码p源请收下我的解析膝盖!
3.谈谈对springaop的理解?
4.spring—AOP与事务
5.如何理解Spring的AOP?
6.Spring注解驱动开发二狗子让我给他讲讲@EnableAspectJAutoProxy注解

spring aop的源码解析_spring aop 源码解析

spring aop代理对象创建以及调用invoke源码

       深入解析Spring AOP代理对象创建及调用invoke源码

       一、代理对象创建与invoke源码概览

       1.1 代理对象创建源码概览

       Spring AOP代理对象的源码p源创建时机主要在实例化后或初始化后。具体流程涉及BeanPostProcessor.postProcessAfterInitialization()方法。解析正常情况下,码解代理对象创建与单例池内的源码p源代理对象一致,确保方法调用实际指向代理对象。解析

       1.2 invoke执行目标方法源码概览

       目标对象方法调用后,码解因为代理对象存储于单例池,源码p源实际调用的解析是代理对象的增强方法。这种方式实现了方法调用的码解动态代理。

       1.3 exposeProxy = true使用说明

       1.3.1 不使用(exposeProxy = true)

       不使用配置时,目标方法内部调用被拦截增强的方法,不会再次触发AOP。

       1.3.2 使用(exposeProxy = true)

       启用此配置后,执行目标方法时,AOP增强将再次激活,从而触发重复执行。

       1.3.3 cglib与JDK代理区别

       cglib通过继承实现代理,方法调用指向代理对象,因此内嵌方法会重复调用增强逻辑;

       JDK代理通过反射,方法调用直接指向目标对象,内嵌方法不会重复调用。

       关于Spring中cglib不会重复调用的解释:测试表明,使用Spring5.版本,强制使用cglib配置时,案例中方法调用与代理对象方法调用之间并无重复,原因是Spring调用的是目标方法而非代理对象的方法。

       二、代理对象创建及invoke源码分析图

       代理创建流程始于@EnableAspectJAutoProxy注解注册的在线建站平台+源码AspectJAutoProxyRegistrar,此注册器在解析import注解时执行registerBeanDefinitions方法。该方法注册了在bean实例化前调用的InstantiationAwareBeanPostProcessor类型的bean后置处理器,此处理器在实例化前解析AOP,非循环依赖在初始化后调用postProcessAfterInitialization()创建动态代理。

       匹配Advisor集合:首先筛选Advisor列表,匹配规则涉及类级别和方法级别的筛选,通过Aspect匹配实现。同时,Advisor排序确保调用顺序遵循通知类型。创建代理对象遵循ProxyTargetClass参数与目标类接口的配置,选择JDK或cglib动态代理。

       代理方法调用:由于存储的是代理对象,方法调用实际指向代理。exposeProxy = true配置下,代理对象暴露到线程变量中。代理对象执行方法调用遵循责任链模式,按顺序执行前置、目标方法、后置等通知。

张图,剖析 Spring AOP 源码,小白居然也能看懂,大神,请收下我的膝盖!

       本文将简要介绍AOP(面向切面编程)的基础知识与使用方法,并深入剖析Spring AOP源码。首先,我们需要理解AOP的基本概念。

       1. **基础知识

**

       1.1 **什么是AOP?

**

       AOP全称为Aspect Oriented Programming,即面向切面编程。AOP的思想中,周边功能(如性能统计、日志记录、c# 源码大全事务管理等)被定义为切面,核心功能与切面功能独立开发,然后将两者“编织”在一起,这就是AOP的核心。

       AOP能够将与业务无关、却为业务模块共同调用的逻辑封装,减少系统重复代码,降低模块间的耦合度,有利于系统的可扩展性和可维护性。

       1.2 **AOP基础概念

**

       解释较为官方,以下用“方言”解释:AOP包括五种通知分类。

       1.3 **AOP简单示例

**

       创建`Louzai`类,添加`LouzaiAspect`切面,并在`applicationContext.xml`中配置。程序入口处添加`"睡觉"`方法并添加前置和后置通知。接下来,我们将探讨Spring内部如何实现这一过程。

       1.4 **Spring AOP工作流程

**

       为了便于理解后面的源码,我们将整体介绍源码执行流程。整个Spring AOP源码分为三块,结合示例进行讲解。

       第一块是前置处理,创建`Louzai`Bean前,遍历所有切面信息并存储在缓存中。第二块是后置处理,创建`Louzai`Bean时,主要处理两件事。第三块是执行切面,通过“责任链+递归”执行切面。

       2. **源码解读

**

       注意:Spring版本为5.2..RELEASE,否则代码可能不同!这里,我们将从原理部分开始,安卓源码_基带逐步深入源码。

       2.1 **代码入口

**

       从`getBean()`函数开始,进入创建Bean的逻辑。

       2.2 **前置处理

**

       主要任务是遍历切面信息并存储。

       这是重点!请务必注意!获取切面信息流程结束,后续操作都从缓存`advisorsCache`获取。

       2.2.1 **判断是否为切面

**

       执行逻辑为:判断是否包含切面信息。

       2.2.2 **获取切面列表

**

       进入`getAdvice()`,生成切面信息。

       2.3 **后置处理

**

       主要从缓存拿切面,与`Louzai`方法匹配,创建AOP代理对象。

       进入`doCreateBean()`,执行后续逻辑。

       2.3.1 **获取切面

**

       首先,查看如何获取`Louzai`的切面列表。

       进入`buildAspectJAdvisors()`,方法用于存储切面信息至缓存`advisorsCache`。随后回到`findEligibleAdvisors()`,从缓存获取所有切面信息。

       2.3.2 **创建代理对象

**

       有了`Louzai`的切面列表,开始创建AOP代理对象。

       这是重点!请仔细阅读!这里有两种创建AOP代理对象方式,我们选择使用Cglib。

       2.4 **切面执行

**

       通过“责任链+递归”执行切面与方法。

       这部分逻辑非常复杂!接下来是“执行切面”最核心的逻辑,简述设计思路。

       2.4.1 **第一次递归

**

       数组第一个对象执行`invoke()`,手表商城源码购买参数为`CglibMethodInvocation`。

       执行完毕后,继续执行`CglibMethodInvocation`的`process()`。

       2.4.2 **第二次递归

**

       数组第二个对象执行`invoke()`。

       2.4.3 **第三次递归

**

       数组第三个对象执行`invoke()`。

       执行完毕,退出递归,查看`invokeJoinpoint()`执行逻辑,即执行主方法。回到第三次递归入口,继续执行后续切面。

       切面执行逻辑已演示,直接查看执行方法。

       流程结束时,依次退出递归。

       2.4.4 **设计思路

**

       这部分代码研究了大半天,因为这里不是纯粹的责任链模式。

       纯粹的责任链模式中,对象内部有一个自身的`next`对象,执行当前对象方法后,启动`next`对象执行,直至最后一个`next`对象执行完毕,或中途因条件中断执行,责任链退出。

       这里`CglibMethodInvocation`对象内部无`next`对象,通过`interceptorsAndDynamicMethodMatchers`数组控制执行顺序,依次执行数组中的对象,直至最后一个对象执行完毕,责任链退出。

       这属于责任链,实现方式不同,后续会详细剖析。下面讨论类之间的关系。

       主对象为`CglibMethodInvocation`,继承于`ReflectiveMethodInvocation`,`process()`的核心逻辑在`ReflectiveMethodInvocation`中。

       `ReflectiveMethodInvocation`的`process()`控制整个责任链的执行。

       `ReflectiveMethodInvocation`的`process()`方法中,包含一个长度为3的数组`interceptorsAndDynamicMethodMatchers`,存储了3个对象,分别为`ExposeInvocationInterceptor`、`MethodBeforeAdviceInterceptor`、`AfterReturningAdviceInterceptor`。

       注意!这3个对象都继承了`MethodInterceptor`接口。

       每次`invoke()`调用时,都会执行`CglibMethodInvocation`的`process()`。

       是否有些困惑?别着急,我将再次帮你梳理。

       对象与方法的关系:

       可能有同学疑惑,`invoke()`的参数为`MethodInvocation`,没错!但`CglibMethodInvocation`也继承了`MethodInvocation`,可自行查看。

       执行逻辑:

       设计巧妙之处在于,纯粹的责任链模式中,`next`对象需要保证类型一致。但这里3个对象内部没有`next`成员,不能直接使用责任链模式。怎么办呢?就单独设计了`CglibMethodInvocation.process()`,通过无限递归`process()`实现责任链逻辑。

       这就是我们为什么要研究源码,学习优秀的设计思路!

       3. **总结

**

       本文首先介绍了AOP的基本概念与原理,通过示例展示了AOP的应用。之后深入剖析了Spring AOP源码,分为三部分。

       本文是Spring源码解析的第三篇,感觉是难度较大的一篇。图解代码花费了6个小时,整个过程都沉浸在代码的解析中。

       难度不在于抠图,而是“切面执行”的设计思路,即使流程能走通,将设计思想总结并清晰表达给读者,需要极大的耐心与理解能力。

       今天的源码解析到此结束,有关Spring源码的学习,大家还想了解哪些内容,欢迎留言给楼仔。

谈谈对springaop的理解?

       Spring的AOP如何理解,在业务里的作用是什么?

       1、AOP编程的支持通过Spring提供的AOP功能,方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

       2、AOP:面向切面,是一种编程思想,OOP的延续。将系统中非核心的业务提取出来,进行单独处理。比如事务、日志和安全等。这个简单来说就是可以在一段程序之前或者之后做一些事。

       3、定义增强处理,增强处理就是在AOP框架为普通业务组件织入的处理动作所以进行AOP编程的关键就是定义切入点和定义增强处理,一旦定义了合适的切入点和增强处理,AOP框架将自动生成AOP代理,即:代理对象的方法=增强处理+被代理对象的方法。

       Spring中的AOP怎么理解

       åˆ‡é¢ç¼–程,就是在你项目原有的功能基础上,通过AOP去添加新的功能,这些功能是建立在原有功能的基础上的,而且原有的功能并不知道你已经添加了新的功能。

       IoC就是对象的创建,依赖都由Spring及配置文件控制;AOP就是统一的给一些类似的方法加上同样的功能,比如日志,事务。Spring框架是一个分层架构,由7个定义良好的模块组成。

       åœ¨AOP中有几个概念:—方面(Aspect):一个关注点的模块化,这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的Advisor或拦截器实现。

       AOP:面向切面,是一种编程思想,OOP的延续。将系统中非核心的业务提取出来,进行单独处理。比如事务、日志和安全等。这个简单来说就是可以在一段程序之前或者之后做一些事。

       SpringAOP是编程框架AOP是OOP的延续,是AspectOrientedProgramming的缩写,意思是面向方面编程。AOP实际是GoF设计模式的延续,设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,AOP可以说也是这种目标的一种实现。

       æœ¬äººæš‚且把Spring中的AOP理解成一种方法的拦截器(可能有所片面,主要是方便理解)。个人通俗理解,就好比你去自动取款机取钱,边上装了个摄像头在监视着。

请你谈谈对spring的理解?

       spring的基本意思是“春天,春季”,引申可指“青春”。spring还可作“跳”“跳跃”解,引申可指“弹簧,发条”“泉水”,是可数名词。spring跟带有延续性的介词时,前面要加定冠词the。

       Spring是一个开放源代码的J2EE应用程序框架,由RodJohnson发起,是针对bean的生命周期进行管理的轻量级容器(lightweightcontainer)。

       Spring框架概述Core封装包是框架的最基础部分,提供IoC和依赖注入特性。这里的基础概念是BeanFactory,它提供对Factory模式的经典实现来消除对程序性单例模式的需要,并真正地允许你从程序逻辑中分离出依赖关系和配置。

简述你对Spring框架IOC和AOP的理解。

       IoC就是对象的创建,依赖都由Spring及配置文件控制;AOP就是统一的给一些类似的方法加上同样的功能,比如日志,事务。Spring框架是一个分层架构,由7个定义良好的模块组成。

       ioc就是控制反转,可以理解为当spring被加载启动后,在spring配置的bean都会被这个框架预先实例化(作用于为单例),然后在你需要的这个对象的时候直接添加注入就可以调用这个对象了这样可以大大降低了类之间的耦合度。

       AOP:面向切面,是一种编程思想,OOP的延续。将系统中非核心的业务提取出来,进行单独处理。比如事务、日志和安全等。这个简单来说就是可以在一段程序之前或者之后做一些事。

       AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。

       æˆ‘的理解ioc就是自动创建对象的过程。以前是随时用,随时new,用了ioc就将这个事件交给程序,自动动创建对象。aop就是事物的控制,比如一个提交操作没有完成,则自动回滚。

       è¿™ä¸ªç¬¬ä¸‰æ–¹æŒ‡çš„就是Spring的容器。IoC另解,依赖注入(DependencyInjection),调用类对被调用类的依赖关系由第三方注入,以移除调用类对被调用类的引用。

spring—AOP与事务

        title: spring——AOP与事务.md

        date: -- ::

        categories: [Spring]

        tags: [AOP,事务]

        toc: true

        先列出源码中比较重点的几个类:

        1、<aop:before method="before" pointcut-ref="myMethods"/>包装成一个advisor

        2、AspectJAwareAdvisorAutoProxyCreator,当实例化所有bean都会执行到AspectJAwareAdvisorAutoProxyCreatorç±»

        它会检测bean是否advisor以及advice存在,如果有就说明这个bean有切面,有切面那么就会生成代理

        3、jdk的代理,bean里面的所有advisor加入到proxyFactory。

        4、jdkDynamicProxy invoke,拿到bean里面的所有Interceptor,会循环proxyFactory里面的所有advisor

        里面有advice,里面的advice有两种类型,要么是advice,要么是MethodInterceptor类型的

        5、当代理对象调用方式,是一个MethodInterceptor类型的类的链式调用过程,直到容器的大小和索引一致的时候调用JoinPoint目标方法

        before:this.advice.before(),invocation.processd();

        装配参数,切面里面before方法的method对象,method.getParamterTypes()[0]

        最终会把advice封装成MethodInterceptor类型的对象

        程序执行的某个特定位置:如类开始初始化前、类初始化后、类某个方法调用前、调用后、方法抛出异常后。一个类或一段程序代码拥有一些具有边界性质的特定点,这些点中的特定点就称为“连接点”。Spring仅支持方法的连接点,即仅能在方法调用前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行点织入增强。连接点由两个信息确定:第一是用方法表示的程序执行点;第二是用相对点表示的方位。

        每个程序类都拥有多个连接点,如一个拥有两个方法的类,这两个方法都是连接点,即连接点是程序类中客观存在的事物。AOP通过“切点”定位特定的连接点。连接点相当于数据库中的记录,而切点相当于查询条件。切点和连接点不是一对一的关系,一个切点可以匹配多个连接点。在Spring中,切点通过org.springframework.aop.Pointcut接口进行描述,它使用类和方法作为连接点的查询条件,Spring AOP的规则解析引擎负责切点所设定的查询条件,找到对应的连接点。其实确切地说,不能称之为查询连接点,因为连接点是方法执行前、执行后等包括方位信息的具体程序执行点,而切点只定位到某个方法上,所以如果希望定位到具体连接点上,还需要提供方位信息。

        增强是织入到目标类连接点上的一段程序代码,在Spring中,增强除用于描述一段程序代码外,还拥有另一个和连接点相关的信息,这便是执行点的方位。结合执行点方位信息和切点信息,我们就可以找到特定的连接点。

        增强逻辑的织入目标类。如果没有AOP,目标业务类需要自己实现所有逻辑,而在AOP的帮助下,目标业务类只实现那些非横切逻辑的程序逻辑,而性能监视和事务管理等这些横切逻辑则可以使用AOP动态织入到特定的连接点上。

        引介是一种特殊的增强,它为类添加一些属性和方法。这样,即使一个业务类原本没有实现某个接口,通过AOP的引介功能,我们可以动态地为该业务类添加接口的实现逻辑,让业务类成为这个接口的实现类。

        织入是将增强添加对目标类具体连接点上的过程。AOP像一台织布机,将目标类、增强或引介通过AOP这台织布机天衣无缝地编织到一起。根据不同的实现技术,AOP有三种织入的方式:

        a、编译期织入,这要求使用特殊的Java编译器。

        b、类装载期织入,这要求使用特殊的类装载器。

        c、动态代理织入,在运行期为目标类添加增强生成子类的方式。

        Spring采用动态代理织入,而AspectJ采用编译期织入和类装载期织入。

        一个类被AOP织入增强后,就产出了一个结果类,它是融合了原类和增强逻辑的代理类。根据不同的代理方式,代理类既可能是和原类具有相同接口的类,也可能就是原类的子类,所以我们可以采用调用原类相同的方式调用代理类。

        切面由切点和增强(引介)组成,它既包括了横切逻辑的定义,也包括了连接点的定义,Spring AOP就是负责实施切面的框架,它将切面所定义的横切逻辑织入到切面所指定的连接点中。

        advisor: pointCut advice

        一类功能的增强

        around方法里面代码切面

        事务切面

        缓存切面

        日志切面

        事务(Transaction),一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。是数据库操作的最小工作单元,是作为单个逻辑工作单元执行的一系列操作;这些操作作为一个整体一起向系统提交,要么都执行、要么都不执行;事务是一组不可再分割的操作集合(工作逻辑单元)。

        大致流程形如

        数据库事务拥有几大特性:

        事务的四大特性:

        事务是数据库的逻辑工作单位,事务中包含的各操作要么都做,要么都不做

        事 务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。因此当数据库只包含成功事务提交的结果时,就说数据库处于一致性状态。如果数据库系统 运行中发生故障,有些事务尚未完成就被迫中断,这些未完成事务对数据库所做的修改有一部分已写入物理数据库,这时数据库就处于一种不正确的状态,或者说是 不一致的状态。

        一个事务的执行不能其它事务干扰。即一个事务内部的操作及使用的数据对其它并发事务是隔离的,并发执行的各个事务之间不能互相干扰。

        也称永久性,指一个事务一旦提交,它对数据库中的数据的改变就应该是永久性的。接下来的其它操作或故障不应该对其执行结果有任何影响。

        个人理解,事务在Spring中是借助AOP技术来实现的,可以作为AOP中的一个事务切面。spring源码对事务的处理逻辑,自己研究吧!

        ORM框架中以Mybatis为例,事务处理就是用到了一个类Transaction,部分源码如下

        可以看出Transaction管理的就是一个connection,而connection我们很清楚是与用户会话挂钩的。

        那么关系就是Transaction 管理Connection ,而connection与 用户session一对一存在。

        在springBoot中,只需要加入POM就可以了,配合注解使用即可。

        接下来就是事务的控制了。

        首先事务有几大传播属性:

        其中最常见的,用得最多就 PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、 PROPAGATION_NESTED 这三种。事务的传播属性是 spring 特有的,是 spring 用来控制方法事务的一种手段,说直白点就是用来控制方法是否使用同一事务的一种属性,以及按照什么规则回滚的一种手段。

        下面用代码演示这三种属性的机制:

        事务的默认属性就是required,通过Transactional.java中的Propagation propagation() default Propagation.REQUIRED; 可以看出。

        这种情况就是事务1,事务2 都加入到了事务0中。不管是1,2哪个事务抛出异常,事务0都会回滚。数据添加会失败。

        这种情况就是:

        事务0(required) {

        ​ 事务1 (REQUIRES_NEW)

        ​ 事务2

        }

        此时。

        情况a:

        1、如果只是事务2出现了异常,那么事务1会提交,事务2加入到事务0中会回滚。

        2、如果只是事务1出现了异常,那么事务1会回滚,向上层事务0抛异常,事务2会加入到事务0中,这时都会回滚。

        情况b:

        如果事务1,事务2都是REQUIRES_NEW传播属性。那么结果就是:

        1、如果事务1,抛出了异常,那么事务2是不会执行的,那么事务0必然回滚。

        2、如果事务2,抛出异常,那么事务1会提交,表中会有数据。事务2有异常回滚并抛出,事务0回滚。

        NESTED属性其实就是创建了回滚点,有异常时,会回滚到指定的回滚点。

        在这通过代码测试,出现一种情况是,无论事务1,事务2哪个有异常,数据都不会插入成功,原因是,不论是事务1还是事务2都会向事务0抛出异常,事务0捕获到异常后,执行rollback()方法,这就操作成了,事务的全部回滚。

        如果想要事务1和事务2 想要根据自己的回滚点回滚,那么事务0必须自己处理异常,不让spring捕获到这个异常,那么就满足了。把代码改成这种:

        Jack大佬提供了,伪代码分析法。

        按照Spring源码的事务处理逻辑,伪代码大致为:

如何理解Spring的AOP?

       Spring的AOP面向切面编程,就是横向的,比如程序运行时都要建日志,相当于SQL的触发器。

       Spring是一个开放源代码的设计层面框架,他解决的是业务逻辑层和其他各层的松耦合问题,因此它将面向接口的编程思想贯穿整个系统应用。Spring是于 年兴起的一个轻量级的Java 开发框架,由Rod Johnson创建。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式) è½»é‡çº§å¼€æºæ¡†æž¶ã€‚

       Spring特点:

       1、方便解耦,简化开发

       é€šè¿‡Spring提供的IoC容器,我们可以将对象之间的依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合。有了Spring,用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。

       2、AOP编程的支持

       é€šè¿‡Spring提供的AOP功能,方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

       3、声明式事务的支持

       åœ¨Spring中,我们可以从单调烦闷的事务管理代码中解脱出来,通过声明式方式灵活地进行事务的管理,提高开发效率和质量。

       4、方便程序的测试

       å¯ä»¥ç”¨éžå®¹å™¨ä¾èµ–的编程方式进行几乎所有的测试工作,在Spring里,测试不再是昂贵的操作,而是随手可做的事情。例如:Spring对Junit4支持,可以通过注解方便的测试Spring程序。

       5、方便集成各种优秀框架

       Spring不排斥各种优秀的开源框架,相反,Spring可以降低各种框架的使用难度,Spring提供了对各种优秀框架(如Struts,Hibernate、Hessian、Quartz)等的直接支持。

       6、降低Java EE API的使用难度

       Spring对很多难用的Java EE API(如JDBC,JavaMail,远程调用等)提供了一个薄薄的封装层,通过Spring的简易封装,这些Java EE API的使用难度大为降低。

       7、Java 源码是经典学习范例

       Spring的源码设计精妙、结构清晰、匠心独运,处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。Spring框架源码无疑是Java技术的最佳实践范例。如果想在短时间内迅速提高自己的Java技术水平和应用开发水平,学习和研究Spring源码将会使你收到意想不到的效果。

Spring注解驱动开发二狗子让我给他讲讲@EnableAspectJAutoProxy注解

       在配置类上添加@EnableAspectJAutoProxy注解,能够开启注解版的AOP功能。这意味着,如果在AOP中要启用注解版的AOP功能,就需要在配置类上添加@EnableAspectJAutoProxy注解。让我们来看看@EnableAspectJAutoProxy注解的源码,如下所示。

       从源码可以看出,@EnableAspectJAutoProxy注解使用@Import注解引入了AspectJAutoProxyRegister.class对象。那么,AspectJAutoProxyRegistrar是做什么的呢?我们点击到AspectJAutoProxyRegistrar类的源码中,如下所示。

       可以看到AspectJAutoProxyRegistrar类实现了ImportBeanDefinitionRegistrar接口。我们回顾ImportBeanDefinitionRegistrar接口的定义,如下所示。

       通过ImportBeanDefinitionRegistrar接口,我们可以实现将自定义的组件添加到IOC容器中。也就是说,@EnableAspectJAutoProxy注解使用AspectJAutoProxyRegistrar对象自定义组件,并将相应的组件添加到IOC容器中。

       在AspectJAutoProxyRegistrar类的registerBeanDefinitions()方法中设置断点,我们以debug的方法来运行AopTest类的testAop()方法。当程序运行到断点位置时,我们可以看到程序已经暂停,IDEA的左下角显示了方法的调用栈。

       在registerBeanDefinitions()方法中,首先调用AopConfigUtils类的registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法来注册registry。在registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法中,直接调用了重载的registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法。在重载的registerAspectJAnnotationAutoProxyCreatorIfNecessary()方法中,传入了AnnotationAwareAspectJAutoProxyCreator.class对象。

       在registerOrEscalateApcAsRequired()方法中,接收到的Class对象的类型为:org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator。然后,我们继续跟进代码。

       在registerOrEscalateApcAsRequired()方法中,首先判断registry是否包含org.springframework.aop.config.internalAutoProxyCreator类型的bean。接下来,我们继续看代码。

       最终,AopConfigUtils类的registerOrEscalateApcAsRequired()方法中,会通过registry调用registerBeanDefinition()方法注册组件,并注册的bean的名称为org.springframework.aop.config.internalAutoProxyCreator。

       接下来,我们继续看AspectJAutoProxyRegistrar类的registerBeanDefinitions()源码。我们通过AnnotationConfigUtils类的attributesFor方法来获取@EnableAspectJAutoProxy注解的信息。接下来,我们继续判断proxyTargetClass属性的值是否为true,如果为true则调用AopConfigUtils类的forceAutoProxyCreatorToUseClassProxying()方法;继续判断exposeProxy属性的值是否为true,如果为true则调用AopConfigUtils类的forceAutoProxyCreatorToExposeProxy()方法。

       综上所述,向Spring的配置类上添加@EnableAspectJAutoProxy注解后,会向IOC容器中注册AnnotationAwareAspectJAutoProxyCreator。

       了解了这些之后,我们就可以关注「冰河技术」微信公众号,后台回复不同的关键字获取相应的PDF文档。这些文档都是由冰河原创并整理的超硬核教程,包括《深入浅出Java 种设计模式》、《Java8新特性教程》和《亿级流量下的分布式限流解决方案》,都是面试必备的资料。

       最后,如果你觉得这篇文章对你有帮助,别忘了点个赞,给个在看和转发,让更多的人看到,一起学习,一起进步!

Spring源码插播一个创建代理对象的wrapIfNecessary()方法

       在深入探讨Spring源码中创建代理对象的`wrapIfNecessary()`方法之前,先简要回顾其作用。`wrapIfNecessary()`方法主要任务是基于一系列条件判断,决定是否为Bean创建代理对象,从而实现AOP(面向切面编程)的功能。下面,我们将逐步解析这一方法的内部逻辑。

       `wrapIfNecessary()`方法的执行流程可以分为以下阶段:

       1. **条件判断**:

        - **已处理Bean**:首先检查传入的Bean是否已处理过,即在`targetSourcedBeans`集合中是否存在该Bean的记录。

        - **已创建代理**:接着检查`advisedBeans`集合中是否已有该Bean的代理对象缓存,以确认是否需要再次创建代理。

        - **自定义Bean**:通过`isInfrastructureClass()`方法判断是否为Spring自带的Bean,排除此类无需代理的情况。

        - **无需代理**:如果上述任一条件满足,则直接返回传入的Bean对象,无需创建代理。

       2. **代理创建**:

        - **获取Advices和Advisors**:如果上述条件均不满足,则调用`getAdvicesAndAdvisorsForBean()`方法获取当前Bean的Advices和Advisors信息。

        - **判断适配**:通过`findEligibleAdvisors()`方法从候选通知器中筛选出适合当前Bean的Advisors,确保这些Advisors可以应用到当前Bean。

        - **实现逻辑**:通过`findCandidateAdvisors()`和`findAdvisorsThatCanApply()`方法进一步筛选、拓展、排序Advisors,最终获取到实际需要应用的Adviser集合。

       3. **代理构建**:

        - **决策**:根据获取的Advisors判断是否需要创建代理。若结果非`DO_NOT_PROXY`,则调用`createProxy()`方法创建代理对象,并缓存以备后续使用。

        - **过程**:在创建代理过程中,`exposeTargetClass()`方法设置Bean的属性,`shouldProxyTargetClass()`方法决定使用JDK动态代理还是CGLIB动态代理,`evaluateProxyInterfaces()`方法添加代理接口,最终通过`getProxy()`方法构建代理对象。

       4. **优化与扩展**:

        - **Advisors排序**:调用`sortAdvisors()`方法对Advisors进行排序,优化代理逻辑执行顺序。

        - **扩展与定制**:通过`extendAdvisors()`方法提供扩展点,允许对目标Advisor进行进一步定制。

       5. **构建代理对象**:

        - **代理工厂**:通过`AopProxyFactory`初始化代理工厂,并在构建代理对象时,考虑接口添加、回调函数配置等,最终通过`createProxy()`方法生成可调用的代理对象。

       通过这一系列复杂而有序的过程,`wrapIfNecessary()`方法实现了根据特定条件判断是否创建代理对象,并构建出适用于面向切面编程场景的代理对象,进而增强了应用程序的功能性和灵活性。

本文地址:http://5o.net.cn/news/4e45599540.html 欢迎转发