spring循環(huán)依賴策略解析

protected <T> T doGetBean(
    final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
    throws BeansException {
  
  final String beanName = transformedBeanName(name);
  Object bean;
  
  //嘗試獲取單例對象，因?yàn)閟pring大部分的bean都是單例的，所以這里先嘗試能否獲取。
  registered singletons.
  Object sharedInstance = getSingleton(beanName);
  //單例存在的情況下，那么beanName返回的肯定是單例類，但是這里還需要判斷是不是FactoryBean
  if (sharedInstance != null && args == null) {
    ...
    //FactoryBean應(yīng)該返回getObject()對象
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  }
  
  else {
    //走到這里，有可能beanName是單例模式，但之前并沒有實(shí)例化，或者是Prototype類型。
    //首先判斷不是循環(huán)依賴，這里的循環(huán)依賴指的是Prototype類型
    if (isPrototypeCurrentlyInCreation(beanName)) {
      throw new BeanCurrentlyInCreationException(beanName);
    }
  
  
    try {
      final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
      // 如果是單例，則創(chuàng)建單例模式
      if (mbd.isSingleton()) {
        // !!!這里是解決單例循環(huán)依賴的關(guān)鍵，后面再分析
        sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
          @Override
          public Object getObject() throws BeansException {
            try {
              return createBean(beanName, mbd, args);
            }
            catch (BeansException ex) {
              throw ex;
            }
          }
        });
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
      }
  
      else if (mbd.isPrototype()) {
        // 原型模式，則創(chuàng)建一個(gè)新對象.
        Object prototypeInstance = null;
        try {
          /*這里是Prototype循環(huán)依賴的問題，會(huì)記錄在map中beanName，
          如果在解決當(dāng)前Bean的依賴過程中還依賴當(dāng)前Bean，
          則說明了出現(xiàn)了循環(huán)依賴
          */
              beforePrototypeCreation(beanName);
              prototypeInstance = createBean(beanName, mbd, args);
        }
        finally {
          //對應(yīng)beforePrototypeCreation()，從map中移除
              afterPrototypeCreation(beanName);
        }
        bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
      }
      ...
    }
  }
  
  ...
  return (T) bean;
}

sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
  @Override
  public Object getObject() throws BeansException {
    try {
      return createBean(beanName, mbd, args);
    }
    catch (BeansException ex) {
      throw ex;
    }
  }
});

/** 緩存創(chuàng)建的單例對象: bean名字 --> bean對象 */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

/** 緩存單例的factory,就是ObjectFactory這個(gè)東西，: bean name --> ObjectFactory */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

/** 也是緩存創(chuàng)建的單例對象，功能和singletonObjects不一樣，
在bean構(gòu)造成功之后，屬性初始化之前會(huì)把對象放入到這里，
主要是用于解決屬性注入的循環(huán)引用: bean name --> bean instance 
*/
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

/** 記錄在創(chuàng)建單例對象中循環(huán)依賴的問題，還記得Prototype中又記錄創(chuàng)建過程中依賴的map嗎？
在Prototype中只要出現(xiàn)了循環(huán)依賴就拋出異常，而在單例中會(huì)嘗試解決 */
private final Set<String> singletonsCurrentlyInCreation =
    Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {

  synchronized (this.singletonObjects) {
    //嘗試在singletonObjects中獲取
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null) {
      //不存在則創(chuàng)建
      //把當(dāng)前beanName加入到singletonsCurrentlyInCreation中
      beforeSingletonCreation(beanName);
      try {
        
        singletonObject = singletonFactory.getObject();
      }
      ...
      finally {
        ...
        //從singletonsCurrentlyInCreation中刪除beanName
        afterSingletonCreation(beanName);
      }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
  }
}

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
  ...
  Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  ...
}

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

  // 實(shí)例化bean
  BeanWrapper instanceWrapper = null;
  if (mbd.isSingleton()) {
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  }
  if (instanceWrapper == null) {
    //如果沒實(shí)例化則創(chuàng)建新的BeanWrapper
    //如果是通過構(gòu)造器注入，這里是一個(gè)關(guān)鍵點(diǎn)
    /*
    因?yàn)樵贏初始化的時(shí)候發(fā)現(xiàn)構(gòu)造函數(shù)依賴B，就會(huì)去實(shí)例化B，
    然后B也會(huì)運(yùn)行到這段邏輯，構(gòu)造函數(shù)中發(fā)現(xiàn)依賴A，
    這個(gè)時(shí)候就會(huì)拋出循環(huán)依賴的異常
    */
        instanceWrapper = createBeanInstance(beanName, mbd, args);
  }
  

  //如果當(dāng)前是單例，并且allowCircularReferences為true(默認(rèn)就是true，除非我們不希望Spring幫我們解決)
  boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));
  if (earlySingletonExposure) {
    /*
    ?。?！這里很重要，把構(gòu)造成功，但屬性還沒注入的
    的bean加到singletonFactory中，這樣再解決A的依賴
    過程中如果依賴A，就把這個(gè)半成品返回回去。
    */
    addSingletonFactory(beanName, new ObjectFactory<Object>() {
      @Override
      public Object getObject() throws BeansException {
        return getEarlyBeanReference(beanName, mbd, bean);
      }
    });
  }

  
  Object exposedObject = bean;
  try {
    //自動(dòng)注入屬性
    populateBean(beanName, mbd, instanceWrapper);
    if (exposedObject != null) {
      exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
  }
  ...

  return exposedObject;
}

@Component
public class BeanA {
  private BeanB beanB;

  @Autowired
  public BeanA(BeanB beanB) {
    this.beanB = beanB;
  }
}

@Component
public class BeanB {
  @Autowired
  private BeanA beanA;
}