Premiers pas avec gradle

Installation progressive

Exigences : Java JDK ou JRE installé (version 7 ou supérieure pour la version Gradle 3.x)

Étapes d’installation :

  1. Téléchargez la distribution Gradle depuis le [site Web officiel][1]
  2. Décompressez le ZIP
  3. Ajoutez la variable d’environnement GRADLE_HOME. Cette variable doit pointer vers les fichiers décompressés de l’étape précédente.
  4. Ajoutez GRADLE_HOME/bin à votre variable d’environnement PATH, afin que vous puissiez exécuter Gradle à partir de l’interface de ligne de commande (CLI)
  5. Testez votre installation Gradle en tapant gradle -v dans la CLI. La sortie doit contenir la version de Gradle installée et les détails de la configuration actuelle de Gradle

Plus d’informations peuvent être trouvées dans le [guide de l’utilisateur officiel][2]

[1] : https://gradle.org/gradle-download/ [2] : https://docs.gradle.org/current/userguide/installation.html

Installation avec homebrew sur OS X / macOS

Les utilisateurs de [homebrew][1] peuvent installer gradle en exécutant

brew install gradle

[1] : http://brew.sh

Installation avec SdkMan

Les utilisateurs de [SdkMan][1] peuvent installer Gradle en exécutant :

sdk install gradle

Installer une version spécifique

sdk list gradle
sdk install gradle 2.14

Changer de version

sdk use gradle 2.12

[1] : http://sdkman.io

Installer le plugin Gradle pour Eclipse

Voici les étapes nécessaires pour installer le plugin Gradle dans Eclipse :

  1. Ouvrez Eclipse et accédez à Aide -> Eclipse Marketplace
  2. Dans la barre de recherche, entrez buildship et appuyez sur Entrée
  3. Sélectionnez “Buildship Gradle Integration 1.0” et cliquez sur Installer
  4. Dans la fenêtre suivante, cliquez sur Confirmer
  5. Ensuite, acceptez les termes et la licence de l’accord, puis cliquez sur Terminer
  6. Après l’installation, Eclipse devra redémarrer, cliquez sur Oui

Bonjour le monde

Les tâches Gradle peuvent être écrites à l’aide de code Groovy à partir d’un fichier build.gradle de projets. Ces tâches peuvent ensuite être exécutées en utilisant > gradle [nom de la tâche] sur le terminal ou en exécutant la tâche depuis un IDE tel qu’Eclipse.

Pour créer l’exemple Hello World dans gradle, nous devons définir une tâche qui imprimera une chaîne sur la console à l’aide de Groovy. Nous utiliserons printLn de Groovy pour appeler la méthode System.out.printLn de Java pour imprimer le texte sur la console.

build.gradle

task hello {
    doLast {
        println 'Hello world!'
    }
}

Nous pouvons ensuite exécuter cette tâche en utilisant > gradle hello ou > gradle -q hello. Le -q est utilisé pour supprimer les messages du journal de progression afin que seule la sortie de la tâche soit affichée.

Sortie de > gradle -q hello :

> gradle -q hello
Hello world!

En savoir plus sur les tâches

Tout d’abord : l’opérateur << (leftShift) est équivalent à doLast {closure}. À partir de gradle 3.2, il est obsolète. Tout le code de la tâche est écrit dans un build.gradle.

Une tâche représente un travail atomique effectué par un build. Cela peut être la compilation de certaines classes, la création d’un JAR, la génération Javadoc, ou publier des archives dans un référentiel.

Gradle prend en charge deux grands types de tâches : simples et améliorées.

Observons quelques styles de définition de tâche :

task hello {
    doLast{
       //some code
    }    
}

Ou la:

task(hello) {
    doLast{
       //some code
    }    
}

Les tâches ci-dessus sont équivalentes. En outre, vous pouvez fournir des extensions à la tâche, telles que : dependsOn,mustRunAfter, type etc. Vous pouvez étendre la tâche en ajoutant des actions après la définition de la tâche, comme ceci :

task hello {
    doLast{
       println 'Inside task'
    }    
}
hello.doLast {
    println 'added code'
}

Lorsque nous exécuterons ceci, nous aurons :

> gradle -q hello
    Inside task
    added code

Questions sur les dépendances de tâches et la commande examinées [ici] (https://www.wikiod.com/fr/gradle/dependances-des-taches)

Parlons de deux grands types de tâches.

Simple:

Tâches que nous définissons avec une fermeture d’action :

    task hello {
        doLast{
        println "Hello from a simple task"
        }
    }

Amélioré

Enhanced c’est une tâche avec un comportement préconfiguré. Tous les plugins que vous utilisez dans votre projet sont les étendues ou les tâches améliorées. Créons le nôtre et vous comprendrez comment cela fonctionne :

task hello(type: HelloTask)

class HelloTask extends DefaultTask {
    @TaskAction
    def greet() {
        println 'hello from our custom task'
    }
}

De plus, nous pouvons passer des paramètres à notre tâche, comme ceci :

class HelloTask extends DefaultTask {
    String greeting = "This is default greeting"
    @TaskAction
    def greet() {
        println greeting
    }
}

Et à partir de maintenant, nous pouvons réécrire notre tâche comme suit :

   //this is our old task definition style
task oldHello(type: HelloTask) 
   //this is our new task definition style     
task newHello(type: HelloTask) {
    greeting = 'This is not default greeting!'
}

Lorsque nous exécuterons ceci, nous aurons :

> gradle -q oldHello
This is default greeting

> gradle -q newHello
This is not default greeting!

Toutes les questions sur les plugins de développement Gradle sur [site officiel] (https://docs.gradle.org/current/userguide/custom_plugins.html)

Dépendances des tâches →