vlambda博客
学习文章列表

// Assign value to description property. 
project.description = 'Simple project' 
 
// DSL to create a new task using 
// Groovy << operator. 
task simple << { 
    println 'Running simple task for project ' + 
      project.description 
} 

:simple
Running simple task for project Simple project
BUILD SUCCESSFUL
Total time: 0.57 secs

// Use setDescription method 
// to assign value instead of 
// Groovy assignment. 
project.setDescription('Simple project') 
 
// Use create method to add new 
// task instead of Groovy << operator. 
project.getTasks().create('simple') { 
    println 'Running simple task for project ' + 
      project.description 
} 

task first { 
    doFirst { 
        println 'Running first' 
    } 
} 
 
task second { 
    doLast { Task task -> 
        println "Running ${task.name}" 
    } 
} 
 
// Here we use the << operator 
// as synonym for the doLast method. 
task third << { taskObject -> 
    println 'Running ' + taskObject.name 
} 

$ gradle first second third
:first
Running first
:second
Running second
:third
Running third
BUILD SUCCESSFUL
Total time: 0.592 secs

task second { 
    doLast { 
        // Using implicit 'it' closure parameter. 
        // The type of 'it' is a Gradle task. 
        println "Running ${it.name}" 
    } 
} 

task second { 
    doLast { Task task -> 
        // Using explicit name 'task' as closure parameter. 
        // We also defined the type of the parameter. 
        // This can help the IDE to add code completion. 
        println "Running ${task.name}" 
    } 
} 

task numbers << { 
    // To define a range of numbers 
    // we can use the following syntax: 
    // start..end. 
    // The each method executes the code 
    // in the closure for each element 
    // in a collection, like a range. 
    (1..4).each { number -> 
        // def is short for define. 
        // Used to define a variable without 
        // an explicit type of the variable. 
        def squared = number * number 
 
        // Use GString with ${} expression 
        // to get a new string value where 
        // the value references are replaced 
        // with the actual values. 
        println "Square of ${number} = ${squared}" 
    } 
} 
 
task list { 
    doFirst { 
        // Simple notation to define a list of values 
        // in Groovy using square brackets. 
        def list = ['Groovy', 'Gradle'] 
 
        // Groovy makes working with collections 
        // easy and adds utility methods to work 
        // with elements in the collection. 
        // The collect method transform each element 
        // in the original collection with the return 
        // value of the closure. Here all string elements 
        // are turned into lower case values. 
        // The join method joins all elements separated by 
        // the given character. The end result is 
        // groovy&gradle 
        println list.collect { it.toLowerCase() }.join('&') 
    } 
} 

$ gradle -q numbers list
Square of 1 = 1
Square of 2 = 4
Square of 3 = 9
Square of 4 = 16
groovy&gradle

task first << { task -> 
    println "Run ${task.name}" 
} 
 
task second << { task -> 
    println "Run ${task.name}" 
} 
 
// Define dependency of task second on task first 
second.dependsOn 'first' 

$ gradle second
:first
Run first
:second
Run second
BUILD SUCCESSFUL
Total time: 0.583 secs

task first << { task -> 
    println "Run ${task.name}" 
} 
 
task second << { task -> 
    println "Run ${task.name}" 
} 
 
// Use property syntax to define dependency. 
// dependsOn expects a collection object. 
second.dependsOn = ['first'] 
 
// Define dependsOn when we create the task. 
task third(dependsOn: 'second') << { task -> 
    println "Run ${task.name}" 
} 

$ gradle -q third
Run first
Run second
Run third

task third(dependsOn: 'second') << { task -> 
    println "Run ${task.name}" 
} 
 
task second(dependsOn: 'first') << { task -> 
    println "Run ${task.name}" 
} 
 
task first << { task -> 
    println "Run ${task.name}" 
} 

// We assign the task closure 
// to a variable. We can reuse 
// the variable name in our task definitions. 
def printTaskName = { task -> 
    println "Run ${task.name}" 
} 
 
// We use the variable with the closure. 
task third(dependsOn: 'second') << printTaskName 
 
task second(dependsOn: 'first') << printTaskName 
 
task first << printTaskName 

$ gradle first

defaultTasks 'first', 'second' 
 
task first { 
    doLast { 
        println "I am first" 
    } 
} 
 
task second { 
    doFirst { 
        println "I am second" 
    } 
} 

$ gradle
:first
I am first
:second
I am second
BUILD SUCCESSFUL
Total time: 0.558 secs

defaultTasks 'second' 
 
task first << { 
    println "I am first" 
} 
 
task second(dependsOn: first) << { 
    println "I am second" 
} 

$ gradle -q tasks
------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------
Default tasks: second
Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]
Help tasks
----------
components - Displays the components produced by root project 'organize'. [incubating]
dependencies - Displays all dependencies declared in root project 'organize'.
dependencyInsight - Displays the insight into a specific dependency in root project 'organize'.
help - Displays a help message.
model - Displays the configuration model of root project 'organize'. [incubating]
projects - Displays the sub-projects of root project 'organize'.
properties - Displays the properties of root project 'organize'.
tasks - Displays the tasks runnable from root project 'organize'.
Other tasks
-----------
second
To see all tasks and more detail, run gradle tasks --all
To see more detail about a task, run gradle help --task <task>

$ gradle tasks --all
...
Other tasks
-----------
second
 first

Default tasks: second

task 'simple' << { task -> 
    println "Running ${task.name}" 
} 

// Define name of task 
// as a variable. 
def simpleTask = 'simple' 
 
// Variable is used for the task name. 
task(simpleTask) << { task -> 
    println "Running ${task.name}" 
} 

$ gradle -q tasks
...
Other tasks
-----------
simple
...

// Name of task as variable. 
def simpleTask = 'simple' 
 
// Using Groovy GString with 
// ${} expression to use variable 
// as task name. 
task "${simpleTask}" << { task -> 
    println "Running ${task.name}" 
} 
 
// Or use loops to create multiple tasks. 
['Dev', 'Acc', 'Prod'].each { environment -> 
    // A new task is created for each element 
    // in the list ['Dev', 'Acc', 'Prod']. 
    task "deployTo${environment}" << { task -> 
        println "Deploying to ${environment}" 
    } 
} 

$ gradle -q tasks
...
Other tasks
-----------
deployToAcc
deployToDev
deployToProd
simple
...

def printTaskName = { task -> 
    println "Running ${task.name}" 
} 
 
// Use tasks project variable to get access 
// to the TaskContainer object. 
// Then we use the create method of 
// TaskContainer to create a new task. 
project.tasks.create(name: 'first') << printTaskName 
 
// Let Gradle resolve tasks to project variable. 
tasks.create(name: 'second', dependsOn: 'first') << printTaskName 

// Create a simple task. 
task simple << { task -> 
    println "Running ${task.name}" 
} 
 
// The simple task is available as 
// project property. 
simple.description = 'Print task name' 
 
// We can invoke methods from the 
// Task object. 
simple.doLast { 
    println "Done" 
} 
 
// We can also reference the task 
// via the project property 
// explicitly. 
project.simple.doFirst { 
    println "Start" 
} 

$ gradle -q simple
Start
Running simple
Done

// Create simple task. 
task simple << { 
    println "Hello ${message}" 
} 
 
// We set the value for 
// the non-existing message 
// property with the task extension 
// support. 
simple.ext.message = 'world' 

:simple
Hello world
BUILD SUCCESSFUL
Total time: 0.584 secs

def printTaskName = { task -> 
    println "Running ${task.name}" 
} 
 
task 'one' { 
    // Invoke doFirst method to add action. 
    doFirst printTaskName 
} 
 
// Assign action through left-shift operator (<<). 
task 'two' << printTaskName 
 
task 'three' { 
    // This line will be displayed during configuration 
    // and not when we execute the task, 
    // because we use the configuration closure 
    // and forgot the << operator. 
    println "Running three" 
} 
 
defaultTasks 'one', 'two'