一篇文章让你吃透spring aop底层原理

最新推荐文章于 2024-06-17 15:49:24 发布
最新推荐文章于 2024-06-17 15:49:24 发布
阅读量712 收藏 28
点赞数 11
分类专栏： Java程序员 文章标签： spring java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60607245/article/details/136855832
版权 
  	if (!cls.getName().equals(apcDefinition.getBeanClassName())) {

  		int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());

  		int requiredPriority = findPriorityForClass(cls);

  		if (currentPriority < requiredPriority) {

  			apcDefinition.setBeanClassName(cls.getName());

  		}

  	}

  	return null;

  }

  RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);

  beanDefinition.setSource(source);

  beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST\_PRECEDENCE);

  beanDefinition.setRole(BeanDefinition.ROLE\_INFRASTRUCTURE);

  registry.registerBeanDefinition(AUTO\_PROXY\_CREATOR\_BEAN\_NAME, beanDefinition);

  return beanDefinition;

}

IOC容器中注入了一个internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator的beandefintion，到此可以得出结论，@EnableAspectJAutoProxy给容器中注册一个AnnotationAwareAspectJAutoProxyCreator。

AnnotationAwareAspectJAutoProxyCreator 上下继承关系如下

我们从下图可以知道继承接口BeanFactoryAware 和BeanPostProcessor接口因此我们可以知道在bean初始化时回出发

在此需要关注两点内容：

1）关注后置处理器SmartInstantiationAwareBeanPostProcessor（在bean初始化完成前后做事情）

2）关注自动装配BeanFactory。

通过代码查看，发现父类AbstractAutoProxyCreator中有后置处理器的内容；AbstactAdvisorAutoProxyCreator类中重写了其父类AbstractAutoProxyCreator中setBeanFactory()方法，在AnnotationAwareAspectJAutoProxyCreator类中initBeanFactory()方法完成了自动装配BeanFactory。分别在这两处关注点打断点来查看其流程：

我们知道AbstactAdvisorAutoProxyCreator 初始化时的一个大致过程如下:

setBeanFactory方法和BeanPostProcessorsBeforeInitialization BeanPostProcessorsAfterInitialization 顺序如下图

源码逻辑:

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {

  if (System.getSecurityManager() != null) {

  	AccessController.doPrivileged((PrivilegedAction<Object>) () -> {

  		invokeAwareMethods(beanName, bean);

  		return null;

  	}, getAccessControlContext());

  }

  else {

// 执行aware 中的方法

  	invokeAwareMethods(beanName, bean);

  }

  Object wrappedBean = bean;

  if (mbd == null || !mbd.isSynthetic()) {

  	//BeanPostProcessor Before方法

  	wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

  }

  try {

  	// init 方法 @PostConstruct init指定方法 InitializingBean等方式

  	invokeInitMethods(beanName, wrappedBean, mbd);

  }

  catch (Throwable ex) {

  	throw new BeanCreationException(

  			(mbd != null ? mbd.getResourceDescription() : null),

  			beanName, "Invocation of init method failed", ex);

  }

  if (mbd == null || !mbd.isSynthetic()) {

  	//beanPostProcessor after方法

  	wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

  }

  return wrappedBean;

}

invokeAwareMethods

该方法比较简单:

org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#setBeanFactory

@Override

public void setBeanFactory(BeanFactory beanFactory) {

  super.setBeanFactory(beanFactory);

  if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {

  	throw new IllegalArgumentException(

  			"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);

  }

  initBeanFactory((ConfigurableListableBeanFactory) beanFactory);

}

protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {

  this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);

}

子类重写了initBeanFactory方法

@Override

protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {

  super.initBeanFactory(beanFactory);

  if (this.aspectJAdvisorFactory == null) {

  	this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);

  }

  this.aspectJAdvisorsBuilder =

  		new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);

}

applyBeanPostProcessorsBeforeInitialization

我看的5.3.x版本的spring 开始没重写 这个before方法

invokeInitMethods

实例化

applyBeanPostProcessorsAfterInitialization

此时看beanpostProcessor 工作原理

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的过程========

aop创建对象原理

从上面我分析的逻辑和前置知识非常清楚,当我们自己编写的类填写@EnableAspectJAutoProxy或者通过其他方式开启aop都是在docreateBean方法中进行增强:

我们在这个方法入口打断点 使用断点的方式进行跟踪分析:

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)

exposedObject = initializeBean(beanName, exposedObject, mbd);

这个方法上面我都分析了aware相关的方法, before init after方法,由于 自己的类非aware ,因此不会执行, before没有重写, 因此不重要下面直接after方法

进来的时候实体对象不是代理对象,我们继续往下看从哪里开始处理成的代理对象的

beanpostProcessor 工作原理

从上面分析我们可以知道Spring入住了AnnotationAwareAspectJAutoProxyCreator 一个BeanPostProcessor类,又知道改类没有重写before方法,因此after方法才是我们的重点:

重写 beanpostprocessor的after方法

org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization

@Override

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {

  if (bean != null) {

  	Object cacheKey = getCacheKey(bean.getClass(), beanName);

  	if (this.earlyProxyReferences.remove(cacheKey) != bean) {

  		return wrapIfNecessary(bean, beanName, cacheKey);

  	}

  }

  return bean;

}

这个地方是二级缓存中存在,删除进行创建对象,ps:二级缓存中存放的是只进行实例化,没有进行初始化的对象

postProcessAfterInitialization方法会对切面进行一次包装的处理。

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {

  if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {

  	return bean;

  }

  if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {

  	return bean;

  }

  if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {

  	this.advisedBeans.put(cacheKey, Boolean.FALSE);

  	return bean;

  }

  // Create proxy if we have advice.

  //获取我们配置的切面 根据切面进行动态代理

  Object\[\] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);

  if (specificInterceptors != DO\_NOT\_PROXY) {

  	this.advisedBeans.put(cacheKey, Boolean.TRUE);

  	//创建代理对象

  	Object proxy = createProxy(

  			bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));

  	this.proxyTypes.put(cacheKey, proxy.getClass());

  	return proxy;

  }

  this.advisedBeans.put(cacheKey, Boolean.FALSE);

  return bean;

}

下面进行创建代理对象

第一步:创建代理对象的ProxyFactory 工厂

第二步:使用工厂模式创建代理对象

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,

  	@Nullable Object\[\] specificInterceptors, TargetSource targetSource) {

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
img
img
img

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
img

rgetSource targetSource) {

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-GJfjiPS6-1710854282142)]
[外链图片转存中…(img-KHsHaTx0-1710854282143)]
[外链图片转存中…(img-qNs0BRy7-1710854282144)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-rAnvMSxD-1710854282145)]

m0_60607245
关注
  • 11
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring aop实现原理
03-15
NULL 博文链接：https://zhang-yingjie-qq-com.iteye.com/blog/319927
深入理解spring的AOP机制原理
08-29
深入理解 Spring 的 ...本篇文章对 Spring 的 AOP 机制原理进行了详细的介绍，包括 AOP 的基本概念、Spring 的 AOP 支持、AspectJ 切点表达式语言等。理解 Spring 的 AOP 机制原理对于深入学习 Spring 框架非常重要。
一文吃透spring aop底层原理
11-28 5993
一文吃透spring aop底层原理前言回顾ioc容器 初始化过程从@EnableAspectJAutoProxy看起AnnotationAwareAspectJAutoProxyCreator 上下继承关系如下invokeAwareMethodsapplyBeanPostProcessorsBeforeInitializationinvokeInitMethodsapplyBeanPostProcessorsAfterInitialization小结aop创建对象原理beanpostProcessor 工
java面试问到项目问题怎么回答，一篇文章让你吃透spring aop底层原理，书籍+视频+学习笔记+技能提升资源库
2301_79098686的博客
04-05 392
我还通过一些渠道整理了一些大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。还有专门针对JVM、SPringBoot、SpringCloud、数据库、Linux、缓存、消息中间件、源码等相关面试题。一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
吃透 Spring AOP （2.底层原理）
陆续将以前写过的技术博客统一搬运到csdn
05-17 196
代理类实现的接口列表（注意是个列表 因为被代理类可能实现了多个接口）（这里就看出来了 jdk动态代理为什么必须实现接口，因为这里生成代理类的时候只能传接口）但是这个代理对象 还没有具体的对这个目标对象做什么增强了，它只是刚刚出生而已。包括动态代理代理的思想。它通过上面这个过程 生成了最终的FOO的代理对象。你的代理对象实现的接口 那个接口叫什么名字 获取到它 生成第二个参数。这个代理类 它相当于包裹主了 被代理类 然后对它进行前后加工。然后调用分派的一个类 在这个类里面 就封装具体的代理增强操作。
【架构视角】一篇文章带你彻底吃透Spring
潘潘和他的朋友们
04-28 1367
框架，本质上是一些实用经验集合。即是前辈们在实际开发过程中积攒下来的实战经验，累积成一套实用工具，避免你在开发过程中重复去造轮子，特别是帮你把日常中能遇到的场景或问题都给屏蔽掉，框架的意义在于屏蔽掉开发的基础复杂度、屏蔽掉此类共性的东西，同时建立严格的编码规范，让框架使用者开箱即用，并且只需要关注差异面，即业务层面的实现。简而言之，框架只干一件事，那就是简化开发。然后在此基础上，可能会再考虑一些安全性、效率、性能、弹性、管理、拓展、解耦等等。
Spring篇——03. Spring核心AOP和Spring声明式事务
m0_46084075的博客
01-24 673
开头寄语 Spring有两大核心一个是控制反转IOC，一个是面向切面AOP 控制反转IOC也就相当于是一个Spring容器，我们将我们编写代码所需要的内容都存放在Spring的IOC容器中，让Spring来帮助我们管理，我们需要的时候直接调用就好，而不需要在出现new这些关键字来创建对象，他的底层使用了Java基础里面反射的原理。 而面向切面AOP也同样是Spring的核心之一，这篇笔记就是用来介绍Spring中面向切面AOP的思想和如何在Spring中使用到这种思想！ 自己的知识水平不是很高，写的不好大家
【4万字详解】一篇文章搞定Spring框架
Coder Xu
05-22 624
文章目录前言 前言 该技术博客是关于动力节点Mybatis教程的笔记总结，方便自己学习的同时希望能为大家带来帮助！ 更多好文推荐 ： MySQL操作笔记（五万字详解） Java常用类笔记 计算机底层原理——汇编语言 学习Java异常，吃透这篇足够 ...
你知道Spring是怎么将AOP应用到Bean的生命周期中的吗?
ITMuch的专栏
07-19 451
本系列文章：读源码，我们可以从第一行读起你知道Spring是怎么解析配置类的吗？配置类为什么要添加@Configuration注解？谈谈Spring中的对象跟Bean，你知道Sprin...
spring 源码解析（配图文讲解）顺带搞懂了循环依赖、aop底层实现
风团团
04-07 492
平时用aop用的很爽，今天决定研究一下源码，基于spring+aspectj来讲 AOP 定义：一种切面的编程思想 具体实现有： 1：springAOP 2：spring+aspectj 底层实现：cglib、jdk动态代理 @EnableAspectJAutoProxy(proxyTargetClass = false) 这个注解添加上aop就可以正常运行，一删掉就失效了，那么就从这里分析开始吧｜ 可以看到这其实是一个自定义注解，关键的地方在于@import，这个注解给AspectJAutoProxyRe
Spring AOP 原理剖析，这一篇就够
12-22
Spring AOP 学习记录 AOP（面向切面编程）方面的知识又是看了忘忘了看，今天有空记录下AOP的知识点。主要分为以下几方面： ​ 1、AOP相关术语 ​ 2、基础知识及示例 ​ 3、增强分类 1、AOP相关术语 连接点...
springIOC及AOP底层原理Demo实现
11-13
实现spring框架中两大思想： 1.ioc 2.aop 分析实现原理自己实现ioc和aop。
深入浅析Spring 的aop实现原理
09-02
AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。本文给大家介绍Spring 的aop实现原理，感兴趣的朋友一起学习吧
Spring Security实现用户认证四：使用JWT与Redis实现无状态认证
不做菜虚困的博客
06-12 825
在基本的通信流程中，我们一般采用Session去存储用户的认证状态。在Spring Security实现用户认证三中讲过，在拿到前端传输过来的用户名和密码之后，会有专门的过滤器处理这部分的需求，并且对认证成功的用户生成Token且存储在Session中。在下次发起请求时，直接从Session中取出同用户名的token进行密码哈希的比较要认证用户。对于无状态认证，则我们的认证不依赖与服务器端存储的Session的状态。所以无状态认证需要我们每次从前端传输一个包含完整认证信息的Token到服务器端进行自定义的认
graalvm编译springboot3 native应用
fengchengwu2012的博客
06-12 703
云原生时代容器先行，为了更好的拥抱云原生，spring boot3之后，推出了graalvm编译boot项目，利用jvm的AOT（ Ahead Of Time ）运行前编译技术，可以将javay源码直接构建成机器码二进制的文件，无需jdk静态编译为class字节码，运行时jre解释执行，这样就无需依赖java环境运行，部署到容器中可以直接启动运行。
SpringBoot3 整合 Mybatis 完整版
northcastle的博客
06-14 460
SpringBoot3 整合 MyBatis 的步骤详细记录
Spring IOC 控制反转（注解版）
最新发布
Dreadnaught的博客
06-17 594
Spring 框架中的核心概念之一就是控制反转（Inversion of Control，IoC）。IOC就是一种思想，而依赖注入(Dependency Injection, DI)是控制反转的一种实现方式。Spring本身是一个容器，存的是对象。对象这个词，在 Spring的范围内，称之为 Bean。控制反转（Inversion of Control，IoC）是一种设计原则，它将对象的创建和依赖关系的管理从程序代码中解耦出来，交由框架或容器进行处理。
springaop底层原理
06-05
Spring AOP 的底层原理主要基于以下几个关键概念： 1. **通知(Advice)**: 是 AOP 的核心，它是对目标方法执行前后的行为进行增强的代码片段。Spring 提供了五种类型的通知：前置通知（Before）、后置通知（After）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值