Gradle Goodness: Working with Live Task Collection-优快云博客

本文介绍如何在Gradle中定义动态任务集合，利用filter()和matching()方法创建只在特定条件下的任务集合。通过这些集合，可以实现任务的动态添加和依赖，提升构建过程的灵活性。

Gradle support the definition of so called live collections. These collections are mostly created based on criteria like with a filter() or matching() method. The collection content can change if the content of the source collection changes. For example the org.gradle.api.DomainObjectCollection interface has a matching method that returns a live collection. The list of tasks in a project implements this interface so we can have a live collection of tasks that match a certain criteria.

The nice thing about the live collection of tasks is that we can add tasks to the project after we have defined the task collection and they will be included in the collection. Normally if we would access the list of tasks in a project and use for example a findAll method than the returned list of tasks will not change. So if we add a new task to the project it will not be added to the list of task that apply to the condition of the findAll method.

Now if we use the matching() method on a list of tasks the result will be a live list of tasks. Even if we add tasks to the project after the definition of the list of tasks, they will be added to the collection.

Let's see the following Gradle build file that defines the tasks allCompile and allCopy. Each task has dependencies on other tasks. We use the dependsOn() method of a task to set those dependencies. The dependsOn() method accepts a collection of other tasks. For the allCompile task we don't use a live collection and for the allCopy task we use a live collection.

    00.
    task allCompile << {
   
    01.
    println 'All is compiled.'
   
    02.
    }
   
    03.
    allCompile.dependsOn project.tasks.findAll {
   
    04.
    it.name.startsWith('compile')
   
    05.
    }
   
    06.
     
    07.
    task allCopy << {
   
    08.
    println 'Everything is copied.'
   
    09.
    }
   
    10.
    // Set dependencies with live collection of tasks.
   
    11.
    allCopy.dependsOn project.tasks.matching {
   
    12.
    it.name.startsWith('copy')
   
    13.
    }
   
    14.
     
    15.
    // Add dependency tasks.
   
    16.
    5.times {
   
    17.
    // Dependencies for compileAll task.
   
    18.
    task "compile${it}" << { println 'Compile the code.' }
   
    19.
     
    20.
    // Dependencies for copyAll task.
   
    21.
    task "copy${it}" << { println 'Copy something.' }
   
    22.
    }

If we run the build script we get the following output:

    $ gradle allCompile allCopy
   
    :allCompile
   
    All is compiled.
   
    :copy0
   
    Copy something.
   
    :copy1
   
    Copy something.
   
    :copy2
   
    Copy something.
   
    :copy3
   
    Copy something.
   
    :copy4
   
    Copy something.
   
    :allCopy
   
    Everything is copied.
   
    BUILD SUCCESSFUL
   
    Total time: 2.232 secs

We notice the allCompile tasks doesn't have any dependencies, because those task dependencies didn't exist when we used the dependsOn() method. The allCopy task has all task dependencies even though we created them later in the build script.

Bonus: we can use the findAll method to look for task dependencies, but we have to let Gradle evaluate this condition in a closure. So we can change our build script and use a closure with the dependsOn() method. Gradle will invoke the closure at execution time and not a configuration time. The dependencies tasks are then available and assigned as dependencies to the allCompile task:

    00.
    task allCompile << {
   
    01.
    println 'All is compiled.'
   
    02.
    }
   
    03.
    // Use closure for resolving task dependencies.
   
    04.
    allCompile.dependsOn {
   
    05.
    project.tasks.findAll {
   
    06.
    it.name.startsWith('compile')
   
    07.
    }
   
    08.
    }
   
    09.
     
    10.
    task allCopy << {
   
    11.
    println 'Everything is copied.'
   
    12.
    }
   
    13.
    // Set dependencies with live collection of tasks.
   
    14.
    allCopy.dependsOn project.tasks.matching {
   
    15.
    it.name.startsWith('copy')
   
    16.
    }
   
    17.
     
    18.
    // Add dependency tasks.
   
    19.
    5.times {
   
    20.
    // Dependencies for compileAll task.
   
    21.
    task "compile${it}" << { println 'Compile the code.' }
   
    22.
     
    23.
    // Dependencies for copyAll task.
   
    24.
    task "copy${it}" << { println 'Copy something.' }
   
    25.
    }

If we invoke both tasks with Gradle we get the following output:

    :compile0
   
    Compile the code.
   
    :compile1
   
    Compile the code.
   
    :compile2
   
    Compile the code.
   
    :compile3
   
    Compile the code.
   
    :compile4
   
    Compile the code.
   
    :allCompile
   
    All is compiled.
   
    :copy0
   
    Copy something.
   
    :copy1
   
    Copy something.
   
    :copy2
   
    Copy something.
   
    :copy3
   
    Copy something.
   
    :copy4
   
    Copy something.
   
    :allCopy
   
    Everything is copied.
   
    BUILD SUCCESSFUL
   
    Total time: 2.258 secs