Gradle----Groovy

String testFunction(arg1,arg2){//无需指定参数类型

  ...

}

def  nonReturnTypeFunc(){

     last_line   //最后一行代码的执行结果就是本函数的返回值

}

//如果指定了函数返回类型，则可不必加def关键字来定义函数

String  getString(){

   return "I am a string"

}

//下面这个函数的返回值是字符串"getSomething return value"

def getSomething(){

      "getSomething return value" //如果这是最后一行代码，则返回类型为String

      1000 //如果这是最后一行代码，则返回类型为Integer

}

   def singleQuote='I am $ dolloar'  //输出就是I am $ dolloar

   def doubleQuoteWithoutDollar = "I am one dollar" //输出 I am one dollar

   def x = 1

   def doubleQuoteWithDollar = "I am $x dolloar" //输出I am 1 dolloar

   def multieLines = ''' begin

     line  1 

     line  2

     end '''

println("test") ---> println "test"

def getSomething(){

   "hello"

}

变量定义：List变量由[]定义，比如

def aList = [5,'string',true] //List由[]定义，其元素可以是任何对象

变量存取：可以直接通过索引存取，而且不用担心索引越界。如果索引超过当前链表长度，List会自动

往该索引添加元素

assert aList[1] == 'string'

assert aList[5] == null //第6个元素为空

aList[100] = 100  //设置第101个元素的值为10

assert aList[100] == 100

那么，aList到现在为止有多少个元素呢？

println aList.size  ===>结果是101

容器变量定义

变量定义：Map变量由[:]定义，比如

def aMap = ['key1':'value1','key2':true] 

Map由[:]定义，注意其中的冒号。冒号左边是key，右边是Value。key必须是字符串，value可以是任何对象。另外，key可以用''或""包起来，也可以不用引号包起来。比如

def aNewMap = [key1:"value",key2:true] //其中的key1和key2默认被

处理成字符串"key1"和"key2"

不过Key要是不使用引号包起来的话，也会带来一定混淆，比如

def key1="wowo"

def aConfusedMap=[key1:"who am i?"]

aConfuseMap中的key1到底是"key1"还是变量key1的值“wowo”？显然，答案是字符串"key1"。如果要是"wowo"的话，则aConfusedMap的定义必须设置成：

def aConfusedMap=[(key1):"who am i?"]

Map中元素的存取更加方便，它支持多种方法：

println aMap.keyName    <==这种表达方法好像key就是aMap的一个成员变量一样

println aMap['keyName'] <==这种表达方法更传统一点

aMap.anotherkey = "i am map"  <==为map添加新元素

def aRange = 1..5  <==Range类型的变量 由begin值+两个点+end值表示

                      左边这个aRange包含1,2,3,4,5这5个值

如果不想包含最后一个元素，则

def aRangeWithoutEnd = 1..<5  <==包含1,2,3,4这4个元素

println aRange.from

println aRange.to

def aClosure = {//闭包是一段代码，所以需要用花括号括起来..  

    String param1, int param2 ->  //这个箭头很关键。箭头前面是参数定义，箭头后面是代码  

    println "this is code" //这是代码，最后一句是返回值，  

   //也可以使用return，和Groovy中普通函数一样  

}  

def xxx = {paramters -> code}  //或者  

def xxx = {无参数，纯code}  这种case不需要->符号

aClosure.call("this is string",100)  或者  

aClosure("this is string", 100)  

def greeting = { "Hello, $it!" }

assert greeting('Patrick') == 'Hello, Patrick!'

def greeting = { it -> "Hello, $it!" }

assert greeting('Patrick') == 'Hello, Patrick!'

def noParamClosure = { -> true }

noParamClosure ("test")  <==报错喔！

public static <T> List<T> each(List<T> self, Closure closure)

def iamList = [1,2,3,4,5]  //定义一个List

iamList.each{  //调用它的each，这段代码的格式看不懂了吧？each是个函数，圆括号去哪了？

      println it

}

def  testClosure(int a1,String b1, Closure closure){

      //do something

      closure() //调用闭包

}

那么调用的时候，就可以免括号！

testClosure (4, "test", {

   println "i am in closure"

} )  //红色的括号可以不写..

 doLast({

   println 'Hello world!'

})

public static <T> List<T> each(List<T> self, Closure closure)

def iamList = [1,2,3,4,5]  //定义一个List变量

iamList.each{  //调用它的each函数，只要传入一个Closure就可以了。

  println it

}

iamList.each{String name,int x ->

  return x

}  //运行的时候肯定报错！

Java中，我们最熟悉的是类。但是我们在Java的一个源码文件中，不能不写class（interface或者其他....），而Groovy可以像写脚本一样，把要做的事情都写在xxx.groovy中，而且可以通过groovyxxx.groovy直接执行这个脚本。这到底是怎么搞的？

既然是基于Java的，Groovy会先把xxx.groovy中的内容转换成一个Java类。比如：

test.groovy的代码是：

println 'Groovy world!'  

Groovy把它转换成这样的Java类：

执行 groovyc -dclasses test.groovy

groovyc是groovy的编译命令，-dclasses用于将编译得到的class文件拷贝到classes文件夹下

下图是test.groovy脚本转换得到的java class。用jd-gui反编译它的代码：

 图中：

·        test.groovy被转换成了一个test类，它从script派生。

·        每一个脚本都会生成一个static main函数。这样，当我们groovytest.groovy的时候，其实就是用java去执行这个main函数

·        脚本中的所有代码都会放到run函数中。比如，println'Groovy world'，这句代码实际上是包含在run函数里的。

·        如果脚本中定义了函数，则函数会被定义在test类中。

groovyc是一个比较好的命令，读者要掌握它的用法。然后利用jd-gui来查看对应class的Java源码。

def x = 1 <==注意，这个x有def（或者指明类型，比如 int x = 1）  

def printx(){  

   println x  

}  

x = 1  <==注意，去掉def或者类型

def printx(){

   println x

}

printx()  <==OK

import groovy.transform.Field;   //必须要先import

@Field x = 1  <==在x前面加上@Field标注，这样，x就彻彻底底是test的成员变量了。

targetFile.eachLine{   

  String oneLine ->  

   println oneLine      

  <==是不是令人发指？？！  

targetFile.getBytes()  <==文件内容一次性读出，返回类型为byte[]  

def ism =  targetFile.newInputStream()  

//操作ism，最后记得关掉  

ism.close  

注：实际操作中发现发生如下异常：

Caught: groovy.lang.MissingPropertyException: No such property: close for class: java.io.BufferedInputStream
Possible solutions: class
groovy.lang.MissingPropertyException: No such property: close for class: java.io.BufferedInputStream

修改为ism.close()后异常消失，疑因把close误认为是属性引起的。

 targetFile.withInputStream{ ism ->

   操作ism. 不用close。Groovy会自动替你close

}

def srcFile = new File(源文件名)  

def targetFile = new File(目标文件名)  

targetFile.withOutputStream{ os->  

  srcFile.withInputStream{ ins->  

      os << ins   //利用OutputStream的<<操作符重载，完成从inputstream到OutputStream  

       //的输出  

   }  

}  

<response version-api="2.0">  

       <value>  

           <books>  

               <book available="20"id="1">  

                   <title>Don Xijote</title>  

                   <author id="1">Manuel De Cervantes</author>  

               </book>  

               <book available="14"id="2">  

                   <title>Catcher in the Rye</title>  

                  <author id="2">JD Salinger</author>  

              </book>  

              <book available="13"id="3">  

                  <title>Alice in Wonderland</title>  

                  <author id="3">Lewis Carroll</author>  

              </book>  

              <book available="5"id="4">  

                  <title>Don Xijote</title>  

                  <author id="4">Manuel De Cervantes</author>  

              </book>  

           </books>  

      </value>  

   </response>  

//第一步，创建XmlSlurper类  

def xparser = new XmlSlurper()  

def targetFile = new File("test.xml")  

//轰轰的GPath出场  

gpathResult =xparser.parse(targetFile)  

//开始玩test.xml。现在我要访问id=4的book元素。  

//下面这种搞法，gpathResult代表根元素response。通过e1.e2.e3这种  

//格式就能访问到各级子元素....  

def book4 = gpathResult.value.books.book[3]  

//得到book4的author元素  

def author = book4.author  

//再来获取元素的属性和textvalue  

assert author.text() == 'Manuel De Cervantes'  

获取属性更直观  

author.@id == '4' 或者 author['@id'] == '4'  

属性一般是字符串，可通过toInteger转换成整数  

author.@id.toInteger() == 4  

再看个例子。我在使用Gradle的时候有个需求，就是获取AndroidManifest.xml版本号（versionName）。有了GPath，一行代码搞定，请看：  

def androidManifest = newXmlSlurper().parse("AndroidManifest.xml")  

println androidManifest['@android:versionName']  

或者  

println androidManifest.@'android:versionName'