Spring源码解析(五):循环依赖

这篇具有很好参考价值的文章主要介绍了Spring源码解析(五):循环依赖。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Spring源码系列文章

Spring源码解析(一):环境搭建

Spring源码解析(二):bean容器的创建、默认后置处理器、扫描包路径bean

Spring源码解析(三):bean容器的刷新

Spring源码解析(四):单例bean的创建流程

Spring源码解析(五):循环依赖

Spring源码解析(六):bean工厂后置处理器ConfigurationClassPostProcessor

Spring源码解析(七):bean后置处理器AutowiredAnnotationBeanPostProcessor

Spring源码解析(八):bean后置处理器CommonAnnotationBeanPostProcessor

Spring源码解析(九):AOP源码之@Aspect所有相关注解解析

Spring源码解析(十):spring整合mybatis源码

Spring源码解析(十一):spring事务配置类源码

Spring源码解析(十二):TransactionInterceptor事务拦截器


一、什么是循环依赖

  • 简单点说,就是A依赖了B,B依赖的A
@Component
public class A {

	@Autowired
	private B b;
}

@Component
public class B {

	@Autowired
	private A a;
}
  • 如果不处理,那么A创建时候需要属性填充B
  • 此时B还没有创建,那么去创建B,又需要属性填充A
  • 以此形成了死循环

Spring源码解析(五):循环依赖,spring,spring,java,后端

二、什么情况下循环依赖可以被处理?

依赖情况 依赖注入方式 循环依赖是否被解决
AB相互依赖(循环依赖) 均采用setter方法注入
AB相互依赖(循环依赖) 均采用构造器注入
AB相互依赖(循环依赖) A中注入B的方式为setter方法,B中注入A的方式为构造器
AB相互依赖(循环依赖) B中注入A的方式为setter方法,A中注入B的方式为构造器

三、简单的循环依赖(没有AOP)

Spring在创建Bean的过程中分为三步

  1. 实例化,简单理解就是new一个对象
  2. 属性注入,为实例化对象属性赋值
  3. 初始化,执行aware接口中的方法,初始化方法,完成AOP代理

以上面AB相互依赖为例

@Component
public class A {

	@Autowired
	private B b;
}

@Component
public class B {

	@Autowired
	private A a;
}

解读整个循环依赖处理的过程

  • 整个流程应该是以A的创建为起点
  • Spring在创建Bean的时候默认是按照自然排序来进行创建的,所以第一步Spring会去创建A
  • 创建A的过程实际上就是调用getBean方法,这个方法有两层含义
    1. 创建一个新的Bean
    2. 从缓存中获取到已经被创建的对象

1、getSingleton(beanName)缓存中获取对象

  • 调用getSingleton(a)方法,这个方法又会调用getSingleton(beanName, true)
  • true表示允许提前曝光引用
public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}
  • getSingleton(beanName, true)这个方法实际上就是到缓存中尝试去获取Bean,整个缓存分为三级
    • singletonObjects,一级缓存,存储的是所有创建好了的单例Bean
    • earlySingletonObjects,完成实例化,但是还未进行属性注入及初始化的对象
    • singletonFactories,提前暴露的一个单例工厂,二级缓存中存储的就是从这个工厂中获取到的对象

Spring源码解析(五):循环依赖,spring,spring,java,后端

  • if中代码不会执行,因为还没有到bean的创建中,这是创建前的操作
  • 因为A是第一次被创建,所以不管哪个缓存中必然都是没有的
  • 因此会进入getSingleton的另外一个重载方法getSingleton(beanName, singletonFactory)

2、getSingleton(beanName, singletonFactory)从对象工厂中获取对象,添加到一级缓存

  • 核心代码:通过createBean方法返回的Bean最终被放到了一级缓存,也就是单例池中
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    synchronized (this.singletonObjects) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {

            // ....
            // 省略异常处理及日志
            // ....

            // 在单例对象创建前先做一个标记
            // 将beanName放入到singletonsCurrentlyInCreation这个集合中
            // 标志着这个单例Bean正在创建
            // 如果同一个单例Bean多次被创建,这里会抛出异常
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
			
			// ....
            // 用于记录异常相关信息
            // ....

            try {
                // 上游传入的lambda在这里会被执行,调用createBean方法创建一个Bean后返回
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            
            // ...
            // 省略catch异常处理
            // ...
            
            finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                // 创建完成后将对应的beanName从singletonsCurrentlyInCreation移除
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                // 添加到一级缓存singletonObjects中
                addSingleton(beanName, singletonObject);
            }
        }
        return singletonObject;
    }
}
  • 将从对象工厂中获取的对象放入一级缓存
  • 将creatBean中放入二三缓存的东西删除到,因为以后不需要了

Spring源码解析(五):循环依赖,spring,spring,java,后端

3、addSingletonFactory(beanName, singletonFactory) 创建对象工厂添加到三级缓存

  • 这段代码是creatBean中的核心内容
  • 也就是bean真正的创建

Spring源码解析(五):循环依赖,spring,spring,java,后端

在完成Bean的实例化后,属性注入之前Spring将Bean包装成一个工厂对象添加进了三级缓存中,对应源码如下:

Spring源码解析(五):循环依赖,spring,spring,java,后端

  • 这里只是添加了一个工厂,通过这个工厂(ObjectFactory)的getObject方法可以得到一个bean对象
  • 而这个对象实际上就是通过getEarlyBeanReference这个方法创建的

4、getEarlyBeanReference()对象工厂暴露的对象引用

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}
  • 它实际上就是调用了后置处理器的getEarlyBeanReference
  • 而真正实现了这个方法的后置处理器只有一个,就是通过@EnableAspectJAutoProxy注解导入的AnnotationAwareAspectJAutoProxyCreator
  • 也就是说如果在不考虑AOP的情况下,上面的代码等价于:
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    return exposedObject;
}
  • 也就是说(不考虑AOP情况下)这个对象工厂啥都没干,直接将实例化阶段创建的对象返回了

总结

根据流程图串一下流程:

Spring源码解析(五):循环依赖,spring,spring,java,后端

A依赖BB依赖A,自然排序,所以先实例化A

  1. getBean(a),先从缓存中获取,没有,则需要去创建
  2. 实例化A,创建一个对象工厂,可以通过getObje返回刚实例化的A对象,将对象工厂放入三级缓存
  3. A属性填充,需要给A中的b属性赋值,则需要getBean(b),先从缓存中获取,没有,则需要去创建
  4. 实例化B,创建一个对象工厂,可以通过getObje返回刚实例化的A对象,将对象工厂放入三级缓存
  5. B属性填充,需要给B中的a属性赋值,则需要getBean(a),从缓存中获取getSingleton(beanName, true)
    • 此时a对象在创建中,所以会进入if方法
    • 一级缓存中没有,则去二级缓存中找,也没有
    • 最后从三级缓存获取对象工厂里的对象,放入二级缓存,并删除三级缓存的对象工厂
  6. B属性填充完毕后,初始化,然后B对象的创建流程完毕
  7. 接下来回到A的b属性填充,也就完成了
  8. A初始化,创建流程完毕,删除A的二级缓存,放入一级缓存

四、aop代理bean的循环依赖

  • 在普通的循环依赖的情况下,三级缓存没有任何作用
  • 三级缓存实际上跟Spring中的AOP相关,我们再来看一看getEarlyBeanReference的代码:
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}
  • 如果在开启AOP的情况下,那么就是调用到AnnotationAwareAspectJAutoProxyCreatorgetEarlyBeanReference方法
  • 对应的源码如下:
public Object getEarlyBeanReference(Object bean, String beanName) {
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    this.earlyProxyReferences.put(cacheKey, bean);
    // 如果需要代理,返回一个代理对象,不需要代理,直接返回当前传入的这个bean对象
    return wrapIfNecessary(bean, beanName, cacheKey);
}
  • 回到上面的例子,如果我们对A进行了AOP代理的话
  • 那么此时getEarlyBeanReference将返回一个代理后的对象
  • 而不是实例化阶段创建的对象
  • 这样就意味着B中注入的A将是一个代理对象而不是A的实例化阶段创建后的对象

代理bean的循环依赖过程

Spring源码解析(五):循环依赖,spring,spring,java,后端

1、在给B注入的时候为什么要注入一个代理对象?

  • 当我们对A进行了AOP代理时
  • 说明我们希望从容器中获取到的就是A代理后的对象而不是A本身
  • 因此把A当作依赖进行注入时也要注入它的代理对象

2、明明初始化的时候是A对象,那么Spring是在哪里将代理对象放入到容器中的呢?

  • 首先A对象创建,然后将A代理对象工厂放入三级缓存
  • 然后A执行到下图populateBean()属性填充时候去创建B
  • B属性填充的时候从三级缓存获取到代理对象,并放入二级缓存,并删除三级缓存
  • B属性填充A的代理对象,然后初始化,B创建完毕,A属性赋值B也就完成了
  • 接下来就是A的初始化,此时exposedObject还是A的原始对象
  • 最后从二级缓存中拿到代理对象,之后会添加到一级缓存,并删除二级缓存

Spring源码解析(五):循环依赖,spring,spring,java,后端

3、初始化的时候是对A对象本身进行初始化,而容器中以及注入到B中的都是代理对象,这样不会有问题吗?

  • 不会
  • 因为不管是cglib代理还是jdk动态代理生成的代理类,内部都持有一个目标类的引用
  • 当调用代理对象的方法时,实际会去调用目标对象的方法,A完成初始化相当于代理对象自身也完成了初始化

4、三级缓存为什么要使用工厂而不是直接使用引用?换而言之,为什么需要这个三级缓存,直接通过二级缓存暴露一个引用不行吗?

  • 这个工厂的目的在于延迟对实例化阶段生成的对象代理
  • 只有真正发生循环依赖的时候,才去提前生成代理对象
  • 否则只会创建一个工厂并将其放入到三级缓存中,但是不会去通过这个工厂去真正创建对象

我们思考一种简单的情况,就以单独创建A为例,假设AB之间现在没有依赖关系,但是A被代理了,这个时候当A完成实例化后还是会进入下面这段代码:

// A是单例的,mbd.isSingleton()条件满足
// allowCircularReferences:这个变量代表是否允许循环依赖,默认是开启的,条件也满足
// isSingletonCurrentlyInCreation:正在在创建A,也满足
// 所以earlySingletonExposure=true
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                  isSingletonCurrentlyInCreation(beanName));
// 还是会进入到这段代码中
if (earlySingletonExposure) {
	// 还是会通过三级缓存提前暴露一个工厂对象
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
  • 即使没有循环依赖,也会将其添加到三级缓存中,而且是不得不添加到三级缓存中
  • 因为到目前为止Spring也不能确定这个Bean有没有跟别的Bean出现循环依赖

  • 假设我们在这里直接使用二级缓存的话,那么意味着所有的Bean在这一步都要完成AOP代理
  • Spring结合AOP跟Bean的生命周期本身就是通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来完成的,在这个后置处理的postProcessAfterInitialization方法中对初始化后的Bean完成AOP代理
    • 如果出现了循环依赖,那没有办法,只有给Bean先创建代理
    • 但是没有出现循环依赖的情况下,设计之初就是让Bean在生命周期的最后一步完成代理而不是在实例化后就立马完成代理
    • 如果没有循环依赖,只是三级缓存添加了一个代理A对象工厂(不会执行),A对象会在初始化最后一步生成代理对象,然后放入一级缓存,最后清空二三级缓存

五、总结

Spring是如何解决的循环依赖?

  • Spring通过三级缓存解决了循环依赖,其中一级缓存为单例池(singletonObjects),二级缓存为早期曝光对象(earlySingletonObjects),三级缓存为早期曝光对象工厂(singletonFactories
  • 当A、B两个类发生循环引用时,在A完成实例化后,就使用实例化后的对象去创建一个对象工厂,并添加到三级缓存中
    • 如果A被AOP代理,那么通过这个工厂获取到的就是A代理后的对象
    • 如果A没有被AOP代理,那么这个工厂获取到的就是A实例化的对象
  • 当A进行属性注入时,会去创建B,同时B又依赖了A,所以创建B的同时又会去调用getBean(a)来获取需要的依赖,此时的getBean(a)会从缓存中获取
    • 第一步,先获取到三级缓存中的对象工厂
    • 第二步,调用对象工工厂的getObject方法来获取到对应的对象,得到这个对象后将其注入到B中
    • 紧接着B会走完它的生命周期流程,包括初始化、后置处理器等
  • 当B创建完后,会将B再注入到A中,此时A再完成它的整个生命周期
  • 至此,循环依赖结束!

为什么要使用三级缓存呢?二级缓存能解决循环依赖吗?文章来源地址https://www.toymoban.com/news/detail-609464.html

  • 如果要使用二级缓存解决循环依赖,意味着所有Bean在实例化后就要完成AOP代理,这样违背了Spring设计的原则
  • Spring在设计之初就是通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来在Bean生命周期的最后一步来完成AOP代理,而不是在实例化后就立马进行AOP代理

到了这里,关于Spring源码解析(五):循环依赖的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Spring专题】Spring之Bean的生命周期源码解析——阶段二(二)(IOC之属性填充/依赖注入)

    由于Spring源码分析是一个前后联系比较强的过程,而且这边分析,也是按照代码顺序讲解的,所以不了解前置知识的情况下,大概率没办法看懂当前的内容。所以,特别推荐看看我前面的文章(自上而下次序): Spring底层核心原理解析【学习难度: ★★☆☆☆ 】 手写简易

    2024年02月12日
    浏览(39)
  • spring 的循环依赖以及spring为什么要用三级缓存解决循环依赖

            bean的生命周期         这里简单过一下 class -无参构造 -普通对象 -依赖注入(对加了autowire等的属性赋值) -初始化前-初始化 -初始化后(aop) -放入单例池的map(一级缓存) -bean对象 这里提一点单例bean单例bean 其实就是用mapbeanName,Bean对象创建的,多例bean就不

    2024年02月15日
    浏览(53)
  • 【Spring】Spring循环依赖的处理

    循环依赖是指两个或多个组件之间相互依赖,形成一个闭环,从而导致这些组件无法正确地被初始化或加载。这种情况可能会在软件开发中引起问题,因为循环依赖会导致初始化顺序混乱,组件之间的关系变得复杂,甚至可能引发死锁或其他不稳定行为。 在编程中,循环依赖

    2024年02月11日
    浏览(38)
  • 【Spring】Spring循环依赖(超重要!!)

    目录 什么是循环依赖问题 循环依赖具体是怎么解决的 具体的解决步骤: 通俗实例:       严谨的循环依赖解决图例 为什么使用的是三级缓存,二级缓存不够用吗?         Spring的循环依赖是指在Bean之间存在相互依赖关系,形成一个闭环的情况。简单来说,Bean A依赖于

    2024年02月11日
    浏览(32)
  • 【Spring】Spring的循环依赖以及解决方案

    ​ Spring循环依赖指的是两个或多个Bean之间相互依赖,形成一个环状依赖的情况。通俗的说,就是A依赖B,B依赖C,C依赖A,这样就形成了一个循环依赖的环。 ​ Spring循环依赖通常会导致Bean无法正确地被实例化,从而导致应用程序无法正常启动或者出现异常。因此,Spring循环

    2024年04月25日
    浏览(35)
  • 【Spring】循环依赖

    循环依赖是什么? 循环依赖的场景有哪一些? 三级缓存分别是什么?三个Map有什么异同? 三级缓存是如何解决循环依赖的? 为什么要使用三级缓存?为什么不可以用二级缓存? 为什么构造器循环依赖、原型Bean循环依赖无法用三级缓存解决? 看过 Spring源码吗?一般我们说

    2024年02月21日
    浏览(35)
  • Spring解决循环依赖问题

    例如,就是A对象依赖了B对象,B对象依赖了A对象。(下面的代码属于 属性的循环依赖 ,也就是初始化阶段的循环依赖,区别与底下 构造器的循环依赖 ) 问题来了: A Bean创建 —— 依赖了 B 属性 ——  触发 B Bean创建 ——  B 依赖了 A 属性 ——  需要 A Bean(但A Bean还在创建

    2024年02月12日
    浏览(39)
  • Spring解决循环依赖

    目录 什么是spring循环依赖 什么情况下循环依赖可以被处理? spring 如何解决循环依赖 创建A这个Bean的流程 答疑 疑问:在给B注入的时候为什么要注入一个代理对象? 初始化的时候是对A对象本身进行初始化,而容器中以及注入到B中的都是代理对象,这样不会有问题吗? 三级

    2024年02月22日
    浏览(46)
  • Spring循环依赖处理

    循环依赖是指两个或多个组件之间相互依赖,形成一个闭环,从而导致这些组件无法正确地被初始化或加载。这种情况可能会在软件开发中引起问题,因为循环依赖会导致初始化顺序混乱,组件之间的关系变得复杂,甚至可能引发死锁或其他不稳定行为。 在编程中,循环依赖

    2024年02月07日
    浏览(36)
  • Spring如何解决循环依赖问题

    循环依赖问题在Spring中主要有三种情况: (1)通过构造方法进行依赖注入时产生的循环依赖问题。 (2)通过setter方法进行依赖注入且是在多例(原型)模式下产生的循环依赖问题。 (3)通过setter方法进行依赖注入且是在单例模式下产生的循环依赖问题。 在Spring中,只有第

    2024年02月06日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包