Spring源码解析之循环依赖处理（5）

什么是循环依赖？

    循环依赖其实就是两个或者两个以上的bean，互相引用对方，形成闭环，如A--->B，B--->C，C--->A。这样的依赖就是循环依赖。而循环依赖在正常的情况下就是一个死循环，A的初始化为引起B的初始化，B的初始化会触发C的初始化，而C的初始化会触发A的初始化，死循环了。

   Spring的循环依赖有两种：

1. 构造器的循环依赖
2. 属性的循环依赖      

      构造器的循环依赖是没有Spring的无法解决，所以会抛出异常。我们分析的都是基于属性的循环依赖。

循环依赖的处理。

 第一次处理循环依赖的地方是doGetBean()方法中的：

Object sharedInstance = getSingleton(beanName);

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            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;
}

  这个方法其实之前分析过的，我们可以这样理解循环依赖有三层的缓存。

 singletonObjects：一级缓存，存放的是beanName和bean实例。

earlySingletonObjects：二级缓存，存放的是beanName和已经被初始化但是没有创建完成的bean实例。也就是允许提前曝光的bean的实例

singletonFactory：三级缓存，存放的是beanName和ObjectFactory工厂。

通过这三层缓存的有效的解决了Spring的属性循环依赖问题。这个方法还有两个方法要解析。

1. isSingletonCurrentlyInCreation方法：判断bean是否在创建中。
2. allowEarlyReference：判断bean是否可以被提前曝光。

       getSingletion()这个逻辑：从一级缓存singletonObjects中获取，如果没有当前beanName的是实例并且正在创建中，那么就从二级缓存中earlySingletonObjects获取，如果还是没有获取到，那么从三级缓存中获取并调用getObject()去获取bean的实例，并将其加入二级缓存earlySingletonObjects，从三级缓存singletonFactory中删除。

 那么三级缓存的添加是从哪里开始的。追踪createBean()方法，在doCreateBean()方法中

//判读条件
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));

addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))

 当earlySingletonExposure==true时，会去执行addSingletonFactory()方法。

那满足添加三级缓存的的条件是：

1. mbd.isSingleton()：单例模式
2. this.allowCircularReferences：该bean允许被提前曝光
3. isSingletonCurrentlyInCreation(beanName)：正在处于创建中

protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

这个段代码是在createBeanInstance()之后，bean的实例是已经创建出来，但是并没有属性进行初始化。但是并不妨碍其他bean
对这个bean的对象引用。

 

 下面分析一级缓存的添加逻辑在在类 DefaultSingletonBeanRegistry 中可以发现这个 addSingleton() 方法：

 addSingleton(beanName, singletonObject)方法在this.singletonObjects.get(beanName)之后

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);
    }
}

在Spring解决循环依赖的方案中:Spring在创建bean的时候并不是等完全完成，而是在创建过程中将创建的bean的ObjectFactory提前曝光（加入三级缓存），这样另外的bean需要依赖的bean，可以直接使用ObjectFactory的getObejct获取。

        到这里，关于 Spring 解决 bean 循环依赖就已经分析完毕了。最后来描述下就上面那个循环依赖 Spring 解决的过程：首先 A 完成初始化第一步并将自己提前曝光出来（通过 ObjectFactory 将自己提前曝光），在初始化的时候，发现自己依赖对象 B，此时就会去尝试 get(B)，这个时候发现 B 还没有被创建出来，然后 B 就走创建流程，在 B 初始化的时候，同样发现自己依赖 C，C 也没有被创建出来，这个时候 C 又开始初始化进程，但是在初始化的过程中发现自己依赖 A，于是尝试 get(A)，这个时候由于 A 已经添加至缓存中（一般都是添加至三级缓存 singletonFactories ），通过 ObjectFactory 提前曝光，所以可以通过 ObjectFactory.getObject() 拿到 A 对象，C 拿到 A 对象后顺利完成初始化，然后将自己添加到一级缓存中，回到 B ，B 也可以拿到 C 对象，完成初始化，A 可以顺利拿到 B 完成初始化。到这里整个链路就已经完成了初始化过程了。