控制任务执行 - Gradle 中文

任务依赖项允许根据任务的依赖项以特定顺序执行任务。这确保了依赖于其他任务的任务仅在这些依赖项完成后才执行。

任务依赖项可分为隐式或显式

隐式依赖项: 这些依赖项由 Gradle 根据任务的操作和配置自动推断。例如，如果 taskB 使用 taskA 的输出（例如，由 taskA 生成的文件），Gradle 将自动确保在 taskB 之前执行 taskA 以满足此依赖项。
显式依赖项: 这些依赖项在构建脚本中使用 dependsOn、mustRunAfter 或 shouldRunAfter 方法显式声明。例如，如果你想确保 taskB 始终在 taskA 之后运行，则可以使用 taskB.mustRunAfter(taskA) 显式声明此依赖项。

隐式和显式依赖项在定义任务执行顺序和确保任务按正确顺序执行以生成所需的构建输出方面都发挥着至关重要的作用。

任务依赖项

Gradle 本质上了解任务之间的依赖关系。因此，当你针对特定任务时，它可以确定需要执行的任务。

我们以一个示例应用程序为例，其中包含一个 app 子项目和一个 some-logic 子项目

settings.gradle.kts

rootProject.name = "gradle-project"
include("app")
include("some-logic")

settings.gradle

rootProject.name = 'gradle-project'
include('app')
include('some-logic')

假设 app 子项目依赖于名为 some-logic 的子项目，其中包含一些 Java 代码。我们在 app 构建脚本中添加此依赖项

app/build.gradle.kts

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
}

app/build.gradle

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)。

build.gradle.kts

val taskX by tasks.registering {
    doLast {
        println("taskX")
    }
}
val taskY by tasks.registering {
    doLast {
        println("taskY")
    }
}
taskY {
    mustRunAfter(taskX)
}

build.gradle

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

“应在之后运行”排序规则类似，但不太严格，因为它在两种情况下会被忽略

如果使用该规则会引入排序循环。
当使用并行执行且除“应在之后运行”任务之外的所有任务依赖项都已满足时，无论其“应在之后运行”依赖项是否已运行，此任务都将运行。

应在排序有帮助但并非严格必需的情况下使用“应在之后运行”

build.gradle.kts

val taskX by tasks.registering {
    doLast {
        println("taskX")
    }
}
val taskY by tasks.registering {
    doLast {
        println("taskY")
    }
}
taskY {
    shouldRunAfter(taskX)
}

build.gradle

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

如果“应在之后运行”排序规则引入排序循环，则该规则将被忽略

build.gradle.kts

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) }

build.gradle

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…)接受的任何其他输入

build.gradle.kts

val taskX by tasks.registering {
    doLast {
        println("taskX")
    }
}
val taskY by tasks.registering {
    doLast {
        println("taskY")
    }
}

taskX { finalizedBy(taskY) }

build.gradle

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，最终任务也会执行

build.gradle.kts

val taskX by tasks.registering {
    doLast {
        println("taskX")
        throw RuntimeException()
    }
}
val taskY by tasks.registering {
    doLast {
        println("taskY")
    }
}

taskX { finalizedBy(taskY) }

build.gradle

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()传递可选原因字符串对于解释为何跳过任务很有用

build.gradle.kts

val hello by tasks.registering {
    doLast {
        println("hello world")
    }
}

hello {
    val skipProvider = providers.gradleProperty("skipHello")
    onlyIf("there is no property skipHello") {
        !skipProvider.isPresent()
    }
}

build.gradle

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。

如果某个操作抛出此异常，则会跳过任务操作以及任何后续操作的执行。构建会继续执行下一个任务

build.gradle.kts

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")
    }
}

build.gradle

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

build.gradle.kts

val disableMe by tasks.registering {
    doLast {
        println("This should not be printed if the task is disabled.")
    }
}

disableMe {
    enabled = false
}

build.gradle

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 的所有内置任务都响应超时。

build.gradle.kts

tasks.register("hangingTask") {
    doLast {
        Thread.sleep(100000)
    }
    timeout = Duration.ofMillis(500)
}

build.gradle

tasks.register("hangingTask") {
    doLast {
        Thread.sleep(100000)
    }
    timeout = Duration.ofMillis(500)
}

从执行中排除任务

您可以使用 -x 或 --exclude-task 命令行选项从执行中排除任务，并提供要排除的任务名称。

$ ./gradlew build -x test

例如，您可以运行 check 任务，但排除 test 任务的运行。此方法可能会导致意外结果，特别是如果您排除一个可操作的任务，而该任务会产生其他任务所需的成果。建议定义一个适合所需操作的生命周期任务，而不是依赖 -x 参数。

使用 -x 是一种应该避免的做法，尽管仍然很常见。

1。您可能想知道为什么既没有导入 StopExecutionException，也没有通过其完全限定名称访问它。原因是 Gradle 会向您的脚本添加一组默认导入（请参阅默认导入）。

此页面有帮助吗？