Tipos e ações de tarefas
Explore diferentes tipos de tarefas, defina ações de tarefas e gerencie suas entradas e saídas.
Tipos e ações de tarefas é uma aula grátis de Groovy & Gradle: JVM Automation and Build Engineering no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Groovy & Gradle: JVM Automation and Build Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Groovy & Gradle: JVM Automation and Build Engineering inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
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!
Aprenda Groovy com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 12
- Aulas
- 48
Perguntas Frequentes
A aula “Tipos e ações de tarefas” é grátis?
Sim — o texto completo de “Tipos e ações de tarefas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Groovy & Gradle: JVM Automation and Build Engineering, atualize para CoddyKit PRO. O curso de Groovy & Gradle: JVM Automation and Build Engineering inclui 4 aulas no total.
O que vou aprender em “Tipos e ações de tarefas”?
Explore diferentes tipos de tarefas, defina ações de tarefas e gerencie suas entradas e saídas. Você pratica Groovy & Gradle: JVM Automation and Build Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Groovy & Gradle: JVM Automation and Build Engineering?
Nenhuma experiência prévia é necessária. Groovy & Gradle: JVM Automation and Build Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Tipos e ações de tarefas”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Groovy & Gradle: JVM Automation and Build Engineering?
Sim. Cada aula de Groovy & Gradle: JVM Automation and Build Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Definindo tarefas personalizadas
- Tipos e ações de tarefas
- Propriedades e configuração de tarefas
- Tarefas Incrementais e Verificações de Atualização