拜托，别再问我Spring是如何解决循环依赖了！

时间 2020-04-16

标签拜托别再问我 spring 如何解决循环依赖栏目 Spring 繁體版

原文原文链接

前言

文章首发于微信公众号 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)：源码以下：java

//查询缓存
  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：源码以下spring

//中间省略部分代码。。。。。
  //建立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 不能解决构造器的循环依赖？bash

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

【2】为何多实例 Bean 不能解决循环依赖？微信

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

总结

根据以上的分析，大概清楚了 Spring 是如何解决循环依赖的。假设 A 依赖 B，B 依赖 A（注意：这里是 set 属性依赖）分如下步骤执行：

A 依次执行 doGetBean、查询缓存、 createBean建立实例，实例化完成放入三级缓存 singletonFactories 中，接着执行 populateBean方法装配属性，可是发现有一个属性是 B 的对象。
所以再次调用 doGetBean 方法建立 B 的实例，依次执行 doGetBean、查询缓存、createBean 建立实例，实例化完成以后放入三级缓存 singletonFactories 中，执行 populateBean 装配属性，可是此时发现有一个属性是 A 对象。
所以再次调用 doGetBean 建立 A 的实例，可是执行到 getSingleton 查询缓存的时候，从三级缓存中查询到了 A 的实例(早期引用，未完成属性装配)，此时直接返回 A，不用执行后续的流程建立 A 了，那么 B 就完成了属性装配，此时是一个完整的对象放入到一级缓存 singletonObjects 中。
B 建立完成了，则 A 天然完成了属性装配，也建立完成放入了一级缓存 singletonObjects 中。

Spring 三级缓存的应用完美的解决了循环依赖的问题，下面是循环依赖的解决流程图。