執行過程中多次運行同一任務中gradle這個

是否有可能有一些像gradle這個下面執行過程中多次運行同一任務中gradle這個

task enableMe() << { 
    println "Enable" 
} 
task disableMe() << { 
    shouldRunAfter 'taskAwork' 
    println "Disable" 
} 

task taskAwork(){ 
    shouldRunAfter 'enableMe' 
    println "do work in A while disabled" 
} 
task taskA(dependsOn: disableMe, taskAwork, enableMe){ 
} 
task taskBwork(){ 
    shouldRunAfter 'enableMe' 
    println "do work in B while disabled" 
} 
task taskB(dependsOn: disableMe, taskBwork, enableMe){ 
} 

task taskC(dependsOn: taskA, taskB){ 
}

所以它運行時的任務的順序

disableMe 
taskAwork 
enableMe 
disableMe 
taskBwork 
enableMe

執行但目前，disableMe和enableMe只運行一次..有無論如何設置那裏的狀態，以便他們可以再次運行。

我能想到做到這一點的唯一方法是複製任務;

task enableMeA() << { 
    println "Enable" 
} 
task disableMeA() << { 
    shouldRunAfter 'taskAwork' 
    println "Disable" 
} 
task enableMeB() << { 
    println "Enable" 
} 
task disableMeB() << { 
    shouldRunAfter 'taskBwork' 
    println "Disable" 
} 

task taskAwork(){ 
    shouldRunAfter 'enableMeA' 
    println "do work in A while disabled" 
} 
task taskA(dependsOn: disableMeA, taskAwork, enableMeA){ 
} 
task taskBwork(){ 
    shouldRunAfter 'enableMeB' 
    println "do work in B while disabled" 
} 
task taskB(dependsOn: disableMeB, taskBwork, enableMeB){ 
} 

task taskC(dependsOn: taskA, taskB){ 
}

來源

2016-07-26 Ric Ambridge

似乎，在你的情況下，你必須爲你的任務實現TaskExecutionListener，並使用它的beforeExecute和afterExecute方法來實現你的邏輯。

這可能看起來像：

task taskAwork() << { 
    println "do work in A while disabled" 
} 
task taskBwork() << { 
    println "do work in B while disabled" 
} 

task doAllWorkTask(dependsOn: [taskAwork, taskBwork]){ 
} 

gradle.taskGraph.addTaskExecutionListener new WorkTasksExecutionListener() 

class WorkTasksExecutionListener implements TaskExecutionListener { 

    @Override 
    void afterExecute(final Task task, final TaskState state) { 
     if (task.name.contains('work')) { 
      println('Enabling smth before execution of work task') 
     } 
    } 

    @Override 
    void beforeExecute(final Task task) { 
     if (task.name.contains('work')) { 
      println('Disabling smth after execution of work task') 
     } 
    } 
}

這裏指定了2項任務，其中做一些事情，需要一些常見loigic被運行之前各一個。爲了實現這個公共邏輯，使用WorkTasksExecutionListener實現了TaskExecutionListener接口並註冊爲taskGraph中的監聽器。

WorkTasksExecutionListener落實TaskExecutionListener的兩種方法：beforeExecute和afterExecute。這個方法在每個tsk執行之前和之後都會被調用，所以在它的實現中添加了條件來檢查這個任務是否做了一些工作，如果是，那麼執行一些額外的邏輯。

在這種情況下，輸出將是：

:taskAwork 
Enabling smth after execution of work task 
do work in A while disabled 
Disabling smth before execution of work task 
:taskBwork 
Enabling smth after execution of work task 
do work in B while disabled 
Disabling smth before execution of work task 
:doAllWorkTask

來源

2016-07-27 06:57:10 Stanislav

默認情況下，Gradle不會運行任何最新的任務。如果TaskOutputs屬性未被更改，則認爲該任務是最新的。

如果你想在一次執行過程中運行一個任務多次，您可以使用upToDateWhen屬性來定義一個謂詞，將返回假只要你想的任務再次運行：

task myTask() { 
    outputs.upToDateWhen {some_condition} 

    // Do some stuff 
}

來源

2016-07-26 21:24:10 yonisha

執行過程中多次運行同一任務中gradle這個

回答

相關問題