Quarkus and Maven

Creating a new project

你可以使用以下命令脚手架一个新的 Maven 项目：

CLI
quarkus create app {create-app-group-id}:{create-app-artifact-id} \
    --no-code
cd {create-app-artifact-id}

要创建一个 Gradle 项目，添加 --gradle 或 --gradle-kotlin-dsl 选项。 有关如何安装和使用 Quarkus CLI 的详细信息，请参见 Quarkus CLI 指南。

Maven
mvn {quarkus-platform-groupid}:quarkus-maven-plugin:{quarkus-version}:create \
    -DprojectGroupId={create-app-group-id} \
    -DprojectArtifactId={create-app-artifact-id} \
    -DnoCode
cd {create-app-artifact-id}

要创建一个 Gradle 项目，添加 -DbuildTool=gradle 或 -DbuildTool=gradle-kotlin-dsl 选项。

适用于 Windows 用户：

  • 如果使用 cmd，（不要使用反斜杠 \ ，并将所有内容放在同一行上）

  • 如果使用 Powershell，将 -D 参数用双引号引起来，例如 "-DprojectArtifactId={create-app-artifact-id}"

如果你正在使用 CLI，你可以使用以下命令获取可用选项列表：

quarkus create app --help

如果你正在使用 Maven 命令，下表列出了你可以传递给 create 命令的属性：

Attribute Default Value Description

projectGroupId

org.acme.sample

所创建项目的组 ID

projectArtifactId

mandatory

所创建项目的项目 ID。如果不传递，则会触发交互式模式。

projectVersion

1.0.0-SNAPSHOT

所创建项目的版本

platformGroupId

io.quarkus.platform

目标平台的组 ID。

platformArtifactId

quarkus-bom

目标平台 BOM 的制品 ID。

platformVersion

Quarkus Extension Registry 当前推荐的版本

该项目要使用的平台版本。它也可以接受一个版本范围，在这种情况下将使用指定范围内的最新版本。

javaVersion

17

该项目要使用的 Java 版本。

className

Not created if omitted

生成资源的完全限定名称

path

/hello

资源路径，仅在设置 className 时才相关。

extensions

[]

要添加到项目中的扩展列表（逗号分隔）

quarkusRegistryClient

true

Quarkus 是否应使用在线注册表来解析扩展目录。如果将其设置为 false，则扩展目录将缩小到已定义（或默认）平台 BOM。

默认情况下，该命令将以 io.quarkus.platform:quarkus-bom:${project.version} 平台版本为对象（除非指定所需平台版本的坐标）。

该项目在一个以所传递 artifactId 命名为目录中生成。如果该目录已经存在，则生成将失败。

还会在 src/main/docker 中生成一对适用于原生模式和 jvm 模式的 Dockerfile。在这些 Dockerfile 中编写有构建映像和运行容器的说明。

Dealing with extensions

在 Quarkus 项目内部，你可以使用以下命令获取可用扩展的列表：

CLI
quarkus extension
Maven
./mvnw quarkus:list-extensions
Gradle
./gradlew listExtensions

你可以使用以下命令添加一个扩展：

CLI
quarkus extension add {add-extension-extensions}
Maven
./mvnw quarkus:add-extension -Dextensions='{add-extension-extensions}'
Gradle
./gradlew addExtension --extensions='{add-extension-extensions}'

扩展使用逗号分隔的列表传递。

扩展名是扩展的 GAV 名称：例如，io.quarkus:quarkus-agroal。但是，你可以传递一个部分名称，Quarkus 将尽力寻找正确的扩展。例如，agroal、Agroal`或 `agro 将扩展为 io.quarkus:quarkus-agroal。如果没有找到扩展或有多个扩展匹配，你将会在命令结果中看到一个红色的对号标记 ❌。

$ ./mvnw quarkus:add-extensions -Dextensions=jdbc,agroal,non-exist-ent
[...]
❌ Multiple extensions matching 'jdbc'
     * io.quarkus:quarkus-jdbc-h2
     * io.quarkus:quarkus-jdbc-mariadb
     * io.quarkus:quarkus-jdbc-postgresql
     Be more specific e.g using the exact name or the full gav.
✅ Adding extension io.quarkus:quarkus-agroal
❌ Cannot find a dependency matching 'non-exist-ent', maybe a typo?
[...]

你可以安装与全局模式匹配的所有扩展：

CLI
quarkus extension add {add-extension-extensions}
Maven
./mvnw quarkus:add-extension -Dextensions='{add-extension-extensions}'
Gradle
./gradlew addExtension --extensions='{add-extension-extensions}'

Configuring javac options

Quarkus Maven 插件使用 javac，并且默认情况下它会选择编译器标志从 maven-compiler-plugin 传递到 javac。

如果您需要自定义插件使用的编译器标志（如 development mode）中），请将 configuration 部分添加到 plugin 块中，并设置 compilerArgs 属性，就像在配置 maven-compiler-plugin 时一样。您还可以设置 source、target 和 jvmArgs。例如，要将 --enable-preview 传递给 JVM 和 javac：

<plugin>
  <groupId>${quarkus.platform.group-id}</groupId>
  <artifactId>quarkus-maven-plugin</artifactId>
  <version>${quarkus.platform.version}</version>

  <configuration>
    <source>${maven.compiler.source}</source>
    <target>${maven.compiler.target}</target>
    <compilerArgs>
      <arg>--enable-preview</arg>
    </compilerArgs>
    <jvmArgs>--enable-preview</jvmArgs>
  </configuration>

  ...
</plugin>

因为 Quarkus Maven 插件本身在 Maven 启动的 JVM 中运行，并且因为一些（罕见）Quarkus 扩展需要在构建过程中加载应用程序类，所以可能需要将相同的标志传递给运行 Maven 的 JVM。 为此，您可以使用 MAVEN_OPTS： :iokays-category: quarkus :iokays-path: modules/ROOT/pages/_includes/devtools/maven-opts.adoc :keywords: Quarkus, 中文文档, 编程技术

CLI
MAVEN_OPTS='--enable-preview' quarkus build
Maven
MAVEN_OPTS='--enable-preview' ./mvnw install

Alternatively，你可以简单地在项目根目录中创建文件 .mvn/jvm.config：Maven 将选择在该文件中放入的任何选项，而无需设置 MAVEN_OPTS。

Development mode

Quarkus 具有内置开发模式。使用以下命令运行应用程序：

CLI
quarkus dev
Maven
./mvnw quarkus:dev
Gradle
./gradlew --console=plain quarkusDev

然后，你可以更新应用程序源、资源和配置。这些更改将自动反映在正在运行的应用程序中。这非常适合进行跨 UI 和数据库的开发，因为你可以立即看到反映的更改。

开发模式通过后台编译启用了热部署，这意味着当修改 Java 文件或资源文件并刷新浏览器时，这些更改将自动生效。这也适用于资源文件，如配置属性文件。刷新浏览器的行为将触发对工作区的扫描，如果检测到任何更改，将编译 Java 文件并重新部署应用程序，然后重新部署的应用程序会处理你的请求。如果编译或部署有任何问题，错误页面将通知你。

按 CTRL+C 停止应用程序。

默认情况下，quarkus:dev 将调试主机设置为 localhost（出于安全原因）。如果你需要更改此设置，例如启用所有主机的调试，则可以使用 -DdebugHost 选项，如下所示： include::./_includes/devtools/dev-parameters.adoc[]:!dev-additional-parameters:

Remote Development Mode

可以使用远程开发模式，以便在容器环境（如 OpenShift）中运行 Quarkus，并使对本地文件进行的更改立即可见。

这使你能够在实际运行应用程序的相同环境中进行开发，并且有权访问相同服务。

请勿在生产中使用此功能。此功能只能在开发环境中使用。你不应该在开发模式下运行生产应用程序。

为此，你必须使用 mutable-jar 格式构建一个可变应用程序。在 application.properties 中设置以下属性：

quarkus.package.jar.type=mutable-jar 1
quarkus.live-reload.password=changeit 2
quarkus.live-reload.url=http://my.cluster.host.com:8080 3
1 这会指示 Quarkus 使用可变 jar 格式。可变应用程序还包括 Quarkus 的部署时部分，因此它们会占用更多磁盘空间。如果正常运行，它们启动得和不可变应用程序一样快，并且使用相同的内存，但是它们也可以在开发模式下启动。
2 用于保护远程端和本地端之间的通信的密码。
3 你的 app 在开发模式下运行的 URL。这仅在本地端需要，因此你可能想要将其从 properties 文件中排除，并将其指定为命令行上的系统属性。

然后，以构建正常 Quarkus jar 的相同方式构建 mutable-jar，即通过发布：

CLI
quarkus build
Maven
./mvnw install
Gradle
./gradlew build

在你启动远程主机上的 Quarkus 之前，设置环境变量 QUARKUS_LAUNCH_DEVMODE=true。如果你在裸机上，你可以通过 export QUARKUS_LAUNCH_DEVMODE=true 命令进行设置，然后使用正确的 java -jar …​ 命令运行应用程序来运行应用程序。

如果你计划通过 Docker 运行应用程序，那么你需要向 docker run 命令中添加 -e QUARKUS_LAUNCH_DEVMODE=true。当应用程序启动时，你现在应该在日志中看到以下行：Profile dev activated. Live Coding activated。你还需要通过在 Dockerfile 中向 COPY 命令后面添加 RUN chmod o+rw -R /deployments 来向应用程序授予更新部署资源的权限。出于安全原因，不应将此选项添加到生产 Dockerfile 中。

远程端无需包含 Maven 或任何其他开发工具。使用新 Quarkus 应用程序生成的法规 fast-jar Dockerfile 是你唯一需要的。如果你正在使用裸机启动 Quarkus runner jar，请不要尝试运行正常开发模式。

现在你需要使用 remote-dev 命令将本地代理连接到远程主机：

./mvnw quarkus:remote-dev -Dquarkus.live-reload.url=http://my-remote-host:8080

现在，每次刷新浏览器时，你都应该看到你在本地进行的任何更改都会立即在远程应用程序中显示。这是通过基于 HTTP 的长时间轮询传输完成的，它将通过 HTTP 调用同步本地工作空间和远程应用程序。

如果你不想使用 HTTP 功能，那么你可以简单运行 remote-dev 命令而不指定 URL。在此模式下，命令将持续重建本地应用程序，因此你可以使用外部工具（例如 odo 或 rsync）同步到远程应用程序。

所有配置选项如下所示：

Unresolved include directive in modules/ROOT/pages/maven-tooling.adoc - include::../../../target/quarkus-generated-doc/config/quarkus-core_quarkus.live-reload.adoc[]

建议你在使用远程开发模式时使用 SSL，但即使你使用未加密连接，你的密码也不会直接通过网络发送。对于初始连接请求，密码会使用初始状态数据进行哈希处理，并且后续请求会使用服务器生成的随机会话 ID 和 POST 请求的任何正文内容、DELETE 请求的路径以及递增的计数器对它进行哈希处理，以防止重放攻击。

Debugging

在开发模式下，Quarkus 默认以启用调试模式启动，侦听端口 5005，且不会挂起 JVM。

可以通过向 debug 系统属性赋予以下值之一来改变此行为：

  • false- JVM 将在禁用调试模式的情况下启动

  • true- JVM 在调试模式下启动，并将监听端口 5005

  • client- JVM 将以客户端模式启动并尝试连接到 localhost:5005

  • {port}- JVM 在调试模式下启动，并将监听 {port}

一个附加的系统属性 suspend 可用来在调试模式下启动时挂起 JVM。suspend 支持以下值：

  • y 或 true- 调试模式 JVM 启动已挂起

  • n 或 false - 调试模式 JVM 在不挂起的情况下启动

你还可以使用以下命令用一个挂起的 JVM 在调试模式下运行 Quarkus 应用程序： include::./_includes/devtools/dev-parameters.adoc[]:!dev-additional-parameters: 然后，将你的调试器附加到 localhost:5005。

Import in your IDE

一旦您拥有一个 project generated，您便可以将其导入到您喜爱的 IDE 中。唯一的要求是可以导入 Maven 项目。

Eclipse

在 Eclipse 中，单击：File → Import。在向导中，选择：Maven → Existing Maven Project。在下一个屏幕中，选择项目的根位置。下一个屏幕列出了找到的模块；选择生成的项目并单击 Finish。完成！

在单独的终端中，运行：

CLI
quarkus dev
Maven
./mvnw quarkus:dev
Gradle
./gradlew --console=plain quarkusDev

并尽享高产出环境。

IntelliJ IDEA

在 IntelliJ IDEA 中：

  1. 在 IntelliJ IDEA 中选择 File &#8594; New &#8594; Project From Existing Sources&#8230;&#8203; 或在欢迎对话框中选择 Import project。

  2. Select the project root

  3. 选择 Import project from external model 和 Maven

  4. 接下来点击几次（必要时检查不同的选项）

  5. 在最后一个屏幕中，单击“完成”

在单独的终端中或在嵌入式终端中，运行：

CLI
quarkus dev
Maven
./mvnw quarkus:dev
Gradle
./gradlew --console=plain quarkusDev

享受！

Apache NetBeans

在 NetBeans 中：

  1. 选择 File &#8594; Open Project

  2. Select the project root

  3. Click on Open Project

在单独的终端或嵌入式终端中，转到项目根目录并运行：

CLI
quarkus dev
Maven
./mvnw quarkus:dev
Gradle
./gradlew --console=plain quarkusDev

享受！

Visual Studio Code

在 VS 代码中打开项目目录。如果您已安装 Java 扩展包（将一组 Java 扩展组合在一起），则此项目将加载为 Maven 项目。

Logging Quarkus application build classpath tree

通常，可以使用 mvn dependency:tree 命令显示应用程序（是 Maven 项目）的依赖项。但是，对于 Quarkus 应用程序，此命令将仅列出应用程序的运行时依赖项。由于 Quarkus 构建过程会将应用程序中使用扩展的部署依赖项添加到原始应用程序类路径中，因此了解哪些依赖项以及哪些版本最终出现在构建类路径上会很有用。幸运的是，quarkus Maven 插件包含 dependency-tree 目标，该目标显示应用程序的构建依赖树。

对您的项目执行 `./mvnw quarkus:dependency-tree`应生成类似以下内容的输出：

[INFO] --- quarkus-maven-plugin:{quarkus-version}:dependency-tree (default-cli) @ getting-started ---
[INFO] org.acme:getting-started:jar:1.0.0-SNAPSHOT
[INFO] └─ io.quarkus:quarkus-resteasy-deployment:jar:{quarkus-version} (compile)
[INFO]    ├─ io.quarkus:quarkus-resteasy-server-common-deployment:jar:{quarkus-version} (compile)
[INFO]    │  ├─ io.quarkus:quarkus-core-deployment:jar:{quarkus-version} (compile)
[INFO]    │  │  ├─ commons-beanutils:commons-beanutils:jar:1.9.3 (compile)
[INFO]    │  │  │  ├─ commons-logging:commons-logging:jar:1.2 (compile)
[INFO]    │  │  │  └─ commons-collections:commons-collections:jar:3.2.2 (compile)
...

该目标接受以下可选参数：

  • mode - 默认值是 prod，即生产构建依赖项树。此外，它还接受值 test 以显示测试依赖树并接受值 dev 以显示开发模式依赖树；

  • outputFile - 指定用于持久保存依赖项树的文件；

  • appendOutput - 默认值是 false，表示命令的输出应追加到使用 outputFile 参数指定的文件中，或应覆盖该文件。

Downloading Maven artifact dependencies for offline development and testing

Quarkus 扩展依赖项分为最终出现在应用程序运行时类路径中的运行时扩展依赖项和部署（或构建时）扩展依赖项，而 Quarkus 仅在应用程序构建时解析后者以创建构建类路径。应用程序开发人员预计只会对 Quarkus 扩展的运行时制品表达依赖项。因此，部署扩展依赖项对于不了解 Quarkus 扩展依赖模型的 Maven 插件（例如 maven-dependency-plugin、`go-offline-maven-plugin`等）是不可见的。这意味着这些插件不能用于预下载所有应用程序依赖项，以便稍后在脱机模式下构建和测试应用程序。

为了启用在脱机状态下构建和测试 Quarkus 应用程序的用例，`quarkus-maven-plugin`包含 `go-offline`目标，可以如此从命令行调用：

./mvnw quarkus:go-offline

此目标将解析应用程序的所有运行时、构建时、测试和开发模式依赖项，并将它们下载到配置的本地 Maven 仓库。

Building a native executable

本机可执行文件使 Quarkus 应用程序非常适合容器和无服务器工作负载。

确保已配置 `GRAALVM_HOME`并将其指向 GraalVM ${graal-community.version-for-documentation} 的最新版本。验证您的 `pom.xml`具有适当的 `native`配置，如 Maven configuration 中所示。

使用以下命令创建本机可执行文件：

CLI
quarkus build --native
Maven
./mvnw install -Dnative
Gradle
./gradlew build -Dquarkus.native.enabled=true

本机可执行文件将显示在 target/ 中。

要在本机可执行文件上运行集成测试，请确保具有适当的 Maven plugin configured并启动 verify 目标。

$ ./mvnw verify -Dnative
...
[quarkus-quickstart-runner:50955]     universe:     391.96 ms
[quarkus-quickstart-runner:50955]      (parse):     904.37 ms
[quarkus-quickstart-runner:50955]     (inline):   1,143.32 ms
[quarkus-quickstart-runner:50955]    (compile):   6,228.44 ms
[quarkus-quickstart-runner:50955]      compile:   9,130.58 ms
[quarkus-quickstart-runner:50955]        image:   2,101.42 ms
[quarkus-quickstart-runner:50955]        write:     803.18 ms
[quarkus-quickstart-runner:50955]      [total]:  33,520.15 ms
[INFO]
[INFO] --- maven-failsafe-plugin:2.22.0:integration-test (default) @ quarkus-quickstart-native ---
[INFO]
[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running org.acme.quickstart.GreetingResourceIT
Executing [/Users/starksm/Dev/JBoss/Quarkus/starksm64-quarkus-quickstarts/getting-started-native/target/quarkus-quickstart-runner, -Dquarkus.http.port=8081, -Dtest.url=http://localhost:8081, -Dquarkus.log.file.path=target/quarkus.log]
2019-02-28 16:52:42,020 INFO  [io.quarkus] (main) Quarkus started in 0.007s. Listening on: http://localhost:8080
2019-02-28 16:52:42,021 INFO  [io.quarkus] (main) Installed features: [cdi, rest]
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.081 s - in org.acme.quickstart.GreetingResourceIT
[INFO]
[INFO] Results:
[INFO]
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0

...

Build a container friendly executable

本机可执行文件将特定于您的操作系统。要创建一个将在容器中运行的可执行文件，请使用以下内容：

include::./_includes/devtools/build-native.adoc[]:!build-additional-parameters:

生成的执行文件将是 64 位的 Linux 执行文件，因此，根据您的操作系统，它可能不再具有可运行性。然而，这不是问题，因为我们准备将它复制到 Docker 容器。请注意，在这种情况下构建本身也在 Docker 容器中运行，因此您无需在本地安装 GraalVM。

默认情况下，将使用 quay.io/quarkus/ubi-quarkus-mandrel-builder-image:${mandrel.image-tag-for-documentation} Docker 映像生成原生可执行文件。 如果您要使用不同的 Docker 映像（例如使用不同的 GraalVM 版本）构建原生可执行文件，请使用 -Dquarkus.native.builder-image=<image name> 构建参数。 可在此处找到可用 Docker 镜像列表： quay.io。请注意，给定的 Quarkus 版本可能与所有可用的镜像不兼容。

您还可以关注 Build a native executable guide 和 Deploying Application to Kubernetes and OpenShift 了解详细信息。

Maven configuration

如果您尚未使用 project scaffolding，请在您的 pom.xml 中添加以下元素

<properties>
    <skipITs>true</skipITs> 1
</properties>

<dependencyManagement>
    <dependencies>
        <dependency> 2
            <groupId>${quarkus.platform.group-id}</groupId>
            <artifactId>quarkus-bom</artifactId>
            <version>${quarkus.platform.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<build>
    <plugins>
        <plugin> 3
            <groupId>${quarkus.platform.group-id}</groupId>
            <artifactId>quarkus-maven-plugin</artifactId>
            <version>${quarkus.platform.version}</version>
            <extensions>true</extensions> 4
            <executions>
                <execution>
                    <goals>
                        <goal>build</goal>
                        <goal>generate-code</goal>
                        <goal>generate-code-tests</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <plugin> 5
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>${surefire-plugin.version}</version>
            <configuration>
                <systemPropertyVariables>
                    <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
                    <maven.home>${maven.home}</maven.home>
                </systemPropertyVariables>
            </configuration>
        </plugin>
        <plugin> 6
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            <version>${surefire-plugin.version}</version>
            <executions>
                <execution>
                    <goals>
                        <goal>integration-test</goal>
                        <goal>verify</goal>
                    </goals>
                    <configuration>
                        <systemPropertyVariables>
                            <native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
                            <java.util.logging.manager>org.jboss.logmanager.LogManager</java.util.logging.manager>
                            <maven.home>${maven.home}</maven.home>
                        </systemPropertyVariables>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

<profiles>
    <profile> 7
        <id>native</id>
        <properties> 8
            <quarkus.native.enabled>true</quarkus.native.enabled>
            <skipITs>false</skipITs> 9
        </properties>
    </profile>
</profiles>
1 禁止在所有构建上运行集成测试（测试名称 *IT 并标注为 @QuarkusIntegrationTest）。要始终运行这些测试，请删除此属性、将其值设置为 false，或在运行构建时在命令行上设置 -DskipITs=false。如下所述，这将在 native 配置文件中被覆盖。
2 可以根据需要使用 BOM 文件来省略不同 Quarkus 依赖项的版本。
3 使用将会挂接到构建过程的 Quarkus Maven 插件。
4 启用 Maven 插件扩展将注册一个 Quarkus MavenLifecycleParticipant，它将确保在构建期间使用的 Quarkus 类加载器得到正确关闭。在 generate-code 和 generate-code-tests 目标期间，Quarkus 应用程序引导将被初始化，并在 build 目标中被重新使用（它实际上会构建并打包一个生产应用程序）。Quarkus 类加载器将在 quarkus-maven-plugin 的 build 目标中被正确关闭。然而，如果构建在 generate-code 或 generate-code-tests 和 build 之间失败，那么 Quarkus 增强类加载器将不会被正确关闭，这可能会导致锁定恰好在 Windows 操作系统上类路径中的 JAR 文件。
5 向 maven-surefire-plugin 添加系统属性。如果您在 ${maven.home}/conf/settings.xml 中有自定义配置，则 maven.home 是必需的。
6 如果您想使用集成测试来测试您的构建所生成的制品，请添加以下插件配置。测试名称 *IT 并标注为 @QuarkusIntegrationTest 将针对构建所生成的制品（JAR 文件、容器镜像等）运行。请参阅 Integration Testing guide 了解更多信息。如果您在 ${maven.home}/conf/settings.xml 中有自定义配置，则 maven.home 是必需的。
7 使用特定的 native 配置文件进行原生可执行文件构建。
8 启用 native 包类型。因此，构建将生成一个原生可执行文件。
9 在构建原生镜像时始终运行集成测试（测试名称 *IT 并标注为 @QuarkusIntegrationTest）。如果您不希望在构建原生镜像时运行集成测试，只需完全删除此属性或将其值设置为 true。

Using fast-jar

fast-jar 是默认的 quarkus 包类型。

构建的结果是 target 下名为 quarkus-app 的目录。

你可以使用以下方式运行应用程序：java -jar target/quarkus-app/quarkus-run.jar

若要成功运行生成的 jar，你需要 quarkus-app 目录的全部内容。如果缺少任何文件，应用程序将无法启动或可能无法正确运行。

fast-jar 打包通过创建工件以比旧 Quarkus jar 更快地启动并消耗更少的内存，因为它已对哪个依赖项 jar 包含类和资源编制索引。在加载类或资源时，它因此可以避免像传统 jar 在类路径中搜索每个 jar。

Uber-Jar Creation

Quarkus Maven 插件支持通过在 application.properties（或在 pom.xml 中的 <quarkus.package.jar.type>uber-jar</quarkus.package.jar.type>）中指定 quarkus.package.jar.type=uber-jar 配置选项来生成 Uber-Jars。

原始 jar 仍然存在于 target 目录中，但它将被重命名以包含 .original 后缀。

在构建 Uber-Jar 时，你可以通过使用 quarkus.package.ignored-entries 配置选项指定要从生成的 jar 中排除的条目，这将获取要忽略的一系列条目。

Uber-Jar 默认会排除应用程序依赖项中可能存在的 signature files。

Uber-Jar 的最终名称可以通过 Maven 构建设置 finalName 选项进行配置。

Uber-Jar file name suffix

默认情况下，所生成的 uber JAR 文件名将具有 -runner 后缀，除非通过使用 quarkus.package.runner-suffix 配置选项配置自定义名称来覆盖它。如果不需要后缀，可以通过将 quarkus.package.jar.add-runner-suffix 配置选项设置为 false 来禁用它，在这种情况下，uber JAR 将替换 maven-jar-plugin 为应用程序模块生成的原始 JAR 文件。

Attaching Uber-Jar file as the main project artifact

只要 Uber-Jar 文件名是通过将后缀（如 runner）追加到原始项目 JAR 文件名来创建的，Uber-Jar 文件名后缀也将用作 Uber-Jar 工件的 Maven 工件分类器。有两种方法可以将 Uber-Jar 作为主要项目工件附加（不带分类器）：

  1. 设置 quarkus.package.jar.add-runner-suffix=false，这将禁用添加文件名后缀，这样做会替换文件系统上的原始项目 JAR；

  2. 将 quarkus:build 目标的 attachRunnerAsMainArtifact 参数设置为 true。

Working with multi-module projects

默认情况下，Quarkus 不会在另一个模块内部发现 CDI Bean。

为多模块项目中的模块启用 CDI Bean 发现的最佳方法是包括 jandex-maven-plugin，除非它是已使用 quarkus-maven-plugin 配置的主应用程序模块，在这种情况下，它将自动编入索引。

<build>
  <plugins>
    <plugin>
      <groupId>io.smallrye</groupId>
      <artifactId>jandex-maven-plugin</artifactId>
      <version>{jandex-version}</version>
      <executions>
        <execution>
          <id>make-index</id>
          <goals>
            <goal>jandex</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

有关此主题的更多信息，请参见 CDI 指南的 Bean Discovery 部分。

Maven test plugin configuration

上面显示的 maven-surefire-plugin 和 maven-failsafe-plugin 配置在大多数情况下都会起作用。但是，可能需要额外的配置。

原因是，Quarkus 可能需要在测试阶段重新解析应用程序依赖项，以便为测试设置测试类路径。在测试过程中将无法使用以前构建阶段中使用的原始 Maven 解析器，因此，Quarkus 需要初始化一个新解析器。为了确保正确初始化新解析器，需要将相关配置选项传递给测试过程。

Maven user settings

可能需要将 Maven 用户设置文件的路径传递给测试过程，例如，在没有使用 Maven 发行版中包含的默认 mvn 脚本启动 Maven 构建过程的情况下。可以通过以下方式完成：

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>${surefire-plugin.version}</version>
            <configuration>
                <systemPropertyVariables>
                    <!-- skip -->
                    <maven.settings>${session.request.userSettingsFile.absolutePath}</maven.settings>
                </systemPropertyVariables>
            </configuration>
        </plugin>

Remote repository access through authenticated HTTPS

如果远程 Maven 存储库需要 authenticated HTTPS access configuration，则需要将以下所有或部分属性传递给测试插件：

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>${surefire-plugin.version}</version>
            <configuration>
                <systemPropertyVariables>
                    <!-- skip -->
                    <javax.net.ssl.keyStoreType>${javax.net.ssl.keyStoreType}</javax.net.ssl.keyStoreType>
                    <javax.net.ssl.keyStore>${javax.net.ssl.keyStore}</javax.net.ssl.keyStore>
                    <javax.net.ssl.keyStorePassword>${javax.net.ssl.keyStorePassword}</javax.net.ssl.keyStorePassword>
                    <javax.net.ssl.trustStore>${javax.net.ssl.trustStore}</javax.net.ssl.trustStore>
                    <javax.net.ssl.trustStorePassword>${javax.net.ssl.trustStorePassword}</javax.net.ssl.trustStorePassword>
                </systemPropertyVariables>
            </configuration>
        </plugin>

Building with a specific configuration profile

Quarkus 支持 configuration profiles 以便根据目标环境提供特定配置。

该配置文件可直接采用类型为 mvn:build-helper-plugin 的命令提供给 Maven 构建命令，借助系统属性 quarkus.profile：

include::./_includes/devtools/build.adoc[]:!build-additional-parameters:

不过，也可使用项目属性、Quarkus Maven 插件配置属性或在 Quarkus Maven 插件配置中设置的系统属性，在项目的 POM 文件中直接指定配置文件。

优先顺序如下（优先级越高则最先）：

1. System properties set in the Quarkus Maven plugin configuration
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  ...
  <build>
    <plugins>
      ...
      <plugin>
        <groupId>${quarkus.platform.group-id}</groupId>
        <artifactId>quarkus-maven-plugin</artifactId>
        <version>${quarkus.platform.version}</version>
        <extensions>true</extensions>
        <configuration>
          <systemProperties>
            <quarkus.profile>prod-aws</quarkus.profile> 1
          </systemProperties>
        </configuration>
     </plugin>
     ...
    </plugins>
  </build>
...
</project>
1 该项目的默认配置配置文件为 prod-aws。
2. Quarkus Maven plugin configuration properties
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  ...
  <build>
    <plugins>
      ...
      <plugin>
        <groupId>${quarkus.platform.group-id}</groupId>
        <artifactId>quarkus-maven-plugin</artifactId>
        <version>${quarkus.platform.version}</version>
        <extensions>true</extensions>
        <configuration>
          <properties>
            <quarkus.profile>prod-aws</quarkus.profile> 1
          </properties>
        </configuration>
     </plugin>
     ...
    </plugins>
  </build>
...
</project>
1 该项目的默认配置配置文件为 prod-aws。
3. Project properties
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  ...
  <properties>
    <quarkus.profile>prod-aws</quarkus.profile> 1
    ...
  </properties>
...
</project>
1 该项目的默认配置配置文件为 prod-aws。

无论选择哪种方法，都可以使用 quarkus.profile 系统属性或 QUARKUS_PROFILE 环境变量重写配置文件。

Building several artifacts from a single module

在一些特定使用案例中，从同一模块构建应用程序的多个工件会非常有用。一个典型的示例是，当你想使用不同的配置配置文件构建应用程序时。

在这种情况下，可以在 Quarkus Maven 插件配置中按需添加任意多个执行。

下面是一个 Quarkus Maven 插件配置示例，它会生成同一应用程序的两个构建：一个使用 prod-oracle 配置文件，另一个使用 prod-postgresql 配置文件。

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  ...
  <build>
    <plugins>
      ...
      <plugin>
        <groupId>${quarkus.platform.group-id}</groupId>
        <artifactId>quarkus-maven-plugin</artifactId>
        <version>${quarkus.platform.version}</version>
        <extensions>true</extensions>
        <executions>
          <execution>
            <id>oracle</id>
            <goals>
              <goal>build</goal>
            </goals>
            <configuration>
              <properties>
                <quarkus.profile>prod-oracle</quarkus.profile> 1
                <quarkus.package.output-directory>oracle-quarkus-app</quarkus.package.output-directory> 2
              </properties>
            </configuration>
          </execution>
          <execution>
            <id>postgresql</id>
            <goals>
              <goal>build</goal>
            </goals>
            <configuration>
              <properties>
                <quarkus.profile>prod-postgresql</quarkus.profile> 3
                <quarkus.package.output-directory>postgresql-quarkus-app</quarkus.package.output-directory> 4
              </properties>
            </configuration>
          </execution>
        </executions>
     </plugin>
     ...
    </plugins>
  </build>
...
</project>
1 该插件的第一个执行的默认配置配置文件为 prod-oracle。
2 将该插件的第一个执行的输出目录设置为 oracle-quarkus-app，而不是 quarkus-app，以便具有专用的目录。
3 该插件的第二个执行的默认配置配置文件为 prod-postgresql。
4 将该插件的第二个执行的输出目录设置为 postgresql-quarkus-app，而不是 quarkus-app，以便具有专用的目录。

使用上述配置，两个配置文件构建将使用相同的依赖关系，因此，如果我们向应用程序中添加了 Oracle 和 PostgreSQL 驱动程序的依赖关系，则这两个驱动程序都将出现在两个构建中。

为了从其他配置文件中隔离特定配置文件的依赖关系，JDBC 驱动程序可以作为可选依赖关系添加到应用程序中，但配置为包含在需要它们的每个配置文件中，例如：

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  ...
  <dependencies>
    ...
    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
      <version>${postgresql.driver.version}</version>
      <optional>true</optional> 1
    </dependency>
  </dependencies>
  <build>
    <plugins>
      ...
      <plugin>
        <groupId>${quarkus.platform.group-id}</groupId>
        <artifactId>quarkus-maven-plugin</artifactId>
        <version>${quarkus.platform.version}</version>
        <extensions>true</extensions>
        <executions>
          ...
          <execution>
            <id>postgresql</id>
            <goals>
              <goal>build</goal>
            </goals>
            <configuration>
              <properties>
                <quarkus.profile>prod-postgresql</quarkus.profile>
                <quarkus.package.output-directory>postgresql-quarkus-app</quarkus.package.output-directory>
                <quarkus.package.jar.filter-optional-dependencies>true</quarkus.package.jar.filter-optional-dependencies> 2
                <quarkus.package.jar.included-optional-dependencies>org.postgresql:postgresql::jar</quarkus.package.jar.included-optional-dependencies> 3
              </properties>
            </configuration>
          </execution>
        </executions>
     </plugin>
     ...
    </plugins>
  </build>
...
</project>
1 PostgreSQL 的 JDBC 驱动程序定义为可选依赖关系
2 出于向后兼容性原因，必须明确指出需要过滤可选依赖关系。
3 最终工件中仅包含对应于 PostgreSQL 的 JDBC 驱动程序的可选依赖关系。

如果要在 quarkus.package.jar.included-optional-dependencies 标记中声明多个可选依赖项，请确保用 , 将其分隔开（例如，org.postgresql:postgresql::jar,com.foo:bar::jar）。

Configuring the Project Output

有一些配置选项将定义项目构建的输出内容。这些选项与任何其他配置属性在 application.properties 中的提供方式相同。

属性如下所示：

Unresolved include directive in modules/ROOT/pages/maven-tooling.adoc - include::../../../target/quarkus-generated-doc/config/quarkus-core_quarkus.package.adoc[]

Custom test configuration profile in JVM mode

默认情况下，使用 test 配置配置文件运行 JVM 模式下的 Quarkus 测试。如果你不熟悉 Quarkus 配置配置文件，所有你需要了解的内容都在 Configuration Profiles Documentation 中进行了说明。

但你可以使用以下所示的 Maven Surefire 和 Maven Failsafe 配置为测试使用自定义配置配置文件。如果需要使用非默认测试数据库运行一些测试，这会很有用。

<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>${surefire-plugin.version}</version>
        <configuration>
          <systemPropertyVariables>
            <quarkus.test.profile>foo</quarkus.test.profile> 1
            <buildDirectory>${project.build.directory}</buildDirectory>
            [...]
          </systemPropertyVariables>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-failsafe-plugin</artifactId>
        <version>${failsafe-plugin.version}</version>
        <configuration>
          <systemPropertyVariables>
            <quarkus.test.profile>foo</quarkus.test.profile> 1
            <buildDirectory>${project.build.directory}</buildDirectory>
            [...]
          </systemPropertyVariables>
        </configuration>
      </plugin>
    </plugins>
  </build>
  [...]
</project>
1 foo 配置配置文件将用于运行测试。

现在还无法在原生模式下使用测试自定义配置文件。始终使用 prod 配置文件运行原生测试。

Bootstrap Maven properties

Quarkus 启动程序包含一个 Maven 解析器实现，用于解析应用程序运行时和构建时依赖项。Quarkus Maven 解析器使用启动构建、测试或开发模式的相同 Maven 命令行进行初始化。通常，无需添加任何额外配置。但有时可能需要一个额外的配置选项才能在测试或开发模式或 IDE 中正确解析应用程序依赖项。

例如，Maven 测试插件（例如 surefire 和 failsafe）不会默认将构建系统属性传播到正在运行的测试。这意味着 Maven CLI 设置的一些系统属性对于针对测试初始化的 Quarkus Maven 解析器不可用，这可能导致使用不同于主 Maven 构建的设置来解析测试依赖项。

以下是 Quarkus 启动程序 Maven 解析器在初始化期间检查的系统属性列表。

Property name Default Value Description

maven.home

MAVEN_HOME envvar

Maven 主目录用于解析全局设置文件，除非使用 -gs 参数在命令行上明确提供

maven.settings

~/.m2/settings.xml

除非使用 -s 参数提供了自定义设置文件，否则此属性可用于将解析器指向自定义 Maven 设置文件

maven.repo.local

~/.m2/repository

如果此属性不同于默认值且在 settings.xml 中指定的值，则可用于配置自定义本地 Maven 仓库目录

maven.top-level-basedir

none

此属性可能有助于 Maven 解析器识别工作区中的顶级 Maven 项目。默认情况下，Maven 解析器将通过浏览父模块 POM 关系来发现项目的 workspace。但有些项目布局可能会使用聚合器模块，该模块不会显示为其模块的父模块。在这种情况下，此属性将帮助 Quarkus Maven 解析器正确发现 workspace。

quarkus.bootstrap.effective-model-builder

false

默认情况下，Quarkus Maven 解析器在发现项目的布局时直接读取项目的 POM。在大多数情况下，这种方式的工作效果足够好并且相对较快，但读取原始 POM 有其局限性。例如，如果 POM 在配置文件中包含模块，则无法发现这些模块。此系统属性启用基于有效 POM 模型（经过适当插值）而不是原始模型的项目布局发现功能。此选项未启用为默认选项的原因是它似乎会占用大量时间，比如会增加 CI 测试时间。在找到可以默认使用的更好的方法之前，需要此选项的项目应该启用此选项。

以上这些系统属性可以添加到 surefire 和/或 failsafe 插件配置中，如

<project>
  [...]
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>${surefire-plugin.version}</version>
        <configuration>
          <systemPropertyVariables>
            <maven.home>${maven.home}</maven.home> 1
            <maven.repo.local>${settings.localRepository}</maven.repo.local> 2
            <maven.settings>${session.request.userSettingsFile.path}</maven.settings> 3
            <maven.top-level-basedir>${session.topLevelProject.basedir.absolutePath}</maven.top-level-basedir> 4
            <quarkus.bootstrap.effective-model-builder>true</quarkus.bootstrap.effective-model-builder> 5
          </systemPropertyVariables>
        </configuration>
      </plugin>
    </plugins>
  </build>
  [...]
</project>
1 将 Maven CLI 设置的 maven.home 系统属性传播到测试
2 设置用于测试的 Maven 本地仓库目录
3 为测试设置 Maven 设置文件
4 指向测试的顶级项目目录
5 启用有效的基于 POM 的项目布局发现

Top-level vs Multi-module project directory

在 Maven 中，似乎存在顶级项目概念（公开为项目属性 ${session.topLevelProject.basedir.absolutePath}）和多模块项目目录（可用作属性 ${maven.multiModuleProjectDirectory}）。这些目录不一定总是一致的！

maven.multiModuleProjectDirectory 预计由 Maven 代码本身参考，而非依赖用户代码。因此，如果您觉得有帮助，请自行承担风险！

${maven.multiModuleProjectDirectory} 会解析为第一个包含 .mvn 目录的目录，该目录为其子目录，从当前目录（或通过 -f 参数指定的目录）启动 mvn 命令时，从工作空间文件系统树开始向上移动。但如果未找到 .mvn 目录，则 ${maven.multiModuleProjectDirectory} 会指向启动 mvn 命令的目录（或通过 -f 参数指定的目录）。

${session.topLevelProject.basedir.absolutePath} 会指向启动 mvn 命令的目录或使用 -f 参数指定的目录（如果指定了该参数）。

Quarkus project info

Quarkus Maven 插件包括一个称为 info 的目标（目前标记为“实验”），它会记录项目中特定于 Quarkus 的信息，例如：导入的 Quarkus 平台 BOM 和项目依存关系中找到的 Quarkus 扩展。在多模块项目 quarkus:info 中会认为当前模块（在其中执行）是应用程序的主模块。

目前 quarkus:info 生成的报告不包括 Quarkus Maven 插件信息，但计划在未来版本中添加。

下面是一个简单项目的 info 输出示例：

[aloubyansky@localhost code-with-quarkus]$ mvn quarkus:info
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------------< org.acme:code-with-quarkus >---------------------
[INFO] Building code-with-quarkus 1.0.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- quarkus-maven-plugin:{quarkus-version}:info (default-cli) @ code-with-quarkus ---
[WARNING] quarkus:info goal is experimental, its options and output may change in future versions
[INFO] Quarkus platform BOMs: 1
[INFO]   {quarkus-platform-groupid}:quarkus-bom:pom:{quarkus-version}
[INFO]   {quarkus-platform-groupid}:quarkus-camel-bom:pom:{quarkus-version}
[INFO]
[INFO] Extensions from {quarkus-platform-groupid}:quarkus-bom: 2
[INFO]   io.quarkus:quarkus-rest
[INFO]
[INFO] Extensions from {quarkus-platform-groupid}:quarkus-camel-bom: 3
[INFO]   org.apache.camel.quarkus:camel-quarkus-rabbitmq
[INFO]
[INFO] Extensions from registry.quarkus.io: 4
[INFO]   io.quarkiverse.prettytime:quarkus-prettytime:2.0.1
1 项目中导入的 Quarkus 平台 BOM（父 POM 导入的 BOM 也将报告）
2 quarkus-bom 管理的直接 Quarkus 扩展依存关系
3 quarkus-camel-bom 管理的直接 Quarkus 扩展依存关系
4 Quarkus BOM 不管理但可以在 Quarkus 扩展注册表中找到的直接 Quarkus 扩展依存关系

quarkus:info 还会报告 Quarkus 扩展注册表中找不到的 Quarkus 扩展（如果这些扩展存在于项目依存关系中），表明这些扩展的“来源未知”。

Highlighting misaligned versions

在检测到基本 Quarkus 依赖关系版本不一致时，quarkus:info 也会突出显示它们。例如，如果我们通过从依存关系中删除 camel-quarkus-rabbitmq 扩展并在 quarkus-bom 管理的 quarkus-rest 依存关系中添加 2.6.3.Final <version> 元素来修改上面提到的项目，然后再次运行 quarkus:info，会看到类似以下内容：

[INFO] --- quarkus-maven-plugin:{quarkus-version}:info (default-cli) @ code-with-quarkus ---
[WARNING] quarkus:info goal is experimental, its options and output may change in future versions
[INFO] Quarkus platform BOMs:
[INFO]   {quarkus-platform-groupid}:quarkus-bom:pom:{quarkus-version}
[INFO]   {quarkus-platform-groupid}:quarkus-camel-bom:pom:{quarkus-version} | unnecessary 1
[INFO]
[INFO] Extensions from {quarkus-platform-groupid}:quarkus-bom:
[INFO]   io.quarkus:quarkus-resteasy-reactive:2.6.3.Final | misaligned 2
[INFO]
[INFO] Extensions from {quarkus-platform-groupid}:quarkus-camel-bom:
[INFO]   org.apache.camel.quarkus:camel-quarkus-rabbitmq
[INFO]
[INFO] Extensions from registry.quarkus.io:
[INFO]   io.quarkiverse.prettytime:quarkus-prettytime:2.0.1
[INFO]
[WARNING] Non-recommended Quarkus platform BOM and/or extension versions were found. For more details, please, execute 'mvn quarkus:update -Drectify'
1 现在，quarkus-camel-bom 导入被报告为“不必要”，因为它包含的 Quarkus 扩展均不在项目依存关系中
2 现在，quarkus-resteasy-reactive 的 2.6.3.Final 版本被报告为与项目中导入的 Quarkus 平台 BOM 管理的版本不一致，版本为 ${project.version}

Quarkus project update

Quarkus Maven 插件提供的 quarkus:update 目标（目前标记为“实验”）可用于检查项目是否存在可用的与 Quarkus 相关的更新，例如：相关 Quarkus 平台 BOM 的新版本和项目中存在的非平台 Quarkus 扩展。在多模块项目中，update 目标应从 Quarkus 主应用程序模块执行。

在这一点上，`quarkus:update`目标实际上不会应用推荐的更新，但会告诉您更新内容以及如何手动应用。

Quarkus Maven 插件的版本当前并未包含在更新报告中，但计划在未来的版本中添加。

quarkus:update`的工作方式是，首先，收集项目的所有直接 Quarkus 扩展依赖项（由 Quarkus 平台 BOM 管理的和未由 Quarkus 平台 BOM 管理但在 Quarkus 扩展注册表中找到的）。然后，将查询已配置的 Quarkus 扩展注册表（通常是 `registry.quarkus.io）以获得最新推荐/支持的 Quarkus 平台版本和与之兼容的非平台 Quarkus 扩展。然后，该算法将选择项目中找到的所有扩展的最新兼容组合（假设这种组合确实存在）。否则，将不建议进行更新。

假设我们有一个项目包括基于 Quarkus `2.7.1.Final`的 Quarkus 平台中可用的 Kogito、Camel 和核心 Quarkus 扩展，则 `quarkus:update`的输出如下所示：

[aloubyansky@localhost code-with-quarkus]$ mvn quarkus:update
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------------< org.acme:code-with-quarkus >---------------------
[INFO] Building code-with-quarkus 1.0.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- quarkus-maven-plugin:{quarkus-version}:update (default-cli) @ code-with-quarkus ---
[WARNING] quarkus:update goal is experimental, its options and output might change in future versions
[INFO]
[INFO] Recommended Quarkus platform BOM updates: 1
[INFO] Update: {quarkus-platform-groupid}:quarkus-bom:pom:2.7.1.Final -> {quarkus-version}
[INFO] Update: {quarkus-platform-groupid}:quarkus-camel-bom:pom:2.7.1.Final -> {quarkus-version}
1 当前推荐的 Quarkus 平台 BOM 更新列表

通常，将使用单个项目属性管理所有 Quarkus 平台 BOM，但当前的实现还不够智能，无法指出这一点，并会单独报告每个 BOM 的更新。

如果我们修改项目以从项目中删除所有 Camel Quarkus 扩展，将 quarkus-resteasy-reactive`扩展的版本更改为 `2.6.3.Final，并将未包含在 Quarkus 平台 BOM 中的 quarkus-prettytime`降级为 `0.2.0，则 `quarkus:update`将报告如下内容：

[INFO] Recommended Quarkus platform BOM updates: 1
[INFO] Update: {quarkus-platform-groupid}:quarkus-bom:pom:2.7.1.Final -> {quarkus-version}
[INFO] Remove: {quarkus-platform-groupid}:quarkus-camel-bom:pom:2.7.1.Final 2
[INFO]
[INFO] Extensions from {quarkus-platform-groupid}:quarkus-bom:
[INFO] Update: io.quarkus:quarkus-resteasy-reactive:2.6.3.Final -> remove version (managed) 3
[INFO]
[INFO] Extensions from registry.quarkus.io:
[INFO] Update: io.quarkiverse.prettytime:quarkus-prettytime:0.2.0 -> 0.2.1 4
1 项目中当前推荐的 Quarkus 平台 BOM 更新列表
2 鉴于项目不包括任何 Camel Quarkus 扩展，建议删除 BOM 导入
3 `quarkus-resteasy-reactive`的过时版本建议移除，取而代之的是由 `quarkus-bom`管理的版本
4 `quarkus-prettytime`扩展的最新兼容版本

Quarkus project rectify

如上所述，`quarkus:info`除了报告 Quarkus 平台和扩展版本外，还执行快速版本对齐检查，以确保项目中使用的扩展版本与导入的 Quarkus 平台 BOM 兼容。如果检测到不对齐，将记录以下警告消息：

[WARNING] Non-recommended Quarkus platform BOM and/or extension versions were found. For more details, please, execute 'mvn quarkus:update -Drectify'

启用 `rectify`选项后，`quarkus:update`将记录更新说明，简单地将项目中找到的扩展依赖版本与当前导入的 Quarkus 平台 BOM 对齐，而不是建议使用最新的推荐 Quarkus 版本更新。