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

Dans Maven, il existe une fonctionnalité très utile lorsque vous pouvez définir une dépendance dans la <dependencyManagement>section du POM parent et référencer cette dépendance à partir de modules enfants sans spécifier la version ou la portée ou autre.

Quelles sont les alternatives à Gradle?

Vous pouvez déclarer des dépendances courantes 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 ensuite utiliser les déclarations de dépendance comme ceci:

dependencies {
    compile libraries.spring_core
    testCompile libraries.junit
}

Pour partager des déclarations de dépendance avec des options de configuration avancées, vous pouvez utiliser 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 ensuite les deux dépendances à la fois.

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

C'est une réponse tardive, mais vous voudrez peut-être aussi jeter un œil à: http://plugins.gradle.org/plugin/io.spring.dependency-management Il offre la possibilité d'importer un maven 'bom' et de réutiliser les définitions défini dans le «bom». C'est certainement une aide précieuse lors de la migration progressive de maven à gradle! Profiter maintenant.

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 projets plus volumineux consiste à déclarer des dépendances sans versions et à utiliser des contraintes de dépendance pour la déclaration de version. L'avantage est que les contraintes de dépendance vous permettent de gérer les versions de toutes les dépendances, y compris celles transitives, en un seul endroit.

Dans votre build.gradledossier parent :

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

Enveloppant le bloc de dépendances avec une vérification du plugin Java (... whenPluginAdded {) n'est pas strictement nécessaire, mais cela gérera alors 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 versions 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.

io.spring.gradle:dependency-management-pluginLe plugin a des problèmes avec la nouvelle série Gradle 3.x mais stable pour la série 2.x. Pour référence, regardez le rapport de bogue Drop support pour Gradle 3 # 115

En cas de Spring ( principal promoteur de l'utilisation de la nomenclature ), vous pouvez terminer par:

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-bomhave org.springframework.boot:spring-boot-starter-parentcomme parent donc il est 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 tâche:

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

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

Vous pouvez centraliser une dépendance en utilisant le code ci-dessous:

Dans gradle.properties

COMPILE_SDK_VERSION=26
BUILD_TOOLS_VERSION=26.0.1
TARGET_SDK_VERSION=26
MIN_SDK_VERSION=14

ANDROID_SUPPORT_VERSION=26.0.2

Dans chaque module, ajoutez à build.gradle:

android {
    compileSdkVersion COMPILE_SDK_VERSION as int
    buildToolsVersion BUILD_TOOLS_VERSION as String

    defaultConfig {
        minSdkVersion MIN_SDK_VERSION as int
        targetSdkVersion TARGET_SDK_VERSION as int
        versionCode 1
        versionName "1.0"

    }

}

dependencies {
 compile "com.android.support:appcompat-v7:${ANDROID_SUPPORT_VERSION}"
 compile "com.android.support:support-v4:${ANDROID_SUPPORT_VERSION}"
 compile "com.android.support:support-annotations:${ANDROID_SUPPORT_VERSION}"
 compile "com.android.support:support-vector-drawable:${ANDROID_SUPPORT_VERSION}"
 compile "com.android.support:design:${ANDROID_SUPPORT_VERSION}"
}

Cet article de blog suggère de gérer les dépendances et les groupes en tant que configurations: https://www.javacodegeeks.com/2016/05/manage-dependencies-gradle-multi-project-build.html

Je ne l'ai pas essayé moi-même, mais cela semble intéressant.

Projet racine build.gradle

subprojects {
  configurations {
    commonsIo
  }

  dependencies {
    commonsIo 'commons-io:commons-io:2.5'
  }
}

Sous-projet build.gradle

configurations {
  compile.extendsFrom commonsIo
}

Pour garder votre fichier de gradation propre, nous pouvons regrouper les dépendances dans un tableau et les implémenter plus tard.

1. Ajoutez une version de bibliothèques comme celle-ci dans build.gradle (au niveau de l'application) en dehors du bloc de dépendance :

// déclarer les versions de la bibliothèque

final RetrofitVersion = '2.3.0'
final OkHttpVersion = '3.9.1'

2. Créez un tableau de dépendances associées pour pouvoir le retrouver facilement plus tard. Ajoutez-le dans build.gradle (au niveau de l'application) en dehors du bloc de dépendance :

// Utilisation de la version dans la bibliothèque et ajout de la dépendance avec le nom d'accès (comme retrofit (premier))

final networkDependencies = [
        retrofit             : "com.squareup.retrofit2:retrofit:${RetrofitVersion}",
        retrofitGsonConverter: "com.squareup.retrofit2:converter-gson:${RetrofitVersion}",
        retrofitRxJavaAdapter: "com.squareup.retrofit2:adapter-rxjava2:${RetrofitVersion}",
        okHttp3              : "com.squareup.okhttp3:okhttp:${OkHttpVersion}",
        okHttp3Logging       : "com.squareup.okhttp3:logging-interceptor:${OkHttpVersion}"
]

3. Et dans le bloc de dépendance :

// Implémente toutes les dépendances du tableau

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation networkDependencies.values()
}

Le code final ressemblera donc à ceci:

final RetrofitVersion = '2.3.0'
final OkHttpVersion = '3.9.1'

final networkDependencies = [
        retrofit             : "com.squareup.retrofit2:retrofit:${RetrofitVersion}",
        retrofitGsonConverter: "com.squareup.retrofit2:converter-gson:${RetrofitVersion}",
        retrofitRxJavaAdapter: "com.squareup.retrofit2:adapter-rxjava2:${RetrofitVersion}",
        okHttp3              : "com.squareup.okhttp3:okhttp:${OkHttpVersion}",
        okHttp3Logging       : "com.squareup.okhttp3:logging-interceptor:${OkHttpVersion}"
]

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation networkDependencies.values()
}