Spring 循环依赖

什么是循环依赖

概念： 在代码中对象A依赖对象B，对象B依赖对象A，对象相互之间依赖关系；

Class A{
 private B b;
}
Class B{
private A a;
}

Spring能解决什么情况下的依赖

• Spring单例对象的属性之间形成的循环依赖

Class A {
B b ;
private setB(B b){
this.b=b;
}
}

Spring不能解决循环依赖的情况

• 原型的依赖，因为已经委托给容器管理
• 单例的构造器注入；(Spring在refresh()初始化bean对象过程中，需要创建一个Springbean，然后注入其对象)

Spring如何解决的单例的循环依赖问题

三个缓存对象

1：在DefaultSingletonBeanRegistry 单例的注册中心有三个缓存的对象：

• singletonObjects 对象的一级缓存，创建完成后的对象，都在该对象中；
• singletonFactories 单例bean的三级缓存；单例对象工厂的cache，第一次创建的bean单例对象，在第一次创建过程都会现在此缓存一下；
• earlySingletonObjects 提前曝光的单例对象（对象在进行属性注入的时候，获取到singletonFactories中的对象，会将singletonFactories 中的对象，缓存到earlySingletonObjects中去）

2 源码分析

• 先分析获取单例对象时候，先从缓存中拿到单例对象

@Nullable
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);//判断三级缓存中是否存在bean对象
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();//从三级缓存中取出数据的时候，需要将bean对象转换成器代理对象，
               this.earlySingletonObjects.put(beanName, singletonObject);//如果三级缓存中存在，吧bean 对象加入到二级缓存中
               this.singletonFactories.remove(beanName);//移除三级缓存中的数据
            }
         }
      }
   }
   return singletonObject;
}

通过上述代码，非常清晰的告诉读者；在单例的对象创建之前，都会先从一级缓存的singletonObjects获取对象；

如果一级缓存中没有，从earlySingletonObjects 提前曝光的二级缓存中获取对象；

• 在创建bean 开始之前，还会在判断一次缓存中，对象是否存在，从singletonObjects 和 singletonFactories缓存中获取；

  /**
   * Return the (raw) singleton object registered under the given name,
   * creating and registering a new one if none registered yet.
   * @param beanName the name of the bean
   * @param singletonFactory the ObjectFactory to lazily create the singleton
   * with, if necessary
   * @return the registered singleton object
   */
  public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
     Assert.notNull(beanName, "Bean name must not be null");
     synchronized (this.singletonObjects) {
        //从单例池中取出对象
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
           //是否正在销毁，异常
           if (this.singletonsCurrentlyInDestruction) {
              throw new BeanCreationNotAllowedException(beanName,
                    "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                    "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
           }
           if (logger.isDebugEnabled()) {
              logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
           }
           //验证完 要真正开始创建对象，先从标识该bean正在被创建，因为Springbean创建过程复杂，步骤很多，需要标识
           beforeSingletonCreation(beanName);
           boolean newSingleton = false;
           boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
           if (recordSuppressedExceptions) {
              this.suppressedExceptions = new LinkedHashSet<>();
           }
           try {
              singletonObject = singletonFactory.getObject();
              newSingleton = true;
           }
           catch (IllegalStateException ex) {
              // Has the singleton object implicitly appeared in the meantime ->
              // if yes, proceed with it since the exception indicates that state.
              singletonObject = this.singletonObjects.get(beanName);
              if (singletonObject == null) {
                 throw ex;
              }
           }
           catch (BeanCreationException ex) {
              if (recordSuppressedExceptions) {
                 for (Exception suppressedException : this.suppressedExceptions) {
                    ex.addRelatedCause(suppressedException);
                 }
              }
              throw ex;
           }
           finally {
              if (recordSuppressedExceptions) {
                 this.suppressedExceptions = null;
              }
              afterSingletonCreation(beanName);
           }
           if (newSingleton) {
              addSingleton(beanName, singletonObject);
           }
        }
        return singletonObject;
     }
  }
  

  单例对象在第一次创建的时候，都会将单例对象bean，先放在singletonFactories当中

    /**
     * Add the given singleton factory for building the specified singleton
     * if necessary.
     * <p>To be called for eager registration of singletons, e.g. to be able to
     * resolve circular references.
     * @param beanName the name of the bean
     * @param singletonFactory the factory for the singleton object
     * 
     *
     */
  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);//加入三级缓存，所以现在singletonFactory，
           this.earlySingletonObjects.remove(beanName);//并从二级缓存中删除
           this.registeredSingletons.add(beanName);
        }
     }
  }
  

总结：根据上述的源代码，getSingleton和addSingletonFactory ，知道了三个缓存中的转换关系；如果A依赖B，B依赖A

• A对象第一次创建，先执行getSingleton（）方法 bean对象会返回为空，在执行addSingletonFactory()，正在创建的bean会先放在singletonFactories 中

• 因为A依赖B，在处理A的成员变量B的创建过程中，B，也是先执行getSingleton（）方法 bean对象会返回为空，在执行addSingletonFactory()，正在创建的bean会先放在singletonFactories 中

• 所以此时 singletonFactories 中存在两个正在创建的bean,A 和B；

• 因为B同样依赖A，B的属性依赖A的对象，在创建的时候，先执行getSingleton（），很清楚的发现

  if (singletonFactory != null) {
                 singletonObject = singletonFactory.getObject();//从三级缓存中取出数据的时候，需要将bean对象转换成器代理对象，
                 this.earlySingletonObjects.put(beanName, singletonObject);//如果三级缓存中存在，把bean 对象加入到二级缓存中
                 this.singletonFactories.remove(beanName);//移除三级缓存中的数据
              }
  

  此时对象A从singletonFactory 中取出，并加入到earlySingletonObjects 缓存当中去；并将对象返回；

• B对象依赖的成员变量A 在创建过程中，在三级缓存中获取得到了对象A，并将其缓存到二级对象earlySingletonObjects中，然后此时回调；B对象先完成创建，并将B对象放在一级缓存（singletonObjects）中

• B对象,完成initializeBean(aware接口实现，init方法实现，beanpostprocessor实现)完成创建，回溯到A对象中的属性B完成创建

• A对象的其它属性创建成功，A对象最后从二级缓存中获取到A的对象，放在一级缓存当中

Spring调用栈的时序图

分析spring 解决循环依赖问题，需要主要上面的几个流程，同时把握Spring 源码在初始化Spring bean对象的过程；

• refresh()方法 abstractApplicationContext的方法，bean对象初始化的入口
• finishBeanFactoryInitialization() bean 对象创建的入口方法
• preInstantiateSingletons() ,加载bean对象的RootBeanDefinition,并且开始getBean()，注意bean的动态的代理对象也是再次获取

下面是具体的时序图；有待完善，只记录自己的学习过程

时序图.png