在Gradle任务之前如何做某事'；是否执行了的依赖项？

我在

build.gradle中有以下内容：

task aoeu据我所知，您的代码应该可以正常工作，但它不能
doFirst
应在配置阶段执行，配置阶段在
doLast
之前运行（执行阶段）。顺便说一句，该代码工作正常：

正如Peter Niederwiser在这里所写的
doFirst
在执行阶段作为第一条语句运行（在
doLast
之前），因此您的代码工作正常。此示例将向您展示gradle build中的执行顺序：

task publish {
    println "(1) before (run in configuration phase)" // this will run before gradle dependencies
}

task aoeu << {
    println "(2) during  (run in execution phase as last statement)"
}

tasks.publish.dependsOn(aoeu)
tasks.publish.doLast {
    println "(4) after  (run in execution phase as last statement)"
}

tasks.publish.doFirst {
    println "(3) after  (run in execution phase as FORST statement - before doLast/<<)"
}

会回来的

C:\>gradle publish
(1) before (run in configuration phase)
:aoeu
(2) during  (run in execution phase as last statement)
:publish
(3) after  (run in execution phase as FORST statement - before doLast/<<)
(4) after  (run in execution phase as last statement)

C:\>gradle publish
:publish
(1) after  (run in execution phase as FORST statement - before doLast/<<)
(2) during  (run in execution phase as last statement)
(3) after  (run in execution phase as last statement)

C:\>gradle publish
:publishInit
(1)
:aoeu
(2)
:publish
(3)

它会回来的

C:\>gradle publish
(1) before (run in configuration phase)
:aoeu
(2) during  (run in execution phase as last statement)
:publish
(3) after  (run in execution phase as FORST statement - before doLast/<<)
(4) after  (run in execution phase as last statement)

C:\>gradle publish
:publish
(1) after  (run in execution phase as FORST statement - before doLast/<<)
(2) during  (run in execution phase as last statement)
(3) after  (run in execution phase as last statement)

C:\>gradle publish
:publishInit
(1)
:aoeu
(2)
:publish
(3)

如果要递归添加依赖项，请执行以下操作：

def recursivelyAddDependsOn(Task parent, Task dependsOn) {
    if (!parent.equals(dependsOn)) {
        parent.dependsOn(dependsOn)

        def tasks = parent.dependsOn.findAll { dependency ->
            dependency instanceof Task
        }
        tasks.each { task ->
            recursivelyAddDependsOn(task, dependsOn)
        }
    }
}

recursivelyAddDependsOn(publish, snth)

更实用的解决方案是：

def recursivelyApplyToTaskDependencies(Task parent, Closure closure) {
    closure(parent)

    parent.dependsOn.findAll { dependency ->
        dependency instanceof Task
    }.each { task ->
        recursivelyApplyToTaskDependencies(task, closure)
    }
}

def recursivelyAddTaskDependency(Task parent, Task dependency) {
    def addTaskDependency = { p ->
        if (!p.name.equals(dependency.name)) {
            p.dependsOn(dependency)
        }
    }

    recursivelyApplyToTaskDependencies(parent, addTaskDependency)
}

recursivelyAddTaskDependency(publish, snth)

排序任务是件令人头痛的事，
因此可以将
之前的
放入
发布
配置中。我希望尽量减少
之前
和
期间
之间的时间。在执行阶段，是否有一种替代方法可以允许在执行阶段的
期间
之前发生
before
。但是请记住调用
execute（）
是错误的。我记得它将在Gradle2.0API中删除（但我不确定）。为什么不能只使用依赖项？奇怪的是，您想在另一个任务中调用task。尝试重构您的构建。如果要在另一个任务中间调用它，只需将另一个任务分为两个单独的任务。引用邮件列表文章：“每个任务都有一个操作序列，这些操作按照任务执行时指定的顺序运行….doFirst（）方法将任务配置为在序列的开头添加一个操作。doLast（）现在“

def recursivelyAddDependsOn(Task parent, Task dependsOn) {
    if (!parent.equals(dependsOn)) {
        parent.dependsOn(dependsOn)

        def tasks = parent.dependsOn.findAll { dependency ->
            dependency instanceof Task
        }
        tasks.each { task ->
            recursivelyAddDependsOn(task, dependsOn)
        }
    }
}

recursivelyAddDependsOn(publish, snth)

def recursivelyApplyToTaskDependencies(Task parent, Closure closure) {
    closure(parent)

    parent.dependsOn.findAll { dependency ->
        dependency instanceof Task
    }.each { task ->
        recursivelyApplyToTaskDependencies(task, closure)
    }
}

def recursivelyAddTaskDependency(Task parent, Task dependency) {
    def addTaskDependency = { p ->
        if (!p.name.equals(dependency.name)) {
            p.dependsOn(dependency)
        }
    }

    recursivelyApplyToTaskDependencies(parent, addTaskDependency)
}

recursivelyAddTaskDependency(publish, snth)

task publish {
    println "here we go"
}

task task1 {
    println "first"
}

task task2 {
    println "second"
}

task task3 {
    println "third"
}

// task execution order. this executes bottom to top order.
publish.dependsOn task3
task3.dependsOn task2
task2.dependsOn task1

here we go
first
second
third