org.gradle.api.artifacts.dsl
Interface DependencyHandler

public interface DependencyHandler

A DependencyHandler is used to declare dependencies. Dependencies are grouped into configurations (see Configuration).

To declare a specific dependency for a configuration you can use the following syntax:

 dependencies {
     configurationName dependencyNotation1, dependencyNotation2, ...
 }
 

Example shows a basic way of declaring dependencies.

 apply plugin: 'java'
 //so that we can use 'compile', 'testCompile' for dependencies

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

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

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

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

Advanced dependency configuration

To do some advanced configuration on a dependency when it is declared, you can additionally pass a configuration closure:

 dependencies {
     configurationName(dependencyNotation){
         configStatement1
         configStatement2
     }
 }
 

• forcing certain dependency version in case of the conflict
• excluding certain dependencies by name, group or both
• avoiding transitive dependencies for certain dependency

 apply plugin: 'java' //so that I can declare 'compile' dependencies

 dependencies {
   compile('org.hibernate:hibernate:3.1') {
     //in case of versions conflict '3.1' version of hibernate wins:
     force = true

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

Dependency notations

There are several supported dependency notations. These are described below. For each dependency declared this way, a Dependency object is created. You can use this object to query or further configure the dependency.

You can also always add instances of Dependency directly:

External dependencies

There are 2 notations supported for declaring a dependency on an external module. One is a String notation formatted this way: group:name:version

The other is a map notation:

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

External dependencies are represented by a ExternalModuleDependency.

 apply plugin: 'java'
 //so that we can use 'compile', 'testCompile' for dependencies

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

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

Project dependencies

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

configurationName project(':someProject')

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

By default, when you declare dependency to projectA, you actually declare dependency to the 'default' configuration of the projectA. If you need to depend on a specific configuration of projectA, use map notation for projects:

configurationName project(path: ':projectA', configuration: 'someOtherConfiguration')

Project dependencies are represented using a ProjectDependency.

File dependencies

You can also add a dependency using a FileCollection:

 apply plugin: 'java'
 //so that we can use 'compile', 'testCompile' for dependencies

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

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

File dependencies are represented using a SelfResolvingDependency.

Dependencies to other configurations

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.

Client module dependencies

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

 configurationName module(moduleNotation) {
     module dependencies
 }
 

add

Dependency add(String configurationName,
               Object dependencyNotation)

Adds a dependency to the given configuration.

Parameters:

configurationName - The name of the configuration.

dependencyNotation - The dependency notation, in one of the notations described above.

Returns:

The dependency.

add

Dependency add(String configurationName,
               Object dependencyNotation,
               Closure configureClosure)

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

Parameters:

configurationName - The name of the configuration.

dependencyNotation - The dependency notation, in one of the notations described above.

configureClosure - The closure to use to configure the dependency.

Returns:

The dependency.

create

Dependency create(Object dependencyNotation)

Creates a dependency without adding it to a configuration.

Parameters:

dependencyNotation - The dependency notation, in one of the notations described above.

Returns:

The dependency.

create

Dependency create(Object dependencyNotation,
                  Closure configureClosure)

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

Parameters:

dependencyNotation - The dependency notation, in one of the notations described above.

configureClosure - The closure to use to configure the dependency.

Returns:

The dependency.

module

Dependency module(Object notation)

Creates a dependency on a client module.

Parameters:

notation - The module notation, in one of the notations described above.

Returns:

The dependency.

module

Dependency module(Object notation,
                  Closure configureClosure)

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

Parameters:

notation - The module notation, in one of the notations described above.

configureClosure - The closure to use to configure the dependency.

Returns:

The dependency.

project

Dependency project(Map<String,?> notation)

Creates a dependency on a project.

Parameters:

notation - The project notation, in one of the notations described above.

Returns:

The dependency.

gradleApi

Dependency gradleApi()

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

Returns:

The dependency.

localGroovy

Dependency localGroovy()

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

Returns:

The dependency.