exclude - gradle module dependency

En Gradle, ¿cómo declaro las dependencias comunes en un solo lugar?

Question

En Maven hay una característica muy útil cuando se puede definir una dependencia en la sección <dependencyManagement> del POM padre, y hacer referencia a esa dependencia desde los módulos secundarios sin especificar la versión o el alcance o lo que sea.

¿Cuáles son las alternativas en Gradle?

Answer 1

Es una respuesta tardía, pero es posible que también desee echarle un vistazo a: http://plugins.gradle.org/plugin/io.spring.dependency-management Proporciona la posibilidad de importar un "bom" maven y reutilizar las definiciones definido en el ''bom''. ¡Sin duda es una gran ayuda al migrar gradualmente de maven a gradle! Disfrutando ahora mismo.

Answer 2

Esta publicación de blog sugiere administrar dependencias y grupos como configuraciones: https://www.javacodegeeks.com/2016/05/manage-dependencies-gradle-multi-project-build.html

No lo he probado, pero parece interesante.

Proyecto raíz build.gradle

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

Subproyecto build.gradle

configurations {
compile.extendsFrom commonsIo
}

Answer 3

Puede declarar dependencias comunes en un script principal:

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

Desde un script secundario, puede usar las declaraciones de dependencia de la siguiente manera:

dependencies {
compile libraries.spring_core
testCompile libraries.junit
}

Para compartir declaraciones de dependencia con opciones de configuración avanzadas, puede usar DependencyHandler.create :

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

Múltiples dependencias se pueden compartir bajo el mismo nombre:

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

dependencies { compile libraries.spring } agregará ambas dependencias a la vez.

La única información que no se puede compartir de esta manera es qué configuración ( alcance en términos de Maven) se debe asignar a una dependencia. Sin embargo, desde mi experiencia, es mejor ser explícito al respecto de todos modos.

Answer 4

Puedes centralizar una dependencia usando el siguiente código:

En 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

En cada módulo agrega a 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}"
}

Answer 5

io.spring.gradle:dependency-management-plugin tiene problemas con la nueva serie Gradle 3.x pero es estable para la serie 2.x. Para referencia, consulte el informe de errores Soporte de caída para Gradle 3 # 115

En caso de Spring ( promotor principal del uso de BOM ) puede terminar con:

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

Tenga en cuenta que io.spring.platform:platform-bom tiene org.springframework.boot:spring-boot-starter-parent como parent por lo que es compatible con Spring Boot

Puede verificar la resolución de dependencia real a través de:

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

o con la tarea:

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

Lea la publicación oficial del blog de Soring Mejor administración de dependencias para que Gradle comprenda el motivo de la introducción de io.spring.gradle:dependency-management-plugin .