原文首發(fā)于微信公眾號：躬行之(jzman-blog)，歡迎關(guān)注交流！

上一篇學(xué)習(xí)了 Gradle 的入門知識，Gradle 基于 Groovy，今天學(xué)習(xí)一下 Groovy 的基礎(chǔ)知識，Groovy 是基于 JVM 虛擬機的一種動態(tài)語言，語法與 Java 語法類似，Groovy 完全兼容 Java，每個 Gradle 文件都是一個 Groovy 腳本文件，Gradle 文件基于 Groovy 語法，而 Groovy 又兼容 Java，故可以在 Gradle 文件中寫 Java 代碼，在此基礎(chǔ)上增加了很多新特性，如支持閉包、DSL等，可以說 Groovy 是一門非常靈活的動態(tài)腳本語言，閱讀本文之前可以先閱讀下面這篇文章：

• Gradle系列之初識Gradle

下面針對 Gradle 來學(xué)習(xí)一下 Groovy 的一些基礎(chǔ)知識。

1. 字符串

2. 集合

3. 方法

4. JavaBean

5. 關(guān)于閉包

字符串

說一個 Groovy 的特性，在 Groovy 中分號不是必須的，其單引號是雙引號都定義的是一個字符串常量，不同之處是單引號是純粹的字符串常量，不會對該字符串里面的表達式做運算，而使用雙引號定義的字符串常量可以使用合法表達式做相關(guān)運算，測試代碼如下：

task stringTest{
    //使用def關(guān)鍵字定義變量，
    def str1 = "雙引號"
    def str2 = '單引號'
    
    println "雙引號定義的字符串："+str1
    println "雙引號定義的字符串："+str1.class
    println "單引號定義的字符串："+str2
    
    //變量動態(tài)變化
    str1 = true;
    println "雙引號定義的字符串："+str1.class
    
    //使用$運算符
    println "雙引號定義的字符串：${str1}"
    //只有一個變量的時候可以省去中括號
    println "雙引號定義的字符串：$str1"
    
    //單引號定義的字符串不能使用表達式進行運算
    println '單引號定義的字符串：$str2'
}

下面是執(zhí)行結(jié)果，參考如下：

PS E:\Gradle\study\Groovy> gradle stringTest

> Configure project :
雙引號定義的字符串：雙引號
雙引號定義的字符串：class java.lang.String
單引號定義的字符串：單引號
雙引號定義的字符串：class java.lang.Boolean
雙引號定義的字符串：true
雙引號定義的字符串：true
單引號定義的字符串：$str2


BUILD SUCCESSFUL in 1s

集合

Groovy 中也有集合的概念，主要看一下常用的 List、Map，下面將對 List 和 Map 常用操作進行介紹。

那么如何在 Groovy 中定義 List 呢，Groovy 中的 List 的定義方式類似于 Java 中的數(shù)組，具體操作參考下面代碼：

task list{
    //定義List
    def list = [1,2,3,4,5,6];
    def weekList = ['星期一','星期二','星期三','星期四','星期五','星期六','星期日'];
    println "list的類型："+list.class
    println "weekList的類型："+weekList.class
    
    //訪問集合里面的元素
    println '第一個元素：'+list[0]//訪問第一個元素
    println '第二個元素：'+list[1]//訪問第二個元素，以此類推
    
    println '最后一個元素：'+list[-1]//訪問最后一個元素
    println '倒數(shù)第二個元素：'+list[-2]//訪問倒數(shù)第二個元素，以此類推
    println '某個范圍內(nèi)元素：'+list[2..4]//訪問某個范圍內(nèi)元素，以此類推
    
    //使用each遍歷集合中的元素
    weekList.each{
        //使用it作為迭代的元素變量，不能寫錯喔
        println it
    }
}

下面是上述代碼的執(zhí)行結(jié)果，參考如下：

PS E:\Gradle\study\Groovy\ListMap> gradle list

> Configure project :
list的類型：class java.util.ArrayList
weekList的類型：class java.util.ArrayList
第一個元素：1
第二個元素：2
最后一個元素：6
倒數(shù)第二個元素：5
某個范圍內(nèi)元素：[3, 4, 5]
星期一
星期二
星期三
星期四
星期五
星期六
星期日


BUILD SUCCESSFUL in 2s

那么如何在 Groovy 中定義 Map 呢，Groovy 中的 Map 當(dāng)然也是鍵值對，具體定義及操作參考下面代碼：

task map{
    
    //定義Map
    def map = ['name':'Groovy', 'age':10];
    println "map的類型："+map.getClass().name;
    
    //訪問Map里面的元素
    println map.name;
    println map['name'];
    
    //遍歷Map中的元素
    map.each{
        println "Key:${it.key},value:${it.value}"
    }
}

下面是上述代碼的執(zhí)行結(jié)果，參考如下：

PS E:\Gradle\study\Groovy\ListMap> gradle map

> Configure project :
map的類型：java.util.LinkedHashMap
Groovy
Groovy
Key:name,value:Groovy
Key:age,value:10


BUILD SUCCESSFUL in 2s

關(guān)于 Groovy 的集合就了解這么多。

方法

Groovy 中的方法和 Java 中的方法類似，只是寫法上更加靈活，Groovy 中 return 不是必須的，在不寫 return 的時候，Groovy 會將最后一句代碼作為該方法的返回值。代碼塊指的是一段被花括號包圍的代碼，Groovy 中可將代碼塊作為一個參數(shù)進行傳遞，可以參考前面關(guān)于集合的遍歷部分，參考代碼如下：

task method{
    //方法調(diào)用
    methodA(1, 2)
    methodA 1, 2 
    
    //獲取方法返回的結(jié)果
    def a = methodA 10, 20
    println '獲取方法返回的結(jié)果：'+a
    
    //代碼塊作為參數(shù)傳遞
    def list = [1,2,3,4,5];
    list.each(
        //閉包參數(shù)
        {
        //    println it
        }
    )
    
    //Groovy規(guī)定，如果方法的最后一個參數(shù)是閉包，可以直接放到方法外面
    list.each(){
    //    println it
    }
    
    //簡寫方式
    list.each{
        println it
    }
}

//方法的定義
def methodA(int a, int b){
    println a + b
    //Groovy中return語句不是必須的，默認將最后一句代碼的結(jié)果作為返回值
    a + b
}

下面是上述代碼參考如下：

PS E:\Gradle\study\Groovy\Method> gradle method

> Configure project :
3
3
30
獲取方法返回的結(jié)果：30
1
2
3
4
5


BUILD SUCCESSFUL in 2s

JavaBean

Groovy 中的 JavaBean 相較 Java 中的比較靈活，可以直接使用 javaBean.屬性的方式獲取和修改 JavaBean 的屬性值，無需使用相應(yīng)的 Getter、Setter 方法，直接看代碼：

task javaBean{
    //Groovy中定義JavaBean
    Student student = new Student()
    student.name = "Groovy"
    student.age = 10
    
    student.setName("Gradle")
    println "名字是："+student.name
    //不能調(diào)用Getter方法獲取值
//    println "名字是："+student.getName
    println "年齡是：${student.age}"
    println "分?jǐn)?shù)是："+student.score
}

class Student{
    private String name
    private int age
    //定義的Getter方法所對應(yīng)的屬性可以直接調(diào)用
    public String getScore(){
        100
    }
    
    //屬性的Getter、Setter方法
    public String setName(String name){
        this.name = name
    }
    
    public void getName(){
        name
    }
}

下面是上述代碼的執(zhí)行結(jié)果：

PS E:\Gradle\study\Groovy\JavaBean> gradle javaBean

> Configure project :
名字是：Gradle
年齡是：10
分?jǐn)?shù)是：100


BUILD SUCCESSFUL in 2s

閉包

閉包是大多數(shù)腳本語言具有的一個特性，如 JavaScript、Groovy 等，閉包就是一個使用花括號包圍的代碼塊，下面來學(xué)習(xí) Groovy 中的閉包，主要有兩部分：閉包及閉包參數(shù)傳遞和閉包委托。

閉包及其參數(shù)傳遞

下面來看一下如何定義一個閉包以及相關(guān)參數(shù)的傳遞，直接上代碼：

task closure{
    //自定義閉包的執(zhí)行
    mEach{
        println it
    }
    
    //向閉包傳遞參數(shù)
    mEachWithParams{m,n -> //m,n ->將閉包的參數(shù)和主體區(qū)分離開來
        println "${m} is ${n}"
    }
}

//1.定義一個方法，參數(shù)closure用于接收閉包
//2.閉包的執(zhí)行就是花括號里面代碼的執(zhí)行
//3.閉包接收的參數(shù)就是閉包參數(shù)closure參數(shù)中的i，如果是一個參數(shù)默認就是it變量
def mEach(closure){
    for(int i in 1..5){
        closure(i)
    }
}

//向閉包傳遞參數(shù)
def mEachWithParams(closure){
    def map = ["name":"Groovy","age":10]
    map.each{
        closure(it.key, it.value)
    }
}

上面代碼中定義了閉包以及如何進行閉包的參數(shù)的傳遞，當(dāng)閉包只有一個參數(shù)時，默認就是 it，反之閉包有多個參數(shù)時，就需要將參數(shù)定義出來，具體可參考上述代碼，下面是執(zhí)行結(jié)果：

PS E:\Gradle\study\Groovy\Closure> gradle delegate

> Configure project :
1
2
3
4
5
name is Groovy
age is 10

BUILD SUCCESSFUL in 2s

閉包委托

Groovy 閉包的強大之處在于它支持閉包方法的委托，Groovy 的閉包有三個屬性：thisObject、owner、delegate，當(dāng)在一個閉包中調(diào)用定義的方法時，由這三個屬性來確定該方法由哪個對象來執(zhí)行，默認 owner 和 delegate 是相等的，其中 delete 是可以被修改的，Gradle 中閉包的很多功能都是通過修改 delegate 來實現(xiàn)的。下面通過定義一個閉包以及方法，通過打印來說明這三個屬性的一些區(qū)別：

//閉包的委托
task delegate{
    new Delegate().test{
        //Groovy閉包的三個屬性：thisObject、owner、delegate
        println "thisObject:${thisObject.getClass()}"
        println "owner:${owner.getClass()}"
        println "delegate:${delegate.getClass()}"
        
        //閉包默認it
        println "閉包默認it:"+it.getClass()
        
        //定義的方法，優(yōu)先使用thisObject來處理
        method()
        //閉包中的方法
        it.method()
    }
}

def method(){
    println "mththod in root:${this.getClass()}"
}

class Delegate{
    def method(){
        println "mththod in Delegate:${this.getClass()}"
    }
    
    //閉包
    def test(Closure<Delegate> closure){
        closure(this);
    }
}

下面是上述代碼的執(zhí)行結(jié)果，參考如下：

PS E:\Gradle\study\Groovy\Closure> gradle delegate

> Configure project :

thisObject:class build_3ajca04o1rprxygcsq0ajvt7i
owner:class build_3ajca04o1rprxygcsq0ajvt7i$_run_closure2
delegate:class build_3ajca04o1rprxygcsq0ajvt7i$_run_closure2
閉包默認it:class Delegate
mththod in root:class build_3ajca04o1rprxygcsq0ajvt7i
mththod in Delegate:class Delegate


BUILD SUCCESSFUL in 2s

當(dāng)在閉包中調(diào)用方法 method() 時，發(fā)現(xiàn)是 thisObject 調(diào)用了 method() 方法，而不是 owner 或 delegate，說明閉包中優(yōu)先使用 thisObject 來處理方法的執(zhí)行，同時可以看到 owner 和 delegate 是一致的，但是 owner 比 delegate 的優(yōu)先級要高，所以閉包中方法的處理順序是：thisObject > owner > delegate。

Gradle 中一般會指定 delegate 為當(dāng)前的 it，這樣我們將可以通過 delegate 指定的對象來操作 it 了，下面指定閉包的 delegate 并設(shè)置委托優(yōu)先，讓委托的具體對象來執(zhí)行其方法，下面是測試代碼：

task student{
    configStudent{
        println "當(dāng)前it：${it}"
        
        name = "Groovy"
        age = 10
        getInfo()
    }
}

class Student{
    String name
    int age
    def getInfo(){
        println "name is ${name}, age is ${age}"
    }
}

def configStudent(Closure<Student> closure){
    Student student = new Student()
    //設(shè)置委托對象為當(dāng)前創(chuàng)建的Student實例
    closure.delegate = student
    //設(shè)置委托模式優(yōu)先，如果不設(shè)置閉包內(nèi)方法的處理者是thisObject
    closure.setResolveStrategy(Closure.DELEGATE_FIRST)
    //設(shè)置it變量
    closure(student)
}

下面是上述代碼的執(zhí)行結(jié)果，參考如下：

PS E:\Gradle\study\Groovy\Closure> gradle student

> Configure project :

當(dāng)前it：Student@18f6d755
name is Groovy, age is 10


BUILD SUCCESSFUL in 2s

總結(jié)

學(xué)習(xí) Groovy 的目的還是為了加深對 Gradle 構(gòu)建工具的理解，上面通過五個方面對 Groovy 有了初步的人認識，后續(xù)如果有需要在看 Groovy 的高級用法。