[读书笔记]Spring中的循环依赖详解

什么是循环依赖？

循环依赖就是N个类中循环嵌套引用，如果在日常开发中我们用new 对象的方式发生这种循环依赖的话程序会在运行时一直循环调用，直至内存溢出报错。

那么Spring是如何解决循环依赖的？

【1】Spring循环依赖的三种方式

① 构造器参数循环依赖

Spring容器会将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中，Bean标识符在创建过程中将一直保持在这个池中，因此如果在创建Bean过程中发现自己已经在“当前创建Bean池”里时将抛出​​BeanCurrentlyInCreationException​​异常表示循环依赖。而对于创建完毕的Bean将从“当前创建Bean池”中清除掉。

首先我们先初始化三个Bean。

public class StudentA {
  private StudentB studentB ;
  public void setStudentB(StudentB studentB) {
    this.studentB = studentB;
  }
  public StudentA() {
  }
  public StudentA(StudentB studentB) {
    this.studentB = studentB;
  }
}

public class StudentB {
  private StudentC studentC ;
  public void setStudentC(StudentC studentC) {
    this.studentC = studentC;
  }
  public StudentB() {
  }
  public StudentB(StudentC studentC) {
    this.studentC = studentC;
  }
}
public class StudentC {
  private StudentA studentA ;
  public void setStudentA(StudentA studentA) {
    this.studentA = studentA;
  }
  public StudentC() {
  }
  public StudentC(StudentA studentA) {
    this.studentA = studentA;
  }
}

也就是A依赖B，B依赖C，C依赖A。如果这时候创建实例A，将会抛出如下异常：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException:
Error creating bean with name 'a': Requested bean is currently in creation:
Is there an unresolvable circular reference?

Spring容器先创建单例StudentA，StudentA依赖StudentB，然后将A放在“当前创建Bean池”中，此时创建StudentB,StudentB依赖StudentC ,然后将B放在“当前创建Bean池”中,此时创建StudentC，StudentC又依赖StudentA， 但是，此时StudentA已经在池
中，所以会报错，，因为在池中的Bean都是未初始化完的，所以会依赖错误 ，（初始化完的Bean会从池中移除）。

下图来源于网络

② set方法注入单例

如果要说setter方式注入的话，我们最好先看一张Spring中Bean实例化的图

如图中前两步骤得知：Spring是先将Bean对象实例化之后再设置对象属性的。

这时候我们再次获取StudentA对象将会成功获取到。

public class Test {
  public static void main(String[] args) {
    ApplicationContext context = new
    ClassPathXmlApplicationContext("com/zfx/student/applicationContext.xml");
    System.out.println(context.getBean("a", StudentA.class));
  }
}

那么为什么此时不会发生循环依赖异常呢？我们结合上面那张图看，Spring先是用构造实例化Bean对象 ，此时Spring会将这个实例化结束的对象放到一个Map中，并且Spring提供了获取这个未设置属性的实例化对象引用的方法。

结合我们的实例来看，当Spring实例化了StudentA、StudentB、StudentC后，紧接着会去设置对象的属性，此时StudentA依赖StudentB，就会去Map中取出存在里面的单例StudentB对象，以此类推，不会出现循环的问题。

---

我们常用的可能是如下方式：

@Component
public class StudentA {
    @Autowired
    StudentB studentB;
}

@Component
public class StudentB {
    @Autowired
    StudentC studentc;
}

@Component
public class StudentC {

    @Autowired
    StudentA studentA;
}

// 如下测试代码
@Api(tags = {"意见反馈"})
@Controller
@RequestMapping({"/advice","home/advice"})
public class SysAdviceController {

    @Autowired
    StudentA studentA;

    @ResponseBody
    @RequestMapping("/test")
    public ResponseBean test(){
        System.out.println("************************"+studentA);
        return ResultUtil.success();
    }
    //...
}

这里我们可以看下获取的对象，其同样是完成了正常的实例化，并没有出现循环依赖异常。可以说这样属性注入本质与setXXX单例是一样的。

---

③ setter方式原型，prototype

​​scope="prototype"​​ 意思是 每次请求都会创建一个实例对象。两者的区别是：有状态的bean都使用Prototype作用域，无状态的一般都使用singleton单例作用域。

这里直接说明测试结果：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException:
Error creating bean with name 'a': Requested bean is currently in creation:
Is there an unresolvable circular reference?

对于“prototype”作用域Bean，Spring容器无法完成依赖注入，因为“prototype”作用域的Bean，Spring容器不进行缓存，因此无法提前暴露一个创建中的Bean。

【2】从源码角度看Spring如何解决循环依赖

Spring的三级缓存

其实这里要了解Spring的三级缓存。下面是DefaultSingletonBeanRegistry中的一些常量：

• 一级缓存​​Map<String, Object> singletonObjects​​
• 二级缓存​​Map<String, Object> earlySingletonObjects​​
• 三级缓存​​Map<String, ObjectFactory<?>> singletonFactories​​

// 一级缓存，存放beanName和Bean instance
/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

// 三级缓存  bean name - -objectFactory
/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

// 二级缓存，存放beanName和Bean instance  early：早期的
/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

// 注册序列的bean名称--单例哦
/** Set of registered singletons, containing the bean names in registration order. */
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

// 正在创建的bean的名称
/** Names of beans that are currently in creation. */
private final Set<String> singletonsCurrentlyInCreation =
    Collections.newSetFromMap(new ConcurrentHashMap<>(16));

在[读书笔记]IOC容器的依赖注入详解​我们看到了Bean创建的过程。

如上图所示，在doGetBean的方法中首先调用​​​DefaultSingletonBeanRegistry​​​的​​getSingleton(java.lang.String, boolean)​​方法尝试拿到单例缓存(也就是前面创建的，但是还可能没有完全完成bean的实例化)。

getSingleton方法是用来急切地检查手动注册的单例缓存。其允许当前创建的单例暴露出去，用来解决循环依赖。

// AbstractBeanFactory#doGetBean
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从一级缓存里面获取
  Object singletonObject = this.singletonObjects.get(beanName);
  // 如果一级缓存获取不到，且beanName是正在创建的Bean
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  // 对一级缓存加锁
    synchronized (this.singletonObjects) {
      //从二级缓存里面获取
      singletonObject = this.earlySingletonObjects.get(beanName);
      
      // allowEarlyReference 这里传入的是true  允许bean提前暴露
      // 如果二级缓存里面没有，则从三级缓存获取工厂
      if (singletonObject == null && allowEarlyReference) {
        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
        if (singletonFactory != null) {
        // 得到工厂生产的bean
          singletonObject = singletonFactory.getObject();
          // 放入二级缓存
          this.earlySingletonObjects.put(beanName, singletonObject);
          // 从三级缓存移除
          this.singletonFactories.remove(beanName);
        }
      }
    }
  }
  return singletonObject;
}

如果这里获取到了会直接调用​​bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);​​获取最终bean实例。然后判断是否需要格式化，之后返回。

如果这里获取不到，那么就会走创建流程。最终我们会在​​AbstractAutowireCapableBeanFactory的doCreateBean​​方法中看到这样的关键几步：

// 创建对象
instanceWrapper = createBeanInstance(beanName, mbd, args);

//单例  允许循环引用  是当前正在创建的bean，则调用addSingletonFactory  allowCircularReferences 默认为true
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
  if (logger.isTraceEnabled()) {
    logger.trace("Eagerly caching bean '" + beanName +
        "' to allow for resolving potential circular references");
  }
  // 放到三级缓存
  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

// 依赖注入，实例化后期处理
Object exposedObject = bean;
try {
  // 属性赋值，解析依赖，循环依赖也发生在这个过程
  populateBean(beanName, mbd, instanceWrapper);
  // bean实例化的后置处理，比如beanpostprocessor   init-method等
  exposedObject = initializeBean(beanName, exposedObject, mbd);
}

我们看下这个addSingletonFactory方法，这个方法让那些需要迫切注册单例，例如能够解析循环引用场景使用。

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
  Assert.notNull(singletonFactory, "Singleton factory must not be null");
  synchronized (this.singletonObjects) {//对一级缓存加锁
    if (!this.singletonObjects.containsKey(beanName)) { //如果一级缓存不存在该bean
      this.singletonFactories.put(beanName, singletonFactory);//放入三级缓存
      this.earlySingletonObjects.remove(beanName);//从二级缓存移除
      this.registeredSingletons.add(beanName);//放入bean名称
    }
  }
}

这样当执行到populateBean时 ，如果两个对象相互依赖，那么当前对象(假设为A)的实例化就会触发另外一个对象(假设为B)的实例化。当B实例化时其又依赖了A就会从三级缓存(或二级缓存)获取A的引用完成实例化从而最终完成A的实例化。

那么二级缓存在这里面的作用呢?

假设AB相互依赖，AC相互依赖。那么B实例化后，就该进行C的实例化，这时C就可以从二级缓存来获取A的实例引用了，就不需要再从三级缓存获取工厂让其生产实例。

即假设只有AB相互依赖，其他对象不依赖AB时，这里二级缓存是没用的，一级和三级缓存起作用。

那么什么时候放入一级缓存呢？

仍旧在AbstractBeanFactory的doGetBean方法中。如下代码所示，首先运行createBean方法，其次会调用getSingleton方法。

// Create bean instance.
if (mbd.isSingleton()) {
  sharedInstance = getSingleton(beanName, () -> {
    try {
      return createBean(beanName, mbd, args);
    }
    catch (BeansException ex) {
      // Explicitly remove instance from singleton cache: It might have been put there
      // eagerly by the creation process, to allow for circular reference resolution.
      // Also remove any beans that received a temporary reference to the bean.
      destroySingleton(beanName);
      throw ex;
    }
  });
  bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

这里调用的getSingleton方法是​​getSingleton(String beanName, ObjectFactory<?> singletonFactory)​​​,如下所示如果未从一级缓存得到singletonObject ，那么其会调用​​addSingleton(beanName, singletonObject);​​方法。

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 + "'");
      }
      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;
  }
}

​​addSingleton(beanName, singletonObject);​​方法如下所示：

protected void addSingleton(String beanName, Object singletonObject) {
  synchronized (this.singletonObjects) {
    // 放入一级缓存
    this.singletonObjects.put(beanName, singletonObject);
    // 从三级缓存移除
    this.singletonFactories.remove(beanName);
    // 从二级缓存移除
    this.earlySingletonObjects.remove(beanName);
    // 放入registeredSingletons中
    this.registeredSingletons.add(beanName);
  }
}

参考博文：
​[读书笔记]IOC容器的依赖注入详解