Gradle系列之Groovy基础篇
原文发于微信公众号 jzman-blog，欢迎关注交流。java
上一篇学习了 Gradle 的入门知识，Gradle 基于 Groovy，今天学习一下 Groovy 的基础知识，Groovy 是基于 JVM 虚拟机的一种动态语言，语法与 Java 语法相似，Groovy 彻底兼容 Java，每一个 Gradle 文件都是一个 Groovy 脚本文件，Gradle 文件基于 Groovy 语法，而 Groovy 又兼容 Java，故能够在 Gradle 文件中写 Java 代码，在此基础上增长了不少新特性，如支持闭包、DSL等，能够说 Groovy 是一门很是灵活的动态脚本语言，阅读本文以前能够先阅读下面这篇文章：数组
下面针对 Gradle 来学习一下 Groovy 的一些基础知识。微信
- 字符串
- 集合
- 方法
- JavaBean
- 关于闭包
字符串
说一个 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 经常使用操做进行介绍。post
那么如何在 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 固然也是键值对，具体定义及操做参考下面代码：gradle
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}"
}
}
复制代码
下面是上述代码的执行结果，参考以下：ui
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，一块儿交流学习。
