目錄

在Linux下面有相當多的壓縮命令可以運行，這些壓縮命令可以讓我們更方便地從網絡上面下載容量較大的文件。此外，我們知道在Linux下面，擴展名沒有什麼特殊的意義。 不過，針對這些壓縮命令所產生的壓縮文件，為了方便記憶，還是會有一些特殊的命名方式，就讓我們來看看吧！

文件壓縮

什麼是文件壓縮呢？我們稍微談一談它的原理，目前我們使用的計算機系統中都是使用所謂的字節單位來計量。不過，事實上，計算機最小的計量單位應該是bit才對，此外，我們也知道 1字節=8比特(1Byte=8bit),但是如果今天我們只是記錄一個数字，即1這個数字，它會如何記錄？假設一個字節可以看成下面的模樣：

由於 1Byte=8bit，所以每個字節當中會有8個空格，而每個空格只可以是0、1

由於我們記錄的数字是1，考慮計算機所謂的二進制，如此一來，1會在最右邊佔據1個位，而其他的7個位將會自動地被填上0.如下圖所示

你看看，其實在這樣的例子中，那7個位應該是空的才對。不過，為了要滿足目前我們的操作系統數據的讀寫，所以就會將該數據轉為字節的形式來記錄。而一些聰明的計算機工程師就利用一些複雜的計算方式，將這些沒有使用到的空間【丟】出來，以讓文件佔用的空間變小，這就是壓縮的技術。
另一種壓縮技術也很有趣，它是將重複的數據進行統計記錄。舉例來說，如果你的數據為【111······】共有100個1時，那麼壓縮技術會記錄為【100個1】而不是真的有100個1的位存在。這樣也能夠精簡文件記錄的容量，非常有趣吧！
簡單地說，你可以將它想成，其實文件裏面有相當多的空間存在，並不是完全填滿的，而壓縮技術就是將這些空間填滿，以讓整個文件佔用的容量下降。不過，這些壓縮過的文件並無法直接被我們的操作系統所使用，因此，若要使用這些被壓縮過的文件數據，則必須將它還原回未壓縮前的模樣，那就是所謂的解壓縮。而至於壓縮后與壓縮的文件所佔用的磁盤空間大小，就可以被稱為是壓縮比。
這個壓縮與解壓縮的操作有什麼好處呢？
1.最大的好處就是壓縮過的文件容量變小了，所以你的硬盤無形之中就可以容納更多的數據。
2.此外，在一些網絡數據的傳輸中，也會由於數據量的降低，好讓網絡帶寬可以用來做更多的工作，而不是老卡在一些大型文件傳輸上面。

Linux系統常見壓縮命令

在Linux的環境中，壓縮文件的擴展名大多是: *.tar、*.tar.gz、*.gz、*.Z、*.bz2、*.xz。為什麼會有這樣的擴展名？不是說Linux的擴展名沒有什麼作用嗎？
這是因為Linux支持的壓縮命令非常多，且不同的命令所用的壓縮技術並不相同，當然彼此之間可能就無法互通/解壓縮文件。所以，當你下載到某個文件時，自然就需要知道該文件是由哪種壓縮命令所製作出來的，好用來對照對照着解壓縮，也就是說，雖然Linux文件的屬性基本上是與文件名沒有絕對關係的，但是為了幫助我們人類小小的腦袋，所以適當的擴展名還是必要的，下面我們就列出幾個常見的壓縮文件擴展名:

*.gz         gzip程序壓縮的文件
*.bz2        bzip2程序壓縮的文件
*.xz         xz程序壓縮的文件
*.zip        zip程序壓縮的文件
*.Z          compress程序壓縮的文件
*.tar        tar程序打包的文件，並沒有壓縮過
*.tar.gz     tar程序打包的文件，並且經過gzip的壓縮
*.tar.bz2    tar程序打包的文件，並且經過bzip2的壓縮
*.tar.xz     tar程序打包的文件，並且經過xz的壓縮

Linux常見的壓縮命令就是gzip、bzip2以及最新的xz，至於compress已經不流行了。為了支持windows常見的zip，其實Linux也早就有zip命令了。gzip是由GNU計劃所開發出來的壓縮命令，該命令支持已經替換了compress。後台GNU又開發出了bzip2及xz這幾個壓縮比更好的壓縮命令。不過，這些命令通常僅能針對一個文件來壓縮與解壓縮，如此一來，每次壓縮與解壓縮都要一大堆文件，豈不煩人？此時，這個所謂的【打包軟件,tar】就顯得很重要。
這個tar可以將很多文件打包成一個文件，甚至是目錄也可以這麼玩。不過，單純的tar功能僅僅是打包而已，即將很多文件結合為一個文件，事實上，它並沒有提供壓縮的功能，後台，GNU計劃中，將整個tar與壓縮的功能結合在一起，如此一來，提供用戶更方便且更強大的壓縮與打包功能，下面我們就來談一談這些在Linux下面基本的壓縮命令。

gzip

gzip可以說是應用最廣的壓縮命令了，目前gzip可以解開compress、zip和gzip等軟件所壓縮的文件，至於gzip所建立的壓縮文件為*.gz，讓我們來看看這個命令的語法:

gzip [-cdtvn] 文件名
選項與參數：
-c: 將壓縮的數據輸出到屏幕上，可通過數據流重定向來處理;
-d: 解壓縮的參數;
-t: 可以用來檢驗一個壓縮文件的一致性，看看文件有無錯誤;
-v: 可以显示出原文件/壓縮文件的壓縮比等信息;
-n: n為数字的意思,代表壓縮等級，-1最快，但壓縮比最差，-9最慢，但是壓縮比最好，默認是-6

示例1：壓縮文件(gzip -v 文件名)

示例2：解壓縮文件(gzip -d 文件名)

示例3:按照指定壓縮比壓縮(gzip -9 文件名)

示例4：查看壓縮文件的內容(zcat 文件名)

示例5：壓縮為指定文件名(gzip -c 文件名 > 指定文件名)

當你使用gzip進行壓縮時，在默認的狀態下原本的文件會被壓縮成為.gz後綴的文件，源文件就不存在了，這點與一般習慣使用Windows做壓縮的朋友所熟悉的情況不同，要注意。cat/more/less可以使用不同的方式來讀取純文本文件，那麼zcat/zmore/zless則可以對應於cat/more/less的方式來讀取純文件文件被壓縮后的壓縮文件。

bzip2

若說gzip是為了替換compress並提供更好的壓縮比而成立的，那麼bzip2則是為了替換gzip並提供更加的壓縮比而來。bzip2真是很不錯的東西，這玩意的壓縮比竟然比gzip還要好，至於bzip2的用法幾乎與gzip相同,看看下面的用法吧!

bzip2 [-cdkzvn] 文件名
選項與參數：
-c: 將壓縮的數據輸出到屏幕上，可通過數據流重定向來處理;
-d: 解壓縮的參數;
-k: 保留原始文件，而不是刪除原始文件；
-z: 壓縮的參數(默認值，可以不加)；
-v: 可以显示出原文件/壓縮文件的壓縮比等信息;
-n: n為数字的意思,代表壓縮等級，-1最快，但壓縮比最差，-9最慢，但是壓縮比最好，默認是-6

示例:

bzip2 -v 待壓縮文件名
bzip2 -d 壓縮后的文件名
bzip2 -9 -c 待壓縮的文件名 > 自定義壓縮文件名

xz

雖然bzip2已經具有很棒的壓縮比，不過顯然某些自由軟件開發者還不滿足，因此後來還推出了xz這個壓縮比更高的軟件。這個軟件的用法也跟gzip/bzip2幾乎一模一樣，那我們就來看一看。

xz [-cdtlkn] 文件名
選項與參數：
-c: 將壓縮的數據輸出到屏幕上，可通過數據流重定向來處理;
-d: 解壓縮的參數;
-k: 保留原始文件，而不是刪除原始文件；
-l: 列出壓縮文件的相關信息；
-t: 測試壓縮文件的完整性，看看有沒有錯誤;
-z: 壓縮的參數(默認值，可以不加)；
-n: n為数字的意思,代表壓縮等級，-1最快，但壓縮比最差，-9最慢，但是壓縮比最好，默認是-6

示例：

xz -v 待壓縮的文件名
xz -l 壓縮后的文件名
xz -d 壓縮后的文件名
xz -k 待壓縮的文件名

打包命令

前面談到的命令大多僅能針對單一文件來進行壓縮，雖然gzip、bzip2、xz也能夠針對目錄來進行壓縮，不過，這幾個命令對目錄的壓縮指的是將目錄內的所有文件【分別】進行壓縮的操作。而不像在Windows的系統，可以使用類似WinRAR這一類的壓縮軟件來將好多數據包成一個文件的樣式。
這種將多個文件或目錄包成一個大文件的命令功能，我們可以稱它是一種打包命令，那Linux有沒有這種打包命令？有，那就是大名鼎鼎的tar,tar可以將多個目錄或文件打包成一個大文件，同時還可以通過gzip、bzip2、xz的支持，將該文件同時進行壓縮。更有趣的是，由於tar的使用太廣泛了，目前Windows的WinRAR也支持.tar.gz文件名的解壓縮。

tar

tar的選項與參數特別多，我們只講幾個常用的選項，更多選項您可以自行man tar查詢。

tar [-z|-j|-J] [cv] [-f 待建立的新文件名] filename... <== 打包與壓縮。
tar [-z|-j|-J] [cv] [-f 既有的tar文件名]  <== 查看文件名
tar [-z|-j|-J] [xv] [-f 既有的tar文件名]  <== 解壓縮
選項與參數:
-c: 建立打包文件，可搭配-v來查看過程中被打包的文件名(filename);
-t: 查看打包文件的內容含有那些文件名，重點在查看【文件名】；
-x: 解包或解壓縮功能，可以搭配-C(大寫)在特定目錄解壓，特別留意的是，-c、-t、-x不可同時出現在一串命令行中；
-z: 通過gzip的支持進行壓縮/解壓縮: 此時文件名最好為*.tar.gz；
-j: 通過bzip2的支持進行壓縮/解壓縮：此時文件名最好為*.tar.bz2;
-J: 通過xz的支持進行壓縮/解壓縮: 此時文件名最好為 *.tar.xz，特別留意，-z、-j、-J不可以同時出現在一串命令行中；
-v: 在壓縮/解壓縮的過程中，將正在處理的文件名显示出來;
-f filename: -f後面要立刻接要被處理的文件名,建議-f單獨寫一個選項(比較不會忘記)。
-C 目錄: 這個選項用在解壓縮，若要在特定目錄解壓縮，可以使用這個選項
-p(小寫): 保留備份數據的原本權限與屬性，常用於備份(-c)重要的配置文件；
-P(大寫): 保留絕對路徑，亦即允許備份數據中含有根目錄存在之意

其實最簡單的使用tar就只要記住下面的命令即可:

• 壓縮: tar -jcv -f filename.tar.bz2 要被壓縮的文件或目錄名稱；
• 查詢: tar -jtv -f filename.tar.bz2
• 解壓縮: tar -jxv -f filename.tar.bz2 -C 欲解壓縮的目錄

示例:

tar -zcvf 文件名.tar.gz 文件名(目錄)

tar -ztvf 文件名.tar.gz

tar -zxvf 文件名.tar.gz

資料:

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※公開收購3c價格,不怕被賤賣!

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※帶您來看台北網站建置，台北網頁設計，各種案例分享

概述

本文以SpringBoot應用為基礎，嘗試分析基於註解@Configuration的配置類是如何向Spring容器註冊BeanDefinition的過程

其中主要分析了 ConfigurationClassPostProcessor 這個BeanDefinitionRegistryPostProcessor 即Bean定義註冊後置處理器，在Spring啟動過程中對@Configuration配置類的處理，主要體現在 解析並發現所有配置類，處理配置類的相關邏輯（如配置類上的@ComponentScan、@Import、@Bean註解等），註冊其中的BeanDefinition

SpringBoot版本：2.0.9.RELEASE

Spring版本：5.0.13.RELEASE

ConfigurationClassPostProcessor如何被引入

首先看一下ConfigurationClassPostProcessor的類繼承關係

從紅框中可以看出ConfigurationClassPostProcessor是BeanDefinitionRegistryPostProcessor接口的實現類，即是一個Bean定義註冊的後置處理器，會在Spring容器啟動時被調用，具體時機為

// 調用鏈
AbstractApplicationContext.refresh()
    => invokeBeanFactoryPostProcessors()
    => PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors()

invokeBeanFactoryPostProcessors()會先調用所有的BeanDefinitionRegistryPostProcessor之後，再調用所有的BeanFactoryPostProcessor

ConfigurationClassPostProcessor又是如何被引入Spring的呢？？

SpringBoot應用會在ApplicationContext應用上下文被創建的構造函數中new AnnotatedBeanDefinitionReader這個用於註冊基於註解的BeanDefinition的Reader，在其構造中又會調用AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)使用工具類向Spring容器中註冊一些所謂的註解配置處理器，其中就包含ConfigurationClassPostProcessor

// ConfigurationClassPostProcessor被註冊
AnnotationConfigServletWebServerApplicationContext構造
    => new AnnotatedBeanDefinitionReader(registry)
        => AnnotationConfigUtils.registerAnnotationConfigProcessors(registry)
            => 註冊ConfigurationClassPostProcessor到Spring容器

ConfigurationClassPostProcessor處理過程簡述

首先，ConfigurationClassPostProcessor後置處理器的處理入口為postProcessBeanDefinitionRegistry()方法。其主要使用了ConfigurationClassParser配置類解析器解析@Configuration配置類上的諸如@ComponentScan、@Import、@Bean等註解，並嘗試發現所有的配置類；還使用了ConfigurationClassBeanDefinitionReader註冊所發現的所有配置類中的所有Bean定義；結束執行的條件是所有配置類都被發現和處理，相應的bean定義註冊到容器

大致流程如下：

1、通過BeanDefinitionRegistry查找當前Spring容器中所有BeanDefinition

2、通過ConfigurationClassUtils.checkConfigurationClassCandidate() 檢查BeanDefinition是否為 “完全配置類” 或 “簡化配置類”，並對配置類做標記，放入集合待後續處理

Spring配置類的分類可以

3、通過 ConfigurationClassParser解析器 parse解析配置類集合，嘗試通過它們找到其它配置類

4、使用 ConfigurationClassBeanDefinitionReader 註冊通過所發現的配置類中找到的所有beanDefinition

5、處理完一輪配置類后，查看BeanDefinitionRegistry中是否存在新加載的且還未被處理過的 “完全配置類” 或 “簡化配置類”，有的話繼續上面步驟

其中第3、4步後面重點分析

ConfigurationClassParser#parse()：解析構建配置類

對於SpringBoot應用來說，參与解析的種子配置文件即為SpringBoot的Application啟動類

解析構建配置類流程

通過ConfigurationClassParser解析器parse解析配置類集合，嘗試通過它們找到其它配置類

• 循環解析所有配置類 ConfigurationClassParser#processConfigurationClass()

  • 根據@Conditional的ConfigurationPhase.PARSE_CONFIGURATION階段條件判斷是否跳過配置類

    注意：有些@Conditional是在當前這個PARSE_CONFIGURATION解析配置階段使用的，有些是在REGISTER_BEAN註冊beanDefinition階段使用的

  • 【重點】調用ConfigurationClassParser#doProcessConfigurationClass()循環解析配置類，直到不存在未處理過的父類

    • 1、處理配置類的成員內部類： 檢查其是否為“完全/簡化配置類”，是則對其繼續分析處理並將其放入分析器的屬性configurationClasses
    • 2、處理@PropertySource： 將找到的PropertySource添加到environment的PropertySource集合
    • 3、處理@ComponentScan： 掃描到的@Component類BeanDefinition就直接註冊到Spring容器；如果組件為配置類，繼續分析處理並將其放入分析器的屬性configurationClasses
    • 4、處理@Import：
      • （1）處理ImportSelector： 如果是DeferredImportSelector，如SpringBoot的自動配置導入，添加到deferredImportSelectors，延遲進行processImports()；其它通過ImportSelector找到的類，繼續調用processImports()，要麼是@Configuration配置類繼續解析，要麼是普通組件導入Spring容器
      • （2）處理ImportBeanDefinitionRegistrar： 調用當前配置類的addImportBeanDefinitionRegistrar()，後面委託它註冊其它bean定義
      • （3）其它Import：調用processConfigurationClass()繼續解析，最終要麼是配置類放入configurationClasses，要麼是普通組件導入Spring容器
    • 5、處理@ImportResource： 添加到配置類的importedResources集合，後續ConfigurationClassBeanDefinitionReader#loadBeanDefinitions()時再使用這些導入的BeanDefinitionReader讀取Resource中的bean定義並註冊
    • 6、處理@Bean： 獲取所有@Bean方法，並添加到配置類的beanMethods集合
    • 7、處理配置類接口上的default methods
    • 8、檢查是否有未處理的父類： 如果配置類有父類，且其不在解析器維護的knownSuperclasses中，對其調用doProcessConfigurationClass()重複如上檢查，直到不再有父類或父類在knownSuperclasses中已存在

• processDeferredImportSelectors()：處理推遲的ImportSelector集合，其實就是延遲調用了processImports()

  SpringBoot的自動配置類就是被DeferredImportSelector推遲導入的

解析構建配置類源碼分析

ConfigurationClassParser#processConfigurationClass()

包含了處理單個配置類的大體流程，先根據ConfigurationPhase.PARSE_CONFIGURATION解析配置階段的@Conditional條件判斷當前配置類是否應該解析，之後調用ConfigurationClassParser#doProcessConfigurationClass()循環解析配置類，直到不存在未處理過的父類

/**
 * 解析單個配置類
 * 解析的最後會將當前配置類放到configurationClasses
 */
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
    /**
     * 根據@Conditional條件判斷是否跳過配置類
     * 注意：當前這個PARSE_CONFIGURATION解析配置階段只會使用這個階段的@Conditional條件，有些REGISTER_BEAN註冊beanDefinition階段的條件不會在此時使用
     */
    if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
        return;
    }

    ConfigurationClass existingClass = this.configurationClasses.get(configClass);
    // 如果configClass在已經分析處理的配置類記錄中已存在
    if (existingClass != null) {
        //如果配置類是被@Import註冊的，return
        if (configClass.isImported()) {
            if (existingClass.isImported()) {
                existingClass.mergeImportedBy(configClass);
            }
            // Otherwise ignore new imported config class; existing non-imported class overrides it.
            return;
        }
        // 否則，清除老的記錄，在來一遍
        else {
            // Explicit bean definition found, probably replacing an import.
            // Let's remove the old one and go with the new one.
            this.configurationClasses.remove(configClass);
            this.knownSuperclasses.values().removeIf(configClass::equals);
        }
    }

    // Recursively process the configuration class and its superclass hierarchy.
    /**
     * 遞歸處理配置類及其超類層次結構
     * 從當前配置類configClass開始向上沿着類繼承結構逐層執行doProcessConfigurationClass，直到遇到的父類是由Java提供的類結束循環
     */
    SourceClass sourceClass = asSourceClass(configClass);
    /**
     * 循環處理配置類configClass直到sourceClass變為null，即父類為null
     * doProcessConfigurationClass的返回值是其參數configClass的父類
     * 如果該父類是由Java提供的類或者已經處理過，返回null
     */
    do {
        sourceClass = doProcessConfigurationClass(configClass, sourceClass);
    }
    while (sourceClass != null);

    this.configurationClasses.put(configClass, configClass);
}

ConfigurationClassParser#doProcessConfigurationClass()：真正解析配置類

通過解析配置類上的註解、內部成員類和方法構建一個完整的ConfigurationClass配置類，過程中如果發現了新的配置類可以重複調用此方法

真正解析過程中會處理成員內部類、@PropertySource、@ComponentScan、@Import、@ImportSource、@Bean方法等，流程如下：

• 1、處理配置類的成員內部類： 檢查其是否為“完全/簡化配置類”，是則對其繼續分析處理並將其放入分析器的屬性configurationClasses
• 2、處理@PropertySource： 將找到的PropertySource添加到environment的PropertySource集合
• 3、處理@ComponentScan： 掃描到的@Component類BeanDefinition就直接註冊到Spring容器；如果組件為配置類，繼續分析處理並將其放入分析器的屬性configurationClasses
• 4、處理@Import：
  • （1）處理ImportSelector： 如果是DeferredImportSelector，如SpringBoot的自動配置導入，添加到deferredImportSelectors，延遲進行processImports()；其它通過ImportSelector找到的類，繼續調用processImports()，要麼是@Configuration配置類繼續解析，要麼是普通組件導入Spring容器
  • （2）處理ImportBeanDefinitionRegistrar： 調用當前配置類的addImportBeanDefinitionRegistrar()，後面委託它註冊其它bean定義
  • （3）其它Import： 調用processConfigurationClass()繼續解析，最終要麼是配置類放入configurationClasses，要麼是普通組件導入Spring容器
• 5、處理@ImportResource： 添加到配置類的importedResources集合，後續ConfigurationClassBeanDefinitionReader#loadBeanDefinitions()時再使用這些導入的BeanDefinitionReader讀取Resource中的bean定義並註冊
• 6、處理@Bean： 獲取所有@Bean方法，並添加到配置類的beanMethods集合
• 7、處理配置類接口上的default methods
• 8、檢查是否有未處理的父類： 如果配置類有父類，且其不在解析器維護的knownSuperclasses中，對其調用doProcessConfigurationClass()重複如上檢查，直到不再有父類或父類在knownSuperclasses中已存在

/**
 * Apply processing and build a complete {@link ConfigurationClass} by reading the
 * annotations, members and methods from the source class. This method can be called
 * multiple times as relevant sources are discovered.
 * @param configClass the configuration class being build
 * @param sourceClass a source class
 * @return the superclass, or {@code null} if none found or previously processed
 */
@Nullable
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
        throws IOException {

    // Recursively process any member (nested) classes first
    /**
     * 1、處理配置類的成員類(配置類內嵌套定義的類)
     * 內部嵌套類也可能是配置類，遍歷這些成員類，檢查是否為"完全/簡化配置類"
     * 有的話，調用processConfigurationClass()處理它們，最終將配置類放入configurationClasses集合
     */
    processMemberClasses(configClass, sourceClass);

    // Process any @PropertySource annotations
    /**
     * 2、處理 @PropertySource
     * 將找到的PropertySource添加到environment的PropertySource集合
     */
    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), PropertySources.class,
            org.springframework.context.annotation.PropertySource.class)) {
        if (this.environment instanceof ConfigurableEnvironment) {
            processPropertySource(propertySource);
        }
        else {
            logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                    "]. Reason: Environment must implement ConfigurableEnvironment");
        }
    }

    // Process any @ComponentScan annotations
    /**
     * 3、處理 @ComponentScan
     * 處理用戶手工添加的@ComponentScan，SpringBoot創建ApplicationContext時的ClassPathBeanDefinitionScanner是為了掃描啟動類下的包
     * 為的是找到滿足條件的@ComponentScan，即@Component相關的組件，先掃描一下，掃描到的就註冊為BeanDefinition
     * 看其中是否還有配置類，有的話parse()繼續分析處理，配置類添加到configurationClasses集合
     */
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    // 如果當前配置類上有@ComponentScan，且使用REGISTER_BEAN註冊beanDefinition的條件判斷也不跳過的話
    if (!componentScans.isEmpty() &&
            !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
        for (AnnotationAttributes componentScan : componentScans) {
            // The config class is annotated with @ComponentScan -> perform the scan immediately
            // 立即掃描，掃描到的就註冊為BeanDefinition，並獲得掃描到的所有beanDefinition
            // 在處理SpringBoot啟動類上的@ComponentScan時，雖然指指定了excludeFilters，但會根據啟動類所在包推測basePackage，就會掃描到SpringBoot啟動類包以下的Bean並註冊
            Set<BeanDefinitionHolder> scannedBeanDefinitions =
                    this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());

            // Check the set of scanned definitions for any further config classes and parse recursively if needed
            // 檢查掃描到的beanDefinition中是否有配置類，有的話parse()繼續分析處理，，配置類添加到configurationClasses集合
            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                if (bdCand == null) {
                    bdCand = holder.getBeanDefinition();
                }
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                    parse(bdCand.getBeanClassName(), holder.getBeanName());
                }
            }
        }
    }

    // Process any @Import annotations
    /**
     * 4、處理 @Import
     * (1)處理ImportSelector
     * 如果是DeferredImportSelector，如SpringBoot的自動配置導入，添加到deferredImportSelectors，延遲進行processImports()
     * 其它通過ImportSelector找到的類，繼續調用processImports()，要麼是@Configuration配置類繼續解析，要麼是普通組件導入Spring容器
     * (2)處理ImportBeanDefinitionRegistrar
     * 調用當前配置類的addImportBeanDefinitionRegistrar()，後面委託它註冊其它bean定義
     * (3)其它
     * 調用processConfigurationClass()繼續解析，最終要麼是配置類放入configurationClasses，要麼是普通組件導入Spring容器
     */
    processImports(configClass, sourceClass, getImports(sourceClass), true);

    // Process any @ImportResource annotations
    /**
     * 5、處理 @ImportResource
     * 添加到配置類的importedResources集合，後續loadBeanDefinitions()加載bean定義時再讓這些導入BeanDefinitionReader自行讀取bean定義
     */
    AnnotationAttributes importResource =
            AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
    if (importResource != null) {
        String[] resources = importResource.getStringArray("locations");
        Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
        for (String resource : resources) {
            String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
            configClass.addImportedResource(resolvedResource, readerClass);
        }
    }

    // Process individual @Bean methods
    /**
     * 6、處理個別@Bean方法
     * 獲取所有@Bean方法，並添加到配置類的beanMethods集合
     */
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }

    // Process default methods on interfaces
    /**
     * 7、處理配置類接口上的default methods
     */
    processInterfaces(configClass, sourceClass);

    // Process superclass, if any
    /**
     * 8、檢查父類是否需要處理，如果父類需要處理返回父類，否則返回null
     * 如果存在父類，且不在knownSuperclasses已經分析過的父類列表裡，返回並繼續分析
     */
    if (sourceClass.getMetadata().hasSuperClass()) {
        String superclass = sourceClass.getMetadata().getSuperClassName();
        if (superclass != null && !superclass.startsWith("java") &&
                !this.knownSuperclasses.containsKey(superclass)) {
            this.knownSuperclasses.put(superclass, configClass);
            // Superclass found, return its annotation metadata and recurse
            return sourceClass.getSuperClass();
        }
    }

    // No superclass -> processing is complete
    return null;
}

ConfigurationClassBeanDefinitionReader#loadBeanDefinitions()：讀取配置類，基於配置信息註冊BeanDefinition

讀取配置類，基於配置信息註冊BeanDefinition流程

在上面解析配置類的過程中，除了構建了一個完整的ConfigurationClass配置類，其實已經向BeanDefinitionRegistry中添加了一些beanDefinition了，比如在處理@ComponentScan時，掃描到的@Component相關組件就已經註冊了

而ConfigurationClassBeanDefinitionReader會繼續讀取已經構建好的ConfigurationClass配置類中的成員變量，從而註冊beanDefinition

構建好的ConfigurationClass配置類中在本階段可用的成員變量包括：

1. Set<BeanMethod> beanMethods： @Bean的方法
2. Map<String, Class<? extends BeanDefinitionReader>> importedResources：配置類上@ImportResource註解的類存入此集合，會使用BeanDefinitionReader讀取Resource中的BeanDefinition並註冊
3. Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> importBeanDefinitionRegistrars：ImportBeanDefinitionRegistrar集合

通過構建好的配置類的配置信息，使用ConfigurationClassBeanDefinitionReader註冊所有能夠讀取到的beanDefinition：

• 根據ConfigurationPhase.REGISTER_BEAN階段條件判斷配置類是否需要跳過

  循環判斷配置類以及導入配置類的類，使用ConfigurationPhase.REGISTER_BEAN階段條件判斷是否需要跳過只要配置類或導入配置類的類需要跳過即返回跳過​

• 如果configClass.isImported()，將配置類自身註冊為beanDefinition

• 註冊配置類所有@Bean方法為beanDefinition

• 註冊由@ImportedResources來的beanDefinition，即通過其它類型Resource的BeanDefinitionReader讀取BeanDefinition並註冊，如xml格式的配置源 XmlBeanDefinitionReader

• 註冊由ImportBeanDefinitionRegistrars來的beanDefinition

讀取配置類，基於配置信息註冊BeanDefinition源碼分析

/**
 * Read a particular {@link ConfigurationClass}, registering bean definitions
 * for the class itself and all of its {@link Bean} methods.
 * 讀取特定配置類，根據配置信息註冊bean definitions
 */
private void loadBeanDefinitionsForConfigurationClass(
        ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

    /**
     * 根據ConfigurationPhase.REGISTER_BEAN階段條件判斷配置類是否需要跳過
     * 循環判斷配置類以及導入配置類的類，使用ConfigurationPhase.REGISTER_BEAN階段條件判斷是否需要跳過
     * 只要配置類或導入配置類的類需要跳過即返回跳過
     */
    if (trackedConditionEvaluator.shouldSkip(configClass)) {
        String beanName = configClass.getBeanName();
        if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
            this.registry.removeBeanDefinition(beanName);
        }
        this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
        return;
    }

    // 1、如果當前配置類是通過內部類導入 或 @Import導入，將配置類自身註冊為beanDefinition
    if (configClass.isImported()) {
        registerBeanDefinitionForImportedConfigurationClass(configClass);
    }

    // 2、註冊配置類所有@Bean方法為beanDefinition
    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);
    }

    // 3、註冊由@ImportedResources來的beanDefinition
    // 即通過其它類型Resource的BeanDefinitionReader讀取BeanDefinition並註冊
    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

    // 4、註冊由ImportBeanDefinitionRegistrars來的beanDefinition
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

思維導圖

請放大觀看

參考

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※高價收購3C產品,價格不怕你比較

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※3c收購,鏡頭 收購有可能以全新價回收嗎?

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!