Route-nice
0%

SpringBoot官方文档翻译-构建工具插件

发表于 更新于 分类于 Disqus：

Spring Boot 为 Maven 和 Gradle 提供了构建工具插件。插件提供了多种功能，包括可执行 jar 的打包。本节提供了有关这两个插件的更多详细信息，以及在扩展不受支持的构建系统时所需的一些帮助。如果您刚刚 Starter，则可能需要先从“ 第三部分，“使用 Spring Boot””部分阅读“ 第 13 章，构建系统”。

SpringBootMaven插件

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

Note

有关完整的插件文档，请参见Spring Boot Maven 插件网站。

包含插件

要使用 Spring Boot Maven 插件，请在pom.xml的plugins部分中包含适当的 XML，如以下示例所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?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 http://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.1.1.RELEASE</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

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

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

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

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

如果使用里程碑或快照发行版，则还需要添加相应的pluginRepository元素，如以下 Lists 所示：

1
2
3
4
5
6
7
8
9
10
<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>

包装可执行的Jar和War文件

将spring-boot-maven-plugin包含在pom.xml中后，它会自动尝试重写 Files，以使 Files 可以通过spring-boot:repackage目标执行。您应该使用通常的packaging元素将项目配置为构建 jar 或 war(视情况而定)，如以下示例所示：

1
2
3
4
5
6
7
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <!-- ... -->
    <packaging>jar</packaging>
    <!-- ... -->
</project>

Spring Boot 在package阶段会增强您现有的存档。可以通过使用配置选项或通过以常规方式向 Lists 添加Main-Class属性来指定要启动的主类。如果未指定主类，则插件将使用public static void main(String[] args)方法搜索一个类。

要构建和运行项目工件，可以键入以下内容：

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

要构建既可执行又可部署到外部容器的 war 文件，您需要将嵌入式容器的依赖关系标记为“已提供”，如以下示例所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<?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 http://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>

Tip

有关如何创建可部署的 war 文件的更多详细信息，请参见“ 第 92.1 节“创建可部署的 War 文件””部分。

插件信息页面中提供了高级配置选项和示例。

SpringBootGradle插件

Spring Boot Gradle 插件在 Gradle 中提供了 Spring Boot 支持，使您可以打包可执行 jar 或 war 归档文件，运行 Spring Boot 应用程序以及使用spring-boot-dependencies提供的依赖项 Management。它需要 Gradle 4.4 或更高版本。请参考插件的文档以了解更多信息：

SpringBootAntLib模块

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

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

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

1
$ ant -lib <folder containing spring-boot-antlib-2.1.1.RELEASE.jar>

Tip

“使用 Spring Boot”部分包括结合使用 Apache Ant 和 spring-boot-antlib的更完整示例。

SpringBootAnt任务

声明spring-boot-antlib名称空间后，可以使用以下附加任务：

spring-boot:exejar

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

Attribute Description Required
destfile 要创建的目标 jar 文件 Yes
classes Java 类文件的根目录 Yes
start-class 要运行的主要应用程序类 否(默认为找到的第一个声明main方法的类)

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

Element Description
resources 一个或多个Resource Collections描述一组Resources，应将其添加到创建的 jar 文件的内容中。
lib 应该将一个或多个Resource Collections添加到组成应用程序运行时依赖项 Classpath 的 jar 库集合中。

Examples

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

Specify start-class.

1
2
3
4
5
6
7
8
9
<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.

1
2
3
4
5
<exejar destfile="target/my-application.jar" classes="target/classes">
    <lib>
        <fileset dir="lib" />
    </lib>
</exejar>

spring-boot:findmainclass

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

Attribute Description Required
classesroot Java 类文件的根目录 是(除非指定了mainclass)
mainclass 可用于短路main类搜索 No
property 应该与结果一起设置的 Ant 属性 否(如果未指定，将记录结果)

Examples

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

查找并记录.

1
<findmainclass classesroot="target/classes" />

查找并设置.

1
<findmainclass classesroot="target/classes" property="main-class" />

覆盖并设置.

1
<findmainclass mainclass="com.example.MainClass" property="main-class" />

支持其他构建系统

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

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

重新打包Files

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

嵌套库

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

如果您的存档中已经包含库，则可以使用Libraries.NONE。

查找主要类

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

重新打包实施示例

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

1
2
3
4
5
6
7
8
9
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));
            }
        });

接下来要读什么

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

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