原文發於微信公眾號 jzman-blog，歡迎關注交流。

上一篇學習了 Gradle 的入門知識，Gradle 基於 Groovy，今天學習一下 Groovy 的基礎知識，Groovy 是基於 JVM 虛擬機器的一種動態語言，語法與 Java 語法類似，Groovy 完全相容 Java，每個 Gradle 檔案都是一個 Groovy 指令碼檔案，Gradle 檔案基於 Groovy 語法，而 Groovy 又相容 Java，故可以在 Gradle 檔案中寫 Java 程式碼，在此基礎上增加了很多新特性，如支援閉包、DSL等，可以說 Groovy 是一門非常靈活的動態指令碼語言，閱讀本文之前可以先閱讀下面這篇文章：

• Gradle系列之初識Gradle

下面針對 Gradle 來學習一下 Groovy 的一些基礎知識。

1. 字串
2. 集合
3. 方法
4. JavaBean
5. 關於閉包

字串

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

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

 

下面是執行結果，參考如下：

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 中的陣列，具體操作參考下面程式碼：

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 '倒數第二個元素：'+list[-2]//訪問倒數第二個元素，以此類推
	println '某個範圍內元素：'+list[2..4]//訪問某個範圍內元素，以此類推
	
	//使用each遍歷集合中的元素
	weekList.each{
		//使用it作為迭代的元素變數，不能寫錯喔
		println it
	}
}

下面是上述程式碼的執行結果，參考如下：

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

> Configure project :
list的型別：class java.util.ArrayList
weekList的型別：class java.util.ArrayList
第一個元素：1
第二個元素：2
最後一個元素：6
倒數第二個元素：5
某個範圍內元素：[3, 4, 5]
星期一
星期二
星期三
星期四
星期五
星期六
星期日


BUILD SUCCESSFUL in 2s

那麼如何在 Groovy 中定義 Map 呢，Groovy 中的 Map 當然也是鍵值對，具體定義及操作參考下面程式碼：

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

下面是上述程式碼的執行結果，參考如下：

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

關於 Groovy 的集合就瞭解這麼多。

方法

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

task method{
	//方法呼叫
	methodA(1, 2)
	methodA 1, 2 
	
	//獲取方法返回的結果
	def a = methodA 10, 20
	println '獲取方法返回的結果：'+a
	
	//程式碼塊作為引數傳遞
	def list = [1,2,3,4,5];
	list.each(
		//閉包引數
		{
		//	println it
		}
	)
	
	//Groovy規定，如果方法的最後一個引數是閉包，可以直接放到方法外面
	list.each(){
	//	println it
	}
	
	//簡寫方式
	list.each{
		println it
	}
}

//方法的定義
def methodA(int a, int b){
	println a + b
	//Groovy中return語句不是必須的，預設將最後一句程式碼的結果作為返回值
	a + b
}

下面是上述程式碼參考如下：

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

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


BUILD SUCCESSFUL in 2s

JavaBean

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

task javaBean{
	//Groovy中定義JavaBean
	Student student = new Student()
	student.name = "Groovy"
	student.age = 10
	
	student.setName("Gradle")
	println "名字是："+student.name
	//不能呼叫Getter方法獲取值
//	println "名字是："+student.getName
	println "年齡是：${student.age}"
	println "分數是："+student.score
}

class Student{
	private String name
	private int age
	//定義的Getter方法所對應的屬性可以直接呼叫
	public String getScore(){
		100
	}
	
	//屬性的Getter、Setter方法
	public String setName(String name){
		this.name = name
	}
	
	public void getName(){
		name
	}
}

下面是上述程式碼的執行結果：

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

> Configure project :
名字是：Gradle
年齡是：10
分數是：100


BUILD SUCCESSFUL in 2s

閉包

閉包是大多數指令碼語言具有的一個特性，如 JavaScript、Groovy 等，閉包就是一個使用花括號包圍的程式碼塊，下面來學習 Groovy 中的閉包，主要有兩部分：閉包及閉包引數傳遞和閉包委託。

閉包及其引數傳遞

下面來看一下如何定義一個閉包以及相關引數的傳遞，直接上程式碼：

task closure{
	//自定義閉包的執行
	mEach{
		println it
	}
	
	//向閉包傳遞引數
	mEachWithParams{m,n -> //m,n ->將閉包的引數和主體區分離開來
		println "${m} is ${n}"
	}
}

//1.定義一個方法，引數closure用於接收閉包
//2.閉包的執行就是花括號裡面程式碼的執行
//3.閉包接收的引數就是閉包引數closure引數中的i，如果是一個引數預設就是it變數
def mEach(closure){
	for(int i in 1..5){
		closure(i)
	}
}

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

上面程式碼中定義了閉包以及如何進行閉包的引數的傳遞，當閉包只有一個引數時，預設就是 it，反之閉包有多個引數時，就需要將引數定義出來，具體可參考上述程式碼，下面是執行結果：

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，當在一個閉包中呼叫定義的方法時，由這三個屬性來確定該方法由哪個物件來執行，預設 owner 和 delegate 是相等的，其中 delete 是可以被修改的，Gradle 中閉包的很多功能都是通過修改 delegate 來實現的。下面通過定義一個閉包以及方法，通過列印來說明這三個屬性的一些區別：

//閉包的委託
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()
		
		//定義的方法，優先使用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);
	}
}

下面是上述程式碼的執行結果，參考如下：

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

當在閉包中呼叫方法 method() 時，發現是 thisObject 呼叫了 method() 方法，而不是 owner 或 delegate，說明閉包中優先使用 thisObject 來處理方法的執行，同時可以看到 owner 和 delegate 是一致的，但是 owner 比 delegate 的優先順序要高，所以閉包中方法的處理順序是：thisObject > owner > delegate。

Gradle 中一般會指定 delegate 為當前的 it，這樣我們將可以通過 delegate 指定的物件來操作 it 了，下面指定閉包的 delegate 並設定委託優先，讓委託的具體物件來執行其方法，下面是測試程式碼：

task student{
	configStudent{
		println "當前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()
	//設定委託物件為當前建立的Student例項
	closure.delegate = student
	//設定委託模式優先，如果不設定閉包內方法的處理者是thisObject
	closure.setResolveStrategy(Closure.DELEGATE_FIRST)
	//設定it變數
	closure(student)
}

下面是上述程式碼的執行結果，參考如下：

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

> Configure project :

當前it：Student@18f6d755
name is Groovy, age is 10


BUILD SUCCESSFUL in 2s

總結

學習 Groovy 的目的還是為了加深對 Gradle 構建工具的理解，上面通過五個方面對 Groovy 有了初步的人認識，後續如果有需要在看 Groovy 的高階用法。

如果感興趣，可以關注公眾號：躬行之(jzman-blog)，一起交流學習。

相關推薦