@Override
public Object getBean(String name) throws BeansException {
    // 獲取name對應的bean實例，如果不存在，則創建一個
    return doGetBean(name, null, null, false);
}

見 doGetBean 方法詳解。

doGetBean

protected <T> T doGetBean(
        final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {
    // 1.解析beanName，主要是解析別名、去掉FactoryBean的前綴“&”
    final String beanName = transformedBeanName(name);
    Object bean;

    // Eagerly check singleton cache for manually registered singletons.
    // 2.嘗試從緩存中獲取beanName對應的實例
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        // 3.如果beanName的實例存在於緩存中
        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 + "'");
            }
        }
        // 3.1 返回beanName對應的實例對象（主要用於FactoryBean的特殊處理，普通Bean會直接返回sharedInstance本身）
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } else {
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        // 4.scope爲prototype的循環依賴校驗：如果beanName已經正在創建Bean實例中，而此時我們又要再一次創建beanName的實例，則代表出現了循環依賴，需要拋出異常。
        // 例子：如果存在A中有B的屬性，B中有A的屬性，那麼當依賴注入的時候，就會產生當A還未創建完的時候因爲對於B的創建再次返回創建A，造成循環依賴
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // Check if bean definition exists in this factory.
        // 5.獲取parentBeanFactory
        BeanFactory parentBeanFactory = getParentBeanFactory();
        // 5.1 如果parentBeanFactory存在，並且beanName在當前BeanFactory不存在Bean定義，則嘗試從parentBeanFactory中獲取bean實例
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            // 5.2 將別名解析成真正的beanName
            String nameToLookup = originalBeanName(name);
            // 5.3 嘗試在parentBeanFactory中獲取bean對象實例
            if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            } else {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }

        if (!typeCheckOnly) {
            // 6.如果不是僅僅做類型檢測，而是創建bean實例，這裏要將beanName放到alreadyCreated緩存
            markBeanAsCreated(beanName);
        }

        try {
            // 7.根據beanName重新獲取MergedBeanDefinition（步驟6將MergedBeanDefinition刪除了，這邊獲取一個新的）
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 7.1 檢查MergedBeanDefinition
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            // 8.拿到當前bean依賴的bean名稱集合，在實例化自己之前，需要先實例化自己依賴的bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                // 8.1 遍歷當前bean依賴的bean名稱集合
                for (String dep : dependsOn) {
                    // 8.2 檢查dep是否依賴於beanName，即檢查是否存在循環依賴
                    if (isDependent(beanName, dep)) {
                        // 8.3 如果是循環依賴則拋異常
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // 8.4 將dep和beanName的依賴關係註冊到緩存中
                    registerDependentBean(dep, beanName);
                    // 8.5 獲取dep對應的bean實例，如果dep還沒有創建bean實例，則創建dep的bean實例
                    getBean(dep);
                }
            }

            // Create bean instance.
            // 9.針對不同的scope進行bean的創建
            if (mbd.isSingleton()) {
                // 9.1 scope爲singleton的bean創建（新建了一個ObjectFactory，並且重寫了getObject方法）
                sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                    @Override
                    public Object getObject() throws BeansException {    //
                        try {
                            // 9.1.1 創建Bean實例
                            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;
                        }
                    }
                });
                // 9.1.2 返回beanName對應的實例對象
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } else if (mbd.isPrototype()) {
                // 9.2 scope爲prototype的bean創建
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    // 9.2.1 創建實例前的操作（將beanName保存到prototypesCurrentlyInCreation緩存中）
                    beforePrototypeCreation(beanName);
                    // 9.2.2 創建Bean實例
                    prototypeInstance = createBean(beanName, mbd, args);
                } finally {
                    // 9.2.3 創建實例後的操作（將創建完的beanName從prototypesCurrentlyInCreation緩存中移除）
                    afterPrototypeCreation(beanName);
                }
                // 9.2.4 返回beanName對應的實例對象
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            } else {
                // 9.3 其他scope的bean創建，可能是request之類的
                // 9.3.1 根據scopeName，從緩存拿到scope實例
                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 {
                    // 9.3.2 其他scope的bean創建（新建了一個ObjectFactory，並且重寫了getObject方法）
                    Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                        @Override
                        public Object getObject() throws BeansException {
                            // 9.3.3 創建實例前的操作（將beanName保存到prototypesCurrentlyInCreation緩存中）
                            beforePrototypeCreation(beanName);
                            try {
                                // 9.3.4 創建bean實例
                                return createBean(beanName, mbd, args);
                            } finally {
                                // 9.3.5 創建實例後的操作（將創建完的beanName從prototypesCurrentlyInCreation緩存中移除）
                                afterPrototypeCreation(beanName);
                            }
                        }
                    });
                    // 9.3.6 返回beanName對應的實例對象
                    bean = 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) {
            // 如果創建bean實例過程中出現異常，則將beanName從alreadyCreated緩存中移除
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    // Check if required type matches the type of the actual bean instance.
    // 10.檢查所需類型是否與實際的bean對象的類型匹配
    if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
        try {
            // 10.1 類型不對，則嘗試轉換bean類型
            return 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());
        }
    }
    // 11.返回創建出來的bean實例對象
    return (T) bean;
}

1.解析 beanName，主要是解析別名、去掉 FactoryBean 的修飾符 “&”，在 Spring IoC：finishBeanFactoryInitialization詳解中的代碼塊4已解析過。

2.嘗試從緩存中獲取 beanName 對應的實例，在 Spring IoC：finishBeanFactoryInitialization詳解中的代碼塊7已解析過。

3.1 返回 beanName 對應的實例對象（主要用於 FactoryBean 的特殊處理，普通 bean 會直接返回 sharedInstance 本身），見代碼塊1詳解。

6.如果不是僅僅做類型檢測，而是創建 bean 實例，這裏要將 beanName 放到 alreadyCreated 緩存，見代碼塊5詳解。

7.根據 beanName 重新獲取 MergedBeanDefinition，在 Spring IoC：finishBeanFactoryInitialization詳解中的代碼塊2已解析過。

8.2 檢查 dep 是否依賴於 beanName，即檢查是否存在循環依賴，見代碼塊6詳解。

8.4 將 dep 和 beanName 的依賴關係註冊到緩存中，見代碼塊7詳解。

9.1 scope 爲 singleton 的 bean 創建（新建了一個 ObjectFactory，並且重寫了 getObject 方法），見代碼塊8詳解。

9.1.1、9.2.2、9.3.4 創建 bean 實例，限於篇幅，在下篇文章單獨解析。

9.1.2、9.2.4、9.3.6 返回 beanName 對應的實例對象，見代碼塊1詳解。

9.2.1 scope 爲 prototype 時創建實例前的操作、9.2.3 scope 爲 prototype 時創建實例後的操作，相對應的兩個方法，見代碼塊11詳解。

代碼塊1：getObjectForBeanInstance

protected Object getObjectForBeanInstance(
        Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

    // Don't let calling code try to dereference the factory if the bean isn't a factory.
    // 1.如果name以“&”爲前綴，但是beanInstance不是FactoryBean，則拋異常
    if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
        throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
    }
    // Now we have the bean instance, which may be a normal bean or a FactoryBean.
    // If it's a FactoryBean, we use it to create a bean instance, unless the
    // caller actually wants a reference to the factory.

    // 2.1 如果beanInstance不是FactoryBean（也就是普通bean），則直接返回beanInstance
    // 2.2 如果beanInstance是FactoryBean，並且name以“&”爲前綴，則直接返回beanInstance（以“&”爲前綴代表想獲取的是FactoryBean本身）
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
        return beanInstance;
    }

    // 3.走到這邊，代表beanInstance是FactoryBean，但name不帶有“&”前綴，表示想要獲取的是FactoryBean創建的對象實例
    Object object = null;
    if (mbd == null) {
        // 4.如果mbd爲空，則嘗試從factoryBeanObjectCache緩存中獲取該FactoryBean創建的對象實例
        object = getCachedObjectForFactoryBean(beanName);
    }

    if (object == null) {
        // Return bean instance from factory.
        // 5.只有beanInstance是FactoryBean才能走到這邊，因此直接強轉
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        // Caches object obtained from FactoryBean if it is a singleton.
        if (mbd == null && containsBeanDefinition(beanName)) {
            // 6.mbd爲空，但是該bean的BeanDefinition在緩存中存在，則獲取該bean的MergedBeanDefinition
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        // 7.mbd是否是合成的（這個字段比較複雜，mbd正常情況都不是合成的，也就是false，有興趣的可以自己查閱資料看看）
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        // 8.從FactoryBean獲取對象實例
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    // 9.返回對象實例
    return object;
}

如果對 FactoryBean 不熟悉的，可以回頭去看 Spring IoC：finishBeanFactoryInitialization詳解中對 FactoryBean 的簡單介紹。

6.mbd 爲空，但是該 bean 的 BeanDefinition 在緩存中存在，則獲取該 bean 的 MergedBeanDefinition，在 Spring IoC：finishBeanFactoryInitialization詳解中的代碼塊2已經解析過。

8.從 FactoryBean 獲取對象實例，見代碼塊2詳解。

代碼塊2：getObjectFromFactoryBean

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    // 1.如果是單例，並且已經存在於單例對象緩存中
    if (factory.isSingleton() && containsSingleton(beanName)) {
        synchronized (getSingletonMutex()) {
            // 2.從FactoryBean創建的單例對象的緩存中獲取該bean實例
            Object object = this.factoryBeanObjectCache.get(beanName);
            if (object == null) {
                // 3.調用FactoryBean的getObject方法獲取對象實例
                object = doGetObjectFromFactoryBean(factory, beanName);
                // Only post-process and store if not put there already during getObject() call above
                // (e.g. because of circular reference processing triggered by custom getBean calls)
                Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                // 4.如果該beanName已經在緩存中存在，則將object替換成緩存中的
                if (alreadyThere != null) {
                    object = alreadyThere;
                } else {
                    if (object != null && shouldPostProcess) {
                        try {
                            // 5.對bean實例進行後置處理，執行所有已註冊的BeanPostProcessor的postProcessAfterInitialization方法
                            object = postProcessObjectFromFactoryBean(object, beanName);
                        } catch (Throwable ex) {
                            throw new BeanCreationException(beanName,
                                    "Post-processing of FactoryBean's singleton object failed", ex);
                        }
                    }
                    // 6.將beanName和object放到factoryBeanObjectCache緩存中
                    this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
                }
            }
            // 7.返回object對象實例
            return (object != NULL_OBJECT ? object : null);
        }
    } else {
        // 8.調用FactoryBean的getObject方法獲取對象實例
        Object object = doGetObjectFromFactoryBean(factory, beanName);
        if (object != null && shouldPostProcess) {
            try {
                // 9.對bean實例進行後置處理，執行所有已註冊的BeanPostProcessor的postProcessAfterInitialization方法
                object = postProcessObjectFromFactoryBean(object, beanName);
            } catch (Throwable ex) {
                throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
            }
        }
        // 10.返回object對象實例
        return object;
    }
}

3.調用 FactoryBean 的 getObject 方法獲取對象實例，見代碼塊3詳解。

5.對 bean 實例進行後續處理，執行所有已註冊的 BeanPostProcessor 的 postProcessAfterInitialization 方法，見代碼塊4詳解。

代碼塊3：doGetObjectFromFactoryBean

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
        throws BeanCreationException {

    Object object;
    try {
        // 1.調用FactoryBean的getObject方法獲取bean對象實例
        if (System.getSecurityManager() != null) {
            AccessControlContext acc = getAccessControlContext();
            try {
                object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                    @Override
                    public Object run() throws Exception {
                        // 1.1 帶有權限驗證的
                        return factory.getObject();
                    }
                }, acc);
            } catch (PrivilegedActionException pae) {
                throw pae.getException();
            }
        } else {
            // 1.2 不帶權限
            object = factory.getObject();
        }
    } catch (FactoryBeanNotInitializedException ex) {
        throw new BeanCurrentlyInCreationException(beanName, ex.toString());
    } catch (Throwable ex) {
        throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
    }

    // Do not accept a null value for a FactoryBean that's not fully
    // initialized yet: Many FactoryBeans just return null then.
    // 2.getObject返回的是空值，並且該FactoryBean正在初始化中，則直接拋異常，不接受一個尚未完全初始化的FactoryBean的getObject返回的空值
    if (object == null && isSingletonCurrentlyInCreation(beanName)) {
        throw new BeanCurrentlyInCreationException(
                beanName, "FactoryBean which is currently in creation returned null from getObject");
    }
    // 3.返回創建好的bean對象實例
    return object;
}

很簡單的方法，就是直接調用 FactoryBean 的 getObject 方法來獲取到對象實例。

細心的同學可以發現，該方法是以 do 開頭，看過 Spring IoC：源碼學習總覽的同學知道，我在總覽裏就特別提到以 do 開頭的方法是最終進行實際操作的方法，例如本方法就是 FactoryBean 最終實際進行創建 bean 對象實例的方法。

代碼塊4：postProcessObjectFromFactoryBean

@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
    return applyBeanPostProcessorsAfterInitialization(object, beanName);
}

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    // 1.遍歷所有註冊的BeanPostProcessor實現類，調用postProcessAfterInitialization方法
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        // 2.在bean初始化後，調用postProcessAfterInitialization方法
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            // 3.如果返回null，則不會調用後續的BeanPostProcessors
            return result;
        }
    }
    return result;
}

這邊走的是 AbstractAutowireCapableBeanFactory 裏的方法。通過前面的介紹，我們知道創建的 BeanFactory 爲 DefaultListableBeanFactory，而 DefaultListableBeanFactory 繼承了 AbstractAutowireCapableBeanFactory，因此這邊會走 AbstractAutowireCapableBeanFactory 的重寫方法。

在 Spring IoC：registerBeanPostProcessors詳解中已經學過 BeanPostProcessor，在創建完 bean 實例後，會執行 BeanPostProcessor 的 postProcessAfterInitialization 方法。

代碼塊5：markBeanAsCreated

protected void markBeanAsCreated(String beanName) {
    if (!this.alreadyCreated.contains(beanName)) {
        synchronized (this.mergedBeanDefinitions) {
            // 1.如果alreadyCreated緩存中不包含beanName
            if (!this.alreadyCreated.contains(beanName)) {
                // Let the bean definition get re-merged now that we're actually creating
                // the bean... just in case some of its metadata changed in the meantime.
                // 2.將beanName的MergedBeanDefinition從mergedBeanDefinitions緩存中移除，
                // 在之後重新獲取MergedBeanDefinition，避免BeanDefinition在創建過程中發生變化
                clearMergedBeanDefinition(beanName);
                // 3.將beanName添加到alreadyCreated緩存中，代表該beanName的bean實例已經創建（或即將創建）
                this.alreadyCreated.add(beanName);
            }
        }
    }
}

protected void clearMergedBeanDefinition(String beanName) {
    this.mergedBeanDefinitions.remove(beanName);
}

2.這邊會將 beanName 對應的 MergedBeanDefinition 移除，然後在之後的代碼重新獲取，主要是爲了使用最新的 MergedBeanDefinition 來進行創建操作。

代碼塊6：isDependent

private boolean isDependent(String beanName, String dependentBeanName, Set<String> alreadySeen) {
    // 已經檢查過的直接跳過
    if (alreadySeen != null && alreadySeen.contains(beanName)) {
        return false;
    }
    // 1.將別名解析爲真正的名稱
    String canonicalName = canonicalName(beanName);
    // 2.拿到依賴canonicalName的beanName集合
    Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
    // 3.如果dependentBeans爲空，則兩者必然還未確定依賴關係，返回false
    if (dependentBeans == null) {
        return false;
    }
    // 4.如果dependentBeans包含dependentBeanName，則表示兩者已確定依賴關係，返回true
    if (dependentBeans.contains(dependentBeanName)) {
        return true;
    }
    // 5.循環檢查，即檢查依賴canonicalName的所有beanName是否存在被dependentBeanName依賴的（即隔層依賴）
    for (String transitiveDependency : dependentBeans) {
        if (alreadySeen == null) {
            alreadySeen = new HashSet<String>();
        }
        // 6.已經檢查過的添加到alreadySeen，避免重複檢查
        alreadySeen.add(beanName);
        if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
            return true;
        }
    }
    return false;
}

這邊引入了一個緩存 dependentBeanMap：beanName -> 所有依賴 beanName 對應的 bean 的 beanName 集合。內容比較簡單，就是檢查依賴 beanName 的集合中是否包含 dependentBeanName，隔層依賴也算。例如：A 依賴了 B，B 依賴了 C，則 A 也算依賴了 C。

代碼塊7：registerDependentBean

public void registerDependentBean(String beanName, String dependentBeanName) {
    // A quick check for an existing entry upfront, avoiding synchronization...
    // 1.解析別名
    String canonicalName = canonicalName(beanName);
    // 2.拿到依賴canonicalName的beanName集合
    Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
    // 3.如果dependentBeans包含dependentBeanName，則表示依賴關係已經存在，直接返回
    if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
        return;
    }

    // No entry yet -> fully synchronized manipulation of the dependentBeans Set
    // 4.如果依賴關係還沒有註冊，則將兩者的關係註冊到dependentBeanMap和dependenciesForBeanMap緩存
    synchronized (this.dependentBeanMap) {
        // 4.1 將dependentBeanName添加到依賴canonicalName的beanName集合中
        dependentBeans = this.dependentBeanMap.get(canonicalName);
        if (dependentBeans == null) {
            dependentBeans = new LinkedHashSet<String>(8);
            this.dependentBeanMap.put(canonicalName, dependentBeans);
        }
        dependentBeans.add(dependentBeanName);
    }
    synchronized (this.dependenciesForBeanMap) {
        // 4.2 將canonicalName添加到dependentBeanName依賴的beanName集合中
        Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
        if (dependenciesForBean == null) {
            dependenciesForBean = new LinkedHashSet<String>(8);
            this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
        }
        dependenciesForBean.add(canonicalName);
    }
}

這邊又引入了一個跟 dependentBeanMap 類似的緩存，dependenciesForBeanMap：beanName -> beanName 對應的 bean 依賴的所有 bean 的 beanName 集合。

這兩個緩存很容易搞混，舉個簡單例子：例如 B 依賴了 A，則 dependentBeanMap 緩存中應該存放一對映射：其中 key 爲 A，value 爲含有 B 的 Set；而 dependenciesForBeanMap 緩存中也應該存放一對映射：其中 key 爲：B，value 爲含有 A 的 Set。

代碼塊8：getSingleton

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "'beanName' must not be null");
    // 1.加鎖，避免重複創建單例對象
    synchronized (this.singletonObjects) {
        // 2.首先檢查beanName對應的bean實例是否在緩存中存在，如果已經存在，則直接返回
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            // 3.beanName對應的bean實例不存在於緩存中，則進行Bean的創建
            if (this.singletonsCurrentlyInDestruction) {
                // 4.當bean工廠的單例處於destruction狀態時，不允許進行單例bean創建，拋出異常
                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 + "'");
            }
            // 5.創建單例前的操作
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            // suppressedExceptions用於記錄異常相關信息
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<Exception>();
            }
            try {
                // 6.執行singletonFactory的getObject方法獲取bean實例
                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;
                }
                // 7.創建單例後的操作
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                // 8.如果是新的單例對象，將beanName和對應的bean實例添加到緩存中（singletonObjects、registeredSingletons）
                addSingleton(beanName, singletonObject);
            }
        }
        // 9.返回創建出來的單例對象
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
}

5.創建單例前的操作，7.創建單例後的操作，這兩個方法是對應的，見代碼塊9詳解。

6.執行 singletonFactory 的 getObject 方法獲取 bean 實例，該方法會走文章開頭 doGetBean 方法的註釋 9.1.1。

8.如果是新的單例對象，將 beanName 和對應的單例對象添加到緩存中，見代碼塊10詳解。

代碼塊9：beforeSingletonCreation、afterSingletonCreation

protected void beforeSingletonCreation(String beanName) {
    // 先校驗beanName是否爲要在創建檢查排除掉的（inCreationCheckExclusions緩存），如果不是，
    // 則將beanName加入到正在創建bean的緩存中（Set），如果beanName已經存在於該緩存，會返回false拋出異常（這種情況出現在構造器的循環依賴）
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}

protected void afterSingletonCreation(String beanName) {
    // 先校驗beanName是否爲要在創建檢查排除掉的（inCreationCheckExclusions緩存），如果不是，
    // 則將beanName從正在創建bean的緩存中（Set）移除，如果beanName不存在於該緩存，會返回false拋出異常
    if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
        throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
    }
}

inCreationCheckExclusions 是要在創建檢查排除掉的 beanName 集合，正常爲空，可以不管。這邊主要是引入了 singletonsCurrentlyInCreation 緩存：當前正在創建的 bean 的 beanName 集合。在 beforeSingletonCreation 方法中，通過添加 beanName 到該緩存，可以預防出現構造器循環依賴的情況。

爲什麼無法解決構造器循環依賴？

我們之前在 Spring IoC：finishBeanFactoryInitialization詳解中的代碼塊7提過，getSingleton 方法是解決循環引用的核心代碼。解決邏輯的第一句話：“我們先用構造函數創建一個 “不完整” 的 bean 實例”，從這句話可以看出，構造器循環依賴是無法解決的，因爲當構造器出現循環依賴，我們連 “不完整” 的 bean 實例都構建不出來。Spring 能解決的循環依賴有：通過 setter 注入的循環依賴、通過屬性注入的循環依賴。

代碼塊10：addSingleton

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        // 1.添加到單例對象緩存
        this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
        // 2.將單例工廠緩存移除（已經不需要）
        this.singletonFactories.remove(beanName);
        // 3.將早期單例對象緩存移除（已經不需要）
        this.earlySingletonObjects.remove(beanName);
        // 4.添加到已經註冊的單例對象緩存
        this.registeredSingletons.add(beanName);
    }
}

代碼塊11：beforePrototypeCreation、afterPrototypeCreation

protected void beforePrototypeCreation(String beanName) {
    // 1.拿到當前線程中正在創建的prototype的bean的beanName集合
    Object curVal = this.prototypesCurrentlyInCreation.get();
    // 2.如果爲空，則將ThreadLocal設置成當前的beanName
    if (curVal == null) {
        this.prototypesCurrentlyInCreation.set(beanName);
    }
    // 3.如果不爲空，並且是String類型，則代表目前只有一個beanName，將之前和當前的一起封裝成Set<String>，設置到ThreadLocal中
    else if (curVal instanceof String) {
        Set<String> beanNameSet = new HashSet<String>(2);
        beanNameSet.add((String) curVal);
        beanNameSet.add(beanName);
        this.prototypesCurrentlyInCreation.set(beanNameSet);
    }
    // 4.如果不爲空，並且不是String，則必然是Set<String>類型，將當前的beanName加到Set中去
    else {
        Set<String> beanNameSet = (Set<String>) curVal;
        beanNameSet.add(beanName);
    }
}

protected void afterPrototypeCreation(String beanName) {
    // 1.拿到當前線程中正在創建的prototype的bean的beanName集合
    Object curVal = this.prototypesCurrentlyInCreation.get();
    // 2.如果是String類型，則代表目前只有一個beanName，則直接移除
    if (curVal instanceof String) {
        this.prototypesCurrentlyInCreation.remove();
    }
    else if (curVal instanceof Set) {
        // 3.如果是Set類型，則從Set從移除beanName
        Set<String> beanNameSet = (Set<String>) curVal;
        beanNameSet.remove(beanName);
        if (beanNameSet.isEmpty()) {
            this.prototypesCurrentlyInCreation.remove();
        }
    }
}

該方法和代碼塊9的兩個方法類似。主要是在進行 bean 實例的創建前，將 beanName 添加到 prototypesCurrentlyInCreation 緩存；bean 實例創建後，將 beanName 從 prototypesCurrentlyInCreation 緩存中移除。這邊 prototypesCurrentlyInCreation 存放的類型爲 Object，在只有一個 beanName 的時候，直接存該 beanName，也就是 String 類型；當有多個 beanName 時，轉成 Set 來存放。

總結

本文介紹了獲取 bean 實例的大部分內容，包括先從緩存中檢查、 FactoryBean 的 bean 創建、實例化自己的依賴（depend-on 屬性）、創建 bean 實例的前後一些標記等，在下篇文章中，將解析創建 bean 的內容。

Spring IoC源碼學習：getBean 詳解

Spring IoC源碼學習全系列

前言

正文

getBean

doGetBean

代碼塊1：getObjectForBeanInstance

代碼塊2：getObjectFromFactoryBean

代碼塊3：doGetObjectFromFactoryBean

代碼塊4：postProcessObjectFromFactoryBean

代碼塊5：markBeanAsCreated

代碼塊6：isDependent

代碼塊7：registerDependentBean

代碼塊8：getSingleton

代碼塊9：beforeSingletonCreation、afterSingletonCreation

代碼塊10：addSingleton

代碼塊11：beforePrototypeCreation、afterPrototypeCreation

總結

詐騙（殺豬盤）網站進行滲透測試

Python 潮流週刊#50：我最喜歡的 Python 3.13 新特性！

【Python】保存gym截圖

【譯】使用 GitHub Copilot 作爲你的編碼 GPS

Linux 服務器配置-安裝portainer-ce社區版

外行也能讀懂的網絡硬件設備功能原理速成

安裝Auto-GPT

BATJTMD 面試必問的 MySQL，你懂了嗎？

Spring AOP源碼學習：AOP 註解的解析

Spring AOP源碼學習：基本概念

Spring 源碼學習系列彙總

4 年 Java 經驗，阿里網易拼多多面試總結、心得體會

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結