ResolutionStrategy

The currently configured version selection rules object.

Returns currently configured forced modules. For more information on forcing versions see ResolutionStrategy.force()

Sets the length of time that changing modules will be cached, with units expressed as a String.

A convenience method for ResolutionStrategy.cacheChangingModulesFor() with units expressed as a String. Units are resolved by calling the valueOf(String) method of TimeUnit with the upper-cased string value.

Sets the length of time that changing modules will be cached.

Gradle caches the contents and artifacts of changing modules. By default, these cached values are kept for 24 hours, after which the cached entry is expired and the module is resolved again.

Use this method to provide a custom expiry time after which the cached entries for any changing module will be expired.

Sets the length of time that dynamic versions will be cached, with units expressed as a String.

A convenience method for ResolutionStrategy.cacheDynamicVersionsFor() with units expressed as a String. Units are resolved by calling the valueOf(String) method of TimeUnit with the upper-cased string value.

Sets the length of time that dynamic versions will be cached.

Gradle keeps a cache of dynamic version => resolved version (ie 2.+ => 2.3). By default, these cached values are kept for 24 hours, after which the cached entry is expired and the dynamic version is resolved again.

Use this method to provide a custom expiry time after which the cached value for any dynamic version will be expired.

The componentSelection block provides rules for how versions should be selected. This is useful for defining your own version scheme.

Adds a dependency resolve rule that is triggered for every dependency (including transitive) when the configuration is being resolved. The action receives an instance of DependencyResolveDetails that can be used to find out what dependency is being resolved and to influence the resolution process. Example:

apply plugin: 'java' //so that there are some configurations

configurations.all {
  resolutionStrategy {
    eachDependency { DependencyResolveDetails details ->
      //specifying a fixed version for all libraries with 'org.gradle' group
      if (details.requested.group == 'org.gradle') {
        details.useVersion '1.4'
      }
    }
    eachDependency { details ->
      //multiple actions can be specified
      if (details.requested.name == 'groovy-all') {
         //changing the name:
         details.useTarget group: details.requested.group, name: 'groovy', version: details.requested.version
      }
    }
  }
}

The rules are evaluated in order they are declared. Rules are evaluated after forced modules are applied (see ResolutionStrategy.force()

In case of conflict, Gradle by default uses the newest of conflicting versions. However, you can change this behavior. Use this method to configure the resolution to fail eagerly on any version conflict, e.g. multiple different versions of the same dependency (group and name are equal) in the same Configuration. The check includes both first level and transitive dependencies. See example below:

apply plugin: 'java' //so that there are some configurations

configurations.all {
  resolutionStrategy.failOnVersionConflict()
}

Allows forcing certain versions of dependencies, including transitive dependencies. Appends new forced modules to be considered when resolving dependencies.

It accepts following notations:

Example:

apply plugin: 'java' //so that there are some configurations

configurations.all {
  resolutionStrategy.force 'asm:asm-all:3.3.1', 'commons-io:commons-io:1.4'
}