任务依赖允许任务基于其依赖关系以特定顺序执行。这确保了依赖于其他任务的任务仅在这些依赖项完成后执行。
任务依赖可以分为隐式或显式
- 隐式依赖
-
这些依赖关系由 Gradle 根据任务的操作和配置自动推断。例如，如果
taskB使用taskA的输出（例如，由taskA生成的文件），Gradle 将自动确保在taskB之前执行taskA以满足此依赖关系。 - 显式依赖
-
这些依赖关系在构建脚本中使用
dependsOn、mustRunAfter或shouldRunAfter方法显式声明。例如，如果您想确保taskB始终在taskA之后运行，您可以显式使用taskB.mustRunAfter(taskA)声明此依赖关系。
隐式和显式依赖关系在定义任务执行顺序和确保任务以正确的顺序执行以产生所需的构建输出方面都起着至关重要的作用。
任务依赖
Gradle 本身了解任务之间的依赖关系。因此，当您以特定任务为目标时，它可以确定需要执行的任务。
让我们以一个包含 app 子项目和 some-logic 子项目的示例应用程序为例
rootProject.name = "gradle-project"
include("app")
include("some-logic")rootProject.name = 'gradle-project'
include('app')
include('some-logic')假设 app 子项目依赖于名为 some-logic 的子项目，该子项目包含一些 Java 代码。我们在 app 构建脚本中添加此依赖项
plugins {
id("application") // app is now a java application
}
application {
mainClass.set("hello.HelloWorld") // main class name required by the application plugin
}
dependencies {
implementation(project(":some-logic")) // dependency on some-logic
}plugins {
id('application') // app is now a java application
}
application {
mainClass = 'hello.HelloWorld' // main class name required by the application plugin
}
dependencies {
implementation(project(':some-logic')) // dependency on some-logic
}如果我们再次运行 :app:build，我们会看到 some-logic 的 Java 代码也由 Gradle 自动编译
$./gradlew :app:build
> Task :app:processResources NO-SOURCE
> Task :app:processTestResources NO-SOURCE
> Task :some-logic:compileJava UP-TO-DATE
> Task :some-logic:processResources NO-SOURCE
> Task :some-logic:classes UP-TO-DATE
> Task :some-logic:jar UP-TO-DATE
> Task :app:compileJava
> Task :app:classes
> Task :app:jar UP-TO-DATE
> Task :app:startScripts
> Task :app:distTar
> Task :app:distZip
> Task :app:assemble
> Task :app:compileTestJava UP-TO-DATE
> Task :app:testClasses UP-TO-DATE
> Task :app:test
> Task :app:check
> Task :app:build
BUILD SUCCESSFUL in 430ms
9 actionable tasks: 5 executed, 4 up-to-date添加依赖
您可以通过多种方式定义任务的依赖关系。
使用任务名称和 dependsOn()` 方法定义依赖关系是最简单的。
以下示例添加了从 taskX 到 taskY 的依赖关系
tasks.register("taskX") {
dependsOn("taskY")
}tasks.register("taskX") {
dependsOn "taskY"
}$ gradle -q taskX taskY taskX
有关任务依赖关系的更多信息，请参阅 Task API。
任务排序
在某些情况下，控制两个任务的执行顺序很有用，而无需在这些任务之间引入显式依赖关系。
任务排序和任务依赖之间的主要区别在于，排序规则不影响将要执行哪些任务，而仅影响它们的执行顺序。
任务排序在许多场景中都很有用
-
强制任务的顺序执行（例如，
build永远不会在clean之前运行）。 -
在构建早期运行构建验证（例如，在开始发布构建的工作之前验证我是否具有正确的凭据）。
-
通过在长时间验证任务之前运行快速验证任务来更快地获得反馈（例如，单元测试应在集成测试之前运行）。
-
聚合特定类型的所有任务结果的任务（例如，测试报告任务合并所有已执行的测试任务的输出）。
有两种排序规则可用：“必须在...之后运行”和“应该在...之后运行”。
要指定 2 个任务之间的“必须在...之后运行”或“应该在...之后运行”排序，您可以使用 Task.mustRunAfter(java.lang.Object...) 和 Task.shouldRunAfter(java.lang.Object...) 方法。这些方法接受任务实例、任务名称或 Task.dependsOn(java.lang.Object...) 接受的任何其他输入。
当您使用“必须在...之后运行”时，您指定当构建需要执行 taskX 和 taskY 时，taskY 必须始终在 taskX 之后运行。因此，如果您仅运行带有 mustRunAfter 的 taskY，则不会导致 taskX 运行。这表示为 taskY.mustRunAfter(taskX)。
val taskX by tasks.registering {
doLast {
println("taskX")
}
}
val taskY by tasks.registering {
doLast {
println("taskY")
}
}
taskY {
mustRunAfter(taskX)
}def taskX = tasks.register('taskX') {
doLast {
println 'taskX'
}
}
def taskY = tasks.register('taskY') {
doLast {
println 'taskY'
}
}
taskY.configure {
mustRunAfter taskX
}$ gradle -q taskY taskX taskX taskY
“应该在...之后运行”排序规则类似，但不太严格，因为它在两种情况下会被忽略
-
如果使用该规则引入排序循环。
-
当使用并行执行并且除了“应该在...之后运行”任务之外的所有任务依赖项都已满足时，则无论其“应该在...之后运行”依赖项是否已运行，都将运行此任务。
您应该在排序有帮助但不是严格要求的情况下使用“应该在...之后运行”
val taskX by tasks.registering {
doLast {
println("taskX")
}
}
val taskY by tasks.registering {
doLast {
println("taskY")
}
}
taskY {
shouldRunAfter(taskX)
}def taskX = tasks.register('taskX') {
doLast {
println 'taskX'
}
}
def taskY = tasks.register('taskY') {
doLast {
println 'taskY'
}
}
taskY.configure {
shouldRunAfter taskX
}$ gradle -q taskY taskX taskX taskY
在上面的示例中，仍然可以在不导致 taskX 运行的情况下执行 taskY
$ gradle -q taskY taskY
如果“应该在...之后运行”排序规则引入排序循环，则会被忽略
val taskX by tasks.registering {
doLast {
println("taskX")
}
}
val taskY by tasks.registering {
doLast {
println("taskY")
}
}
val taskZ by tasks.registering {
doLast {
println("taskZ")
}
}
taskX { dependsOn(taskY) }
taskY { dependsOn(taskZ) }
taskZ { shouldRunAfter(taskX) }def taskX = tasks.register('taskX') {
doLast {
println 'taskX'
}
}
def taskY = tasks.register('taskY') {
doLast {
println 'taskY'
}
}
def taskZ = tasks.register('taskZ') {
doLast {
println 'taskZ'
}
}
taskX.configure { dependsOn(taskY) }
taskY.configure { dependsOn(taskZ) }
taskZ.configure { shouldRunAfter(taskX) }$ gradle -q taskX taskZ taskY taskX
请注意，taskY.mustRunAfter(taskX) 或 taskY.shouldRunAfter(taskX) 并不意味着任务之间有任何执行依赖关系
-
可以独立执行
taskX和taskY。排序规则仅在计划执行两个任务时才有效。 -
当使用
--continue运行时，如果taskX失败，taskY可能会执行。
最终任务
当最终任务计划运行时，最终任务会自动添加到任务图中。
要指定最终任务，您可以使用 Task.finalizedBy(java.lang.Object…) 方法。此方法接受任务实例、任务名称或 Task.dependsOn(java.lang.Object…) 接受的任何其他输入
val taskX by tasks.registering {
doLast {
println("taskX")
}
}
val taskY by tasks.registering {
doLast {
println("taskY")
}
}
taskX { finalizedBy(taskY) }def taskX = tasks.register('taskX') {
doLast {
println 'taskX'
}
}
def taskY = tasks.register('taskY') {
doLast {
println 'taskY'
}
}
taskX.configure { finalizedBy taskY }$ gradle -q taskX taskX taskY
即使最终任务失败或最终任务被视为 UP-TO-DATE，最终任务也会执行
val taskX by tasks.registering {
doLast {
println("taskX")
throw RuntimeException()
}
}
val taskY by tasks.registering {
doLast {
println("taskY")
}
}
taskX { finalizedBy(taskY) }def taskX = tasks.register('taskX') {
doLast {
println 'taskX'
throw new RuntimeException()
}
}
def taskY = tasks.register('taskY') {
doLast {
println 'taskY'
}
}
taskX.configure { finalizedBy taskY }$ gradle -q taskX taskX taskY FAILURE: Build failed with an exception. * Where: Build file '/home/user/gradle/samples/build.gradle' line: 4 * What went wrong: Execution failed for task ':taskX'. > java.lang.RuntimeException (no error message) * Try: > Run with --stacktrace option to get the stack trace. > Run with --info or --debug option to get more log output. > Run with --scan to get full insights. > Get more help at https://help.gradle.org. BUILD FAILED in 0s
当构建创建必须清理的资源时，无论构建失败还是成功，最终任务都很有用。这种资源的一个例子是 Web 容器，它在集成测试任务之前启动，并且即使某些测试失败也必须关闭。
跳过任务
Gradle 提供了多种跳过任务执行的方法。
1. 使用谓词
您可以使用 Task.onlyIf 将谓词附加到任务。仅当谓词评估为 true 时，才会执行任务的操作。
谓词作为参数传递给任务，如果任务将执行，则返回 true，如果任务将被跳过，则返回 false。谓词在任务执行之前进行评估。
将可选的原因字符串传递给 onlyIf() 对于解释为什么跳过任务很有用
val hello by tasks.registering {
doLast {
println("hello world")
}
}
hello {
val skipProvider = providers.gradleProperty("skipHello")
onlyIf("there is no property skipHello") {
!skipProvider.isPresent()
}
}def hello = tasks.register('hello') {
doLast {
println 'hello world'
}
}
hello.configure {
def skipProvider = providers.gradleProperty("skipHello")
onlyIf("there is no property skipHello") {
!skipProvider.present
}
}$ gradle hello -PskipHello > Task :hello SKIPPED BUILD SUCCESSFUL in 0s
要查找任务被跳过的原因，请使用 --info 日志记录级别运行构建。
$ gradle hello -PskipHello --info ... > Task :hello SKIPPED Skipping task ':hello' as task onlyIf 'there is no property skipHello' is false. :hello (Thread[included builds,5,main]) completed. Took 0.018 secs. BUILD SUCCESSFUL in 13s
2. 使用 StopExecutionException
如果无法用谓词表示跳过任务的逻辑，则可以使用 StopExecutionException。
如果操作抛出此异常，则任务操作以及任何后续操作的执行都将被跳过。构建通过执行下一个任务继续
val compile by tasks.registering {
doLast {
println("We are doing the compile.")
}
}
compile {
doFirst {
// Here you would put arbitrary conditions in real life.
if (true) {
throw StopExecutionException()
}
}
}
tasks.register("myTask") {
dependsOn(compile)
doLast {
println("I am not affected")
}
}def compile = tasks.register('compile') {
doLast {
println 'We are doing the compile.'
}
}
compile.configure {
doFirst {
// Here you would put arbitrary conditions in real life.
if (true) {
throw new StopExecutionException()
}
}
}
tasks.register('myTask') {
dependsOn('compile')
doLast {
println 'I am not affected'
}
}$ gradle -q myTask I am not affected
如果您使用 Gradle 提供的任务，此功能很有用。它允许您添加此类任务的内置操作的条件执行。[1]
3. 启用和禁用任务
每个任务都有一个 enabled 标志，默认为 true。将其设置为 false 可防止执行任务的操作。
禁用的任务将被标记为 SKIPPED
val disableMe by tasks.registering {
doLast {
println("This should not be printed if the task is disabled.")
}
}
disableMe {
enabled = false
}def disableMe = tasks.register('disableMe') {
doLast {
println 'This should not be printed if the task is disabled.'
}
}
disableMe.configure {
enabled = false
}$ gradle disableMe > Task :disableMe SKIPPED BUILD SUCCESSFUL in 0s
4. 任务超时
每个任务都有一个 timeout 属性，可用于限制其执行时间。当任务达到其超时时间时，其任务执行线程将被中断。该任务将被标记为 FAILED。
最终任务 将被执行。如果使用 --continue，其他任务将继续运行。
不响应中断的任务无法超时。所有 Gradle 的内置任务都响应超时。
tasks.register("hangingTask") {
doLast {
Thread.sleep(100000)
}
timeout = Duration.ofMillis(500)
}tasks.register("hangingTask") {
doLast {
Thread.sleep(100000)
}
timeout = Duration.ofMillis(500)
}任务规则
有时您希望拥有一个任务，其行为取决于大量或无限数值范围的参数。提供此类任务的一种非常出色且富有表现力的方法是任务规则
tasks.addRule("Pattern: ping<ID>") {
val taskName = this
if (startsWith("ping")) {
task(taskName) {
doLast {
println("Pinging: " + (taskName.replace("ping", "")))
}
}
}
}tasks.addRule("Pattern: ping<ID>") { String taskName ->
if (taskName.startsWith("ping")) {
task(taskName) {
doLast {
println "Pinging: " + (taskName - 'ping')
}
}
}
}$ gradle -q pingServer1 Pinging: Server1
String 参数用作规则的描述，该描述与 ./gradlew tasks 一起显示。
规则不仅在从命令行调用任务时使用。您还可以在基于规则的任务上创建 dependsOn 关系
tasks.addRule("Pattern: ping<ID>") {
val taskName = this
if (startsWith("ping")) {
task(taskName) {
doLast {
println("Pinging: " + (taskName.replace("ping", "")))
}
}
}
}
tasks.register("groupPing") {
dependsOn("pingServer1", "pingServer2")
}tasks.addRule("Pattern: ping<ID>") { String taskName ->
if (taskName.startsWith("ping")) {
task(taskName) {
doLast {
println "Pinging: " + (taskName - 'ping')
}
}
}
}
tasks.register('groupPing') {
dependsOn 'pingServer1', 'pingServer2'
}$ gradle -q groupPing Pinging: Server1 Pinging: Server2
如果您运行 ./gradlew -q tasks，您将找不到名为 pingServer1 或 pingServer2 的任务，但此脚本正在执行基于运行这些任务请求的逻辑。
从执行中排除任务
您可以使用 -x 或 --exclude-task 命令行选项从执行中排除任务，并提供要排除的任务名称。
$ ./gradlew build -x test例如，您可以运行 check 任务，但排除 test 任务的运行。这种方法可能会导致意外的结果，尤其是在您排除生成其他任务所需结果的可操作任务时。建议为所需的操作定义合适的生命周期任务，而不是依赖 -x 参数。
使用 -x 是一种应该避免的做法，尽管仍然很常见。