Gradle-概要

「Gradleはオープンソースのビルド自動化システムです」

AntとMavenは、JAVAマーケットプレイスで大きな成功を収めました。 Antは2000年にリリースされた最初のビルドツールであり、手続き型プログラミングのアイデアに基づいて開発されています。後で、Apache-IVYの助けを借りてネットワーク経由でプラグインと依存関係管理を受け入れる機能で改善されます。主な欠点は、ビルドスクリプトを記述するためのフォーマットとしてのXMLであり、階層的であることは手続き型プログラミングには適しておらず、XMLは扱いにくいほど大きくなる傾向があります。

Mavenは2004年に導入されました。 ANTに比べて大幅に改善されています。構造を変更し、ビルド仕様の作成にXMLを使用し続けます。 Mavenは規則に依存しており、ネットワーク経由で依存関係をダウンロードできます。 Mavenの主な利点は、そのライフサイクルです。複数のプロジェクトに対して同じライフサイクルを継続的に実行します。これには柔軟性が犠牲になります。 Mavenは、依存関係管理の問題にも直面しています。同じライブラリのバージョン間の競合をうまく処理せず、複雑なカスタマイズされたビルドスクリプトは、実際にはANTよりもMavenで記述するのが困難です。

最後に、Gradleは2012年に登場しました。 Gradleは、両方のツールの効率的な機能を備えています。

Gradleの特徴

以下は、Gradleが提供する機能のリストです。

宣言型ビルドと慣習ビルド-Gradleは、Groovy言語に基づいた個別のドメイン固有言語（DSL）で利用できます。 Gradleは宣言型言語要素を提供します。また、これらの要素は、Java、Groovy、OSGI、Web、およびScalaの慣例ごとのサポートも提供します。
依存関係ベースのプログラミングの言語-宣言型言語は、ビルドで完全に活用できる汎用タスクグラフの上部にあります。
ビルドの構築-Gradleでは、最終的に共通の設計原則を適用できます。あなたのビルドに。ビルドに最適な構造を提供するため、適切に構造化され、メンテナンスが容易な、包括的なビルドを設計できます。
Deep API -このAPIを使用すると、構成を監視およびカスタマイズできます。コアへの実行動作。
* Gradleスケール*-Gradleは、シンプルで単一のプロジェクトビルドから巨大なエンタープライズマルチプロジェクトビルドまで、生産性を簡単に向上させることができます。
マルチプロジェクトビルド-Gradleはマルチプロジェクトビルドをサポートし、部分ビルドをサポートします。サブプロジェクトをビルドする場合、Gradleは依存するすべてのサブプロジェクトをビルドします。
ビルドを管理するさまざまな方法-Gradleは、依存関係を管理するためのさまざまな戦略をサポートしています。
* Gradleは最初のビルド統合ツールです*-GradleはANTで完全にサポートされていますタスク、依存関係を公開および取得するためのMavenおよびlvyリポジトリインフラストラクチャ。 Gradleは、Maven pom.xmlをGradleスクリプトに変換するコンバーターも提供します。
移行の容易さ-Gradleは、どのような構造にも簡単に適応できます。だからライブスクリプトをビルドできるのと同じブランチでGradleビルドをいつでも開発できます。
Gradle Wrapper -Gradle Wrapperでは、GradleがインストールされていないマシンでGradleビルドを実行できます。これは、サーバーの継続的な統合に役立ちます。
無料のオープンソース-Gradleはオープンソースプロジェクトであり、Apacheの下でライセンスされていますソフトウェアライセンス（ASL）。
Groovy -GradleのビルドスクリプトはGroovyで記述されています。 Gradleの全体設計は厳格なフレームワークとしてではなく、言語としての使用を指向しています。また、Groovyでは、いくつかの抽象化を使用して独自のスクリプトを作成できます。 Gradle API全体は、Groovy言語で完全に設計されています。

なぜGroovyなのか？

完全なGradle APIは、Groovy言語を使用して設計されています。これは、XMLよりも内部DSLの利点です。 Gradleは、その中心にある汎用ビルドツールです。主な焦点はJavaプロジェクトです。このようなプロジェクトでは、チームメンバーはJavaに非常に精通しているため、ビルドはすべてのチームメンバーに対して可能な限り透過的である必要があります。

Python、Groovy、Rubyなどの言語は、フレームワークの構築に適しています。 Groovyが選ばれた理由は、Javaを使用している人々にとってはるかに優れた透明性を提供するからです。 Groovyの基本構文はJavaと同じです。 Groovyは、さらに多くの機能を提供します。

Gradle-インストール

Gradleは、javaに基づいてビルドされるビルドツールです。 Gradleフレームワークをインストールする前にインストールする必要がある前提条件がいくつかあります。

前提条件

JDKとGroovyは、Gradleインストールの前提条件です。

Gradleを使用するには、システムにJDKバージョン6以降がインストールされている必要があります。インストールされ、JAVA_HOME環境変数に設定されるJDKライブラリを使用します。
Gradleには独自のGroovyライブラリが搭載されているため、Groovyを明示的にインストールする必要はありません。インストールされている場合、Gradleはそれを無視します。

以下は、Gradleをシステムにインストールする手順です。

ステップ1-JAVAインストールの確認

まず、システムにJava Software Development Kit（SDK）をインストールする必要があります。これを確認するには、作業しているプラットフォームのいずれかで Java –version コマンドを実行します。

Windowsの場合-

次のコマンドを実行して、Javaのインストールを確認します。システムにJDK 1.8をインストールしました。

C:\> java -version

出力-

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

Linuxの場合-

次のコマンドを実行して、Javaのインストールを確認します。システムにJDK 1.8をインストールしました。

$ java - version

出力-

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

このチュートリアルの読者は、Java SDKバージョン1.8.0_66がシステムにインストールされていることを前提としています。

ステップ2-Gradleビルドファイルのダウンロード

Gradleのダウンロードリンクから最新バージョンのGradleをダウンロードします。リファレンスページで、[完全な配布]リンクをクリックします。この手順は、すべてのプラットフォームで共通です。このために、完全な配布ファイルをダウンロードフォルダーに取得します。

ステップ3-Gradleの環境を設定する

環境を設定すると、配布ファイルを抽出し、ライブラリファイルを適切な場所にコピーする必要があります。 GRADLE_HOME および PATH 環境変数を設定します。

この手順はプラットフォームに依存します。

Windowsの場合-

ダウンロードした gradle-2.11-all.zip という名前のzipファイルを抽出し、配布ファイルを Downloads \ gradle-2.11 \ から C：\ gradle \ の場所にコピーします。

その後、 C：\ gradle および C：\ gradle \ bin ディレクトリを GRADLE_HOME および PATH システム変数に追加します。 *コンピューターを右クリック→プロパティをクリック→システムの詳細設定→環境変数をクリック*の指示に従ってください。システム変数を作成および編集するためのダイアログボックスがあります。 GRADLE_HOME変数を作成するための新しいボタンをクリックします（左側のスクリーンショットに従ってください）。既存のPathシステム変数を編集するには、[編集]をクリックします（右側のスクリーンショットに従います）。以下のスクリーンショットに従ってください。

Gradleのセットアップ環境

Linuxの場合-

ダウンロードした gradle-2.11-all.zip という名前のzipファイルを解凍すると、 gradle-2.11 という名前の解凍済みファイルが見つかります。

以下を使用して、配布ファイルを Downloads/gradle-2.11/ から /opt/gradle/ の場所に移動できます。ダウンロードディレクトリからこの操作を実行します。

$ sudo mv gradle-2.11/opt/gradle

〜/.bashrcファイルを編集し、次の内容をそのファイルに貼り付けて保存します。

export ORIENT_HOME =/opt/gradle
export PATH = $PATH:

次のコマンドを実行して、*〜/.bashrc *ファイルを実行します。

$ source ~/.bashrc

ステップ4：Gradleのインストールを確認する

Windowsの場合：

コマンドプロンプトで次のコマンドを実行できます。

C:\> gradle –v

出力：そこにGradleバージョンがあります。

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978
Groovy: 2.4.4

Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Windows 8.1 6.3 amd64

Linuxの場合：

ターミナルで次のコマンドを実行できます。

$ gradle –v

出力：そこにGradleバージョンがあります。

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978

Groovy: 2.4.4
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Linux 3.13.0-74-generic amd64

Gradle-ビルドスクリプト

Gradleは、2つのことを処理するためのスクリプトファイルを作成します。 1つは projects で、もう1つは tasks です。すべてのGradleビルドは、1つ以上のプロジェクトを表します。プロジェクトは、ライブラリJARまたはWebアプリケーションを表すか、他のプロジェクトによって生成されたJARからアセンブルされたZIPを表す場合があります。簡単に言えば、プロジェクトはさまざまなタスクで構成されています。タスクとは、ビルドが実行する作業を意味します。タスクは、いくつかのクラスのコンパイル、JARの作成、Javadocの生成、またはいくつかのアーカイブのリポジトリへの公開などです。

Gradleは、スクリプトの作成に* Groovy言語*を使用します。

ビルドスクリプトの作成

Gradleは、ビルドを記述するためのドメイン固有言語（DSL）を提供します。これはGroovy言語を使用して、ビルドの記述を容易にします。 Gradleの各ビルドスクリプトはUTF-8を使用してエンコードされ、オフラインで保存され、build.gradleという名前が付けられます。

build.gradle

Groovyスクリプトを使用して、タスクとプロジェクトについて説明しています。 Gradleコマンドを使用してGradleビルドを実行できます。このコマンドは、 build.gradle というファイルを探します。 finddevguides を出力する小さなスクリプトを表す次の例を見てください。次のスクリプトをコピーして、 build.gradle という名前のファイルに保存します。このビルドスクリプトは、finddevguides文字列を出力するために使用されるタスク名helloを定義します。

task hello {
   doLast {
      println 'finddevguides'
   }
}

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q hello

出力：

finddevguides

タスクがANTのターゲットと同様に機能すると考える場合、そうです-GradleタスクはANTターゲットと同等です。

*doLast* ステートメントへのショートカット（記号 *<<* を表す）を指定することにより、このhelloタスクを単純化できます。 このショートカットを上記のタスク *hello* に追加すると、次のスクリプトのようになります。

task hello << {
   println 'finddevguides'
}

上記と同じように、 gradle –q hello コマンドを使用して上記のスクリプトを実行できます。

Gradeスクリプトは主に2つの実際のオブジェクトを使用しました。1つはプロジェクトオブジェクトで、もう1つはスクリプトオブジェクトです。

プロジェクトオブジェクト-各スクリプトは、1つまたは複数のプロジェクトについて説明します。実行中に、このスクリプトはプロジェクトオブジェクトを構成します。プロジェクトオブジェクトに委任されたビルドスクリプトでいくつかのメソッドを呼び出し、プロパティを使用できます。

*Script Object* -Gradleは、スクリプトインターフェイスを実装するクラスにスクリプトコードを取り込み、実行します。 これは、スクリプトインターフェイスによって宣言されたすべてのプロパティとメソッドが、スクリプトで使用できることを意味します。

次の表は、*標準プロジェクトプロパティ*のリストを定義しています。これらのプロパティはすべて、ビルドスクリプトで使用できます。

Sr. No.	Name	Type	Default Value
1	project	Project	The Project instance
2	name	String	The name of the project directory.
3	path	String	The absolute path of the project.
4	description	String	A description for the project.
5	projectDir	File	The directory containing the build script.
6	buildDir	File	projectDir/build
7	group	Object	Unspecified
8	version	Object	Unspecified
9	ant	AntBuilder	An AntBuilder instance

Groovyの基本

Gradleビルドスクリプトは、完全な長さのGroovy APIを使用します。スタートアップとして、次の例を見てください。

次の例では、文字列を大文字に変換する方法について説明します。

以下のコードをコピーして build.gradle ファイルに保存します。

task upper << {
   String expString = 'TUTORIALS point'
   println "Original: " + expString
   println "Upper case: " + expString.toUpperCase()
}

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q upper

出力：

Original: TUTORIALS point
Upper case: TUTORIALS POINT

次の例では、暗黙的なパラメーター（$ it）の値を4回出力する方法について説明します。

次のコードをコピーして build.gradle ファイルに保存します。

task count << {
   4.times {
      print "$it "
   }
}

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

$ gradle –q count

出力：

0 1 2 3

Groovy言語は、以下で説明するいくつかの重要な機能の中で多くの機能を提供します。

Groovy JDKメソッド

Groovyは、多くの便利なメソッドを標準Javaクラスに追加します。たとえば、JDKのIterable APIは、Iterable Interfaceの要素を反復処理する* each（）*メソッドを実装します。

次のコードをコピーして build.gradle ファイルに保存します。

task groovyJDK << {
   String myName = "Marc";
   myName.each() {
      println "${it}"
   };
}

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q groovyJDK

出力：

M
a
r
c

プロパティアクセサ

参照を指定することにより、特定のプロパティの適切なgetterおよびsetterメソッドに自動的にアクセスできます。

次のスニペットは、プロパティ buildDir のgetterおよびsetterメソッドの構文を定義しています。

//Using a getter method
println project.buildDir
println getProject().getBuildDir()

//Using a setter method
project.buildDir = 'target'
getProject().setBuildDir('target')

メソッド呼び出しのオプションの括弧

Groovyには、メソッド呼び出しに特別な機能が含まれています。メソッド呼び出しの場合、括弧はオプションです。この機能は、Gradleスクリプトにも適用されます。

次の構文を見てください。これは、 test オブジェクトの systemProperty を呼び出すメソッドを定義します。

test.systemProperty 'some.prop', 'value'
test.systemProperty('some.prop', 'value')

メソッドの最後のパラメーターとしてのクロージャー

Gradle DSLは多くの場所でクロージャーを使用します。メソッドの最後のパラメーターがクロージャーである場合、メソッド呼び出しの後にクロージャーを配置できます。

次のスニペットは、クロージャーがrepositories（）メソッドのパラメーターとして使用する構文を定義しています。

repositories {
   println "in a closure"
}
repositories() {
   println "in a closure"
}
repositories({ println "in a closure" })

デフォルトのインポート

Gradleは、インポートステートメントのセットをGradleスクリプトに自動的に追加します。次のリストは、Gradleスクリプトへのデフォルトのインポートパッケージを示しています。

以下は、Gradleスクリプトへのデフォルトのインポートパッケージです

import org.gradle.*
import org.gradle.api.*
import org.gradle.api.artifacts.*
import org.gradle.api.artifacts.cache.*
import org.gradle.api.artifacts.component.*
import org.gradle.api.artifacts.dsl.*
import org.gradle.api.artifacts.ivy.*
import org.gradle.api.artifacts.maven.*
import org.gradle.api.artifacts.query.*
import org.gradle.api.artifacts.repositories.*
import org.gradle.api.artifacts.result.*
import org.gradle.api.component.*
import org.gradle.api.credentials.*
import org.gradle.api.distribution.*
import org.gradle.api.distribution.plugins.*
import org.gradle.api.dsl.*
import org.gradle.api.execution.*
import org.gradle.api.file.*
import org.gradle.api.initialization.*
import org.gradle.api.initialization.dsl.*
import org.gradle.api.invocation.*
import org.gradle.api.java.archives.*
import org.gradle.api.logging.*
import org.gradle.api.plugins.*
import org.gradle.api.plugins.announce.*
import org.gradle.api.plugins.antlr.*
import org.gradle.api.plugins.buildcomparison.gradle.*
import org.gradle.api.plugins.jetty.*
import org.gradle.api.plugins.osgi.*
import org.gradle.api.plugins.quality.*
import org.gradle.api.plugins.scala.*
import org.gradle.api.plugins.sonar.*
import org.gradle.api.plugins.sonar.model.*
import org.gradle.api.publish.*
import org.gradle.api.publish.ivy.*
import org.gradle.api.publish.ivy.plugins.*
import org.gradle.api.publish.ivy.tasks.*
import org.gradle.api.publish.maven.*
import org.gradle.api.publish.maven.plugins.*
import org.gradle.api.publish.maven.tasks.*
import org.gradle.api.publish.plugins.*
import org.gradle.api.reporting.*
import org.gradle.api.reporting.components.*
import org.gradle.api.reporting.dependencies.*
import org.gradle.api.reporting.model.*
import org.gradle.api.reporting.plugins.*
import org.gradle.api.resources.*
import org.gradle.api.specs.*
import org.gradle.api.tasks.*
import org.gradle.api.tasks.ant.*
import org.gradle.api.tasks.application.*
import org.gradle.api.tasks.bundling.*
import org.gradle.api.tasks.compile.*
import org.gradle.api.tasks.diagnostics.*
import org.gradle.api.tasks.incremental.*
import org.gradle.api.tasks.javadoc.*
import org.gradle.api.tasks.scala.*
import org.gradle.api.tasks.testing.*
import org.gradle.api.tasks.testing.junit.*
import org.gradle.api.tasks.testing.testng.*
import org.gradle.api.tasks.util.*
import org.gradle.api.tasks.wrapper.*
import org.gradle.authentication.*
import org.gradle.authentication.http.*
import org.gradle.buildinit.plugins.*
import org.gradle.buildinit.tasks.*
import org.gradle.external.javadoc.*
import org.gradle.ide.cdt.*
import org.gradle.ide.cdt.tasks.*
import org.gradle.ide.visualstudio.*
import org.gradle.ide.visualstudio.plugins.*
import org.gradle.ide.visualstudio.tasks.*
import org.gradle.ivy.*
import org.gradle.jvm.*
import org.gradle.jvm.application.scripts.*
import org.gradle.jvm.application.tasks.*
import org.gradle.jvm.platform.*
import org.gradle.jvm.plugins.*
import org.gradle.jvm.tasks.*
import org.gradle.jvm.tasks.api.*
import org.gradle.jvm.test.*
import org.gradle.jvm.toolchain.*
import org.gradle.language.assembler.*
import org.gradle.language.assembler.plugins.*
import org.gradle.language.assembler.tasks.*
import org.gradle.language.base.*
import org.gradle.language.base.artifact.*
import org.gradle.language.base.plugins.*
import org.gradle.language.base.sources.*
import org.gradle.language.c.*
import org.gradle.language.c.plugins.*
import org.gradle.language.c.tasks.*
import org.gradle.language.coffeescript.*
import org.gradle.language.cpp.*
import org.gradle.language.cpp.plugins.*
import org.gradle.language.cpp.tasks.*
import org.gradle.language.java.*
import org.gradle.language.java.artifact.*
import org.gradle.language.java.plugins.*
import org.gradle.language.java.tasks.*
import org.gradle.language.javascript.*
import org.gradle.language.jvm.*
import org.gradle.language.jvm.plugins.*
import org.gradle.language.jvm.tasks.*
import org.gradle.language.nativeplatform.*
import org.gradle.language.nativeplatform.tasks.*
import org.gradle.language.objectivec.*
import org.gradle.language.objectivec.plugins.*
import org.gradle.language.objectivec.tasks.*
import org.gradle.language.objectivecpp.*
import org.gradle.language.objectivecpp.plugins.*
import org.gradle.language.objectivecpp.tasks.*
import org.gradle.language.rc.*
import org.gradle.language.rc.plugins.*
import org.gradle.language.rc.tasks.*
import org.gradle.language.routes.*
import org.gradle.language.scala.*
import org.gradle.language.scala.plugins.*
import org.gradle.language.scala.tasks.*
import org.gradle.language.scala.toolchain.*
import org.gradle.language.twirl.*
import org.gradle.maven.*
import org.gradle.model.*
import org.gradle.nativeplatform.*
import org.gradle.nativeplatform.platform.*
import org.gradle.nativeplatform.plugins.*
import org.gradle.nativeplatform.tasks.*
import org.gradle.nativeplatform.test.*
import org.gradle.nativeplatform.test.cunit.*
import org.gradle.nativeplatform.test.cunit.plugins.*
import org.gradle.nativeplatform.test.cunit.tasks.*
import org.gradle.nativeplatform.test.googletest.*
import org.gradle.nativeplatform.test.googletest.plugins.*
import org.gradle.nativeplatform.test.plugins.*
import org.gradle.nativeplatform.test.tasks.*
import org.gradle.nativeplatform.toolchain.*
import org.gradle.nativeplatform.toolchain.plugins.*
import org.gradle.platform.base.*
import org.gradle.platform.base.binary
import org.gradle.platform.base.component.*
import org.gradle.platform.base.plugins.*
import org.gradle.platform.base.test.*
import org.gradle.play.*
import org.gradle.play.distribution.*
import org.gradle.play.platform.*
import org.gradle.play.plugins.*
import org.gradle.play.tasks.*
import org.gradle.play.toolchain.*
import org.gradle.plugin.use.*
import org.gradle.plugins.ear.*
import org.gradle.plugins.ear.descriptor.*
import org.gradle.plugins.ide.api.*
import org.gradle.plugins.ide.eclipse.*
import org.gradle.plugins.ide.idea.*
import org.gradle.plugins.javascript.base.*
import org.gradle.plugins.javascript.coffeescript.*
import org.gradle.plugins.javascript.envjs.*
import org.gradle.plugins.javascript.envjs.browser.*
import org.gradle.plugins.javascript.envjs.http.*
import org.gradle.plugins.javascript.envjs.http.simple.*
import org.gradle.plugins.javascript.jshint.*
import org.gradle.plugins.javascript.rhino.*
import org.gradle.plugins.javascript.rhino.worker.*
import org.gradle.plugins.signing.*
import org.gradle.plugins.signing.signatory.*
import org.gradle.plugins.signing.signatory.pgp.*
import org.gradle.plugins.signing.type.*
import org.gradle.plugins.signing.type.pgp.*
import org.gradle.process.*
import org.gradle.sonar.runner.*
import org.gradle.sonar.runner.plugins.*
import org.gradle.sonar.runner.tasks.*
import org.gradle.testing.jacoco.plugins.*
import org.gradle.testing.jacoco.tasks.*
import org.gradle.testkit.runner.*
import org.gradle.util.*

Gradle-タスク

Gradleビルドスクリプトは、1つ以上のプロジェクトについて説明します。各プロジェクトは異なるタスクで構成されています。タスクは、ビルドが実行する作業です。タスクには、いくつかのクラスのコンパイル、クラスファイルの個別のターゲットフォルダへの保存、JARの作成、Javadocの生成、またはリポジトリへの成果の公開があります。

この章では、タスクとは何か、タスクを生成および実行する方法について説明します。

タスクを定義する

タスクは、ビルドスクリプトにタスクを定義するために使用されるキーワードです。 finddevguides を出力する hello という名前のタスクを表す次の例を見てください。次のスクリプトをコピーして、 build.gradle という名前のファイルに保存します。このビルドスクリプトは、finddevguides文字列を出力するために使用されるタスク名helloを定義します。

task hello {
   doLast {
      println 'finddevguides'
   }
}

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q hello

出力：

finddevguides

*doLast* ステートメントへのショートカット（記号 *<<* を表す）を指定することにより、このhelloタスクを単純化できます。 このショートカットを上記のタスク *hello* に追加すると、次のスクリプトのようになります。

task hello << {
   println 'finddevguides'
}

*gradle –q hello* コマンドを使用して、上記のスクリプトを実行できます。

タスクの定義にはいくつかのバリエーションがありますので、ご覧ください。次の例では、タスク hello を定義しています。

次のコードをコピーして build.gradle ファイルに保存します。

task (hello) << {
   println "finddevguides"
}

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q hello

出力：

finddevguides

タスク名に文字列を使用することもできます。同じhelloの例を見てください。ここでは、タスクとして文字列を使用します。

次のコードをコピーして build.gradle ファイルに保存します。

task('hello') << {
   println "finddevguides"
}

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q hello

出力：

finddevguides

タスクを定義するための代替構文も使用できます。 create（）メソッドを使用してタスクを定義しています。以下に示す同じhelloの例を見てください。

以下のコードをコピーして build.gradle ファイルに保存します。

tasks.create(name: 'hello') << {
   println "finddevguides"
}

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q hello

出力：

finddevguides

タスクを見つける

ビルドファイルで定義したタスクを検索する場合は、それぞれの標準プロジェクトプロパティを使用する必要があります。つまり、各タスクは、タスク名をプロパティ名として使用して、プロジェクトのプロパティとして使用できます。

プロパティとしてタスクにアクセスする次のコードを見てください。

以下のコードをコピーして build.gradle ファイルに保存します。

task hello

println hello.name
println project.hello.name

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q hello

出力：

hello
hello

タスクコレクションを通じてすべてのプロパティを使用することもできます。

次のコードをコピーして build.gradle ファイルに保存します。

task hello

println tasks.hello.name
println tasks['hello'].name

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q hello

出力：

hello
hello

タスクを使用してタスクのパスにアクセスすることもできます。このために、タスク名、相対パス、または絶対パスでgetByPath（）メソッドを呼び出すことができます。

以下のコードをコピーして build.gradle ファイルに保存します。

project(':projectA') {
   task hello
}
task hello

println tasks.getByPath('hello').path
println tasks.getByPath(':hello').path
println tasks.getByPath('projectA:hello').path
println tasks.getByPath(':projectA:hello').path

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q hello

出力：

:hello
:hello
:projectA:hello
:projectA:hello

タスクへの依存関係の追加

タスクを別のタスクに依存させることができます。つまり、1つのタスクが完了すると、他のタスクのみが開始されます。各タスクは、タスク名で区別されます。タスク名のコレクションは、そのタスクコレクションによって参照されます。別のプロジェクトのタスクを参照するには、プロジェクトのパスを各タスク名のプレフィックスとして使用する必要があります。

taskXからtaskYに依存関係を追加する次の例。

以下のコードをコピーして build.gradle ファイルに保存します。次のコードを見てください。

task taskX << {
   println 'taskX'
}
task taskY(dependsOn: 'taskX') << {
   println "taskY"
}

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradle ファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q taskY

出力：

taskX
taskY

上記の例では、名前を使用してタスクへの依存関係を追加しています。タスクオブジェクトを使用して依存関係を定義するタスクの依存関係を実現する別の方法があります。

taskXに依存するtaskYの同じ例を取り上げますが、タスク参照名の代わりにタスクオブジェクトを使用しています。

次のコードをコピーして build.gradle ファイルに保存します。

task taskY << {
   println 'taskY'
}
task taskX << {
   println 'taskX'
}
taskY.dependsOn taskX

コマンドプロンプトで次のコマンドを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q taskY

出力：

taskX
taskY

上記の例では、名前を使用してタスクへの依存関係を追加しています。タスクオブジェクトを使用して依存関係を定義するタスクの依存関係を実現する別の方法があります。

ここでは、taskYがtaskXに依存しているのと同じ例を取り上げますが、タスク参照名の代わりにタスクオブジェクトを使用しています。それを見てみましょう。

以下のコードをコピーして build.gradle ファイルに保存します。次のコードを見てください。

task taskX << {
   println 'taskX'
}
taskX.dependsOn {
   tasks.findAll {
      task → task.name.startsWith('lib')
   }
}
task lib1 << {
   println 'lib1'
}
task lib2 << {
   println 'lib2'
}
task notALib << {
   println 'notALib'
}

コマンドプロンプトで次のコマンドを実行します。上記のスクリプトを実行します。 build.gradle ファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q taskX

出力：

lib1
lib2
taskX

タスクへの説明の追加

タスクに説明を追加できます。この説明は、* Gradleタスク*を実行すると表示されます。これは、descriptionキーワードを使用することで可能です。

次のコードをコピーして build.gradle ファイルに保存します。次のコードを見てください。

task copy(type: Copy) {
   description 'Copies the resource directory to the target directory.'
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
   println("description applied")
}

コマンドプロンプトで次のコマンドを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q copy

コマンドが正常に実行されると、次の出力が得られます。

description applied

タスクをスキップする

タスクのスキップは、述語クロージャーを渡すことで実行できます。これは、タスクのメソッドまたはタスクの実際の作業が実行される前に StopExecutionException をスローするクロージャーのメソッドの場合にのみ可能です。

次のコードをコピーして build.gradle ファイルに保存します。

task eclipse << {
   println 'Hello Eclipse'
}

//#1st approach - closure returning true, if the task should be executed, false if not.
eclipse.onlyIf {
   project.hasProperty('usingEclipse')
}

//#2nd approach - alternatively throw an StopExecutionException() like this
eclipse.doFirst {
   if(!usingEclipse) {
      throw new StopExecutionException()
   }
}

コマンドプロンプトで次のコマンドを実行します。 build.gradleファイルが保存されている場所でこれを実行する必要があります。

C:\> gradle –q eclipse

タスク構造

Gradleには、タスクを操作するときのさまざまなフェーズがあります。まず、構成フェーズがあり、タスクのクロージャで直接指定されたコードが実行されます。構成ブロックは、後で実際に実行されるタスクだけでなく、使用可能なすべてのタスクに対して実行されます。

構成フェーズの後、実行フェーズは、実際に実行されるタスクの doFirst または doLast クロージャー内のコードを実行します。

Gradle-依存関係管理

Gradleビルドスクリプトは、プロジェクトをビルドするプロセスを定義します。各プロジェクトには、いくつかの依存関係といくつかの出版物が含まれています。依存関係とは、他のプロジェクトからの必要なJARファイルや、クラスパス内のJDBC JARやEh-cache JARなどの外部JARなど、プロジェクトのビルドをサポートするものを意味します。出版物とは、テストクラスファイルやビルドファイル（warファイルなど）など、プロジェクトの結果を意味します。

ほとんどすべてのプロジェクトは自己完結型ではありません。ソースファイルをコンパイルおよびテストするには、他のプロジェクトによってビルドされたファイルが必要です。たとえば、プロジェクトでHibernateを使用するには、クラスパスにいくつかのHibernate JARを含める必要があります。 Gradleは、いくつかの特別なスクリプトを使用して、ダウンロードする必要がある依存関係を定義します。

Gradleは、どこかで結果を作成して公開することに注意します。公開は、定義したタスクに基づいています。ファイルをローカルディレクトリにコピーするか、リモートのMavenまたはlvyリポジトリにアップロードするか、同じマルチプロジェクトビルド内の別のプロジェクトのファイルを使用します。タスクを公開するプロセスを公開と呼ぶことができます。

依存関係の宣言

依存関係の構成は、依存関係のセットを定義するだけです。この機能を使用して、Webからダウンロードする外部依存手段を宣言できます。これは、次のような異なるスタンダーを定義します。

apply plugin: 'java'

repositories {
   mavenCentral()
}

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
   testCompile group: 'junit', name: 'junit', version: '4.+'
}

依存関係の構成

依存関係の構成は、一連の依存関係を定義するだけです。この機能を使用して、Webからダウンロードする外部依存関係を宣言できます。これにより、次のさまざまな標準構成が定義されます。

コンパイル-プロジェクトの本番ソースをコンパイルするために必要な依存関係。
Runtime -実行時に本番クラスに必要な依存関係。デフォルトでは、コンパイル時の依存関係も含まれます。
テストコンパイル-プロジェクトのテストソースをコンパイルするために必要な依存関係。デフォルトでは、コンパイル済みのプロダクションクラスとコンパイル時の依存関係が含まれます。
テストランタイム-テストの実行に必要な依存関係。デフォルトでは、ランタイムおよびテストコンパイルの依存関係が含まれます。

外部依存関係

外部依存関係は、依存関係のタイプの1つです。これは、現在のビルドの外部でビルドされ、Mavenセントラル、企業Mavenまたはlvyリポジトリ、ローカルファイルシステムのディレクトリなど、何らかの種類のリポジトリに格納されているいくつかのファイルへの依存関係です。

次のコードスニペットは、外部依存関係を定義するものです。 build.gradle ファイルでこのコードを使用します。

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
}

外部依存関係が外部依存関係を宣言しており、ショートカット形式は「group：name：version」のように見えます。

リポジトリ

外部依存関係を追加中。 Gradleはリポジトリでそれらを探します。リポジトリは、グループ、名前、バージョンごとに整理された単なるファイルのコレクションです。デフォルトでは、Gradleはリポジトリを定義しません。少なくとも1つのリポジトリを明示的に定義する必要があります。次のコードスニペットは、Mavenリポジトリを定義する方法を定義しています。 build.gradle ファイルでこのコードを使用します。

repositories {
   mavenCentral()
}

次のコードは、リモートMavenを定義するためのものです。 build.gradle ファイルでこのコードを使用します。

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

アーティファクトの公開

依存関係の構成は、ファイルの公開にも使用されます。これらの公開されたファイルは成果物と呼ばれます。通常、プラグインを使用して成果物を定義します。ただし、アーティファクトを公開する場所をGradleに伝える必要があります。これは、リポジトリをアーカイブのアップロードタスクに添付することで実現できます。 Mavenリポジトリを公開するための次の構文をご覧ください。 Gradleは実行中に、プロジェクトの要件に従ってPom.xmlを生成およびアップロードします。 build.gradle ファイルでこのコードを使用します。

apply plugin: 'maven'

uploadArchives {
   repositories {
      mavenDeployer {
         repository(url: "file://localhost/tmp/myRepo/")
      }
   }
}

Gradle-プラグイン

プラグインはタスクのセットに他なりません。タスクのコンパイル、ドメインオブジェクトの設定、ソースファイルのセットアップなど、ほとんどすべての有用なタスクはプラグインによって処理されます。プラグインをプロジェクトに適用すると、プラグインがプロジェクトの機能を拡張できるようになります。プラグインは次のようなことを行うことができます-

基本的なGradleモデルを拡張します（例：設定可能な新しいDSL要素を追加します）。
変換に従ってプロジェクトを構成します（例：新しいタスクを追加するか、適切なデフォルトを設定します）。
特定の構成を適用します（例：組織のリポジトリを追加するか、標準を実施します）。

プラグインの種類

Gradleには、スクリプトプラグインとバイナリプラグインの2種類のプラグインがあります。スクリプトプラグインは、ビルドを操作するための宣言型アプローチを提供する追加のビルドスクリプトです。これは通常、ビルド内で使用されます。バイナリプラグインは、プラグインインターフェイスを実装し、ビルドを操作するためのプログラム的なアプローチを採用するクラスです。バイナリプラグインは、ビルドスクリプト、プロジェクト階層、またはプラグインJARの外部に常駐できます。

プラグインを適用する

Project.apply（）* APIメソッドは、特定のプラグインを適用するために使用されます。同じプラグインを複数回使用できます。プラグインには、スクリプトプラグインとバイナリプラグインの2種類があります。

スクリプトプラグイン

スクリプトプラグインは、ローカルファイルシステムまたはリモートの場所にあるスクリプトから適用できます。ファイルシステムの場所はプロジェクトディレクトリに関連していますが、リモートスクリプトの場所はHTTP URLを指定します。次のコードスニペットをご覧ください。これは、 other.gradle プラグインをビルドスクリプトに適用するために使用されます。 build.gradle ファイルでこのコードを使用します。

apply from: 'other.gradle'

バイナリプラグイン

一部のコアプラグインは短い名前を使用して適用し、一部のコミュニティプラグインはプラグインIDに完全修飾名を使用しているため、各プラグインはプラグインIDによって識別されます。プラグインのクラスを指定することができます。

次のコードスニペットをご覧ください。タイプを使用してjavaプラグインを適用する方法を示します。 build.gradle ファイルでこのコードを使用します。

apply plugin: JavaPlugin

短い名前を使用してコアプラグインを適用するための次のコードをご覧ください。 build.gradle ファイルでこのコードを使用します。

plugins {
   id 'java'
}

ショートネームを使用してコミュニティプラグインを適用するための次のコードをご覧ください。 build.gradle ファイルでこのコードを使用します。

plugins {
   id "com.jfrog.bintray" version "0.4.1"
}

カスタムプラグインの作成

カスタムプラグインの作成中に、プラグインの実装を記述する必要があります。 Gradleはプラグインをインスタンス化し、Plugin.apply（）メソッドを使用してプラグインインスタンスを呼び出します。次のサンプルには、プロジェクトにhelloタスクを追加するグリーティングプラグインが含まれています。次のコードを見てください。 build.gradle ファイルでこのコードを使用します。

apply plugin: GreetingPlugin

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.task('hello') << {
         println "Hello from the GreetingPlugin"
      }
   }
}

次のコードを使用して、上記のスクリプトを実行します。

C:\> gradle -q hello

出力：

Hello from the GreetingPlugin

ビルドから入力を取得する

ほとんどのプラグインには、ビルドスクリプトからの構成サポートが必要です。 Gradleプロジェクトには、プラグインに渡されるすべての設定とプロパティを追跡するのに役立つExtensionContainerオブジェクトが関連付けられています。

プロジェクトに単純な拡張オブジェクトを追加しましょう。ここで、プロジェクトにグリーティング拡張オブジェクトを追加します。これにより、グリーティングを設定できます。 build.gradle ファイルでこのコードを使用します。

apply plugin: GreetingPlugin

greeting.message = 'Hi from Gradle'

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
     //Add the 'greeting' extension object
      project.extensions.create("greeting", GreetingPluginExtension)

     //Add a task that uses the configuration
      project.task('hello') << {
         println project.greeting.message
      }
   }
}

class GreetingPluginExtension {
   def String message = 'Hello from GreetingPlugin'
}

次のコードを使用して、上記のスクリプトを実行します。

C:\> gradle -q hello

出力：

Hi from Gradle

この例では、GreetingPluginは、messageというフィールドを持つ単純な古いGroovyオブジェクトです。拡張オブジェクトは、グリーティングという名前でプラグインリストに追加されます。このオブジェクトは、拡張オブジェクトと同じ名前のプロジェクトプロパティとして使用可能になります。

Gradleは各拡張オブジェクトに構成クロージャーを追加するため、設定をグループ化できます。次のコードを見てください。 build.gradle ファイルでこのコードを使用します。

apply plugin: GreetingPlugin

greeting {
   message = 'Hi'
   greeter = 'Gradle'
}

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.extensions.create("greeting", GreetingPluginExtension)

      project.task('hello') << {
         println "${project.greeting.message} from ${project.greeting.greeter}"
      }
   }
}

class GreetingPluginExtension {
   String message
   String greeter
}

次のコードを使用して、上記のスクリプトを実行します。

C:\> gradle -q hello

出力：

Hello from Gradle

標準Gradleプラグイン

Gradleディストリビューションに含まれるさまざまなプラグインがあります。

言語プラグイン

これらのプラグインは、JVMでコンパイルおよび実行できるさまざまな言語のサポートを追加します。

Plugin Id	Automatically Applies	Description
java	java-base	Adds Java compilation, testing, and bundling capabilities to a project. It serves as the basis for many of the other Gradle plugins.
groovy	java,groovy-base	Adds support for building Groovy projects.
scala	java,scala-base	Adds support for building Scala projects.
antlr	Java	Adds support for generating parsers using Antlr.

言語プラグインのインキュベーション

これらのプラグインは、さまざまな言語のサポートを追加します。

Plugin Id	Automatically Applies	Description
assembler	-	Adds native assembly language capabilities to a project.
c	-	Adds C source compilation capabilities to a project.
cpp	-	Adds C++ source compilation capabilities to a project.
objective-c	-	Adds Objective-C source compilation capabilities to a project.
objective-cpp	-	Adds Objective-C++ source compilation capabilities to a project.
windows-resources	-	Adds support for including Windows resources in native binaries.

Gradle-ビルドの実行

Gradleは、ビルドスクリプトを実行するコマンドラインを提供します。一度に複数のタスクを実行できます。この章では、異なるオプションを使用して複数のタスクを実行する方法について説明します。

複数のタスクを実行する

1つのビルドファイルから複数のタスクを実行できます。 Gradleは、* gradleコマンド*を使用してそのビルドファイルを処理できます。このコマンドは、リストされている順に各タスクをコンパイルし、異なるオプションを使用して依存関係とともに各タスクを実行します。

例-4つのタスク-task1、task2、task3、およびtask4があります。 Task3とtask4は、タスク1とタスク2に依存しています。次の図をご覧ください。

複数のタスクの実行

上記の4つのタスクは互いに依存しており、矢印記号で表されています。次のコードを見てください。コピーは build.gradle ファイルに貼り付けることができます。

task task1 << {
   println 'compiling source'
}

task task2(dependsOn: task1) << {
   println 'compiling unit tests'
}

task task3(dependsOn: [task1, task2]) << {
   println 'running unit tests'
}

task task4(dependsOn: [task1, task3]) << {
   println 'building the distribution'
}

上記のタスクをコンパイルして実行するには、次のコードを使用できます。

C:\> gradle task4 test

出力：

:task1
compiling source
:task2
compiling unit tests
:task3
running unit tests
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

タスクを除外する

実行からタスクを除外するときに、gradleコマンドと一緒に-xオプションを使用し、除外するタスクの名前を指定できます。

上記のスクリプトからtask4を除外するには、次のコマンドを使用します。

C:\> gradle task4 -x test

出力：

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

障害が発生したときにビルドを継続する

Gradleは、タスクが失敗するとすぐに実行を中止し、ビルドに失敗します。障害が発生した場合でも実行を継続できます。このためには、gradleコマンドで–continueオプションを使用する必要があります。各タスクを依存関係とともに個別に処理します。そして、主な重要なポイントは、発生した各障害をキャッチし、ビルドの実行の終了時に報告することです。タスクが失敗した場合、依存する後続のタスクも実行されないとします。

実行するビルドの選択

gradleコマンドを実行すると、現在のディレクトリでビルドファイルが検索されます。 -bオプションを使用すると、特定のビルドファイルと絶対パスを選択できます。次の例では、 subdir/ にある myproject.gradle ファイルからプロジェクトhelloを選択します。

task hello << {
   println "using build file '$buildFile.name' in '$buildFile.parentFile.name'."
}

次のコマンドを使用して、上記のスクリプトを実行できます。

C:\> gradle -q -b subdir/myproject.gradle hello

出力：

using build file 'myproject.gradle' in 'subdir'.

ビルド情報の取得

Gradleには、タスクとプロジェクトに関する情報の詳細を取得するためのいくつかの組み込みタスクが用意されています。これは、ビルドの構造と依存関係を理解し、問題をデバッグするのに役立ちます。プロジェクトレポートプラグインを使用して、プロジェクトにタスクを追加すると、これらのレポートが生成されます。

プロジェクトのリスト

*gradle –q projects* コマンドを使用して、選択したプロジェクトとそのサブプロジェクトのプロジェクト階層を一覧表示できます。 次に例を示します。次のコマンドを使用して、ビルドファイル内のすべてのプロジェクトを一覧表示します。

C:\> gradle -q projects

出力：

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

レポートには、指定されている場合、各プロジェクトの説明が表示されます。次のコマンドを使用して、説明を指定できます。 build.gradle ファイルに貼り付けます。

description = 'The shared API for the application'

タスクのリスト

次のコマンドを使用して、複数のプロジェクトに属するすべてのタスクをリストできます。

C:\> gradle -q tasks

出力：

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
dists - Builds the distribution
libs - Builds the JAR

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
components - Displays the components produced by root project 'projectReports'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
properties - Displays the properties of root project 'projectReports'.
tasks - Displays the tasks runnable from root project 'projectReports'
   (some of the displayed tasks may belong to subprojects).

To see all tasks and more detail, run gradle tasks --all

To see more detail about a task, run gradle help --task <task>

次のコマンドを使用して、すべてのタスクの情報を表示できます。

C:\> gradle -q tasks --all

出力：

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
api:clean - Deletes the build directory (build)
webapp:clean - Deletes the build directory (build)
dists - Builds the distribution [api:libs, webapp:libs]
   docs - Builds the documentation
api:libs - Builds the JAR
   api:compile - Compiles the source files
webapp:libs - Builds the JAR [api:libs]
   webapp:compile - Compiles the source files

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
api:buildEnvironment - Displays all buildscript dependencies declared in project ':api'.
webapp:buildEnvironment - Displays all buildscript dependencies declared in project ':webapp'.
components - Displays the components produced by root project 'projectReports'. [incubating]
api:components - Displays the components produced by project ':api'. [incubating]
webapp:components - Displays the components produced by project ':webapp'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
api:dependencies - Displays all dependencies declared in project ':api'.
webapp:dependencies - Displays all dependencies declared in project ':webapp'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
api:dependencyInsight - Displays the insight into a specific dependency in project ':api'.
webapp:dependencyInsight - Displays the insight into a specific dependency in project ':webapp'.
help - Displays a help message.
api:help - Displays a help message.
webapp:help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
api:model - Displays the configuration model of project ':api'. [incubating]
webapp:model - Displays the configuration model of project ':webapp'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
api:projects - Displays the sub-projects of project ':api'.
webapp:projects - Displays the sub-projects of project ':webapp'.
properties - Displays the properties of root project 'projectReports'.
api:properties - Displays the properties of project ':api'.
webapp:properties - Displays the properties of project ':webapp'.
tasks - Displays the tasks runnable from root project 'projectReports'
   (some of the displayed tasks may belong to subprojects).
api:tasks - Displays the tasks runnable from project ':api'.
webapp:tasks - Displays the tasks runnable from project ':webapp'.

以下に、さまざまなオプションを説明するコマンドのリストを表に示します。

Sr. No.	Command	Description
1	gradle –q help –task <task name>	Provides the usage information (such as path, type, description, group) about a specific task or multiple tasks.
2	gradle –q dependencies	Provides a list of dependencies of the selected project.
3	gradle -q api:dependencies --configuration <task name>	Provides the list of limited dependencies respective to configuration.
4	gradle –q buildEnvironment	Provides the list of build script dependencies.
5	gradle –q dependencyInsight	Provides an insight into a particular dependency.
6	Gradle –q properties	Provides the list of properties of the selected project.

Gradle-JAVAプロジェクトを構築する

この章では、Gradleビルドファイルを使用してJavaプロジェクトをビルドする方法について説明します。

まず、Javaプラグインをビルドスクリプトに追加する必要があります。これは、Javaソースコードをコンパイルし、ユニットテストを実行し、Javadocを作成し、JARファイルを作成するタスクを提供するためです。 build.gradle ファイルで次の行を使用します。

apply plugin: 'java'

Javaデフォルトプロジェクトレイアウト

ビルドにプラグインを追加するときは、Javaプロジェクトの特定のセットアップ（Mavenに類似）を想定しています。次のディレクトリ構造を見てください。

src/main/javaにはJavaソースコードが含まれています
src/test/javaにはJavaテストが含まれています

この設定に従えば、Javaプロジェクトをコンパイル、テスト、およびバンドルするには、次のビルドファイルで十分です。

ビルドを開始するには、コマンドラインで次のコマンドを入力します。

C:\> gradle build

*SourceSets* を使用して、異なるプロジェクト構造を指定できます。 たとえば、ソースは *src/main/java* ではなく *src* フォルダーに保存されます。 次のディレクトリ構造を見てください。

apply plugin: 'java'
sourceSets {
   main {
      java {
         srcDir 'src'
      }
   }

   test {
      java {
         srcDir 'test'
      }
   }
}

initタスクの実行

Gradleは、まだ複数のプロジェクトテンプレートをサポートしていません。ただし、新しいGradleプロジェクトの構造を作成する init タスクが提供されます。追加のパラメーターなしで、このタスクはGradleプロジェクトを作成します。Gradleプロジェクトには、gradleラッパーファイル、 build.gradle および settings.gradle ファイルが含まれます。

-type *パラメーターに値として *java-library を追加すると、javaプロジェクト構造が作成され、 build.gradle ファイルにJunitを含む特定のJavaテンプレートが含まれます。 build.gradle ファイルの次のコードを見てください。

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

リポジトリセクションでは、依存関係の場所を定義します。 Jcenter は、依存関係を解決するためのものです。依存関係セクションは、外部依存関係に関する情報を提供するためのものです。

Javaバージョンの指定

通常、Javaプロジェクトにはバージョンと、それがコンパイルされるターゲットJREがあります。 version および sourceCompatibility プロパティは、 build.gradle ファイルで設定できます。

version = 0.1.0
sourceCompatibility = 1.8

アーティファクトが実行可能なJavaアプリケーションである場合、 MANIFEST.MF ファイルは、mainメソッドを持つクラスを認識している必要があります。

apply plugin: 'java'

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

例：

以下のスクリーンショットに示すように、ディレクトリ構造を作成します。

ディレクトリ構造

以下のJavaコードをApp.javaファイルにコピーし、* consumerbanking \ src \ main \ java \ com \ bankディレクトリに保存します*。

package com.bank;

/**
* Hello world!
*
*/

public class App {
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

以下のJavaコードをAppTset.javaファイルにコピーし、* consumerbanking \ src \ test \ java \ com \ bankディレクトリに保存します*。

package com.bank;

/**
* Hello world!
*
*/

public class App{
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

以下のコードをbuild.gradleファイルにコピーし、 consumerbanking \ ディレクトリに配置します。

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

上記のスクリプトをコンパイルして実行するには、以下のコマンドを使用します。

consumerbanking\> gradle tasks
consumerbanking\> gradle assemble
consumerbanking\> gradle build

それぞれのディレクトリのすべてのクラスファイルを確認し、 consumerbanking \ build \ lib フォルダーで consumerbanking.jar ファイルを確認します。

Gradle-Groovyプロジェクトを構築する

この章では、 build.gradle ファイルを使用してGroovyプロジェクトをコンパイルおよび実行する方法について説明します。

Groovyプラグイン

Gradle用のGroovyプラグインは、Javaプラグインを拡張し、Groovyプログラムにタスクを提供します。 groovyプラグインを適用するには、次の行を使用できます。

apply plugin: 'groovy'

完全なビルドスクリプトファイルは次のとおりです。次のコードを build.gradle ファイルにコピーします。

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

dependencies {
   compile 'org.codehaus.groovy:groovy-all:2.4.5'
   testCompile 'junit:junit:4.12'
}

次のコマンドを使用して、ビルドスクリプトを実行できます。

gradle build

Groovyプロジェクトのデフォルトのプロジェクトレイアウト

Groovyプラグインは、Groovyプロジェクトの特定のセットアップを前提としています。

src/main/groovyにはGroovyソースコードが含まれています
src/test/groovyにはGroovyテストが含まれています
src/main/javaにはJavaソースコードが含まれています
src/test/javaにはJavaテストが含まれています

ビルドフォルダの build.gradle ファイルが配置されているそれぞれのディレクトリを確認します。

Gradle-テスト

テストタスクは、テストソースセット内のすべてのユニットテストを自動的に検出して実行します。また、テストの実行が完了するとレポートを生成します。 JUnitおよびTestNGはサポートされているAPIです。

テストタスクには、JVMがデバッガーを待機するように起動するように設定できる* Test.getDebug（）メソッドが用意されています。実行に進む前に、デバッガポストを *5005 に設定します。

テスト検出

*Test Task* は、コンパイルされたテストクラスを検査することにより、どのクラスがテストクラスであるかを検出します。 デフォルトでは、すべての.classファイルをスキャンします。 カスタムの包含/除外を設定できます。これらのクラスのみがスキャンされます。 使用するテストフレームワーク（JUnit/TestNG）に応じて、テストクラスの検出は異なる基準を使用します。

JUnitを使用する場合、JUnit 3と4の両方のテストクラスをスキャンします。次の基準のいずれかが一致する場合、クラスはJUnitテストクラスであるとみなされます-

クラスまたはスーパークラスはTestCaseまたはGroovyTestCaseを拡張します
クラスまたはスーパークラスには@RunWithアノテーションが付けられます
クラスまたはスーパークラスに@Testアノテーションが付けられたメソッドが含まれている
TestNGを使用する場合、@ Testアノテーションが付けられたメソッドをスキャンします

注意-抽象クラスは実行されません。 Gradleはまた、継承ツリーをスキャンして、テストクラスパス上のjarファイルにします。

テストクラスの検出を使用したくない場合は、 scanForTestClasses をfalseに設定することで無効にできます。

テストのグループ化

JUnitとTestNGを使用すると、テストメソッドを高度にグループ化できます。グループ化のために、JUnitテストクラスとメソッドJUnit 4.8はカテゴリの概念を導入しています。テストタスクでは、含めるおよび除外するJUnitカテゴリを指定できます。

build.gradleファイルで次のコードスニペットを使用して、テストメソッドをグループ化できます。

test {
   useJUnit {
      includeCategories 'org.gradle.junit.CategoryA'
      excludeCategories 'org.gradle.junit.CategoryB'
   }
}

特定のテストを含めるおよび除外する

*Test* クラスには、 *include* および *exclude* メソッドがあります。 これらのメソッドを使用して、実際に実行するテストを指定できます。

含まれているテストのみを実行します-

test {
   include '**my.package.name/*'
}

除外されたテストをスキップする-

test {
   exclude '**my.package.name/*'
}

以下に示すサンプルの build.gradle ファイルは、さまざまな構成オプションを示しています。

apply plugin: 'java'//adds 'test' task

test {
  //enable TestNG support (default is JUnit)
   useTestNG()

  //set a system property for the test JVM(s)
   systemProperty 'some.prop', 'value'

  //explicitly include or exclude tests
   include 'org/foo/**'
   exclude 'org/boo/**'

  //show standard out and standard error of the test JVM(s) on the console
   testLogging.showStandardStreams = true

  //set heap size for the test JVM(s)
   minHeapSize = "128m"
   maxHeapSize = "512m"

  //set JVM arguments for the test JVM(s)
   jvmArgs '-XX:MaxPermSize=256m'

  //listen to events in the test execution lifecycle
   beforeTest {
      descriptor → logger.lifecycle("Running test: " + descriptor)
   }

  //listen to standard out and standard error of the test JVM(s)
   onOutput {
      descriptor, event → logger.lifecycle
         ("Test: " + descriptor + " produced standard out/err: "
         + event.message )
   }
}

次のコマンド構文を使用して、いくつかのテストタスクを実行できます。

gradle <someTestTask> --debug-jvm

Gradle-マルチプロジェクトビルド

Gradleは、最小および最大のプロジェクトを簡単に処理できます。小さなプロジェクトには、単一のビルドファイルとソースツリーがあります。より小さく、相互に依存するモジュールに分割されたプロジェクトを消化して理解することは非常に簡単です。 Gradleは、マルチプロジェクトビルドであるこのシナリオを完全にサポートしています。

マルチプロジェクトビルドの構造

このようなビルドはすべての形状とサイズで提供されますが、いくつかの共通の特徴があります-

プロジェクトのルートまたはマスターディレクトリにある settings.gradle ファイル。
ルートまたはマスターディレクトリにある build.gradle ファイル。
独自の**。gradle *ビルドファイルを持つ子ディレクトリ（一部のマルチプロジェクトビルドでは、子プロジェクトのビルドスクリプトが省略される場合があります）。

ビルドファイル内のすべてのプロジェクトを一覧表示するには、次のコマンドを使用できます。

C:\> gradle -q projects

出力：

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

レポートには、指定されている場合、各プロジェクトの説明が表示されます。次のコマンドを使用して、説明を指定できます。 build.gradle ファイルに貼り付けます。

description = 'The shared API for the application'

一般的なビルド構成の指定

root_projectの build.gradle ファイルでは、一般的な構成をすべてのプロジェクトまたはサブプロジェクトに適用できます。

allprojects {
   group = 'com.example.gradle'
   version = '0.1.0'
}

subprojects {
   apply plugin: 'java'
   apply plugin: 'eclipse'
}

これにより、すべてのプロジェクトに共通の com.example.gradle グループと 0.1.0 バージョンが指定されます。 subprojects クロージャーは、すべてのサブプロジェクトに共通の構成を適用しますが、 allprojects クロージャーのようにルートプロジェクトには適用しません。

プロジェクト固有の構成と依存関係

コアの ui および util サブプロジェクトには、特定のニーズがあり、ルートプロジェクトの一般的な構成によってまだ適用されていない場合、独自の build.gradle ファイルを含めることもできます。

たとえば、通常、uiプロジェクトはコアプロジェクトに依存しています。したがって、uiプロジェクトには、この依存関係を指定するための独自の build.gradle ファイルが必要です。

dependencies {
   compile project(':core')
   compile 'log4j:log4j:1.2.17'
}

プロジェクトの依存関係は、プロジェクトメソッドで指定されます。

Gradle-展開

Gradleは、ビルドアーティファクトリポジトリを展開するいくつかの方法を提供します。アーティファクトの署名をMavenリポジトリにデプロイする場合、公開されたPOMファイルにも署名する必要があります。

Maven-publishプラグインの使用

*maven-publish* プラグイン。Gradleがデフォルトで提供します。 gradleスクリプトを公開するために使用されます。 次のコードを見てください。

apply plugin: 'java'
apply plugin: 'maven-publish'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
         url "$buildDir/repo"
      }
   }
}

*Java* および *maven-publish* プラグインが適用される場合、いくつかの公開オプションがあります。 次のコードを見てください。プロジェクトをリモートリポジトリにデプロイします。

apply plugin: 'groovy'
apply plugin: 'maven-publish'

group 'workshop'
version = '1.0.0'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
          default credentials for a nexus repository manager
         credentials {
            username 'admin'
            password 'admin123'
         }
        //url to the releases maven repository
            url "http://localhost:8081/nexus/content/repositories/releases/"
      }
   }
}

プロジェクトをMavenからGradleに変換する

使用されているすべてのMavenプラグインがこのタスクで認識されている場合、Apache Maven pom.xml ファイルをGradleビルドファイルに変換する特別なコマンドがあります。

このセクションでは、次の pom.xml maven構成がGradleプロジェクトに変換されます。それを見てみましょう。

<project xmlns = "http://maven.apache.org/POM/4.0.0"
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">

   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example.app</groupId>
   <artifactId>example-app</artifactId>
   <packaging>jar</packaging>

   <version>1.0.0-SNAPSHOT</version>

   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>

         <version>4.11</version>
         <scope>test</scope>
      </dependency>
   </dependencies>

</project>

次のコマンドをコマンドラインで使用すると、次のGradle構成ができます。

C:\> gradle init --type pom

*init* タスクはラッパータスクに依存するため、Gradleラッパーが作成されます。

結果の build.gradle ファイルはこれに似ています-

apply plugin: 'java'
apply plugin: 'maven'

group = 'com.example.app'
version = '1.0.0-SNAPSHOT'

description = """"""

sourceCompatibility = 1.5
targetCompatibility = 1.5

repositories {
   maven { url "http://repo.maven.apache.org/maven2" }
}

dependencies {
   testCompile group: 'junit', name: 'junit', version:'4.11'
}

Gradle-Eclipse統合

この章では、EclipseとGradleの統合について説明します。 GradleプラグインをEclipseに追加するには、以下の手順に従ってください。

ステップ1-Eclipse Marketplaceを開きます

まず、システムにインストールされているEclipseを開きます。ヘルプに移動→ EclipseMarketplaceをクリックします。次のスクリーンショットをご覧ください。

Open Eclipse Marketplace

ステップ2-ビルドシッププラグインのインストール

Eclipse Marketplaceをクリックすると、次のスクリーンショットが表示されます。ここで、左側の検索バーに buildship と入力します。 BuildshipはGradle統合プラグインです。画面にビルドシップが見つかったら、右側の[インストール]をクリックします。次のスクリーンショットをご覧ください。

ビルドシッププラグインのインストール

その後、次のスクリーンショットが表示されます。確認ボタンをクリックして、ソフトウェアのインストールを確認する必要があります。次のスクリーンショットをご覧ください。

確認

その後、次の画面で「ライセンス契約に同意する」をクリックして、「終了」をクリックする必要があります。次のスクリーンショットをご覧ください。

ライセンスに同意

インストールには時間がかかります。次のスクリーンショットをご覧ください。

インストールプロセス

その後、Eclipseの再起動を要求します。そこで、[はい]を選択します。

ステップ3-Gradleプラグインの確認

確認しながら、所定の手順に従って新しいプロジェクトを作成します。 Eclipseでファイルに移動→新規をクリック→他のプロジェクトをクリックします。そこには、次の画面があります。そこでGradleプロジェクトを選択し、次へをクリックします。次のスクリーンショットをご覧ください。

Gradleプラグインの検証

次のボタンをクリックすると、次の画面が表示されます。そこで、ローカルファイルシステムのGradleホームディレクトリパスを指定し、[次へ]ボタンをクリックします。次のスクリーンショットをご覧ください。

Gradle Home Directory

次のスクリーンショットをご覧ください。Gradleプロジェクトの名前を指定します。このチュートリアルでは、 demoproject を使用して[完了]ボタンをクリックします。

デモプロジェクト

次のスクリーンショットを見て、プロジェクトを確認する必要があります。そのために、次の画面で[完了]ボタンをクリックします。

プロジェクトの確認

ステップ4-ディレクトリ構造の検証

Gradleプラグインが正常にインストールされたら、次のスクリーンショットに示すように、デフォルトのファイルとフォルダーのデモプロジェクトのディレクトリ構造を確認してください。

ディレクトリ構造の検証

Gradle-quick-guide

Gradle-概要

Gradleの特徴

なぜGroovyなのか？

Gradle-インストール

前提条件

ステップ1-JAVAインストールの確認

Windowsの場合-

Linuxの場合-

ステップ2-Gradleビルドファイルのダウンロード

ステップ3-Gradleの環境を設定する

Windowsの場合-

Linuxの場合-

Windowsの場合：

Linuxの場合：

Gradle-ビルドスクリプト

ビルドスクリプトの作成

build.gradle

Groovyの基本

Groovy JDKメソッド

プロパティアクセサ

メソッド呼び出しのオプションの括弧

メソッドの最後のパラメーターとしてのクロージャー

デフォルトのインポート

Gradle-タスク

タスクを定義する

タスクを見つける

タスクへの依存関係の追加

タスクへの説明の追加

タスクをスキップする

タスク構造

Gradle-依存関係管理

依存関係の宣言

依存関係の構成

外部依存関係

リポジトリ

アーティファクトの公開

Gradle-プラグイン

プラグインの種類

プラグインを適用する

スクリプトプラグイン

バイナリプラグイン

カスタムプラグインの作成

ビルドから入力を取得する

標準Gradleプラグイン

言語プラグイン

言語プラグインのインキュベーション

Gradle-ビルドの実行

複数のタスクを実行する

タスクを除外する

障害が発生したときにビルドを継続する

実行するビルドの選択

ビルド情報の取得

プロジェクトのリスト

タスクのリスト

Gradle-JAVAプロジェクトを構築する

Javaデフォルトプロジェクトレイアウト

initタスクの実行

Javaバージョンの指定

Gradle-Groovyプロジェクトを構築する

Groovyプラグイン

Groovyプロジェクトのデフォルトのプロジェクトレイアウト

Gradle-テスト

テスト検出

テストのグループ化

特定のテストを含めるおよび除外する

Gradle-マルチプロジェクトビルド

マルチプロジェクトビルドの構造

一般的なビルド構成の指定

プロジェクト固有の構成と依存関係

Gradle-展開

Maven-publishプラグインの使用

プロジェクトをMavenからGradleに変換する

Gradle-Eclipse統合

ステップ1-Eclipse Marketplaceを開きます

ステップ2-ビルドシッププラグインのインストール

ステップ3-Gradleプラグインの確認

ステップ4-ディレクトリ構造の検証