做者 | 良名阿里巴巴技术专家html

背景

相信不少人都使用过 start.spring.io 来初始化本身的 Spring Boot 工程，这个工具为开发者提供了丰富的可选组件，而且能够选择多种打包方式，大大方便了开发人员的使用。最近，阿里的 Nacos、Sentinel 也进入 start.spring.io 的选项中，进一步的方便开发者使用阿里云的产品。java

可是，生成的工程骨架中，只有组件坐标信息，缺乏对应的使用方法和 Demo 代码；因而，开发者仍是须要去寻找相关使用教程，或者样例代码；若是找的不对，或者是版本不匹匹配，还须要花费很多时间去排查和解决问题；这些问题都在无形中增长用户的工做量。git

咱们将对软件工程的抽象层次自上而下进行切分，会获得以下的几个层级：行业、解决方案、应用、功能、组件；明显的， start.spring.io 目前只能提供组件级别的支持。再将组件这层展开，会发现这样一个生命周期：组件引入、组件配置、功能开发、线上运维。start.spring.io 也只实现了“组件引入”这一功能。github

咱们的目标是**“让阿里云成为广大 Java 开发者最好用的云”**。要实现这个目标，是否能够再向前走几步，在解决“组件引入”问题的基础上，将组件的典型使用方法、样例代码、使用说明也加入到工程中呢？web

基于这种思考，咱们上线了本身的 bootstrap 站点 start.aliyun.com ：spring

start.aliyun.com/bootstrap

固然，本着不重复造轮子的原则，咱们再也不构建一套工程生成底层框架，而是使用 Spring Initializr 来实现这部分功能。在此之上专一于增长新特性，实现服务广大开发者的目标。api

Spring Initializr：github.com/spring-io/i…缓存

在 start.aliyun.com 中，咱们为广大开发者带来了以下便利特性：springboot

为每一个组件提供了单独的 DemoCode 和对应的配置样例（本次已发布）；
工程内置说明，减小用户查找文档的困难（部分实现）；
开发者只须要作减法，而非加法的使用方式（部分实现）；
提供多组件集成的解决方案（开发中）；
按期跟进 start.spring.io 的更新，方便你们使用到 spring 的最新功能。

start.aliyun.com：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 说明文档

docs.spring.io/initializr/…

spring-initializr 项目地址

github.com/spring-io/i…

start.spring.io 项目地址

github.com/spring-io/s…

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 等技术领域、聚焦云原生流行技术趋势、云原生大规模的落地实践，作最懂云原生开发者的公众号。”/

阿里云发布 Spring Boot 新脚手架，真香

背景

使用篇