Dans Gradle, comment déclarer les dépendances communes en un seul endroit ?

Question

Dans Maven, il y a une fonctionnalité très utile qui permet de définir une dépendance dans la balise <dependencyManagement> du POM parent, et faire référence à cette dépendance à partir des modules enfants sans spécifier la version, la portée ou autre.

Quelles sont les alternatives dans Gradle ?

Answer 1

Vous pouvez déclarer des dépendances communes dans un script parent :

ext.libraries = [ // Groovy map literal
    spring_core: "org.springframework:spring-core:3.1",
    junit: "junit:junit:4.10"
]

À partir d'un script enfant, vous pouvez alors utiliser les déclarations de dépendance comme suit :

dependencies {
    compile libraries.spring_core
    testCompile libraries.junit
}

Pour partager les déclarations de dépendances avec des options de configuration avancées, vous pouvez utiliser les éléments suivants DependencyHandler.create :

libraries = [
    spring_core: dependencies.create("org.springframework:spring-core:3.1") {
        exclude module: "commons-logging"
        force = true
    }
]

Plusieurs dépendances peuvent être partagées sous le même nom :

libraries = [
    spring: [ // Groovy list literal
        "org.springframework:spring-core:3.1", 
        "org.springframework:spring-jdbc:3.1"
    ]
]

dependencies { compile libraries.spring } ajoutera alors les deux dépendances en une seule fois.

Le seul élément d'information que vous ne pouvez pas partager de cette manière est la configuration ( portée en termes de Maven) à laquelle une dépendance doit être affectée. Cependant, d'après mon expérience, il est préférable d'être explicite à ce sujet de toute façon.

Answer 2

Depuis Gradle 4.6, les contraintes de dépendance sont suggérées dans la documentation comme moyen d'y parvenir. Depuis https://docs.gradle.org/current/userguide/declaring_dependencies.html#declaring_a_dependency_without_version :

Une pratique recommandée pour les grands projets est de déclarer les dépendances sans version et d'utiliser les contraintes de dépendance pour la déclaration des versions. L'avantage est que les contraintes de dépendance vous permettent de gérer les versions de toutes les dépendances, y compris les dépendances transitives, en un seul endroit.

Dans votre parent build.gradle fichier :

allprojects {
  plugins.withType(JavaPlugin).whenPluginAdded {
    dependencies {
      constraints {
        implementation("com.google.guava:guava:27.0.1-jre")
      }
    }
  }
}

Envelopper le bloc de dépendances avec une vérification pour le plugin Java (...) whenPluginAdded { ) n'est pas strictement nécessaire, mais il permettra de gérer l'ajout d'un projet non-Java à la même construction.

Ensuite, dans un projet gradle enfant, vous pouvez simplement omettre la version :

apply plugin: "java"

dependencies {
  implementation("com.google.guava:guava")
}

Les enfants peuvent toujours choisir de spécifier une version supérieure. Si une version inférieure est spécifiée, elle est automatiquement mise à niveau vers la version de la contrainte.

Answer 3

C'est une réponse tardive, mais vous pourriez aussi vouloir jeter un coup d'œil à.. : http://plugins.gradle.org/plugin/io.spring.dependency-management Il permet d'importer un "bom" maven, et de réutiliser les définitions définies dans le "bom". C'est certainement une aide précieuse lors de la migration progressive de maven vers gradle ! Je l'apprécie en ce moment.

Answer 4

io.spring.gradle:dependency-management-plugin Le plugin a des problèmes avec les nouvelles séries de Gradle 3.x mais est stable pour les séries 2.x. Pour référence, consultez le rapport de bogue Suppression du support pour Gradle 3 #115

En cas de printemps ( principal promoteur de l'utilisation de la nomenclature ) vous risquez de vous retrouver avec :

buildscript {
    repositories {
        mavenLocal()
        jcenter()
    }
    dependencies {
        classpath 'io.spring.gradle:dependency-management-plugin:1.0.0.RELEASE'
    }
}

repositories {
    mavenLocal()
    jcenter()
}

apply plugin: 'java'
apply plugin: 'io.spring.dependency-management'

dependencyManagement {
    imports {
        mavenBom 'io.spring.platform:platform-bom:Athens-SR3'
    }
}

dependencies {
    compile 'org.springframework.boot:spring-boot-starter-web'

    testCompile 'org.springframework.boot:spring-boot-starter-test'
}

Notez que io.spring.platform:platform-bom ont org.springframework.boot:spring-boot-starter-parent comme parent afin qu'il soit compatible avec Spring Boot

Vous pouvez vérifier la résolution réelle des dépendances via :

$ gradle dependencies
$ gradle dependencies --configuration compile
$ gradle dependencies -p $SUBPROJ

$ gradle buildEnvironment
$ gradle buildEnvironment -p $SUBPROJ

ou avec une tâche :

task showMeCache {
    configurations.compile.each { println it }
}

Lire l'article officiel du blog sur la sorcellerie Meilleure gestion des dépendances pour Gradle pour comprendre la raison de l'introduction io.spring.gradle:dependency-management-plugin .

Answer 5

Je préfère créer dépendances_communes.gradle dans le projet Root avec le contenu

buildscript {
ext {
    commonDependencies = [
            redis      : 'redis.clients:jedis:3.6.3',
            lettuce    : 'io.lettuce:lettuce-core:6.1.4.RELEASE'
      ]
   }
}

alors, dans le module racine/sous-module build.gradle

apply from: rootProject.file("common_dependencies.gradle")

dependencies {
    commonDependencies.values().forEach {
        implementation it
    }
}