介紹

Gradle，這是一個基於 JVM 的富有突破性構建工具。

它為您提供了:

• 一個像 ant 一樣，通用的靈活的構建工具
• 一種可切換的，像 maven 一樣的基於約定約定優於配置的構建框架
• 強大的多工程構建支援
• 強大的依賴管理(基於 ApacheIvy)
• 對已有的 maven 和 ivy 倉庫的全面支援
• 支援傳遞性依賴管理，而不需要遠端倉庫或者 pom.xml 或者 ivy 配置檔案
• ant 式的任務和構建是 gradle 的第一公民
• 基於 groovy，其 build 指令碼使用 groovy dsl 編寫
• 具有廣泛的領域模型支援你的構建

Gradle 概述

---

特性說明

下面是一些 Gradle 特性的列表。

基於宣告的構建和基於約定的構建

Gradle 的核心在於基於 Groovy 的豐富而可擴充套件的域描述語言(DSL)。 Groovy 通過宣告性的語言元素將基於宣告的構建推向下層，你可以按你想要的方式進行組合。 這些元素同樣也為支援 Java， Groovy，OSGi，Web 和 Scala 專案提供了基於約定的構建。 並且，這種宣告性的語言是可以擴充套件的。你可以新增新的或增強現有的語言元素。 因此，它提供了簡明、可維護和易理解的構建。

為以依賴為基礎的程式設計方式提供語言支援

宣告性語言優點在於通用任務圖，你可以將其充分利用在構建中. 它提供了最大限度的靈活性，以讓 Gradle 適應你的特殊需求。

構建結構化

Gradle 的靈活和豐富性最終能夠支援在你的構建中應用通用的設計模式。 例如，它可以很容易地將你的構建拆分為多個可重用的模組，最後再進行組裝，但不要強制地進行模組的拆分。 不要把原本在一起的東西強行分開（比如在你的專案結構裡），從而避免讓你的構建變成一場噩夢。 最後，你可以建立一個結構良好，易於維護，易於理解的構建。

深度 API

Gradle 允許你在構建執行的整個生命週期，對它的核心配置及執行行為進行監視並自定義。

Gradle 的擴充套件

Gradle 有非常良好的擴充套件性。 從簡單的單專案構建，到龐大的多專案構建，它都能顯著地提升你的效率。 這才是真正的結構化構建。通過最先進的增量構建功能，它可以解決許多大型企業所面臨的效能瓶頸問題。

多專案構建

Gradle 對多專案構建的支援非常出色。專案依賴是首先需要考慮的問題。 我們允許你在多專案構建當中對專案依賴關係進行建模，因為它們才是你真正的問題域。 Gradle 遵守你的佈局。

Gradle 提供了局部構建的功能。 如果你在構建一個單獨的子專案，Gradle 也會幫你構建它所依賴的所有子專案。 你也可以選擇重新構建依賴於特定子專案的子專案。 這種增量構建將使得在大型構建任務中省下大量時間。

多種方式管理依賴

不同的團隊喜歡用不同的方式來管理他們的外部依賴。 從 Maven 和 Ivy 的遠端倉庫的傳遞依賴管理，到本地檔案系統的 jar 包或目錄，Gradle 對所有的管理策略都提供了方便的支援。

Gradle 是第一個構建整合工具

Ant tasks 是最重要的。而更有趣的是，Ant projects 也是最重要的。 Gradle 對任意的 Ant 專案提供了深度匯入，並在執行時將 Ant 目標(target)轉換為原生的 Gradle 任務(task)。 你可以從 Gradle 上依賴它們(Ant targets)，增強它們，甚至在你的 build.xml 上定義對 Gradle tasks 的依賴。Gradle 為屬性、路徑等等提供了同樣的整合。

Gradle 完全支援用於釋出或檢索依賴的 Maven 或 Ivy 倉庫。 Gradle 同樣提供了一個轉換器，用於將一個 Maven pom.xml 檔案轉換為一個 Gradle 指令碼。Maven 專案的執行時匯入的功能將很快會有。

易於移植

Gradle 能適應你已有的任何結構。因此，你總可以在你構建專案的同一個分支當中開發你的 Gradle 構建指令碼，並且它們能夠並行進行。 我們通常建議編寫測試，以保證生成的檔案是一樣的。 這種移植方式會盡可能的可靠和減少破壞性。這也是重構的最佳做法。

Groovy

Gradle 的構建指令碼是採用 Groovy 寫的，而不是用 XML。 但與其他方法不同，它並不只是展示了由一種動態語言編寫的原始指令碼的強大。 那樣將導致維護構建變得很困難。 Gradle 的整體設計是面向被作為一門語言，而不是一個僵化的框架。 並且 Groovy 是我們允許你通過抽象的 Gradle 描述你個人的 story 的黏合劑。 Gradle 提供了一些標準通用的 story。這是我們相比其他宣告性構建系統的主要特點。 我們的 Groovy 支援也不是簡單的糖衣層，整個 Gradle 的 API 都是完全 groovy 化的。只有通過 Groovy才能去運用它並對它提高效率。

The Gradle wrapper

Gradle Wrapper 允許你在沒有安裝 Gradle 的機器上執行 Gradle 構建。 這一點是非常有用的。比如，對一些持續整合服務來說。 它對一個開源專案保持低門檻構建也是非常有用的。 Wrapper 對企業來說也很有用，它使得對客戶端計算機零配置。 它強制使用指定的版本，以減少相容支援問題。

自由和開源

Gradle 是一個開源專案，並遵循 ASL 許可。

為什麼使用 Groovy?

我們認為內部 DSL（基於一種動態語言）相比 XML 在構建指令碼方面優勢非常大。它們是一對動態語言。 為什麼使用 Groovy？答案在於 Gradle 內部的執行環境。 雖然 Gradle 核心目的是作為通用構建工具，但它還是主要面向 Java 專案。 這些專案的團隊成員顯然熟悉 Java。我們認為一個構建工具應該儘可能地對所有團隊成員透明。

你可能會想說，為什麼不能使用 Java 來作為構建指令碼的語言。 我認為這是一個很有意義的問題。對你們的團隊來講，它確實會有最高的透明度和最低的學習曲線。 但由於 Java 本身的侷限性，這種構建語言可能就不會那樣友善、 富有表現力和強大。 [1] 這也是為什麼像 Python，Groovy 或者 Ruby 這樣的語言在這方面表現得更好的原因。 我們選擇了 Groovy，因為它向 Java 人員提供了目前為止最大的透明度。 其基本的語法，型別，包結構和其他方面都與 Java 一樣，Groovy 在這之上又增加了許多東西。但是和 Java 也有著共同點。

對於那些分享和樂於去學習 Python 知識的 Java 團隊而言，上述論點並不適用。 Gradle 的設計非常適合在 JRuby 或 Jython 中建立另一個構建指令碼引擎。 那時候，對我們而言，它只是不再是最高優先順序的了。我們很高興去支援任何社群努力建立其他的構建指令碼引擎。

Gradle 安裝

---

先決條件

Gradle 需要 1.5 或更高版本的 JDK.Gradle 自帶了 Groovy 庫，所以不需要安裝 Groovy。Gradle 會忽略已經安裝的 Groovy。Gradle 會使用 ptah (這裡的"path"應該是指 PATH 環境變數。[Rover12421]譯註) 中的 JDK(可以使用 java -version 檢查)。當然，你可以配置 JAVA_HOME 環境變數來指向 JDK 的安裝目錄。

下載

從 Gralde 官方網站下載 Gradle 的最新發行包。

解壓

Gradle 發行包是一個 ZIP 檔案。完整的發行包包括以下內容(官方發行包有 full 完整版，也有不帶原始碼和文件的版本，可根據需求下載。[Rover12421]譯註):

• Gradle 可執行檔案
• 使用者手冊 (有 PDF 和 HTML 兩種版本)
• DSL 參考指南
• API 手冊(Javadoc 和 Groovydoc)
• 樣例，包括使用者手冊中的例子，一些完整的構建樣例和更加複雜的構建指令碼
• 原始碼。僅供參考使用,如果你想要自己來編譯 Gradle 你需要從原始碼倉庫中檢出發行版本原始碼，具體請檢視 Gradle 官方主頁。

配置環境變數

執行 gradle 必須將 GRADLE_HOME/bin 加入到你的 PATH 環境變數中。

測試安裝

執行如下命令來檢查是否安裝成功.該命令會顯示當前的 JVM 版本和 Gradle 版本。

gradle -v 

JVM 引數配置

Gradle 執行時的 JVM 引數可以通過 GRADLE_OPTS 或 JAVA_OPTS 來設定.這些引數將會同時生效。 JAVA_OPTS 設定的引數將會同其它 JAVA 應用共享，一個典型的例子是可以在 JAVA_OPTS 中設定代理和 GRADLE_OPTS 設定記憶體引數。同時這些引數也可以在 gradle 或者 gradlew 指令碼檔案的開頭進行設定。

Gradle 構建基礎

---

Projects 和 tasks

projects 和 tasks是 Gradle 中最重要的兩個概念。

任何一個 Gradle 構建都是由一個或多個 projects 組成。每個 project 包括許多可構建組成部分。 這完全取決於你要構建些什麼。舉個例子，每個 project 或許是一個 jar 包或者一個 web 應用，它也可以是一個由許多其他專案中產生的 jar 構成的 zip 壓縮包。一個 project 不必描述它只能進行構建操作。它也可以部署你的應用或搭建你的環境。不要擔心它像聽上去的那樣龐大。 Gradle 的 build-by-convention 可以讓您來具體定義一個 project 到底該做什麼。

每個 project 都由多個 tasks 組成。每個 task 都代表了構建執行過程中的一個原子性操作。如編譯，打包，生成 javadoc，釋出到某個倉庫等操作。

到目前為止，可以發現我們可以在一個 project 中定義一些簡單任務，後續章節將會闡述多專案構建和多專案多工的內容。

Hello world

你可以通過在命令列執行 gradle 命令來執行構建，gradle 命令會從當前目錄下尋找 build.gradle 檔案來執行構建。我們稱 build.gradle 檔案為構建指令碼。嚴格來說這其實是一個構建配置指令碼，後面你會了解到這個構建指令碼定義了一個 project 和一些預設的 task。

你可以建立如下指令碼到 build.gradle 中 To try this out，create the following build script named build.gradle。

第一個構建指令碼

build.gradle

task hello {
    doLast {
        println 'Hello world!'
    }
}

然後在該檔案所在目錄執行 gradle -q hello

-q 引數的作用是什麼?

該文件的示例中很多地方在呼叫 gradle 命令時都加了 -q 引數。該引數用來控制 gradle 的日誌級別，可以保證只輸出我們需要的內容。具體可參閱本文件第十八章日誌來了解更多引數和資訊。

執行指令碼

Output of gradle -q hello
> gradle -q hello
Hello world!

上面的指令碼定義了一個叫做 hello 的 task，並且給它添加了一個動作。當執行 gradle hello 的時候, Gralde 便會去呼叫 hello 這個任務來執行給定操作。這些操作其實就是一個用 groovy 書寫的閉包。

如果你覺得它看上去跟 Ant 中的 targets 很像，那麼是對的。Gradle 的 tasks 就相當於 Ant 中的 targets。不過你會發現他功能更加強大。我們只是換了一個比 target 更形象的另外一個術語。不幸的是這恰巧與 Ant 中的術語有些衝突。ant 命令中有諸如 javac、copy、tasks。所以當該文件中提及 tasks 時，除非特別指明 ant task。否則指的均是指 Gradle 中的 tasks。

快速定義任務

用一種更簡潔的方式來定義上面的 hello 任務。

快速定義任務

build.gradle

task hello << {
    println 'Hello world!'
}

上面的指令碼又一次採用閉包的方式來定義了一個叫做 hello 的任務，本文件後續章節中我們將會更多的採用這種風格來定義任務。

程式碼即指令碼

Gradle 指令碼採用 Groovy 書寫，作為開胃菜,看下下面這個例子。

在 gradle 任務中採用 groovy

build.gradle

task upper << {
    String someString = 'mY_nAmE'
    println "Original: " + someString
    println "Upper case: " + someString.toUpperCase()
}
Output of gradle -q upper
> gradle -q upper
Original: mY_nAmE
Upper case: MY_NAME

或者

在 gradle 任務中採用 groovy

build.gradle

task count << {
    4.times { print "$it " }
}
Output of gradle -q count
> gradle -q count
0 1 2 3

任務依賴

你可以按如下方式建立任務間的依賴關係

在兩個任務之間指明依賴關係

build.gradle

task hello << {
    println 'Hello world!'
}
task intro(dependsOn: hello) << {
    println "I'm Gradle"
}

gradle -q intro 的輸出結果

Output of gradle -q intro
> gradle -q intro
Hello world!
I'm Gradle

新增依賴 task 也可以不必首先宣告被依賴的 task。

延遲依賴

build.gradle

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

Output of gradle -q taskX

 > gradle -q taskX
taskY
taskX

可以看到，taskX 是 在 taskY 之前定義的，這在多專案構建中非常有用。

注意:當引用的任務尚未定義的時候不可使用短標記法來執行任務。

動態任務

藉助 Groovy 的強大不僅可以定義簡單任務還能做更多的事。例如，可以動態定義任務。

建立動態任務

build.gradle

4.times { counter ->
    task "task$counter" << {
        println "I'm task number $counter"
    }
}

gradle -q task1 的輸出結果。

Output of gradle -q task1
> gradle -q task1
I'm task number 1

任務操縱

一旦任務被建立後，任務之間可以通過 API 進行相互訪問。這也是與 Ant 的不同之處。比如可以增加一些依賴。

通過 API 進行任務之間的通訊 - 增加依賴

build.gradle

4.times { counter ->
    task "task$counter" << {
        println "I'm task number $counter"
    }
}
task0.dependsOn task2, task3

gradle -q task0的輸出結果。

Output of gradle -q task0
> gradle -q task0
I'm task number 2
I'm task number 3
I'm task number 0

為已存在的任務增加行為。

通過 API 進行任務之間的通訊 - 增加任務行為

build.gradle

task hello << {
    println 'Hello Earth'
}
hello.doFirst {
    println 'Hello Venus'
}
hello.doLast {
    println 'Hello Mars'
}
hello << {
    println 'Hello Jupiter'
}
Output of gradle -q hello
> gradle -q hello
Hello Venus
Hello Earth
Hello Mars
Hello Jupite

doFirst 和 doLast 可以進行多次呼叫。他們分別被新增在任務的開頭和結尾。當任務開始執行時這些動作會按照既定順序進行。其中 << 操作符 是 doLast 的簡寫方式。

短標記法

你早就注意到了吧，沒錯，每個任務都是一個指令碼的屬性，你可以訪問它:

以屬性的方式訪問任務

build.gradle

task hello << {
    println 'Hello world!'
}
hello.doLast {
    println "Greetings from the $hello.name task."
}

gradle -q hello 的輸出結果

Output of gradle -q hello
> gradle -q hello
Hello world!
Greetings from the hello task.

對於外掛提供的內建任務。這尤其方便(例如:complie)

增加自定義屬性

你可以為一個任務新增額外的屬性。例如,新增一個叫做 myProperty 的屬性，用 ext.myProperty 的方式給他一個初始值。這樣便增加了一個自定義屬性。

為任務增加自定義屬性

build.gradle

task myTask {
    ext.myProperty = "myValue"
}

task printTaskProperties << {
    println myTask.myProperty
}

gradle -q printTaskProperties 的輸出結果

Output of gradle -q printTaskProperties
> gradle -q printTaskProperties
myValue

自定義屬性不僅僅侷限於任務上，還可以做更多事情。

呼叫 Ant 任務

Ant 任務是 Gradle 中的一等公民。Gradle 藉助 Groovy 對 Ant 任務進行了優秀的整合。Gradle 自帶了一個 AntBuilder，在 Gradle 中呼叫 Ant 任務比在 build.xml 中呼叫更加的方便和強大。 通過下面的例子你可以學到如何呼叫一個 Ant 任務以及如何與 Ant 中的屬性進行通訊。

利用 AntBuilder 執行 ant.loadfile

build.gradle

task loadfile << {
    def files = file('../antLoadfileResources').listFiles().sort()
    files.each { File file ->
        if (file.isFile()) {
            ant.loadfile(srcFile: file, property: file.name)
            println " *** $file.name ***"
            println "${ant.properties[file.name]}"
        }
    }
}

gradle -q loadfile 的輸出結果

Output of gradle -q loadfile
> gradle -q loadfile
*** agile.manifesto.txt ***
Individuals and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration  over contract negotiation
Responding to change over following a plan
 *** gradle.manifesto.txt ***
Make the impossible possible, make the possible easy and make the easy elegant.
(inspired by Moshe Feldenkrais)

在你腳本里還可以利用 Ant 做更多的事情。想了解更多請參閱在 Gradle 中呼叫 Ant。

方法抽取

Gradle 的強大要看你如何編寫指令碼邏輯。針對上面的例子，首先要做的就是要抽取方法。

利用方法組織指令碼邏輯

build.gradle

task checksum << {
    fileList('../antLoadfileResources').each {File file ->
        ant.checksum(file: file, property: "cs_$file.name")
        println "$file.name Checksum: ${ant.properties["cs_$file.name"]}"
    }
}
task loadfile << {
    fileList('../antLoadfileResources').each {File file ->
        ant.loadfile(srcFile: file, property: file.name)
        println "I'm fond of $file.name"
    }
}
File[] fileList(String dir) {
    file(dir).listFiles({file -> file.isFile() } as FileFilter).sort()
}

gradle -q loadfile 的輸出結果

Output of gradle -q loadfile
> gradle -q loadfile
I'm fond of agile.manifesto.txt
I'm fond of gradle.manifesto.txt

在後面的章節你會看到類似出去出來的方法可以在多專案構建中的子專案中呼叫。無論構建邏輯多複雜，Gradle 都可以提供給你一種簡便的方式來組織它們。

定義預設任務

Gradle 允許在指令碼中定義多個預設任務。

定義預設任務

build.gradle

defaultTasks 'clean', 'run'
task clean << {
    println 'Default Cleaning!'
}
task run << {
    println 'Default Running!'
}
task other << {
    println "I'm not a default task!"
}

gradle -q 的輸出結果。

Output of gradle -q
> gradle -q
Default Cleaning!
Default Running!

這與直接呼叫 gradle clean run 效果是一樣的。在多專案構建中，每個子專案都可以指定單獨的預設任務。如果子專案未進行指定將會呼叫父專案指定的的預設任務。

Configure by DAG

稍後會對 Gradle 的配置階段和執行階段進行詳細說明 配置階段後，Gradle 會了解所有要執行的任務 Gradle 提供了一個鉤子來捕獲這些資訊。一個例子就是可以檢查已經執行的任務中有沒有被釋放。藉由此，你可以為一些變數賦予不同的值。

在下面的例子中，為 distribution 和 release 任務賦予了不同的 version 值。

依賴任務的不同輸出

build.gradle

task distribution << {
    println "We build the zip with version=$version"
}
task release(dependsOn: 'distribution') << {
    println 'We release now'
}
gradle.taskGraph.whenReady {taskGraph ->
    if (taskGraph.hasTask(release)) {
        version = '1.0'
    } else {
        version = '1.0-SNAPSHOT'
    }
}

gradle -q distribution 的輸出結果

Output of gradle -q distribution
> gradle -q distribution
We build the zip with version=1.0-SNAPSHOT

gradle -q release 的輸出結果

Output of gradle -q release
> gradle -q release
We build the zip with version=1.0
We release now

whenReady 會在已釋出的任務之前影響到已釋出任務的執行。即使已釋出的任務不是主要任務(也就是說，即使這個任務不是通過命令列直接呼叫)
更多參見:Gradle 簡介 - Gradle 教程 | BootWiki.com Gradle 教程_w3cschool