当前位置： 移动技术网 > IT编程>开发语言>Java > Spring解决循环依赖，你真的懂了吗？

Spring解决循环依赖，你真的懂了吗？

2020年03月19日  | 移动技术网IT编程  | 我要评论

导读

微信所有码猿技术专栏

  • 这个就是典型的构造器依赖，详情请看上面两篇文章，这里不再详细赘述了。本篇文章将会从源码深入解析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三级缓存的应用完美的解决了循环依赖的问题，下面是循环依赖的解决流程图。

微信搜索码猿技术专栏

  • 如果觉得作者写的好，有所收获的话，点个关注推荐一下哟！！！
    微信搜索公众号码猿技术专栏

您可能感兴趣的文章:

如对本文有疑问， 点击进行留言回复！！

相关文章:

验证码：
最近更新的文章
大家感兴趣的文章
移动技术网