Task Types & Actions
Explore different task types, define task actions, and manage task inputs and outputs.
Task Types & Actions is a free Groovy & Gradle: JVM Automation and Build Engineering lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Groovy & Gradle: JVM Automation and Build Engineering learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Tasks: Types & Actions Intro
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.
What are Task Actions?
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.
Simple Task Action Example
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.
task helloAction {
doLast {
println 'Hello from a Gradle action!'
}
}doFirst vs doLast Explained
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.
doFirst & doLast in Action
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.
task orderedActions {
doLast { println 'Action C: This is the main action (doLast).' }
doFirst { println 'Action B: This runs before everything.' }
doLast { println 'Action D: Another action at the end.' }
println 'Action A: This runs during configuration phase.'
}Built-in Task Types
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.
Example: The `Copy` Task Type
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.
task copyMyFile(type: Copy) {
from '.' // Source directory (project root)
include 'my_document.txt' // File to copy
into 'build/backup' // Destination directory
}Example: The `JavaExec` Task Type
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:
// In build.gradle
apply plugin: 'java'
repositories {
mavenCentral()
}
task runMyJavaApp(type: JavaExec) {
classpath sourceSets.main.runtimeClasspath
mainClass = 'MyApp' // Your main class name
args 'Hello', 'World' // Optional arguments
}
// A sample src/main/java/MyApp.java file:
// public class MyApp {
// public static void main(String[] args) {
// System.out.println("Args: " + String.join(", ", args));
// }
// }Task Inputs: The 'What It Needs'
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: The 'What It Produces'
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.
Quick Check: Action Order
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?
Recap: Master Your Tasks!
Great job! You've explored deeper into Gradle tasks.
- We defined task actions using
doFirstanddoLastto control execution order. - You saw how to leverage powerful built-in task types like
CopyandJavaExec. - 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!
Frequently asked questions
Is the “Task Types & Actions” lesson free?
Yes — the full text of “Task Types & Actions” is free to read here on the web, and the Groovy & Gradle: JVM Automation and Build Engineering course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Groovy & Gradle: JVM Automation and Build Engineering course, upgrade to CoddyKit PRO.
What will I learn in “Task Types & Actions”?
Explore different task types, define task actions, and manage task inputs and outputs. You practise Groovy & Gradle: JVM Automation and Build Engineering with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Groovy & Gradle: JVM Automation and Build Engineering?
No prior experience is required. Groovy & Gradle: JVM Automation and Build Engineering on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Task Types & Actions” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Groovy & Gradle: JVM Automation and Build Engineering lesson?
Yes. Every Groovy & Gradle: JVM Automation and Build Engineering lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.