// 一級緩存Map 存放完整的Bean（流程跑完的）
private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);

// 二級緩存Map 存放不完整的Bean（只實例化完，還沒屬性賦值、初始化）
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16);

// 三級緩存Map 存放一個Bean的lambda表達式（也是剛實例化完）
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);

@Service
public class AService {

    @Resource
    private BService bService;
}

@Service
public class BService {

    @Resource
    private AService aService;
}

//在spring中我們平時用到的getbean（）這個方法實際上是調(diào)用的AbstractBeanFactory這個抽象工廠中得getbean方法
public Object getBean(String name) throws BeansException {
//看源碼 我們首先看其返回值   如下返回得是doGetBean這個方法
        return this.doGetBean(name, null, null, false);
        }
//接下來我們看這個doGetBean這個方法
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {

 //獲取name對應的真正beanName
//有這么幾種情況 傳入得參數(shù)有可能是某個參數(shù)得別名，也有可能是FactoryBean的name  //根據(jù)具體得實例去解析最終的得name
final String beanName = this.transformedBeanName(name);

        Object bean;

      //   在創(chuàng)建單例bean的時候會存在依賴注入的情況，而在創(chuàng)建依賴的時候為了避免循環(huán)依賴
       //  Spring創(chuàng)建bean的原則是不等bean創(chuàng)建完成就會將創(chuàng)建bean的ObjectFactory提前曝光（將對應的ObjectFactory加入到緩存）
      //   一旦下一個bean創(chuàng)建需要依賴上一個bean，則直接使用ObjectFactory對象
        // 獲取單例
        Object sharedInstance = this.getSingleton(beanName);
        if (sharedInstance != null && args == null) {
        // 實例已經(jīng)存在
        if (logger.isDebugEnabled()) {
	        if (this.isSingletonCurrentlyInCreation(beanName)) {
	        	logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
	        } else {
	        	logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
	        }
        }
        // 返回對應的實例
        bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, null);
        } else {
	        // 單例實例不存在
	        if (this.isPrototypeCurrentlyInCreation(beanName)) {
	         // 只有在單例模式下才會嘗試解決循環(huán)依賴問題
	         // 對于原型模式，如果存在循環(huán)依賴，也就是滿足this.isPrototypeCurrentlyInCreation(beanName)，拋出異常
	        throw new BeanCurrentlyInCreationException(beanName);
        }

        // 獲取parentBeanFactory實例
        BeanFactory parentBeanFactory = this.getParentBeanFactory();
        // 如果在beanDefinitionMap中（即所有已經(jīng)加載的類中）不包含目標bean，則嘗試從parentBeanFactory中獲取
        if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
        	String nameToLookup = this.originalBeanName(name);  // 獲取name對應的真正beanName，如果是factoryBean，則加上“&”前綴
	        if (args != null) {
	        // 遞歸到BeanFactory中尋找
	        	return (T) parentBeanFactory.getBean(nameToLookup, args);
	        } else {
	        	return parentBeanFactory.getBean(nameToLookup, requiredType);
	        }
        }

        // 如果不僅僅是做類型檢查，標記bean的狀態(tài)已經(jīng)創(chuàng)建，即將beanName加入alreadyCreated集合中
        if (!typeCheckOnly) {
        	this.markBeanAsCreated(beanName);
        }

        try {
		 //將存儲XML配置的GenericBeanDefinition實例轉換成RootBeanDefinition實例，方便后續(xù)處理
		 // 如果存在父bean，則同時合并父bean的相關屬性
		final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
        // 檢查bean是否是抽象的，如果是則拋出異常
        this.checkMergedBeanDefinition(mbd, beanName, args);

        // 加載當前bean依賴的bean
        String[] dependsOn = mbd.getDependsOn();
        if (dependsOn != null) {
        // 存在依賴，遞歸實例化依賴的bean
        for (String dep : dependsOn) {
        if (this.isDependent(beanName, dep)) {
        // 檢查dep是否依賴beanName，從而導致循環(huán)依賴
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
        }
        // 緩存依賴調(diào)用
        this.registerDependentBean(dep, beanName);
        this.getBean(dep);
        }
        }

        // 完成加載依賴的bean后，實例化mbd自身
        if (mbd.isSingleton()) {
        // scope == singleton
        sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
        try {
        return createBean(beanName, mbd, args);
        } catch (BeansException ex) {
        // 清理工作，從單例緩存中移除
        destroySingleton(beanName);
        throw ex;
        }
        }
        });
        bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        } else if (mbd.isPrototype()) {
        // scope == prototype
        Object prototypeInstance;
        try {
        // 設置正在創(chuàng)建的狀態(tài)
        this.beforePrototypeCreation(beanName);
        // 創(chuàng)建bean
        prototypeInstance = this.createBean(beanName, mbd, args);
        } finally {
        this.afterPrototypeCreation(beanName);
        }
        // 返回對應的實例
        bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
        } else {
        // 其它范圍得實例
        String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
        if (scope == null) {
        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
        }
        try {
        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
        @Override
        public Object getObject() throws BeansException {
        beforePrototypeCreation(beanName);
        try {
        return createBean(beanName, mbd, args);
        } finally {
        afterPrototypeCreation(beanName);
        }
        }
        });
        // 返回對應的實例
        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
        } catch (IllegalStateException ex) {
        throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex);
        }
        }
        } catch (BeansException ex) {
        cleanupAfterBeanCreationFailure(beanName);
        throw ex;
        }
        }

        // 檢查需要的類型是否符合bean的實際類型，對應getBean時指定的需要類型
        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
        try {
        // 執(zhí)行類型轉換，轉換成對應的類型
        return this.getTypeConverter().convertIfNecessary(bean, requiredType);
        } catch (TypeMismatchException ex) {
        if (logger.isDebugEnabled()) {
        logger.debug("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex);
        }
        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
        }
        到這里才是真正意義上返回一個bean而已
        return (T) bean;
        }

public Object getSingleton(String beanName) {
    return this.getSingleton(beanName, true);
}

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 從一級緩存中獲取Bean 獲取到了則返回 沒獲取到繼續(xù)
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
        // 從二級緩存中獲取Bean  獲取到了則返回 沒獲取到則繼續(xù)
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            // 加一把鎖防止 線程安全 雙重獲取校驗
            synchronized(this.singletonObjects) {
                // 從一級緩存中獲取Bean 獲取到了則返回 沒獲取到繼續(xù)
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    // 從二級緩存中獲取Bean  獲取到了則返回 沒獲取到則繼續(xù)
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        // 從三級緩存中獲取 沒獲取到則返回
                        ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            // 獲取到了 執(zhí)行三級緩存中的lambda表達式
                            singletonObject = singletonFactory.getObject();
                            // 并將結果放入二級緩存
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            // 從三級緩存中移除
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }

    return singletonObject;
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized(this.singletonObjects) {
        // 一級緩存中不存在的話 
        if (!this.singletonObjects.containsKey(beanName)) {
            // 將lambda表達式放入三級緩存
            this.singletonFactories.put(beanName, singletonFactory);
            // 清除二級緩存 
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
        Iterator var5 = this.getBeanPostProcessors().iterator();
        // 遍歷后置處理器
        while(var5.hasNext()) {
            BeanPostProcessor bp = (BeanPostProcessor)var5.next();
            // 找到實現(xiàn)SmartInstantiationAwareBeanPostProcessor接口的
            // 該接口getEarlyBeanReference方法什么時候會執(zhí)行？
            // AOP動態(tài)代理的時候 該方法執(zhí)行就是判斷該Bean是否需要被代理
            // 需要代理則會創(chuàng)建代理對象返回
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor)bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    // 這個Object有兩種情況，一是實例化后的半成品Bean，二是半成品Bean動態(tài)代理后的代理對象
    return exposedObject;
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
     
        synchronized(this.singletonObjects) {
            // 第一次進來這里獲取肯定為null
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
               // 省略................
                try {
                    // 注意啊，這個就是執(zhí)行外面那個傳參的lambda表達式
                    // 所以這里才會跳到createBean方法那里去執(zhí)行
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                } 
                // 省略................
                finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
                    this.afterSingletonCreation(beanName);
                }
                // 到了這說明Bean創(chuàng)建完了
                if (newSingleton) {
                    // 這里就會把Bean放入一級緩存中了 同時清除二、三級緩存
                    this.addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject;
        }
    }

protected void addSingleton(String beanName, Object singletonObject) {
  synchronized(this.singletonObjects) {
     // 放入一級緩存  
      this.singletonObjects.put(beanName, singletonObject);
      // 清除二、三級緩存
      this.singletonFactories.remove(beanName);
      this.earlySingletonObjects.remove(beanName);
      this.registeredSingletons.add(beanName);
  }
}