Gradle 系列之 Groovy 基础篇
上一篇学习了 Gradle 的入门知识，Gradle 基于 Groovy，今天学习一下 Groovy 的基础知识，Groovy 是基于 JVM 虚拟机的一种动态语言，语法与 Java 语法类似，Groovy 完全兼容 Java，每个 Gradle 文件都是一个 Groovy 脚本文件，Gradle 文件基于 Groovy 语法，而 Groovy 又兼容 Java，故可以在 Gradle 文件中写 Java 代码，在此基础上增加了很多新特性，如支持闭包、DSL等，可以说 Groovy 是一门非常灵活的动态脚本语言，针对 Gradle 来学习一下 Groovy 的一些基础知识。
字符串
集合
方法
JavaBean
关于闭包
字符串
说一个 Groovy 的特性，在 Groovy 中分号不是必须的，其单引号是双引号都定义的是一个字符串常量，不同之处是单引号是纯粹的字符串常量，不会对该字符串里面的表达式做运算，而使用双引号定义的字符串常量可以使用合法表达式做相关运算，测试代码如下：
1task stringTest{
2 //使用def关键字定义变量，
3 def str1 = "双引号"
4 def str2 = '单引号'
5
6 println "双引号定义的字符串："+str1
7 println "双引号定义的字符串："+str1.class
8 println "单引号定义的字符串："+str2
9
10 //变量动态变化
11 str1 = true;
12 println "双引号定义的字符串："+str1.class
13
14 //使用$运算符
15 println "双引号定义的字符串：${str1}"
16 //只有一个变量的时候可以省去中括号
17 println "双引号定义的字符串：$str1"
18
19 //单引号定义的字符串不能使用表达式进行运算
20 println '单引号定义的字符串：$str2'
21}
下面是执行结果，参考如下：
1PS E:\Gradle\study\Groovy> gradle stringTest
2
3> Configure project :
4双引号定义的字符串：双引号
5双引号定义的字符串：class java.lang.String
6单引号定义的字符串：单引号
7双引号定义的字符串：class java.lang.Boolean
8双引号定义的字符串：true
9双引号定义的字符串：true
10单引号定义的字符串：$str2
11
12
13BUILD SUCCESSFUL in 1s
集合
Groovy 中也有集合的概念，主要看一下常用的 List、Map，下面将对 List 和 Map 常用操作进行介绍。
那么如何在 Groovy 中定义 List 呢，Groovy 中的 List 的定义方式类似于 Java 中的数组，具体操作参考下面代码：
1task list{
2 //定义List
3 def list = [1,2,3,4,5,6];
4 def weekList = ['星期一','星期二','星期三','星期四','星期五','星期六','星期日'];
5 println "list的类型："+list.class
6 println "weekList的类型："+weekList.class
7
8 //访问集合里面的元素
9 println '第一个元素：'+list[0]//访问第一个元素
10 println '第二个元素：'+list[1]//访问第二个元素，以此类推
11
12 println '最后一个元素：'+list[-1]//访问最后一个元素
13 println '倒数第二个元素：'+list[-2]//访问倒数第二个元素，以此类推
14 println '某个范围内元素：'+list[2..4]//访问某个范围内元素，以此类推
15
16 //使用each遍历集合中的元素
17 weekList.each{
18 //使用it作为迭代的元素变量，不能写错喔
19 println it
20 }
21}
下面是上述代码的执行结果，参考如下：
1PS E:\Gradle\study\Groovy\ListMap> gradle list
2
3> Configure project :
4list的类型：class java.util.ArrayList
5weekList的类型：class java.util.ArrayList
6第一个元素：1
7第二个元素：2
8最后一个元素：6
9倒数第二个元素：5
10某个范围内元素：[3, 4, 5]
11星期一
12星期二
13星期三
14星期四
15星期五
16星期六
17星期日
18
19
20BUILD SUCCESSFUL in 2s
那么如何在 Groovy 中定义 Map 呢，Groovy 中的 Map 当然也是键值对，具体定义及操作参考下面代码：
1task map{
2
3 //定义Map
4 def map = ['name':'Groovy', 'age':10];
5 println "map的类型："+map.getClass().name;
6
7 //访问Map里面的元素
8 println map.name;
9 println map['name'];
10
11 //遍历Map中的元素
12 map.each{
13 println "Key:${it.key},value:${it.value}"
14 }
15}
下面是上述代码的执行结果，参考如下：
1PS E:\Gradle\study\Groovy\ListMap> gradle map
2
3> Configure project :
4map的类型：java.util.LinkedHashMap
5Groovy
6Groovy
7Key:name,value:Groovy
8Key:age,value:10
9
10
11BUILD SUCCESSFUL in 2s
关于 Groovy 的集合就了解这么多。
方法
Groovy 中的方法和 Java 中的方法类似，只是写法上更加灵活，Groovy 中 return 不是必须的，在不写 return 的时候，Groovy 会将最后一句代码作为该方法的返回值。代码块指的是一段被花括号包围的代码，Groovy 中可将代码块作为一个参数进行传递，可以参考前面关于集合的遍历部分，参考代码如下：
1task method{
2 //方法调用
3 methodA(1, 2)
4 methodA 1, 2
5
6 //获取方法返回的结果
7 def a = methodA 10, 20
8 println '获取方法返回的结果：'+a
9
10 //代码块作为参数传递
11 def list = [1,2,3,4,5];
12 list.each(
13 //闭包参数
14 {
15 // println it
16 }
17 )
18
19 //Groovy规定，如果方法的最后一个参数是闭包，可以直接放到方法外面
20 list.each(){
21 // println it
22 }
23
24 //简写方式
25 list.each{
26 println it
27 }
28}
29
30//方法的定义
31def methodA(int a, int b){
32 println a + b
33 //Groovy中return语句不是必须的，默认将最后一句代码的结果作为返回值
34 a + b
35}
下面是上述代码参考如下：
1PS E:\Gradle\study\Groovy\Method> gradle method
2
3> Configure project :
43
53
630
7获取方法返回的结果：30
81
92
103
114
125
13
14
15BUILD SUCCESSFUL in 2s
JavaBean
Groovy 中的 JavaBean 相较 Java 中的比较灵活，可以直接使用 javaBean.属性的方式获取和修改 JavaBean 的属性值，无需使用相应的 Getter、Setter 方法，直接看代码：
1task javaBean{
2 //Groovy中定义JavaBean
3 Student student = new Student()
4 student.name = "Groovy"
5 student.age = 10
6
7 student.setName("Gradle")
8 println "名字是："+student.name
9 //不能调用Getter方法获取值
10// println "名字是："+student.getName
11 println "年龄是：${student.age}"
12 println "分数是："+student.score
13}
14
15class Student{
16 private String name
17 private int age
18 //定义的Getter方法所对应的属性可以直接调用
19 public String getScore(){
20 100
21 }
22
23 //属性的Getter、Setter方法
24 public String setName(String name){
25 this.name = name
26 }
27
28 public void getName(){
29 name
30 }
31}
下面是上述代码的执行结果：
1PS E:\Gradle\study\Groovy\JavaBean> gradle javaBean
2
3> Configure project :
4名字是：Gradle
5年龄是：10
6分数是：100
7
8
9BUILD SUCCESSFUL in 2s
闭包
闭包是大多数脚本语言具有的一个特性，如 JavaScript、Groovy 等，闭包就是一个使用花括号包围的代码块，下面来学习 Groovy 中的闭包，主要有两部分：闭包及闭包参数传递和闭包委托。
闭包及其参数传递
下面来看一下如何定义一个闭包以及相关参数的传递，直接上代码：
1task closure{
2 //自定义闭包的执行
3 mEach{
4 println it
5 }
6
7 //向闭包传递参数
8 mEachWithParams{m,n -> //m,n ->将闭包的参数和主体区分离开来
9 println "${m} is ${n}"
10 }
11}
12
13//1.定义一个方法，参数closure用于接收闭包
14//2.闭包的执行就是花括号里面代码的执行
15//3.闭包接收的参数就是闭包参数closure参数中的i，如果是一个参数默认就是it变量
16def mEach(closure){
17 for(int i in 1..5){
18 closure(i)
19 }
20}
21
22//向闭包传递参数
23def mEachWithParams(closure){
24 def map = ["name":"Groovy","age":10]
25 map.each{
26 closure(it.key, it.value)
27 }
28}
上面代码中定义了闭包以及如何进行闭包的参数的传递，当闭包只有一个参数时，默认就是 it，反之闭包有多个参数时，就需要将参数定义出来，具体可参考上述代码，下面是执行结果：
1PS E:\Gradle\study\Groovy\Closure> gradle delegate
2
3> Configure project :
41
52
63
74
85
9name is Groovy
10age is 10
11
12BUILD SUCCESSFUL in 2s
闭包委托
Groovy 闭包的强大之处在于它支持闭包方法的委托，Groovy 的闭包有三个属性：thisObject、owner、delegate，当在一个闭包中调用定义的方法时，由这三个属性来确定该方法由哪个对象来执行，默认 owner 和 delegate 是相等的，其中 delete 是可以被修改的，Gradle 中闭包的很多功能都是通过修改 delegate 来实现的。下面通过定义一个闭包以及方法，通过打印来说明这三个属性的一些区别：
1//闭包的委托
2task delegate{
3 new Delegate().test{
4 //Groovy闭包的三个属性：thisObject、owner、delegate
5 println "thisObject:${thisObject.getClass()}"
6 println "owner:${owner.getClass()}"
7 println "delegate:${delegate.getClass()}"
8
9 //闭包默认it
10 println "闭包默认it:"+it.getClass()
11
12 //定义的方法，优先使用thisObject来处理
13 method()
14 //闭包中的方法
15 it.method()
16 }
17}
18
19def method(){
20 println "mththod in root:${this.getClass()}"
21}
22
23class Delegate{
24 def method(){
25 println "mththod in Delegate:${this.getClass()}"
26 }
27
28 //闭包
29 def test(Closure<Delegate> closure){
30 closure(this);
31 }
32}
下面是上述代码的执行结果，参考如下：
1PS E:\Gradle\study\Groovy\Closure> gradle delegate
2
3> Configure project :
4
5thisObject:class build_3ajca04o1rprxygcsq0ajvt7i
6owner:class build_3ajca04o1rprxygcsq0ajvt7i$_run_closure2
7delegate:class build_3ajca04o1rprxygcsq0ajvt7i$_run_closure2
8闭包默认it:class Delegate
9mththod in root:class build_3ajca04o1rprxygcsq0ajvt7i
10mththod in Delegate:class Delegate
11
12
13BUILD SUCCESSFUL in 2s
当在闭包中调用方法 method() 时，发现是 thisObject 调用了 method() 方法，而不是 owner 或 delegate，说明闭包中优先使用 thisObject 来处理方法的执行，同时可以看到 owner 和 delegate 是一致的，但是 owner 比 delegate 的优先级要高，所以闭包中方法的处理顺序是：thisObject > owner > delegate。
Gradle 中一般会指定 delegate 为当前的 it，这样我们将可以通过 delegate 指定的对象来操作 it 了，下面指定闭包的 delegate 并设置委托优先，让委托的具体对象来执行其方法，下面是测试代码：
1task student{
2 configStudent{
3 println "当前it：${it}"
4
5 name = "Groovy"
6 age = 10
7 getInfo()
8 }
9}
10
11class Student{
12 String name
13 int age
14 def getInfo(){
15 println "name is ${name}, age is ${age}"
16 }
17}
18
19def configStudent(Closure<Student> closure){
20 Student student = new Student()
21 //设置委托对象为当前创建的Student实例
22 closure.delegate = student
23 //设置委托模式优先，如果不设置闭包内方法的处理者是thisObject
24 closure.setResolveStrategy(Closure.DELEGATE_FIRST)
25 //设置it变量
26 closure(student)
27}
下面是上述代码的执行结果，参考如下：
1PS E:\Gradle\study\Groovy\Closure> gradle student
2
3> Configure project :
4
5当前it：Student@18f6d755
6name is Groovy, age is 10
7
8
9BUILD SUCCESSFUL in 2s
总结
学习 Groovy 的目的还是为了加深对 Gradle 构建工具的理解，上面通过五个方面对 Groovy 有了初步的人认识，后续如果有需要在看 Groovy 的高级用法。
如果有帮助可以点个赞，可以添加我的微信 jzmanu 相互交流学习。
推荐阅读：