gradle Tutoriel
Démarrer avec gradle

Remarques

Gradle Installation

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

Étapes d'installation:

1. Télécharger la distribution Gradle sur le site officiel
2. Déballer 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 pour pouvoir 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 configuration de Gradle actuels

Plus d'informations peuvent être trouvées dans le guide d'utilisation officiel

Installation avec homebrew sur OS X / macOS

Les utilisateurs de homebrew peuvent installer graduellement en cours d'exécution

brew install gradle

Installation avec SdkMan

Les utilisateurs de SdkMan 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

Installer le plugin Gradle pour Eclipse

Voici les étapes à suivre pour installer le plug-in Gradle dans Eclipse:

1. Ouvrez Eclipse et allez dans Aide -> Eclipse Marketplace
2. Dans la barre de recherche, entrez bâtiment 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 du code Groovy à partir d'un fichier build.gradle de projets. Ces tâches peuvent alors être exécutées en utilisant > gradle [taskname] 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 alors exécuter cette tâche en utilisant > gradle hello ou > gradle -q hello . Le -q est utilisé pour supprimer les messages de journal de dégradé afin que seule la sortie de la tâche soit affichée.

Sortie de > gradle -q hello :

> gradle -q hello
Hello world!

Plus sur les tâches

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

Une tâche représente un travail atomique effectué par une construction. Cela peut être la compilation de certaines classes, la création d'un JAR, la génération de Javadoc ou la publication de certaines 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
    }    
}

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

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

Quand nous exécuterons ceci, nous avons:

> gradle -q hello
    Inside task
    added code

Questions sur les dépendances de tâches et la commande examinées ici

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"
        }
    }

Renforcée

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

task hello(type: HelloTask)

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

En outre, 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!'
}

Quand nous exécuterons ceci, nous avons:

> gradle -q oldHello
This is default greeting

> gradle -q newHello
This is not default greeting!

Toutes les questions sur le développement des plug-ins progressifs sur le site officiel