DependencyHandler

There are two notations supported for declaring a dependency on an external module. One is a string notation formatted this way:

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

The other is a map notation:

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

In both notations, all properties, except name, are optional.

External dependencies are represented by a 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'
}

To add a project dependency, you use the following notation:

configurationName project(':some-project')

The notation project(':project-a') is similar to the syntax you use when configuring a projectA in a multi-module gradle project.

Project dependencies are resolved by treating each consumable configuration in the target project as a variant and performing variant-aware attribute matching against them. However, in order to override this process, an explicit target configuration can be specified:

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

Project dependencies are represented using a ProjectDependency.

You can also add a dependency using a 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')
}

File dependencies are represented using a FileCollectionDependency.

You can add a dependency using a Configuration.

When the configuration is from the same project as the target configuration, the target configuration is changed to extend from the provided configuration.

When the configuration is from a different project, a project dependency is added.

It is possible to depend on certain Gradle APIs or libraries that Gradle ships with. It is particularly useful for Gradle plugin development. Example:

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

Client module dependencies are deprecated and will be removed in Gradle 9.0. Please use component metadata rules instead.

To add a client module to a configuration you can use the notation:

configurationName module(moduleNotation) {
    module dependencies
}

The module notation is the same as the dependency notations described above, except that the classifier property is not available. Client modules are represented using a ClientModule.

The component metadata handler for this project. The returned handler can be used for adding rules that modify the metadata of depended-on software components.

The dependency constraint handler for this project.

The container of extensions.

The component module metadata handler for this project. The returned handler can be used for adding rules that modify the metadata of depended-on software components.

Adds a dependency to the given configuration.

Adds a dependency to the given configuration, and configures the dependency using the given closure.

Configures component metadata for this project.

This method executes the given action against the ComponentMetadataHandler for this project.

Configures dependency constraint for this project.

This method executes the given action against the DependencyConstraintHandler for this project.

Creates a dependency without adding it to a configuration.

Creates a dependency without adding it to a configuration, and configures the dependency using the given closure.

Creates an artifact resolution query.

This is a legacy API and is in maintenance mode. In future versions of Gradle, this API will be deprecated and removed. New code should not use this API. Prefer <UNHANDLED-LINK>ArtifactView.ViewConfiguration#withVariantReselection()</UNHANDLED-LINK> for resolving sources and javadoc.

Declares a dependency on an enforced platform. If the target coordinates represent multiple potential components, the platform component will be selected, instead of the library. An enforced platform is a platform for which the direct dependencies are forced, meaning that they would override any other version found in the graph.

Declares a dependency on an enforced platform. If the target coordinates represent multiple potential components, the platform component will be selected, instead of the library. An enforced platform is a platform for which the direct dependencies are forced, meaning that they would override any other version found in the graph.

Configures this dependency provider to select the enforced-platform variant of the target component

Configures this dependency provider to select the enforced-platform variant of the target component

Creates a dependency on the API of the current version of Gradle.

Creates a dependency on the Gradle test-kit API.

Creates a dependency on the Groovy that is distributed with the current version of Gradle.

Creates a dependency on a client module.

Creates a dependency on a client module. The dependency is configured using the given closure before it is returned.

Configures module metadata for this project.

This method executes the given action against the ComponentModuleMetadataHandler for this project.

Declares a dependency on a platform. If the target coordinates represent multiple potential components, the platform component will be selected, instead of the library.

Declares a dependency on a platform. If the target coordinates represent multiple potential components, the platform component will be selected, instead of the library.

Configures this dependency provider to select the platform variant of the target component

Configures this dependency provider to select the platform variant of the target component

Creates a dependency on a project.

Registers an artifact transform.

The registration action needs to specify the from and to attributes. It may also provide parameters for the transform action by using TransformSpec.parameters(org.gradle.api.Action).

For example:

// 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")
    }
}