Gradle-クイックガイド

"Gradle is an open source build automation system"

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

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

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

Gradleの機能

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

Declarative builds and build-by-convention− Gradleは、Groovy言語に基づく個別のドメイン固有言語（DSL）で利用できます。Gradleは宣言型言語要素を提供します。これらの要素は、Java、Groovy、OSGI、Web、Scalaの従来のビルドサポートも提供します。
Language for dependency based programming −宣言型言語は、ビルドで完全に活用できる汎用タスクグラフの上部にあります。
Structure your build− Gradleを使用すると、一般的な設計原則をビルドに適用できます。これにより、ビルドに最適な構造が得られるため、適切に構造化され、保守が容易でわかりやすいビルドを設計できます。
Deep API −このAPIを使用すると、構成と実行動作を監視し、コアに合わせてカスタマイズできます。
Gradle scales − Gradleは、単純な単一プロジェクトのビルドから大規模なエンタープライズマルチプロジェクトビルドまで、生産性を簡単に向上させることができます。
Multi-project builds− Gradleはマルチプロジェクトビルドをサポートし、部分ビルドをサポートします。サブプロジェクトをビルドする場合、Gradleは依存するすべてのサブプロジェクトのビルドを処理します。
Different ways to manage your builds − Gradleは、依存関係を管理するためのさまざまな戦略をサポートしています。
Gradle is the first build integration tool− ANTタスク、依存関係を公開および取得するためのMavenおよびlvyリポジトリインフラストラクチャで完全にサポートされているGradle。Gradleは、Mavenpom.xmlをGradleスクリプトに変換するためのコンバーターも提供します。
Ease of migration− Gradleは、あらゆる構造に簡単に適応できます。したがって、ライブスクリプトをビルドできるのと同じブランチでいつでもGradleビルドを開発できます。
Gradle Wrapper− Gradle Wrapperを使用すると、GradleがインストールされていないマシンでGradleビルドを実行できます。これは、サーバーの継続的インテグレーションに役立ちます。
Free open source − Gradleはオープンソースプロジェクトであり、Apache Software License（ASL）の下でライセンスされています。
Groovy−GradleのビルドスクリプトはGroovyで記述されています。Gradleの全体的な設計は、厳密なフレームワークとしてではなく、言語として使用されることを目的としています。また、Groovyを使用すると、いくつかの抽象化を使用して独自のスクリプトを作成できます。Gradle API全体は、Groovy言語で完全に設計されています。

なぜGroovyなのか？

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

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

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

前提条件

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

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

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

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

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

Windowsの場合-

次のコマンドを実行して、Javaのインストールを確認します。システムにJDK1.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のインストールを確認します。システムにJDK1.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)

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

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

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

ステップ3-Gradleの環境をセットアップする

環境を設定するということは、配布ファイルを抽出し、ライブラリファイルを適切な場所にコピーする必要があることを意味します。セットアップGRADLE_HOME そして PATH 環境変数。

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

Windowsの場合-

ダウンロードしたzipファイルを解凍します。 gradle-2.11-all.zip から配布ファイルをコピーします Downloads\gradle-2.11\ に C:\gradle\ ロケーション。

その後、を追加します C:\gradle そして C:\gradle\bin にディレクトリ GRADLE_HOME そして PATHシステム変数。与えられた指示に従ってくださいright click on my computers -> click on properties -> advanced system settings -> click on environmental variables。そこには、システム変数を作成および編集するためのダイアログボックスがあります。GRADLE_HOME変数を作成するための新しいボタンをクリックします（左側のスクリーンショットに従ってください）。[編集]をクリックして、既存のパスシステム変数を編集します（右側のスクリーンショットに従ってください）。以下のスクリーンショットに従ってください。

Linuxの場合-

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

Gradleの用途 Groovy language スクリプトを書くため。

ビルドスクリプトの作成

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

build.gradle

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

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

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

C:\> gradle –q hello

出力：

tutorialspoint

タスクがANTのターゲットと同様に機能すると思われる場合は、その通りです。GradleタスクはANTターゲットと同等です。

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

task hello << {
   println 'tutorialspoint'
}

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

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

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

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

次の表は、 standard project properties。これらのプロパティはすべて、ビルドスクリプトで使用できます。

シニア番号	名前	タイプ	デフォルト値
1	事業	事業	プロジェクトインスタンス
2	名前	ストリング	プロジェクトディレクトリの名前。
3	道	ストリング	プロジェクトの絶対パス。
4	説明	ストリング	プロジェクトの説明。
5	projectDir	ファイル	ビルドスクリプトを含むディレクトリ。
6	buildDir	ファイル	projectDir / build
7	グループ	オブジェクト	詳細不明
8	バージョン	オブジェクト	詳細不明
9	蟻	AntBuilder	AntBuilderインスタンス

Groovyの基本

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

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

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

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

C:\> gradle –q upper

出力：

Original: TUTORIALS point
Upper case: TUTORIALS POINT

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

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

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

$ gradle –q count

出力：

0 1 2 3

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

GroovyJDKメソッド

Groovyは、標準のJavaクラスに多くの便利なメソッドを追加します。たとえば、JDKのIterableAPIはeach() IterableInterfaceの要素を反復処理するメソッド。

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

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

C:\> gradle –q groovyJDK

出力：

M
a
r
c

プロパティアクセサー

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

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

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

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

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

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

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

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

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

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

次のスニペットは、Closuresが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ビルドスクリプトは、1つ以上のプロジェクトについて記述します。各プロジェクトは、さまざまなタスクで構成されています。タスクは、ビルドが実行する作業の一部です。タスクには、いくつかのクラスのコンパイル、クラスファイルの個別のターゲットフォルダーへの保存、JARの作成、Javadocの生成、またはいくつかの成果のリポジトリへの公開が含まれる場合があります。

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

タスクの定義

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

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

C:\> gradle –q hello

出力：

tutorialspoint

task hello << {
   println 'tutorialspoint'
}

上記のスクリプトは、 gradle –q hello コマンド。

タスクを定義する際のいくつかのバリエーションがあります。それを見てください。次の例はタスクを定義しますhello。

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

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

C:\> gradle –q hello

出力：

tutorialspoint

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

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

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

C:\> gradle –q hello

出力：

tutorialspoint

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

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

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

C:\> gradle –q hello

出力：

tutorialspoint

タスクの検索

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

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

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

task hello

println hello.name
println project.hello.name

C:\> gradle –q hello

出力：

hello
hello

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

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

task hello

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

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

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

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

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

次のコードをコピーしてに保存します 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'
}

C:\> gradle –q taskX

出力：

lib1
lib2
taskX

タスクへの説明の追加

タスクに説明を追加できます。この説明は、実行時に表示されますGradle tasks。これは、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ビルドスクリプトは、プロジェクトをビルドするプロセスを定義します。各プロジェクトには、いくつかの依存関係といくつかの出版物が含まれています。依存関係とは、他のプロジェクトからの必要なJARファイルや、クラスパス内のJDBCJARやEh-cacheJARなどの外部JARなど、プロジェクトのビルドをサポートするものを意味します。パブリケーションとは、テストクラスファイルやwarファイルなどのビルドファイルなど、プロジェクトの結果を意味します。

ほとんどすべてのプロジェクトは自己完結型ではありません。ソースファイルをコンパイルしてテストするには、他のプロジェクトで作成したファイルが必要です。たとえば、プロジェクトでHibernateを使用するには、クラスパスにいくつかのHibernateJARを含める必要があります。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からダウンロードする外部依存関係を宣言できます。これにより、次のさまざまな標準構成が定義されます。

Compile −プロジェクトの本番ソースをコンパイルするために必要な依存関係。
Runtime−実行時に本番クラスに必要な依存関係。デフォルトでは、コンパイル時の依存関係も含まれます。
Test Compile−プロジェクトのテストソースをコンパイルするために必要な依存関係。デフォルトでは、コンパイルされた本番クラスとコンパイル時の依存関係が含まれます。
Test Runtime−テストの実行に必要な依存関係。デフォルトでは、ランタイムとテストコンパイルの依存関係が含まれています。

外部依存関係

外部依存関係は、依存関係のタイプの1つです。これは、現在のビルドの外部でビルドされ、Maven Central、企業の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モデルを拡張します（たとえば、構成可能な新しいDSL要素を追加します）。
変換に従ってプロジェクトを構成します（たとえば、新しいタスクを追加したり、適切なデフォルトを構成したりします）。
特定の構成を適用します（たとえば、組織のリポジトリを追加したり、標準を適用したりします）。

プラグインの種類

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

プラグインの適用

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

スクリプトプラグイン

スクリプトプラグインは、ローカルファイルシステムまたはリモートの場所にあるスクリプトから適用できます。ファイルシステムの場所はプロジェクトディレクトリからの相対位置ですが、リモートスクリプトの場所はHTTPURLを指定します。次のコードスニペットを見てください。適用するために使用されます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オブジェクトです。拡張オブジェクトは、greetingという名前でプラグインリストに追加されます。このオブジェクトは、拡張オブジェクトと同じ名前のプロジェクトプロパティとして使用できるようになります。

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でコンパイルおよび実行できるさまざまな言語のサポートを追加します。

プラグインID	自動的に適用	説明
java	java-base	Javaのコンパイル、テスト、およびバンドル機能をプロジェクトに追加します。これは、他の多くのGradleプラグインの基盤として機能します。
グルーヴィー	java、groovy-base	Groovyプロジェクトの構築のサポートを追加します。
Scala	java、scala-base	Scalaプロジェクトを構築するためのサポートを追加します。
antlr	Java	Antlrを使用してパーサーを生成するためのサポートを追加します。

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

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

プラグインID	自動的に適用	説明
アセンブラ	-	プロジェクトにネイティブアセンブリ言語機能を追加します。
c	-	Cソースコンパイル機能をプロジェクトに追加します。
cpp	-	C ++ソースコンパイル機能をプロジェクトに追加します。
Objective-c	-	プロジェクトにObjective-Cソースコンパイル機能を追加します。
目的-cpp	-	プロジェクトにObjective-C ++ソースコンパイル機能を追加します。
ウィンドウリソース	-	ネイティブバイナリにWindowsリソースを含めるためのサポートを追加します。

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

複数のタスクの実行

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

Example− task1、task2、task3、およびtask4の4つのタスクがあります。Task3とtask4は、task1とtask2に依存します。次の図を見てください。

上記の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オプションを使用して、絶対パスとともに特定のビルドファイルを選択できます。次の例からプロジェクトhelloを選択しますmyproject.gradle にあるファイル subdir/ それを見てください。

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'.

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

シニア番号	コマンド	説明
1	gradle –q help –task <タスク名>	特定のタスクまたは複数のタスクに関する使用情報（パス、タイプ、説明、グループなど）を提供します。
2	gradle –qの依存関係	選択したプロジェクトの依存関係のリストを提供します。
3	gradle -q api：dependencies --configuration <タスク名>	構成ごとに制限された依存関係のリストを提供します。
4	gradle –q buildEnvironment	ビルドスクリプトの依存関係のリストを提供します。
5	gradle –qdependencyInsight	特定の依存関係への洞察を提供します。
6	Gradle –qプロパティ	選択したプロジェクトのプロパティのリストを提供します。

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

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

apply plugin: 'java'

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

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

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

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

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

C:\> gradle build

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

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

initタスクの実行

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'
   }
}

Example:

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

以下のJavaコードをApp.javaファイルにコピーし、に保存します。 consumerbanking\src\main\java\com\bank directory。

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 directory。

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 ファイル。

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

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 ビルドフォルダのファイルの場所。

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

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

テスト検出

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

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

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

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

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

テストのグループ化

JUnitとTestNGを使用すると、テストメソッドを高度にグループ化できます。グループ化のために、JUnitテストクラスとメソッドJUnit4.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は、マルチプロジェクトビルドであるこのシナリオを完全にサポートします。

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

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

A settings.gradle プロジェクトのルートディレクトリまたはマスターディレクトリにあるファイル。
A 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

description = 'The shared API for the application'

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

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

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は、ビルドアーティファクトリポジトリをデプロイするいくつかの方法を提供します。アーティファクトの署名をMavenリポジトリーにデプロイするときは、公開されたPOMファイルにも署名する必要があります。

Maven公開プラグインの使用

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に変換する

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

このセクションでは、次の pom.xmlMaven構成は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'
}

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

ステップ1-Eclipseマーケットプレイスを開く

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

ステップ2-Buildshipプラグインをインストールする

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