Spring Boot 为 Maven 和 Gradle 提供了构建工具插件. 插件提供了多种功能,包括可执行jar的打包. 本节提供了有关这两个插件的更多详细信息,以及在扩展不受支持的构建系统时所需的一些帮助. 如果您刚刚入门,则可能需要先阅读 “using-spring-boot.html” 部分中的 “using-spring-boot.html”.

1. Spring Boot Maven 插件

Spring Boot Maven 插件在 Maven 中提供了 Spring Boot 支持,使您可以打包可执行 jar 或 war 归档文件并 “in-place” 运行应用程序. 要使用它,必须使用Maven 3.2 (或更高版本) .

请参阅 Spring Boot Maven 插件网站]以获取完整的插件文档.

1.1. 导入插件

要使用 Spring Boot Maven 插件,请在 pom.xmlplugins 部分中包含适当的XML,如以下示例所示:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- ... -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.2.8.RELEASE</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

前面的配置将在Maven生命周期的 package 阶段中构建的jar或war重新打包. 下面的示例在 target 目录中显示了重新打包的jar和原始jar:

$ mvn package
$ ls target/*.jar
target/myproject-1.0.0.jar target/myproject-1.0.0.jar.original

如上例所示,如果不包括 <execution/> 配置,则可以单独运行插件 (但也必须同时使用软件包目标) ,如以下示例所示:

$ mvn package spring-boot:repackage
$ ls target/*.jar
target/myproject-1.0.0.jar target/myproject-1.0.0.jar.original

如果使用里程碑或快照版本,则还需要添加适当的 pluginRepository 元素,如以下清单所示:

<pluginRepositories>
    <pluginRepository>
        <id>spring-snapshots</id>
        <url>https://repo.spring.io/snapshot</url>
    </pluginRepository>
    <pluginRepository>
        <id>spring-milestones</id>
        <url>https://repo.spring.io/milestone</url>
    </pluginRepository>
</pluginRepositories>

1.2. 打包可执行的Jar和War文件

一旦您的 pom.xml 中包含了 spring-boot-maven-plugin,它就会使用 spring-boot:repackage 目标自动尝试重写存档以使其可执行. 您应该使用通常的 packaging 元素将您的项目配置为构建jar或war (适当时) ,如以下示例所示:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!-- ... -->
    <packaging>jar</packaging>
    <!-- ... -->
</project>

package 阶段,Spring Boot会增强您现有的存档. 您可以通过使用配置选项 (如下所示) 或将 Main-Class 属性添加到清单中来指定要启动的主类. 如果您未指定主类,则插件将使用 public static void main(String[] args) 方法搜索一个类.

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <configuration>
        <mainClass>com.example.app.Main</mainClass>
    </configuration>
</plugin>

要构建和运行项目工件,可以输入以下内容:

$ mvn package
$ java -jar target/mymodule-0.0.1-SNAPSHOT.jar

要构建一个既可执行又可部署到外部容器的war文件,您需要将嵌入式容器的依赖关系标记为 “provided”,如以下示例所示:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!-- ... -->
    <packaging>war</packaging>
    <!-- ... -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- ... -->
    </dependencies>
</project>
有关如何创建可部署的war文件的更多详细信息,请参见 "`howto.html`"部分.

plugin info page中提供了高级配置选项和示例.

2. Spring Boot Gradle 插件

Spring Boot Gradle 插件在Gradle中提供了Spring Boot支持,可让您打包可执行jar或war归档文件,运行Spring Boot应用程序以及使用所提供的依赖管理 spring-boot-dependencies. 它需要Gradle 5.x (也支持4.10,但不支持该支持,并且在以后的版本中将删除该支持) . 请参考插件的文档以了解更多信息:

3. Spring Boot AntLib 模块

Spring Boot AntLib模块为Apache Ant提供了基本的Spring Boot支持. 您可以使用该模块创建可执行jar. 要使用该模块,您需要在中声明一个额外的 spring-boot 命名空间 build.xml,如以下示例所示:

<project xmlns:ivy="antlib:org.apache.ivy.ant"
    xmlns:spring-boot="antlib:org.springframework.boot.ant"
    name="myapp" default="build">
    ...
</project>

您需要记住使用该 -lib 选项启动Ant ,如以下示例所示:

$ ant -lib <folder containing spring-boot-antlib-2.2.8.RELEASE.jar>
使用Spring Boot 部分包含将Apache Ant与结合使用 spring-boot-antlib 的更完整示例.

3.1. Spring Boot Ant 任务

一旦 spring-boot-antlib 命名空间已申报,以下附加任务:

3.1.1. spring-boot:exejar

您可以使用该 exejar 任务创建一个Spring Boot可执行jar. 任务支持以下属性:

属性 描述 是否需要

destfile

要创建的目标jar文件

Yes

classes

Java类文件的根目录

Yes

start-class

要运行的主要应用程序类

No (否 (默认为找到的第一个声明 main 方法的类) )

以下嵌套元素可用于任务:

元素 描述

resources

一个或多个 资源集合,描述应添加到创建的jar文件内容中的一组 Resources .

lib

应将一个或多个 资源集合 添加到组成应用程序运行时依赖类路径的jar库集合中.

3.1.2. 例子

本节显示了两个Ant任务示例.

Specify start-class
<spring-boot:exejar destfile="target/my-application.jar"
        classes="target/classes" start-class="com.example.MyApplication">
    <resources>
        <fileset dir="src/main/resources" />
    </resources>
    <lib>
        <fileset dir="lib" />
    </lib>
</spring-boot:exejar>
Detect start-class
<exejar destfile="target/my-application.jar" classes="target/classes">
    <lib>
        <fileset dir="lib" />
    </lib>
</exejar>

3.2. spring-boot:findmainclass

findmainclass 任务在内部 exejar 用于查找声明的类 main. 如有必要,您也可以在构建中直接使用此任务. 支持以下属性:

属性 描述 是否需要

classesroot

Java类文件的根目录

Yes (除非 mainclass 指定)

mainclass

可用于短路 main class 搜索

No

property

应该与结果一起设置的Ant属性

No (如果未指定,将记录结果)

3.2.1. 例子

本节包含使用的三个示例 findmainclass.

查找并记录
<findmainclass classesroot="target/classes" />
查找并设置
<findmainclass classesroot="target/classes" property="main-class" />
覆盖并设置
<findmainclass mainclass="com.example.MainClass" property="main-class" />

4. 支持其他构建系统

如果要使用Maven,Gradle或Ant以外的构建工具,则可能需要开发自己的插件. 可执行的jar需要遵循特定的格式,某些条目需要以未压缩的形式编写 (有关详细信息,请参见附录中的 “可执行jar格式” 部分) .

Spring Boot Maven和Gradle插件都利用它们 spring-boot-loader-tools 来实际生成jar. 如果需要,可以直接使用此库.

4.1. 重新打包 Archives

要重新打包现有存档,使其成为独立的可执行存档,请使用 org.springframework.boot.loader.tools.Repackager. 该 Repackager class 采取的是指现有的 jar 或 war archive 单个构造函数的参数. 使用两种可用 repackage() 方法之一替换原始文件或写入新目标. 在重新打包程序运行之前,还可以对其进行各种设置.

4.2. 嵌套库

重新打包 存档 时,可以使用该 org.springframework.boot.loader.tools.Libraries 接口包括对依赖文件的引用. 我们 Libraries 这里不提供任何具体的实现,因为它们通常是特定于构建系统的.

如果归档文件中已经包含库,则可以使用 Libraries.NONE.

4.3. 查找 Main Class

如果您不用于 Repackager.setMainClass() 指定主类,则重新包装器将使用 ASM 读取类文件,并尝试使用一种 public static void main(String[] args) 方法找到合适的类. 如果找到多个候选者,则会引发异常.

4.4. 重新打包示例实现

以下示例显示了典型的重新打包实现:

Repackager repackager = new Repackager(sourceJarFile);
repackager.setBackupSource(false);
repackager.repackage(new Libraries() {
            @Override
            public void doWithLibraries(LibraryCallback callback) throws IOException {
                // Build system specific implementation, callback for each dependency
                // callback.library(new Library(nestedFile, LibraryScope.COMPILE));
            }
        });

5. 接下来阅读什么

如果您对构建工具插件的工作方式感兴趣,可以查看 spring-boot-tools 上的模块. 可执行jar格式的更多技术细节在 附录中 介绍.

如果您有与构建相关的特定问题,可以查看 “how-to” 指南.