歡迎光臨
每天分享高質量文章

【死磕 Spring】—– IOC 之開啟 bean 的加載

精品專欄

 

(此圖來自《Spring 揭秘》)

Spring IOC 容器所起的作用如上圖所示,它會以某種方式加載 Configuration Metadata,將其解析註冊到容器內部,然後回根據這些信息系結整個系統的物件,最終組裝成一個可用的基於輕量級容器的應用系統。

Spring 在實現上述功能中,將整個流程分為兩個階段:容器初始化階段和加載bean 階段。

  • 容器初始化階段:首先通過某種方式加載 Configuration Metadata (主要是依據 Resource、ResourceLoader 兩個體系),然後容器會對加載的 Configuration MetaData 進行解析和分析,並將分析的信息組裝成 BeanDefinition,並將其儲存註冊到相應的 BeanDefinitionRegistry 中。至此,Spring IOC 的初始化工作完成。

  • 加載 bean 階段:經過容器初始化階段後,應用程式中定義的 bean 信息已經全部加載到系統中了,當我們顯示或者隱式地呼叫 getBean() 時,則會觸發加載 bean 階段。在這階段,容器會首先檢查所請求的物件是否已經初始化完成了,如果沒有,則會根據註冊的 bean 信息實體化請求的物件,併為其註冊依賴,然後將其傳回給請求方。至此第二個階段也已經完成。

第一個階段前面已經用了 10 多篇博客深入分析了(總結參考【死磕 Spring】—– IOC 之 IOC 初始化總結)。所以從這篇開始分析第二個階段:加載 bean 階段。當我們顯示或者隱式地呼叫 getBean() 時,則會觸發加載 bean 階段。如下:

  1.    public Object getBean(String name) throws BeansException {

  2.        return doGetBean(name, null, null, false);

  3.    }

內部呼叫 doGetBean() 方法,其接受四個引數:

  • name:要獲取 bean 的名字

  • requiredType:要獲取 bean 的型別

  • args:創建 bean 時傳遞的引數。這個引數僅限於創建 bean 時使用

  • typeCheckOnly:是否為型別檢查

這個方法的代碼比較長,各位耐心看下:

  1.    protected T doGetBean(final String name, @Nullable final Class requiredType,

  2.                              @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

  3.        // 獲取 beanName,這裡是一個轉換動作,將 name 轉換Wie beanName

  4.        final String beanName = transformedBeanName(name);

  5.        Object bean;

  6.        // 從快取中或者實體工廠中獲取 bean

  7.        // *** 這裡會涉及到解決迴圈依賴 bean 的問題

  8.        Object sharedInstance = getSingleton(beanName);

  9.        if (sharedInstance != null && args == null) {

  10.            if (logger.isDebugEnabled()) {

  11.                if (isSingletonCurrentlyInCreation(beanName)) {

  12.                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +

  13.                            "' that is not fully initialized yet - a consequence of a circular reference");

  14.                }

  15.                else {

  16.                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");

  17.                }

  18.            }

  19.            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

  20.        }

  21.        else {

  22.            // 因為 Spring 只解決單例樣式下得迴圈依賴,在原型樣式下如果存在迴圈依賴則會丟擲異常

  23.            // **關於迴圈依賴後續會單獨出文詳細說明**

  24.            if (isPrototypeCurrentlyInCreation(beanName)) {

  25.                throw new BeanCurrentlyInCreationException(beanName);

  26.            }

  27.            // 如果容器中沒有找到,則從父類容器中加載

  28.            BeanFactory parentBeanFactory = getParentBeanFactory();

  29.            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {

  30.                String nameToLookup = originalBeanName(name);

  31.                if (parentBeanFactory instanceof AbstractBeanFactory) {

  32.                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(

  33.                            nameToLookup, requiredType, args, typeCheckOnly);

  34.                }

  35.                else if (args != null) {

  36.                    return (T) parentBeanFactory.getBean(nameToLookup, args);

  37.                }

  38.                else {

  39.                    return parentBeanFactory.getBean(nameToLookup, requiredType);

  40.                }

  41.            }

  42.            // 如果不是僅僅做型別檢查則是創建bean,這裡需要記錄

  43.            if (!typeCheckOnly) {

  44.                markBeanAsCreated(beanName);

  45.            }

  46.            try {

  47.                // 從容器中獲取 beanName 相應的 GenericBeanDefinition,並將其轉換為 RootBeanDefinition

  48.                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

  49.                // 檢查給定的合併的 BeanDefinition

  50.                checkMergedBeanDefinition(mbd, beanName, args);

  51.                // 處理所依賴的 bean

  52.                String[] dependsOn = mbd.getDependsOn();

  53.                if (dependsOn != null) {

  54.                    for (String dep : dependsOn) {

  55.                        // 若給定的依賴 bean 已經註冊為依賴給定的b ean

  56.                        // 迴圈依賴的情況

  57.                        if (isDependent(beanName, dep)) {

  58.                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,

  59.                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");

  60.                        }

  61.                        // 快取依賴呼叫

  62.                        registerDependentBean(dep, beanName);

  63.                        try {

  64.                            getBean(dep);

  65.                        }

  66.                        catch (NoSuchBeanDefinitionException ex) {

  67.                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,

  68.                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);

  69.                        }

  70.                    }

  71.                }

  72.                // bean 實體化

  73.                // 單例樣式

  74.                if (mbd.isSingleton()) {

  75.                    sharedInstance = getSingleton(beanName, () -> {

  76.                        try {

  77.                            return createBean(beanName, mbd, args);

  78.                        }

  79.                        catch (BeansException ex) {

  80.                            // 顯示從單利快取中刪除 bean 實體

  81.                            // 因為單例樣式下為瞭解決迴圈依賴,可能他已經存在了,所以銷毀它

  82.                            destroySingleton(beanName);

  83.                            throw ex;

  84.                        }

  85.                    });

  86.                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

  87.                }

  88.                // 原型樣式

  89.                else if (mbd.isPrototype()) {

  90.                    // It's a prototype -> create a new instance.

  91.                    Object prototypeInstance = null;

  92.                    try {

  93.                        beforePrototypeCreation(beanName);

  94.                        prototypeInstance = createBean(beanName, mbd, args);

  95.                    }

  96.                    finally {

  97.                        afterPrototypeCreation(beanName);

  98.                    }

  99.                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

  100.                }

  101.                else {

  102.                    // 從指定的 scope 下創建 bean

  103.                    String scopeName = mbd.getScope();

  104.                    final Scope scope = this.scopes.get(scopeName);

  105.                    if (scope == null) {

  106.                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");

  107.                    }

  108.                    try {

  109.                        Object scopedInstance = scope.get(beanName, () -> {

  110.                            beforePrototypeCreation(beanName);

  111.                            try {

  112.                                return createBean(beanName, mbd, args);

  113.                            }

  114.                            finally {

  115.                                afterPrototypeCreation(beanName);

  116.                            }

  117.                        });

  118.                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);

  119.                    }

  120.                    catch (IllegalStateException ex) {

  121.                        throw new BeanCreationException(beanName,

  122.                                "Scope '" + scopeName + "' is not active for the current thread; consider " +

  123.                                        "defining a scoped proxy for this bean if you intend to refer to it from a singleton",

  124.                                ex);

  125.                    }

  126.                }

  127.            }

  128.            catch (BeansException ex) {

  129.                cleanupAfterBeanCreationFailure(beanName);

  130.                throw ex;

  131.            }

  132.        }

  133.        // 檢查需要的型別是否符合 bean 的實際型別

  134.        if (requiredType != null && !requiredType.isInstance(bean)) {

  135.            try {

  136.                T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);

  137.                if (convertedBean == null) {

  138.                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

  139.                }

  140.                return convertedBean;

  141.            }

  142.            catch (TypeMismatchException ex) {

  143.                if (logger.isDebugEnabled()) {

  144.                    logger.debug("Failed to convert bean '" + name + "' to required type '" +

  145.                            ClassUtils.getQualifiedName(requiredType) + "'", ex);

  146.                }

  147.                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

  148.            }

  149.        }

  150.        return (T) bean;

  151.    }

代碼是相當長,處理邏輯也是相當複雜,下麵將其進行拆分闡述。

1.獲取 beanName

  1. final String beanName = transformedBeanName(name);

這裡傳遞的是 name,不一定就是 beanName,可能是 aliasName,也有可能是 FactoryBean,所以這裡需要呼叫 transformedBeanName() 方法對 name 進行一番轉換,主要如下:

  1.    protected String transformedBeanName(String name) {

  2.        return canonicalName(BeanFactoryUtils.transformedBeanName(name));

  3.    }

  4.    // 去除 FactoryBean 的修飾符

  5.    public static String transformedBeanName(String name) {

  6.        Assert.notNull(name, "'name' must not be null");

  7.        String beanName = name;

  8.        while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {

  9.            beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());

  10.        }

  11.        return beanName;

  12.    }

  13.    // 轉換 aliasName

  14.    public String canonicalName(String name) {

  15.        String canonicalName = name;

  16.        // Handle aliasing...

  17.        String resolvedName;

  18.        do {

  19.            resolvedName = this.aliasMap.get(canonicalName);

  20.            if (resolvedName != null) {

  21.                canonicalName = resolvedName;

  22.            }

  23.        }

  24.        while (resolvedName != null);

  25.        return canonicalName;

  26.    }

主要處理過程包括兩步:

  1. 去除 FactoryBean 的修飾符。如果 name 以 “&” 為前綴,那麼會去掉該 "&",例如, name="&studentService;",則會是 name="studentService"

  2. 取指定的 alias 所表示的最終 beanName。主要是一個迴圈獲取 beanName 的過程,例如別名 A 指向名稱為 B 的 bean 則傳回 B,若 別名 A 指向別名 B,別名 B 指向名稱為 C 的 bean,則傳回 C。

2.從單例 bean 快取中獲取 bean

對應代碼段如下:

  1.        Object sharedInstance = getSingleton(beanName);

  2.        if (sharedInstance != null && args == null) {

  3.            if (logger.isDebugEnabled()) {

  4.                if (isSingletonCurrentlyInCreation(beanName)) {

  5.                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +

  6.                            "' that is not fully initialized yet - a consequence of a circular reference");

  7.                }

  8.                else {

  9.                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");

  10.                }

  11.            }

  12.            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

  13.        }

我們知道單例樣式的 bean 在整個過程中只會被創建一次,第一次創建後會將該 bean 加載到快取中,後面在獲取 bean 就會直接從單例快取中獲取。如果從快取中得到了 bean,則需要呼叫 getObjectForBeanInstance() 對 bean 進行實體化處理,因為快取中記錄的是最原始的 bean 狀態,我們得到的不一定是我們最終想要的 bean。

3.原型樣式依賴檢查與 parentBeanFactory

對應代碼段

  1.            if (isPrototypeCurrentlyInCreation(beanName)) {

  2.                throw new BeanCurrentlyInCreationException(beanName);

  3.            }

  4.            // Check if bean definition exists in this factory.

  5.            BeanFactory parentBeanFactory = getParentBeanFactory();

  6.            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {

  7.                // Not found -> check parent.

  8.                String nameToLookup = originalBeanName(name);

  9.                if (parentBeanFactory instanceof AbstractBeanFactory) {

  10.                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(

  11.                            nameToLookup, requiredType, args, typeCheckOnly);

  12.                }

  13.                else if (args != null) {

  14.                    // Delegation to parent with explicit args.

  15.                    return (T) parentBeanFactory.getBean(nameToLookup, args);

  16.                }

  17.                else {

  18.                    // No args -> delegate to standard getBean method.

  19.                    return parentBeanFactory.getBean(nameToLookup, requiredType);

  20.                }

  21.            }

Spring 只處理單例樣式下得迴圈依賴,對於原型樣式的迴圈依賴直接丟擲異常。主要原因還是在於 Spring 解決迴圈依賴的策略有關。對於單例樣式 Spring 在創建 bean 的時候並不是等 bean 完全創建完成後才會將 bean 添加至快取中,而是不等 bean 創建完成就會將創建 bean 的 ObjectFactory 提早加入到快取中,這樣一旦下一個 bean 創建的時候需要依賴 bean 時則直接使用 ObjectFactroy。但是原型樣式我們知道是沒法使用快取的,所以 Spring 對原型樣式的迴圈依賴處理策略則是不處理(關於迴圈依賴後面會有單獨文章說明)。

如果容器快取中沒有相對應的 BeanDefinition 則會嘗試從父類工廠(parentBeanFactory)中加載,然後再去遞迴呼叫 getBean()

3. 依賴處理

對應原始碼如下:

  1.                String[] dependsOn = mbd.getDependsOn();

  2.                if (dependsOn != null) {

  3.                    for (String dep : dependsOn) {

  4.                        if (isDependent(beanName, dep)) {

  5.                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,

  6.                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");

  7.                        }

  8.                        registerDependentBean(dep, beanName);

  9.                        try {

  10.                            getBean(dep);

  11.                        }

  12.                        catch (NoSuchBeanDefinitionException ex) {

  13.                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,

  14.                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);

  15.                        }

  16.                    }

  17.                }

每個 bean 都不是單獨工作的,它會依賴其他 bean,其他 bean 也會依賴它,對於依賴的 bean ,它會優先加載,所以在 Spring 的加載順序中,在初始化某一個 bean 的時候首先會初始化這個 bean 的依賴。

作用域處理

Spring bean 的作用域預設為 singleton,當然還有其他作用域,如prototype、request、session 等,不同的作用域會有不同的初始化策略。

型別轉換

在呼叫 doGetBean() 方法時,有一個 requiredType 引數,該引數的功能就是將傳回的 bean 轉換為 requiredType 型別。當然就一般而言我們是不需要進行型別轉換的,也就是 requiredType 為空(比如 getBean(Stringname)),但有可能會存在這種情況,比如我們傳回的 bean 型別為 String,我們在使用的時候需要將其轉換為 Integer,那麼這個時候 requiredType 就有用武之地了。當然我們一般是不需要這樣做的。

至此 getBean() 過程講解完了。後續將會對該過程進行拆分,更加詳細的說明,弄清楚其中的來龍去脈,所以這篇博客只能算是 Spring bean 加載過程的一個概覽。拆分主要是分為三個部分:

  1. 分析從快取中獲取單例 bean,以及對 bean 的實體中獲取物件

  2. 如果從單例快取中獲取 bean,Spring 是怎麼加載的呢?所以第二部分是分析 bean 加載,以及 bean 的依賴處理

  3. bean 已經加載了,依賴也處理完畢了,第三部分則分析各個作用域的 bean 初始化過程。

【死磕 Spring】----- IOC 之 IOC 初始化總結

【死磕 Spring】----- IOC 之解析 bean 標簽:解析自定義標簽

【死磕 Spring】----- IOC 之解析 bean 標簽:constructor-arg、property 子元素

【死磕 Spring】—– IOC 之解析 bean 標簽:meta、lookup-method、replace-method)

【死磕 Spring】----- IOC 之解析 bean 標簽:開啟解析行程

【死磕 Spring】----- IOC 之 獲取 Document 物件

【死磕 Spring】----- IOC 之 註冊 BeanDefinition

【死磕 Spring】----- IOC 之 獲取驗證模型

【死磕 Spring】----- IOC 之 Spring 統一資源加載策略

【死磕 Spring】----- IOC 之深入理解 Spring IoC

END


我是 Java 技術驛站,感謝有你


>>>>>> 加群交流技術 <<<<<<

赞(0)

分享創造快樂

© 2021 知識星球   网站地图