groovy 是一种基于 jvm 的动态语言，他的语法和 java 相似，最终也是要编译 .class 在jvm上运行。
groovy 完全兼容 java 并且在此基础上添加了很多动态类型和灵活的特性，比如支持闭包，支持dsl，是一门非常灵活的动态脚本语言。
这篇文章是为了能看懂在 gradle脚本中的代码，知道怎么写。所以不会深入groovy。
每个 build 脚本配置文件都是一个 groovy脚本文件。在里面可以写任何符合 groovy 语法的代码。
例如定义类，方法，变量等。又因为groovy 是完全兼容java的，故也可以写任何java代码，是完全兼容的。
dsl（domain specific language) 中文意思是 领域特定语言，专门关注某一领域，在于专而不是全。所以才是领域特定的。
gradle 的脚本就是基于 groovy 的dsl，专门解决自动化构建的dsl。
我们只需要按照相应的语法，配置相应的 gradle 脚本就可以达到自动化构建的目的，这也是 dsl 的初衷。
//这里是注释 def name = "佛系编码"
/* 这里是多行注释 啦啦啦啦 */
/** * 这里是 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 的定义是键值对的方式，使用逗号隔开
def colors = [red:'#ff0000',green:'#00ff00',blue:'#0000ff']
访问 map 中的元素有三种方式：
例如：
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
}
}
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 的闭包有三个重要属性
如果将闭包定义在一个类中，默认三个属性都是相等的；
举个例子： 在 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
下面通过一个嵌套类演示一下 策略更改的实际应用。
定义两个类 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
这里只介绍和 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
在使用断言时最好是给出一条消息，此消息可以帮助其他人理解和维护你的代码，理清你的意图。
对于闭包的参数，只能在 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
如果要执行上面的测试代码，步骤是
task test{
dolast{
//这里是代码
}
}
gradle test
附上我的 gradle 版本
如对本文有疑问， 点击进行留言回复！！
Android SDK Manager 不知为什么突然打不开了？看这里
监听Android系统发出的插入SD卡并且已正确安装（识别）时发出的广播
RecyclerView三种常用效果的实现方法-android-kotlin
Android Studio app启动错误 Error running ：Default Activity not found
网友评论