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. More details about per-dependency exclusions can be found in docs for ModuleDependency.exclude.
• 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
   }
 }
 

• Declaring dependency to a specific configuration of the module.
• Explicit specification of the artifact. See also ModuleDependency.artifact.

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

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

   //configuring dependency on 'someLib' module
   compile(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 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 two notations supported for declaring a dependency on an external module. One is a string notation formatted this way:

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.

Gradle distribution specific dependencies

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
 apply plugin: 'groovy'
 //now we can use the 'compile' configuration for declaring dependencies

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

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

Client module dependencies

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

 configurationName module(moduleNotation) {
     module dependencies
 }