Propriétés et configuration des tâches
Apprenez à ajouter des propriétés aux tâches personnalisées, à les configurer et à garantir des constructions incrémentielles.
Propriétés et configuration des tâches est une leçon Groovy & Gradle: JVM Automation and Build Engineering gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Groovy & Gradle: JVM Automation and Build Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Groovy & Gradle: JVM Automation and Build Engineering comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
What are Task Properties?
Custom Gradle tasks can be made highly flexible by adding properties. These properties act like variables that allow you to configure a task's behavior from your build.gradle script.
Using properties makes your custom tasks reusable and adaptable to different project needs without having to change their core logic.
Defining Simple Properties
To add a property to a custom task, you simply declare a public field within your task class. For basic types like String, int, or boolean, this is straightforward.
For more advanced scenarios, Gradle also offers dedicated Property types, but we'll start with simple declarations.
Custom Task with a Property
Here's a basic custom task defined directly in build.gradle. It has a message property that will be printed when the task runs. Notice the default value set for the property.
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction
class MyMessageTask extends DefaultTask {
String message = "Default task message"
@TaskAction
void printMessage() {
println "Task says: ${message}"
}
}
task helloWorld(type: MyMessageTask)
Configuring Task Properties
Once a task property is defined, you can easily set its value from your build.gradle file. This is done within the task's configuration block, which allows you to customize the task instance.
Run the example to see how the default message is overridden.
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction
class MyMessageTask extends DefaultTask {
String message = "Default task message"
@TaskAction
void printMessage() {
println "Task says: ${message}"
}
}
task helloWorld(type: MyMessageTask) {
message = "Hello from CoddyKit!"
}
Inputs for Incremental Builds
One of Gradle's most powerful features is incremental builds. This means Gradle can skip tasks if their inputs and outputs haven't changed since the last build, saving a lot of time.
To enable this, you must tell Gradle which properties are considered task inputs. These are properties whose values influence the task's outcome.
Declaring Input Properties
You mark a property as an input using the @Input annotation. Gradle will then track its value. If the value changes between builds, the task will execute. If not, Gradle can mark it as UP-TO-DATE and skip it.
For file or directory inputs, use @InputFile, @InputDirectory, or @InputFiles.
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.TaskAction
class MyInputTask extends DefaultTask {
@Input
String greeting = "Hola!"
@TaskAction
void greet() {
println "Greeting: ${greeting}"
}
}
task sayHello(type: MyInputTask) {
greeting = "Bonjour!"
}
Outputs for Incremental Builds
Equally important are outputs. These are the files or directories that your task creates or modifies during its execution. Gradle also tracks these to determine if a task is up-to-date.
If a task's inputs haven't changed AND its declared outputs are present and valid, Gradle knows the task doesn't need to run again.
Declaring Output Properties
You use annotations like @OutputFile for a single result file or @OutputDirectory for a directory containing results. These tell Gradle where the task's generated artifacts will be stored.
The task will ensure the parent directory exists before writing the file.
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.TaskAction
class MyOutputFileTask extends DefaultTask {
@Input
String content = "Default report content."
@OutputFile
File outputFile = project.file("build/reports/output.txt")
@TaskAction
void generateFile() {
outputFile.parentFile.mkdirs()
outputFile.write(content)
println "Generated: ${outputFile.name}"
}
}
task generateReport(type: MyOutputFileTask) {
content = "Report data for: " + new Date().format("yyyy-MM-dd HH:mm:ss")
}
The Power of Incremental Builds
By correctly declaring both inputs and outputs, you unlock Gradle's powerful incremental build feature. This means your tasks only run when necessary, drastically speeding up build times.
This optimization is crucial for efficient development workflows and robust CI/CD pipelines, ensuring quick feedback and resource savings.
Quick Check on Properties
Imagine you have a custom Gradle task that takes a specific configuration file as an input. Which annotation would you use for the property that defines the path to this single configuration file?
Recap: Task Properties & Incremental Builds
In this lesson, you learned how to add properties to custom tasks, making them configurable and reusable. You also discovered how to mark properties as inputs (e.g., @Input, @InputFile) and outputs (e.g., @OutputFile, @OutputDirectory).
These annotations are key to enabling Gradle's powerful incremental build feature, which significantly speeds up your builds by skipping tasks that are already up-to-date. Keep practicing to master efficient task configuration!
Questions Fréquemment Posées
La leçon « Propriétés et configuration des tâches » est-elle gratuite ?
Oui — le texte complet de « Propriétés et configuration des tâches » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Groovy & Gradle: JVM Automation and Build Engineering, passe à CoddyKit PRO. Le cours Groovy & Gradle: JVM Automation and Build Engineering comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Propriétés et configuration des tâches » ?
Apprenez à ajouter des propriétés aux tâches personnalisées, à les configurer et à garantir des constructions incrémentielles. Tu pratiques Groovy & Gradle: JVM Automation and Build Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Groovy & Gradle: JVM Automation and Build Engineering ?
Aucune expérience préalable n'est requise. Groovy & Gradle: JVM Automation and Build Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Propriétés et configuration des tâches » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Groovy & Gradle: JVM Automation and Build Engineering ?
Oui. Chaque leçon Groovy & Gradle: JVM Automation and Build Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Définition de tâches personnalisées
- Types et actions des tâches
- Propriétés et configuration des tâches
- Tâches incrémentielles et vérifications d’actualisation