Gradle est un outil de constructino de projets comparable à Apache Maven, mais conçu pour offrir davantage de flexibilité, de performance et de contrôle sur la gestion des dépendances.

Fonctionnalités clés

• Extensibilité : Gradle repose sur un modèle ouvert qui permet d’adapter le processus de build à presque tous les types de projets, y compris ceux en C/C++.
• Performance : Grâce à des mécanismes comme le cache incrémental et le daemon, Gradle peut être jusqu’à 100 fois plus rapide que Maven dans certains scénarios.
• Gestion fine des dépendances : Il permet de définir des configurations personnalisées (comme implementation, api, etc.), ce qui améliore la modularité et réduit les temps de build.

Concepts fondamentaux

1. Projet : Un projet Gradle représente une unité logicielle (application, bibliothèque). Il peut être simple (un seul module) ou multi-modules (un projet racine avec plusieurs sous-projets).
2. Dépendances : Les dépendances externes sont déclarées dans les scripts de build et résolues automatiquement par Gradle depuis des dépôts comme Maven Central.
3. Scripts de build : Écrits en Groovy DSL ou Kotlin DSL, ces fichiers (build.gradle ou build.gradle.kts) définissent la configuration du projet et ses tâches.
4. Tâches (tasks) : Unités d’exécution atomiques (ex. : compilation, tests, packaging). Chaque tâche peut dépendre d’autres tâches.
5. Plugins : Modules qui étendent les capacités de Gradle en ajoutant des tâches prédéfinies ou des conventions (ex. : plugin Java, plugin application).

Structure typique d’un projet Gradle

mon-projet/
├── .gradle/                     # Cache spécifique au projet
├── gradle/
│   ├── libs.versions.toml       # Gestion centralisée des versions
│   └── wrapper/
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew                      # Script Linux/macOS
├── gradlew.bat                  # Script Windows
├── settings.gradle              # Définit les sous-projets
├── app/
│   ├── src/
│   │   ├── main/
│   │   └── test/
│   └── build.gradle             # Configuration du module
└── build/                       # Résultats de la compilation

Répertoires utilisés par Gradle

Répertoire utilisateur (GRADLE_USER_HOME) : Par défaut ~/.gradle (Linux/macOS) ou C:\Users\<USER>\.gradle (Windows). Il contient :

• caches/ : artefacts téléchargés, métadonnées de dépendances
• daemon/ : processus longue durée pour accélérer les builds
• wrapper/ : distributions téléchargées via Gradle Wrapper

Répertoire racine du projet : Contient le code source, les scripts de build et les artefacts générés.

Mise en œuvre pratique

Initialisation d’un projet Java

Pour créer un projet Java avec Gradle (DSL Groovy) :

mkdir demo-gradle && cd demo-gradle
gradle init --type java-application --dsl groovy

Lors de l’exécution, Gradle utilise le Wrapper. Si le fichier gradle-x.x-bin.zip n’est pas présent localement, il tente de le télécharger. En cas de restriction réseau, placez manuellement l’archive dans :

$GRADLE_USER_HOME/wrapper/dists/gradle-x.x-bin/<hash>/

Ajout d’un nouveau module

Pour ajouter un module nommé client, créez un dossier client à la racine, puis modifiez settings.gradle :

rootProject.name = 'demo-gradle'
include 'app'
include 'client'

Gestion des dépendances via libs.versions.toml

Déclarez les versions et bibliothèques dans gradle/libs.versions.toml :

[versions]
okhttp = "4.12.0"

[libraries]
okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }

Puis référencez-les dans client/build.gradle :

dependencies {
    implementation libs.okhttp
}

Utilisation de plugins

Plugin Java – pour générer un JAR exécutable :

plugins {
    id 'java'
}

jar {
    manifest {
        attributes 'Main-Class': 'com.example.Main'
    }
    from {
        configurations.runtimeClasspath.files.collect { zipTree(it) }
    }
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

Plugin Appplication – pour créer une distribution exécutable :

plugins {
    id 'application'
}

application {
    mainClass = 'com.example.Main'
}

Exécutez ./gradlew distZip pour générer une archive dans build/distributions/.

Notes importantes

La compatibilité entre les versions de Gradle et celles de Java est stricte. Consultez toujours la documentation officielle correspondant à votre version (ex. : Gradle 8.5). La documentation en chinois ne précise souvent pas les versions, ce qui peut entraîner des erreurs de configuraton.