Types et actions des tâches

In Gradle, tasks are the core units of work. While Lesson 1 showed how to define basic tasks, this lesson dives deeper into task types and actions.

We'll learn how different task types offer specific functionalities, define what a task actually does using actions, and understand how to manage task inputs and outputs for efficient builds.

A task action is a piece of code that a task executes. Think of it as the 'what to do' part of your task.

You can define actions directly within a task block or using special methods like doLast and doFirst.

• Directly: Code inside doLast { ... } or the task block itself.
• doLast: Executes the action at the very end of the task's execution.
• doFirst: Executes the action at the very beginning of the task's execution.

Let's create a simple Gradle task with an action using doLast. This action will print a message to the console.

Save this as build.gradle and run gradle helloAction.

When a task has multiple actions, their order matters. doFirst actions run before any other actions, while doLast actions run after.

If you define actions directly in the task configuration block (without doFirst/doLast), they are implicitly added as doLast actions.

Observe the execution order in this example. The println outside of doFirst/doLast runs during the configuration phase.

Run gradle orderedActions to see the output.

Gradle isn't just for custom scripts! It provides many powerful built-in task types for common operations like compiling Java code, running tests, or copying files.

These types are classes that extend Gradle's DefaultTask and come with pre-defined properties and behaviors. You configure them instead of writing all the logic from scratch.

The Copy task type is used to copy files and directories. It's much more robust than a simple script for file operations.

To run this, first create an empty file named my_document.txt in your project root. Then execute gradle copyMyFile.

The JavaExec task type is designed to execute a Java application in a separate JVM process.

For this to run, you'd typically have a Java file (e.g., src/main/java/MyApp.java) with a main method. Here's how you'd define the task in build.gradle:

Task inputs are any values, files, or directories that a task uses to perform its work. Gradle tracks these inputs.

If the inputs haven't changed since the last build, Gradle knows it can skip executing the task (making your builds faster!). This is crucial for incremental builds.

For custom task classes (covered in the next lesson), you mark properties with annotations like @Input, @InputFile, or @InputDirectory.

Task outputs are any files or directories a task creates or modifies. Gradle also tracks these.

By declaring outputs (e.g., with @OutputDirectory or @OutputFile for custom task classes), Gradle can cache task results, share them across builds, and properly manage task dependencies.

Understanding inputs and outputs is key to leveraging Gradle's build caching and parallel execution features.

Consider a Gradle task definition:

task myTask {
  doLast { println 'Action C' }
  doFirst { println 'Action B' }
  doLast { println 'Action D' }
  println 'Action A'
}

What is the correct order of output when gradle myTask is run?

Great job! You've explored deeper into Gradle tasks.

• We defined task actions using doFirst and doLast to control execution order.
• You saw how to leverage powerful built-in task types like Copy and JavaExec.
• We also touched upon the importance of declaring task inputs and outputs for incremental builds and caching.

Next, we'll learn how to add properties to custom tasks and configure them for even more flexibility!