Spring源碼分析（十一）bean的加載

摘要：本文結合《Spring源碼深度解析》來分析Spring 5.0.6版本的源代碼。若有描述錯誤之處，歡迎指正。

 

 經過前面的分析，我們終於結束了對XML配置文件的解析，接下來將會面臨更大的挑戰，就是對bean加載的探索。bean加載的功能實現遠比bean的解析要復雜得多。同樣，我們還是以最開始的示例為基礎，對於加載bean的功能，在Spring中的調用方式是：

MySpringBean bean = (MySpringBean) beanFactory.getBean("mySpringBean");

這句代碼實現了什么樣的功能呢？我們可以先快速體驗一下Spring中代碼是如何實現的。

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

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

    // 提取對應的beanName
    final String beanName = transformedBeanName(name);
    Object bean;

    /**
     * 檢查緩存中或者實例工廠中是否有對應的實例
     * 為什么首先會使用這段代碼呢？
     * 因為在創建bean的時候會存在依賴注入的情況，而在創建依賴的時候為了避免循環依賴，
     * Spring創建bean的原則是不等bean創建完成就會將創建bean的ObjectFactory提早曝光，
     * 也就是將ObjectFactory加入到緩存中，一旦下個bean創建時候需要依賴上個bean則直接使用ObjectFactory
     */
    // Eagerly check singleton cache for manually registered singletons.
    // 首先嘗試從緩存獲取或者singletonFactories中的ObjectFactory中獲取
    Object sharedInstance = getSingleton(beanName);
    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 + "'");
            }
        }
        // 返回對應的實例，有時候存在諸如BeanFactory的情況並不是直接返回實例本身而是返回指定方法返回的實例
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        /**
         * 只有在單例情況才會嘗試解決循環依賴，原型模式情況下，如果存在A中有B的屬性，B中有A的屬性，
         * 那么當依賴注入的時候，就會產生當A還未創建完的時候因為對於B的創建再次返回創建A，
         * 造成循環依賴，也就是下面的情況isPrototypeCurrentlyInCreation(beanName)為true
         */
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // Check if bean definition exists in this factory.
        // 如果beanDefinitionMap中也就是在所有已經加載的類中不包括beanName則嘗試從parentBeanFactory中檢測
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            // 遞歸到BeanFactory中尋找
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                // Delegation to parent with explicit args.
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        // 如果不是僅僅做類型檢查則是創建bean，這里要進行記錄
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            // 將存儲XML配置文件的GenericBeanDefinition轉換為RootBeanDefinition，
            // 如果指定beanName是子Bean的話同時會合並父類的相關屬性
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            String[] dependsOn = mbd.getDependsOn();
            // 若存在依賴則需要遞歸實例化依賴的bean
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // 緩存依賴調用
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            // Create bean instance.
            // 實例化依賴的bean后便可以實例化mbd本身了
            // singleton模式的創建
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        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;
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }

            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                // prototype模式的創建
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            else {
                // 指定的scope上實例化bean
                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, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(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) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    // Check if required type matches the type of the actual bean instance.
    // 檢查需要的類型是否符合bean的實際類型
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
        }
        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());
        }
    }
    return (T) bean;
}

僅從代碼量就能看出來bean的加載經歷了一個相當復雜的過程，其中涉及各種各樣的考慮。相信讀者細心閱讀上面的代碼，並參照部分代碼注釋，是可以粗略地了解整個加載bean的過程。對於加載過程中所涉及的步驟大致如下。

（1）轉換對應的beanName。

或許很多人不理解轉換對應的beanName是什么意思，傳入的參數name不就是beanName嗎？其實不是，這里傳入的參數可能是別名，也可能是FactoryBean，所以需要進行一系列的解析，這些解析內容包括如下內容。

• 去除BeanFactory的修飾符，也就是如果name="&hello"，那么會首先去除&而使name="hello"。
• 取指定alias所表示的最終beanName，例如別名A指向名稱為B的bean則返回B；若別名A指向別名B，別名B又指向名稱為C的bean則返回C。　

（2）嘗試從緩存中加載單例。

單例在Spring的同一個容器內只會被創建一次，后續再獲取bean，就直接從單例緩存中獲取了。當然這里也只是嘗試加載，首先嘗試從緩存中加載，如果加載不成功則再次嘗試從singletonFactories中加載。因為在創建單例bean的時候會存在依賴注入的情況，而在創建依賴的時候為了避免循環依賴，Spring創建bean的原則是不等bean創建完成就會將創建bean的ObjectFactory提早曝光，也就是將ObjectFactory加入到緩存中，一旦下個bean創建時候需要依賴上個bean則直接使用ObjectFactory。

（3）bean的實例化。

如果從緩存中得到了bean的原始狀態，則需要對bean進行實例化。這里有必要強調一下，緩存中記錄的只是最原始的bean狀態，並不一定是我們最終想要的bean。舉個例子，假如我們需要對工廠bean進行處理，那么這里得到的其實是工廠bean的初始狀態，但是我們真正需要的是工廠bean中定義的factory-method方法返回的bean，而getObjectForBeanInstance就是完成這個工作的，后續會詳細講解。

（4）原型模式的依賴檢查。

只有在單例情況才會嘗試解決循環依賴，原型模式情況下，如果存在A中有B的屬性，B中有A的屬性，那么當依賴注入的時候，就會產生當A還未創建完的時候因為對於B的創建再次返回創建A，造成循環依賴，也就是情況：isPrototypeCurrentlyInCreation(beanName)為true。

（5）檢測parentBeanFactory。

從代碼上看，如果緩存沒有數據的話直接轉到父類工廠上去加載了，這是為什么呢？

可能讀者忽略了一個很重要的判斷條件：parentBeanFactory != null && !containsBeanDefinition(beanName)。parentBeanFactory如果為空，則其他一切都是浮雲，但是!containsBeanDefinition(beanName)就比較重要了，它是在檢測如果當前加載的XML配置文件中不包含beanName所對應的配置，就只能到parentBeanFactory去嘗試了，然后再去遞歸地調用getBean方法。

（6）將存儲XML配置文件的GenericBeanDefinition轉換為RootBeanDefinition。

因為從XML配置文件中讀取到的Bean信息是存儲在GenericBeanDefinition中的，但是所有的Bean后續處理都是針對於RootBeanDefinition的，所以這里需要進行轉換，轉換的同時如果父類bean不為空的話，則會一並合並父類的屬性。

（7）尋找依賴。

因為 bean 的初始化過程中很可能會用到某些屬性，而某些屬性很可能是動態配置的，並且配置成依賴於其他的 bean ，那么這個時候就有必要先加載依賴的 bean ，所以，在 Sring 的加載順序中，在初始化某一個 bean 的時候首先會初始化這個 bcan 所對應的依賴。

( 8 ）針對不同的 scope 進行 bean 的創建。

我們都知道，在 Spring 中存在着不同的 scope ，其中默認的是 singleton ，但是還有些其他的配置諸如 prototype、 request 之類的。在這個步驟中， Sring會根據不同的配置進行不同的初始化策略。

( 9 ）類型轉換。

程序到這里返回 bean 后已經基本結束了，通常對該方法的調用參數 requiredType 是為空的，但是可能會存在這樣的情況，返回的 bean 其實是個 String ，但是 requiredType卻傳入 Integer類型，那么這時候本步驟就會起作用了 ，它的功能是將返回的 bean轉換為 requiredType 所指定的類型。當然， String 轉換為 Integer 是最簡單的一種轉換，在 Spring 中提供了各種各樣的轉換器，用戶也可以白己擴展轉換器來滿足需求。

經過上面的步驟后bean的加載就結束了，這個時候就可以返回所需要的 bean 了。其中最重要的就是步驟（ 8 ) ，針對不同的 scope 進行 bean 的創建，你會看到各種常用的 Spring 特性在這里的實現。