Les concepts fondamentaux de Gradle

La notion de projet

Pour démarrer, nous allons créer un répertoire gradle-project.

Gradle définit la notion de projet. Un projet est un morceau de logiciel qui peut être construit comme une application ou une bibliothèque.

Gradle supporte la notion de projet simple ou de structures multi-projets.

Quand un build Gradle inclut un seul projet, ce projet est appelé projet racine (root project).

La notion de scripts de Build

Les scripts de build détaillent les étapes de construction de votre projet.

Chaque projet peut inclure un ou plusieurs scripts de build.

Dans ce répertoire, créer un fichier build.gradle vide.

Dans les projets professionnels, vous utiliserez gradle init.

La syntaxe des scripts de build

Les scripts de build peuvent être écrits en Kotlinbuild.gradle.kts et Groovy build.gradle.

Un script de build contient généralement les informations suivants :

• des propriétés et autres paramètres
• la déclaration de plugins
• l'arborescence des sous-projets
• la gestion des dépendances
• la déclaration de tâches
• la déclaration d'objets spécifiques à une technologie comme les repositories, les applications, les frameworks de tests, les toolchains...
• du code Kotlin ou Groovy

Ecrire du code dans son script

Le script peut contenir du code Kotlin ou Groovy.

Ajouter le code suivant dans votre script :

def helloworld() {
    println "Voici mon premier script"
}

helloworld()

Pour exécuter le script, lancez le script gradle build

Analyser les logs produits.

La notion de tâches

Gradle fournit de nombreuses tâches par défaut pour un projet, qui sont listées en tapant la commande ./gradlew tasks

Nous allons créer notre première tâche.

Il existe des tâches qui peuvent être actionnées manuellement ( en utilisant gradle , une syntaxe spécifique et le nom de la tâche ) ou bien être attachée au cycle de vie du projet ( lifecycle ).

Ajoutons le code :

tasks.register("hello") {
    group = "Groupe de tâches"
    description = "Notre première tache"
    doLast {
        println("Hello world!")
    }
}

Tapons à nouveau la commande gradle tasks. Que remarquez-vous ?

Pour exécuter la commande, tapez ? gradle :hello.

Pour information, gradle :hello, appelle la tâche hello du projet racine. gradle hello appelle la tâche hello du projet racine et de tous les sous-projets qui supportent cette tâche.

Afficher la documentation de la tâche en tapant :

/gradlew help --task hello

Vérification de la structure du projet

La structure d'un projet Gradle généralement sera la suivante. La présence des scripts gradlew et gradlew.bat sont un bon indicateur que votre projet de développement supporte Gradle.

project
├── gradle
│   ├── libs.versions.toml
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle(.kts)
├── subproject-a
│   ├── build.gradle(.kts)
│   └── src
└── subproject-b
    ├── build.gradle(.kts)
    └── src

Utilisation de la notion de properties

Créer un fichier gradle.properties.

Déclarer une property en utilisant la syntaxe clé=valeur exemple compilationLocation=/tmp

Il est possible de référencer la propriété en utilisant le code suivant dans votre tâche :

En Groovy :

println "L'emplacement du compilateur est " + compilationLocation

println "L'emplacement du compilateur est " + settings.provider.gradleProperty("compilationLocation").get()

println "L'emplacement du compilateur est " + settings[compilationLocation]

En Kotlin :

// Utilisation de l'API gradle, fournit un accesseur paresseux Provider<String>
println(providers.gradleProperty("compilationLocation").get())

// En utilisant le mécanisme de propriétés Kotlin déléguées depuis `settings`
val gradlePropertiesProp: String by settings
println(compilationLocation)

Vérifiez que vous pouvez surcharger la valeur de la propriété en tapant la commande gradle suivante :

gradle -PcompilerLocation=/newvalue :hello

Utilisation des loggers

Une option simple pour vous connecter à votre fichier de build consiste à écrire des messages sur la sortie standard. Gradle redirige tout ce qui est écrit sur la sortie standard vers son système de journalisation au niveau de journalisation QUIET.

println("Un message enregistré au niveau SILENCIEUX")

Gradle fournit également une propriété logger à un script de construction, qui est une instance de Logger. Cette interface étend l'interface SLF4J Logger et y ajoute quelques méthodes spécifiques à Gradle. Vous trouverez ci-dessous un exemple de la façon dont cela est utilisé dans le script de construction :

logger.quiet("Un message du journal d'informations qui est toujours enregistré.")
logger.error("Un message du journal des erreurs.")
logger.warn("Un message du journal d'avertissement.")
logger.lifecycle("Un message du journal d'informations sur le cycle de vie.")
logger.info("Un message du journal d'informations.")
logger.debug("Un message du journal de débogage.")
logger.trace("Un message de journal de trace.") // Gradle n'enregistre jamais les journaux de niveau TRACE

=> Recherchez dans la ligne de commande Gradle, les paramètres pour afficher chaque niveau de log.

Documentation des loggers dans Gradle

Utilisation du fichier settings

Le fichier de paramètres est le point d'entrée de chaque build Gradle.

Le fichier settings.gradle permet de définir :

• la structure des projets
• le nom du projet racine