ResolutionStrategy (Gradle API 2.2-20140924021627+0000)

public interface ResolutionStrategy

Defines the strategies around dependency resolution. For example, forcing certain dependency versions, conflict resolutions or snapshot timeouts.

Examples:

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

 configurations.all {
   resolutionStrategy {
     // fail eagerly on version conflict (includes transitive dependencies)
     // e.g. multiple different versions of the same dependency (group and name are equal)
     failOnVersionConflict()

     // force certain versions of dependencies (including transitive)
     //  *append new forced modules:
     force 'asm:asm-all:3.3.1', 'commons-io:commons-io:1.4'
     //  *replace existing forced modules with new ones:
     forcedModules = ['asm:asm-all:3.3.1']

     // add a dependency resolve rule
     eachDependency { DependencyResolveDetails details ->
       //specifying a fixed version for all libraries with 'org.gradle' group
       if (details.requested.group == 'org.gradle') {
           details.useVersion'1.4'
       }
       //changing 'groovy-all' into 'groovy':
       if (details.requested.name == 'groovy-all') {
          details.useTarget group: details.requested.group, name: 'groovy', version: details.requested.version
       }
     }

     // cache dynamic versions for 10 minutes
     cacheDynamicVersionsFor 10*60, 'seconds'
     // don't cache changing modules at all
     cacheChangingModulesFor 0, 'seconds'
   }
 }

導入されたバージョン:: 1.0-milestone-6

メソッドの概要

All Methods Instance Methods Abstract Methods
修飾子とタイプ	メソッドと説明
`void`	`cacheChangingModulesFor(int value, String units)` Sets the length of time that changing modules will be cached, with units expressed as a String.
`void`	`cacheChangingModulesFor(int value, TimeUnit units)` Sets the length of time that changing modules will be cached.
`void`	`cacheDynamicVersionsFor(int value, String units)` Sets the length of time that dynamic versions will be cached, with units expressed as a String.
`void`	`cacheDynamicVersionsFor(int value, TimeUnit units)` Sets the length of time that dynamic versions will be cached.
`ResolutionStrategy`	`componentSelection(Action<? super ComponentSelectionRules> action)` The componentSelection block provides rules for how versions should be selected.
`ResolutionStrategy`	`eachDependency(Action<? super DependencyResolveDetails> rule)` Adds a dependency resolve rule that is triggered for every dependency (including transitive) when the configuration is being resolved.
`ResolutionStrategy`	`failOnVersionConflict()` In case of conflict, Gradle by default uses the newest of conflicting versions.
`ResolutionStrategy`	`force(Object... moduleVersionSelectorNotations)` Allows forcing certain versions of dependencies, including transitive dependencies.
`ComponentSelectionRules`	`getComponentSelection()` Returns the currently configured version selection rules object.
`Set<ModuleVersionSelector>`	`getForcedModules()` Returns currently configured forced modules.
`ResolutionStrategy`	`setForcedModules(Object... moduleVersionSelectorNotations)` Allows forcing certain versions of dependencies, including transitive dependencies.

- メソッドの詳細
  - failOnVersionConflict
```
ResolutionStrategy failOnVersionConflict()
```
    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()
 }
 
```
    戻り値:
    
    this resolution strategy instance
    
    導入されたバージョン:
    
    1.0-milestone-6
  - force
```
ResolutionStrategy force(Object... moduleVersionSelectorNotations)
```
    Allows forcing certain versions of dependencies, including transitive dependencies. Appends new forced modules to be considered when resolving dependencies.
    It accepts following notations:
    - String in a format of: 'group:name:version', for example: 'org.gradle:gradle-core:1.0'
    - instance of ModuleVersionSelector
    - any collection or array of above will be automatically flattened
    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'
 }
 
```
    パラメータ:
    
    moduleVersionSelectorNotations - typically group:name:version notations to append
    
    戻り値:
    
    this ResolutionStrategy instance
    
    導入されたバージョン:
    
    1.0-milestone-7
  - setForcedModules
```
ResolutionStrategy setForcedModules(Object... moduleVersionSelectorNotations)
```
    Allows forcing certain versions of dependencies, including transitive dependencies. Replaces existing forced modules with the input.
    For information on notations see force(Object...)
    Example:
```
 apply plugin: 'java' //so that there are some configurations

 configurations.all {
   resolutionStrategy.forcedModules = ['asm:asm-all:3.3.1', 'commons-io:commons-io:1.4']
 }
 
```
    パラメータ:
    
    moduleVersionSelectorNotations - typically group:name:version notations to set
    
    戻り値:
    
    this ResolutionStrategy instance
    
    導入されたバージョン:
    
    1.0-milestone-7
  - getForcedModules
```
Set<ModuleVersionSelector> getForcedModules()
```
    Returns currently configured forced modules. For more information on forcing versions see force(Object...)
    
    戻り値:
    
    forced modules
    
    導入されたバージョン:
    
    1.0-milestone-7
  - eachDependency
```
@Incubating
ResolutionStrategy eachDependency(Action<? super DependencyResolveDetails> rule)
```
    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 force(Object...)
    戻り値:
    
    this
    
    導入されたバージョン:
    
    1.4
  - cacheDynamicVersionsFor
```
void cacheDynamicVersionsFor(int value,
                             String units)
```
    Sets the length of time that dynamic versions will be cached, with units expressed as a String.
    A convenience method for cacheDynamicVersionsFor(int, java.util.concurrent.TimeUnit) with units expressed as a String. Units are resolved by calling the valueOf(String) method of TimeUnit with the upper-cased string value.
    
    パラメータ:
    
    value - The number of time units
    
    units - The units
    
    導入されたバージョン:
    
    1.0-milestone-6
  - cacheDynamicVersionsFor
```
void cacheDynamicVersionsFor(int value,
                             TimeUnit units)
```
    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.
    
    パラメータ:
    
    value - The number of time units
    
    units - The units
    
    導入されたバージョン:
    
    1.0-milestone-6
  - cacheChangingModulesFor
```
void cacheChangingModulesFor(int value,
                             String units)
```
    Sets the length of time that changing modules will be cached, with units expressed as a String.
    A convenience method for cacheChangingModulesFor(int, java.util.concurrent.TimeUnit) with units expressed as a String. Units are resolved by calling the valueOf(String) method of TimeUnit with the upper-cased string value.
    
    パラメータ:
    
    value - The number of time units
    
    units - The units
    
    導入されたバージョン:
    
    1.0-milestone-6
  - cacheChangingModulesFor
```
void cacheChangingModulesFor(int value,
                             TimeUnit units)
```
    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.
    
    パラメータ:
    
    value - The number of time units
    
    units - The units
    
    導入されたバージョン:
    
    1.0-milestone-6
  - getComponentSelection
```
@Incubating
ComponentSelectionRules getComponentSelection()
```
    Returns the currently configured version selection rules object.
    
    戻り値:
    
    the version selection rules
    
    導入されたバージョン:
    
    2.2
  - componentSelection
```
@Incubating
ResolutionStrategy componentSelection(Action<? super ComponentSelectionRules> action)
```
    The componentSelection block provides rules for how versions should be selected. This is useful for defining your own version scheme.
    
    パラメータ:
    
    action - Action to be applied to the ComponentSelectionRules
    
    戻り値:
    
    this ResolutionStrategy instance
    
    導入されたバージョン:
    
    2.2

インタフェース ResolutionStrategy

メソッドの概要

メソッドの詳細

failOnVersionConflict

force

setForcedModules

getForcedModules

eachDependency

cacheDynamicVersionsFor

cacheDynamicVersionsFor

cacheChangingModulesFor

cacheChangingModulesFor

getComponentSelection

componentSelection