spring中循环依赖的解决--三级缓存

一、循环依赖的产生和解决的前提

循环依赖的产生可能有很多种情况，例如：

1. A的构造方法中依赖了B的实例对象，同时B的构造方法中依赖了A的实例对象
2. A的构造方法中依赖了B的实例对象，同时B的某个field或者setter需要A的实例对象，以及反之
3. A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象，以及反之

Spring对于循环依赖的解决不是无条件的，首先前提条件是针对scope单例并且没有显式指明不需要解决循环依赖的对象，而且要求该对象没有被代理过。同时Spring解决循环依赖也不是万能，以上三种情况只能解决两种，第一种在构造方法中相互依赖的情况Spring也无力回天。

初始化过程

Spring单例对象的初始化其实可以分为三步：（实例化、填充属性、初始化）

1. createBeanInstance， 实例化，实际上就是调用对应的构造方法构造对象，此时只是调用了构造方法，spring xml中指定的property并没有进
2. populate：populateBean，填充属性，这步对spring xml中指定的property进行populate
3. initializeBean，调用spring xml中指定的init方法，或者AfterPropertiesSet方法
   会发生循环依赖的步骤集中在第一步和第二步。

先来看看Spring中用来存储bean的map

/** Cache of singleton objects: bean name --> bean instance */

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

/** Cache of singleton factories: bean name --> ObjectFactory */

private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

/** Cache of early singleton objects: bean name --> bean instance */

private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

singletonObjects指单例对象的cache
singletonFactories指单例对象工厂的cache
earlySingletonObjects指提前曝光的单例对象的cache。

三级缓存的用法

protected Object getSingleton(String beanName, boolean allowEarlyReference) {

   Object singletonObject = this.singletonObjects.get(beanName);
	
	//isSingletonCurrentlyInCreation 判断对应的单例对象是否在创建中
	//当单例对象没有被初始化完全(例如A定义的构造函数依赖了B对象，得先去创建B对象，或者在populatebean过程中依赖了B对象，得先去创建B对象，此时A处于创建中)
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {

  synchronized (this.singletonObjects) {

     singletonObject = this.earlySingletonObjects.get(beanName);
    
    //allowEarlyReference 是否允许从singletonFactories中通过getObject拿到对象
     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 != NULL_OBJECT ? singletonObject : null);}

获取步骤:

1. 首先从singletonObjects（一级缓存）中尝试获取
2. 如果获取不到并且对象在创建中，则尝试从earlySingletonObjects(二级缓存)中获取
3. 如果还是获取不到并且允许从singletonFactories通过getObject获取，则通过singletonFactory.getObject()(三级缓存)获取。如果获取到了则将singletonObject放入到earlySingletonObjects,也就是 将三级缓存提升到二级缓存中

循环引用的具体解决

“A的某个field或者setter依赖了B的实例对象，同时B的某个field或者setter依赖了A的实例对象”
A首先完成了初始化的第一步，并且将自己提前曝光到singletonFactories中，此时进行初始化的第二步，发现自己依赖对象B，此时就尝试去get(B)，发现B还没有被create，所以走create流程，B在初始化第一步的时候发现自己依赖了对象A，于是尝试get(A)，尝试一级缓存singletonObjects(肯定没有，因为A还没初始化完全)，尝试二级缓存earlySingletonObjects（也没有），尝试三级缓存singletonFactories，由于A通过ObjectFactory将自己提前曝光了，所以B能够通过ObjectFactory.getObject拿到A对象(虽然A还没有初始化完全，但是总比没有好呀)，B拿到A对象后顺利完成了初始化阶段1、2、3，完全初始化之后将自己放入到一级缓存singletonObjects中。此时返回A中，A此时能拿到B的对象顺利完成自己的初始化阶段2、3，最终A也完成了初始化，长大成人，进去了一级缓存singletonObjects中，而且更加幸运的是，由于B拿到了A的对象引用，所以B现在hold住的A对象也完成了