依赖处理程序

目录

高级依赖配置
依赖符号
特性
方法
脚本块
物业详情
方法详情
API文档：DependencyHandler

ADependencyHandler用于声明依赖关系。依赖关系被分组为配置（请参阅 参考资料Configuration）。

要声明配置的特定依赖项，您可以使用以下语法：

dependencies {
    configurationName dependencyNotation
}

示例显示了声明依赖关系的基本方法。 

plugins {
    id 'java' // so that we can use 'implementation', 'testImplementation' for dependencies
}

dependencies {
  //for dependencies found in artifact repositories you can use
  //the group:name:version notation
  implementation 'commons-lang:commons-lang:2.6'
  testImplementation 'org.mockito:mockito:1.9.0-rc1'

  //map-style notation:
  implementation group: 'com.google.code.guice', name: 'guice', version: '1.0'

  //declaring arbitrary files as dependencies
  implementation files('hibernate.jar', 'libs/spring.jar')

  //putting all jars from 'libs' onto compile classpath
  implementation fileTree('libs')
}

高级依赖配置

要在声明依赖项时对其进行一些高级配置，您还可以传递配置闭包：

dependencies {
    configurationName(dependencyNotation){
        configStatement1
        configStatement2
    }
}

高级依赖声明的示例包括：

  • 在发生冲突的情况下强制使用某些依赖版本。
  • 按名称、组或两者排除某些依赖项。有关每个依赖项排除的更多详细信息可以在ModuleDependency.exclude(java.util.Map).
  • 避免某些依赖关系的传递依赖。
plugins {
    id 'java' // so that I can declare 'implementation' dependencies
}

dependencies {
  implementation('org.hibernate:hibernate') {
    //in case of versions conflict '3.1' version of hibernate wins:
    version {
      strictly('3.1')
    }

    //excluding a particular transitive dependency:
    exclude module: 'cglib' //by artifact name
    exclude group: 'org.jmock' //by group
    exclude group: 'org.unwanted', module: 'iAmBuggy' //by both name and group

    //disabling all transitive dependencies of this dependency
    transitive = false
  }
}

更多高级配置示例，当依赖模块具有多个工件时非常有用： 

plugins {
    id 'java' // so that I can declare 'implementation' dependencies
}

dependencies {
  //configuring dependency to specific configuration of the module
  implementation configuration: 'someConf', group: 'org.someOrg', name: 'someModule', version: '1.0'

  //configuring dependency on 'someLib' module
  implementation(group: 'org.myorg', name: 'someLib', version:'1.0') {
    //explicitly adding the dependency artifact:
    artifact {
      //useful when some artifact properties unconventional
      name = 'someArtifact' //artifact name different than module name
      extension = 'someExt'
      type = 'someType'
      classifier = 'someClassifier'
    }
  }
}

依赖符号

有几种受支持的依赖符号。这些将在下面描述。对于以这种方式声明的每个依赖项，Dependency都会创建一个对象。您可以使用该对象来查询或进一步配置依赖关系。

您还可以直接添加以下实例 Dependency：

configurationName <instance>

还可以使用Provider提供任何其他受支持的依赖关系符号的 来声明依赖关系。

外部依赖

支持两种表示法来声明对外部模块的依赖关系。一种是这样格式化的字符串表示法：

configurationName "group:name:version:classifier@extension"

另一种是地图符号：

configurationName group: group, name: name, version: version, classifier: classifier, ext: extension

在这两种表示法中，除名称之外的所有属性都是可选的。

外部依赖项由ExternalModuleDependency.

plugins {
    id 'java' // so that we can use 'implementation', 'testImplementation' for dependencies
}

dependencies {
  //for dependencies found in artifact repositories you can use
  //the string notation, e.g. group:name:version
  implementation 'commons-lang:commons-lang:2.6'
  testImplementation 'org.mockito:mockito:1.9.0-rc1'

  //map notation:
  implementation group: 'com.google.code.guice', name: 'guice', version: '1.0'
}

项目依赖

要添加项目依赖项，请使用以下符号：

configurationName project(':some-project')

该表示法project(':project-a')类似于在多模块 gradle 项目中配置 projectA 时使用的语法。

通过将目标项目中的每个消耗品配置视为变体并针对它们执行变体感知属性匹配来解决项目依赖性。但是，为了覆盖此过程，可以指定显式目标配置：

configurationName project(path: ':project-a', configuration: 'someOtherConfiguration')

项目依赖关系使用ProjectDependency.

文件依赖关系

您还可以使用以下命令添加依赖项FileCollection：

configurationName files('a file') 

plugins {
    id 'java' // so that we can use 'implementation', 'testImplementation' for dependencies
}

dependencies {
  //declaring arbitrary files as dependencies
  implementation files('hibernate.jar', 'libs/spring.jar')

  //putting all jars from 'libs' onto compile classpath
  implementation fileTree('libs')
}

文件依赖关系使用FileCollectionDependency.

对其他配置的依赖

您可以使用Configuration.

当配置与目标配置来自同一项目时，目标配置将更改为从提供的配置扩展。

当配置来自不同的项目时，会添加项目依赖项。

Gradle 发行版特定依赖项

可以依赖 Gradle 附带的某些 Gradle API 或库。它对于 Gradle 插件开发特别有用。例子：

//Our Gradle plugin is written in groovy
plugins {
    id 'groovy'
}
// now we can use the 'implementation' configuration for declaring dependencies

dependencies {
  //we will use the Groovy version that ships with Gradle:
  implementation localGroovy()

  //our plugin requires Gradle API interfaces and classes to compile:
  implementation gradleApi()

  //we will use the Gradle test-kit to test build logic:
  testImplementation gradleTestKit()
}

客户端模块依赖关系

客户端模块依赖项已弃用，并将在 Gradle 9.0 中删除。请改用组件元数据规则。

要将客户端模块添加到配置中，您可以使用以下符号：

configurationName module(moduleNotation) {
    module dependencies
}

模块表示法与上述依赖关系表示法相同，只是分类器属性不可用。客户端模块使用ClientModule.

特性

财产描述
components

该项目的组件元数据处理程序。返回的处理程序可用于添加修改依赖软件组件的元数据的规则。

constraints

该项目的依赖约束处理程序。

extensions

扩展的容器。

modules

该项目的组件模块元数据处理程序。返回的处理程序可用于添加修改依赖软件组件的元数据的规则。

方法

方法描述
add(configurationName, dependencyNotation)

添加对给定配置的依赖项。

add(configurationName, dependencyNotation, configureClosure)

将依赖项添加到给定配置，并使用给定闭包配置依赖项。

components(configureAction)

配置该项​​目的组件元数据。

constraints(configureAction)

配置该项​​目的依赖约束。

create(dependencyNotation)

创建依赖项而不将其添加到配置中。

create(dependencyNotation, configureClosure)

创建依赖项而不将其添加到配置中，并使用给定的闭包配置依赖项。

createArtifactResolutionQuery()

创建工件解析查询。

enforcedPlatform(notation)

声明对强制平台的依赖。如果目标坐标代表多个潜在组件，则将选择平台组件，而不是库。强制平台是强制直接依赖的平台，这意味着它们将覆盖图中找到的任何其他版本。

enforcedPlatform(notation, configureAction)

声明对强制平台的依赖。如果目标坐标代表多个潜在组件，则将选择平台组件，而不是库。强制平台是强制直接依赖的平台，这意味着它们将覆盖图中找到的任何其他版本。

enforcedPlatform(dependencyProvider)

配置此依赖项提供程序以选择目标组件的强制平台变体

enforcedPlatform(dependencyProviderConvertible)

配置此依赖项提供程序以选择目标组件的强制平台变体

gradleApi()

创建对当前版本 Gradle 的 API 的依赖项。

gradleTestKit()

创建对Gradle 测试工具包API的依赖项。

localGroovy()

创建对随当前版本的 Gradle 分发的 Groovy 的依赖项。

module(notation)
已弃用

创建对客户端模块的依赖关系。

module(notation, configureClosure)
已弃用

创建对客户端模块的依赖关系。在返回之前，使用给定的闭包配置依赖项。

modules(configureAction)

配置该项​​目的模块元数据。

platform(notation)

声明对平台的依赖。如果目标坐标代表多个潜在组件，则将选择平台组件，而不是库。

platform(notation, configureAction)

声明对平台的依赖。如果目标坐标代表多个潜在组件，则将选择平台组件，而不是库。

platform(dependencyProvider)

配置此依赖项提供程序以选择目标组件的平台变体

platform(dependencyProviderConvertible)

配置此依赖项提供程序以选择目标组件的平台变体

project(notation)

创建对项目的依赖关系。

registerTransform(actionType, registrationAction)

注册一个工件转换。

脚本块

无脚本块

物业详情

ComponentMetadataHandler components（只读）

该项目的组件元数据处理程序。返回的处理程序可用于添加修改依赖软件组件的元数据的规则。

DependencyConstraintHandler constraints（只读）

该项目的依赖约束处理程序。

ExtensionContainer extensions（只读）

扩展的容器。

ComponentModuleMetadataHandler modules（只读）

该项目的组件模块元数据处理程序。返回的处理程序可用于添加修改依赖软件组件的元数据的规则。

方法详情

Dependency add（String配置名称，Object依赖符号）

添加对给定配置的依赖项。

Dependency add（String配置名称、Object依赖符号、ClosureconfigureClosure）

将依赖项添加到给定配置，并使用给定闭包配置依赖项。

void components（配置动作）Action<? super ComponentMetadataHandler>

配置该项​​目的组件元数据。

ComponentMetadataHandler此方法针对该项目执行给定的操作。

void constraints（配置动作）Action<? super DependencyConstraintHandler>

配置该项​​目的依赖约束。

DependencyConstraintHandler此方法针对该项目执行给定的操作。

Dependency create（Object依赖符号）

创建依赖项而不将其添加到配置中。

Dependency create（Object依赖符号，ClosureconfigureClosure）

创建依赖项而不将其添加到配置中，并使用给定的闭包配置依赖项。

ArtifactResolutionQuery createArtifactResolutionQuery()

创建工件解析查询。

Dependency enforcedPlatform（Object符号）

声明对强制平台的依赖。如果目标坐标代表多个潜在组件，则将选择平台组件，而不是库。强制平台是强制直接依赖的平台，这意味着它们将覆盖图中找到的任何其他版本。

Dependency enforcedPlatform（Object符号，configureAction）Action<? super Dependency>

声明对强制平台的依赖。如果目标坐标代表多个潜在组件，则将选择平台组件，而不是库。强制平台是强制直接依赖的平台，这意味着它们将覆盖图中找到的任何其他版本。

配置此依赖项提供程序以选择目标组件的强制平台变体

配置此依赖项提供程序以选择目标组件的强制平台变体

Dependency gradleApi()

创建对当前版本 Gradle 的 API 的依赖项。

Dependency gradleTestKit()

创建对Gradle 测试工具包API的依赖项。

Dependency localGroovy()

创建对随当前版本的 Gradle 分发的 Groovy 的依赖项。

Dependency module（Object符号）

注意：此方法已被弃用，并将在 Gradle 的下一个主要版本中删除。

创建对客户端模块的依赖关系。

Dependency module（Object表示法，ClosureconfigureClosure）

注意：此方法已被弃用，并将在 Gradle 的下一个主要版本中删除。

创建对客户端模块的依赖关系。在返回之前，使用给定的闭包配置依赖项。

void modules（配置动作）Action<? super ComponentModuleMetadataHandler>

配置该项​​目的模块元数据。

ComponentModuleMetadataHandler此方法针对该项目执行给定的操作。

Dependency platform（Object符号）

声明对平台的依赖。如果目标坐标代表多个潜在组件，则将选择平台组件，而不是库。

Dependency platform（Object符号，configureAction）Action<? super Dependency>

声明对平台的依赖。如果目标坐标代表多个潜在组件，则将选择平台组件，而不是库。

配置此依赖项提供程序以选择目标组件的平台变体

配置此依赖项提供程序以选择目标组件的平台变体

Dependency project（符号）Map<String, ?>

创建对项目的依赖关系。

void registerTransform（动作类型，注册动作）Class<? extends TransformAction<T>>Action<? super TransformSpec<T>>

注册一个工件转换。

注册动作需要指定from和to属性。它还可以使用 提供变换操作的参数TransformSpec.parameters(org.gradle.api.Action)。

例如：

// You have a transform action like this:
abstract class MyTransform implements TransformAction<Parameters> {
    interface Parameters extends TransformParameters {
        @Input
        Property<String> getStringParameter();
        @InputFiles
        ConfigurableFileCollection getInputFiles();
    }

    void transform(TransformOutputs outputs) {
        // ...
    }
}

// Then you can register the action like this:

def artifactType = Attribute.of('artifactType', String)

dependencies.registerTransform(MyTransform) {
    from.attribute(artifactType, "jar")
    to.attribute(artifactType, "java-classes-directory")

    parameters {
        stringParameter.set("Some string")
        inputFiles.from("my-input-file")
    }
}