spring循环依赖和三级缓存

前言

Spring如何解决的循环依赖，是近两年流行起来的一道Java面试题。

其实笔者本人对这类 框架源码题 还是持一定的怀疑态度的。

如果笔者作为面试官，可能会问一些诸如“如果注入的属性为 null ，你会从哪几个方向去排查”这些 场景题 。

那么既然写了这篇文章，闲话少说，发车看看 Spring是如何解决的循环依赖 ，以及带大家看清循环依赖的本质是什么。

正文

通常来说，如果问Spring内部如何解决循环依赖，一定是单默认的 单例 Bean中，属性互相引用的场景。

比如几个Bean之间的互相引用：

甚至自己“循环”依赖自己：

先说明前提： 原型 (Prototype)的场景是 不支持 循环依赖的，通常会走到AbstractBeanFactory类中下面的判断，抛出异常。

if (isPrototypeCurrentlyInCreation(beanName)) {
  throw new BeanCurrentlyInCreationException(beanName);
}

原因很好理解，创建 新的A 时，发现要注入 原型字段B ，又创建 新的B 发现要注入 原型字段A ...

这就套娃了, 你猜是先 StackOverflow 还是 OutOfMemory ？

Spring怕你不好猜，就先抛出了 BeanCurrentlyInCreationException

基于构造器的循环依赖，就更不用说了， 官方文档 都摊牌了，你想让构造器注入支持循环依赖，是不存在的，不如把代码改了。

那么默认单例的属性注入场景， Spring 是如何支持循环依赖的？

Spring解决循环依赖

首先，Spring内部维护了三个 Map ，也就是我们通常说的 三级缓存 。

笔者翻阅Spring文档倒是没有找到三级缓存的概念，可能也是本土为了方便理解的词汇。

在Spring的DefaultSingletonBeanRegistry类中，你会赫然发现类上方挂着这三个Map：

• singletonObjects 它是我们最熟悉的朋友，俗称“ 单例池 ”“ 容器 ”，缓存创建完成单例Bean的地方。
• singletonFactories 映射创建Bean的原始工厂
• earlySingletonObjects 映射Bean的 早期 引用，也就是说在这个Map里的Bean不是完整的，甚至还不能称之为“ Bean ”，只是一个 Instance .

后两个Map其实是“ 垫脚石 ”级别的，只是创建Bean的时候，用来借助了一下，创建完成就清掉了。

所以笔者前文对“三级缓存”这个词有些迷惑，可能是因为注释都是以Cache of开头吧。

为什么成为后两个Map为 垫脚石 ，假设最终放在 singletonObjects 的Bean是你想要的一杯“凉白开”。

那么Spring准备了两个杯子，即singletonFactories和earlySingletonObjects来回“倒腾”几番，把热水晾成“凉白开”放到 singletonObjects 中。

闲话不说，都浓缩在图里。

上面的是一张GIF，如果你没看到可能还没加载出来。三秒一帧，不是你电脑卡。

笔者画了17张图 简化表述 了Spring的主要步骤，GIF上方即是刚才提到的三级缓存，下方展示是 主要 的几个方法。

当然了，这个地步你肯定要结合 Spring源码 来看，要不肯定看不懂。

如果你只是想大概了解，或者面试，可以先记住笔者上文提到的“ 三级缓存 ”，以及下文即将要说的本质。

循环依赖的本质

上文了解完Spring如何处理循环依赖之后，让我们跳出“ 阅读源码 ”的思维，假设让你实现一个有以下特点的功能，你会怎么做？

• 将指定的一些类实例为单例
• 类中的字段也都实例为单例
• 支持循环依赖

举个例子，假设有类A：

public class A {
    private B b;
}

类B：

public class B {
    private A a;
}

说白了让你 模仿Spring ： 假装A 和 B 是被@Component修饰， 并且类中的字段 假装 是@Autowired修饰的，处理完放到Map中。

其实非常简单，笔者写了一份粗糙的代码，可供参考：

/**
     * 放置创建好的bean Map
     */
    private static Map<String, Object> cacheMap = new HashMap<>(2);

    public static void main(String[] args) {
        // 假装扫描出来的对象
        Class[] classes = {A.class, B.class};
        // 假装项目初始化实例化所有bean
        for (Class aClass : classes) {
            getBean(aClass);
        }
        // check
        System.out.println(getBean(B.class).getA() == getBean(A.class));
        System.out.println(getBean(A.class).getB() == getBean(B.class));
    }

    @SneakyThrows
    private static <T> T getBean(Class<T> beanClass) {
        // 本文用类名小写 简单代替bean的命名规则
        String beanName = beanClass.getSimpleName().toLowerCase();
        // 如果已经是一个bean，则直接返回
        if (cacheMap.containsKey(beanName)) {
            return (T) cacheMap.get(beanName);
        }
        // 将对象本身实例化
        Object object = beanClass.getDeclaredConstructor().newInstance();
        // 放入缓存
        cacheMap.put(beanName, object);
        // 把所有字段当成需要注入的bean，创建并注入到当前bean中
        Field[] fields = object.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            // 获取需要注入字段的class
            Class<?> fieldClass = field.getType();
            String fieldBeanName = fieldClass.getSimpleName().toLowerCase();
            // 如果需要注入的bean，已经在缓存Map中，那么把缓存Map中的值注入到该field即可
            // 如果缓存没有 继续创建
            field.set(object, cacheMap.containsKey(fieldBeanName)
                    ? cacheMap.get(fieldBeanName) : getBean(fieldClass));
        }
        // 属性填充完成，返回
        return (T) object;
    }

这段代码的效果，其实就是处理了循环依赖，并且处理完成后，cacheMap中放的就是完整的“ Bean ”了

这就是“ 循环依赖 ”的本质，而不是“Spring如何解决循环依赖”。

之所以要举这个例子，是发现一小部分盆友陷入了“ 阅读源码的泥潭 ”，而忘记了问题的本质。

为了看源码而看源码，结果一直看不懂，却忘了本质是什么。

如果真看不懂，不如先写出基础版本，逆推Spring为什么要这么实现，可能效果会更好。

what？问题的本质居然是two sum！

看完笔者刚才的代码有没有似曾相识？没错，和 two sum 的解题是类似的。

不知道 two sum 是什么梗的，笔者和你介绍一下：

two sum是刷题网站 leetcode 序号为1的题，也就是大多人的算法入门的第一题。

常常被人调侃，有 算法面 的公司，被面试官钦定了，合的来。那就来一道 two sum 走走过场。

问题内容是：给定 一个数组 ，给定 一个数字 。返回数组中可以 相加得到指定数字 的两个 索引 。

比如：给定nums = [2, 7, 11, 15], target = 9 那么要返回 [0, 1]，因为2 + 7 = 9

这道题的优解是，一次遍历+HashMap：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

先去Map中找 需要的数字 ，没有就将 当前的数字 保存在Map中，如果找到 需要的数字 ，则一起返回。

和笔者上面的代码是不是一样？

先去缓存里找 Bean ，没有则 实例化当前的Bean 放到Map，如果有需要 依赖 当前Bean的，就能从Map取到。

spring源码

1.检查缓存中是否已经存在实例化完毕的Bean

protected Object getSingleton(String beanName, boolean allowEarlyReference) {   //首先检查一级缓存中是否存在   Object singletonObject = this.singletonObjects.get(beanName);   /**    *  如果一级缓存中不存在代表当前 Bean 还未被创建或者正在创建中    *  检查当前 Bean 是否正处于正在创建的状态中(当Bean创建时会将Bean名称存放到 singletonsCurrentlyInCreation 集合中)   */   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {      synchronized (this.singletonObjects) {         //检查二级缓存中是否存在         singletonObject = this.earlySingletonObjects.get(beanName);         /**          * @@如果二级缓存中不存在 并且 允许使用早期依赖          * allowEarlyReference ： 它的含义是是否允许早期依赖          * @@那么什么是早期依赖？           * 就是当Bean还未成为成熟的Bean时就提前使用它，在实例化流程图中我们看到在添加缓存前刚刚实例化Bean但是还未依赖注入时的状态         */         if (singletonObject == null && allowEarlyReference) {                        //获取三级缓存中的 Bean ObjectFactory            ObjectFactory singletonFactory = this.singletonFactories.get(beanName);            //如果 Bean 对应的 ObjectFactory 存在            if (singletonFactory != null) {               //使用 getObject 方法获取到 Bean 的实例               singletonObject = singletonFactory.getObject();               //将 bean 从三级缓存提升至二级缓存               this.earlySingletonObjects.put(beanName, singletonObject);               this.singletonFactories.remove(beanName);            }         }      }   }   return singletonObject;}

2.创建Bean

`protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)      throws BeanCreationException {   

/**    * 我们一开始通过 getSingleton() 方法中获取三级缓存中存放的Bean，这里就是向三级缓存中添加 bean 的地方   
* 流程:    
* 1.检查当前 bean 是否为单例模式，并且是否允许循环引用[讲解1],并且当前是否正在创建中(在getSingleton方法中添加的)    
* 2.如果允许提前曝光[讲解2]，addSingletonFactory() 方法向缓存中添加当前 bean 的 ObjectFactory    
*    * [讲解1]：当前 Bean 如果不允许循环引用(循环依赖也就是被依赖)，则这里就不会提前曝光，对应的 ObjectFactory    * 则当发生循环依赖时会抛出 BeanCreationException 异常   
*    * [讲解2]：提前曝光的含义就是说当 bean 还未创建完毕时就先将创建中状态的bean放到指定缓存中，为循环依赖提供支持   */   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&         isSingletonCurrentlyInCreation(beanName));   //需要提前曝光   if (earlySingletonExposure) {      
/**       * 向缓存(三级缓存)中添加当前 bean 的 ObjectFactory      */      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));   }   
/**    * Initialize the bean instance.    * 初始化 Bean 实例阶段   */   Object exposedObject = bean;   try {      /**       *  依赖注入这时会递归调用getBean      */      populateBean(beanName, mbd, instanceWrapper);      //调用初始化方法，如：init-method      exposedObject = initializeBean(beanName, exposedObject, mbd);   }      /**    * 当允许提前曝光时进入判断    * @这里做了什么？    * 1.检查当前bean是否经历了一场循环依赖    *   - 通过 getSingleton(beanName,false) 获取缓存中的 bean，传入 false 代表不获取三级缓存中的bean    *   - 为什么说 检查当前bean是否经历了一场循环依赖呢？ 因为上述说了传入 false 代表不获取三级缓存的    *   - 那么什么情况下才会存在与一级缓存和二级缓存呢？答案就是循环依赖后 [解释1] 和bean实例化完成后    *   - 所以如果 getSingleton 返回的 bean 不为空，则这个bean就是刚刚经历了循环依赖    *    * 2.检查提前曝光的bean和当前的Bean是否一致    *   - 下面有个判断 if (exposedObject == bean) ，这个判断从缓存中获取的bean 和 经历过初始化后的 bean    *   - 是否一致，可能我们有点晕，这里解释一下，缓存从的bean是什么时候存进去的？是在 addSingletonFactory 方法(649行)    *   - 然后这里存进去的 bean 只是提前曝光的 bean，还没有依赖注入和初始化，但是在依赖注入和初始化时都是可能直接改变    *   - 当前 bean 的实例的，这意味着什么？意味着经历了依赖注入和初始化的bean很可能和缓存中的bean就已经完全不是一个 bean了    *   下面讲解当一致或不一致时的逻辑：    * 2.1 一致：    *  不是很理解，直接赋值，可是经历了各种 BeanPostProsser 或者依赖注入和初始化后不是就不一样了吗    * 2.2 不一致:    *  看下方对于 else if 代码块的解释    *    * @[解释1]    * 当循环依赖时，A依赖着B，B依赖着A，实例化A首先将A放到三级缓存中然后发现依赖着B，然后去实例化B，发现依赖着A    * 发现A在三级缓存，然后获取三级缓存中的bean并且将A从三级缓存中提升到二级缓存中，实例化B完成，接着实例化A也完成。    *    * @通俗讲解    * 假设我们业务上对某种数据加了缓存，假设 i 在缓存中存的值为1，当我在数据库中把 i 的值改成 2 时，缓存中的 i 还没有被改变还是 1    * 这时的数据已经和我们的真实数据偏离了，不一致了，这时有两种解决方式：1.服务器检查到数据不一致抛出异常。(也就是进入else if 代码块)    * 2.直接使用原始值也就是1(也就是将 allowRawInjectionDespiteWrapping 改成 true),当然这两种方式明显不是我们正常数据库的操作，只是    * 为了说明当前的这个例子而已。    *   */   if (earlySingletonExposure) {      //获取缓存中(除三级缓存) beanName 对应的 bean      Object earlySingletonReference = getSingleton(beanName, false);      //当经历了一场循环依赖后 earlySingletonReference 就不会为空      if (earlySingletonReference != null) {         //如果 exposedObject 没有在初始化方法中被改变，也就是没有被增强         if (exposedObject == bean) {            //直接赋值? 可是经历了各种 BeanPostProsser 或者依赖注入和初始化后不是就不一样了吗            exposedObject = earlySingletonReference;         }         /**          *          * 走到 else if  时说明 当前 Bean 被 BeanPostProessor 增强了          * 判断的条件为：          * 1.如果允许使用被增强的          * 2.检查是否存在依赖当前bean的bean          *          * 如果存在依赖的bean已经被实例化完成的，如果存在则抛出异常          * 为什么抛出异常呢？          * 因为依赖当前bean 的bean 已经在内部注入了当前bean的旧版本，但是通过初始化方法后这个bean的版本已经变成新的了          * 旧的哪个已经不适用了，所以抛出异常          *         */         else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {            String[] dependentBeans = getDependentBeans(beanName);            Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);            for (String dependentBean : dependentBeans) {               if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {                  actualDependentBeans.add(dependentBean);               }            }            if (!actualDependentBeans.isEmpty()) {               throw new BeanCurrentlyInCreationException(beanName,                     "Bean with name '" + beanName + "' has been injected into other beans [" +                     StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +                     "] in its raw version as part of a circular reference, but has eventually been " +                     "wrapped. This means that said other beans do not use the final version of the " +                     "bean. This is often the result of over-eager type matching - consider using " +                     "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");            }         }      }   }   try {      /**       * Register bean as disposable.       * 注册 Bean 的销毁方法拓展      */      registerDisposableBeanIfNecessary(beanName, bean, mbd);   }   catch (BeanDefinitionValidationException ex) {      throw new BeanCreationException(            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);   }   return exposedObject;}

参考链接：spring源码解析： https://m.toutiao.com/i677612...