Question

在Maven中有一个非常有用的功能，您可以在父POM的<dependencyManagement>部分中定义依赖项，并在不指定版本或范围或其他任何内容的情况下从子模块引用该依赖项。

Gradle有哪些替代方案？

Answer 1

您可以在父脚本中声明公共依赖项：

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

然后，您可以从子脚本中使用依赖性声明，如下所示：

dependencies {
    compile libraries.spring_core
    testCompile libraries.junit
}

要与高级配置选项共享依赖性声明，您可以使用DependencyHandler.create：

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

可以使用相同的名称共享多个依赖项：

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

然后

dependencies { compile libraries.spring }会立即添加两个依赖项。

您无法以这种方式共享的一条信息是应该为其分配依赖项的配置（Maven术语中的范围）。但是，根据我的经验，最好还是要明确这一点。

Answer 2

这是一个迟到的回复，但您可能还想查看：http://plugins.gradle.org/plugin/io.spring.dependency-management 它提供了导入maven＆＃39; bom的可能性，并重复使用＆＃39; bom＆＃39;中定义的定义。当逐渐从maven迁移到gradle时，它确实是一个很好的帮助！现在享受它。

Answer 3

从Gradle 5.0（或更早的版本）开始，文档中建议使用依赖项约束来实现此目的。来自https://docs.gradle.org/current/userguide/declaring_dependencies.html#declaring_a_dependency_without_version：

对于较大的项目，建议的做法是声明没有版本的依赖项，并将依赖项约束用于版本声明。优点是，依赖关系约束使您可以在一处管理所有依赖关系的版本，包括可传递的依赖关系。

在您的父build.gradle文件中：

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

严格地检查Java插件（... whenPluginAdded {）来包装依赖项块，但是它将处理将非Java项目添加到同一内部版本。

然后在一个gradle项目中，您可以简单地省略版本：

apply plugin: "java"

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

子版本仍可以选择指定更高版本。如果指定了较低的版本，它将自动升级到约束中的版本。

Answer 4

io.spring.gradle:dependency-management-plugin插件新Gradle 3.x系列存在问题但2.x系列稳定。如需参考，请查看错误报告Drop support for Gradle 3 #115

如果是春天（main promoter of BOM usage），你可以结束：

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

请注意io.spring.platform:platform-bom有org.springframework.boot:spring-boot-starter-parent作为父级，因此它与Spring Boot兼容

您可以通过以下方式验证实际依赖项解析：

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

$ gradle buildEnvironment
$ gradle buildEnvironment -p $SUBPROJ

或任务：

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

阅读官方Soring博文Better dependency management for Gradle，了解引入io.spring.gradle:dependency-management-plugin的原因。

Answer 5

此博客文章建议将依赖关系和组作为配置进行管理： https://www.javacodegeeks.com/2016/05/manage-dependencies-gradle-multi-project-build.html

我自己没试过，但看起来很有趣。

根项目build.gradle

subprojects {
  configurations {
    commonsIo
  }

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

子项目build.gradle

configurations {
  compile.extendsFrom commonsIo
}

Answer 6

您可以使用以下代码集中依赖关系：

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

在每个模块中添加 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 7

为了使您的gradle文件保持干净，我们可以将依赖项分组到一个数组中，并在以后实现。

在依赖项块之外的 build.gradle（应用程序级别）中添加类似版本的库：

//声明库的版本

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

创建一个相关依赖项数组，以便以后可以轻松找到它。将其添加到依赖项块之外的 build.gradle（应用程序级别）：

///在库中使用版本并添加依赖项和访问权限名称（如翻新（第一个））

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()
}

最终代码如下所示：

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()
}

Answer 8

我更喜欢在包含内容的根项目中创建 common_dependencies.gradle 文件

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

然后在根/子模块的build.gradle

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

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

在Gradle中，如何在一个地方声明公共依赖项？

8 个答案: