Spring Boot包括Maven和Gradle的构建插件。本部分回答有关这些插件的常见问题。

16.1. 生成构建信息

Maven插件和Gradle插件都允许生成包含项目的坐标，名称和版本的构建信息。还可以将插件配置为通过配置添加其他属性。当存在这样的文件时，Spring Boot会自动配置一个BuildPropertiesbean。
要使用Maven生成构建信息，请为build-info目标添加执行，如以下示例所示：

  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>org.springframework.boot</groupId>
  5.             <artifactId>spring-boot-maven-plugin</artifactId>
  6.             <version>2.4.0-SNAPSHOT</version>
  7.             <executions>
  8.                 <execution>
  9.                     <goals>
  10.                         <goal>build-info</goal>
  11.                     </goals>
  12.                 </execution>
  13.             </executions>
  14.         </plugin>
  15.     </plugins>
  16. </build>
有关更多详细信息，请参见Spring Boot Maven插件文档。

下面的示例对Gradle执行相同的操作：

  1. springBoot {
  2.     buildInfo()
  3. }
有关更多详细信息，请参见Spring Boot Gradle插件文档。

16.2. 生成Git信息

Maven和Gradle都允许生成一个git.properties文件，其中包含有关git构建项目时源代码存储库状态的信息。
对于Maven用户，spring-boot-starter-parentPOM包含一个预配置的插件来生成git.properties文件。要使用它，请将以下声明添加到您的POM中：

  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>pl.project13.maven</groupId>
  5.             <artifactId>git-commit-id-plugin</artifactId>
  6.         </plugin>
  7.     </plugins>
  8. </build>

Gradle用户可以通过使用gradle-git-properties插件获得相同的结果，如以下示例所示：

  1. plugins {
  2.     id "com.gorylenko.gradle-git-properties" version "2.2.2"
  3. }
提交时间git.properties应与以下格式匹配：yyyy-MM-dd’T’HH:mm:ssZ。这是上面列出的两个插件的默认格式。使用此格式，可以将时间解析为，Date并将其序列化为JSON时的格式由Jackson的日期序列化配置设置控制。

16.3. 自定义依赖版本

该spring-boot-dependenciesPOM管理公共依赖的版本。Maven和Gradle的Spring Boot插件允许使用构建属性来自定义这些托管依赖项版本。

每个Spring Boot发行版均针对这组特定的第三方依赖项进行了设计和测试。覆盖版本可能会导致兼容性问题。

要使用Maven覆盖依赖版本，请参阅Maven插件文档的这一部分。
要覆盖Gradle中的依赖版本，请参阅Gradle插件文档的这一部分。

16.4. 使用Maven创建可执行JAR

该spring-boot-maven-plugin可用于创建可执行的“肥肉” JAR。如果使用spring-boot-starter-parentPOM，则可以声明插件，然后将jar重新包装如下：

  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>org.springframework.boot</groupId>
  5.             <artifactId>spring-boot-maven-plugin</artifactId>
  6.         </plugin>
  7.     </plugins>
  8. </build>

如果您不使用父POM，则仍然可以使用该插件。但是，您必须另外添加一个<executions>部分，如下所示：

  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>org.springframework.boot</groupId>
  5.             <artifactId>spring-boot-maven-plugin</artifactId>
  6.             <version>2.4.0-SNAPSHOT</version>
  7.             <executions>
  8.                 <execution>
  9.                     <goals>
  10.                         <goal>repackage</goal>
  11.                     </goals>
  12.                 </execution>
  13.             </executions>
  14.         </plugin>
  15.     </plugins>
  16. </build>

有关完整用法的详细信息，请参见插件文档。

16.5. 使用Spring Boot应用程序作为依赖项

像war文件一样，Spring Boot应用程序也不打算用作依赖项。如果您的应用程序包含要与其他项目共享的类，则建议的方法是将该代码移到单独的模块中。然后，您的应用程序和其他项目可以依赖单独的模块。
如果您不能按照上面的建议重新排列代码，则必须配置Spring Boot的Maven和Gradle插件以生成一个单独的工件，该工件适合用作依赖项。可执行档案不能用作依赖项，因为可执行jar格式将打包应用程序类BOOT-INF/classes。这意味着当将可执行jar用作依赖项时，找不到它们。
为了产生两个工件，一个可以用作依赖项，另一个可以执行，必须指定分类器。该分类器应用于可执行档案的名称，保留默认档案作为依赖项。
要exec在Maven中配置分类器，可以使用以下配置：

  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>org.springframework.boot</groupId>
  5.             <artifactId>spring-boot-maven-plugin</artifactId>
  6.             <configuration>
  7.                 <classifier>exec</classifier>
  8.             </configuration>
  9.         </plugin>
  10.     </plugins>
  11. </build>

16.6. 运行可执行jar时提取特定的库

可执行jar中的大多数嵌套库无需解压缩即可运行。但是，某些库可能会有问题。例如，JRuby包含其自己的嵌套jar支持，它假定jruby-complete.jar总是可以直接以文件的形式直接使用。
要处理任何有问题的库，您可以标记在可执行jar首次运行时应自动解压缩特定的嵌套jar。这些嵌套的jar会写在java.io.tmpdirsystem属性标识的临时目录下。

应注意确保已配置您的操作系统，以使其在应用程序仍在运行时不会删除已解压缩到临时目录中的jar。

例如，为了指示应该使用Maven插件将JRuby标记为解包，您可以添加以下配置：

  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>org.springframework.boot</groupId>
  5.             <artifactId>spring-boot-maven-plugin</artifactId>
  6.             <configuration>
  7.                 <requiresUnpack>
  8.                     <dependency>
  9.                         <groupId>org.jruby</groupId>
  10.                         <artifactId>jruby-complete</artifactId>
  11.                     </dependency>
  12.                 </requiresUnpack>
  13.             </configuration>
  14.         </plugin>
  15.     </plugins>
  16. </build>

16.7. 创建带有排除项的不可执行的JAR

通常，如果您具有一个可执行文件和一个不可执行的jar作为两个单独的构建产品，则可执行版本具有库jar中不需要的其他配置文件。例如，application.yml配置文件可能会从不可执行的JAR中排除。
在Maven中，可执行jar必须是主要工件，您可以为库添加一个分类的jar，如下所示：

  1. <build>
  2.     <plugins>
  3.         <plugin>
  4.             <groupId>org.springframework.boot</groupId>
  5.             <artifactId>spring-boot-maven-plugin</artifactId>
  6.         </plugin>
  7.         <plugin>
  8.             <artifactId>maven-jar-plugin</artifactId>
  9.             <executions>
  10.                 <execution>
  11.                     <id>lib</id>
  12.                     <phase>package</phase>
  13.                     <goals>
  14.                         <goal>jar</goal>
  15.                     </goals>
  16.                     <configuration>
  17.                         <classifier>lib</classifier>
  18.                         <excludes>
  19.                             <exclude>application.yml</exclude>
  20.                         </excludes>
  21.                     </configuration>
  22.                 </execution>
  23.             </executions>
  24.         </plugin>
  25.     </plugins>
  26. </build>

16.8. 远程调试以Maven开头的Spring Boot应用程序

要将远程调试器附加到使用Maven启动的Spring Boot应用程序，可以使用maven plugin的jvmArguments属性。
有关更多详细信息，请参见此示例。

16.9. 不使用spring-boot-antlib从Ant构建可执行存档

要使用Ant进行构建，您需要获取依赖项，进行编译，然后创建一个jar或war存档。要使其可执行，可以使用该spring-boot-antlib模块，也可以按照以下说明进行操作：

  1. 如果要构建jar，请将应用程序的类和资源打包在嵌套BOOT-INF/classes目录中。如果要发动战争，请WEB-INF/classes照常将应用程序的类打包在嵌套目录中。
  2. 在BOOT-INF/libjar或WEB-INF/libwar的嵌套目录中添加运行时依赖项。切记不要压缩存档中的条目。
  3. 将provided（嵌入式容器）依赖项添加到BOOT-INF/libjar或WEB-INF/lib-providedwar的嵌套目录中。切记不要压缩存档中的条目。
  4. 将spring-boot-loader类添加到存档的根目录（以便Main-Class可用）。
  5. 使用适当的启动器（例如JarLauncherjar文件）作为Main-Class清单中的属性，并指定其所需的其他属性作为清单条目（主要是通过设置Start-Class属性）。

以下示例显示了如何使用Ant构建可执行归档文件：

  1. <target name="build" depends="compile">
  2.     <jar destfile="target/${ant.project.name}-${spring-boot.version}.jar" compress="false">
  3.         <mappedresources>
  4.             <fileset dir="target/classes" />
  5.             <globmapper from="*" to="BOOT-INF/classes/*"/>
  6.         </mappedresources>
  7.         <mappedresources>
  8.             <fileset dir="src/main/resources" erroronmissingdir="false"/>
  9.             <globmapper from="*" to="BOOT-INF/classes/*"/>
  10.         </mappedresources>
  11.         <mappedresources>
  12.             <fileset dir="${lib.dir}/runtime" />
  13.             <globmapper from="*" to="BOOT-INF/lib/*"/>
  14.         </mappedresources>
  15.         <zipfileset src="${lib.dir}/loader/spring-boot-loader-jar-${spring-boot.version}.jar" />
  16.         <manifest>
  17.             <attribute name="Main-Class" value="org.springframework.boot.loader.JarLauncher" />
  18.             <attribute name="Start-Class" value="${start-class}" />
  19.         </manifest>
  20.     </jar>
  21. </target>