• 欢迎访问 winrains 的个人网站!
  • 本网站主要从互联网整理和收集了与Java、网络安全、Linux等技术相关的文章,供学习和研究使用。如有侵权,请留言告知,谢谢!

Spring 如何解决循环依赖

Spring winrains 来源:不才陈某 2个月前 (04-30) 25次浏览

前言

文章首发于微信公众号Spring如何解决循环依赖?
前几天发表的文章SpringBoot 多数据源动态切换SpringBoot 整合多数据源的巨坑中,提到了一个坑就是动态数据源添加@Primary 接口就会造成循环依赖异常,如下图:
这个就是典型的构造器依赖,详情请看上面两篇文章,这里不再详细赘述了。本篇文章将会从源码深入解析 Spring 是如何解决循环依赖的?为什么不能解决构造器的循环依赖?

什么是循环依赖

简单的说就是 A 依赖 B,B 依赖 C,C 依赖 A 这样就构成了循环依赖。

微信搜索码猿技术专栏

循环依赖分为构造器依赖和属性依赖,众所周知的是 Spring 能够解决属性的循环依赖(set 注入)。下文将从源码角度分析 Spring 是如何解决属性的循环依赖。

思路

如何解决循环依赖,Spring 主要的思路就是依据三级缓存,在实例化 A 时调用 doGetBean,发现 A 依赖的 B 的实例,此时调用 doGetBean 去实例 B,实例化的 B 的时候发现又依赖 A,如果不解决这个循环依赖的话此时的 doGetBean 将会无限循环下去,导致内存溢出,程序奔溃。spring 引用了一个早期对象,并且把这个”早期引用”并将其注入到容器中,让 B 先完成实例化,此时 A 就获取 B 的引用,完成实例化。

三级缓存

Spring 能够轻松的解决属性的循环依赖正式用到了三级缓存,在 AbstractBeanFactory 中有详细的注释。
/**一级缓存,用于存放完全初始化好的 bean,从该缓存中取出的 bean 可以直接使用*/
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/**三级缓存 存放 bean 工厂对象,用于解决循环依赖*/
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/**二级缓存 存放原始的 bean 对象(尚未填充属性),用于解决循环依赖*/
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
  • 一级缓存:singletonObjects,存放完全实例化属性赋值完成的 Bean,直接可以使用。
  • 二级缓存:earlySingletonObjects,存放早期 Bean 的引用,尚未属性装配的 Bean
  • 三级缓存:singletonFactories,三级缓存,存放实例化完成的 Bean 工厂。

开撸

先上一张流程图看看 Spring 是如何解决循环依赖的

微信搜索码猿技术专栏

上图标记蓝色的部分都是涉及到三级缓存的操作,下面我们一个一个方法解析

【1】 getSingleton(beanName):源码如下:

//查询缓存
Object sharedInstance = getSingleton(beanName);
//缓存中存在并且args是null
if (sharedInstance != null && args == null) {
    //.......省略部分代码

    //直接获取Bean实例
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}

//getSingleton源码,DefaultSingletonBeanRegistry#getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //先从一级缓存中获取已经实例化属性赋值完成的Bean
    Object singletonObject = this.singletonObjects.get(beanName);
    //一级缓存不存在,并且Bean正处于创建的过程中
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            //从二级缓存中查询,获取Bean的早期引用,实例化完成但是未赋值完成的Bean
            singletonObject = this.earlySingletonObjects.get(beanName);
            //二级缓存中不存在,并且允许创建早期引用(二级缓存中添加)
            if (singletonObject == null && allowEarlyReference) {
                    //从三级缓存中查询,实例化完成,属性未装配完成
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    //二级缓存中添加
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    //从三级缓存中移除
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}
从源码可以得知,doGetBean 最初是查询缓存,一二三级缓存全部查询,如果三级缓存存在则将 Bean 早期引用存放在二级缓存中并移除三级缓存。(升级为二级缓存)

【2】addSingletonFactory:源码如下

    //中间省略部分代码。。。。。
    //创建Bean的源码,在AbstractAutowireCapableBeanFactory#doCreateBean方法中
    if (instanceWrapper == null) {
        //实例化Bean
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    //允许提前暴露
    if (earlySingletonExposure) {
        //添加到三级缓存中
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    try {
        //属性装配,属性赋值的时候,如果有发现属性引用了另外一个Bean,则调用getBean方法
        populateBean(beanName, mbd, instanceWrapper);
        //初始化Bean,调用init-method,afterproperties方法等操作
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
}

//添加到三级缓存的源码,在DefaultSingletonBeanRegistry#addSingletonFactory
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        //一级缓存中不存在
        if (!this.singletonObjects.containsKey(beanName)) {
            //放入三级缓存
            this.singletonFactories.put(beanName, singletonFactory);
            //从二级缓存中移除,
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}
从源码得知,Bean 在实例化完成之后会直接将未装配的 Bean 工厂存放在三级缓存中,并且移除二级缓存

【3】addSingleton:源码如下:

//获取单例对象的方法,DefaultSingletonBeanRegistry#getSingleton
//调用createBean实例化Bean
singletonObject = singletonFactory.getObject();

//。。。。中间省略部分代码

//doCreateBean之后才调用,实例化,属性赋值完成的Bean装入一级缓存,可以直接使用的Bean
addSingleton(beanName, singletonObject);

//addSingleton源码,在DefaultSingletonBeanRegistry#addSingleton方法中
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        //一级缓存中添加
        this.singletonObjects.put(beanName, singletonObject);
        //移除三级缓存
        this.singletonFactories.remove(beanName);
        //移除二级缓存
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}
总之一句话,Bean 添加到一级缓存,移除二三级缓存。

扩展

【1】为什么 Spring 不能解决构造器的循环依赖?

从流程图应该不难看出来,在 Bean 调用构造器实例化之前,一二三级缓存并没有 Bean 的任何相关信息,在实例化之后才放入三级缓存中,因此当 getBean 的时候缓存并没有命中,这样就抛出了循环依赖的异常了。

【2】为什么多实例 Bean 不能解决循环依赖?

多实例 Bean 是每次创建都会调用 doGetBean 方法,根本没有使用一二三级缓存,肯定不能解决循环依赖。

总结

根据以上的分析,大概清楚了 Spring 是如何解决循环依赖的。假设 A 依赖 B,B 依赖 A(注意:这里是 set 属性依赖)分以下步骤执行:
  1. A 依次执行doGetBean、查询缓存、createBean创建实例,实例化完成放入三级缓存 singletonFactories 中,接着执行populateBean方法装配属性,但是发现有一个属性是 B 的对象。
  2. 因此再次调用 doGetBean 方法创建 B 的实例,依次执行 doGetBean、查询缓存、createBean 创建实例,实例化完成之后放入三级缓存 singletonFactories 中,执行 populateBean 装配属性,但是此时发现有一个属性是 A 对象。
  3. 因此再次调用 doGetBean 创建 A 的实例,但是执行到 getSingleton 查询缓存的时候,从三级缓存中查询到了 A 的实例(早期引用,未完成属性装配),此时直接返回 A,不用执行后续的流程创建 A 了,那么 B 就完成了属性装配,此时是一个完整的对象放入到一级缓存 singletonObjects 中。
  4. B 创建完成了,则 A 自然完成了属性装配,也创建完成放入了一级缓存 singletonObjects 中。
Spring 三级缓存的应用完美的解决了循环依赖的问题,下面是循环依赖的解决流程图。

作者:不才陈某

来源:https://juejin.im/post/5e9088ecf265da47b554f0d7


版权声明:文末如注明作者和来源,则表示本文系转载,版权为原作者所有 | 本文如有侵权,请及时联系,承诺在收到消息后第一时间删除 | 如转载本文,请注明原文链接。
喜欢 (0)