摘要：簡介為了寫容器源碼分析系列的文章，我特地寫了一篇容器的導讀文章。在做完必要的準備工作后，從本文開始，正式開始進入源碼分析的階段。從緩存中獲取單例。返回以上就是和兩個方法的分析。

為了寫 Spring IOC 容器源碼分析系列的文章，我特地寫了一篇 Spring IOC 容器的導讀文章。在導讀一文中，我介紹了 Spring 的一些特性以及閱讀 Spring 源碼的一些建議。在做完必要的準備工作后，從本文開始，正式開始進入源碼分析的階段。

在本篇文章中，我將會詳細分析BeanFactory的getBean(String)方法實現細節，getBean(String) 及所調用的方法總體來說實現上較為復雜，代碼長度比較長。作為源碼分析文章，本文的文章長度也會比較長，希望大家耐心讀下去。

好了，其他的不多說了，進入主題環節吧。

簡單說一下本章的內容安排吧，在本章的開始，也就是2.1節，我將會分析getBean(String)方法整體的實現邏輯。但不會分析它所調用的方法，這些方法將會在后續幾節中依次進行分析。那接下來，我們就先來看看 getBean(String) 方法是如何實現的吧。

在本小節，我們先從戰略上俯瞰 getBean(String) 方法的實現源碼。代碼如下：

public Object getBean(String name) throws BeansException {
    // getBean 是一個空殼方法，所有的邏輯都封裝在 doGetBean 方法中
    return doGetBean(name, null, null, false);
}

protected  T doGetBean(
        final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {

    /*
     * 通過 name 獲取 beanName。這里不使用 name 直接作為 beanName 有兩點原因：
     * 1. name 可能會以 & 字符開頭，表明調用者想獲取 FactoryBean 本身，而非 FactoryBean 
     *    實現類所創建的 bean。在 BeanFactory 中，FactoryBean 的實現類和其他的 bean 存儲
     *    方式是一致的，即 ，beanName 中是沒有 & 這個字符的。所以我們需要
     *    將 name 的首字符 & 移除，這樣才能從緩存里取到 FactoryBean 實例。
     * 2. 若 name 是一個別名，則應將別名轉換為具體的實例名，也就是 beanName。
     */
    final String beanName = transformedBeanName(name);
    Object bean;

    /*
     * 從緩存中獲取單例 bean。Spring 是使用 Map 作為 beanName 和 bean 實例的緩存的，所以這
     * 里暫時可以把 getSingleton(beanName) 等價于 beanMap.get(beanName)。當然，實際的
     * 邏輯并非如此簡單，后面再細說。
     */
    Object sharedInstance = getSingleton(beanName);

    /*
     * 如果 sharedInstance = null，則說明緩存里沒有對應的實例，表明這個實例還沒創建。
     * BeanFactory 并不會在一開始就將所有的單例 bean 實例化好，而是在調用 getBean 獲取 
     * bean 時再實例化，也就是懶加載。
     * getBean 方法有很多重載，比如 getBean(String name, Object... args)，我們在首次獲取
     * 某個 bean 時，可以傳入用于初始化 bean 的參數數組（args），BeanFactory 會根據這些參數
     * 去匹配合適的構造方法構造 bean 實例。當然，如果單例 bean 早已創建好，這里的 args 就沒有
     * 用了，BeanFactory 不會多次實例化單例 bean。
     */
    if (sharedInstance != null && args == null) {
        if (logger.isDebugEnabled()) {
            if (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 + """);
            }
        }
      
        /*
         * 如果 sharedInstance 是普通的單例 bean，下面的方法會直接返回。但如果 
         * sharedInstance 是 FactoryBean 類型的，則需調用 getObject 工廠方法獲取真正的 
         * bean 實例。如果用戶想獲取 FactoryBean 本身，這里也不會做特別的處理，直接返回
         * 即可。畢竟 FactoryBean 的實現類本身也是一種 bean，只不過具有一點特殊的功能而已。
         */
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    /*
     * 如果上面的條件不滿足，則表明 sharedInstance 可能為空，此時 beanName 對應的 bean 
     * 實例可能還未創建。這里還存在另一種可能，如果當前容器有父容器，beanName 對應的 bean 實例
     * 可能是在父容器中被創建了，所以在創建實例前，需要先去父容器里檢查一下。
     */
    else {
        // BeanFactory 不緩存 Prototype 類型的 bean，無法處理該類型 bean 的循環依賴問題
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // 如果 sharedInstance = null，則到父容器中查找 bean 實例
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // 獲取 name 對應的 beanName，如果 name 是以 & 字符開頭，則返回 & + beanName
            String nameToLookup = originalBeanName(name);
            // 根據 args 是否為空，以決定調用父容器哪個方法獲取 bean
            if (args != null) {
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            } 
            else {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }

        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            // 合并父 BeanDefinition 與子 BeanDefinition，后面會多帶帶分析這個方法
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // 檢查是否有 dependsOn 依賴，如果有則先初始化所依賴的 bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    /*
                     * 檢測是否存在 depends-on 循環依賴，若存在則拋異常。比如 A 依賴 B，
                     * B 又依賴 A，他們的配置如下：
                     *   
                     *   
                     *   
                     * beanA 要求 beanB 在其之前被創建，但 beanB 又要求 beanA 先于它
                     * 創建。這個時候形成了循環，對于 depends-on 循環，Spring 會直接
                     * 拋出異常
                     */
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between "" + beanName + "" and "" + dep + """);
                    }
                    // 注冊依賴記錄
                    registerDependentBean(dep, beanName);
                    try {
                        // 加載 depends-on 依賴
                        getBean(dep);
                    } 
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                """ + beanName + "" depends on missing bean "" + dep + """, ex);
                    }
                }
            }

            // 創建 bean 實例
            if (mbd.isSingleton()) {
                /*
                 * 這里并沒有直接調用 createBean 方法創建 bean 實例，而是通過 
                 * getSingleton(String, ObjectFactory) 方法獲取 bean 實例。
                 * getSingleton(String, ObjectFactory) 方法會在內部調用 
                 * ObjectFactory 的 getObject() 方法創建 bean，并會在創建完成后，
                 * 將 bean 放入緩存中。關于 getSingleton 方法的分析，本文先不展開，我會在
                 * 后面的文章中進行分析
                 */
                sharedInstance = getSingleton(beanName, new ObjectFactory