Gradle如何根据任务规则生成新任务 [英] How does Gradle generate a new task from a task rules

问题描述

在第19.11节中.此任务规则示例是4.2.1用户指南中的.if谓词在规则执行之前如何能够成立.我还注意到，在任务规则之前输入任务groupPing时，构建会失败.甚至在规则启动之前如何创建任务pingServer1，pingServer2?

In section 19.11. of the 4.2.1 user guide is this task rule example. How is the if predicate able to be true before the rule is even executed. I also noticed that when task groupPing is entered before the task rule the build fails. How are the tasks pingServer1, pingServer2 already created before the rule even starts?

tasks.addRule("Pattern: ping<ID>") { String taskName ->
    if (taskName.startsWith("ping")) {
        task(taskName) {
            doLast {
                println "Pinging: " + (taskName - 'ping')
            }
        }
    }
}

task groupPing {
    dependsOn pingServer1, pingServer2
}

推荐答案

为此

Per this book excerpt, the mechanism is similar to the methodMissing functionality in Groovy and other languages. That is, if the task does not exist, then Gradle will deliberately check the task rules, which can clearly create tasks dynamically.

要解决该评论，请考虑以下 build.gradle :

To address the comment, consider the following build.gradle:

tasks.addRule("rule 1") { String taskName ->
    println "TRACER xyz before if: ${taskName}"
    if (taskName.startsWith("xyz")) {
        println "TRACER xyz inside if: ${taskName}"
        task(taskName) {
            doLast {
                println "xyz " + (taskName - "xyz")
            }
        }
    }
}

tasks.addRule("rule 2") { String taskName ->
    println "TRACER ping before if: ${taskName}"
    if (taskName.startsWith("ping")) {
        println "TRACER ping inside if: ${taskName}"
        task(taskName) {
            doLast {
                println "Pinging: " + (taskName - "ping")
            }
        }
    }
}

task foo {
    println 'foo: config phase'
    doFirst {
        println 'foo: exec phase first'
    }
    doLast {
        println 'foo: exec phase last'
    }
}

task groupPing {
    dependsOn pingServer1, pingServer2
    println 'groupPing: config phase'
}

从本质上讲，它是这样做的:

In essence, this does:

• 定义规则1"，该规则检查 taskName ( String ，不是任务！)的前缀 xyz
• 定义规则2"，该规则检查 taskName 中是否有前缀 ping
• 使用一些printlns定义任务 foo
• 定义依赖于动态任务的任务 groupPing

• Define "rule 1" which checks the taskName (a String, not a task!) for prefix xyz
• Define "rule 2" which checks the taskNamefor prefix ping
• Define task foo with some printlns
• Define task groupPing with dependencies on dynamic tasks

这是 foo 的输出(添加了间距).它说明了在配置阶段，Gradle会先调用规则1"，然后调用规则2"来定义 pingServer1 和 pingServer2 :

Here is the output for foo (spacing added). It illustrates that, in the configuration phase, Gradle invokes "rule 1" and then "rule 2" to define pingServer1 and pingServer2:

$ gradle -q foo 
foo: config phase
TRACER xyz before if: pingServer1

TRACER ping before if: pingServer1
TRACER ping inside if: pingServer1

TRACER xyz before if: pingServer2

TRACER ping before if: pingServer2
TRACER ping inside if: pingServer2

groupPing: config phase
foo: exec phase first
foo: exec phase last

这篇关于Gradle如何根据任务规则生成新任务的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！