DependencyHandler

The following notation is used to declare a dependency on an external module:

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

All properties, except name, are optional.

External dependencies are represented by a ExternalModuleDependency.

plugins {
    id("java-library")
}

dependencies {
    // Declare dependency on module components
    // Coordinates are separated by a single colon -- group:name:version
    implementation("org.apache.commons:commons-lang3:3.17.0")
    testImplementation("org.mockito:mockito-core:5.18.0")
}

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

configurationName(project(":some-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-library")
}

dependencies {
    // Declare dependency on arbitrary files
    implementation(files("hibernate.jar", "libs/spring.jar"))

    // Declare dependency on all jars from the 'libs' directory
    implementation(fileTree("libs"))
}

File dependencies are represented using a FileCollectionDependency.

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

plugins {
    id("groovy")
}

dependencies {
    // Declare dependency on the Groovy version that ships with Gradle
    implementation(localGroovy())

    // Declare dependency on the Gradle API interfaces and classes
    implementation(gradleApi())

    // Declare dependency on the Gradle test-kit to test build logic
    testImplementation(gradleTestKit())
}

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.

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