Quarkus and Gradle

Creating a new project

若要构建 Gradle 项目，您可以使用 Quarkus CLI 或 Quarkus Maven 插件：

CLI
quarkus create app my-groupId:my-artifactId \
    --extensions=rest,rest-jackson \
    --gradle

For more information about how to install the Quarkus CLI and use it, please refer to the Quarkus CLI guide.

Maven
mvn {quarkus-platform-groupid}:quarkus-maven-plugin:{quarkus-version}:create \
    -DprojectGroupId=my-groupId \
    -DprojectArtifactId=my-artifactId \
    -Dextensions="rest,rest-jackson" \
    -DbuildTool=gradle

如果您刚刚启动 mvn io.quarkus.platform:quarkus-maven-plugin:${project.version}:create，Maven 插件会询问用户输入。通过向 Maven 命令传递 -B，可以禁用此互动模式（并使用默认值）。

如果您偏好使用 Kotlin DSL，使用 gradle-kotlin-dsl 而不是 gradle 。

Quarkus 项目脚手架在您的项目中自动安装 Gradle 包装器 (./gradlew)。 如果您更偏好使用独立的 Gradle 安装，请使用 Gradle ${gradle-wrapper.version}。

此项目是在以传递的 artifactId 命名的目录中生成的。

这一对适用于本地和 JVM 模式的 Dockerfile 也在 src/main/docker 中生成。这些 Dockerfile 中写有构建镜像和运行容器的说明。

Custom test configuration profile in JVM mode

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

但是，使用下方所示的 Gradle 构建配置，为您的测试使用自定义配置配置文件是可行的。这可能很有用，例如，如果您需要使用某个不是您的默认测试数据库的特定数据库运行一些测试时。

Groovy DSL
test {
    systemProperty "quarkus.test.profile", "foo" 1
}
1 foo 配置配置文件将用于运行测试。
Kotlin DSL
tasks.test {
    systemProperty("quarkus.test.profile", "foo") 1
}
1 foo 配置配置文件将用于运行测试。

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

Dealing with extensions

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

CLI
quarkus extension
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 。如果没有找到扩展或有多个扩展匹配，您将在命令结果中看到一个红色的对号 ❌。

$ ./gradlew addExtension --extensions="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?
[...]

您可以安装所有与某一 globbing 模式匹配的扩展：

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

Development mode

Quarkus 带有内置的开发模式。您可以使用以下方法启动它：

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

请注意，如果您以这种方式运行它，持续测试体验将不会那么好，因为 gradle 作为一个守护进程运行，而 Quarkus 无法绘制“美观”的测试输出，因此退回到仅仅记录输出。

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

quarkusDev 启用热部署以及后台编译，这意味着当您修改 Java 文件或资源文件并刷新您的浏览器时，这些更改将自动生效。这对于资源文件（如配置属性文件）也很有效。刷新浏览器的行为将触发扫描工作区，如果检测到任何更改，Java 文件将被编译，应用程序将重新部署，然后您的请求将由重新部署的应用程序提供服务。如果编译或部署存在任何问题，一个错误页面会让您知道。

按 CTRL+C 停止应用程序。

您可以更改开发环境运行的工作目录：

Groovy DSL
quarkusDev {
    workingDirectory = rootProject.layout.projectDirectory.asFile
}
Kotlin DSL
tasks.quarkusDev {
    workingDirectory = rootProject.layout.projectDirectory.asFile
}

默认情况下，quarkusDev 任务使用 compileJava 编译器选项。这些选项可以通过在任务中设置 compilerArgs 属性来覆盖。

默认情况下，quarkusDev 将调试主机设置为 localhost (出于安全原因)。如果您需要更改此设置，例如，为启用在所有主机上进行调试，您可以像这样使用 -DdebugHost 选项： include::./_includes/devtools/dev-parameters.adoc[]:!dev-additional-parameters:

您还可以向开发环境中添加环境变量：

Groovy DSL
quarkusDev {
    environmentVariables = [FOO_VALUE: 'abc', BAR_VALUE: 'def']
}
Kotlin DSL
tasks.quarkusDev {
    environmentVariables.set(mapOf("FOO_VALUE" to "abc", "BAR_VALUE" to "def"))
}

该插件还公开了一个 quarkusDev 配置。在该配置中声明一个依赖项的使用，将限制其使用仅限于开发模式。 quarkusDev 配置可以使用如下方式：

Groovy DSL
dependencies {
    quarkusDev 'io.quarkus:quarkus-jdbc-h2'
}
Kotlin DSL
dependencies {
    quarkusDev("io.quarkus:quarkus-jdbc-h2")
}

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 命令将本地代理连接到远程主机：

./gradlew quarkusRemoteDev -Dquarkus.live-reload.url=http://my-remote-host:8080

现在，每次刷新浏览器时，你应该立即看到自己在远程应用程序中对本地做出的任何更改。

所有配置选项如下所示：

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

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。唯一要求就是导入 Gradle 项目的能力。

Eclipse

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

在单独的终端中，运行：

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

并尽享高产出环境。

IntelliJ IDEA

在 IntelliJ IDEA 中：

  1. 在 IntelliJ IDEA 中选择 File → New → Project From Existing Sources…​ 或在欢迎对话框中选择 Import project。

  2. Select the project root

  3. 选择 Import project from external model 和 Gradle

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

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

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

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

享受！

Apache NetBeans

在 NetBeans 中：

  1. 选择 File → 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 Code 中打开项目目录。如果你已经安装了 Java Extension Pack（分组一系列 Java 扩展程序），则会将项目加载为 Gradle 项目。

Downloading dependencies for offline development and testing

Quarkus 扩展程序依赖关系分为最终出现在应用程序运行时类路径中的运行时扩展程序依赖关系和仅在应用程序构建时由 Quarkus 解析以创建构建类路径的部署（或构建时）扩展程序依赖关系。应用程序开发人员应该只依赖 Quarkus 扩展程序的运行时构件。

为了实现离线构建和测试 Quarkus 应用程序的用例，该插件包含可以像这样从命令行调用的 quarkusGoOffline 任务：

./gradlew quarkusGoOffline

该任务会将应用程序的所有运行时、构建时、测试和开发模式依赖关系解析到 Gradle 缓存。执行后，你将能够放心地使用 --offline 标志来运行 quarkus 任务。

Building a native executable

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

确保已经配置 GRAALVM_HOME，并且指向 GraalVM ${graal-community.version-for-documentation} 的最新版本。

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

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

本机可执行文件将出现在 build/ 中。

本机相关属性可以添加到 application.properties 文件、作为命令行参数或添加到 quarkusBuild 任务中。可以按照以下步骤配置 quarkusBuild 任务：

Groovy DSL
quarkusBuild {
    nativeArgs {
        containerBuild = true 1
        builderImage = "quay.io/quarkus/ubi-quarkus-mandrel-builder-image:{mandrel-flavor}" 2
    }
}
1 将 quarkus.native.container-build 属性设置为 true
2 将 quarkus.native.builder-image 属性设置为 quay.io/quarkus/ubi-quarkus-mandrel-builder-image:${mandrel.image-tag-for-documentation}
Kotlin DSL
tasks.quarkusBuild {
    nativeArgs {
        "container-build" to true 1
        "builder-image" to "quay.io/quarkus/ubi-quarkus-mandrel-builder-image:{mandrel-flavor}" 2
    }
}
1 将 quarkus.native.container-build 属性设置为 true
2 将 quarkus.native.builder-image 属性设置为 quay.io/quarkus/ubi-quarkus-mandrel-builder-image:${mandrel.image-tag-for-documentation}

当使用 Gradle Groovy DSL 时，属性键必须遵循小驼峰式命名法。例如：container-build 无效，应该替换为 containerBuild。此限制不适用于 Gradle Kotlin DSL。

Build a container friendly executable

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

CLI
quarkus build --native --no-tests -Dquarkus.native.container-build=true
# The --no-tests flag is required only on Windows and macOS.
Maven
./mvnw install -Dnative -DskipTests -Dquarkus.native.container-build=true
Gradle
./gradlew build -Dquarkus.native.enabled=true -Dquarkus.native.container-build=true

生成的执行文件将是 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 版本可能与所有可用的镜像不兼容。

Running native tests

使用以下命令运行本机测试：

./gradlew testNative

该任务依赖于 quarkusBuild，因此它会在运行测试之前生成本机镜像。

默认情况下，native-test 源集基于 main 和 test 源集。可以添加一个额外的源集。例如，如果你的集成测试位于 integrationTest 源集中，你可以将其指定为：

Groovy DSL
quarkus {
    sourceSets {
        extraNativeTest = sourceSets.integrationTest
    }
}
Kotlin DSL
quarkus {
    sourceSets {
        setExtraNativeTest(sourceSets["integrationTest"])
    }
}

Running integration tests

使用 @QuarkusIntegrationTest 注释的 Quarkus 集成测试将在 Quarkus 生成的工件上运行。这些测试可以放在 src/integrationTest/java 目录中并使用以下内容执行：

./gradlew quarkusIntTest

此任务依赖于 test 和 quarkusBuild 任务。最终工件将在运行测试之前生成。

Using fast-jar

fast-jar 现在是默认的 Quarkus 软件包类型。./gradlew build 命令的结果是在 build 下的新目录，名为 quarkus-app。

你可以使用以下命令运行应用程序：java -jar build/quarkus-app/quarkus-run.jar。

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

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

Building Uber-Jars

Quarkus Gradle 插件支持通过指定 quarkus.package.jar.type 参数生成单一 JAR，如下所示：

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

生成单一 JAR 时，你可以使用 --ignored-entry 参数指定要从生成的 JAR 中排除的项：

./gradlew quarkusBuild -Dquarkus.package.jar.type=uber-jar --ignored-entry=META-INF/file1.txt

这些项相对于生成的单一 JAR 的根目录。你可以通过添加额外的 --ignored-entry 参数来指定多个项。

Working with multi-module projects

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

在多模块项目中为模块启用 CDI bean 发现的最佳方式是包含一个 META-INF/beans.xml 文件，除非它已经是使用 quarkus-maven-plugin 配置的主应用程序模块，在这种情况下它将自动编制索引。

或者，可以使用一些非官方 ` Gradle Jandex plugins` 代替 META-INF/beans.xml 文件。

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

Publishing your application

为了确保 Gradle 使用正确的依赖项版本，BOM 在你的构建文件中声明为一个 enforcedPlatform。默认情况下，maven-publish 插件将阻止你因 enforcedPlatform 而发布你的应用程序。可以通过在构建文件中添加以下配置来跳过此验证：

Groovy DSL
tasks.withType(GenerateModuleMetadata).configureEach {
    suppressedValidationErrors.add('enforced-platform')
}
Kotlin DSL
tasks.withType<GenerateModuleMetadata>().configureEach {
    suppressedValidationErrors.add("enforced-platform")
}

Configuring Quarkus builds

影响 Quarkus 构建的配置源不止一个，按照优先级顺序提到。Quarkus 构建使用 prod 配置文件：

  1. 系统属性（例如 ./gradlew -Dquarkus.package.jar.type=fast-jar &#8230;&#8203;）

  2. 系统环境（例如 QUARKUS_PACKAGE_JAR_TYPE=fast-jar ./gradlew &#8230;&#8203;）

  3. 通过 quarkus 扩展的 quarkusBuildProperties 进行配置，例如：quarkus { quarkusBuildProperties { set("package.jar.type", "uber-jar") } }

  4. 通过 Gradle 项目属性进行配置（例如 ./gradlew -Pquarkus.package.jar.type=fast-jar）

  5. 来自项目 application.properties、application.yaml 和 application.yml 文件的配置，以及项目的 application-prod.properties、application-prod.yaml 和 application-prod.yml 文件

上述优先级在 Quarkus 插件中从 3.0 开始发生了变化。较旧版本的 Quarkus Gradle 插件更喜欢设置中的 application.properties 而不是 Gradle 构建中的设置。

Quarkus Gradle 插件使用“标准”Quarkus 机制加载和解析配置。除了 application.properties 外，在 Quarkus 3.0 中增加了对 application.(yaml|yml) 的支持。在 3.0 中的另一项新增功能是通过 SmallRye Config 提供的所有机制现在也隐式地可用于 Quarkus Gradle 插件。

使用 quarkusShowEffectiveConfig 任务来显示 Quarkus 构建中使用的有效配置选项。如果您指定 --save-config-properties 命令行选项，则配置文件属性还存储在 build/<final-name>.quarkus-build.properties 文件中。

Gradle caching / task inputs

默认情况下，从 quarkus. 开头开始的系统属性和环境变量（包括来自 ~/.env 的那些环境变量）从 QUARKUS_ 开始，被视为 Gradle 任务的输入。这意味着只有那些系统属性或环境变量的更改才会导致 Gradle 的最新版本触发重新构建。对其他系统属性或环境变量的更改不会更改 Quarkus 的 Gradle 任务输入，也不会触发不必要的重新构建。

通过 quarkus.quarkusBuildProperties 指定的或通过 Quarkus application.* 配置文件指定的配置文件属性都视为 Gradle 任务输入，换句话说，这些文件中的每次更改都会导致重新构建。

如果您的 Quarkus 构建引用了不是以 quarkus. 开头开始的系统属性（或不是以 QUARKUS_ 开头开始的环境变量），则必须通过 Quarkus 构建扩展来引用那些属性。例如，如果您的 application.properties 文件引用了这样的环境变量：

greeting.message=${FOO_MESSAGE:Hello!}

则必须将其明确声明为“缓存相关”：

quarkus { cachingRelevantProperties.add("FOO_MESSAGE") // Note: cachingRelevantProperties accepts regular expressions }

Build workers

Quarkus 应用程序构建使用 Gradle 的工作人员 API 在隔离进程中运行。这包括 Quarkus 应用程序构建和 Quarkus 代码生成。这对于从 quarkus 扩展和 Gradle 项目属性正确传递配置到 Quarkus 的代码生成器/应用程序构建器是必需的。

执行代码生成和/或 Quarkus 构建的进程的 JVM 设置可以按如下方式进行配置，详情请见 JavaForkOptions。

Groovy DSL
plugins {
    id 'java'
    id 'io.quarkus'
}

quarkus {
    buildForkOptions {
        maxHeapSize = '2g'
    }
    codeGenForkOptions {
        maxHeapSize = '128m'
    }
}
Kotlin DSL
plugins {
    java
    id("io.quarkus")
}

quarkus {
    buildForkOptions {
        maxHeapSize = '2g'
    }
    codeGenForkOptions {
        maxHeapSize = '128m'
    }
}

Cached build artifacts

Gradle’s build cache 是一种非常有效的机制，可以通过重复使用以前生成的输出（ Incremental build 了解技术细节）来改善整体构建运行时。

Quarkus 插件利用了 Gradle 的最新检查机制和构建缓存。构建缓存可以是本地或本地 plus 远程缓存服务器，或者如果在 CI 环境中配置，则可以作为检索和存储整个缓存的工件的远程环境，例如使用 Gradle’s GitHub action 或直接/手动使用 GitHub 的 GitHub’s cache action。

Quarkus Gradle 插件关心 what 是否已缓存 in which environment（CI 或本地开发）。像 uber-jar 和本机二进制文件这样的大型工件在 CI 中不会被缓存，但在本地开发环境中会被缓存。

如果存在 CI 环境变量，则 Quarkus Gradle 插件会检测一个 CI environment。

非 CI 和 CI 环境中各种 Quarkus 包类型如何进行缓存，在下表中进行了介绍。请注意，即使任务的输出不是 cached， up-to-date 检查仍然适用。

Quarkus 应用程序构建被拆分为三个任务。 quarkusBuild 任务负责 provide 一个已构建的 Quarkus 应用程序。 quarkusDependenciesBuild 和 quarkusAppPartsBuild 任务被视为内部任务（可能会在任何时间改变且没有事先通知）。请参阅以下详情。

Quarkus package type

Notes

Caching (non-CI)

Caching in CI

fast-jar, jar

从属 jar 作为单个文件在 quarkus-app/lib/ 目录中被未经修改地存储。 quarkus-app/ 目录中的所有其他文件均为生成的。 quarkusAppPartsBuild 任务构建 fast-jar 包类型应用程序，并允许缓存 generated 部分，generated 部分是除 quarkus-app/lib/ 目录中的从属项之外的所有内容。 quarkusDependenciesBuild 任务用于通过 Gradle 机制收集从属项。然后， quarkusBuild 任务将 quarkusAppPartsBuild 和 quarkusDependenciesBuild 任务的输出汇编在一起。注意：如果没有明确配置包类型，则默认使用 fast-jar（或 -jar）。

✅

✅

mutable-jar, uber-jar, native, native-sources

quarkusBuild 任务负责构建 Quarkus 应用程序。对于 uber-jar， quarkusAppPartsBuild 和 quarkusDependenciesBuild 任务不执行任何操作。

✅

❌

legacy-jar, legacy

legacy-jar 构建与 fast-jar 构建类似，不同之处在于目录结构不同并且 modified-*.jar 文件被视为已生成。

✅

✅

在本地开发环境中，存储（和检索）更大缓存工件的成本（即时间）低于重新构建 Quarkus 应用程序的成本。这意味着 Quarkus Gradle 插件允许在非 CI 环境中缓存甚至像 uber-jar 或本机二进制文件这样可能较大的工件。在 CI 环境中，针对不断变化的代码库状态运行构建（例如：针对主分支上的每次提交运行 CI），将每个构建的（和较大的）工件添加到构建缓存中将导致构建缓存变得不必要的大，这在 GitHub 中尤为成问题，GitHub 中缓存工件的总量被限制为 10 GB。

背景信息：Gradle 中有两种相关的机制可用于提高构建性能：

  • 最新检查允许跳过任务的执行，前提是任务的 inputs 和 outputs 没有更改。例如，考虑一个 Java 编译任务：如果库依赖项和源文件（inputs）没有更改，并且编译的类文件（outputs）仍然可用，则可以跳过编译。

  • 构建缓存可以将（可缓存的）任务的输出存储到本地构建缓存中。任务的“output”可从缓存中返回。

最新检查和构建缓存的交互带来的好处是以建模“inputs”和“outputs”为代价的。输入不仅是文件或目录，还有构建期间使用的 Java 版本、操作系统、工作目录、配置选项等。因此，所有会影响任务操作的输出的内容都必须声明为任务的输入。

Gradle configuration cache

Quarkus Gradle 插件适用于启用了“ Gradle’s configuration cache” 的构建，但已禁用 Quarkus 任务的配置缓存。这意味着 Quarkus 插件不会破坏此类 Gradle 构建。