SpringBootMaven插件

Stephane Nicoll, Andy Wilkinson, Scott Frederick

介绍

Spring Boot Maven插件在Apache Maven中提供Spring引导支持。它允许您打包可执行的jar或war文件，运行Spring引导应用程序，生成构建信息，并在运行集成测试之前启动Spring引导应用程序。

入门

要使用Spring Boot Maven插件，请在pom的插件部分包含适当的XML。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.3.4.RELEASE</version>
            </plugin>
        </plugins>
    </build>
</project>

如果您使用一个里程碑或快照版本，您还需要添加适当的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>

使用插件

Maven用户可以从spring-boot-starter-parent继承，以获得合理的缺省值。父项目提供以下功能:

• Java 1.8作为默认的编译器级别。
• utf - 8编码。
• 从spring-boot-dependencies的POM继承的依赖项管理部分，用于管理公共依赖项的版本。这种依赖项管理允许您在自己的POM中使用这些依赖项时省略<version/>标记。
• 使用重新打包执行id执行重新打包目标。
• 合理的资源过滤。
• 合理的插件配置(Git commit ID和shade)。
• 应用程序的合理资源筛选,application.properties和application.yml。包含特定的配置文件(例如，application-dev.properties和application-dev.yml)

注意，自application.properties和application.yml文件接受Spring样式占位符(${…})后，Maven过滤改为使用@..@占位符。(您可以通过设置一个名为resource.delimiter的Maven属性来覆盖它。)

继承启动器父POM

要将您的项目配置为从spring-boot-starter-parent，请将父项目设置如下:

<!-- Inherit defaults from Spring Boot -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>

您应该只需要在这个依赖项上指定Spring引导版本号。如果您导入了额外的启动程序，则可以安全地省略版本号。

通过该设置，您还可以通过覆盖自己项目中的属性来覆盖各个依赖项。例如，要使用不同版本的SLF4J库和Spring数据发布系列，您需要在您的pom.xml中添加以下内容:

<properties>
    <slf4j.version>1.7.30</slf4j.version>
    <spring-data-releasetrain.version>Moore-SR6</spring-data-releasetrain.version>
</properties>

浏览Spring引导参考中的依赖版本附录，获得依赖版本属性的完整列表。

不继承父POM

不从spring-boot-starter-parent POM继承可能是有原因的。您可能需要使用自己的公司标准父组件，或者您可能更喜欢显式地声明所有的Maven配置。

如果你不想使用spring-boot-starter-parent，你仍然可以通过使用import作用域依赖项来保持依赖项管理(而不是插件管理)的优势，如下所示:

<dependencyManagement>
    <dependencies>
        <dependency>
            <!-- Import dependency management from Spring Boot -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.3.4.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

前面的示例设置不允许您通过使用属性(如上所述)覆盖单个依赖项。要达到相同的结果，您需要在spring启动依赖项之前在项目的dependencyManagement部分中添加条目。例如，要使用不同版本的SLF4J库和Spring数据发布系列，您可以在您的pom.xml中添加以下元素:

<dependencyManagement>
    <dependencies>
        <!-- Override SLF4J provided by Spring Boot -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.30</version>
        </dependency>
        <!-- Override Spring Data release train provided by Spring Boot -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-releasetrain</artifactId>
            <version>Moore-SR6</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.3.4.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Goals

Spring Boot插件有以下目标:

Goal	Description
spring-boot:build-image	使用构建包将应用程序打包到OCI映像中。
spring-boot:build-info	生成一个build-info。属性文件基于当前MavenProject的内容。
spring-boot:help	显示有关spring-boot-maven-plugin的帮助信息。调用mvn spring-boot:help -Ddetail=true -Dgoal=<goal-name>显示参数细节。
spring-boot:repackage	重新打包现有的JAR和WAR归档，以便可以使用java -jar从命令行执行它们。使用layout=NONE也可以简单地用于打包带有嵌套依赖关系的JAR(没有主类，所以不是可执行的)。
spring-boot:run	运行应用
spring-boot:start	启动一个spring应用程序。与运行目标相反，它不会阻塞，并允许其他目标对应用程序进行操作。这个目标通常用于集成测试场景，其中应用程序在测试套件之前启动，在测试套件之后停止。
spring-boot:stop	停止由“start”目标启动的应用程序。通常在测试套件完成后调用。

打包可执行档案

插件可以创建包含应用程序所有依赖项的可执行档案(jar文件和war文件)，然后可以使用java -jar运行。

打包一个可执行的存档文件是由repackage目标执行的，如下面的例子所示:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.3.4.RELEASE</version>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Note

如果您使用spring-boot-starter-parent，这样的执行已经预先配置了一个重新打包的执行ID，因此只需要添加插件定义。

上面的示例重新打包了在Maven生命周期的包阶段构建的jar或war归档，包括在项目中定义的任何提供的依赖项。如果需要排除其中一些依赖项，可以使用其中一个排除选项;有关更多细节，请参见依赖项排除。

原始的(即非可执行的)工件在默认情况下被重命名为.original，但是使用自定义分类器来保留原始工件也是可能的。

Note

maven-war-plugin的outputFileNameMapping特性目前不受支持。

默认情况下，Devtools会自动被排除(你可以使用excludeDevtools属性来控制)。为了使其与war打包一起工作，spring-boot-devtools依赖关系必须设置为可选的，或者设置为提供的范围。

这个插件会重写你的清单，特别是它会管理Main-Class和Start-Class条目。如果默认值不工作，您必须在Spring引导插件中配置值，而不是在jar插件中。清单中的主类是由Spring Boot插件的layout属性控制的，如下面的例子所示:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.3.4.RELEASE</version>
            <configuration>
                <mainClass>${start.class}</mainClass>
                <layout>ZIP</layout>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

布局属性默认为由存档类型(jar或war)确定的值。可供选择的布局如下:

• JAR:常规的可执行JAR布局。
• WAR:可执行的WAR布局。提供的依赖关系放置在WEB-INF/lib中，以避免在servlet容器中部署war时发生冲突。
• ZIP (DIR的别名):类似于使用PropertiesLauncher的JAR布局。
• NONE:捆绑所有依赖项和项目资源。不绑定引导加载程序。

分层的Jars

重新打包的jar分别在BOOT-INF/classes和BOOT-INF/lib中包含应用程序的类和依赖项。对于需要从jar的内容构建docker映像的情况，进一步分离这些目录将非常有用，这样就可以将它们写入不同的层中。

分层jar使用与常规重新打包的jar相同的布局，但是包含一个额外的元数据文件来描述每一层。要使用此功能，必须启用分层功能:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <layers>
                        <enabled>true</enabled>
                    </layers>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

默认情况下，定义了以下层:

• dependencies 任何版本不包含快照的依赖项。
• spring-boot-loader用于jar加载器类。
• snapshot-dependencies用于版本包含SNAPSHOT的任何依赖。
• application用于application类和resources。

层顺序很重要，因为它决定了当应用程序的一部分发生更改时缓存前一层的可能性有多大。默认顺序是dependencies, spring-boot-loader, snapshot-dependencies, application。首先应该添加最不容易更改的内容，然后添加更容易更改的层。

自定义层配置

根据您的应用程序，您可能需要调整层的创建和添加新层的方式。这可以使用一个单独的配置文件来完成，应该注册如下所示:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <layers>
                        <enabled>true</enabled>
                        <configuration>${project.basedir}/src/layers.xml</configuration>
                    </layers>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

配置文件描述了如何将jar划分为层，以及这些层的顺序。下面的示例展示了如何显式定义上面描述的默认顺序:

<layers xmlns="http://www.springframework.org/schema/boot/layers"
                      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                      xsi:schemaLocation="http://www.springframework.org/schema/boot/layers
                      https://www.springframework.org/schema/boot/layers/layers-2.3.xsd">
    <application>
        <into layer="spring-boot-loader">
            <include>org/springframework/boot/loader/**</include>
        </into>
        <into layer="application" />
    </application>
    <dependencies>
        <into layer="snapshot-dependencies">
            <include>*:*:*SNAPSHOT</include>
        </into>
        <into layer="dependencies" />
    </dependencies>
    <layerOrder>
        <layer>dependencies</layer>
        <layer>spring-boot-loader</layer>
        <layer>snapshot-dependencies</layer>
        <layer>application</layer>
    </layerOrder>
</layers>

层XML格式定义在三个部分:

• <application>块定义了应用程序类和资源应该如何分层。
• <dependencies>块定义了应该如何分层依赖。
• <layerOrder>块定义了应该写入这些层的顺序。

在<application>和<dependencies>部分中使用嵌套的<into>块声明一个层的内容。从上到下，按照定义块的顺序计算。前面的块没有声明的任何内容仍然可用，供后续块考虑。

<into>块使用嵌套的<include>和<exclude>元素声明内容。<application>部分对包含/排除表达式使用了ant样式的补丁匹配。<dependencies>部分使用group:artifact[:version]模式。

如果没有定义<include>，那么将考虑所有内容(不是由前面的块声明的)。

如果没有定义<exclude>，则不应用任何排除。

看看上面的<dependencies>示例，我们可以看到第一个<into>将声明快照依赖层的所有快照依赖关系。后续的<into>将声明依赖项层的所有剩余内容(在本例中，是不是快照的任何依赖项)。

<application>块具有类似的规则。首先声明spring引导加载器层的org/springframework/boot/loader/**内容。然后为应用层声明所有剩余的类和资源。

Note

<into>块的顺序通常与写入层的顺序不同。因此，必须始终包含<layerOrder>元素，并且必须覆盖<info>块中引用的所有层。

spring-boot:repackage

org.springframework.boot:spring-boot-maven-plugin:2.3.4.RELEASE

重新打包现有的JAR和WAR归档，以便可以使用java -jar从命令行执行它们。使用layout=NONE也可以简单地用于打包带有嵌套依赖关系的JAR(没有主类，所以不是可执行的)。

参数要求

Name	Type	Default
outputDirectory	File	${project.build.directory}

可选参数

Name	Type	Default
attach	boolean	true
classifier	String
embeddedLaunchScript	File
embeddedLaunchScriptProperties	Properties
excludeDevtools	boolean	true
excludeGroupIds	String
excludes	List
executable	boolean	false
includeSystemScope	boolean	false
includes	List
layers	Layers
layout	AbstractPackagerMojo$LayoutType
layoutFactory	LayoutFactory
mainClass	String
outputTimestamp	String	${project.build.outputTimestamp}
requiresUnpack	List
skip	boolean	false

详细参数

attach

附加要安装到本地Maven存储库或部署到远程存储库的重新打包归档。如果没有配置分类器，它将取代普通的jar。如果一个classfier被配置成普通jar和重新打包的jar不同，那么它将与普通jar一起被附加。当属性设置为false时，将不会安装或部署重新打包的存档。

Name	attach
Type	boolean
Default value	true
User property
Since	1.4.0

classifier

添加到重新打包归档的分类器。如果没有给出，主构件将被重新打包的归档文件替换。如果给定，分类器还将用于确定要重新打包的源存档:如果一个带有分类器的工件已经存在，它将被用作源并替换。如果不存在这样的工件，那么主工件将被用作源，而重新打包的存档将作为附加工件与该分类器一起附加。附加工件允许将其部署到原始工件的旁边，请参阅$1[$2]。

Name	classifier
Type	java.lang.String
Default value
User property
Since	1.0.0

embeddedLaunchScript

嵌入的启动脚本，如果它是完全可执行的，它将被前置到jar的前端。如果没有指定“Spring Boot”，将使用默认脚本。

Name	embeddedLaunchScript
Type	java.io.File
Default value
User property
Since	1.3.0

embeddedLaunchScriptProperties

应该在嵌入的启动脚本中展开的属性。

Name	embeddedLaunchScriptProperties
Type	java.util.Properties
Default value
User property
Since	1.3.0

excludeDevtools

从重新打包的归档文件中排除Spring Boot devtools。

Name	excludeDevtools
Type	boolean
Default value	true
User property	spring-boot.repackage.excludeDevtools
Since	1.3.0

excludeGroupIds

要排除的用逗号分隔的groupId名称列表(精确匹配)。

Name	excludeGroupIds
Type	java.lang.String
Default value
User property	spring-boot.excludeGroupIds
Since	1.1.0

excludes

要排除的工件定义的集合。Exclude元素定义了groupId和artifactId强制属性以及一个可选的分类器属性。

Name	excludes
Type	java.util.List
Default value
User property	spring-boot.excludes
Since	1.1.0

executable

通过在jar前添加启动脚本，为*nix机器创建一个完全可执行的jar。

目前，一些工具不接受这种格式，所以您可能不总是能够使用这种技术。例如，jar -xf可能悄无声息地无法提取完全可执行的jar或war。建议仅在打算直接执行该选项时启用它，而不是使用java -jar运行它或将其部署到servlet容器中。

Name	executable
Type	boolean
Default value	false
User property
Since	1.3.0

includeSystemScope

包括系统范围的依赖项。

Name	includeSystemScope
Type	boolean
Default value	false
User property
Since	1.4.0

includes

要包含的工件定义的集合。Include元素定义了groupId和artifactId强制属性以及一个可选的分类器属性。

Name	includes
Type	java.util.List
Default value
User property	spring-boot.includes
Since	1.2.0

layers

层配置的选项，以排除层工具jar。

Name	layers
Type	org.springframework.boot.maven.Layers
Default value
User property
Since	2.3.0

layout

归档的类型(对应于依赖项在其中的布局方式)。可能的值是JAR、WAR、ZIP、DIR、NONE。默认情况下是基于存档类型的猜测。

Name	layout
Type	org.springframework.boot.maven.AbstractPackagerMojo$LayoutType
Default value
User property	spring-boot.repackage.layout
Since	1.0.0

layoutFactory

布局工厂，将用于创建可执行的存档，如果没有明确的布局设置。替代布局实现可以由第三方提供。

Name	layoutFactory
Type	org.springframework.boot.loader.tools.LayoutFactory
Default value
User property
Since	1.5.0

mainClass

主类的名称。如果没有指定，将使用第一个发现的包含“main”方法的编译类。

Name	mainClass
Type	java.lang.String
Default value
User property
Since	1.0.0

outputDirectory

包含生成的归档文件的目录。

Name	outputDirectory
Type	java.io.File
Default value	${project.build.directory}
User property
Since	1.0.0

outputTimestamp

可再现输出归档条目的时间戳，可以格式化为ISO 8601 (yyyy-MM-dd 'HH:mm:ssXXX)，也可以是表示自纪元以来秒数的int。war包不支持。

Name	outputTimestamp
Type	java.lang.String
Default value	${project.build.outputTimestamp}
User property
Since	2.3.0

requiresUnpack

必须从胖jar中解压缩才能运行的库的列表。将每个库指定为<dependency>、<groupId>和<artifactId>，它们将在运行时解压缩。

Name	requiresUnpack
Type	java.util.List
Default value
User property
Since	1.1.0

skip

跳过执行。

Name	skip
Type	boolean
Default value	false
User property	spring-boot.repackage.skip
Since	1.2.0

Example

自定义Classfier

默认情况下，重新打包目标用重新打包的工件替换原始工件。对于表示应用程序的模块来说，这是一种正常的行为，但是如果您的模块被用作另一个模块的依赖项，那么您需要为重新打包的模块提供一个分类器。原因是应用程序类被打包在BOOT-INF/classes中，这样依赖模块就不能加载重新打包的jar类。

如果是这样，或者如果您想保留原始工件，并将重新打包的工件附加到不同的分类器中，那么配置插件如下面的示例所示:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                        <configuration>
                            <classifier>exec</classifier>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

如果您使用spring-boot-starter-parent，那么重新打包目标将在id repackage执行中自动执行。在这个设置中，只需要指定配置，如下面的例子所示:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <configuration>
                            <classifier>exec</classifier>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

这个配置将生成两个工件:原始的和由重新打包目标产生的重新打包的计数器部分。两者的安装和部署都是透明的。

如果您希望以替换主工件的相同方式重新打包辅助工件，您也可以使用相同的配置。以下配置使用重新打包的应用程序安装/部署单个任务分类构件:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>1.2.3</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                        <phase>package</phase>
                        <configuration>
                            <classifier>task</classifier>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                        <configuration>
                            <classifier>task</classifier>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

由于maven-jar-plugin和spring-boot-maven-plugin在同一阶段运行，所以务必首先定义jar插件(以便在重新打包目标之前运行)。同样，如果您使用的是spring-boot-starter-parent，这可以简化如下:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <executions>
                    <execution>
                        <id>default-jar</id>
                        <configuration>
                            <classifier>task</classifier>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <configuration>
                            <classifier>task</classifier>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

自定义名字

如果您需要重新打包的jar有一个不同于项目的artifactId属性定义的本地名称，请使用标准的finalName，如下面的示例所示:

<project>
    <build>
        <finalName>my-app</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

这个配置将在target/my-app.jar中生成重新打包的构件。

本地重新打包档案

默认情况下，重新打包目标将原始工件替换为可执行工件。如果你只需要部署原来的jar，但又能够运行你的应用程序的常规文件名，配置插件如下:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                        <configuration>
                            <attach>false</attach>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

这个配置生成了两个工件:原始的和由重新打包目标生成的可执行的对应部分。只有原始版本将被安装/部署。

自定义Layout

Spring Boot使用在附加jar文件中定义的自定义布局工厂为这个项目重新打包jar文件，作为构建插件的依赖项提供:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                        <configuration>
                            <layoutFactory implementation="com.example.CustomLayoutFactory">
                                <customProperty>value</customProperty>
                            </layoutFactory>
                        </configuration>
                    </execution>
                </executions>
                <dependencies>
                    <dependency>
                        <groupId>com.example</groupId>
                        <artifactId>custom-layout</artifactId>
                        <version>0.0.1.BUILD-SNAPSHOT</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>
</project>

布局工厂是作为pom中显式指定的LayoutFactory(来自spring-boot-loader-tools)的实现提供的。如果在插件类路径上只有一个定制LayoutFactory，并且在META-INF/spring.factories中列出。这样就没有必要在插件配置中显式地设置它。

如果设置了显式布局，布局工厂总是被忽略。

依赖排除

默认情况下，重新打包和运行目标都将包括在项目中定义的任何提供的依赖项。Spring引导项目应该将提供的依赖项视为运行应用程序所需的“容器”依赖项。

有些依赖关系可能根本不需要，应该从可执行jar中排除。为了保持一致性，它们在运行应用程序时也不应该出现。

有两种方法可以让依赖项在运行时不被打包/使用:

• 排除由groupId和artifactId标识的特定工件，如果需要，可以选择使用分类器。

• 排除属于给定groupId的任何工件。

下面的示例排除了com.foo:bar，只有那个artifact:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>com.foo</groupId>
                            <artifactId>bar</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

这个例子排除了任何属于com.foo的工件组:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <excludeGroupIds>com.foo</excludeGroupIds>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

分层Jar工具

当您创建分层jar时，spring-boot-jarmode-layertools jar将作为依赖项添加到您的jar中。有了类路径上的这个jar，您就可以以一种特殊的模式启动应用程序，这种模式允许引导代码运行与应用程序完全不同的东西，例如，提取层的东西。如果你想排除这种依赖，你可以这样做，在以下方式:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <layers>
                        <enabled>true</enabled>
                        <includeLayerTools>false</includeLayerTools>
                    </layers>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

自定义层配置

默认设置将依赖项划分为快照和非快照，但是，您可能有更复杂的规则。例如，您可能希望将项目的公司特定依赖关系隔离在专用层中。下面的layers.xml配置显示了这样的设置:

<layers xmlns="http://www.springframework.org/schema/boot/layers"
                      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                      xsi:schemaLocation="http://www.springframework.org/schema/boot/layers
                      https://www.springframework.org/schema/boot/layers/layers-2.3.xsd">
    <application>
        <into layer="spring-boot-loader">
            <include>org/springframework/boot/loader/**</include>
        </into>
        <into layer="application" />
    </application>
    <dependencies>
        <into layer="snapshot-dependencies">
            <include>*:*:*SNAPSHOT</include>
        </into>
        <into layer="company-dependencies">
            <include>com.acme:*</include>
        </into>
        <into layer="dependencies"/>
    </dependencies>
    <layerOrder>
        <layer>dependencies</layer>
        <layer>spring-boot-loader</layer>
        <layer>snapshot-dependencies</layer>
        <layer>company-dependencies</layer>
        <layer>application</layer>
    </layerOrder>
</layers>

上面的配置创建了一个附加的company-dependencies，所有的库都使用com.acme 组ID。

打包OCI镜像

这个插件可以使用Cloud Native Buildpacks创建一个OCI映像。可以使用build-image目标来构建映像。

Note

出于安全原因，映像以非根用户的身份生成和运行，请参阅本节了解更多细节。

最简单的开始方法是在项目上调用mvn spring-boot:build-image。只要调用包阶段，就可以自动创建映像，如下面的示例所示:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.3.4.RELEASE</version>
            <executions>
                <execution>
                    <goals>
                        <goal>build-image</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Note

虽然构建包从可执行存档运行，但没有必要首先执行重新打包的目标，因为如果需要的话，可执行存档会自动创建。当构建映像重新打包应用程序时，它会应用与重新打包目标相同的设置，即依赖关系可以使用其中一个排除选项排除，Devtools默认情况下自动排除(你可以使用excludeDevtools属性控制)。

Docker守护进程

构建映像目标需要访问Docker守护进程。默认情况下，它将通过本地连接与Docker守护进程通信。这工作Docker引擎在所有支持的平台上没有配置。

可以设置环境变量来配置构建映像目标，以使用minikube提供的Docker守护进程。下表显示了环境变量及其值:

环境变量	描述
DOCKER_HOST	包含Docker守护进程的主机和端口的URL - e.g. tcp://192.168.99.100:2376
DOCKER_TLS_VERIFY	当设置为1时启用安全HTTPS协议(可选)
DOCKER_CERT_PATH	HTTPS证书和密钥文件的路径(哪里DOCKER_TLS_VERIFY=1需要，否则忽略)

在Linux和macOS上，可以在minikube启动后使用eval $(minikube dockator -env)命令设置这些环境变量。

镜像定制

插件调用一个构建器来编排映像的生成。构建器包括多个buildpacks，它们可以检查应用程序以影响生成的映像。默认情况下，插件选择一个构建器镜像。生成的图像的名称由项目属性导出。

image参数允许对构建器进行配置，以及如何对项目进行操作。下表总结了可用的参数及其默认值:

参数	Description	User property	Default value
builder	要使用的生成器映像的名称。	spring-boot.build-image.builder	gcr.io/paketo-buildpacks/builder:base-platform-api-0.3
runImage	要使用的运行映像的名称。	spring-boot.build-image.runImage	没有默认值，表示应该使用生成器元数据中指定的运行映像。
name	生成的映像的映像名。	spring-boot.build-image.imageName	docker.io/library/${project.artifactId}:${project.version}
env	应该传递给构建器的环境变量。
cleanCache	是否在生成前清理缓存。		false
verboseLogging	启用构建器操作的详细日志记录。		false

该插件使用编译器的插件配置或maven.compiler.target属性检测项目的目标Java兼容性。默认情况下，插件指示构建包安装相同的Java版本。您可以通过设置BP_JVM_VERSION环境变量来覆盖此行为，请参阅构建器配置。

有关详细信息，还请参见自定义映像生成器和自定义映像名称。

spring-boot:build-image

org.springframework.boot:spring-boot-maven-plugin:2.3.4.RELEASE

使用构建包将应用程序打包到OCI映像中。

必要参数

Name	Type	Default
sourceDirectory	File	${project.build.directory}

可选参数

Name	Type	Default
classifier	String
excludeDevtools	boolean	true
excludeGroupIds	String
excludes	List
includeSystemScope	boolean	false
includes	List
layers	Layers
layout	AbstractPackagerMojo$LayoutType
layoutFactory	LayoutFactory
mainClass	String
skip	boolean	false

详细参数

classifier

添加到重新打包归档的分类器。如果没有给出，主构件将被重新打包的归档文件替换。如果给定，分类器还将用于确定要重新打包的源存档:如果一个带有分类器的工件已经存在，它将被用作源并替换。如果不存在这样的工件，那么主工件将被用作源，而重新打包的存档将作为附加工件与该分类器一起附加。附加工件允许将其部署到原始工件的旁边，请参阅$1[$2]。

Name	classifier
Type	java.lang.String
Default value
User property
Since	1.0.0

excludeDevtools

从重新打包的归档文件中排除Spring Boot devtools。

Name	excludeDevtools
Type	boolean
Default value	true
User property	spring-boot.repackage.excludeDevtools
Since	1.3.0

excludeGroupIds

要排除的用逗号分隔的groupId名称列表(精确匹配)。

Name	excludeGroupIds
Type	java.lang.String
Default value
User property	spring-boot.excludeGroupIds
Since	1.1.0

excludes

要排除的工件定义的集合。Exclude元素定义了groupId和artifactId强制属性以及一个可选的分类器属性。

Name	excludes
Type	java.util.List
Default value
User property	spring-boot.excludes
Since	1.1.0

image

映像配置，使用生成器、runImage、name、env、cleanCache和verboseLogging选项。

Name	image
Type	org.springframework.boot.maven.Image
Default value
User property
Since	2.3.0

includeSystemScope

包括系统范围的依赖项。

Name	includeSystemScope
Type	boolean
Default value	false
User property
Since	1.4.0

includes

要包含的工件定义的集合。Include元素定义了groupId和artifactId强制属性以及一个可选的分类器属性。

Name	includes
Type	java.util.List
Default value
User property	spring-boot.includes
Since	1.2.0

layers

层配置的选项，以排除层工具jar。

Name	layers
Type	org.springframework.boot.maven.Layers
Default value
User property
Since	2.3.0

layout

归档的类型(对应于依赖项在其中的布局方式)。可能的值是JAR、WAR、ZIP、DIR、NONE。默认情况下是基于存档类型的猜测。

Name	layout
Type	org.springframework.boot.maven.AbstractPackagerMojo$LayoutType
Default value
User property	spring-boot.repackage.layout
Since	1.0.0

layoutFactory

布局工厂，将用于创建可执行的存档，如果没有明确的布局设置。替代布局实现可以由第三方提供。

Name	layoutFactory
Type	org.springframework.boot.loader.tools.LayoutFactory
Default value
User property
Since	1.5.0

mainClass

主类的名称。如果没有指定，将使用第一个发现的包含“main”方法的编译类。

Name	mainClass
Type	java.lang.String
Default value
User property
Since	1.0.0

skip

跳过执行。

Name	skip
Type	boolean
Default value	false
User property	spring-boot.repackage.skip
Since	1.2.0

sourceDirectory

包含JAR的目录。

Name	sourceDirectory
Type	java.io.File
Default value	${project.build.directory}
User property
Since	2.3.0

Examples

自定义镜像构建器

如果您需要自定义用于创建图像的构建器或用于启动构建图像的运行图像，配置插件如下所示:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <image>
                        <builder>mine/java-cnb-builder</builder>
                        <runImage>mine/java-cnb-run</runImage>
                    </image>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

这个配置将使用一个名为mine/java-cnb-builder的构建器映像和最新的标记，以及名为mine/java-cnb-run的运行映像和最新的标记。

构建器和运行映像也可以在命令行上指定，如下例所示:

mvn spring-boot:build-image -Dspring-boot.build-image.builder=mine/java-cnb-builder -Dspring-boot.build-image.runImage=mine/java-cnb-run

构建器配置

如果构建器使用环境变量公开配置选项，则可以使用env属性设置这些选项。

下面的示例假设默认构建器识别BP_JVM_VERSION属性。这个属性通常用于自定义图像应该使用的JDK版本，通过指定主要版本和版本其余部分的通配符:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <image>
                        <env>
                            <BP_JVM_VERSION>8.*</BP_JVM_VERSION>
                        </env>
                    </image>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

如果在运行构建器的Docker守护进程和构建包从其中下载构件的网络位置之间存在网络代理，则需要配置构建器以使用代理。当使用默认构建器时，可以通过设置HTTPS_PROXY和/或HTTP_PROXY环境变量来完成，如下面的例子所示:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <image>
                        <env>
                            <HTTP_PROXY>http://proxy.example.com</HTTP_PROXY>
                            <HTTPS_PROXY>https://proxy.example.com</HTTPS_PROXY>
                        </env>
                    </image>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

自定义镜像名称

默认情况下，图像名称是从artifactId和项目的版本推断出来的，类似于docker.io/library/${project.artifactId}:${project.version}。您可以控制名称，如下面的例子所示:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <image>
                        <name>example.com/library/${project.artifactId}</name>
                    </image>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

注意，此配置没有提供显式标记，因此使用的是latest。也可以指定一个标签，使用${project.version}，构建版本或硬编码版本中可用的任何属性。

也可以在命令行中指定图像名称，如下例所示:

$ mvn spring-boot:build-image -Dspring-boot.build-image.imageName=example.com/library/my-app:v1

使用Maven运行Application

该插件包括一个运行目标，可以用来启动您的应用程序从命令行，如下面的例子所示:

$ mvn spring-boot:run

应用程序参数可以使用arguments参数指定，有关详细信息，请参阅使用应用程序参数。

默认情况下，应用程序在派生进程中执行，在命令行上设置属性不会影响应用程序。如果您需要指定一些JVM参数(例如，为了调试目的)，您可以使用jvmArguments参数，请参见调试应用程序以了解更多细节。还显式支持系统属性和环境变量。

由于启用属性文件非常常见，所以有一个专用的概要文件属性为-Dspring-boot.run.jvmArguments="- dspring .profile .active=dev"提供了快捷方式，请参见指定活动属性文件。

尽管不建议这样做，但是可以通过禁用fork属性从Maven JVM直接执行应用程序。这样做意味着忽略jvmArguments、systemPropertyVariables、environmentVariables和agents选项。

Spring Boot devtools是一个模块，用于改进在Spring Boot应用程序上工作时的开发时间体验。要启用它，只需添加以下依赖项到您的项目:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <version>2.3.4.RELEASE</version>
        <optional>true</optional>
    </dependency>
</dependencies>

当devtools运行时，当你重新编译你的应用程序时，它会检测变化并自动刷新它。这不仅适用于资源，也适用于代码。它还提供了一个LiveReload服务器，这样当事情发生变化时，它可以自动触发浏览器刷新。

Devtools还可以配置为只在静态资源发生变化时刷新浏览器(忽略代码中的任何变化)。只需包括以下属性在您的项目:

spring.devtools.remote.restart.enabled=false

在devtools出现之前，该插件默认支持资源的热刷新，现在为了支持上述解决方案，它被禁用了。您可以恢复它在任何时候通过配置您的项目:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.3.4.RELEASE</version>
            <configuration>
                <addResources>true</addResources>
            </configuration>
        </plugin>
    </plugins>
</build>

当addResources被启用时，当您运行应用程序时，任何src/main/resources目录都将被添加到应用程序类路径中，并且在target/classes中找到的任何副本都将被删除。这允许对资源进行热刷新，这在开发web应用程序时非常有用。例如，您可以处理HTML、CSS或JavaScript文件并立即查看更改，而无需重新编译应用程序。它也是允许前端开发人员不需要下载和安装Java IDE就可以工作的一种有用的方法。

Note

使用此特性的一个副作用是在构建时筛选资源将不起作用。

为了与重新打包的目标保持一致，run目标构建类路径的方式是，任何被排除在插件配置中的依赖项也被排除在类路径之外。有关更多细节，请参见专用示例。

有时，在运行应用程序时包含测试依赖关系是有用的。例如，如果您想在使用存根类的测试模式下运行应用程序。如果希望这样做，可以将useTestClasspath参数设置为true。注意，这仅在运行应用程序时应用:重新打包目标不会将测试依赖项添加到结果JAR/WAR中。

spring-boot:run

org.springframework.boot:spring-boot-maven-plugin:2.3.4.RELEASE

运行应用程序

必要参数

Name	Type	Default
classesDirectory	File	${project.build.outputDirectory}

可选参数

Name	Type	Default
addResources	boolean	false
agents	File[]
arguments	String[]
commandlineArguments	String
directories	String[]
environmentVariables	Map
excludeGroupIds	String
excludes	List
folders	String[]
fork	boolean	true
includes	List
jvmArguments	String
mainClass	String
noverify	boolean
optimizedLaunch	boolean	true
profiles	String[]
skip	boolean	false
systemPropertyVariables	Map
useTestClasspath	Boolean	false
workingDirectory	File

详细参数

addResources

直接将maven资源添加到类路径中，这允许对资源进行实时的就地编辑。从目标/类中删除重复的资源，以防止在调用ClassLoader.getResources()时它们出现两次。请考虑在您的项目中添加spring-boot-devtools，因为它提供了这个特性和更多特性。

Name	addResources
Type	boolean
Default value	false
User property	spring-boot.run.addResources
Since	1.0.0

agents

到代理jar的路径。注意:使用此特性需要一个分支过程。

Name	agents
Type	java.io.File[]
Default value
User property	spring-boot.run.agents
Since	2.2.0

arguments

应该传递给应用程序的参数。

Name	arguments
Type	java.lang.String[]
Default value
User property
Since	1.0.0

classesDirectory

目录，其中包含应该打包到存档中的类和资源文件。

Name	classesDirectory
Type	java.io.File
Default value	${project.build.outputDirectory}
User property
Since	1.0.0

commandlineArguments

应该传递给应用程序的命令行参数。使用空格分隔多个参数，并确保在引号之间包装多个值。在指定时，优先于#arguments。

Name	commandlineArguments
Type	java.lang.String
Default value
User property	spring-boot.run.arguments
Since	2.2.3

directories

应该添加到类路径的类目录之外的其他目录。

Name	directories
Type	java.lang.String[]
Default value
User property	spring-boot.run.directories
Since	1.0.0

environmentVariables

应与用于运行应用程序的派生进程关联的环境变量的列表。注意:使用此特性需要一个分支过程。

Name	environmentVariables
Type	java.util.Map
Default value
User property
Since	2.1.0

excludeGroupIds

要排除的用逗号分隔的groupId名称列表(精确匹配)。

Name	excludeGroupIds
Type	java.lang.String
Default value
User property	spring-boot.excludeGroupIds
Since	1.1.0

excludes

要排除的工件定义的集合。Exclude元素定义了groupId和artifactId强制属性以及一个可选的分类器属性。

Name	excludes
Type	java.util.List
Default value
User property	spring-boot.excludes
Since	1.1.0

folders

应该添加到类路径的类目录之外的其他目录。

Name	folders
Type	java.lang.String[]
Default value
User property	spring-boot.run.folders
Since	1.0.0

fork

标志，指示是否应该派生运行进程。禁用fork将禁用一些特性，如代理、自定义JVM参数、devtools或指定要使用的工作目录。

Name	fork
Type	boolean
Default value	true
User property	spring-boot.run.fork
Since	1.2.0

includes

要包含的工件定义的集合。Include元素定义了groupId和artifactId强制属性以及一个可选的分类器属性。

Name	includes
Type	java.util.List
Default value
User property	spring-boot.includes
Since	1.2.0

jvmArguments

应该与用于运行应用程序的派生进程相关联的JVM参数。在命令行上，确保在引号之间包装多个值。注意:使用此特性需要一个分支过程

Name	jvmArguments
Type	java.lang.String
Default value
User property	spring-boot.run.jvmArguments
Since	1.1.0

mainClass

主类的名称。如果没有指定，将使用第一个发现的包含“main”方法的编译类。

Name	mainClass
Type	java.lang.String
Default value
User property	spring-boot.run.main-class
Since	1.0.0

noverify

表示代理需要-noverify。

Name	noverify
Type	boolean
Default value
User property	spring-boot.run.noverify
Since	1.0.0

optimizedLaunch

是否应该优化JVM的启动。

Name	optimizedLaunch
Type	boolean
Default value	true
User property	spring-boot.run.optimizedLaunch
Since	2.2.0

profiles

要激活的spring配置文件。指定spring.profiles的快捷方式。积极的观点。在命令行中，使用逗号分隔多个概要文件。

Name	profiles
Type	java.lang.String[]
Default value
User property	spring-boot.run.profiles
Since	1.3.0

skip

跳过执行。

Name	skip
Type	boolean
Default value	false
User property	spring-boot.run.skip
Since	1.3.2

systemPropertyVariables

要传递给进程的JVM系统属性列表。注意:使用此特性需要一个分支过程。

Name	systemPropertyVariables
Type	java.util.Map
Default value
User property
Since	2.1.0

useTestClasspath

标记以在运行时包含测试类路径。

Name	useTestClasspath
Type	java.lang.Boolean
Default value	false
User property	spring-boot.run.useTestClasspath
Since	1.3.0

workingDirectory

用于应用程序的当前工作目录。如果没有指定，将使用basedir。注意:使用此特性需要一个分支过程。

Name	workingDirectory
Type	java.io.File
Default value
User property	spring-boot.run.workingDirectory
Since	1.5.0

Examples

调试应用

默认情况下，run目标在分支进程中运行应用程序。如果需要调试它，应该添加必要的JVM参数来启用远程调试。以下配置将暂停进程，直到调试器在端口5005上加入:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <jvmArguments>
                        -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005
                    </jvmArguments>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

这些参数也可以在命令行中指定，确保包装正确，即:

$ mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005"

使用系统属性

系统属性可以使用systemPropertyVariables属性指定。下面的示例将property1设置为test，将property2设置为42:

<project>
    <build>
        <properties>
            <my.value>42</my.value>
        </properties>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <systemPropertyVariables>
                        <property1>test</property1>
                        <property2>${my.value}</property2>
                    </systemPropertyVariables>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

如果值为空或未定义(即<my-property/>)，则系统属性将以空字符串作为值设置。Maven会调整pom中指定的值，因此不可能通过这种机制指定需要以空间开始或结束的系统属性:考虑使用jvmArguments。

任何字符串类型的Maven变量都可以作为系统属性传递。任何传递其他Maven变量类型(例如List或URL变量)的尝试都会导致变量表达式按字面意思传递(未计算)。

jvmArguments参数优先于使用上述机制定义的系统属性。在下面的示例中，property1的值被覆盖:

$ mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Dproperty1=overridden"

使用环境变量

可以使用environmentVariables属性指定环境变量。下面的示例设置了“ENV1”、“ENV2”、“ENV3”、“ENV4”环境变量:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <environmentVariables>
                        <ENV1>5000</ENV1>
                        <ENV2>Some Text</ENV2>
                        <ENV3/>
                        <ENV4></ENV4>
                    </environmentVariables>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

如果值为空或未定义(即<MY_ENV/>)，则使用空字符串设置env变量的值。Maven会对pom中指定的值进行调整，因此不可能指定需要以空格开始或结束的env变量。

任何字符串类型的Maven变量都可以作为系统属性传递。任何传递其他Maven变量类型(例如List或URL变量)的尝试都会导致变量表达式按字面意思传递(未计算)。

以这种方式定义的环境变量优先于现有值。

使用Application参数

可以使用arguments属性指定应用程序参数。下面的示例设置了两个参数:property1和property2=42:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <arguments>
                        <argument>property1</argument>
                        <argument>property2=${my.value}</argument>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

在命令行上，参数以空格分隔，与jvmArguments相同。如果参数包含空格，请确保引用它。在下面的示例中，有两个参数可用:property1和property2=Hello World:

$ mvn spring-boot:run -Dspring-boot.run.arguments="property1 'property2=Hello World'"

指定活动概要文件

可以使用profiles参数指定用于特定应用程序的活动概要文件。

以下配置启用了foo和bar配置文件:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <profiles>
                        <profile>foo</profile>
                        <profile>bar</profile>
                    </profiles>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

要启用的配置文件也可以在命令行上指定，确保用逗号分隔它们，如下面的例子所示:

$ mvn spring-boot:run -Dspring-boot.run.profiles=foo,bar

运行集成测试

虽然您可以非常容易地从测试(或测试套件)本身启动Spring引导应用程序，但在构建中处理它可能是可取的。为了确保围绕集成测试正确管理Spring Boot应用程序的生命周期，您可以使用start和stop目标，如下面的示例所示:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.3.4.RELEASE</version>
            <executions>
                <execution>
                    <id>pre-integration-test</id>
                    <goals>
                        <goal>start</goal>
                    </goals>
                </execution>
                <execution>
                    <id>post-integration-test</id>
                    <goals>
                        <goal>stop</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

这样的设置现在可以像预期的那样使用failsafe插件来运行集成测试。

默认情况下，应用程序在单独的进程中启动，并使用JMX与应用程序通信。如果需要配置JMX端口，请参阅专用示例。

spring-boot:start

org.springframework.boot:spring-boot-maven-plugin:2.3.4.RELEASE

必要参数

Name	Type	Default
classesDirectory	File	${project.build.outputDirectory}

可选参数

Name	Type	Default
addResources	boolean	false
agents	File[]
arguments	String[]
commandlineArguments	String
directories	String[]
environmentVariables	Map
excludeGroupIds	String
excludes	List
folders	String[]
fork	boolean	true
includes	List
jmxName	String
jmxPort	int
jvmArguments	String
mainClass	String
maxAttempts	int
noverify	boolean
profiles	String[]
skip	boolean	false
systemPropertyVariables	Map
useTestClasspath	Boolean	false
wait	long
workingDirectory	File

详细参数

addResources

直接将maven资源添加到类路径中，这允许对资源进行实时的就地编辑。从target/classes中删除重复的资源，以防止在调用ClassLoader.getResources()时它们出现两次。请考虑在您的项目中添加spring-boot-devtools，因为它提供了这个特性和更多特性。

Name	addResources
Type	boolean
Default value	false
User property	spring-boot.run.addResources
Since	1.0.0

agents

到代理jar的路径。注意:使用此特性需要一个分支过程。

Name	agents
Type	java.io.File[]
Default value
User property	spring-boot.run.agents
Since	2.2.0

arguments

应该传递给应用程序的参数。

Name	arguments
Type	java.lang.String[]
Default value
User property
Since	1.0.0

classesDirectory

目录，其中包含应该打包到存档中的类和资源文件。

Name	classesDirectory
Type	java.io.File
Default value	${project.build.outputDirectory}
User property
Since	1.0.0

commandlineArguments

应该传递给应用程序的命令行参数。使用空格分隔多个参数，并确保在引号之间包装多个值。在指定时，优先于#arguments。

Name	commandlineArguments
Type	java.lang.String
Default value
User property	spring-boot.run.arguments
Since	2.2.3

directories

应该添加到类路径的类目录之外的其他目录。

Name	directories
Type	java.lang.String[]
Default value
User property	spring-boot.run.directories
Since	1.0.0

environmentVariables

应与用于运行应用程序的派生进程关联的环境变量的列表。注意:使用此特性需要一个分支过程。

Name	environmentVariables
Type	java.util.Map
Default value
User property
Since	2.1.0

excludeGroupIds

要排除的用逗号分隔的groupId名称列表(精确匹配)。

Name	excludeGroupIds
Type	java.lang.String
Default value
User property	spring-boot.excludeGroupIds
Since	1.1.0

excludes

要排除的工件定义的集合。Exclude元素定义了groupId和artifactId强制属性以及一个可选的分类器属性。

Name	excludes
Type	java.util.List
Default value
User property	spring-boot.excludes
Since	1.1.0

folders

应该添加到类路径的类目录之外的其他目录。

Name	folders
Type	java.lang.String[]
Default value
User property	spring-boot.run.folders
Since	1.0.0

fork

标志，指示是否应该派生运行进程。禁用fork将禁用一些特性，如代理、自定义JVM参数、devtools或指定要使用的工作目录。

Name	fork
Type	boolean
Default value	true
User property	spring-boot.run.fork
Since	1.2.0

includes

要包含的工件定义的集合。Include元素定义了groupId和artifactId强制属性以及一个可选的分类器属性。

Name	includes
Type	java.util.List
Default value
User property	spring-boot.includes
Since	1.2.0

jmxName

自动部署的管理spring应用程序生命周期的MBean的JMX名称。

Name	jmxName
Type	java.lang.String
Default value
User property
Since

jmxPort

如果应用程序是派生的，则用于公开平台MBeanServer的端口。

Name	jmxPort
Type	int
Default value
User property
Since

jvmArguments

应该与用于运行应用程序的派生进程相关联的JVM参数。在命令行上，确保在引号之间包装多个值。注意:使用此特性需要一个分支过程。

Name	jvmArguments
Type	java.lang.String
Default value
User property	spring-boot.run.jvmArguments
Since	1.1.0

mainClass

主类的名称。如果没有指定，将使用第一个发现的包含“main”方法的编译类。

Name	mainClass
Type	java.lang.String
Default value
User property	spring-boot.run.main-class
Since	1.0.0

maxAttempts

检查spring应用程序是否准备就绪的最大尝试次数。结合“wait”参数，这会给出一个全局超时值(默认为30秒)

Name	maxAttempts
Type	int
Default value
User property
Since

noverify

表示代理需要-noverify。

Name	noverify
Type	boolean
Default value
User property	spring-boot.run.noverify
Since	1.0.0

profiles

要激活的spring配置文件。指定spring.profiles的快捷方式。积极的观点。在命令行中，使用逗号分隔多个概要文件。

Name	profiles
Type	java.lang.String[]
Default value
User property	spring-boot.run.profiles
Since	1.3.0

skip

路过执行。

Name	skip
Type	boolean
Default value	false
User property	spring-boot.run.skip
Since	1.3.2

systemPropertyVariables

要传递给进程的JVM系统属性列表。注意:使用此特性需要一个分支过程。

Name	systemPropertyVariables
Type	java.util.Map
Default value
User property
Since	2.1.0

useTestClasspath

标记以在运行时包含测试类路径。

Name	useTestClasspath
Type	java.lang.Boolean
Default value	false
User property	spring-boot.run.useTestClasspath
Since	1.3.0

wait

每次尝试检查spring应用程序是否准备就绪之间等待的毫秒数。

Name	wait
Type	long
Default value
User property
Since

workingDirectory

用于应用程序的当前工作目录。如果没有指定，将使用basedir。注意:使用此特性需要一个分支过程。

Name	workingDirectory
Type	java.io.File
Default value
User property	spring-boot.run.workingDirectory
Since	1.5.0

spring-boot:stop

org.springframework.boot:spring-boot-maven-plugin:2.3.4.RELEASE

停止由“start”目标启动的应用程序。通常在测试套件完成后调用。

可选参数

Name	Type	Default
fork	Boolean
jmxName	String
jmxPort	int
skip	boolean	false

详细参数

fork

指示要停止的进程是否已分叉的标志。默认情况下，该值是从MavenProject继承的。如果设置了这个值，它必须与StartMojo启动进程时使用的值匹配。

Name	fork
Type	java.lang.Boolean
Default value
User property	spring-boot.stop.fork
Since	1.3.0

jmxName

自动部署的管理应用程序生命周期的MBean的JMX名称。

Name	jmxName
Type	java.lang.String
Default value
User property
Since

jmxPort

如果应用程序已经派生，则用于查找平台MBeanServer的端口。

Name	jmxPort
Type	int
Default value
User property
Since

skip

跳过执行

Name	skip
Type	boolean
Default value	false
User property	spring-boot.stop.skip
Since	1.3.2

Exampless

用于集成测试的随机端口

Spring引导测试集成的一个很好的特性是，它可以为web应用程序分配一个自由端口。当使用插件的启动目标时，Spring引导应用程序将单独启动，这使得将实际的端口传递到集成测试本身变得困难。

下面的例子展示了如何使用Build Helper Maven插件实现相同的功能:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>build-helper-maven-plugin</artifactId>
                <version>1.2.3</version>
                <executions>
                    <execution>
                        <id>reserve-tomcat-port</id>
                        <goals>
                            <goal>reserve-network-port</goal>
                        </goals>
                        <phase>process-resources</phase>
                        <configuration>
                            <portNames>
                                <portName>tomcat.http.port</portName>
                            </portNames>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <executions>
                    <execution>
                        <id>pre-integration-test</id>
                        <goals>
                            <goal>start</goal>
                        </goals>
                        <configuration>
                            <arguments>
                                <argument>--server.port=${tomcat.http.port}</argument>
                            </arguments>
                        </configuration>
                    </execution>
                    <execution>
                        <id>post-integration-test</id>
                        <goals>
                            <goal>stop</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>1.2.3</version>
                <configuration>
                    <systemPropertyVariables>
                        <test.server.port>${tomcat.http.port}</test.server.port>
                    </systemPropertyVariables>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

现在可以检索test.server.port在任何集成测试中端口system属性，以创建到服务器的正确URL。

自定义JMX端口

jmxPort属性允许定制插件用于与Spring引导应用程序通信的端口。

这个示例展示了如何在案例9001已经使用的情况下定制端口:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                   <configuration>
                       <jmxPort>9009</jmxPort>
                   </configuration>
                <executions>
                    <execution>
                        <id>pre-integration-test</id>
                        <goals>
                            <goal>start</goal>
                        </goals>
                        <configuration>
                            <skip>${skip.it}</skip>
                        </configuration>
                    </execution>
                    <execution>
                        <id>post-integration-test</id>
                        <goals>
                            <goal>stop</goal>
                        </goals>
                        <configuration>
                            <skip>${skip.it}</skip>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Note

如果需要配置JMX端口，请确保如上所示在全局配置中进行配置，以便两个目标共享该端口。

跳过集成测试

skip属性允许完全跳过Spring Boot maven插件的执行。

这个例子展示了如何跳过命令行属性的集成测试，同时确保重新打包的目标运行:

<project>
    <properties>
        <skip.it>false</skip.it>
    </properties>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <executions>
                    <execution>
                        <id>pre-integration-test</id>
                        <goals>
                            <goal>start</goal>
                        </goals>
                        <configuration>
                            <skip>${skip.it}</skip>
                        </configuration>
                    </execution>
                    <execution>
                        <id>post-integration-test</id>
                        <goals>
                            <goal>stop</goal>
                        </goals>
                        <configuration>
                            <skip>${skip.it}</skip>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-failsafe-plugin</artifactId>
                <version>1.2.3</version>
                <configuration>
                    <skip>${skip.it}</skip>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

默认情况下，集成测试将运行，但此设置允许您轻松禁用它们的命令行如下:

$ mvn verify -Dskip.it=true

集成Actuator

如果有META-INF/build-info.properties文件, Spring引导执行器将显示与构建相关的信息。build-info目标使用项目坐标和构建时间生成这样的文件。它还允许您添加任意数量的附加属性，如下面的例子所示:

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>build-info</goal>
                        </goals>
                        <configuration>
                            <additionalProperties>
                                <encoding.source>UTF-8</encoding.source>
                                <encoding.reporting>UTF-8</encoding.reporting>
                                <java.source>${maven.compiler.source}</java.source>
                                <java.target>${maven.compiler.target}</java.target>
                            </additionalProperties>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

这个配置将生成一个build-info.properties的属性,带有四个附加键的预期位置上。请注意，maven.compiler.source和maven.compiler.target预计是项目中可用的常规属性。它们会像你期望的那样被插入。

spring-boot:build-info

org.springframework.boot:spring-boot-maven-plugin:2.3.4.RELEASE

基于当前MavenPorject内容生成一个build-info.properties文件。

可选参数

Name	Type	Default
additionalProperties	Map
outputFile	File	${project.build.outputDirectory}/META-INF/build-info.properties
time	String

详细参数

additionalProperties

要存储在build-info.properties中的其他属性。每个条目都以build作为前缀。在生成的build-info.properties中。

Name	additionalProperties
Type	java.util.Map
Default value
User property
Since

outputFile

生成的build-info.properties的位置。

Name	outputFile
Type	java.io.File
Default value	${project.build.outputDirectory}/META-INF/build-info.properties
User property
Since

time

用于构建的值build.time属性的格式适合于Instant#parse(CharSequence)。默认为session.request.startTime。禁用build.time属性完全使用“off”。

Name	time
Type	java.lang.String
Default value
User property
Since	2.2.0

帮助信息

help目标是一个标准目标，它显示了关于插件功能的信息。

spring-boot:help

org.springframework.boot:spring-boot-maven-plugin:2.3.4.RELEASE

显示有关spring-boot-maven-plugin的帮助信息。调用mvn spring-boot:help -Ddetail=true -Dgoal=<goal-name>显示参数细节。

可选参数

Name	Type	Default
detail	boolean	false
goal	String
indentSize	int	2
lineLength	int	80

详细参数

detail

如果为真，则显示每个目标的所有可设置属性。

Name	detail
Type	boolean
Default value	false
User property	detail
Since

goal

帮助目标的名称。如果未指定，则显示所有目标。

Name	goal
Type	java.lang.String
Default value
User property	goal
Since

indentSize

每个缩进层的空格数应该是正的。

Name	indentSize
Type	int
Default value	2
User property	indentSize
Since

lineLength

显示线的最大长度，应该是正的。

Name	lineLength
Type	int
Default value	80
User property	lineLength
Since