Groovy語法，變數定義，方法聲明，集合操作，閉包，運算符，斷言等基礎知識。 ...

先來一張思維導圖

Groovy 簡介

Groovy 是一種基於 JVM 的動態語言，他的語法和 Java 相似，最終也是要編譯 .class 在JVM上運行。

Groovy 完全相容 Java 並且在此基礎上添加了很多動態類型和靈活的特性，比如支持閉包，支持DSL，是一門非常靈活的動態腳本語言。

這篇文章是為了能看懂在 Gradle腳本中的代碼，知道怎麼寫。所以不會深入Groovy。

每個 build 腳本配置文件都是一個 Groovy腳本文件。在裡面可以寫任何符合 Groovy 語法的代碼。
例如定義類，方法，變數等。又因為Groovy 是完全相容Java的，故也可以寫任何Java代碼，是完全相容的。

DSL

DSL（Domain Specific Language) 中文意思是領域特定語言，專門關註某一領域，在於專而不是全。所以才是領域特定的。

Gradle 的腳本就是基於 Groovy 的DSL，專門解決自動化構建的DSL。
我們只需要按照相應的語法，配置相應的 Gradle 腳本就可以達到自動化構建的目的，這也是 DSL 的初衷。

註釋

單行註釋

//這裡是註釋
def name = "佛系編碼"

多行註釋

/* 這裡是多行註釋
   啦啦啦啦 */

doc 註釋

/**
 * 這裡是 doc 註釋
 * 啦啦啦啦
 */

數據類型

Java中的基本數據類型，對象它都支持；另外還有
閉包
加強的 List，Map的集合
加強的File，Stream等IO類型

類型可以顯式聲明，也可以用 def 來聲明，用 def 聲明的類型Groovy將會進行類型推斷。

基本數據類型都是和Java 中的一致，就不拿出來說了。下麵說一下，對象，字元串，閉包等;

另外：Groovy 中的分號是可以省略的；

字元串

使用單引號和雙引號都可以定義一個字元串常量。

差別是單引號只是單純的字元串，不能使用表達式，運算，求值，正則等。

task character(){
  doLast{
      def name = '張三'
      def address ="北京市"
      def age = 19
      println "單引號雙引號都是字元串 name is ${name}; age is $age ; address is ${address}"
      println '單引號里無法運算表達式例如 name is ${name}'
  }
}

執行 character

gradle character

得到結果如下

單引號雙引號都是字元串 name is 張三; age is 19 ; address is 北京市
單引號里無法運算表達式例如 name is ${name}

雙引號的字元串可以直接進行表達式計算，規則是一個美元符號緊跟一個花括弧: ${expression} ，如果只有一個變數可以省略花括弧。例如上面的 $age

集合

集合預設是 java.util.ArrayList 類型的

def nums = [1,2,4,5,6]
println "nums is ${nums.getClass().getName()} size = ${nums.size()}"

輸出結果為

nums is java.util.ArrayList size = 5

也可以顯式指定集合類型使用 as 關鍵字；

def nums1 = [0,"23",4,5,62,false] as LinkedList
println "nums1 is ${nums1.getClass().getName()};size = ${nums1.size()}"

輸出為

nums1 is java.util.LinkedList;size = 6

或者在前面顯式指定類型

LinkedList otherLinked = [3, 4, 5]

訪問元素

元素的訪問是通過下標訪問的

println "第三個元素是 ${nums1[2]},倒數第一個是 ${nums1[-1]};第一個和倒數第一個：${nums1[0,-1]}"
println "第二個到第四個：${nums1[1..3]}"

輸出為：

第三個元素是 4,倒數第一個是 false;第一個和倒數第一個：[0, false]
第二個到第四個：[23, 4, 5]

遍歷元素

使用 each 方法遍歷集合參數預設是 it

//遍歷
nums1.each {
  print "$it, "
}

輸出為：

0, 23, 4, 5, 62, false,

帶有下標的遍歷：使用 eachWithIndex 方法

numList.eachWithIndex { int value ,int index->
    println "list[$index] = $value"
    }

數組

數組的定義要明確的指定數組類型

String [] strings = ["I","'","m","is","a","dog","."]
   println "\n 數組 :${strings.getClass().getName()}"
   strings.each{
       print "$it "
   }

   def multi = [5,7,5,8,54,87] as int[]

   println "\n使用 as 顯式指定類型: ${multi.getClass().getName()}"
   multi.each{
       print "$it "
   }

輸出是

數組 :[Ljava.lang.String;
I ' m is a dog .
使用 as 顯式指定類型: [I
5 7 5 8 54 87

添加元素

使用 List.add() 添加元素

numList.add(-11)

使用可以使用 << 操作符添加一個

numList << 13

修改元素

numList[0] = 0

不用擔心下標越界；Groovy就自動增加到所需的下標,中間的會設置為 null

def numList = [0,1,2,3,4,5] as LinkedList

        numList.each{
            print "$it "
        }

        println "\n 在 10位置添加一個 11"

        numList[10] =11

        println "添加後的："

        numList.each{
            print "$it "
        }

輸出為：

> Task :collect1
0 1 2 3 4 5 
 在 10位置添加一個 11
添加後的：
0 1 2 3 4 5 null null null null 11 
BUILD SUCCESSFUL in 0s

刪除元素

使用 List.remove() 移除元素參數可以是下標，可以是值

numList.remove 0
numList.remove((Object)10)

使用 List.removeLast() 移除最後一個元素

numList.removeLast()

查找元素

使用 List.find() 查找第一個符合條件的元素

print "\n list.find() 查找第一個符合條件的元素 numList.find { it%2==0}"
print numList.find { it%2==0}

使用 List.findAll() 查找所有符合條件的元素

print "\n list.findAll() 查找所有符合條件的元素 numList.findAll {it % 2 ==0 }"
print numList.findAll { it % 2 ==0}

使用 List.any() 查找元素，只要有一個元素符合就返回 true

print "\n list.any() 只要有一個元素符合條件就返回 true numList.any { it % 2 ==1} "
print numList.any { it % 2 ==1}

使用 List.every() 查找元素，必須所有元素都符合條件才會返回 true

print "\n list.every() 必須所有元素都符合條件才會返回 true numList.every {it % 2 == 0} "
print numList.every { it % 2 == 0}

統計元素

統計符合條件的元素個數：使用 List.count()

print numList.count { it % 2 ==0 }

統計最大值：List.max()，最小值：List.min()

print "\n 最大值是 ${numList.max()} ,最小值是 ${numList.min()}， 最小的絕對值是 "
print numList.min { Math.abs it}

Map

Map 的定義是鍵值對的方式，使用逗號隔開

def colors = [red:'#FF0000',green:'#00FF00',blue:'#0000FF']

訪問 Map 中的元素有三種方式：

map.key
map[key]
map.get(key)

例如：

task map{
    doLast{
        def colors = [red:'#FF0000',green:'#00FF00',blue:'#0000FF']
        println " map calss is ${colors.getClass().getName()}"
        println "通過 map.key 的方式訪問 colors.red = ${colors.red}"
        println "通過 map[key] 的方式訪問 colors['red'] = ${colors['red']}"
        println "通過 map.get(key) 的方式訪問 colors.get(red) = ${colors.get('red')}"
    }
}

輸出為：

> Task :map
 map calss is java.util.LinkedHashMap
通過 map.key 的方式訪問 colors.red = #FF0000
通過 map[key] 的方式訪問 colors['red'] = #FF0000
通過 map.get(key) 的方式訪問 colors.get(red) = #FF0000


BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

添加元素

//添加元素
colors['pink'] = '#FF00FF'
colors.yellow = '#FFFF00'

修改元素

//修改元素
colors.red = 'red'
colors['blue'] = 'blue'
println "修改後的元素是 colors.red = ${colors.red},colors.blue = ${colors.blue}"

刪除元素

//刪除元素
colors.remove('red')

遍歷元素

和上面的一樣使用 each 方法

//遍歷 
colors.each{
    println "${it.key} :${it.value}"
}

查找元素

查找的方法和上面的都一樣，只是參數換成了 Map.Entry 或者 key,value ;
這裡只用 find 做一個示例：

find 方法

def green = colors.find { key ,value ->
  if(key.equals('green')) {
      return colors[key]
  }
  return null
}

println "查找結果是 ${green}"


def blue = colors.find { Map.Entry entry ->
    if(entry.key.equals('blue')){
        return entry.value
    }
    return null
}
println "查找的結果是 ${blue}"

方法

方法也是使用 def 定義的

/*
 * 返回大的那個
 */
def max(int a ,int b){
    if(a>b){
      return   a
    }else{
      return   b
    }
}

return 是可以省略的

Groovy 會把執行過程中的最後一句代碼作為返回值

/*
 * 返回大的那個
 */
def max(int a ,int b){
    if(a>b){
         a
    }else{
       b
    }
}

括弧是可以省略的；

在調用方法時括弧是可以省略的；使用空格間隔開參數即可

def printMaximum(int a,int b){
    if(a>b){
        println "The maximum value of $a and $b is $a"
    }else{
        println "The maximum value of $a and $b is $b"
    }
}

task method {
    doLast{
        println "max is ${max(0,1)}"
        printMaximum 10,20
    }
}

輸出是

> Task :method
max is 1
The maximum value of 10 and 20 is 20

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

代碼塊是可以作為參數傳遞的

代碼塊就是一段被花括弧包圍的代碼，其實就是閉包；

例如 each 方法

最原始的應該是這樣的

colors.each({println it})

格式化後

colors.each({
    println it
})

Groovy 規定最後一個參數是閉包,可以將閉包放在方法外面

colors.each(){
    println it
}

調用時方法的括弧是可以省略的就成了這樣

colors.each {
    println it
}

閉包

閉包是 Groovy 的一個重要特性，可以說是 DSL 的基礎。

閉包其實就是一段匿名代碼塊。

閉包在 Groovy 中是 groovy.lang.Closure 類的實例，這使得閉包可以賦值給變數或欄位。

定義一個閉包

def hello = { println "Hello 佛系編碼" }

調用這個閉包

hello.call()

另一種調用方式直接在後面跟上 ()

hello()

下麵模擬一個 each 的執行，定一個方法迭代集合中的元素

/*
  * closure 就是 閉包參數
  */
def customEach(closure){
    //迭代元素
    for(int i in 1..10){
    //在閉包後跟上 () 就是調用了 括弧里的參數就是閉包要接收的參數
        closure(i)
    }
}

調用這個方法，傳入一個閉包列印元素; 如果閉包只有一個參數，那麼預設就是 it

// 如果只有一個參數 預設就是 it
customEach {
     println it
}

如果閉包要接收多個參數，那就必須把參數顯式的列出來，使用 -> 將參數和主體分開

再次模擬一個 map 的迭代:

def eachMap(closure){
    def map1 = [name:'佛系編碼',age:666]
    map1.each {
        closure(it.key,it.value)
    }
}
·····

//如果有多個參數，就必須要把參數列出來，使用 -> 將 參數和主體分開
eachMap { key,value ->
    println "$key:$value"
}

閉包委托

Groovy 閉包的強大之處在於它支持閉包方法的委托。

Groovy 的閉包有三個重要屬性

thisObject 閉包定義所在的類
owner 表示閉包定義所在的對象或閉包（閉包內還是可以定義閉包的），這個是最近原則，下麵會做說明
delegate 預設和 owner 一致，可以手動修改。

如果將閉包定義在一個類中，預設三個屬性都是相等的；

舉個例子：在 Person 類中定義了一個 act 閉包

class Person{
    private String name

    public int getAge(){
       12
    }

    Closure act ={
         println "thisObject:${thisObject.getClass()}"
        println "owner:${owner.getClass()}"
        println "delegate:${delegate.getClass()}"
    }
}

調用這個閉包，將會有下麵的輸出

> Task :test
thisObject:class Person
owner:class Person
delegate:class Person

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

如果將閉包定義在一個閉包里，那麼 thisOjbect 就和其他兩個不一樣，因為 thisObject 是表示的定義閉包所在的類，而 owner 表示類或閉包

這次在一個閉包里再定一個閉包看一下

class Person{
    private String name

    public int getAge(){
       12
    }

    Closure act ={
        println "thisObject:$thisObject"
        println "owner:$owner"
        println "delegate:$delegate"
    }

    Closure eat = {
        def test = {
            println "thisObject:${thisObject.getClass()}"
            println "owner:${owner.getClass()}"
            println "delegate:${delegate.getClass()}"
        }
        test()
    }
}

執行這個 eat 閉包，將會得到以下結果

> Task :test
thisObject:class Person
owner:class Person$_closure2
delegate:class Person$_closure2

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

可以看到 thisObject 和 owner 已經不一樣了，因為 thisObject 表示的是所在的類，而 owner 表示的定義所在的類或閉包（最近原則）

三個屬性已經很明白了吧，

委托策略

無論什麼時候在閉包中訪問某屬性或調用某方法時，若沒有明確的設置對象，那麼就會調用一個委托策略。通過這個委托策略來決定如果訪問屬性或調用方法。

有以下幾個策略，可以通過閉包的屬性更改：resolveStrategy

Closure.OWNER_FIRST 預設策略，首先在 owner 上尋找屬性和方法，找不到則在 delegate 上找。
Closure.DELEGATE_FIRST 和上面的相反，首先在 delegate 上尋找，找不到則在 owner 上找
Closure.OWNER_ONLY 只在 owner 上找，忽略 delegate
Closure.DELEGATE_ONLY 只在 delegate 上找忽略 owner
Closure.TO_SELF 高級選項，開發者自己定義策略

下麵通過一個嵌套類演示一下策略更改的實際應用。

定義兩個類 Person 和內部類 Foot ，並且兩者都有 name 屬性。Person 多一個 age 屬性。

class Person{
    private String name

    public int getAge(){
       12
    }

    class Foot {
      String name
      Closure walk = { it ->
          println "name is $name,age is $age ,delegate is ${delegate.getClass()}"
          //設置 delegate 屬性
          delegate = it;
          resolveStrategy = Closure.DELEGATE_FIRST
          println "修改策略為 Closure.DELEGATE_FIRST delegate 優先"
          println "name is $name, age is $age ,delegate is ${delegate.getClass()}"

      }
    }

    void walk(){
        Foot foot = new Foot(name:'腳');
        foot.walk(this)
    }
}

調用 Person 的 walk 方法

Person person = new Person()
person.name ="佛系編碼"
person.walk()

將會得到下麵的輸出

> Task :test
name is 腳,age is 12 ,delegate is class Person$Foot
修改策略為 Closure.DELEGATE_FIRST delegate 優先
name is 佛系編碼, age is 12 ,delegate is class Person

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

我來解釋一下這個輸出

第一個name 是腳；這是因為預設策略是 Closure.OWNER_FIRST 是在 owner 尋找屬性的；owner 當然是 Foot了。

第二個 name 是佛系編碼;這是因為策略改為了 Clousre.DELEGATE_FIRST 是優先在 delegate 上尋找的，而又把 delegate 屬性修改為了傳進去的 Person 實例，他的值在上面已經明確聲明為了佛系編碼。

而 age 只有在 Person 中聲明瞭 getAge() 方法，明確返回了 12.所以即使更改了策略，換了delegate 的值，仍然是 12.

註：三個屬性中只有 delegate 屬性可以修改。

在 Gradle 中，我們一般會指定 delegate 為當前的 it,這樣在閉包中就可以對 it 進行配置

定義一個 User 類

class User{

    String name
    int age
    
    def dumpUser(){

        println "name is $name,age is $age ."
    }

}

在構建配置腳本中定義一個方法，傳入一個閉包參數用來配置 User 類

將閉包委托策略更改，並設置 delegate 屬性

def user(Closure<User> closure){
    User user = new User()
    closure.delegate = user
    closure.resolveStrategy = Closure.DELEGATE_FIRST
    closure(user)
}

在使用的時候就是這樣的了，Gradle 中就有很多這種的 DSL 配置，例如我們創建的 task

task configClosure(){
    doLast{
      user {
        name = '佛系編碼'
        age = 0
        dumpUser()
      }
    }
}

輸出為

> Task :configClosure
name is 佛系編碼,age is 0 .

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

閉包 API 傳送門

類

這裡只介紹和 Java 中不同的地方.

先看段代碼：

task obj{
    doLast{
        Person p = new Person()
        println "沒賦值前的 ：${p.name}"
        p.name = '佛系編碼'
        println "賦值後的 ：${p.name}"

        println "age is ${p.age}"
    }
}

class Person{
    private String name

    public int getAge(){
       12
    }
}

執行 obj 任務的輸出

Task :obj
沒賦值前的 ：null
賦值後的 ：佛系編碼
age is 12

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

在 Person 類中並沒有定義 name 屬性的 get/set 方法；卻可以設置和修改它的值；

這是因為 Groovy 幫我們搞定了 get/set 方法。

age 屬性也沒有在 Person 類中定義，只是定義了一個 getAge() 方法卻可以使用 age 屬性。

但是,因為沒有定義 set 方法，所以 age 屬性只能訪問。

運算符

這裡只列出來和 Java 不同且常用的運算符

可空運算符

對象非空時使用對象本身，對象為空時使用給定值；常用於給定某個可空變數的預設值。

task operator {
    doLast{
        Person person = new Person();
        //person.name 為 null 所以會使用 佛系編碼
        def name = person.name ? person.name:'佛系編碼'
        // getAge 返回 12 不為空 所以使用本身
        def age = person.age ?:10
        println "name is $name , age is $age"
    }
}

輸出

> Task :operator
name is 佛系編碼 , age is 12

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

安全導航運算符

當調用一個對象上的屬性或方法時，如果對象是空的，就會拋出空異常，這個使用 ?. 運算符，當對象為空時，表達式的值也是空，就不會拋出異常。

task operator {
    doLast{
        User user
        println "user.name is ${user?.name}"
    }
}

輸出是

> Task :operator
user.name is null

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

斷言

斷言是用於驗證假設條件是否為真，在Groovy的斷言中，如果假設的條件不為真，那麼就會拋出java.lang.AssertionError異常。

Groovy斷言和Java斷言完全不同。Groovy斷言是一項語言功能，一直處於開啟狀態，和JVM的斷言功能-ea完全無關。所以它是我們進行單元測試的首選方式。

例如

assert 1==2 :"1不等於2"

會拋出以下異常

FAILURE: Build failed with an exception.

······

* What went wrong:
Execution failed for task ':operator'.
> 1不等於2. Expression: (1 == 2)

當然不給出消息也是可以的

assert 1==2

那麼異常就是這樣的。

Execution failed for task ':operator'.
> assert 1==2
          |
          false

在使用斷言時最好是給出一條消息，此消息可以幫助其他人理解和維護你的代碼，理清你的意圖。

Groovy API 查詢方式

對於閉包的參數，只能在 API 查詢了，沒有什麼好的辦法。

這裡把 Groovy 文檔地址列出來，方便大家查詢相關 API

運行須知

要使用 gradle 或者 ./gradle 或者 gradlew 命令，必須是要安裝Gradle 並設置過環境變數的，當然在Gradle所在的目錄也是可以的。

build.gradle 是Gradle 的預設構建腳本文件，在執行 Gradle 命令的時候會預設找在當前目錄下的 build.gradle 文件。

也可以通過 -b 參數指定載入執行的文件。

例如要執行 groovu-basic.build 里的 operator 任務

gradle -b groovy-basic.gradle operator

如果要執行上面的測試代碼，步驟是

新建一個 build.grale 文件或者是通過 gradle 新建一個項目看這篇
定義一個任務，添加動作

task test{
    doLast{
        //這裡是代碼
    }
}

粘貼代碼
運行任務

gradle test

附上我的 Gradle 版本

Groovy語法基礎

Groovy 簡介

DSL

註釋

單行註釋

多行註釋

doc 註釋

數據類型

字元串

集合

訪問元素

遍歷元素

數組

添加元素

修改元素

刪除元素

查找元素

統計元素

Map

添加元素

修改元素

刪除元素

遍歷元素

查找元素

方法

return 是可以省略的

括弧是可以省略的；

代碼塊是可以作為參數傳遞的

閉包

閉包委托

委托策略

類

運算符

可空運算符

安全導航運算符

斷言

Groovy API 查詢方式

運行須知