基于注解的Spring-Aop原理

最新推荐文章于 2023-09-07 11:29:02 发布
最新推荐文章于 2023-09-07 11:29:02 发布
阅读量107 收藏
点赞数
文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37735779/article/details/120353220
版权 
在容器创建完成后，会进行刷新容器（refresh()），在容器刷新时会有一步是将Bean定义保存起来
//xxxRegistrar一般是在其中手动注册一些组件，再通过@import导入到容器中；
@EnableAspectJAutoProxy
 * @Import(AspectJAutoProxyRegistrar.class)
 * 1.(beanName)internalAutoProxyCreator = AnnotationAwareAspectJAutoProxyCreator(组件类型)
 * 	利用AspectJAutoProxyRegistrar自定义给容器创建bean；
 * 	给容器中注册一个组件AnnotationAwareAspectJAutoProxyCreator；
 * 2.AnnotationAwareAspectJAutoProxyCreator：
 * 
 * 
 * 		继承==>AspectJAwareAdvisorAutoProxyCreator
 * 			==>AbstractAdvisorAutoProxyCreator
 * 				==>AbstractAutoProxyCreator
 * 						implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
 * 关注后置处理器(在bean初始化前后做的工作)、自动装配BeanFactory
 * AbstractAutoProxyCreator.setBeanFactory()
 * AbstractAutoProxyCreator有后置处理器的逻辑--postProcessBeforeInstantiation--postProcessAfterInitialization
 * 
 * AbstractAdvisorAutoProxyCreator.setBeanFactory()包含-->initBeanFactory()
 * 
 * AnnotationAwareAspectJAutoProxyCreator.initBeanFactory()
 * 
 * 流程：
 * 1）、传入配置类，创建ioc容器
 * 2）、注册配置类，调用refresh()刷新容器，即是初始化容器
 * 3）、registerBeanPostProcessors(beanFactory)注册bean的后置处理器方便拦截bean的创建
 * 		1.先获取ioc容器中已经定义了的需要创建对象的BeanPostProcessor;其中有一个internalAutoProxyCreator组件，我们只是定义了BeanDefinition，还没有创建对象
 * 		2.给容器中加其他的BeanPostProcessor
 * 		3.优先注册实现了PriorityOrdered接口的处理器
 * 		4.再给容器中注册实现了Ordered接口的处理器
 * 		5.注册没有实现优先级接口的处理器
 * 		6.注册BeanPostProcessor，实际上就是创建BeanPostProcessor对象，保存在容器中
 * 			创建internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】
 * 			1.创建bean的实例
 * 			2.populateBean：给bean的各种属性赋值
 * 			3.initializeBean：初始化bean【internalAutoProxyCreator】
 * 				1.invokeAwareMethods()：处理Aware接口的回调，即判断bean实现了Aware接口的哪种接口	
 * 				2.applyBeanPostProcessorsBeforeInitialization()：应用后置处理器的postProcessBeforeInitialization()
 * 				3.invokeInitMethods()：执行自定义的初始化方法
 * 				4.applyBeanPostProcessorsAfterInitialization()：应用后置处理器的postProcessAfterInitialization()
 * 
 * 			4.BeanPostProcessor[AnnotationAwareAspectJAutoProxyCreator]创建成功
 * 
 * 		7.把BeanPostProcessor注册到BeanFactory中：->registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors)
 * 												->beanFactory.addBeanPostProcessor(postProcessor);
 * 	===========以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程==============
 * 	 AnnotationAwareAspectJAutoProxyCreator=>InstantiationAwareBeanPostProcessor（类型）
 * 	4）、finishBeanFactoryInitialization(beanFactory)：完成BeanFactory初始化工作，创建剩下的单实例Bean
 *		1.遍历获取容器中所有的bean，依次创建对象getBean(beanName);	
 * 			getBean(beanName)=>doGetBean()=>getSingleton()=>createBean();
 * 			
 * 		2. 创建bean 
 * 			【前面知道AnnotationAwareAspectJAutoProxyCreator是InstantiationAwareBeanPostProcessor类型的】
 * 			【AnnotationAwareAspectJAutoProxyCreator在创建bean实例之前会被拦截，InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()】
 * 			1. 先从缓存中获取bean，如果能获取到，说明bean之前被创建过的，直接使用；否则调用createBean()创建bean实例
 *			只要创建好的bean都会被缓存起来
 *			【BeanPostProcessor是在bean对象创建完成初始化前后调用的】
 *			【InstantiationAwareBeanPostProcessor是在创建对象之前先尝试用后置处理器返回对象的】
 *				1）、后置处理器先尝试返回对象
 *					bean = applyBeanPostProcessorsBeforeInstantiation();
 *						applyBeanPostProcessorsBeforeInstantiation()中先拿到所有的后置处理器，如果是InstantiationAwareBeanPostProcessor类型的，
 *						就执行postProcessBeforeInstantiation()：会在下章1.1详细讲到
 *					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
 * 			2. createBean()：创建bean->AnnotationAwareAspectJAutoProxyCreator会在任何bean创建之前先尝试返回bean的实例
 * 				1. resolveBeforeInstantiation():解析BeforeInstantiation
 * 					希望后置处理器能够在此返回一个代理对象，如果能返回就返回，如果不能就继续
 * 				2. doCreateBean(beanName, mbdToUse, args);真正创建一个bean实例；和3.6流程一样
 * 	【会循环的验证并创建bean，所以会重复的执行语句】
 * 		AnnotationAwareAspectJAutoProxyCreator【InstantiationAwareBeanPostProcessor】的作用：
 *			1）、	在每个bean创建之前，会调用postProcessBeforeInstantiation()
 *				关注在Aspect配置类中的AspectService和ControllerAspect的创建过程：
 *				1）、判断当前bean是否在advisedBeans中（保存了所有需要增强的bean：注解有before...）
 * 				2）、判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean，
 * 					或者是不是切面(@Aspect)
 * 				3）、是否需要跳过
 * 					1.获取候选的增强器（切面里的增强方法）【List<Advisor> candidateAdvisors】
 * 					advisor类型都是InstantiationModelAwarePointcutAdvisor
 * 					2.始终返回的是false
 * 			2）、	创建对象
 * 			postProcessAfterInitialization		
 * 				1）、	return wrapIfNecessary(bean, beanName, cacheKey)；//包装，如果需要的话
 * 					1.获取候选的所有增强器（通知方法） :Object[] specificInterceptors;
 * 						getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
 * 						找到能在当前bean使用的增强器（找哪些通知方法是需要切入当前bean方法的）
 * 					2.获取bean可用的；findAdvisorsThatCanApply()
 * 					3.给增强器排序；sortAdvisors()
 * 				2）、把增强器添加到缓存中
 * 				3）、如果当前bean需要增强，创建bean的代理对象；createProxy()
 *  				1.获取所有的增强器（通知方法）
 *  				2.保存到proxyFactory中<--config
 *  				3.创建代理对象 spring自动决定
 *  					JdkDynamicAopProxy(config)；Jdk的自动代理（当类实现接口时，选择jdk自动代理）
 *  					ObjenesisCglibAopProxy(config)；Cglib的自动代理（当类没有实现接口时，选择Cglib代理）
 *  			4）、给容器中返回使用cglib增强了的代理对象	
 * 				5）、以后容器中获取到的就是这个组件的代理对象，执行目标方法时，代理对象就会执行通知方法的流程
 * 			3）、目标方法的执行(div())
 * 				容器中保存了组件的代理对象(Cglib增强后代理对象)，这个代理对象中保存了详细信息（比如增强器、对象方法、xxx）
 *				1）、CglibAopProxy.intercept();拦截目标方法的执行
 *				2）、根据proxyFactory获取将要执行的方法的拦截器链
 *					List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)
 * 						1.List<Object> interceptorList保存所有的拦截器 List长度为5
 * 							一个默认的ExposeInvocationInterceptor，4个增强器
 * 						2.遍历所有的增强器，将其封装成intercetpor：-->registry.getInterceptors(advisor);
 * 						3.将增强器转为List<MethodInterceptor>;
 * 							如果增强器是MethodInterceptor，直接加入到集合中
 * 							如果不是，用AdvisorAdapter将增强器转为MethodInterceptor
 * 							转换完成返回MethodInterceptor数组
 * 				3）、如果没有拦截器链，直接执行目标方法
 * 					 拦截器链（每一个通知方法被包装成方法拦截器，后来方法执行是利用MethodInterceptor机制）
 * 				4）、如果有拦截器链，把需要执行的目标方法、目标对象、拦截器链等信息传入创建一个CglibMethodInvocation对象，
 * 					并调用Object retVal = mi.proceed()
 * 				5）、拦截器链的触发过程	
 * 					1.如果没有拦截器执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；
 * 					2.链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；
 * 						拦截器链的机制，保证通知方法与目标方法的执行顺序（注解积累）

在这里插入图片描述
总结：
在这里插入图片描述
**类的初始化：**是完成程序执行前的准备工作。在这个阶段，静态的（变量，方法，代码块）会被执行。同时在会开辟一块存储空间用来存放静态的数据。初始化只在类加载的时候执行一次。
类的实例化：是指创建一个对象的过程。这个过程中会在堆中开辟内存，将一些非静态的方法，变量存放在里面。在程序执行的过程中，可以创建多个对象，既多次实例化。每次实例化都会开辟一块新的内存。

清风无敌风
关注
Spring Boot - spring-boot-starter-aop
学无止境
06-12 1093
然后，我们创建了一个切面类LoggingAspect，它使用@Before和@After注解来定义前置通知和后置通知，这些通知将在UserService类的getUser()在工作中，spring-boot-starter-aop常用于在应用程序中实现切面编程，例如日志记录、性能监控、事务管理等。最后，在Application类的main()方法中，我们获取UserService的实例并调用getUser()方法。在这个示例中，我们创建了一个UserService类，它有一个getUser()
commons-logging-1.1.3,spring-test-4.0.0.RELEASE,spring-aop-4.0.0.RELEASE
06-14
commons-logging-1.1.3,spring-test-4.0.0.RELEASE,spring-aop-4.0.0.RELEASE,spring-aspects-4.0.0.RELEASE
Spring注解（三）——————SpringAOP原理
不积跬步无以至千里
11-24 412
关注微信公众号【行走在代码行的寻路人】获取Java相关资料，分享项目经验及知识干货。 以下测试的源码地址：https://github.com/877148107/Spring-Annotation SpringAOP AOP面向切面编程【动态代理】指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式 AOP案例如下： 在业务逻辑除法运行的时候打印相关日志信息 ...
知识储备：详解Spring中AOP原理(基于注解版)1
qq_36625757的博客
11-02 263
一:准备工作 1.创建maven工程导入jar包依赖 &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://m...
Spring注解开发_AOP原理及完整过程分析（源码）
hey_wei_ran的博客
05-04 696
浅尝Spring注解开发_AOP原理及完整过程分析（源码） 浅尝Spring注解开发，基于Spring 4.3.12 分析AOP执行过程及源码，包含AOP注解使用、AOP原理、分析AnnotationAwareAspectJAutoProxyCreator、AOP代理、拦截器、链式调用 以初学者的角度跟着雷丰阳的视频走完AOP整个过程，设计很巧妙。补充了自己的理解，为了流程连续性，所以全放在放在一篇里，如有错误请多多指教。 Spring注解开发_自定义注册组件、属性赋值、自动装配 Spring注解开发_
Spring注解驱动开发之AOP
qq_44078893的博客
04-12 207
本文演示了使用Spring注解实现AOP的操作，并从源码级别分析了整个过程
internalAutoProxyCreator启动报错
lengshy的博客
08-04 1513
2019-08-04 14:17:01.918 ERROR 11628 — [ main] o.s.boot.SpringApplication : Application run failed org.springframework.beans.factory.BeanCreationException: Error creating bean w...
spring-aop-jar
12-14
"spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨Spring AOP、相关jar文件以及它们在实际开发中的作用。 首先，我们来看一下提供的文件： 1. aopalliance.jar：这是一...
spring-aop
03-17
在实际使用Spring AOP时，可以通过注解或XML配置来定义切面。例如，我们可以使用`@Aspect`注解来声明一个类作为切面，使用`@Before`、`@After`等注解来定义通知，使用`@Pointcut`来定义切入点表达式。 以下是一些...
spring-redis-aop:redis客户端集成spring实现aop方式
06-25
spring-redis-aop redis客户端集成spring实现aop方式,方便在程序中使用spring的时候更加方便的使用redis内存数据库， 采用aop的方式主要是为了不去污染业务代码，达到业务逻辑更加清晰易于阅读，在使用过程中可以...
Spring核心浅析——AOP
Hireek的博客
01-22 441
文章目录Spring核心——AOPConcepts源码测试代码internalAutoProxyCreatorinitializeBeanAbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization调用AnnotationAwareAspectJAutoProxyCreator的父类AbstractAutoProxyCreator。使用什么代理？DynamicAdvisedInterceptor.intercept
Spring注解驱动之AnnotationAwareAspectJAutoProxyCreator详解（二）
抽象的螺旋
09-11 657
Spring注解驱动。
spring注解驱动开发-7 Spring声明式事务
weixin_44227063的博客
11-20 458
Spring 声明式事务前言声明式事务的实现源码分析end... 前言 。文章课程链接：尚硅谷spring注解驱动教程（雷神） 声明式事务的实现 源码分析 end… 如果总结的还行，就点个赞呗 @_@ 如有错误，欢迎指点，下一篇待编写··· ...
@Column导包错误引发无法创建internalAutoProxyCreator
不积跬步，无以至千里
05-10 688
@Column导包错误 当引入spring-boot-starter-data-jpa.jar和aspectjweaver.jar的时候， @Column的红色报错消失 但是实际运行时，会出现无法启动的问题 Exception sending context initialized event to listener instance of class org.springframework.web.context.ContextLoaderListener org.springfr
Spring源码解析之AOP
weixin_41645232的博客
02-05 279
1、开启AOP注解 1）@EnableAspectJAutoProxy 通过Import引入AspectJAutoProxyRegistrar @Import(AspectJAutoProxyRegistrar.class) 2）实现ImportBeanDefinitionRegistrar接口，给容器注册bean定义 AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar 3）注册一个BeanPostProces
Spring注解驱动开发学习总结15：AOP原理 - AnnotationAwareAspectJAutoProxyCreator后置处理器返回代理对象的步骤
xueping_wu的博客
04-11 802
Spring注解驱动开发学习总结15：AOP原理 - AnnotationAwareAspectJAutoProxyCreator后置处理器返回AOP代理对象的步骤1、方法栈调用分析1.1 分析applyBeanPostProcessorsBeforeInstantiation方法1.2 分析applyBeanPostProcessorsAfterInitialization方法1.3 分析AnnotationAwareAspectJAutoProxyCreator后置处理器返回代理对象的步骤2 小结2.1
【Spring - AOP】--- AOP核心后置处理器的创建过程
nrsc
12-08 1704
文章目录1 简诉2 internalAutoProxyCreator的注册3 internalAutoProxyCreator的继承关系4 internalAutoProxyCreator创建+初始化过程4.1 入口refresh()方法4.2 跟进processor创建+初始化的源码4.3 internalAutoProxyCreator初始化过程中BeanFactoryAware的作用时机 ...
报错：Error creating bean with name ‘org.springframework.aop.config.internalAutoProxyCreator‘
qq_44748683的博客
09-07 2478
删除org.springframework:spring-aop:5.3.20。
【Spring 注解驱动】学习笔记 04 - Spring AOP（四）AOP原理【AnnotationAwareAspectJAutoProxyCreator】注册流程分析
MichelleChung的星球
12-14 747
Spring AOP 源码系列 04 - AOP原理之【AnnotationAwareAspectJAutoProxyCreator】注册流程分析
spring-aop与spring-boot-starter-aop的区别
最新发布
09-22
spring-aop与spring-boot-starter-aop的区别在于配置的简化程度和依赖的引入方式。spring-aop是基于Spring框架的AOP实现方式，需要通过XML配置文件来定义切面和通知。而spring-boot-starter-aop是针对Spring Boot应用程序提供的一种简化配置和使用的方式，可以通过注解和Java配置来定义切面和通知。使用spring-boot-starter-aop可以更方便地进行AOP操作，并且不需要额外引入独立的AOP依赖。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值