第51章 依存関係の管理

Dependency management can be particularly challenging during a migration from one build system to another. If you are migrating from a tool like Ant or Maven to Gradle, you may be faced with some difficult situations. For example, one common pattern is an Ant project with version-less jar files stored in the filesystem. Other build systems require a wholesale replacement of this approach before migrating. With Gradle, you can adapt your new build to any existing source of dependencies or dependency metadata. This makes incremental migration to Gradle much easier than the alternative. On most large projects, build migrations and any change to development process is incremental because most organizations can't afford to stop everything and migrate to a build tool's idea of dependency management.

依存関係の管理で特に問題が発生しやすいのは、あるビルドシステムから別のビルドシステムへ移行するときです。 AntやMavenからGradleへ移行する際には、難しい問題に突き当たることがあるかもしれません。 例えば、よくあるAntプロジェクトですが、バージョンのないjarファイルがファイルシステムに置かれていたりすることがあります。この場合、移行先のビルドシステムによっては、管理方法を完全に置き換える必要が出てくるかもしれません。 一方Gradleでは、依存関係をどこから、どんなメタデータで取得していたとしても、新しいビルドでそれを変更する必要はありません。これにより、段階的にビルドシステムを移行することが他のツールに比べて容易になっているのです。大規模プロジェクトでは、ビルドにしてもその他のあらゆる開発プロセスにしても、段階的に移行していく場合がほとんどです。全てを止めてビルドツール固有の考え方へ依存関係管理を移行している余裕など、ほとんどの組織にはないからです。

Even if your project is using a custom dependency management system or something like an Eclipse .classpath file as master data for dependency management, it is very easy to write a Gradle plugin to use this data in Gradle. For migration purposes this is a common technique with Gradle. (But, once you've migrated, it might be a good idea to move away from a .classpath file and use Gradle's dependency management features directly.)

プロジェクトが独自の方法で依存関係を管理していたとしても、例え依存関係のマスターデータにEclipseの.classpathを使っているようなプロジェクトであったとしても、Gradleでそのデータを使うためのプラグインを書くのはとても簡単な作業です。マイグレーションのためであれば、こうしたテクニックを使うことはGradleではごく普通のことです(ただ、移行が完了した後は、.classpathを使うのは止めてGradleの依存関係管理機能を直接使うのが良いとは思いますが)。

It is ironic that in a language known for its rich library of open source components that Java has no concept of libraries or versions. In Java, there is no standard way to tell the JVM that you are using version 3.0.5 of Hibernate, and there is no standard way to say that foo-1.0.jar depends on bar-2.0.jar. This has led to external solutions often based on build tools. The most popular ones at the moment are Maven and Ivy. While Maven provides a complete build system, Ivy focuses solely on dependency management.

Javaはその豊富なオープンソースライブラリで知られる言語ですが、皮肉なことにライブラリやバージョンといった概念が存在しません。 Javaでは、JVMに、今使っているものがHibernateのバージョン3.0.5であると伝える標準的な方法はありませんし、foo-1.0.jarがbar-2.0.jarに依存していると伝える方法も標準では存在しないのです。 このため、これを実現するための様々なソリューションがサードパーティにより考案されてきました。また、ビルドツールに組み込まれることもよくあります。現在もっとも有名なものがMavenであり、Ivyです。Mavenがビルドシステムの機能全体を備えているのに対し、Ivyは依存関係の管理のみに焦点を当てています。

Both tools rely on descriptor XML files, which contain information about the dependencies of a particular jar. Both also use repositories where the actual jars are placed together with their descriptor files, and both offer resolution for conflicting jar versions in one form or the other. Both have emerged as standards for solving dependency conflicts, and while Gradle originally used Ivy under the hood for its dependency management. Gradle has replaced this direct dependency on Ivy with a native Gradle dependency resolution engine which supports a range of approaches to dependency resolution including both POM and Ivy descriptor files.

どちらのツールも、ある特定のjarファイルについて、その依存関係の情報をXML形式のディスクリプタに定義して使用します。また、リポジトリに実際のjarファイルをディスクリプタファイルと一緒に配置したり、jarのバージョンが競合したときに様々な形でそれを解決する手段を備えている点も同様です。 どちらも依存関係を解決するための標準的な方法となっており、Gradleも最初は依存関係管理機能の水面下でIvyを使用していました。 Gradleは、今ではそのように直接Ivyに依存するのではなく、Gradle独自の依存関係解決エンジンを使用しています。このエンジンは、POMおよびIvyディスクリプタによる管理方法を含め様々な方法に対応しています。

The version of a library must be part of the filename. While the version of a jar is usually in the Manifest file, it isn't readily apparent when you are inspecting a project. If someone asks you to look at a collection of 20 jar files, which would you prefer? A collection of files with names like commons-beanutils-1.3.jar or a collection of files with names like spring.jar? If dependencies have file names with version numbers you can quickly identify the versions of your dependencies.

ライブラリのバージョンはファイル名で簡単に分かるようになっていなければなりません。jarのバージョンは、たいていの場合マニフェストファイルに記述されていますが、それではプロジェクトを調査しているときに手軽に見ることができません。 もし、20個のjarファイルがズラッと並べられて、これを見てほしいと言われたら、どちらがいいと思いますか？　つまり、commons-beanutils-1.3.jarのようなファイル群と、spring.jarのようなファイル群と、どちらの方がわかりやすいと思いますか？ ファイル名にバージョン番号が付いていれば、プロジェクトが依存しているjarのバージョンを簡単に、迅速に特定できます。

If versions are unclear you can introduce subtle bugs which are very hard to find. For example there might be a project which uses Hibernate 2.5. Think about a developer who decides to install version 3.0.5 of Hibernate on her machine to fix a critical security bug but forgets to notify others in the team of this change. She may address the security bug successfully, but she also may have introduced subtle bugs into a codebase that was using a now-deprecated feature from Hibernate. Weeks later there is an exception on the integration machine which can't be reproduced on anyone's machine. Multiple developers then spend days on this issue only finally realising that the error would have easy to uncover if they knew that Hibernate had been upgraded from 2.5 to 3.0.5.

不明瞭なバージョンは、発見するのが非常に難しい、微妙なバグに繋がります。 例えば、Hibernate2.5を使っているプロジェクトがあるとしましょう。Hibernate3.0.5にアップグレードして、致命的なセキュリティのバグを修正したと想定してください。しかし、彼女はチームメンバーにそのことを知らせるのを忘れてしまいました。彼女はセキュリティのバグを上手く修正したかもしれませんが、同時にコードベースに小さなバグを混入させてしまったかもしれません。最新版のライブラリで非推奨となった機能を使っていた場合などです。 数週間後、インテグレーションサーバーで例外が発生します。しかし他のマシンでは再現しません。結果、Hibernateが2.5から3.0.2にアップグレードされていたというだけの問題に、多くの開発者が何日もかけることになるのです。

Versions in jar names increase the expressiveness of your project and make them easier to maintain. This practice also reduces the potential for error.

jarのファイル名にバージョン付けすることは、プロジェクトの表現性を高め、メンテナンスを簡単にします。また、潜在的なエラーを減らすことにも繋がるのです。

Transitive dependency management is a technique that enables your project to depend on libraries which, in turn, depend on other libraries. This recursive pattern of transitive dependencies results in a tree of dependencies including your project's first-level dependencies, second-level dependencies, and so on. If you don't model your dependencies as a hierarchical tree of first-level and second-level dependencies it is very easy to quickly lose control over an assembled mess of unstructured dependencies. Consider the Gradle project itself, while Gradle only has a few direct, first-level dependencies, when Gradle is compiled it needs more than one hundred dependencies on the classpath. On a far larger scale, Enterprise projects using Spring, Hibernate, and other libraries, alongside hundreds or thousands of internal projects, can result in very large dependency trees.

推移的な依存関係の管理とは、プロジェクトがあるライブラリに依存しているとき、その依存ライブラリがさらに別のライブラリに依存することを可能にする技術のことです。 このように推移的な依存関係が再帰的に発生すると、プロジェクトが直接依存する第一層の依存、それが依存する第二層の依存、といったふうに、依存関係のツリー構造が構築されることになります。 階層的にモデリングされていない依存関係は、構造化されないまま複雑にふくれあがり、簡単に制御を失ってしまうでしょう。 Gradle自身のことを考えてみても、Gradleプロジェクト自体は直接の、つまり第一層の依存関係はそう多くはありませんが、プロジェクトのコンパイル時には100以上の依存関係をクラスパスに含める必要があります。 さらに規模が大きくなれば、例えばSpring、Hibernate、その他のライブラリを使うエンタープライズプロジェクトともなれば、それに伴い数百、数千の依存プロジェクトが非常に大きな依存関係ツリーを構築することになります。

When these large dependency trees need to change, you'll often have to solve some dependency version conflicts. Say one open source library needs one version of a logging library and a another uses an alternative version. Gradle and other build tools all have the ability to resolve this dependency tree and resolve conflicts, but what differentiates Gradle is the control it gives you over transitive dependencies and conflict resolution.

このように依存関係ツリーが巨大になってくると、それを修正する際、バージョンの競合が発生しやすくなり、その解決に追われることが増えてきます。 例えば、あるバージョンのロギングライブラリを必要としているオープンソースライブラリがあるとしましょう。この場合、そのロギングライブラリの別のバージョンを要求するライブラリを使用すると、バージョンの競合が発生します。Gradleやその他のビルドツールは全て、このようなバージョン競合を解決する手段を備えています。Gradleでは、さらにその解決方法を細かく制御することもできます。

While you could try to manage this problem manually, you will quickly find that this approach doesn't scale. If you want to get rid of a first level dependency you really can't be sure which other jars you should remove. A dependency of a first level dependency might also be a first level dependency itself, or it might be a transitive dependency of yet another first level dependency. If you try to manage transitive dependencies yourself, the end of the story is that your build becomes brittle: no one dares to change your dependencies because the risk of breaking the build is too high. The project classpath becomes a complete mess, and, if a classpath problem arises, hell on earth invites you for a ride.

これらの問題を、手で何とかしようと頑張ることはできるかもしれませんが、すぐにそうした方法には拡張性がないことに気づくでしょう。 例えば、第一層、直接の依存関係を取り除きたいとなったとき、関連する他のjarも削除して良いものかどうか、分からなくなってしまいます。 削除しようとする依存関係の依存ライブラリだと思っていたjarが、それ自身第一層の依存関係に含まれているかもしれませんし、別の依存関係から参照されている可能性もあります。 自分で、手で推移的な依存関係を管理しようとすれば、その行き着く先は壊れやすく脆いビルドです。 思い切ってそのプロジェクトの依存関係を変更しようなどという人はどこにもいません。ビルドを壊してしまうリスクがあまりに高すぎるからです。 プロジェクトのクラスパスはいつか完全にめちゃくちゃになって、ひとたびそのクラスパスで問題が発生すれば地獄のような状況に陥ることでしょう。

Gradle offers you different ways to express first-level and transitive dependencies. With Gradle you can mix and match approaches; for example, you could store your jars in an SCM without XML descriptor files and still use transitive dependency management.

Gradleは、直接の依存関係および推移的な依存関係を表現するための手段を複数用意しています。複数のアプローチを混ぜたり、組み合わせて使うことも可能です。例えば、jarを、XMLのディスクリプタなしでソースコード管理システムに直接格納することができますし、その場合でも推移的な依存関係はそのまま管理していくことができます。

Conflicting versions of the same jar should be detected and either resolved or cause an exception. If you don't use transitive dependency management, version conflicts are undetected and the often accidental order of the classpath will determine what version of a dependency will win. On a large project with many developers changing dependencies, successful builds will be few and far between as the order of dependencies may directly affect whether a build succeeds or fails (or whether a bug appears or disappears in production).

同じjar間でバージョンの競合が検出された場合、それを解決するか、エラーを発生させなければなりません。ここでもし推移的な依存関係を管理していなければ、バージョン競合は検出できず、クラスパス内で偶然そうなっただけのjarの順序がどのバージョンを優先するか決定することになります。 たくさんの開発者が依存関係を変更しているような巨大プロジェクトの場合、依存関係の順序がビルドの成否(またはプロダクション環境でバグが発生するかどうか)に直接影響するような状態では、上手くいくビルドはほとんどなくなってしまうでしょう。

If you haven't had to deal with the curse of conflicting versions of jars on a classpath, here is a small anecdote of the fun that awaits you. In a large project with 30 submodules, adding a dependency to a subproject changed the order of a classpath, swapping Spring 2.5 for an older 2.4 version. While the build continued to work, developers were starting to notice all sorts of surprising (and surprisingly awful) bugs in production. Worse yet, this unintentional downgrade of Spring introduced several security vulnerabilities into the system, which now required a full security audit throughout the organization.

もしクラスパスのバージョンが競合するという不幸に苦しんだことがないようでしたら、あなたを待ち受ける愉快な逸話を一つ紹介しましょう。 30のサブモジュールからなるある巨大なプロジェクトがありました。ここにあるサブモジュールに依存関係を追加したところ、クラスパスの順序が変わり、Spring2.5が古いバージョンの2.4に置き換わってしまったのです。 ビルドはまだ正常に動き続けているのに、開発者たちは無数の驚くような、というか驚くくらいひどいバグをプロダクション環境で見つけ始めます。 さらに悪いことに、この意図しないSpringのダウングレードはいくつかのセキュリティ的な脆弱性をシステムに招き、組織全体があらゆるセキュリティ監査を受けることになりました。

In short, version conflicts are bad, and you should manage your transitive dependencies to avoid them. You might also want to learn where conflicting versions are used and consolidate on a particular version of a dependency across your organization. With a good conflict reporting tool like Gradle, that information can be used to communicate with the entire organization and standardize on a single version. If you think version conflicts don't happen to you, think again. It is very common for different first-level dependencies to rely on a range of different overlapping versions for other dependencies, and the JVM doesn't yet offer an easy way to have different versions of the same jar in the classpath (see 「Javaにおける依存関係管理 Dependency management and Java」).

要するに、バージョンの競合は悪いことなので、それを避けるために推移的な依存関係は管理しなければならないのです。 また、競合したバージョンが組織全体で何処で使われているのか調べ、一つのバージョンに統一したいという場合について考えると、Gradleのような競合に関する優秀なレポートを作成できるツールがあれば、組織全体でのコミュニケーション、および一つのバージョンへの標準化などに役立つはずです。 もしバージョン競合など自分には起こるわけがないと思っているようでしたら、どうかもう一度考え直してみてください。 第一層の依存関係が、更に別のライブラリに依存していて、それが他の依存関係とバージョンが競合しているというのは非常に良くあることです。 また、JVMには同じjarの違うバージョンをクラスパスで共存させられるような簡単な方法がありません(「Javaにおける依存関係管理 Dependency management and Java」参照)。

Gradle offers the following conflict resolution strategies:

Gradleでは、バージョン競合を解決するための戦略として以下のものを用意しています。

While the strategies introduced above are usually enough to solve most conflicts, Gradle provides more fine-grained mechanisms to resolve version conflicts:

上記の戦略で大抵の場合はほとんどの競合を解決できますが、Gradleはさらに微調整を行うためのメカニズムを備えています。

To deal with problems due to version conflicts, reports with dependency graphs are also very helpful. Such reports are another feature of dependency management.

バージョン競合により発生する様々な問題に対応するときには、依存関係グラフを表示するレポートも非常に有用です。依存関係管理の機能として、Gradleはそのようなレポート機能も備えています。

There are many situations when you want to use the latest version of a particular dependency, or the latest in a range of versions. This can be a requirement during development, or you may be developing a library that is designed to work with a range of dependency versions. You can easily depend on these constantly changing dependencies by using a dynamic version. A dynamic version can be either a version range (e.g. 2.+) or it can be a placeholder for the latest version available (e.g. latest.integration).

あるモジュールについて、常に最新版を使いたい、またはある範囲においての最新版を使いたいといった場面がよくあります。 例えば、開発作業中や、ある範囲のバージョンのライブラリと協調して動作するよう設計されたライブラリを開発しているときなどです。 この種の、絶えず変更されるような依存関係は、動的バージョンを使うと簡単に参照することができます。 動的バージョンは、バージョンの範囲で指定すること(2.+など)も、使用できる最新版を表すプレースホルダで指定すること(latest.integrationなど)もできます。

Alternatively, sometimes the module you request can change over time, even for the same version. An example of this type of changing module is a Maven SNAPSHOT module, which always points at the latest artifact published. In other words, a standard Maven snapshot is a module that never stands still so to speak, it is a “changing module”.

また、要求しているモジュールのバージョンそのものは変わらないのに、中身だけが変更されていく場合もあります。このような変更性モジュールの典型的な例は、MavenのSNAPSHOTモジュールです。このモジュールは、公開された最新のモジュールを常にポイントし続けます。 言い換えれば、標準的なMavenのスナップショットは静的な状態にとどまっているものではありません。それがつまり、「変更性モジュール」です。

The main difference between a dynamic version and a changing module is that when you resolve a dynamic version, you'll get the real, static version as the module name. When you resolve a changing module, the artifacts are named using the version you requested, but the underlying artifacts may change over time.

動的バージョンと変更性モジュールの主な違いは、モジュール名に付加されるバージョンです。動的バージョンが静的な、実際のバージョンに変換されて付加されるのに対し、変更性モジュールは要求したバージョン名がそのまま付加されます。その上で、モジュールの中身が時間が経つにつれて変わっていくのです。

By default, Gradle caches dynamic versions and changing modules for 24 hours. You can override the default cache modes using command line options. You can change the cache expiry times in your build using the resolution strategy (see 「依存関係キャッシュ制御の微調整 Fine-tuned control over dependency caching」).

デフォルトでは、Gradleは動的バージョンと変更性モジュールのキャッシュを24時間保持します。デフォルトに使用される値はコマンドラインオプションで変更できます。 また、ビルド時の実際のキャッシュの有効期限は解決戦略を使って設定できます(「依存関係キャッシュ制御の微調整 Fine-tuned control over dependency caching」参照)。

External module dependencies are the most common dependencies. They refer to a module in an external repository.

外部モジュール依存関係は、もっともポピュラーな種類の依存関係です。このタイプの依存関係は、外部リポジトリにあるモジュールを参照します。

dependencies {
    runtime group: 'org.springframework', name: 'spring-core', version: '2.5'
    runtime 'org.springframework:spring-core:2.5',
            'org.springframework:spring-aop:2.5'
    runtime(
        [group: 'org.springframework', name: 'spring-core', version: '2.5'],
        [group: 'org.springframework', name: 'spring-aop', version: '2.5']
    )
    runtime('org.hibernate:hibernate:3.0.5') {
        transitive = true
    }
    runtime group: 'org.hibernate', name: 'hibernate', version: '3.0.5', transitive: true
    runtime(group: 'org.hibernate', name: 'hibernate', version: '3.0.5') {
        transitive = true
    }
}

See the DependencyHandler class in the API documentation for more examples and a complete reference.

より多くの例と完全なリファレンスはDependencyHandlerを参照してください。

Gradle provides different notations for module dependencies. There is a string notation and a map notation. A module dependency has an API which allows for further configuration. Have a look at ExternalModuleDependency to learn all about the API. This API provides properties and configuration methods. Via the string notation you can define a subset of the properties. With the map notation you can define all properties. To have access to the complete API, either with the map or with the string notation, you can assign a single dependency to a configuration together with a closure.

Gradleはモジュール依存関係を定義するために二つの記法を用意しています。文字列記法とマップ記法です。モジュール依存関係は、実際には非常に多くの設定を可能にするAPIを持っています。ExternalModuleDependencyも併せてご覧ください。 このAPIはプロパティとメソッドを公開しており、文字列記法ではプロパティのうち一部を指定することができます。 マップ記法を使うと全てのプロパティにアクセスできます。全てのAPIにアクセスするには、文字列記法、マップ記法どちらでも構いませんが、依存するモジュールを一つだけ指定して、そこに一緒にクロージャを渡します。

If you declare a module dependency, Gradle looks for a module descriptor file (pom.xml or ivy.xml) in the repositories. If such a module descriptor file exists, it is parsed and the artifacts of this module (e.g. hibernate-3.0.5.jar) as well as its dependencies (e.g. cglib) are downloaded. If no such module descriptor file exists, Gradle looks for a file called hibernate-3.0.5.jar to retrieve. In Maven, a module can have one and only one artifact. In Gradle and Ivy, a module can have multiple artifacts. Each artifact can have a different set of dependencies.

モジュール依存関係が宣言されていると、Gradleは対応するモジュールディスクリプタファイル(pom.xmlまたはivy.xml)をリポジトリに探しに行きます。結果、ディスクリプタファイルが見つかった場合は、それをパースし、指定されているアーティファクト(hibernate-3.0.5.jarなど)および推移的依存関係(cglibなど)をダウンロードします。 ディスクリプタファイルが見つからなければ、Gradleは今度はhibernate-3.0.5.jarという名前のファイルを探して取得しようとします。 Mavenのモジュールは、アーティファクトを一つしか持つことができません。GradleとIvyは一つのモジュールが複数のアーティファクトを持つことができます。それらのアーティファクトは、それぞれ別の依存関係を持っています。

dependencies {
    runtime "org.groovy:groovy:2.2.0@jar"
    runtime group: 'org.groovy', name: 'groovy', version: '2.2.0', ext: 'jar'
}

compile "org.gradle.test.classifiers:service:1.0:jdk15@jar"
    otherConf group: 'org.gradle.test.classifiers', name: 'service', version: '1.0', classifier: 'jdk14'

It is easy to iterate over the dependency artifacts of a configuration:

コンフィグレーションに含まれる依存アーティファクトの一覧は簡単に列挙できます。

task listJars << {
    configurations.compile.each { File file -> println file.name }
}

> gradle -q listJars
hibernate-core-3.6.7.Final.jar
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
hibernate-commons-annotations-3.2.0.Final.jar
hibernate-jpa-2.0-api-1.0.1.Final.jar
jta-1.1.jar
slf4j-api-1.6.1.jar

Client module dependencies allow you to declare transitive dependencies directly in the build script. They are a replacement for a module descriptor in an external repository.

クライアントモジュール依存関係を使うと、モジュールの推移的な依存関係をビルドスクリプトの中で直接定義できます。これは外部リポジトリにある実際のモジュールディスクリプタの代わりに使用されます。

dependencies {
    runtime module("org.codehaus.groovy:groovy:2.3.6") {
        dependency("commons-cli:commons-cli:1.0") {
            transitive = false
        }
        module(group: 'org.apache.ant', name: 'ant', version: '1.9.3') {
            dependencies "org.apache.ant:ant-launcher:1.9.3@jar",
                         "org.apache.ant:ant-junit:1.9.3"
        }
    }
}

This declares a dependency on Groovy. Groovy itself has dependencies. But Gradle does not look for an XML descriptor to figure them out but gets the information from the build file. The dependencies of a client module can be normal module dependencies or artifact dependencies or another client module. Also look at the API documentation for the ClientModule class.

この例では、Groovyに依存していることが宣言されています。Groovyは、それ自身別の依存関係を持っているのですが、ここではGradleはXMLディスクリプタではなく、ビルドスクリプト内の定義を見てGroovyの推移的な依存関係を決定します。 クライアントモジュールの依存関係としては、普通のモジュール依存関係の他、アーティファクトオンリー記法、また別のクライアントモジュール依存関係も使うことができます。APIドキュメントClientModuleも参考にしてください。

In the current release client modules have one limitation. Let's say your project is a library and you want this library to be uploaded to your company's Maven or Ivy repository. Gradle uploads the jars of your project to the company repository together with the XML descriptor file of the dependencies. If you use client modules the dependency declaration in the XML descriptor file is not correct. We will improve this in a future release of Gradle.

現在、クライアントモジュールには一つの制限があります。プロジェクトがライブラリをビルドするもので、そのライブラリを社内のMavenやIvyリポジトリにアップロードしたいとします。GradleはプロジェクトのjarをXMLディスクリプタファイルと一緒に社内リポジトリにアップロードするわけですが、クライアントモジュールを使っているとそのディスクリプタの依存関係宣言が正しいものにならないのです。将来のバージョンで修正される予定です。

Gradle distinguishes between external dependencies and dependencies on projects which are part of the same multi-project build. For the latter you can declare Project Dependencies.

Gradleでは、外部モジュール依存関係と、マルチプロジェクト内で別のプロジェクトを参照する依存関係は明確に区別されます。 後者はプロジェクト依存関係として宣言します。

dependencies {
    compile project(':shared')
}

For more information see the API documentation for ProjectDependency.

APIドキュメントProjectDependencyに詳しい情報が記載されています。

Multi-project builds are discussed in 57章マルチプロジェクトのビルド.

また、マルチプロジェクトについては、57章マルチプロジェクトのビルドで詳述されています。

File dependencies allow you to directly add a set of files to a configuration, without first adding them to a repository. This can be useful if you cannot, or do not want to, place certain files in a repository. Or if you do not want to use any repositories at all for storing your dependencies.

ファイル依存関係は、前もってファイルをリポジトリに格納することなく、直接コンフィギュレーションに追加することを可能にします。これは、何らかの理由であるファイルをリポジトリに置けない、または置きたくない場合に有用です。また、依存関係の保存先としてリポジトリを一切使いたくないという場合もこの依存関係が便利です。

To add some files as a dependency for a configuration, you simply pass a file collection as a dependency:

方法も簡単で、単にファイルコレクションを依存関係としてコンフィギュレーションに渡すだけです。

dependencies {
    runtime files('libs/a.jar', 'libs/b.jar')
    runtime fileTree(dir: 'libs', include: '*.jar')
}

File dependencies are not included in the published dependency descriptor for your project. However, file dependencies are included in transitive project dependencies within the same build. This means they cannot be used outside the current build, but they can be used with the same build.

ファイル依存関係は、公開されるディスクリプタファイルには含まれません。しかし、同じビルド内から参照された場合、その推移的な依存関係としては使用されます。 つまり、ファイル依存関係は、そのビルドの外部からは使用されませんが、同じビルド内のプロジェクトからは使用される、ということです。

You can declare which tasks produce the files for a file dependency. You might do this when, for example, the files are generated by the build.

ファイル依存関係では、どのタスクがファイルを生成するのか宣言することができます。依存ファイルがビルドで作成される場合などで使用されることがあります。

dependencies {
    compile files("$buildDir/classes") {
        builtBy 'compile'
    }
}

task compile << {
    println 'compiling classes'
}

task list(dependsOn: configurations.compile) << {
    println "classpath = ${configurations.compile.collect {File file -> file.name}}"
}

> gradle -q list
compiling classes
classpath = [classes]

You can declare a dependency on the API of the current version of Gradle by using the DependencyHandler.gradleApi() method. This is useful when you are developing custom Gradle tasks or plugins.

DependencyHandler.gradleApi()メソッドを使うと、そのビルドで使用しているGradleのAPIへ依存していることを宣言できます。 Gradleのカスタムタスクやプラグインを開発しているときによく使われます。

dependencies {
    compile gradleApi()
}

You can declare a dependency on the Groovy that is distributed with Gradle by using the DependencyHandler.localGroovy() method. This is useful when you are developing custom Gradle tasks or plugins in Groovy.

DependencyHandler.localGroovy()を使うと、Gradleに同梱されているGroovyへの依存関係を宣言できます。 これもGradleのカスタムタスクやプラグインを開発しているときによく使われます。

dependencies {
    compile localGroovy()
}

You can exclude a transitive dependency either by configuration or by dependency:

コンフィギュレーション単位、または依存関係単位で、特定の推移的な依存関係を除外することができます。

configurations {
    compile.exclude module: 'commons'
    all*.exclude group: 'org.gradle.test.excludes', module: 'reports'
}

dependencies {
    compile("org.gradle.test.excludes:api:1.0") {
        exclude module: 'shared'
    }
}

If you define an exclude for a particular configuration, the excluded transitive dependency will be filtered for all dependencies when resolving this configuration or any inheriting configuration. If you want to exclude a transitive dependency from all your configurations you can use the Groovy spread-dot operator to express this in a concise way, as shown in the example. When defining an exclude, you can specify either only the organization or only the module name or both. Also look at the API documentation of the Dependency and Configuration classes.

コンフィギュレーションに対してある依存関係を除外すると、そのコンフィギュレーション、および全ての継承コンフィギュレーションに含まれる全依存関係に対して推移的依存関係がフィルターされます。 また、全てのコンフィギュレーションにまとめて除外設定を適用したい場合は、例にあるようにGroovyの展開ドット演算子を使うと簡潔に記述できます。 除外設定は、organizationのみを指定することもできますし、モジュール名やその両方で指定しても構いません。 APIドキュメントのDependencyやConfigurationを参照してみてください。

Not every transitive dependency can be excluded - some transitive dependencies might be essential for correct runtime behavior of the application. Generally, one can exclude transitive dependencies that are either not required by runtime or that are guaranteed to be available on the target environment/platform.

全ての推移的な依存関係が除外できるとは限りません。アプリケーションの動作に必須な依存関係もあります。 一般的には、実行時に使われることがないものや、対象環境やプラットフォームでそれが使えると保証できているような場合には、その依存関係を除外することができます。

Should you exclude per-dependency or per-configuration? It turns out that in the majority of cases you want to use the per-configuration exclusion. Here are some typical reasons why one might want to exclude a transitive dependency. Bear in mind that for some of these use cases there are better solutions than exclusions! 除外設定は、依存関係単位かコンフィギュレーション単位、どちらで設定するべきでしょうか？ ほとんどの場合は、コンフィギュレーション単位で設定することになるでしょう。 推移的な依存関係を除外したいと考える、代表的な理由を挙げてみます。 なお、これらの中には、依存関係を除外してしまうよりも優れた解決手段があるものもあります。頭に留めておいてください！

Basically, in most of the cases excluding the transitive dependency should be done per configuration. This way the dependency declaration is more explicit. It is also more accurate because a per-dependency exclude rule does not guarantee the given transitive dependency does not show up in the configuration. For example, some other dependency, which does not have any exclude rules, might pull in that unwanted transitive dependency. 基本的には、ほとんどのケースでコンフィギュレーション単位の除外設定を使うべきです。これにより、依存関係の宣言がより明示的で正確なものになります。依存関係単位で除外ルールを設定しても、その依存関係が必ずしもコンフィギュレーションから取り除かれるとは限らないからです。 例えば、除外ルールを適用していない別の依存関係が、除外したはずの依存関係を引っ張ってきてしまうかもしれません。

Other examples of dependency exclusions can be found in the reference for the ModuleDependency or DependencyHandler classes.

リファレンスには、除外設定の他の例も記載されています。ModuleDependencyやDependencyHandlerを見てみてください。

All attributes for a dependency are optional, except the name. Which attributes are required for actually finding dependencies in the repository will depend on the repository type. See 「リポジトリ Repositories」. For example, if you work with Maven repositories, you need to define the group, name and version. If you work with filesystem repositories you might only need the name or the name and the version.

依存関係宣言の属性は、nameを除いて全てオプションです。ただ、実際にリポジトリから依存関係を見つけてくる際にどんな情報が必要になるのかは、リポジトリの種類により異なります。「リポジトリ Repositories」を参照してください。 例えば、Mavenリポジトリを使うときは、組織名、モジュール名、およびバージョンを指定する必要があります。一方、ただのファイルシステムをリポジトリにしている場合は、必要なのはモジュール名だけかもしれません。

dependencies {
    runtime ":junit:4.10", ":testng"
    runtime name: 'testng' 
}

You can also assign collections or arrays of dependency notations to a configuration:

また、依存関係定義のコレクションや属性をコンフィギュレーションに割り当てることもできます。

List groovy = ["org.codehaus.groovy:groovy-all:2.3.6@jar",
               "commons-cli:commons-cli:1.0@jar",
               "org.apache.ant:ant:1.9.3@jar"]
List hibernate = ['org.hibernate:hibernate:3.0.5@jar',
                  'somegroup:someorg:1.0@jar']
dependencies {
    runtime groovy, hibernate
}

In Gradle a dependency can have different configurations (as your project can have different configurations). If you don't specify anything explicitly, Gradle uses the default configuration of the dependency. For dependencies from a Maven repository, the default configuration is the only possibility anyway. If you work with Ivy repositories and want to declare a non-default configuration for your dependency you have to use the map notation and declare:

Gradleでは、依存先のモジュールが複数のコンフィギュレーションを公開していることがあります(自分のプロジェクトでも様々なコンフィギュレーションを定義できたことを思い出してください)。 特に明示しないかぎり、Gradleはその依存関係のdefaultコンフィギュレーションを使用します。 Mavenリポジトリではdefaultコンフィギュレーションが使用できる唯一のコンフィギュレーションなのでいいのですが、Ivyリポジトリを使う場合、default以外のコンフィギュレーションを参照するときはマップ記法で次のように指定しなければなりません。

dependencies {
    runtime group: 'org.somegroup', name: 'somedependency', version: '1.0', configuration: 'someConfiguration'
}

To do the same for project dependencies you need to declare:

プロジェクト依存関係で同じことをするには、次のように定義する必要があります。

dependencies {
    compile project(path: ':api', configuration: 'spi')
}

You can generate dependency reports from the command line (see 「プロジェクトの依存関係一覧Listing project dependencies」). With the help of the Project report plugin (see 41章プロジェクトレポートプラグイン) such a report can be created by your build.

Gradleには、依存関係に関するレポートを生成できるコマンドが用意されています(「プロジェクトの依存関係一覧Listing project dependencies」参照)。 また、プロジェクトレポートプラグイン(41章プロジェクトレポートプラグイン)を使えば、ビルドのタスクでそのレポートを作成することもできます。

Since Gradle 1.2 there is also a new programmatic API to access the resolved dependency information. The dependency reports (see the previous paragraph) are using this API under the covers. The API lets you walk the resolved dependency graph and provides information about the dependencies. In future releases the API will grow to provide more information about the resolution result. For more information about the API please refer to the Javadocs on ResolvableDependencies.getResolutionResult(). Potential usages of the ResolutionResult API: Gradle1.2からは、解決した依存関係に関する情報に、プログラム的にアクセスできるAPIもあります。 先ほど述べた依存関係のレポートを作成するときも、水面下でこのAPIが使用されています。 このAPIを使えば、解決した依存関係グラフを走査したり、情報を取得したりすることが可能です。 また、近くこのAPIを更に拡張し、解決結果についてもっと情報を取得できるようにする予定です。 APIについての詳細はJavadoc(ResolvableDependencies.getResolutionResult())を参照してください。 API(ResolutionResult)の使い道として考えられるのは、

Maven and Ivy repositories support the use of various transport protocols. At the moment the following protocols are supported:

To define a repository use the repositories configuration block. Within the repositories closure, a Maven repository is declared with maven. An Ivy repository is declared with ivy. The transport protocol is part of the URL definition for a repository. The following build script demonstrates how to create a HTTP-based Maven and Ivy repository:

repositories {
    maven {
        url "http://repo.mycompany.com/maven2"
    }

    ivy {
        url "http://repo.mycompany.com/repo"
    }
}

If authentication is required for a repository, the relevant credentials can be provided. The following example shows how to provide username/password-based authentication for SFTP repositories:

repositories {
    maven {
        url "sftp://repo.mycompany.com:22/maven2"
        credentials {
            username 'user'
            password 'password'
        }
    }

    ivy {
        url "sftp://repo.mycompany.com:22/repo"
        credentials {
            username 'user'
            password 'password'
        }
    }
}

To add the central Maven 2 repository (http://repo1.maven.org/maven2) simply add this to your build script: Maven2のセントラルリポジトリ(http://repo1.maven.org/maven2)は、次のように簡単に追加できます。

repositories {
    mavenCentral()
}

Now Gradle will look for your dependencies in this repository.

Warning: Be aware that the central Maven 2 repository is HTTP only and HTTPS is not supported. If you need a public HTTPS enabled central repository, you can use the JCenter public repository (see 「Maven JCenterリポジトリ Maven JCenter repository」).

これで、Gradleはこのリポジトリから依存関係を探すようになります。

Bintray's JCenter is an up-to-date collection of all popular Maven OSS artifacts, including artifacts published directly to Bintray.

BintrayのJCenterには、Bintrayに直接公開されたアーティファクトだけでなく、ポピュラーなMaven上のOSSライブラリが全て集められ、随時更新されています。

To add the JCenter Maven repository (https://jcenter.bintray.com) simply add this to your build script: JCenter Mavenリポジトリ(https://jcenter.bintray.com)は、次のように簡単に追加できます。

repositories {
    jcenter()
}

Now Gradle will look for your dependencies in the JCenter repository. jcenter() uses HTTPS to connect to the repository. If you want to use HTTP you can configure jcenter():

これで、GradleはJCenterリポジトリから依存関係を探すようになります。 jcenter() uses HTTPS to connect to the repository. If you want to use HTTP you can configure jcenter():

repositories {
    jcenter {
        url "http://jcenter.bintray.com/"
    }
}

To use the local Maven cache as a repository you can do:

Mavenのローカルキャッシュをリポジトリとして使うには、次のようにします。

repositories {
    mavenLocal()
}

Gradle uses the same logic as Maven to identify the location of your local Maven cache. If a local repository location is defined in a settings.xml, this location will be used. The settings.xml in USER_HOME/.m2 takes precedence over the settings.xml in M2_HOME/conf. If no settings.xml is available, Gradle uses the default location USER_HOME/.m2/repository.

Gradleは、Mavenが使っているのと同じロジックでローカルキャッシュの場所を決定します。 もしローカルリポジトリの場所がsettings.xmlで定義されていれば、そこが使用されます。 USER_HOME/.m2のsettings.xmlは、M2_HOME/confのsettings.xmlよりも優先されます。 使用できるsettings.xmlがなければ、デフォルトのUSER_HOME/.m2/repositoryがローカルキャッシュの場所になります。

For adding a custom Maven repository you can do:

カスタムのMavenリポジトリを追加するには、次のようにします。

repositories {
    maven {
        url "http://repo.mycompany.com/maven2"
    }
}

Sometimes a repository will have the POMs published to one location, and the JARs and other artifacts published at another location. To define such a repository, you can do:

POMとJARなどのアーティファクトを別々の場所に配置するようなリポジトリもあります。このようなリポジトリを設定するには、次のようにします

repositories {
    maven {
        // Look for POMs and artifacts, such as JARs, here
        url "http://repo2.mycompany.com/maven2"
        // Look for artifacts here if not found at the above location
        artifactUrls "http://repo.mycompany.com/jars"
        artifactUrls "http://repo.mycompany.com/jars2"
    }
}

Gradle will look at the first URL for the POM and the JAR. If the JAR can't be found there, the artifact URLs are used to look for JARs.

Gradleは、最初のURLを、POMとJARを探すために使用します。JARがそこで見つからなかった場合は、アーティファクトURLを使ってJARを探しに行きます。

repositories {
    maven {
        credentials {
            username 'user'
            password 'password'
        }
        url "http://repo.mycompany.com/maven2"
    }
}

If you want to use a (flat) filesystem directory as a repository, simply type:

ファイルシステム上の(フラットな)ディレクトリをリポジトリとして使用したい場合は、単に次のようにタイプしてください。

repositories {
    flatDir {
        dirs 'lib'
    }
    flatDir {
        dirs 'lib1', 'lib2'
    }
}

This adds repositories which look into one or more directories for finding dependencies. If you only work with flat directory resolvers you don't need to set all attributes of a dependency. See 「オプション属性 Optional attributes」

これで、依存関係を取得するリポジトリとして複数のディレクトリが追加されました。 このフラットディレクトリ・リゾルバのみ使うのであれば、依存関係定義ですべての属性を定義する必要はありません。「オプション属性 Optional attributes」をご参照ください。

To access a repository:

リポジトリ定義にアクセスするには、

println repositories.localRepository.name
    println repositories['localRepository'].name

To configure a repository:

リポジトリの設定を変更するには、

repositories {
    flatDir {
        name 'localRepository'
    }
}
repositories {
    localRepository {
        dirs 'lib'
    }
}
repositories.localRepository {
    dirs 'lib'
}

Gradle, thanks to Ivy under its hood, is extremely flexible regarding repositories:

Gradleは、水面下でIvyを使っているおかげで、リポジトリに関しては非常に高い柔軟性を持っています。たとえば、

Let's say, you declare a dependency on the junit:junit:3.8.2 library. Now how does Gradle find it in the repositories? Somehow the dependency information has to be mapped to a path. In contrast to Maven, where this path is fixed, with Gradle you can define a pattern that defines what the path will look like. Here are some examples: junit:junit:3.8.2へ依存していることを定義したとしましょう。このとき、Gradleはどのようにしてリポジトリからjunitを探すのでしょうか。そのためには、なんとかしてこの依存関係情報をファイルパスに変換する必要があります。Mavenではその変換方法は変更できませんが、Gradleではパスをどのように決定するか、そのパターンを自分で定義できます。たとえば、 ^[24]

// Maven2 レイアウト (Maven2と互換性があるとマークすれば、組織(グループ)フォルダは組織名のドットに従ってサブフォルダに分割される)
someroot/[organisation]/[module]/[revision]/[module]-[revision].[ext]

// 典型的なIvyリポジトリレイアウト(組織フォルダがサブフォルダに分割されない)
someroot/[organisation]/[module]/[revision]/[type]s/[artifact].[ext]

// シンプルなレイアウト(組織名は使用せず、フォルダをネストしない)
someroot/[artifact]-[revision].[ext]

To add any kind of repository (you can pretty easy write your own ones) you can do:

上記のどのリポジトリも、以下のようにして参照できます。

repositories {
    ivy {
        ivyPattern "$projectDir/repo/[organisation]/[module]-ivy-[revision].xml"
        artifactPattern "$projectDir/repo/[organisation]/[module]-[revision](-[classifier]).[ext]"
    }
}

An overview of which Resolvers are offered by Ivy and thus also by Gradle can be found here. With Gradle you just don't configure them via XML but directly via their API.

Ivyで(つまりGradleで)どんなリゾルバを使えるかはここで見ることができます。Gradleでは、XMLを経由することなく直接これらのAPIを操作できます。

Forcing a module version tells Gradle to always use a specific version for given dependency (transitive or not), overriding any version specified in a published module descriptor. This can be very useful when tackling version conflicts - for more information see 「バージョン競合の解決 Resolve version conflicts」.

指定した依存関係について、（推移的かどうかにかかわらず）指定したバージョンを使うよう解決処理を設定できます。 依存関係は、グループ名と名前で指定します。この機能は、バージョンの競合に四苦八苦している際にとても便利です。詳細については、「バージョン競合の解決 Resolve version conflicts」を参照してください。

Force versions can also be used to deal with rogue metadata of transitive dependencies. If a transitive dependency has poor quality metadata that leads to problems at dependency resolution time, you can force Gradle to use a newer, fixed version of this dependency. For an example, see the ResolutionStrategy class in the API documentation. Note that 'dependency resolve rules' (outlined below) provide a more powerful mechanism for replacing a broken module dependency. See 「バージョンのブラックリストと差し替え Blacklisting a version with a replacement」.

また、推移的な依存関係のメタデータが壊れている場合もこれで対処できることがあります。推移的な依存関係のメタデータがあまりに低品質で、依存関係を解決する際に問題が発生している場合、モジュールのバージョンを修正された新バージョンに強制できます。ResolutionStrategyの例を参照してください。また、「依存関係解決ルール」は壊れたモジュールを置き換える更に強力な機構を提供します。「バージョンのブラックリストと差し替え Blacklisting a version with a replacement」を参照してください。

A dependency resolve rule is executed for each resolved dependency, and offers a powerful api for manipulating a requested dependency prior to that dependency being resolved. This feature is incubating, but currently offers the ability to change the group, name and/or version of a requested dependency, allowing a dependency to be substituted with a completely different module during resolution.

依存関係解決ルールは、全ての依存関係に対して実行され、要求された依存関係を解決前に操作する強力なAPIを提供します。 この機能は試験的なものですが、要求した依存関係のグループ名や名前、バージョンを変更し、解決処理中に依存関係を完全に別のモジュールに差し替えてしまうことが可能です。

Dependency resolve rules provide a very powerful way to control the dependency resolution process, and can be used to implement all sorts of advanced patterns in dependency management. Some of these patterns are outlined below. For more information and code samples see the ResolutionStrategy class in the API documentation.

依存関係解決ルールは依存関係をコントロールする非常に強力な手段で、依存関係管理における先進的なパターンを全て実装できます。 いくつかのパターンの概要を以下に紹介します。詳細な情報やコードサンプル等はResolutionStrategyをご参照ください。

configurations.all {
    resolutionStrategy.eachDependency { DependencyResolveDetails details ->
        if (details.requested.group == 'org.gradle') {
            details.useVersion '1.4'
        }
    }
}

configurations.all {
    resolutionStrategy.eachDependency { DependencyResolveDetails details ->
        if (details.requested.version == 'default') {
            def version = findDefaultVersionInCatalog(details.requested.group, details.requested.name)
            details.useVersion version
        }
    }
}

def findDefaultVersionInCatalog(String group, String name) {
    //some custom logic that resolves the default version into a specific version
    "1.0"
}

configurations.all {
    resolutionStrategy.eachDependency { DependencyResolveDetails details ->
        if (details.requested.group == 'org.software' && details.requested.name == 'some-library' && details.requested.version == '1.2') {
            //prefer different version which contains some necessary fixes
            details.useVersion '1.2.1'
        }
    }
}

configurations.all {
    resolutionStrategy.eachDependency { DependencyResolveDetails details ->
        if (details.requested.name == 'groovy-all') {
            //prefer 'groovy' over 'groovy-all':
            details.useTarget group: details.requested.group, name: 'groovy', version: details.requested.version
        }
        if (details.requested.name == 'log4j') {
            //prefer 'log4j-over-slf4j' over 'log4j', with fixed version:
            details.useTarget "org.slf4j:log4j-over-slf4j:1.7.7"
        }
    }
}

dependencies {
    components {
        module("com.google.collections:google-collections").replacedBy("com.google.guava:guava")
    }
}

Gradle's Ivy repository implementations support the equivalent to Ivy's dynamic resolve mode. Normally, Gradle will use the rev attribute for each dependency definition included in an ivy.xml file. In dynamic resolve mode, Gradle will instead prefer the revConstraint attribute over the rev attribute for a given dependency definition. If the revConstraint attribute is not present, the rev attribute is used instead.

GradleのIvyレポジトリ実装は、Ivyの動的解決モードと同等のものをサポートしています。通常、Gradleは依存関係についてivy.xmlファイルで定義されているrev属性を使用しますが、動的解決モードでは、Gradleはrev属性の代わりにrevConstraint属性を優先して使用します。revConstraintが未定義の時はrev属性を使用します。

To enable dynamic resolve mode, you need to set the appropriate option on the repository definition. A couple of examples are shown below. Note that dynamic resolve mode is only available for Gradle's Ivy repositories. It is not available for Maven repositories, or custom Ivy DependencyResolver implementations.

動的解決モードを有効にするには、リポジトリ定義に適切なオプションを設定する必要があります。いくつかの例を以下に挙げます。動的解決モードは、Gradle組み込みのIvyリポジトリ定義でしか使用できないことに注意してください。Mavenリポジトリや独自DependencyResolver実装のIvyリポジトリでは使用できません。

// Can enable dynamic resolve mode when you define the repository
repositories {
    ivy {
        url "http://repo.mycompany.com/repo"
        resolve.dynamicMode = true
    }
}

// Can use a rule instead to enable (or disable) dynamic resolve mode for all repositories
repositories.withType(IvyArtifactRepository) {
    resolve.dynamicMode = true
}

Each module (also called component) has metadata associated with it, such as its group, name, version, dependencies, and so on. This metadata typically originates in the module's descriptor. Metadata rules allow certain parts of a module's metadata to be manipulated from within the build script. They take effect after a module's descriptor has been downloaded, but before it has been selected among all candidate versions. This makes metadata rules another instrument for customizing dependency resolution.

One piece of module metadata that Gradle understands is a module's status scheme. This concept, also known from Ivy, models the different levels of maturity that a module transitions through over time. The default status scheme, ordered from least to most mature status, is integration, milestone, release. Apart from a status scheme, a module also has a (current) status, which must be one of the values in its status scheme. If not specified in the (Ivy) descriptor, the status defaults to integration for Ivy modules and Maven snapshot modules, and release for Maven modules that aren't snapshots.

A module's status and status scheme are taken into consideration when a latest version selector is resolved. Specifically, latest.someStatus will resolve to the highest module version that has status someStatus or a more mature status. For example, with the default status scheme in place, latest.integration will select the highest module version regardless of its status (because integration is the least mature status), whereas latest.release will select the highest module version with status release. Here is what this looks like in code:

dependencies {
    config1 "sea.fish:tuna:latest.integration"
    config2 "sea.fish:tuna:latest.release"
}

task listFish << {
    configurations.config1.each { println it.name }
    println()
    configurations.config2.each { println it.name}
}

> gradle -q listFish
tuna-1.5.jar

tuna-1.4.jar

The next example demonstrates latest selectors based on a custom status scheme declared in a module metadata rule:

dependencies {
    config3 "air.birds:albatross:latest.silver"
    components {
        eachComponent { ComponentMetadataDetails details ->
            if (details.id.group == "air.birds") {
                details.statusScheme = ["bronze", "silver", "gold", "platinum"]
            }
        }
    }
}

task listBirds << {
    configurations.config3.each { println it.name }
}

> gradle -q listBirds
albatross-2.0.jar

Gradle can also create component metadata rules utilizing Ivy-specific metadata for modules resolved from an Ivy repository. Values from the Ivy descriptor are made available via the IvyModuleDescriptor interface.

dependencies {
    components {
        eachComponent { ComponentMetadataDetails details, IvyModuleDescriptor ivyModule ->
            if (details.id.group == 'my.org' && ivyModule.branch == 'testing') {
                details.changing = true
            }
        }
    }
}

Component selection rules define how versions should be selected when multiple versions are available that match a given set of coordinates. Rules are applied against every available version and allow the version to be explicitly rejected by rule. This allows Gradle to select alternate versions when the alternate version is not known in advance.

Rules are configured via the ComponentSelectionRules object. Each rule configured will be called with a ComponentSelection object as an argument which contains information about the version being requested and the candidate version being considered. Calling ComponentSelection.reject() causes the given candidate version to be explicitly rejected, in which case the candidate will not be considered for the selector.

The following example shows a rule that disallows a particular version of a module but allows the default version selection rules to choose the next best candidate. If the version requested was 1.+, and versions 1.1, 1.0.1 and 1.0 were available, it would reject 1.1 and select the next newest version available (1.0.1).

configurations {
    rejectConfig {
        resolutionStrategy {
            componentSelection {
                // Accept the highest version matching the requested version that isn't '1.1'
                all { ComponentSelection selection ->
                    if (selection.candidate.group == 'org.sample' && selection.candidate.module == 'api' && selection.candidate.version == '1.1') {
                        selection.reject("version 1.1 is broken for 'org.sample:api'")
                    }
                }
            }
        }
    }
}

Note that version selection is applied starting with the highest version first. The version selected will be the first version found that all component selection rules accept. A version is considered accepted if a rule does not explicitly reject it.

Similarly, rules can be targeted at specific modules. Modules must be specified in the form of "group:module".

configurations {
    targetConfig {
        resolutionStrategy {
            componentSelection {
                module("org.sample:api") { ComponentSelection selection ->
                    if (selection.candidate.version == "1.1") {
                        selection.reject("known bad version")
                    }
                }
            }
        }
    }
}

Component selection rules can also consider component metadata when selecting a version. Possible metadata arguments that can be considered are ComponentMetadata and IvyModuleDescriptor.

configurations {
    rejectConfig {
        resolutionStrategy {
            componentSelection {
                // Reject any versions with a status of 'experimental'
                all { ComponentSelection selection, ComponentMetadata metadata ->
                    if (selection.candidate.group == 'org.sample' && selection.candidate.module == 'api') {
                        if (metadata.status == 'experimental') {
                            selection.reject("don't use experimental candidates of 'org.sample:api'")
                        }
                    }
                }
                // Accept the highest version with a branch of 'testing' or a status of 'milestone'
                all { ComponentSelection selection, IvyModuleDescriptor descriptor, ComponentMetadata metadata ->
                    if (selection.candidate.group == 'org.sample' && selection.candidate.module == 'api') {
                        if (descriptor.branch != 'testing' && metadata.status != 'milestone') {
                            selection.reject("'org.sample:api' must have testing branch or milestone status")
                        }
                    }
                }
            }
        }
    }
}

Note that a ComponentSelection argument is always required when declaring a component selection rule but the metadata arguments are optional.

You can fine-tune certain aspects of caching using the ResolutionStrategy for a configuration.

キャッシングについて、いくつかの動作は設定でResolutionStrategyを使うことで微調整することができます。

By default, Gradle caches dynamic versions for 24 hours. To change how long Gradle will cache the resolved version for a dynamic version, use:

デフォルトでは、Gradleは動的バージョンを24時間キャッシュします。動的バージョンを具体的なバージョンに解決したとき、それをどれだけの長さキャッシュするか制御するには、以下のようにします。

configurations.all {
    resolutionStrategy.cacheDynamicVersionsFor 10, 'minutes'
}

By default, Gradle caches changing modules for 24 hours. To change how long Gradle will cache the meta-data and artifacts for a changing module, use:

デフォルトでは、Gradleは変更性モジュールを24時間キャッシュします。変更性モジュールのメタデータとアーティファクトをどれだけの長さキャッシュするか制御するには、以下のようにします。

configurations.all {
    resolutionStrategy.cacheChangingModulesFor 4, 'hours'
}

For more details, take a look at the API documentation for ResolutionStrategy.

詳しくはAPIドキュメントでResolutionStrategyを参照してください。

There is another way to deal with transitive dependencies without XML descriptor files. You can do this with Gradle, but we don't recommend it. We mention it for the sake of completeness and comparison with other build tools.

The trick is to use only artifact dependencies and group them in lists. This will directly express your first level dependencies and your transitive dependencies (see 「オプション属性 Optional attributes」). The problem with this is that Gradle dependency management will see this as specifying all dependencies as first level dependencies. The dependency reports won't show your real dependency graph and the compile task uses all dependencies, not just the first level dependencies. All in all, your build is less maintainable and reliable than it could be when using client modules, and you don't gain anything.

そのトリックは、アーティファクトオンリー記法を使い、それらをリストでグループ化するというものです。 この方法でも、なにが直接の依存関係で、何が推移的な依存関係なのか、なんとか表現することはできました(「オプション属性 Optional attributes」を参照してください)。 しかし、この方法の欠点は、Gradleの依存関係管理システムが、すべての依存関係を直接の依存関係として取り扱ってしまうことです。依存関係のレポートを出力させても正しい依存関係グラフは出てきませんし、compileタスクでも、直接的な依存関係だけでなく、すべての依存関係が使われてしまうことになります。クライアントモジュールを使った場合に比べると、大抵は保守性も信頼性も落ちてしまいますし、特にその分なにか利点があるわけでもありません。