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三级缓存的应用完美的解决了循环依赖的问题，下面是循环依赖的解决流程图。

• 如果觉得作者写的好，有所收获的话，点个关注推荐一下哟！！！