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;
 
 //嘗試獲取單例對象，因為spring大部分的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是單例模式，但之前并沒有實例化，或者是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)建一個新對象.
    Object prototypeInstance = null;
    try {
     /*這里是Prototype循環(huán)依賴的問題，會記錄在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這個東西，: bean name --> ObjectFactory */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

/** 也是緩存創(chuàng)建的單例對象，功能和singletonObjects不一樣，
在bean構(gòu)造成功之后，屬性初始化之前會把對象放入到這里，
主要是用于解決屬性注入的循環(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)依賴就拋出異常，而在單例中會嘗試解決 */
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 {

 // 實例化bean
 BeanWrapper instanceWrapper = null;
 if (mbd.isSingleton()) {
  instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
 }
 if (instanceWrapper == null) {
  //如果沒實例化則創(chuàng)建新的BeanWrapper
  //如果是通過構(gòu)造器注入，這里是一個關(guān)鍵點(diǎn)
  /*
  因為在A初始化的時候發(fā)現(xiàn)構(gòu)造函數(shù)依賴B，就會去實例化B，
  然后B也會運(yùn)行到這段邏輯，構(gòu)造函數(shù)中發(fā)現(xiàn)依賴A，
  這個時候就會拋出循環(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，就把這個半成品返回回去。
  */
  addSingletonFactory(beanName, new ObjectFactory<Object>() {
   @Override
   public Object getObject() throws BeansException {
    return getEarlyBeanReference(beanName, mbd, bean);
   }
  });
 }

 
 Object exposedObject = bean;
 try {
  //自動注入屬性
  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;
}