Une tâche personnalisée dans Gradle

1. Vue d'ensemble

Dans cet article, nous verrons comment créer une tâche personnalisée dans Gradle . Nous montrerons une nouvelle définition de tâche à l'aide d'un script de construction ou d'un type de tâche personnalisé.

Pour une introduction au Gradle, veuillez consulter cet article. Il contient les bases de Gradle et - ce qui est le plus important pour cet article - l'introduction aux tâches Gradle.

2. Définition de tâche personnalisée dans build.gradle

Pour créer une tâche Gradle simple, nous devons ajouter sa définition à notre fichier build.gradle :

task welcome { doLast { println 'Welcome in the Baeldung!' } } 

L'objectif principal de la tâche ci-dessus est simplement d'imprimer le texte «Bienvenue dans la Baeldung!». Nous pouvons vérifier si cette tâche est disponible en exécutant la commande gradle tasks –all :

gradle tasks --all 

La tâche figure dans la liste sous le groupe Autres tâches :

Other tasks ----------- welcome

Elle peut être exécutée comme n'importe quelle autre tâche Gradle:

gradle welcome 

Le résultat est comme prévu - le "Bienvenue dans la Baeldung!" message.

Remarque: si l'option –all n'est pas définie, les tâches appartenant à la catégorie «Autre» ne sont pas visibles. La tâche Gradle personnalisée peut appartenir à un groupe différent de «Autre» et peut contenir une description.

3. Définir le groupe et la description

Parfois, il est pratique de regrouper les tâches par fonction, afin qu'elles soient visibles sous une seule catégorie. Nous pouvons rapidement définir un groupe pour nos tâches personnalisées, simplement en définissant une propriété de groupe :

task welcome { group 'Sample category' doLast { println 'Welcome on the Baeldung!' } }

Maintenant, lorsque nous exécutons la commande Gradle pour lister toutes les tâches disponibles ( –all option n'est plus nécessaire), nous verrons notre tâche sous un nouveau groupe:

Sample category tasks --------------------- welcome 

Cependant, il est également bénéfique pour les autres de voir de quoi est responsable une tâche. Nous pouvons créer une description contenant de brèves informations:

task welcome { group 'Sample category' description 'Tasks which shows a welcome message' doLast { println 'Welcome in the Baeldung!' } } 

Lorsque nous imprimons une liste des tâches disponibles, la sortie sera la suivante:

Sample category tasks --------------------- welcome - Tasks which shows a welcome message 

Ce type de définition de tâche est appelé définition ad hoc .

Pour aller plus loin, il est avantageux de créer une tâche personnalisable dont la définition peut être réutilisée. Nous verrons comment créer une tâche à partir d'un type et comment rendre une personnalisation disponible pour les utilisateurs de cette tâche.

4. Définissez le type de tâche Gradle dans build.gradle

La tâche «bienvenue» ci-dessus ne peut pas être personnalisée, donc, dans la plupart des cas, elle n'est pas très utile. Nous pouvons l'exécuter, mais si nous en avons besoin dans un autre projet (ou sous-projet), nous devons alors copier et coller sa définition.

Nous pouvons rapidement activer la personnalisation de la tâche en créant un type de tâche . Simplement, un type de tâche est défini dans le script de construction:

class PrintToolVersionTask extends DefaultTask { String tool @TaskAction void printToolVersion() { switch (tool) { case 'java': println System.getProperty("java.version") break case 'groovy': println GroovySystem.version break default: throw new IllegalArgumentException("Unknown tool") } } }

Un type de tâche personnalisé est une simple classe Groovy qui étend DefaultTask - la classe qui définit l'implémentation de tâche standard. Il existe d'autres types de tâches à partir desquels nous pouvons étendre, mais dans la plupart des cas, la classe DefaultTask est le choix approprié.

La tâche PrintToolVersionTask contient une propriété d'outil qui peut être personnalisée par des instances de cette tâche:

String tool 

Nous pouvons ajouter autant de propriétés que nous le souhaitons - gardez à l'esprit qu'il ne s'agit que d'un simple champ de classe Groovy.

De plus, il contient une méthode annotée avec @TaskAction . Il définit ce que fait cette tâche . Dans cet exemple simple, il imprime la version de Java ou Groovy installé - dépend de la valeur de paramètre donnée.

Pour exécuter une tâche personnalisée en fonction du type de tâche créé, nous devons créer une nouvelle instance de tâche de ce type :

task printJavaVersion(type : PrintToolVersionTask) { tool 'java' } 

Les parties les plus importantes sont:

  • notre tâche est de type PrintToolVersionTask , donc lorsqu'elle est exécutée, elle déclenchera l'action définie dans la méthode annotée avec @TaskAction
  • nous avons ajouté une valeur de propriété d'outil personnalisée ( java ) qui sera utilisée par PrintToolVersionTask

Lorsque nous exécutons la tâche ci-dessus, le résultat est comme prévu (dépend de la version Java installée):

> Task :printJavaVersion 9.0.1 

Créons maintenant une tâche qui imprime la version installée de Groovy:

task printGroovyVersion(type : PrintToolVersionTask) { tool 'groovy' } 

Il utilise le même type de tâche que celui défini précédemment, mais il a une valeur de propriété d'outil différente. Lorsque nous exécutons cette tâche, la version Groovy est imprimée:

> Task :printGroovyVersion 2.4.12 

Si nous n'avons pas trop de tâches personnalisées, nous pouvons les définir directement dans le fichier build.gradle (comme nous l'avons fait ci-dessus). Cependant, s'il y en a plus d'un, notre build. Le fichier gradle devient difficile à lire et à comprendre.

Heureusement, Gradle propose des solutions pour cela.

5. Définissez le type de tâche dans le dossier buildSrc

We can define task types in the buildSrc folder which is located at the root project level. Gradle compiles everything that is inside and adds types to the classpath so our build script can use it.

Our task type which we defined before (PrintToolVersionTask) can be moved into the buildSrc/src/main/groovy/com/baeldung/PrintToolVersionTask.groovy. We have to only add some imports from Gradle API into a moved class.

We can define an unlimited number of tasks types in the buildSrc folder. It's easier to maintain, read, and the task type declaration isn't in the same place as the task instantiation.

We can use these types the same way we're using types defined directly in the build script. We have to remember only to add appropriate imports.

6. Define Task Type in the Plugin

We can define a custom task types inside a custom Gradle plugin. Please refer to this article, which describes how to define a custom Gradle plugin, defined in the:

  • build.gradle file
  • buildSrc folder as other Groovy classes

These custom tasks will be available for our build when we define a dependency to this plugin. Please note that ad-hoc tasks are also available – not only custom task types.

7. Conclusion

Dans ce didacticiel, nous avons expliqué comment créer une tâche personnalisée dans Gradle. Il existe de nombreux plugins disponibles que vous pouvez utiliser dans votre fichier build.gradle qui fourniront de nombreux types de tâches personnalisées dont vous avez besoin.

Comme toujours, des extraits de code sont disponibles à l'adresse over sur Github.