阿里雲發佈 Spring Boot 新腳手架，真香

做者 | 良名  阿里巴巴技術專家

背景

相信不少人都使用過 start.spring.io 來初始化本身的 Spring Boot 工程，這個工具爲開發者提供了豐富的可選組件，而且能夠選擇多種打包方式，大大方便了開發人員的使用。最近，阿里的 Nacos、Sentinel 也進入 start.spring.io 的選項中，進一步的方便開發者使用阿里雲的產品。

可是，生成的工程骨架中，只有組件座標信息，缺乏對應的使用方法和 Demo 代碼；因而，開發者仍是須要去尋找相關使用教程，或者樣例代碼；若是找的不對，或者是版本不匹匹配，還須要花費很多時間去排查和解決問題；這些問題都在無形中增長用戶的工做量。

咱們將對軟件工程的抽象層次自上而下進行切分，會獲得以下的幾個層級：行業、解決方案、應用、功能、組件；明顯的， start.spring.io 目前只能提供組件級別的支持。再將組件這層展開，會發現這樣一個生命週期：組件引入、組件配置、功能開發、線上運維。start.spring.io 也只實現了「組件引入」這一功能。

咱們的目標是**「讓阿里雲成爲廣大 Java 開發者最好用的雲」**。要實現這個目標，是否能夠再向前走幾步，在解決「組件引入」問題的基礎上，將組件的典型使用方法、樣例代碼、使用說明也加入到工程中呢？

基於這種思考，咱們上線了本身的 bootstrap 站點 start.aliyun.com ：

https://start.aliyun.com/

固然，本着不重複造輪子的原則，咱們再也不構建一套工程生成底層框架，而是使用 Spring Initializr 來實現這部分功能。在此之上專一於增長新特性，實現服務廣大開發者的目標。

Spring Initializr：https://github.com/spring-io/initializr

在 start.aliyun.com 中，咱們爲廣大開發者帶來了以下便利特性：

• 爲每一個組件提供了單獨的 DemoCode 和對應的配置樣例（本次已發佈）；
• 工程內置說明，減小用戶查找文檔的困難（部分實現）；
• 開發者只須要作減法，而非加法的使用方式（部分實現）；
• 提供多組件集成的解決方案（開發中）；
• 按期跟進 start.spring.io 的更新，方便你們使用到 spring 的最新功能。

start.aliyun.com：https://start.aliyun.com/

將來，咱們還須要再助力開發者這條路上繼續發力，不只僅是作好組件集成的工做，還要須要繼續向上支持，提供更多功能、服務、應用層級的快速構建能力。

本文，圍繞 spring initializr 框架，以 start.spring.io 爲例，全面的給你們介紹如何使用和擴展這個框架，以及背後的運行原理。

使用篇

因爲 spring-initializr 提供了靈活的擴展能力，以及豐富的默認實現；其使用方式也是很是的靈活多變；爲了便於說明，咱們直接經過 start.spring.io ，看看 Spring 本身是怎麼使用這套框架的。

1. 基本用法

基本用法的原則，是儘可能少寫代碼，甚至是不寫代碼。只經過配置就能夠實現 initializr 工程的建立。

依賴引入

要使用 spring-initializr ，首先要引入這套框架。很簡單，直接依賴 bom 便可：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>io.spring.initializr</groupId>
            <artifactId>initializr-bom</artifactId>
            <version>0.9.0.BUILD-SNAPSHOT</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

有了這個 bom 依賴，咱們就不用再關心內部組件的版本等信息了。

通常來講，咱們還須要引入具體組件：

<dependency>
            <groupId>io.spring.initializr</groupId>
            <artifactId>initializr-generator-spring</artifactId>
        </dependency>
        <dependency>
            <groupId>io.spring.initializr</groupId>
            <artifactId>initializr-version-resolver</artifactId>
        </dependency>
        <dependency>
            <groupId>io.spring.initializr</groupId>
            <artifactId>initializr-web</artifactId>
        </dependency>

具體每一個子模塊的用途，這裏列出來，供讀者參考：

• initializr-actuator: 監控診斷的附加信息，這個暫時忽略；
• initializr-bom: 便於外部使用的bom依賴；
• initializr-docs: 使用文檔；
• initializr-generator: 核心工程生成庫；
• initializr-generator-spring: 用於生成典型的spring boot工程；
• initializr-generator-test: 測試框架；
• initializr-metadata: 項目各個方面的元數據基礎結構；
• initializr-service-sample: 基本使用案例；
• initializr-version-resolver:版本號解析能力；
• initializr-web: 提供給三方客戶端使用的web入口。

基本配置

• 完成了框架引入，就須要作一些基礎配置了
• 支持哪些語言：Java、groovy、Kotlin
• 支持哪些版本：1.八、十一、13
• 支持哪些打包方式：jar、war

將這些信息所有配置到 application.yml 文件中，以下：

initializr:
    packagings:
    - name: Jar
      id: jar
      default: true
    - name: War
      id: war
      default: false
  javaVersions:
    - id: 13
      default: false
    - id: 11
      default: false
    - id: 1.8
      name: 8
      default: true
  languages:
    - name: Java
      id: java
      default: true
    - name: Kotlin
      id: kotlin
      default: false
    - name: Groovy
      id: groovy
      default: false

其中 name 是可選的， id 是必填的。

每一個配置項下，能夠有一個默認值（將 default 這是爲 true 便可），除了這些基本配置，咱們還須要定義能夠支持的項目類型：

initializr:
    types:
    - name: Maven Project
      id: maven-project
      description: Generate a Maven based project archive.
      tags:
        build: maven
        format: project
      default: true
      action: /starter.zip
    - name: Maven POM
      id: maven-build
      description: Generate a Maven pom.xml.
      tags:
        build: maven
        format: build
      default: false
      action: /pom.xml
    - name: Gradle Project
      id: gradle-project
      description: Generate a Gradle based project archive.
      tags:
        build: gradle
        format: project
      default: false
      action: /starter.zip
    - name: Gradle Config
      id: gradle-build
      description: Generate a Gradle build file.
      tags:
        build: gradle
        format: build
      default: false
      action: /build.gradle

默認狀況下， initializr 已經支持 4 種項目類型：

• /pom.xml 生成一個 Maven 的 pom.xml 配置文件
• /build.gradle 生成 Gradle 的配置文件
• /starter.zip 生成 zip 方式壓縮的工程文件
• /starter.tgz 生成以 tgz 方式壓縮的工程文件

經過 tags 標籤，咱們能夠定義不一樣配型的編譯方式 (build) 和打包格式（format）。

配置基本依賴

完成了基本配置之後，就能夠配置可選的依賴組件了。

依賴配置以 dependency 爲 key ，一樣配置在 application.yml 的 initializr 下面，這裏給出一個簡單的樣例：

initializr:
  dependencies:
    - name: Web
      content:
        - name: Web
          id: web
          description: Full-stack web development with Tomcat and Spring MVC
        - name: Developer Tools
      content:
        - name: Spring Boot DevTools
          id: devtools
          groupId: org.springframework.boot
          artifactId: spring-boot-devtools
          description: Provides fast application restarts, LiveReload, and configurations for enhanced development experience.
        - name: Lombok
          id: lombok
          groupId: org.projectlombok
          artifactId: lombok
          description: Java annotation library which helps to reduce boilerplate code.

dependencies 下定義分組。分組的做用是便於展現和快速查找，因此不須要 id ，只須要 name 信息；每一個分組的 content 是分組的具體內容，也就是這個分組下的組件定義；支持以列表形式定義多個；另外，每一個分組均可以設置當前分組內組件公用的配置信息。

每一依賴，包含以下的基本信息：

• id：組件的惟一標識符
• groupId & artifactId：組件的座標
• name：顯示名稱
• description：描述信息，主要用於展現用途
• version：組件版本

關於 groupId & artifactId：若是設置了座標，生成的項目裏會使用這裏的座標定位組件；可是若是沒有設置座標，框架會認爲這是一個標準的 spring-boot 組件，自動添加 spring-boot-starter-{id} 做爲生成的依賴座標。

關於 version：若是直接在組件上設置版本信息，框架會直接使用這個值做爲組件依賴的版本；可是不少時候，組件的版本會受到 spring-boot 版本的影響，此時就須要對版本作特殊的定義 & 管理。

配置依賴版本管理

這裏須要先了解一下版本命名規則：一個典型的版本，通常包含以下 4 個信息：大版本、小版本、修正版本、版本限定符。

版本範圍有一個上界和下界，能夠方括號 [] 或者圓括號 () 表示。方括號表明上下界的閉區間，圓括號表明上下界的開區間。

例如：「[1.1.6.RELEASE,1.3.0.M1)」表明全部從 1.1.6.RELEASE 到 1.3.0.M1 之間全部的版本（包含 1.1.6.RELEASE ，但不包含 1.3.0.M1 ）。

同時，可使用單一版本號做爲版本範圍，例如 「1.2.0.RELEASE」。單一版本號的版本範圍表明「從這個版本以及以後的全部版本」。

若是須要使用「最新的 Release 版本」的概念，可使用一個字母 x 表明具體的版本號。

例如， 1.4.x.BUILD-SNAPSHOT 表明 1.4.x 的最新快照版本。

再好比：若是須要表達，從 1.1.0.RELEASE 到 1.3.x 之間的全部版本，能夠用[1.1.0.RELEASE,1.3.x.RELEASE]來表達。

另外，版本限定符也是有順序的（升序）：

• M：里程碑版本
• RC：發佈候選版本
• RELEASE：發佈版本
• BUILD-SNAPSHOT：爲開發構建的快照版本

因此快照版本是全部限定符裏優先級最高的。假設某個組件須要 Spring Boot 的最新版本，可使用 1.5.x.BUILD-SNAPSHOT  (假設 1.5 版是 Spring Boot 的最新版本)。

最後，版本範圍中討論的版本，指的都是 Spring Boot的版本，而不是組件本身的版本。

前面介紹了，可使用 version 屬性定義組件的具體版本號；可是，若是組件版本與Spring Boot 的版本存在關聯關係，就須要使用 compatibilityRange 來配置依賴的版本範圍。

 compatibilityRange 能夠定義在兩個地方：

• 直接定義在組件（或 Bom ）上

這種定義方式，表明組件只支持  Spring Boot 的某一個版本範圍，例以下面的配置：

initializr:
  dependencies:
    - name: Stuff
      content:
        - name: Foo
          id: foo
          ...
          compatibilityRange: 1.2.0.M1
        - name: Bar
          id: bar
          ...
          compatibilityRange: "[1.5.0.RC1,2.0.0.M1)"

Foo 能夠支持 Spring boot 1.2.0  以後的全部版本；而Bar只能支持 Spring Boot 1.5.0  到  2.0.0 之間的版本，且不包含 2.0.0 ；

• 定義在組件的 mappgin 屬性下

能夠支持在 Spring Boot 不一樣版本之下對組件作不一樣的設置（能夠重置組件部分或者是全部的屬性），下面的例子中對 artifactId 作了特殊定義：

initializr:
  dependencies:
    - name: Stuff
      content:
        - name: Foo
          id: foo
          groupId: org.acme.foo
          artifactId: foo-spring-boot-starter
          compatibilityRange: 1.3.0.RELEASE
          mappings:
            - compatibilityRange: "[1.3.0.RELEASE,1.3.x.RELEASE]"
              artifactId: foo-starter
            - compatibilityRange: "1.4.0.RELEASE"

這個例子中， foo 在 Spring Boot 的 1.3 使用 foo-starter 做爲座標的 artifactId ；在 1.4.0.RELEASE 以及以後的版本中，仍是使用 foo-spring-boot-starter 做爲 artifactId 的值；

**使用 Bom 管理版本：**有時候，須要使用 Bom 的方式管理組件版本；此時不須要對組件單獨設置版本號。

要使用 Bom ，首先要配置 Bom 定義：

initializr:
  env:
    boms:
      my-api-bom:
        groupId: org.acme
        artifactId: my-api-dependencies
        version: 1.0.0.RELEASE
        repositories: my-api-repo-1

注意：Bom 信息，定義在 initializr.env.boms下面。

其屬性和依賴組件基本一致，都是座標、版本；同時， Bom 也支持版本範圍管理。

完成了 Bom 的定義，就須要在組件中引用 Bom ：

initializr:
  dependencies:
    - name: Other
      content:
        - name: My API
          id : my-api
          groupId: org.acme
          artifactId: my-api
          bom: my-api-bom

一旦用戶選擇了 my-api 組件，框架會自動爲生成的項目添加了 my-api-dependencies 的 Bom 依賴；

2. 高級定製

啓用緩存

若是你啓動過 start.spring.io 項目，你會在日誌裏發現這樣的輸出 「Fetching boot metadata from spring.io/project_metadata/spring-boot」 爲了不過於頻繁的檢查 Spring Boot 版本，官方是建議配合緩存一塊兒使用。

首先須要引入緩存框架：

<dependency>
    <groupId>javax.cache</groupId>
    <artifactId>cache-api</artifactId>
</dependency>
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>

而後，在 SpringBootApplication 類上增長 @EnableCaching 註解:

若是須要本身定義緩存，能夠調整以下緩存配置：

**增長 Demo代碼：**因爲不一樣的組件有不一樣的功能，若是須要爲項目增長 Demo 代碼。

**爲不一樣的組件增長獨立配置：**還記得原理篇中提到的 spring.factories 嗎？對，咱們要增長本身的配置項，就須要在這裏增長針對不一樣組件樣例代碼的擴展入口。

io.spring.initializr.generator.project.ProjectGenerationConfiguration=\
com.alibaba.alicloud.initializr.extension.dependency.springboot.SpringCloudProjectGenerationConfiguration

在 SpringCloudProjectGenerationConfiguration 中，咱們經過 ConditionalOnRequestedDependency 註解來識別不一樣組件：

@ProjectGenerationConfiguration
public class SpringCloudAlibabaProjectGenerationConfiguration {
    private final InitializrMetadata metadata;
    private final ProjectDescription description;
    private final IndentingWriterFactory indentingWriterFactory;
    private final TemplateRenderer templateRenderer;
    public SpringCloudAlibabaProjectGenerationConfiguration(InitializrMetadata metadata,
                                                            ProjectDescription description,
                                                            IndentingWriterFactory indentingWriterFactory,
                                                            TemplateRenderer templateRenderer) {
        this.metadata = metadata;
        this.description = description;
        this.indentingWriterFactory = indentingWriterFactory;
        this.templateRenderer = templateRenderer;
    }
    @Bean
    @ConditionalOnRequestedDependency("sca-oss")
    public OSSDemoCodeContributor ossContributor() {
        return new OSSDemoCodeContributor(description, templateRenderer);
    }
    ......
}

上面的代碼，會在選擇了 sca-oss 組件時，建立一個 OSSDemoCodeContributor 用於對應 Demo 代碼的生成。

**生成具體的 Demo 代碼：**繼續以 OSSDemoCodeContributor 爲例，它是一個 ProjectContributor ，會在項目文件空間建立完成了調用。咱們須要爲這個 Contributor 在實例化時增長生成過程當中須要的元數據信息，例如 ProjectDescription 。

代碼生成過程，比較簡單，能夠直接複用框架中就提供的 mstache 模板引擎。

咱們直接將 Demo 代碼，以模板的形式，放置在 resources 文件夾之下：

而後，咱們再經過模板引擎，解析這些模板文件，再拷貝到項目目錄下便可：

private void writeCodeFile(TemplateRenderer templateRenderer, Language langeuage,
                               Map<String, Object> params, Path path, String temp) throws IOException {
        ......
        Path pkgPath = 生成包路徑
        Path filePath = 成成代碼文件路徑
        // 渲染模板
        String code = templateRenderer.render(temp, params);
        // demo 文件寫入
        Files.createDirectories(pkgPath);
        Files.write(filePath, code.getBytes("UTF-8"));
    }

除了模板代碼之外，咱們一般還須要在 applicatioin.properties 文件寫入模塊的配置信息。

這裏，咱們依然可使用代碼生成的方式：建立模板、解析模板，追加文件的方式來實現。具體代碼這裏就不貼了，讀者能夠本身發揮。

原理篇

原理篇，主要介紹 spring.initializr 是如何實現項目工程構建的，以及做爲一個框架，如何提供豐富的擴展能力的。

在原理篇，咱們將 initializr 的執行分爲兩個階段：啓動階段和生成階段。

• 啓動階段：啓動應用，加載配置，擴展信息初始化；
• 生成階段：一個項目生成，從收到請求，到返回內容的完整流程。

1. 啓動階段

再開始啓動流程以前，先要看一下 initializr 的擴展體系。

整個架構大量使用了 spring 的 spi 機制，咱們來看一下一共有哪些 spring.factories ：

• initializr-generator/src/main/resources/META-INF/spring.factories
• initializr-generator-spring/src/main/resources/META-INF/spring.factories
• initializr-web/src/main/resources/META-INF/spring.factories
• initializr-actuator/src/main/resources/META-INF/spring.factories
• start-site/src/main/resources/META-INF/spring.factories

其中只有一個在 start.spring.io 中，其餘 4 個都在 initializr 工程中（各 spring.factories 的具體內容見參考資料）。

不過要注意，這些 spring.factories 定義，僅僅表明了各個 SPI 有哪些擴展。不一樣spi的實現建立和使用徹底是在不一樣的階段進行的。

在應用啓動階段，其實只有一個 spi 會被加載（暫不考慮 actuator）：io.spring.initializr.web.autoconfigure.InitializrAutoConfiguration 。

@Configuration
@EnableConfigurationProperties(InitializrProperties.class)
public class InitializrAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public ProjectDirectoryFactory projectDirectoryFactory()
    @Bean
    @ConditionalOnMissingBean
    public IndentingWriterFactory indentingWriterFactory()
    @Bean
    @ConditionalOnMissingBean(TemplateRenderer.class)
    public MustacheTemplateRenderer templateRenderer(Environment environment, ObjectProvider<CacheManager> cacheManager)
    @Bean
    @ConditionalOnMissingBean
    public InitializrMetadataUpdateStrategy initializrMetadataUpdateStrategy(RestTemplateBuilder restTemplateBuilder,
            ObjectMapper objectMapper)
    @Bean
    @ConditionalOnMissingBean(InitializrMetadataProvider.class)
    public InitializrMetadataProvider initializrMetadataProvider(InitializrProperties properties,
            InitializrMetadataUpdateStrategy initializrMetadataUpdateStrategy)
    @Bean
    @ConditionalOnMissingBean
    public DependencyMetadataProvider dependencyMetadataProvider()
    @Configuration
    @ConditionalOnWebApplication
    static class InitializrWebConfiguration {
        @Bean
        InitializrWebConfig initializrWebConfig()
        @Bean
        @ConditionalOnMissingBean
        ProjectGenerationController<ProjectRequest> projectGenerationController(
                InitializrMetadataProvider metadataProvider, ApplicationContext applicationContext)
        @Bean
        @ConditionalOnMissingBean
        ProjectMetadataController projectMetadataController(InitializrMetadataProvider metadataProvider,
                DependencyMetadataProvider dependencyMetadataProvider)
        @Bean
        @ConditionalOnMissingBean
        CommandLineMetadataController commandLineMetadataController(InitializrMetadataProvider metadataProvider,
                TemplateRenderer templateRenderer)
        @Bean
        @ConditionalOnMissingBean
        SpringCliDistributionController cliDistributionController(InitializrMetadataProvider metadataProvider)
    }
}

這裏會作以下幾件事情：

• 初始化元數據 Provider
• 建立模板引擎
• 建立目錄、縮進工廠
• 初始化 web 配置
• 建立 spring mvc 的 web 入口
• 各類 ProjectGenerationController

其中最關鍵的元數據加載部分，使用了 EnableConfigurationProperties 註解，將 spring 環境中的配置項寫到 InitializrProperties 上：

在 application.yml 文件中，能夠找到以下的配置信息，這裏就是實際的項目依賴關係元數據的配置存儲點：

總體來看，啓動階段的動做仍是比較簡單的，這也是爲何 start.spring.io 啓動只須要數秒的緣由。

更多的邏輯，都被留在了工程生成階段。

2. 生成階段

生成階段，spring-initializr 使用了一個頗有意思的實現方式：initializr 框架會爲每一次項目生成，建立一個獨立的 context 用於存放生成流程中須要使用到的各類 bean 。

先來一張時序圖：

• 藍色的類，是在應用啓動階段就完成了建立和數據填充；其生命週期和整個應用一致；
• 黃色的類，會在具體的項目構建過程當中生成；其生命週期在一次項目生成流程以內結束。

從上面的時序圖中能夠看出：一個典型的建立行爲，一般從 ProjectGenerationController收到web端的建立請求開始，經過 ProjectGenerationInvoker 這個中間層轉換，最終進入 ProjectGenerator 的核心構建流程。

主幹流程

下圖，是 ProjectGenerator 的核心構建流程：

106 行，經過 contextFactory 構建了一個新的 ProjectGenerationContext 。

看一下這個context的繼承關係，原來於spring提供的AnnotationConfigApplicationContext 。

再結合 110 行的 refresh() 方法，是否是發現了什麼？就是 spring 的 ApplicationContext 的刷新流程。

107 行的 resolve 方法，向 context 中註冊了一個 ProjectDescription的Provider，代碼以下：

因爲註冊的是 Provider ，因此這段邏輯會在 Context 執行 refresh 時運行。

這裏的 ProjectDescriptionCustomizer 就是針對 ProjectDescription 的擴展，用於對用戶傳入的 ProjectDescription 作調整。這裏主要是一些強制依賴關係的調整，例如語言版本等。

這時候再看 108 行，這裏向 Context 註冊一個 Configuration 。

那麼這個 Configuration 包含了什麼內容呢？一塊兒來看下面這段代碼：

ProjectGenerationConfiguration！！！前面提到的 spring.factories 中有不少這個 SPI 的實現（參見參考資料）。

原來，initializr 的整個擴展體系，在這裏纔開始建立實例；

ProjectGenerator 的 109 行，對一個 consumer 作了 accept 操做；其實就是調用了下面的代碼：

這裏經過 setParent 將應用的主上下文設置爲此次 ProjectGenerationContext 的父節點。

而且向此次 ProjectGenerationContext 中註冊了元數據對象。

最後，在 ProjectGenerator 的 112 行，調用了 projectAssetGenerator 的 generate 方法，實現以下：

經過上面的代碼能夠發現，這裏對實際的工程構建工做，其實就是不少的 ProjectContributor 共同疊加；

至此，主幹流程已經結束了。

咱們能夠發現，在主幹流程中，沒有作任何寫文件的操做（只建立了根文件夾）；它僅僅是定義了一套數據加載、擴展加載的機制與流程，將全部的具體實現都做爲擴展的一部分。

擴展流程

spring-initializr 提供了 2 種主要擴展途徑：ProjectContributor 和 xxxxxCustomizer。

從方法簽名就能夠看出，入參只有一個項目的根路徑，其職責就是向這個路徑下些人項目文件。這個擴展點很是的靈活，幾乎能夠支持任何的代碼、配置文件寫入工做。

實現過程當中，能夠經過 ProjectGenerationContext 獲取相關依賴，而後經過自定義邏輯完成文件生成工做。

下面是 initializr 和 start.spring.io 提供的 ProjectContributor 實現：

拿幾個主要的實現看看：

• MavenBuildProjectContributor：寫入 maven 項目 pom.xml 文件；
• WebFoldersContributor：建立 web 項目的資源文件夾；
• ApplicationPropertiesContributor：寫入 application.properties 文件；
• MainSourceCodeProjectContributor：寫入應用入口類 xxxApplication.java 文件；
• HelpDocumentProjectContributor：寫入幫助文檔 HELP.md 文件。

相對於 ProjectContributor，xxxxxCustomizer  不是一個統一的接口，我把他理解爲一種感念和與之對應的命名習慣；每一個 Customizer 都有本身明確的名字，同時也對應了明確的觸發邏輯和職責邊界。

下面列出框架提供的 Customizer 的說明：

• MainApplicationTypeCustomizer：自定義 MainApplication 類；
• MainCompilationUnitCustomizer：自定義 MainApplication 編譯單元；
• MainSourceCodeCustomizer：自定義 MainApplication 源碼；
• BuildCustomizer：自定義項目構建工具的配置內容；
• GitIgnoreCustomizer：自定義項目的 .gitignore 文件；
• HelpDocumentCustomizer：自定義項目的幫助文檔；
• InitializrMetadataCustomizer：自定義項目初始化配置元數據；這個 Customizer 比較特殊，框架會在首次加載元數據配置時調用；
• ProjectDescriptionCustomizer：自定義 ProjectDescription ；即在生成項目文件以前，容許調整項目描述信息；
• ServletInitializerCustomizer：自定義 web 應用在類上的配置內容；
• TestApplicationTypeCustomizer：自定義測試 Application 類；
• TestSourceCodeCustomizer：自定義測試 Application 類的源碼。

參考資料

1. 相關連接

• initializr 說明文檔

https://docs.spring.io/initializr/docs/current-SNAPSHOT/reference/html/

• spring-initializr 項目地址

https://github.com/spring-io/initializr

• start.spring.io 項目地址

https://github.com/spring-io/start.spring.io

2. spring.factories 明細

initializr-generator/src/main/resources/META-INF/spring.factoriesio.spring.initializr.generator.buildsystem.BuildSystemFactory=\
io.spring.initializr.generator.buildsystem.gradle.GradleBuildSystemFactory,\
io.spring.initializr.generator.buildsystem.maven.MavenBuildSystemFactory
io.spring.initializr.generator.language.LanguageFactory=\
io.spring.initializr.generator.language.groovy.GroovyLanguageFactory,\
io.spring.initializr.generator.language.java.JavaLanguageFactory,\
io.spring.initializr.generator.language.kotlin.KotlinLanguageFactory
io.spring.initializr.generator.packaging.PackagingFactory=\
io.spring.initializr.generator.packaging.jar.JarPackagingFactory,\
io.spring.initializr.generator.packaging.war.WarPackagingFactory

initializr-generator-spring/src/main/resources/META-INF/spring.factories：

io.spring.initializr.generator.project.ProjectGenerationConfiguration=\
io.spring.initializr.generator.spring.build.BuildProjectGenerationConfiguration,\
io.spring.initializr.generator.spring.build.gradle.GradleProjectGenerationConfiguration,\
io.spring.initializr.generator.spring.build.maven.MavenProjectGenerationConfiguration,\
io.spring.initializr.generator.spring.code.SourceCodeProjectGenerationConfiguration,\
io.spring.initializr.generator.spring.code.groovy.GroovyProjectGenerationConfiguration,\
io.spring.initializr.generator.spring.code.java.JavaProjectGenerationConfiguration,\
io.spring.initializr.generator.spring.code.kotlin.KotlinProjectGenerationConfiguration,\
io.spring.initializr.generator.spring.configuration.ApplicationConfigurationProjectGenerationConfiguration,\
io.spring.initializr.generator.spring.documentation.HelpDocumentProjectGenerationConfiguration,\
io.spring.initializr.generator.spring.scm.git.GitProjectGenerationConfiguration

initializr-web/src/main/resources/META-INF/spring.factories：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
io.spring.initializr.web.autoconfigure.InitializrAutoConfiguration
org.springframework.boot.env.EnvironmentPostProcessor=\
io.spring.initializr.web.autoconfigure.CloudfoundryEnvironmentPostProcessor

initializr-actuator/src/main/resources/META-INF/spring.factories：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
io.spring.initializr.actuate.autoconfigure.InitializrActuatorEndpointsAutoConfiguration,\
io.spring.initializr.actuate.autoconfigure.InitializrStatsAutoConfiguration

start-site/src/main/resources/META-INF/spring.factories：

io.spring.initializr.generator.project.ProjectGenerationConfiguration=\
io.spring.start.site.extension.build.gradle.GradleProjectGenerationConfiguration,\
io.spring.start.site.extension.build.maven.MavenProjectGenerationConfiguration,\
io.spring.start.site.extension.dependency.DependencyProjectGenerationConfiguration,\
io.spring.start.site.extension.dependency.springamqp.SpringAmqpProjectGenerationConfiguration,\
io.spring.start.site.extension.dependency.springboot.SpringBootProjectGenerationConfiguration,\
io.spring.start.site.extension.dependency.springcloud.SpringCloudProjectGenerationConfiguration,\
io.spring.start.site.extension.dependency.springdata.SpringDataProjectGenerationConfiguration,\
io.spring.start.site.extension.dependency.springintegration.SpringIntegrationProjectGenerationConfiguration,\
io.spring.start.site.extension.dependency.springrestdocs.SpringRestDocsProjectGenerationConfiguration,\
io.spring.start.site.extension.description.DescriptionProjectGenerationConfiguration,\
io.spring.start.site.extension.code.kotin.KotlinProjectGenerationConfiguration

做者信息： 陳曦（花名：良名）阿里巴巴技術專家。目前在應用容器&服務框架團隊，Spring Cloud Alibaba 項目成員，致力於將阿里雲打造爲Java開發者最好用的雲。2014 年加入 B2B，屢次參與 雙十一、618 做戰。

「阿里巴巴雲原生關注微服務、Serverless、容器、Service Mesh 等技術領域、聚焦雲原生流行技術趨勢、雲原生大規模的落地實踐，作最懂雲原生開發者的公衆號。」<br />/