Gradle - 快速指南

Gradle - 概述

在本章中，我們將瞭解為什麼需要開發 Gradle，它的功能是什麼，以及為什麼使用 Groovy 程式語言來開發 Gradle。

Gradle 的歷史

Ant 和 Maven 在 JAVA 市場取得了相當大的成功。Ant 是 2000 年釋出的第一個構建工具，它是基於程序式程式設計思想開發的。後來，在 Apache-IVY 的幫助下，它透過網路接受外掛和依賴管理的能力得到了改進。

Ant 的主要缺點包括：

使用 XML 作為格式編寫構建指令碼。
對於程序式程式設計來說，分層結構並不好，並且
XML 相對難以管理。

Maven 於 2004 年推出。它比 ANT 有了很多改進。它能夠改變其結構，並且 XML 可以用於編寫構建規範。Maven 依賴於約定，並且能夠透過網路下載依賴項。

Maven 的主要優點包括：

Maven 的生命週期，在連續多個專案中遵循相同生命週期。

Maven 在依賴管理方面遇到的一些問題包括：

它不處理同一庫的不同版本之間的衝突。
與在ANT中編寫構建指令碼相比，在 Maven 中編寫複雜的自定義構建指令碼比較困難。

最後，Gradle 於 2012 年出現，它融合了這兩個工具的一些有效功能。

Gradle 的特性

Gradle 提供的功能列表。

宣告式構建和約定式構建

Gradle 提供了基於 Groovy 語言的獨立領域特定語言 (DSL)。
它提供了宣告式語言元素。這些元素還為 Java、Groovy、OSGI、Web 和 Scala 提供了約定式構建支援。

基於依賴的程式語言

宣告式語言位於通用任務圖的頂部，構建中可以完全支援該任務圖。

構建結構

Gradle 允許您將通用設計原則應用於您的構建。它將為您提供完美的構建結構，以便您可以設計結構良好且易於維護、易於理解的構建。

深度 API

透過使用此 API，您可以監控並自定義其配置和執行行為的核心。

Gradle 可擴充套件

Gradle 可以輕鬆提高生產力，從簡單和單個專案構建到龐大的企業多專案構建。

多專案構建

Gradle 支援多專案構建和部分構建。如果您構建一個子專案，Gradle 會負責構建該子專案所依賴的所有子專案。

管理構建的不同方法

Gradle 支援不同的策略來管理您的依賴項。

Gradle 是第一個構建整合工具

Gradle 完全支援您的 ANT 任務、Maven 和 lvy 儲存庫基礎設施以釋出和檢索依賴項。它還提供了一個轉換器，用於將 Maven pom.xml 轉換為 Gradle 指令碼。

易於遷移

Gradle 可以輕鬆適應任何結構。因此，您始終可以在同一個分支中開發 Gradle 構建，您可以在其中構建即時指令碼。

Gradle 包裝器

Gradle 包裝器允許您在未安裝 Gradle 的機器上執行 Gradle 構建。這對於持續整合伺服器很有用。

免費開源

Gradle 是一個開源專案，並根據 Apache 軟體許可證 (ASL) 許可。

Groovy

Gradle 的構建指令碼是用 Groovy 程式語言編寫的。Gradle 的整個設計都面向用作語言而不是用作剛性框架。Groovy 允許您使用一些抽象編寫自己的指令碼。整個 Gradle API 完全用 Groovy 語言設計。

為什麼 Gradle 使用 Groovy？

完整的 Gradle API 是使用 Groovy 語言設計的。這是內部 DSL 相對於 XML 的優勢。Gradle 是一個通用的構建工具，其主要關注點是 Java 專案。

在這些專案中，團隊成員將非常熟悉 Java，並且最好使構建對所有團隊成員儘可能透明。

像 Python、Groovy 或 Ruby 這樣的語言更適合構建框架。選擇 Groovy 的原因是，因為它為使用 Java 的人員提供了迄今為止最大的透明度。Groovy 的基本語法與 Java 相同，並且 Groovy 為其使用者提供了更多好處。

Gradle - 安裝

Gradle 是一個基於 Java 的構建工具。在安裝 Gradle 框架之前，需要安裝一些先決條件。

安裝 Gradle 的先決條件

JDK 和 Groovy 是 Gradle 安裝的先決條件。

Gradle 需要在系統中安裝 JDK 版本 6 或更高版本。它使用已安裝的 JDK 庫，並將其設定為 JAVA_HOME 環境變數。

Gradle 自帶 Groovy 庫，因此，我們無需顯式安裝 Groovy。如果已安裝，Gradle 會忽略它。

下面說明了在您的系統中安裝 Gradle 的步驟。

步驟 1 - 驗證 JAVA 安裝

首先，您需要在系統上安裝 Java 軟體開發工具包 (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 構建檔案

從https://gradle.org/install/提供的連結下載最新版本的 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 系統變數（請參考右側截圖）。

請參考以下截圖。

在 Linux 中

提取名為gradle-2.11-all.zip的已下載 zip 檔案，然後您將找到一個名為gradle-2.11的提取檔案。

您可以使用以下命令將分發檔案從Downloads/gradle-2.11/移動到/opt/gradle/位置。從 Downloads 目錄執行此操作。

$ 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: 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 構建一個指令碼檔案來處理兩件事；一個是專案，另一個是任務。每個 Gradle 構建都代表一個或多個專案。

一個專案代表一個庫 JAR 或一個 Web 應用程式，或者它可能代表一個從其他專案生成的 JAR 組裝而成的 ZIP。簡單來說，一個專案是由不同的任務組成的。

任務是指構建執行的一段工作。任務可能是編譯一些類、建立 JAR、生成 Javadoc 或將一些存檔釋出到儲存庫。

Gradle 使用 Groovy 語言編寫指令碼。

編寫構建指令碼

Gradle 提供了一種領域特定語言 (DSL)，用於描述構建。它使用 Groovy 語言來簡化構建的描述。Gradle 的每個構建指令碼都使用 UTF-8 編碼，離線儲存，並命名為 build.gradle。

build.gradle

我們透過使用 Groovy 指令碼描述任務和專案。您可以使用 Gradle 命令執行 Gradle 構建。此命令查詢名為build.gradle的檔案。

請檢視以下示例，它表示一個列印tutorialspoint的小指令碼。

將以下指令碼複製並儲存到名為build.gradle的檔案中。此構建指令碼定義了一個名為 hello 的任務，用於列印 tutorialspoint 字串。

task hello {
  doLast {
   println 'tutorialspoint'
  }
}

在儲存 build.gradle 檔案的命令提示符中執行以下命令。

C:\> gradle –q hello

輸出

您將看到以下輸出 -

tutorialspoint

如果您認為任務的工作方式類似於ANT 的目標，那麼就是正確的。Gradle 任務等效於 ANT 目標。

您可以透過為doLast語句指定一個快捷方式（表示符號<<）來簡化此 hello 任務。如果您將此快捷方式新增到上面的任務hello中，它將如下所示 -

task hello << {
   println 'tutorialspoint'
}

現在，您可以使用gradle –q hello命令執行上述指令碼。

Gradle 指令碼主要使用兩個真實的 Object，一個是 Project Object，另一個是 Script Object。

Project Object - 每個指令碼描述一個或多個專案。在執行過程中，此指令碼配置 Project Object。您可以在構建指令碼中執行某些方法並使用屬性，這些方法和屬性被委託給 Project Object。
Script Object - Gradle 將指令碼程式碼轉換為類，這些類實現 Script 介面，然後執行。這意味著指令碼介面宣告的所有屬性和方法都可以在您的指令碼中使用。

下表定義了標準專案屬性列表。所有這些屬性都可以在您的構建指令碼中使用。

序號	名稱	型別	預設值
1	project	Project	Project 例項
2	name	String	專案目錄的名稱。
3	path	String	專案的絕對路徑。
4	description	String	專案的描述。
5	projectDir	File	包含構建指令碼的目錄。
6	buildDir	File	projectDir/build
7	group	Object	未指定
8	version	Object	未指定
9	ant	AntBuilder	AntBuilder 例項

Groovy 基礎

Gradle 構建指令碼使用完整的 Groovy API。

作為入門，請檢視以下示例。

示例 1

此示例說明如何將字串轉換為大寫。

複製並儲存下面給出的程式碼，到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

示例 2

以下示例說明列印隱式引數（$it）的值 4 次

複製並儲存以下程式碼到build.gradle檔案中。

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

在命令提示符中執行以下命令。它執行上面提到的指令碼。您應該在儲存 build.gradle 檔案的位置執行此操作。

$ gradle –q count

輸出

這將產生以下輸出 -

0 1 2 3

Groovy 的特性

Groovy 語言提供了大量特性。下面討論了一些重要的特性 -

Groovy JDK 方法

Groovy 為標準 Java 類添加了許多有用的方法。例如，來自 JDK 的 Iterable API 實現了一個each()方法，該方法迭代 Iterable 介面的元素。

複製並儲存以下程式碼到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 指令碼新增一組 import 語句。以下列表顯示了 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 構建指令碼描述了一個或多個專案。每個專案都由不同的任務組成，而任務是構建執行的一項工作。

任務可能是編譯一些類，將類檔案儲存到單獨的目標資料夾中，建立 JAR，生成 Javadoc 或將一些存檔釋出到儲存庫中。

本章說明什麼是任務以及如何生成和執行任務。

定義任務

Task 是一個關鍵字，用於在構建指令碼中定義任務。

請檢視以下示例，該示例表示一個名為hello的任務，該任務列印tutorialspoint。將以下指令碼複製並儲存到名為build.gradle的檔案中。

此構建指令碼定義了一個名為hello的任務，用於列印 tutorialspoint 字串。

task hello {
   doLast {
    println 'tutorialspoint'
   }
}

在命令提示符中執行以下命令。它執行上述指令碼。您應該在儲存 build.gradle 檔案的位置執行此操作。

C:\> gradle –q hello

輸出

以下是程式碼的輸出 -

tutorialspoint

您可以透過為doLast語句指定一個快捷方式（表示符號<<）來簡化此hello 任務。如果您將此快捷方式新增到上面的任務hello中，它將如下所示 -

task hello << {
   println 'tutorialspoint'
}

您可以使用gradle –q hello命令執行上述指令碼。

以下示例定義了一個任務hello。

複製並儲存以下程式碼到build.gradle檔案中。

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

在命令提示符中執行以下命令。它執行上面給出的指令碼。您應該在儲存 build.gradle 檔案的位置執行此操作。

C:\> gradle –q hello

輸出

輸出如下所示 -

tutorialspoint

您還可以使用字串作為任務名稱。請檢視相同的hello 示例。在這裡，我們將使用String作為任務。

複製並儲存以下程式碼到build.gradle檔案中。

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

在命令提示符中執行以下命令。它執行上面提到的指令碼。您應該在儲存 build.gradle 檔案的位置執行此操作。

C:\> gradle –q hello

輸出

執行上述程式碼時，您應該看到以下輸出 -

tutorialspoint

您還可以使用另一種語法來定義任務。即，使用 create() 方法來定義任務。請檢視下面給出的相同 hello 示例。

複製並儲存下面給出的程式碼到build.gradle檔案中。

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

在命令提示符中執行以下命令。它執行上面提到的指令碼。您應該在儲存 build.gradle 檔案的位置執行此操作。

C:\> gradle –q hello

輸出

執行後，您將收到以下輸出 -

tutorialspoint

查詢任務

如果您想找到在構建檔案中定義的任務，那麼您必須使用相應的標準專案屬性。這意味著每個任務都作為專案的屬性可用，其中任務名稱用作屬性名稱。

請檢視以下訪問任務作為屬性的程式碼。

複製並儲存下面給出的程式碼到build.gradle檔案中。

task hello

println hello.name
println project.hello.name

在命令提示符中執行以下命令。它執行上面給出的指令碼。您應該在儲存 build.gradle 檔案的位置執行此操作。

C:\> gradle –q hello

輸出

輸出如下所示 -

hello
hello

您還可以透過 tasks 集合使用所有屬性。

複製並儲存以下程式碼到build.gradle檔案中。

task hello

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

在命令提示符中執行以下命令。它執行上面提到的指令碼。您應該在儲存 build.gradle 檔案的位置執行此操作。

C:\> gradle –q hello

輸出

這將產生以下輸出 -

hello
hello

您還可以使用 tasks 訪問任務的路徑。為此，您可以使用任務名稱、相對路徑或絕對路徑呼叫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

向任務新增依賴項

您可以使一個任務依賴於另一個任務，這意味著當一個任務完成後，另一個任務才會開始。

每個任務都使用任務名稱進行區分。任務名稱的集合由其 tasks 集合引用。要引用另一個專案中的任務，您應該使用專案的路徑作為相應任務名稱的字首。

以下示例向 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 為例，但是在這裡，我們使用的是 Task 物件而不是任務引用名稱。

複製並儲存以下程式碼到build.gradle檔案中。

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

在命令提示符中執行以下命令。您應該在儲存 build.gradle 檔案的位置執行此操作。

C:\> gradle –q taskY

輸出

輸出如下所示 -

taskX
taskY

以上示例是使用任務名稱新增任務依賴項。

還有另一種方法可以實現任務依賴項，即使用 Task 物件定義依賴項。

在這裡，我們使用相同的示例，taskY依賴於taskX，但是我們使用的是 Task 物件而不是任務引用名稱。

複製並儲存下面給出的程式碼到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 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 - 依賴管理

Gradle 構建指令碼定義了一個構建專案的流程；每個專案包含一些依賴項和一些釋出項。依賴項指的是構建專案所需的支撐內容，例如來自其他專案的必需 JAR 檔案以及類路徑中的外部 JAR 檔案，例如 JDBC JAR 或 Eh-cache JAR。

釋出項指的是專案的輸出結果，例如測試類檔案、構建檔案和 war 檔案。

並非所有專案都是自包含的。它們需要由其他專案構建的檔案來編譯和測試原始檔。例如，為了在專案中使用 Hibernate，您需要在類路徑中包含一些 Hibernate JAR 檔案。Gradle 使用一些特殊的指令碼定義依賴項，這些依賴項需要下載。

Gradle 處理構建和釋出輸出結果。釋出基於您定義的任務。它可能希望將檔案複製到本地目錄，或將它們上傳到遠端 Maven 或 Ivy 儲存庫，或者您可能在同一個多專案構建中使用來自另一個專案的檔案。我們可以將釋出過程中的任務稱為釋出項。

宣告您的依賴項

依賴項配置定義了一組依賴項。您可以使用此功能宣告外部依賴項，您希望從 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 − 執行測試所需的依賴項。預設情況下，它包括執行時和測試編譯依賴項。

外部依賴項

外部依賴項是依賴項的一種型別。這依賴於當前構建外部構建的一些檔案，並存儲在某種型別的儲存庫中，例如 Maven 中央儲存庫、公司 Maven 或 Ivy 儲存庫，或者本地檔案系統中的目錄。

以下程式碼片段用於定義外部依賴項。在build.gradle檔案中使用此程式碼。

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

外部依賴項聲明瞭外部依賴項，快捷形式如下所示："group: name: version"。

儲存庫

新增外部依賴項時，Gradle 會在儲存庫中查詢它們。按組、名稱和版本組織的檔案集合稱為儲存庫。預設情況下，Gradle 沒有定義任何儲存庫。我們必須顯式定義至少一個儲存庫。以下程式碼片段定義瞭如何定義 Maven 儲存庫。在build.gradle檔案中使用此程式碼。

在build.gradle檔案中使用以下程式碼 −

repositories {
   mavenCentral()
}

以下程式碼用於定義遠端 Maven。在build.gradle檔案中使用此程式碼。

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

釋出構件

依賴項配置也用於釋出檔案。這些已釋出的檔案稱為構件。通常，我們使用外掛來定義構件。但是，您確實需要告訴 Gradle 在哪裡釋出構件。

您可以透過將儲存庫附加到 uploadArchives 任務來實現此目的。檢視釋出 Maven 儲存庫的以下語法。在執行時，Gradle 會根據專案要求生成並上傳Pom.xml。

在build.gradle檔案中使用此程式碼。

apply plugin: 'maven'

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

Gradle - 外掛

外掛只不過是一組所有有用的任務，例如編譯任務、設定域物件、設定原始檔等，都由外掛處理。將外掛應用於專案意味著它允許外掛擴充套件專案的功能。

外掛可以執行以下操作 −

擴充套件基本的 Gradle 模型（例如，新增可以配置的新 DSL 元素）。
根據約定配置專案（例如，新增新任務或配置合理的預設值）。
應用特定配置（例如，新增組織儲存庫或強制執行標準）。

外掛型別

Gradle 中有兩種型別的外掛，如下所示 −

指令碼外掛 − 指令碼外掛是一個額外的構建指令碼，它提供了一種宣告式方法來操作構建。這通常在構建內部使用。
二進位制外掛 − 二進位制外掛是實現外掛介面並採用程式設計方法來操作構建的類。二進位制外掛可以駐留在構建指令碼中，在專案層次結構中，或者外部在外掛 JAR 中。

應用外掛

Project.apply() API 方法用於應用特定的外掛。您可以多次使用同一個外掛。外掛有兩種型別，一種是指令碼外掛，另一種是二進位制外掛。

指令碼外掛

指令碼外掛可以從本地檔案系統上的指令碼或遠端位置應用。檔案系統位置相對於專案目錄，而遠端指令碼位置指定 HTTP URL。

檢視以下程式碼片段。它用於將other.gradle外掛應用於構建指令碼。在build.gradle檔案中使用此程式碼。

apply from: 'other.gradle'

二進位制外掛

每個外掛都由外掛 ID 標識。一些核心外掛使用簡短名稱來應用外掛 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.gradlebuild.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 是一個簡單的舊 Groovy 物件，帶有一個名為 message 的欄位。擴充套件物件以名稱 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 外掛的基礎。
groovy	java,groovy-base	新增對構建 Groovy 專案的支援。
scala	java,scala-base	新增對構建 Scala 專案的支援。
antlr	Java	新增對使用 Antlr 生成解析器的支援。

孵化語言外掛

這些外掛為各種語言新增支援。

外掛 ID	自動應用	描述
assembler	-	向專案新增本機組合語言功能。
c	-	向專案新增 C 原始碼編譯功能。
cpp	-	向專案新增 C++ 原始碼編譯功能。
objective-c	-	向專案新增 Objective-C 原始碼編譯功能。
objective-cpp	-	向專案新增 Objective-C++ 原始碼編譯功能。
windows-resources	-	新增對在原生二進位制檔案中包含 Windows 資源的支援。

Gradle - 執行構建

Gradle 提供了一個命令列來執行構建指令碼。它可以一次執行多個任務。本章介紹瞭如何使用不同的選項執行多個任務。

執行多個任務

您可以從單個構建檔案中執行多個任務。Gradle 可以使用gradle 命令處理構建檔案。此命令將按列出的順序編譯每個任務，並使用不同的選項執行每個任務及其依賴項。

示例

有四個任務 − task1、task2、task3 和 task4。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

排除任務

在從執行中排除任務時，您可以將 –x 選項與 Gradle 命令一起使用，並提及要排除的任務的名稱。

使用以下命令從上述指令碼中排除 task4。

C:\> gradle task4 -x test

輸出

下面引用的是程式碼的輸出 −

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

繼續構建

只要任何任務失敗，Gradle 就會中止執行並使構建失敗。即使發生故障，您也可以繼續執行。為此，您必須將 –continue 選項與 gradle 命令一起使用。它分別處理每個任務及其依賴項。

要點是它會捕獲遇到的每個錯誤，並在構建執行結束時報告。假設如果某個任務失敗，則後續依賴任務也不會執行。

選擇要執行的構建

執行 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 提供了幾個內建任務來檢索有關任務和專案的資訊詳細資訊。這對於理解構建的結構、構建的依賴項以及除錯問題很有用。

您可以使用 project report 外掛向您的專案新增任務，這些任務將生成這些報告。

列出專案

您可以使用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 <task name>	提供有關特定任務或多個任務的用法資訊（例如路徑、型別、描述、組）。
2	gradle –q dependencies	提供所選專案的依賴項列表。
3	gradle -q api:dependencies --configuration <task name>	提供與配置相關的有限依賴項列表。
4	gradle –q buildEnvironment	提供構建指令碼依賴項的列表。
5	gradle –q dependencyInsight	深入瞭解特定依賴項。
6	Gradle –q properties	提供所選專案的屬性列表。

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資料夾中，而不是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'
}

在 repositories 部分，它定義了在哪裡查詢依賴項。Jcenter 用於解析你的依賴項。Dependencies 部分用於提供有關外部依賴項的資訊。

指定 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 專案的特定設定。

src/main/groovy 包含 Groovy 原始碼
src/test/groovy 包含 Groovy 測試
src/main/java 包含 Java 原始碼
src/test/java 包含 Java 測試

檢查build.gradle檔案所在目錄的構建資料夾。

Gradle - 測試

test 任務會自動檢測並在測試源集中執行所有單元測試。測試執行完成後，它還會生成報告。JUnit 和 TestNG 是受支援的 API。

test 任務提供了一個Test.getDebug()方法，可以將其設定為啟動以使 JVM 等待偵錯程式。在繼續執行之前，它將偵錯程式埠設定為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 引入了類別的概念。test 任務允許指定要包含和排除的 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'
}

專案依賴項使用 project 方法指定。

Gradle - 部署

Gradle 提供了幾種將構建工件部署到儲存庫的方法。將工件的簽名部署到 Maven 儲存庫時，你還需要對已釋出的 POM 檔案進行簽名。

Maven-publish 外掛

預設情況下，Gradle 提供了maven-publish外掛。它用於釋出 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 "https://:8081/nexus/content/repositories/releases/"
      }
   }
}

從 Maven 轉換為 Gradle

如果所有使用的 Maven 外掛都為此任務所知，則有一個特殊的命令用於將 Apache Mavenpom.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任務依賴於 wrapper 任務，以便建立 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'
}