Groovy秘诀

听说java世界里有个Groovy大神!java需要半天处理的事情，Groovy只需要几分钟，是的，几分钟…剩下来的时间，程序员终于有时间泡妹子了，^_^…….技术宅的兄弟，赶紧来看看吧。

首先炫技一把!找质数,你们先想想用Java需要多少代码?Groovy一行足以!

def t = 1..100
(2..Math.sqrt(t.last())).each { n -> t -= ((2*n)..(t.last())).step(n) }
println t

//===>
[1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

再来一个装逼的问题:现在手头有很多的0.5美元、0.25美元、10美分、5美分、1美分，将1美元换成这些零钱，有多少种换法?

def count=0 
101.times{ x1 -> 21.times{
    x2 -> 11.times{ 
        x3 -> 5.times{ 
            x4 -> 3.times{ 
                x5 -> if(x1*1+x2*5+x3*10+x4*25+x5*50 == 100){
                         count++ 
                         println "$x1*1+$x2*5+$x3*10+$x4*25+$x5*50 == 100" 
                    } 
                } 
            } 
        } 
    } 
} 
println count

//===>
0*1+0*5+0*10+0*25+2*50 == 100
0*1+0*5+0*10+2*25+1*50 == 100
0*1+0*5+0*10+4*25+0*50 == 100
0*1+0*5+5*10+0*25+1*50 == 100
0*1+0*5+5*10+2*25+0*50 == 100
0*1+0*5+10*10+0*25+0*50 == 100
0*1+1*5+2*10+1*25+1*50 == 100
0*1+1*5+2*10+3*25+0*50 == 100
0*1+1*5+7*10+1*25+0*50 == 100
0*1+2*5+4*10+0*25+1*50 == 100
0*1+2*5+4*10+2*25+0*50 == 100
0*1+2*5+9*10+0*25+0*50 == 100
0*1+3*5+1*10+1*25+1*50 == 100
0*1+3*5+1*10+3*25+0*50 == 100
.............................

292

为什么是101,21,11,5,3
Range的起点是0开始的 100个1美分=1美元 (0..100)->101 20个5美分=1美元 (0..20)->21 10个10美分=1美元 (0..10)->11 4个0.25美元=1美元 (0..3)->4 2个0.5美元=1美元 (0..2)->3

好了,炫技装逼结束!!!

Java作为一种通用、静态类型的编译型语言有很多优势，但同样存在一些负担：

重新编译太费工；
静态类型不够灵活，重构起来时间可能比较长；
部署的动静太大；
java的语法天然不适用生产DSL；

那讲讲Groovy的优点:

groovy类在字节码级别就是java类,所以,groovy 对象在内存中就是java对象,在源代码级别, groovy 类和对象处理几乎是 java 语法的一个超集!

Groovy可以兼容java 是的，你可以用java语法来编写groovy,最后还可以生成class文件，直接用java调用。
Groovy是动态的不需要java的反射，不需要冗长的代码，不需要各种try catch 异常，你就可以实现各种神奇的事情。
函数字面值；
对集合的一等支持；
对正则表达式的一等支持；
对XML,JSON的一等支持；
Groovy是一把瑞士军刀 java是一把基础工具，等你需要的时候，你需要到处去找jar包，来填充自己的程序，而且你需要看API去弄懂各种使用。此外，java的编写实在是太冗长了，为了打印一个HelloWorld，你需要编写class, 写一个main函数。对于Groovy来说：print “hello world!”.这一句就足够了，这只是开始…

来,让我们进入Groovy的神奇世界吧!

Groovy具有的特性

自动导入

import java.lang.*;
import java.util.*;
import java.net.*;
import java.io.*;
import java.math.BigInteger;
import java.math.BigDecimal;
import groovy.lang.*;
import groovy.util.*;

Java会自动帮你导入java.lang包 Groovy会自动帮你导入上面的那些包

可选的分号`;`

def msg = "Hello"
msg += " World"; msg += "!";
println msg;

可选的圆括号`()`

def msg = "Hello"
msg += " World"; msg += "!";
println msg;

在Groovy中，方法参数的圆括号是可选的。这通常用于println等简单方法。然而,如果一个方法没有参数，就必须使用括号。例如:

def s = "Hello"
println s.toUpperCase()

可选的返回语句

String getFullName(){
  return "${firstName} ${lastName}"
}

//equivalent code
String getFullName(){
  "${firstName} ${lastName}"
}

Groovy中方法的最后一行是隐式返回语句。我们可以显式地使用return语句或安全地关闭它。

可选的变量类型 (Duck Typing)

def y = "Hello"
String z = "Hello"
println y.class

//===> java.lang.String

println y.class == z.class
//===> true

因为Groovy是动态语言,Groovy并不强迫你显式地定义一个变量的类型。

可选的异常处理

//in Groovy:
def reader = new FileReader("/foo.txt")

//in Java:
try{
  Reader reader = new FileReader("/foo.txt")
} catch(FileNotFoundException e) {
  e.printStackTrace()
}

在Java中，有两种类型的异常:已检查的和未检查的。 检查异常扩展自java.lang.Exception。我们必须包装可能在try/catch块中抛出异常的方法。
未经检查异常扩展自java.lang.Error或java.lang.RuntimeException。异常，如NullPointerException，ClassCastException和IndexOutOfBoundsException可能被抛出方法，但编译器不需要您将它们包装在一个try / catch块。
Groovy通过将所有已检查的异常转换为未检查的异常来解决这个问题

操作符重载

def d = new Date()
//===> Sat Sep 01 13:14:20 MDT 2007

d.next()
//===> Sun Sep 02 13:14:20 MDT 2007OPERATOR OVERLOADING 51

(1..3).each{ println d++ }
//===>
Sat Sep 01 13:14:20 MDT 2007
Sun Sep 02 13:14:20 MDT 2007
Mon Sep 03 13:14:20 MDT 2007

在Groovy中操作符重载还活着,正如在本例中看到的，++操作符在幕后调用next()方法。下面的列表显示了运算符和对应的方法调用:

Operator	Method
a == b or a != b	a.equals(b)
a + b	a.plus(b)
a - b	a.minus(b)
a * b	a.multiply(b)
a / b	a.div(b)
a % b	a.mod(b)
a++ or ++a	a.next()
a- - or - -a	a.previous()
a & b	a.and(b)
a	b
a[b]	a.getAt(b)
a[b] = c	a.putAt(b,c)
a << b	a.leftShift(b)
a >> b	a.rightShift(b)
a < b or a > b or a <= b or a >= b	a.compareTo(b)

这种语法糖在整个GDK (Groovy对JDK的增强)中都有出现

安全取值`?`

def s = "Jane"
s.size()
//===> 5

s = null
s.size()

//===>
Caught: java.lang.NullPointerException: Cannot invoke method size()
on null object at CommandLine.run(CommandLine.groovy:2)

//notice that we can call size()
//without throwing a NullPointerException
//thanks to the safe dereferencing ? operator
s?.size()
//===> null

Groovy的安全取值避免了空指针异常

//in Java:
if(person != null && person.getAddress() != null
&& person.getAddress().getPhoneNumber() != null ){
  System.out.println(person.getAddress().getPhoneNumber());
}
else{
  System.out.println("");
}

//in Groovy:
println person?.address?.phoneNumber

自动装箱`Autoboxing`

在Java中有原始类型int, float, doubl和包装对象Integer, Float, Double
当Java 5发布时，Sun 添加了自动装箱(透明地将原始类型转换成包装对象)，但是Sun没有消除原始类型/包装对象的划分;它只是让它变得不那么明显。
在Groovy中，一切都是对象。一切! 在Groovy中，原始类型就不再存在了。
Groovy还把Java5的自动装箱又向前推进了一步——自动装箱一切都在运行。

def i = 2
println i.class
//===> java.lang.Integer

def d = 2.2
println d.class
//===> java.math.BigDecima

float f = (float) 2.2F
f.class
//===> class java.lang.Float

对`true`的增强

0、NULL和""(空字符串)都赋值为false。这意味着在处理用户输入时，一个简单的if(args)就能捕获所有您想要避免的事情。

//true
if(1) // any non-zero value is true
if(-1)
if(!null) // any non-null value is true
if("John") // any non-empty string is trueGROOVY TRUTH 55
Map family = [dad:"John", mom:"Jane"]
if(family) // true since the map is populated
String[] sa = new String[1]
if(sa) // true since the array length is greater than 0
StringBuffer sb = new StringBuffer()
sb.append("Hi")
if(sb) // true since the StringBuffer is populated

//false
if(0) // zero is false
if(null) // null is false
if("") // empty strings are false
Map family = [:]
if(family) // false since the map is empty
String[] sa = new String[0]
if(sa) // false since the array is zero length
StringBuffer sb = new StringBuffer()
if(sb) // false since the StringBuffer is empty

嵌入的引号

def s1 = 'My name is "Jane"'
def s2 = "My name is 'Jane'"
def s3 = "My name is \"Jane\""

Groovy为Java字符串添加了一些不错的新技巧。在Java中，单引号用于表示单个char。在Groovy中，我们可以使用单引号将字符串括起来。这意味着我们可以使用单引号来保存包含双引号的字符串，而不必转义它们。当然，包含嵌入单引号的双引号字符串也是如此。带有退格的转义字符在两种语言中都是一样的。

三个引号`"""`

String s = """This is a
multi-line String.
"You don't need to escape internal quotes", he said.
"""

def ss = '''This
That, The Other'''

def xml = """

Groovy Recipes
Scott Davis
"""

def html = """..."""

许多动态语言，从Python到Perl再到Ruby都提供heredoc。一个heredoc允许您在单个变量中存储多行字符串。Groovy使用三引号(三个单引号或三个双引号)来定义这个文档。

魔力字符串`GStrings`

def name = "John"
println "Hello ${name}. Today is ${new Date()}"

//===> Hello John. Today is Fri Dec 28 15:16:32 MDT 2007

对于任何使用Ant构建文件或Java服务器页面(jsp)的人来说，字符串中嵌入的美元符号和花括号都是很熟悉的。它使字符串连接比传统Java容易得多:“Hello”+ name +“.”。 Groovy以GStrings(当然是“Groovy字符串”的缩写)的形式将这种语法引入到语言中。任何嵌入表达式的字符串都是GString!

列表`List`

def languages = ["Java", "Groovy", "JRuby"]
println languages.class

//===> java.util.ArrayList

Groovy为创建ArrayList提供了简洁的语法。
虽然方括号默认会给你一个ArrayList，但你可以在一行的末尾加一个as子句，以转换其他的类型。例如:

def languages = ["Java", "Groovy", "JRuby"] as String[]
def languages = ["Java", "Groovy", "JRuby"] as Set

创建空的列表

def empty = []
println empty.size()

//===> 0

添加元素

def languages = ["Java", "Groovy", "JRuby"]
languages << "Jython"

//===> [Java, Groovy, JRuby, Jython]

神奇的<<

获取元素

def languages = ["Java", "Groovy", "JRuby"]
println languages[1]
println languages.getAt(1)

//==> Groovy

枚举

def languages = ["Java", "Groovy", "JRuby"]
//using the default 'it' variable:
languages.each{println it}

//===>
Java
Groovy
JRuby

//using the named variable of your choice:
languages.each{lang ->
  println lang
}

//===>
Java
Groovy
JRuby

带索引的枚举

def languages = ["Java", "Groovy", "JRuby"]
languages.eachWithIndex{lang, i ->
  println "${i}: ${lang}"
}

//===>
0: Java
1: Groovy
2: JRuby

排序

def languages = ["Java", "Groovy", "JRuby"]
languages.sort()
//===> [Groovy, JRuby, Java]

println languages
//===> [Groovy, JRuby, Java]

倒转

def languages = ["Java", "Groovy", "JRuby"]
languages.reverse()
//===> [JRuby, Groovy, Java]

println languages
//===> [Java, Groovy, JRuby]

弹出

def languages = ["Java", "Groovy", "JRuby"]
languages.pop()
//===> "JRuby"

println languages
//===> [Java, Groovy]

连接

def languages = ["Java", "Groovy", "JRuby"]
def others = ["Jython", "JavaScript"]
languages += others
//===> [Java, Groovy, JRuby, Jython, JavaScript]

languages -= others
//===> [Java, Groovy, JRuby]

结合`join`

def languages = ["Java", "Groovy", "JRuby"]
println languages.join()
//===> JavaGroovyJRuby

//sum()的妙用
println languages.sum()
//===> JavaGroovyJRuby

println languages.join(",")
//===> Java,Groovy,JRuby

发现所有`findAll`

def languages = ["Java", "Groovy", "JRuby"]
languages.findAll{ it.startsWith("G") }

//===> [Groovy]

findAll()允许您查询列表。它返回一个新列表，其中包含所有符合条件的元素。

发现任何`any`

//List中是否含有某个字符串
def wordList = ['groovy', 'akka', 'grails framework', 'spock', 'typesafe']
def tweet = 'This is an example tweet talking about groovy and spock.'
wordList.any { word -> tweet.contains(word) }

//===> true

按条件拆分List`split`

def (passed, failed) = [49, 58, 76, 82, 88, 90].split{ it > 60 }

//===>
 [[76, 82, 88, 90], [49, 58]]

统计`Max, Min, Sum`

def scores = [80, 90, 70]
println scores.max()
//===> 90

println scores.min()
//===> 70

println scores.sum()
//===> 240

收集`Collect`

def languages = ["Java", "Groovy", "JRuby"]
languages.collect{ it += " is cool"}

//===> [Java is cool, Groovy is cool, JRuby is cool]

如果要修改列表中的每个元素，可以使用collect()方法。注意，collect()不修改原始列表。它返回一个新列表。

变平`Flatten`

def languages = ["Java", "Groovy", "JRuby"]
def others = ["Jython", "JavaScript"]
languages << others
//===> [Java, Groovy, JRuby, [Jython, JavaScript]]

languages = languages.flatten()
//===> [Java, Groovy, JRuby, Jython, JavaScript]

蔓延`Spread Operator (*)`

def languages = ["Java", "Groovy", "JRuby"]
println languages*.toUpperCase()
//===> [JAVA, GROOVY, JRUBY]

蔓延运算符允许您简洁地遍历一个列表，对每个元素调用相同的方法.

映射`Map`

def family = [dad:"John", mom:"Jane"]
println family.getClass()

//===> java.util.LinkedHashMap

Groovy为创建映射提供了简洁的语法。只需在等号右边的方括号中放入一个以逗号分隔的名称/值对列表，就可以得到一个映射。

创建空的Map

def empty = [:]
println empty.size()
//===> 0

获取元素

def family = [dad:"John", mom:"Jane"]
family.get("dad")
family.dad
family["dad"]

===> John

问题: 为什么. class在其他类上都行除了Map?

def family = [dad:"John", mom:"Jane"]
println family.class
===> null
println family.getClass()
===> java.util.LinkedHashMap

调用map.clas,类返回null而不是类类型。
为什么?因为映射不包含一个名为class的元素类。
对于Map,你必须使用Java形式的长方法map.getClass()

添加元素

def family = [dad:"John", mom:"Jane"]
family.put("kid", "Timmy")
family.kid2 = "Susie"
family["kid3"] = "Susie3"

println family

//===> dad:John, mom:Jane, kid:Timmy, kid2:Susie, kid3:Susie3]

枚举

def family = [dad:"John", mom:"Jane"]
//using the default 'it' variable:
family.each{println it}
//===>
dad=John
mom=Jane

//getting the key and value from 'it'
family.each{println "${it.value} is the ${it.key}"}
//===>
John is the dad
Jane is the momMAP SHORTCUTS 64

//using named variables for the key and value
family.each{k,v ->
  println "${v} is the ${k}"
}
//===>
John is the dad
Jane is the mom

连接`Concatenating`

def family = [dad:"John", mom:"Jane"]
def kids = [kid:"Timmy", kid2:"Susie"]
family += kids
//===> {dad=John, kid=Timmy, kid2=Susie, mom=Jane}

//删除
kids.each{k,v->
  family.remove("${k}")
}
//===> {dad=John, mom=Jane}

查找keys

def family = [dad:"John", mom:"Jane"]
family.keySet()
//===> [dad, mom]

family.containsKey("dad")
//===> true

查找Values

def family = [dad:"John", mom:"Jane"]
family.values()
//===> [John, Jane]

family.containsValue("John")
//===> true

范围`Ranges`

Groovy为范围提Ranges供了一种本机数据类型。您可以将范围Ranges存储在变量中，也可以动态地创建和使用它们。

def r = 1..3
println r.class
//===> groovy.lang.IntRange

r.each{println it}
//===>
1 2 3

r.each{ println "Hi" }
//===>
Hi
Hi
Hi

(1..3).each{println "Bye"}
//===>
Bye
Bye
Bye

Size, From, To

def r = 1..3
r.size()
//===> 3
r.from
//===> 1
r.to
//===> 3

遍历`For`

for(i in 1..3){ println "Attempt ${i}" }
//===>
Attempt 1
Attempt 2
Attempt 3

(1..3).each{ println "Attempt ${it}" }
//===>
Attempt 1
Attempt 2
Attempt 3

包含`Contains`

def r = 1..3
r.contains(1) && r.contains(3)
//===> true

r.contains(2)
//===> true

r.contains(12)
//===> false

倒转`Reverse`

def r = 1..3
r.reverse()
//===> [3, 2, 1]

闭包`Closures`

在Groovy里闭包无处不在!

def hi = { println "Hi"}
hi()

//===> Hi

上面例子是最简单的形式groovy.lang.Closure,闭包是一个独立的、命名的代码块。它是没有包装类的行为。

接收参数

def hello = { println "Hi ${it}" }
hello("John")
hello "John"

//===> Hi John

下面是一个稍微高级一点的闭包示例。请注意在each和convertToCelsius闭包中如何使用it参数闭包。

def convertToCelsius = {
  return (5.0/9.0) * (it.toFloat() - 32.0)
}

[0, 32, 70, 100].each{
  println "${it} degrees fahrenheit in celsius: ${convertToCelsius(it)}"
}

//===>
0 degrees fahrenheit in celsius: -17.7777777792
32 degrees fahrenheit in celsius: 0.0
70 degrees fahrenheit in celsius: 21.1111111128
100 degrees fahrenheit in celsius: 37.7777777808

命名参数

def calculateTax = { taxRate, amount ->
  return amount + (taxRate * amount)
}
println "Total cost: ${calculateTax(0.055, 100)}"

//===> Total cost: 105.500

固定参数`Currying Parameters`

函数柯里化（currying）是函数式编程中常用的技术。有时候我们在复用已有函数时可能需要固定其中的部分参数. 这除了可以通过默认值参数来实现之外，还可采用固定参数的方式Currying Parameters: 是把多个参数放进一个接受许多参数的函数，形成一个新的函数接受余下的参数，并返回结果。

def calculateTax = { taxRate, amount ->
  return amount + (taxRate * amount)
}
def tax = calculateTax.curry(0.1)

[10,20,30].each{
println "Total cost: ${tax(it)}"
}

//===>
Total cost: 11.0
Total cost: 22.0
Total cost: 33.0

Groovy与java集成的方式

GroovyClassLoader

用 Groovy 的 GroovyClassLoader ，动态地加载一个脚本并执行它的行为。GroovyClassLoader是一个定制的类装载器，负责解释加载Java类中用到的Groovy类。

GroovyClassLoader loader = new GroovyClassLoader();
Class groovyClass = loader.parseClass(new File(groovyFileName));
GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();
groovyObject.invokeMethod("run", "helloworld");

GroovyShell

GroovyShell允许在Java类中（甚至Groovy类）求任意Groovy表达式的值。您可使用Binding对象输入参数给表达式，并最终通过GroovyShell返回Groovy表达式的计算结果。

GroovyShell shell = new GroovyShell();
Script groovyScript = shell.parse(new File(groovyFileName));
Object[] args = {};
groovyScript.invokeMethod("run", args);

GroovyScriptEngine

GroovyShell多用于推求对立的脚本或表达式，如果换成相互关联的多个脚本，使用GroovyScriptEngine会更好些。GroovyScriptEngine从您指定的位置（文件系统，URL，数据库，等等）加载Groovy脚本，并且随着脚本变化而重新加载它们。如同GroovyShell一样，GroovyScriptEngine也允许您传入参数值，并能返回脚本的值。

GroovyBeans (aka POGOs)

自动生成Getters and Setters

class Book{
  String title
}
Book book = new Book()
book.setTitle("Groovy Recipes")
println book.getTitle()

//===> Groovy Recipes

Getter and Setter 的快捷方式

class Book{
  String title
}
Book book = new Book()
book.title = "Groovy Recipes"
//book.setTitle("Groovy Recipes")

println book.title
//println book.getTitle()

//===> Groovy Recipes

禁止自动生成Getters and Setters

class Book2{
  private String title
}
println Book2.getDeclaredField("title")
//===> private java.lang.String Book2.title

println Book2.methods.each{println it}; "DONE"
// neither getTitle() nor setTitle() should appear in the list

在Groovy中显式地将字段标记为private会抑制创建相应的getter和setter方法。如果您希望该字段真正隐藏在Java类中，那么这是很有帮助的。

但是对于其他Groovy类的可见性又如何呢?好吧，这段代码片段应该会让您非常清楚地知道该字段仍然是可访问的;尽管缺少getter和setter方法:

def b2 = new Book2()
b2.title = "Groovy Recipes"
println b2.title

//===> Groovy Recipes

Groovy在隐私方面有一些问题——简而言之，它忽略了私有修饰符。

如果要保护私有字段不受意外修改，您可以添加一对无所事事的getter和setter。

class Book3{
  private String title
  private String getTitle(){}
  private void setTitle(title){}
}

def b3 = new Book3()
b3.title = "Groovy Recipes"
println b3.title

//===> null

尽管创建“不做任何事情”的getter和setter会保护您的私有字段不被偶然的用户访问，但是在字段名中添加@前缀是允许的,您可以直接访问任何字段——公共的、私有的或受保护的。

`getProperty` 和`setProperty`

class Book{
  String title
}
Book book = new Book()
book.setProperty("title", "Groovy Recipes")
//book.title = "Groovy Recipes"
//book.setTitle("Groovy Recipes")

println book.getProperty("title")
//println book.title
//println book.getTitle()

//===> Groovy Recipes

通过`GStrings`来存取属性

class Book{
  String title
}

def b = new Book()
def prop = "title"
def value = "Groovy Recipes"

b."${prop}" = value
println b."${prop}"

//===> Groovy Recipes

使属性事只读的

class Book{
  final String title
  
  Book(title){
    this.title = title
  }
}

Book book = new Book()
book.title = "Groovy Recipes"
//===>
ERROR groovy.lang.ReadOnlyPropertyException:
Cannot set readonly property: title for class: Book

Book book2 = new Book("GIS for Web Developers")
println book2.title
//===>
GIS for Web Develop

在Groovy和Java中，final修饰符的工作方式都是一样的。

构造函数的简洁用法

class Book{
  String title
  String author
  Integer pages
}

Book book1 = new Book(title:"Groovy Recipes", author:"Scott Davis", pages:250)
Book book2 = new Book(pages:230, author:"Scott Davis", title:"GIS for eb Developers")
Book book3 = new Book(title:"Google Maps API")
Book book4 = new Book()

通过支持命名参数和可变长度参数，您可以以任何您认为合适的方式实例化类。

可选参数/缺省值

class Payment{
  BigDecimal amount
  String type
  
  public Payment(BigDecimal amount, String type="cash"){
    this.amount = amount
    this.type = type
  }
  
  String toString(){
    return "${amount} ${type}"
  }
}

def pmt1 = new Payment(10.50, "cash")
println pmt1
//===> 10.50 cash

def pmt2 = new Payment(12.75)
println pmt2
//===> 12.75 cash

def pmt3 = new Payment(15.99, "credit")
println pmt3
//===> 15.99 credit

私有方法

class Book{
  String title
  private String getTitle(){
    return title
  }
  
  private void setTitle(String title){
    this.title = title
  }
  
  private void poke(){
    println "Ouch!"
  }
}

Book book = new Book()CALLING GROOVY FROM JAVA 79
// notice that Groovy completely ignores the private access modifier
book.title = "Groovy Recipes"
println book.title
===> Groovy Recipes

book.poke()
===> Ouch!

简单地说，Groovy不关心方法的私有访问修饰符。您可以像调用公共方法一样轻松地调用私有方法。那私有方法的用处何在? 私有方法不会出现在公共接口中。这意味着当您调用Book.methods.each{println it}时，poke()不会出现。要知道poke()是可用的，唯一的方法是你面前有源代码。

强大的AST注解

Groovy编译器在生成字节码前，会先将代码转换为抽象代码树（Abstract Syntax Tree）。在这个转换过程中，我们可以让机器替我们自动插入很多代码。Groovy 提供了更多的 AST 转换选项，从而进一步减少了那些重复而乏味的例行代码。

`@TypeChecked`静态类型检查

静态类型检查器建立在Groovy已有、强大的AST（抽象语法树）之上，不熟悉它们的开发者可以将其视为一种利用注解触发的可选编译器插件。作为可选特性，不需要它时，Groovy不会强制你使用。要触发静态类型检查，只需在方法或类上使用@TypeChecked注解就可以在你期望的粒度级别打开检查。让我们首先看一个示例：

import groovy.transform.TypeChecked

void someMethod() {}

@TypeChecked
void test() {
    // 编译错误：
    // 找不到匹配的sommeeMethod()
    sommeeMethod()

    def name = "Marion"

    // 编译错误：
    // 没有声明变量naaammme
    println naaammme
}

/*
2 compilation errors:

[Static type checking] - Cannot find matching method ConsoleScript56#sommeeMethod(). Please check if the declared type is correct and if the method exists.
 at line: 9, column: 5

[Static type checking] - The variable [naaammme] is undeclared.
 at line: 15, column: 13
*/

我们用@TypeChecked注解了test()方法，它告诉Groovy编译器在编译时对指定的方法进行静态类型检查。我们试图调用带有明显拼写错误的someMethod()，并打印另一个拼错的name变量，编译器会分别抛出2个编译错误，因为找不到对应的方法和变量声明。

`@CompileStatic`静态编译

Groovy 2.0支持JVM新的"invoke dynamic"指令及其相关API，它们简化了Java平台上动态语言的开发并为Groovy的动态调用带来了额外的性能提高。但是还是比不上javac生成的字节码; 而@CompileStatic就是允许类型检查后的代码代码可被静态编译。

import groovy.transform.CompileStatic

@CompileStatic
int squarePlusOne(int num) {
	num * num + 1
}

assert squarePlusOne(3) == 10
/* 有@CompileStatic的,经过静态编译后的字节码
// access flags 0x1
  public squarePlusOne(I)I
   L0
    LINENUMBER 5 L0
    ILOAD 1
    ILOAD 1
    IMUL
    ICONST_1
    IADD
    IRETURN
   L1
   FRAME FULL [] [java/lang/Throwable]
    NOP
    NOP
    ATHROW
    LOCALVARIABLE this Lscript1540279088950; L0 L1 0
    LOCALVARIABLE num I L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2

*/

/* 没有@CompileStatic的,动态调用的字节码
  // access flags 0x1
  public squarePlusOne(I)I
   L0
    LINENUMBER 2 L0
    ILOAD 1
    ILOAD 1
    INVOKEDYNAMIC invoke(II)Ljava/lang/Object; [
      // handle kind 0x6 : INVOKESTATIC
      org/codehaus/groovy/vmplugin/v7/IndyInterface.bootstrap(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;I)Ljava/lang/invoke/CallSite;
      // arguments:
      "multiply", 
      0
    ]
    ICONST_1
    INVOKEDYNAMIC invoke(Ljava/lang/Object;I)Ljava/lang/Object; [
      // handle kind 0x6 : INVOKESTATIC
      org/codehaus/groovy/vmplugin/v7/IndyInterface.bootstrap(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;I)Ljava/lang/invoke/CallSite;
      // arguments:
      "plus", 
      0
    ]
    INVOKESTATIC org/codehaus/groovy/runtime/typehandling/DefaultTypeTransformation.intUnbox (Ljava/lang/Object;)I
    IRETURN
   L1
   FRAME FULL [] [java/lang/Throwable]
    NOP
    NOP
    ATHROW
    LOCALVARIABLE this Lscript1540279163256; L0 L1 0
    LOCALVARIABLE num I L0 L1 1
    MAXSTACK = 2
    MAXLOCALS = 2
*/

这次使用的是@CompileStatic，而非@TypeChecked，并且你的代码会被静态编译，同时生成的字节码非常像javac的字节码，运行速度一样。就像@TypeChecked注解，@CompileStatic能注解类和方法，@CompileStatic(SKIP)可以让某个方法在其所属类被@CompileStatic标记时不被静态编译。
最后一点值得注意的是，框架或库代码作者可使用静态编译，这有助于避免当代码库中多个部分使用动态元编程时的负面影响。

`@Log`

通过使用该注释（或使用 @Commons/@Log4j/@Slf4j 选择其它日志框架），可以在 AST 转换过程中注入日志代码。

import groovy.util.logging.*

@Log
class Car {
  {
    log.info 'Static Initiation'
  }
}
new Car()

以上代码执行时，会生成级别为 INFO 的日志。（很久很久以前，我们都是靠 IDE 来插入日志代码的，因为很无趣，是吧）

`@TimedInterrupt`

这一注释将有助于扼杀那些由患有BRAIN-DAMAGE(脑残)综合症的用户所制造了巨耗时的任务，比如包含了死循环的代码

@TimedInterrupt(5)
import groovy.transform.*

while(true) {}

这是个死循环，但是在使用注释后，运行该脚本将抛出异常： java.util.concurrent.TimeoutException: Execution timed out after 5 units.

`@ToString`

import groovy.transform.*

@ToString
class T {
    int i, j
}

println new T(i: 12, j: -1)
//===> T(12, -1)

@ToString(includeNames = true)
class T2 {
	int i, j
}

println new T2(i: 12, j: -1)
//===> T2(i:12, j:-1)

就是这么简单!

`@EqualsAndHashCode`

如果你的比较逻辑是基于比较所有成员的值，那么可以使用这个注释

import groovy.transform.*

@EqualsAndHashCode
class T {
	int i, j
}

`@TupleConstructor`

基于元组的构造函数

import groovy.transform.*

@ToString
@TupleConstructor
class T {
	int i, j
}

println new T(1, -12)
//===> T(1, -12)

`@Canonical`

ToString，TupleConstructor以及EqualsAndHashCode 都是最常用的功能，而 Canonical 正是它们的组合

import groovy.transform.*

@Canonical
@ToString(includeNames = true)
class T {
    int i, j
}

println new T(1, -12)
//===> T(i:1, j:-12)

`@Immutable`

创建不可变对象，创建后不能更改。这使得不可变对象在并发和函数编程中非常有用。要将Java类定义为不可变，我们必须将所有属性定义为readonly和private。只有构造函数可以设置属性的值。使类不可变的Java代码很冗长，特别是因为需要重写hashCode()，equals()和toString()方法。
Groovy有@Immutable转换为我们完成所有工作。我们只需要在类定义中定义@Immutable，我们为这个类创建的任何对象都是一个不可变对象。 Groovy按照不可变对象的规则生成一个类文件。所以所有属性都是只读的，创建构造函数来设置属性，生成hashCode()，equals()和toString()方法的实现.

@Immutable class User {
	String username, email
	Date created = new Date()
	Collection roles
}

def first = new User(username: 'mrhaki', email: '[email protected]', roles: ['admin', 'user'])
assert 'mrhaki' == first.username
assert '[email protected]' == first.email
assert ['admin', 'user'] == first.roles
assert new Date().after(first.created)
try {
	// Properties are readonly.
	first.username = 'new username'
} catch (ReadOnlyPropertyException e) {
	assert 'Cannot set readonly property: username for class: User' == e.message
}
try {
	// Collections are wrapped in immutable wrapper classes, so we cannot
	// change the contents of the collection.
	first.roles << 'new role'
} catch (UnsupportedOperationException e) {
	assert true
}

@Builder

我们可以使用@Builder AST转换轻松地为我们的类创建一个fluent(流式)的API。

import groovy.transform.builder.Builder

@Builder
class Message {
    String from, to, subject, body
}

def message = Message
        .builder()  // New internal helper class.
        .from('[email protected]')  // Method per property.
        .to('[email protected]')
        .subject('Sample mail')
        .body('Groovy rocks!')
        .build()  // Create instance of Message

assert message.body == 'Groovy rocks!'
assert message.from == '[email protected]'
assert message.subject == 'Sample mail'
assert message.to == '[email protected]'

@WithReadLock / @WithWriteLock

在以下代码中，如果没有调用 refresh()，那么可以有多个线程同时调用 getResource(key)，一旦有任何线程开始调用 refresh()，那么锁就会生效，所有调用 getResource 的线程都将进入等待状态。

import groovy.transform.*
public class ResourceProvider {

    private final Map data = new HashMap();

    @WithReadLock
    public String getResource(String key) throws Exception {
        return data.get(key);
    }

    @WithWriteLock
    public void refresh() throws Exception {
        //reload the resources into memory
    }
}

Groovy和Shell

简单运行shell脚本

// in Windows:
println "cmd /c dir".execute().text

//in Unix / Linux / Mac OS X:
println "ls -al".execute().text

如果在字符串上简单地调用execute()，则不会捕获得到的输出文本。如果希望看到shell命令返回的输出，可以将.text追加到.execute()的末尾。

如何处理Shell中的通配符

//in Windows:
println "cmd /c dir *.groovy".execute().text
def c = ["cmd", "/c", "dir *.groovy"].execute().text
println c

//in Unix / Linux / Mac OS X:
def output = ["sh", "-c", "ls -al *.groovy"].execute().text
println output

//sadly, these don't work
println "ls -al *.groovy".execute().text
println "sh -c ls -al *.groovy".execute().text

我们可以调用String数组上的execute。数组中的第一个元素是命令，下面的所有元素都作为参数传入。

同时运行多个Shell命令

//in Windows:
println "cmd /c dir c:\\opt & dir c:\\tmp".execute().text

//in Unix / Linux / Mac OS X:
println "ls /opt & ls /tmp".execute().text

等待Shell命令完成

def p = "convert -crop 256x256 full.jpg tile.jpg".execute()
p.waitFor()

获取系统属性

println System.getProperty("java.version")
//===> 1.8.0_172

System.properties.each{println it}
//===>
java.runtime.name=Java(TM) SE Runtime Environment
sun.boot.library.path=c:\Java\jdk1.8\jre\bin
java.vm.version=25.172-b11
java.vm.vendor=Oracle Corporation
java.vendor.url=http://java.oracle.com/
path.separator=;
java.vm.name=Java HotSpot(TM) 64-Bit Server VM
file.encoding.pkg=sun.io
user.country=CN
user.script=
sun.java.launcher=SUN_STANDARD
sun.os.patch.level=
program.name=
java.vm.specification.name=Java Virtual Machine Specification
user.dir=C:\WJW_E\WJW_DATA\OpenSource\groovy\bin
java.runtime.version=1.8.0_172-b11
java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment
java.endorsed.dirs=c:\Java\jdk1.8\jre\lib\endorsed
os.arch=amd64
java.io.tmpdir=C:\temp\
line.separator=
......

获取环境变量值

println System.getenv("JAVA_HOME")
//===> c:\Java\jdk1.8

System.env.each{println it}
//===>
configsetroot=C:\WINDOWS\ConfigSetRoot
USERDOMAIN_ROAMINGPROFILE=WJW-THINKPAD
COMMAND_COM="C:\WINDOWS\system32\cmd.exe"
PROCESSOR_LEVEL=6
SESSIONNAME=Console
ALLUSERSPROFILE=C:\ProgramData
CLASS=groovy.ui.Console
PROCESSOR_ARCHITECTURE=AMD64
PSModulePath=C:\Program Files\WindowsPowerShell\Modules;C:\WINDOWS\system32\WindowsPowerShell\v1.0\Modules
STARTER_CLASSPATH=C:\WJW_E\WJW_DATA\OpenSource\Groovy\bin\..\lib\groovy-2.5.2.jar
SystemDrive=C:
GROOVY_OPTS="-Xmx128m" -Dprogram.name="" -Dgroovy.home="C:\WJW_E\WJW_DATA\OpenSource\Groovy\bin\.." -Dtools.jar="c:\Java\jdk1.8\lib\tools.jar" -Dgroovy.starter.conf="C:\WJW_E\WJW_DATA\OpenSource\Groovy\bin\..\conf\groovy-starter.conf" -Dscript.name=""
DIRNAME=C:\WJW_E\WJW_DATA\OpenSource\Groovy\bin\
STARTER_CONF=C:\WJW_E\WJW_DATA\OpenSource\Groovy\bin\..\conf\groovy-starter.conf
USERNAME=wjw465150
TOOLS_JAR=c:\Java\jdk1.8\lib\tools.jar
ProgramFiles(x86)=C:\Program Files (x86)
PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC
DriverData=C:\Windows\System32\Drivers\DriverData
......

求值字符串`evaluate`

def s = "Scott"
def cmdName = "size"
evaluate("println s.${cmdName}()")
//===> 5

cmdName = "toUpperCase"
evaluate "println s.${cmdName}()"
//===> SCOTT

文件技巧

列出目录中的所有文件(包括目录,但是不包含子目录)

new File(".").eachFile{file ->
  println file
}

多简单!,再来看看Java的实现:

import java.io.File;

public class DirList {
  public static void main(String[] args) {
    File dir = new File(".");
    File[] files = dir.listFiles();
    for (int i = 0; i < files.length; i++) {
      File file = files[i];
      System.out.println(file);
    }
  }
}

只列出目录

new File(".").eachDir{dir ->
  println dir
}

只列出文件

new File(".").eachFile{file ->
  if(file.isFile()){
    println file
  }
}

列出目录中的所有文件(包括目录以及子目录)

new File(".").eachFileRecurse{file ->
  println file
}

如果是Java来实现,那就呵呵了,及其麻烦!为此早几年专门写过一个程序怎样深度优先&广度优先来遍历目录,见代码及附图

package wjw.demo;

import java.io.*;
import java.util.*;


/**
 * @author [email protected]
 *
*/

public class Main {
    /**
   *
   */
    public Main() {
    }
    
    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.out.println("Usage: Main [path name]");
            System.exit(0);
        }
 
        Main main = new Main();
 
        System.out.println("1.非递归广度优先");
        main.doIterator1(args[0]);
 
        System.out.println("--------------------------------------------------------------------");
 
        System.out.println("1.非递归深度优先");
        main.doIterator2(args[0]);
    }
 
    //非递归广度优先算法
    private void doIterator1(String rootPath) throws Exception {
        File rootFile = new File(rootPath);
        int level = 1;
        System.out.println(rootFile.getCanonicalFile());
 
        LinkedList list = new LinkedList();
        File[] childs = rootFile.listFiles();
        if (childs != null) {
            for (File child : childs) { // 1.先添加第1层的子节点到迭代列表里
                list.add(new WrapperFileNodeLevel(child, level + 1));
            }
        }
 
        WrapperFileNodeLevel wrap;
        while (!list.isEmpty()) { // 2. 开始迭代
            wrap = list.removeFirst(); // 移除并返回此列表的第一个元素
            if (wrap.file.isDirectory()) {
                System.out.println(convertLevel2Str(wrap.level) + "[" + wrap.file.getCanonicalPath() + "]");
            } else {
                System.out.println(convertLevel2Str(wrap.level) + wrap.file.getCanonicalPath());
            }
 
            childs = wrap.file.listFiles();
            if (childs != null) {
                for (File child : childs) {
                    list.add(new WrapperFileNodeLevel(child, wrap.level + 1)); // 3.有子节点则加入迭代列表
                }
            }
        }
 
    }
 
    //非递归深度优先算法
    private void doIterator2(String rootPath) throws Exception {
        File rootFile = new File(rootPath);
        int level = 1;
        System.out.println(rootFile.getCanonicalFile());
 
        LinkedList list = new LinkedList();
        File[] childs = rootFile.listFiles();
        if (childs != null) {
            for (File child : childs) { // 1.先添加第1层的子节点到迭代列表里
                list.add(new WrapperFileNodeLevel(child, level + 1));
            }
        }
 
        WrapperFileNodeLevel wrap;
        while (!list.isEmpty()) { // 2. 开始迭代
            wrap = list.removeFirst(); // 移除并返回此列表的第一个元素
            if (wrap.file.isDirectory()) {
                System.out.println(convertLevel2Str(wrap.level) + "[" + wrap.file.getName() + "]");
            } else {
                System.out.println(convertLevel2Str(wrap.level) + wrap.file.getName());
            }
 
            childs = wrap.file.listFiles();
            if (childs != null) {
                int pos = 0;
                for (File child : childs) {
                    list.add(pos++, new WrapperFileNodeLevel(child, wrap.level + 1)); // 3.有子节点则加入迭代列表
                }
            }
        }
 
    }
 
    private String convertLevel2Str(int level) {
        StringBuilder sb = new StringBuilder("");
        for (int i = 0; i < level; i++) {
            if (i == level - 1) {
                sb.append("|-");
            } else {
                sb.append("  ");
            }
        }
 
        return sb.toString();
    }
 
    private class WrapperFileNodeLevel {
        final File file;
        final int level;
 
        /**
         * @param file
         * @param level
         */
        WrapperFileNodeLevel(File file, int level) {
            this.file = file;
            this.level = level;
        }
 
    }
 
}

列出目录中的指定类型的文件

new File(".").eachFile{file ->
  if(file.name.endsWith(".jsp")){
    println file
  }
}

更简单的方法,通过正则表达式

new File(".").eachFileMatch(~/.*\.jsp/){file ->
  println file
}

读取文件内容

new File("x.txt").eachLine{line->
  println line
}

读取文件内容到字符串变量里

String body = new File("x.txt").text

读取文件内容到数组里

List lines = new File("x.txt").readLines()

简单的分析文件

// FileStats.groovy
File file = new File("juliet.txt")
List lines = file.readLines()
println "Number of lines: ${lines.size()}"

int wordCount = 0
file.splitEachLine(" "){words ->
  println words.size()
  wordCount += words.size()
}
println "Number of words: ${wordCount}"

//===>
Number of lines: 4
7 7
10
7
Number of words: 31

向文件里写内容

File file = new File("hello.txt")
file.write("Hello World\n")
println file.text

//===>
Hello World

println file.readLines().size()

//===>
1

再对比一下Java的实现

import java.io.*;
public class NewFile {
  public static void main(String[] args) {
    File file = new File("hello.txt");
    PrintWriter pw = null;
    try {
      pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
      pw.println("Hello World");
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      pw.flush();
      pw.close();
    }
    
    BufferedReader br = null;
    int lineCount = 0;
    try {
      br = new BufferedReader(new FileReader(file));
      String line = null;
      while ((line = br.readLine()) != null) {
        System.out.println(line);
        lineCount++;
      }
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      try {
        br.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
    System.out.println(lineCount);
  }
}

向文件里添加内容

File file = new File("hello.txt")
println "${file.size()} lines"

//===> 1 lines
file.append("How's it going?\n")
file << "I'm fine, thanks.\n"
println "${file.size()} lines"

//===> 3 lines

合并几个文本文件

// merge.groovy
File logDir = new File(".")
File mergedFile = new File("summary/merged.log")
mergedFile.write("") //empty out the existing file
logDir.eachFile { file - >
    if (file.isFile() && file.name.endsWith(".log")) {
      mergedFile << file.text
    }
}

复制文件

//文本文件
def src = new File("src.txt")
new File("dest.txt").write(src.text)

//二进制文件
File src = new File("src.jpg")
new File("dest.jpg").withOutputStream{ out ->
  out.write src.readBytes()
}

添加自己的`copy`到File对象里

File.metaClass.copy = { String destName - >
    if (delegate.isFile()) {
      new File(destName).withOutputStream { out - >
          out.write delegate.readBytes()
      }
    }
}
new File("src.jpg").copy("dest.jpg")

metaClass的威力后面会讲到!

使用`AntBuilder`复制文件

Groovy内建了对Ant的支持!复杂的文件操作可以直接使用Ant的.

//simple Copy
def ant = new AntBuilder()
ant.copy(file:"src.txt", tofile:"dest.txt")

//Copying a File to a Directory
def ant = new AntBuilder()
ant.copy(file:"src.txt", todir:"../backup")

//Overwriting the Destination File
def ant = new AntBuilder()
ant.copy(file:"src.txt", tofile:"dest.txt", overwrite:true)

//Using AntBuilder to Copy a Directory
def ant = new AntBuilder()
ant.copy(todir:"backup"){
  fileset(dir:"images")
}

//Selectively Including/Excluding Files
//NOTE: this WILL NOT copy files in subdirectories
// due to the pattern in include and exclude
def ant = new AntBuilder()
ant.copy(todir:"backup", overwrite:true){
  fileset(dir:"images"){
    include(name:"*.jpg")
    exclude(name:"*.txt")
  }
}

//NOTE: this WILL copy files in subdirectories
// due to the pattern in include and exclude
def ant = new AntBuilder()
ant.copy(todir:"backup", overwrite:true){
  fileset(dir:"images"){
    include(name:"**/*.jpg")
    exclude(name:"**/*.txt")
  }
}

//Flattening the Directory Structure on Copy
def ant = new AntBuilder()
ant.copy(todir:"backup", overwrite:true, flatten:true){
  fileset(dir:"images"){
    include(name:"**/*.jpg")
    exclude(name:"**/*.txt")
  }
}

// images (before):
images/logo.jpg
images/big_image.jpg
images/icons/button.jpg
images/icons/arrow.jpg
images/thumbnails/big_image_thumb.jpgMOVING/RENAMING FILES 112

// backup (after):
backup/logo.jpg
backup/big_image.jpg
backup/button.jpg
backup/arrow.jpg
backup/big_image_thumb.jpg

移动/重命门文件

// using the File method
File src = new File("src.txt")
src.renameTo(new File("dest.txt"))

// using the operating system
"mv src.txt dest.txt".execute()

// using AntBuilder
def ant = new AntBuilder()
ant.move(file:"src.txt", tofile:"dest.txt")

删除文件

// using the File method
new File("src.txt").delete()

// using the operating system
"rm src.txt".execute()

// using AntBuilder
def ant = new AntBuilder()
ant.delete(file:"src.txt")

删除目录

def ant = new AntBuilder()
ant.delete(dir:"tmp", includeemptydirs:"true")

//Deleting Selected Files from a Directory
def ant = new AntBuilder()
ant.delete{
  fileset(dir:"tmp", includes:"**/*.bak")
}

创建压缩文件

def ant = new AntBuilder()

// zip files
ant.zip(basedir:"images", destfile:"../backup.zip")

// tar files
ant.tar(basedir:"images", destfile:"../backup.tar")
ant.gzip(zipfile:"../backup.tar.gz", src:"../backup.tar")
ant.bzip2(zipfile:"../backup.tar.bz2", src:"../backup.tar")


//Zipping Up Selected Files
def ant = new AntBuilder()
ant.zip(destfile:"../backup.zip"){
  fileset(dir:"images"){
    include(name:"**/*.jpg")
    exclude(name:"**/*.txt")
  }
}

解压缩压缩文件

def ant = new AntBuilder()

// unzip files
ant.unzip(src:"../backup.zip", dest:"/dest")

// untar files
ant.gunzip(src:"../backup.tar.gz")
ant.bunzip2(src:"../backup.tar.bz2")
ant.untar(src:"../backup.tar", dest:"/dest")

//Unzipping Selected Files
def ant = new AntBuilder()
ant.unzip(src:"../backup.zip", dest:"/dest"){
  patternset{
    include(name:"**/*.jpg")
    exclude(name:"**/*.txt")
  }
}

解析XML

Parsing XML

def p2 = """

  Jane
  Doe
  
    123 Main St
    Denver
    CO
    80020
  
"""

def person = new XmlSlurper().parseText(p2)
println person.firstname
//===> Jane

println person.address.city
//===> Denver

println person.address.@type
//===> home

`XmlParser`与`XmlSlurper`的异同

先来看看他们的相同之处。

构造方法都是一模一样的，从缺省的构造到自定义的reader，parser等完全的一样
解析XML的parse/parseText方法参数也完全的一致，当然了返回结果类型是不一样的
返回结果类型虽然不一样，但是他们处理GPath的语法却是那么一致

其实，处理XML我们比较关注的还是处理Xml的过程，也就是parser的返回结果，可喜的是groovy.util.Node(XmlParser)和GPathResult(XmlSlurper)对GPath的支持都很好，以下简单罗列一下他们常用的共同的方法：

name() 返回值：Node->Object,GPathResult->String
text() 返回值：String
toString() 返回值：String
parent() 返回值：Node->Node,GPathResult->GPathResult，快捷方式：'..'
children() 返回值：Node->List,GPathResult->GPathResult，快捷方式：'*****'
attributes() 返回值：Map，在GPathResult中并不存在此方法，但是当是节点类型时候会有此方法（实际上还是调用Node的attributes）
iterator() 返回值：Iterator
depthFirst() 返回值：Node->List,GPathResult->Iterator，快捷方式：'**'
breadthFirst() 返回值：Node->List,GPathResult->Iterator

此外对XML元素和属性的操作也是同样的一致，如下：

['elementName']或.elementName，通过名称访问子元素
[index]，通过下标访问子元素
['@attributeName']或.'@attributeName'，访问属性，GPathResult也可以将引号去掉，直接用.@attributeName访问

def CAR_RECORDS = '''  
      
        
        Australia  
        Production Pickup Truck with speed of 271kph  
        
        
        Isle of Man  
        Smallest Street-Legal Car at 99cm wide and 59 kg in weight  
        
      
  '''  
def parserRoot = new XmlParser().parseText(CAR_RECORDS)  
def slurperRoot = new XmlSlurper().parseText(CAR_RECORDS)  
assert 'records'==parserRoot.name()  
assert 'records'==slurperRoot.name()  
assert 2==parserRoot.car.size()  
assert 2==slurperRoot.car.size()  

assert 'P50'==parserRoot.car[1].'@name'  
assert 'P50'==parserRoot.car[1].attribute('name')  
println parserRoot.car[1][email protected]()
println parserRoot.car[1][email protected]()
println parserRoot.car[1][email protected]()

assert 'P50'==slurperRoot.car[1][email protected]() //不能这样: assert 'P50'==slurperRoot.car[1].@name 
assert 'P50'==slurperRoot.car[1][email protected]()
assert slurperRoot.car[1].@name=='P50'

println slurperRoot.car[1][email protected]()
println slurperRoot.car[1][email protected]()
println slurperRoot.car[1][email protected]()

assert slurperRoot.car.any{ it.@name == 'P50' }  

//===>
class java.lang.String
3
P50
class groovy.util.slurpersupport.Attributes
1
P50

说了那么多行同点，不禁要问既生“XmlParser”又生“XmlSlurper”，何必呢，马上我们来看不同之处。前面也可以看到，它们最大的不同就是parse的返回类型不同，因此主要是groovy.util.Node(XmlParser)和GPathResult(XmlSlurper)的不同。

groovy.util.Node是以list的形式来表述GPath的，因此Node在可显性有着明显的优势，比如toString可以直接看到结果，可以直接print，可以在原处修改等等。那缺点呢？显而易见，因为用list来表述，因此也需要额外的内存空间来存储，这在Xml内容小的时候，没啥问题，可一旦处理大量的Xml时，要慎之！慎之！罗列一些Node特有的方法

Object value()
void setValue(Object value)
Object attribute(Object key)
NodeList getAt(QName name)
void print(PrintWriter out)

再来看看GPathResult，它没有使用list来处理GPath，而是采用iterators方式，因此没有了额外空间消耗，可是如果要访问最后一个node时候，可要费点时间了

罗列一些GPathResult特有的方法

GPathResult parents()
GPathResult declareNamespace(Map newNamespaceMapping)
List list()
int size()
GPathResult find(Closure closure)
GPathResult findAll(Closure closure)

总之，两种方式各有优缺点，每个人可以根据实际的情况灵活应用。

命名空间`Namespaces`的处理

//Parsing an XML Document with Namespaces
def p_xml = """

John
Smith

"""
def person = new XmlParser().parseText(p_xml)
//the firstname element cannot be found without its namespace
println person.firstname.text()
===> []
def p = new groovy.xml.Namespace("http://somewhere.org/person")
println person[p.firstname].text()
===> John
println person[p.'last-name'].text()
===> Smith

//Namespaces in XmlSlurper
//XmlSlurper缺省是忽略命名空间的
def p = """

John
Smith

"""

def person = new XmlSlurper().parseText(p)
println person.firstname
println person.'last-name'
===>
John
Smith

//GPathResult是支持命名空间的,通过declareNamespace()方法
def itemXml = """

iPhonePOPULATING A GROOVYBEAN FROM XML 134
Apple
1

"""

def item = new XmlSlurper().parseText(itemXml)
println item.name
===> iPhoneApple

def ns = [:]
ns.product = "urn:somecompany:products"
ns.vendor = "urn:somecompany:vendors"
item.declareNamespace(ns)

println item.'product:name'
===> iPhone

把XML转换成POJO对象

import groovy.transform.*

def p = """

  Jane
  Doe

"""

@ToString(includeNames = true)
class Person {
  String firstname
  String lastname
}

def pxml = new XmlParser().parseText(p)
def person = new Person()

pxml.children().each { child ->
    person.setProperty(child.name(), child.text())
}
println person

def sxml = new XmlSlurper().parseText(p)
def person2 = new Person()

sxml.children().each { child ->
    person2.setProperty(child.name(), child.text())
}

println person2

构建XML

使用`MarkupBuilder`简单的创建XML

def xml = new groovy.xml.MarkupBuilder()
xml.person(id: 99) {
  firstname("John")
  lastname("Smith")
}

//===>

  John
  Smith

就像魔术一样，XML文档无缝的融合在Groovy中。

使用`MarkupBuilder`捕获输出

def sw = new StringWriter()
def xml = new groovy.xml.MarkupBuilder(sw);
xml.PERSON(id:100){
	firstName("Jane")
	LastName("Doe")
}
println sw.toString()
// ===>

  Jane
  Doe


def fw = new FileWriter("/path/to/some/file.xml")
def xml2 = new groovy.xml.MarkupBuilder(fw)
xml2.PERSON(id:100){
	firstName("Jane")
	LastName("Doe")
}

使用`MarkupBuilder`创建带命名空间的XML

def xml = new groovy.xml.MarkupBuilder()
def params = [:]
params."xmlns:product" = "urn:somecompany:products"
params."xmlns:vendor" = "urn:somecompany:vendors"
params.id = 99
xml.person(params) {
  "product:name" ("iPhone")
  "vendor:name" ("Apple")
  quantity(1)
}

//===>

  iPhone
  Apple
  1

`MarkupBuilder`与`StreamingMarkupBuilder`的不同之处

// MarkupBuilder
def xml = new groovy.xml.MarkupBuilder()
xml.person(id:100){
	firstname("Jane")
	lastname("Doe")
}
//===>

Jane
Doe


// StreamingMarkupBuilder
def xml = new groovy.xml.StreamingMarkupBuilder().bind{
  person(id:100){
		firstname("Jane")
		lastname("Doe")
	}
}

println xml
//===>
JaneDoe

像前面的XmlParser和XmlSlurper一样,Groovy也提供2中方式来输出XML. MarkupBuilder是两者中比较简单的一个,当您的需求超出MarkupBuilder所能提供的范围时，您可以使用StreamingMarkupBuilder。

MarkupBuilder和StreamingMarkupBuilder有三个关键区别:

MarkupBuilder将输出发送给System.out。默认情况下StreamingMarkupBuilder是静默的，直到您明确地将它交给一个Writer。
MarkupBuilder是同步的;StreamingMarkupBuilder是异步的。换句话说，MarkupBuilder立即将XML文档写出来。StreamingMarkupBuilder允许单独定义闭包。在StreamingMarkupBuilder被传递给Writer之前，不会生成文档。
最后，MarkupBuilder会格式化它的输出，而StreamingMarkupBuilder并没有。

后面专门介绍StreamingMarkupBuilder,以及他的高级功能!

使用`StreamingMarkupBuilder`通过单独的闭包来创建XML

def builder = new groovy.xml.StreamingMarkupBuilder()
def person = {
	person(id:99){
		firstname("John")
		lastname("Smith")
	}
}
println builder.bind(person)

//===>
JohnSmith/person>

StreamingMarkupBuilder允许定义一个闭包，并将其传递给bind()方法。这意味着您可以独立的创建两个闭包，并将其绑定到StreamingMarkupBuilder来创建XML文档。

def builder = new groovy.xml.StreamingMarkupBuilder(encoding: "UTF-8")
def person1 = {
	person(id:99){
		firstname("John")
		lastname("Smith")
	}
}
def person2 = {
	person(id:100){
		firstname("Jane")
		lastname("Doe")
	}
}
def personList = {
  mkp.xmlDeclaration()   //会输出: 
	"person-list"{
		out << person1
		out << person2
	}
}
println builder.bind(personList)

//===>
JohnSmithJaneDoe

格式化输出XML

def builder = new groovy.xml.StreamingMarkupBuilder()
def person = {
	person(id:99){
		firstname("John")
		lastname("Smith")
	}
}

println groovy.xml.XmlUtil.serialize(builder.bind(person))

//===>

  John
  Smith

使用`StreamingMarkupBuilder`创建带命名空间的XML

def builder = new groovy.xml.StreamingMarkupBuilder().bind{
	mkp.declareNamespace('':'http://myDefaultNamespace')
	mkp.declareNamespace('location':'http://someOtherNamespace')
	person(id:100){
		firstname("Jane")
		lastname("Doe")
		location.address("123 Main St")
	}
}
println builder

//===>
JaneDoe123 Main St

输出XML的`Declaration`

//setting the encoding
def builder2 = new groovy.xml.StreamingMarkupBuilder()
builder2.encoding = "UTF-8"
println builder2.bind{
  mkp.xmlDeclaration()
}
//===>

输出XML的`Processing Instructions`

def builder = new groovy.xml.StreamingMarkupBuilder()
def person = {
  mkp.pi("xml-stylesheet": "type='text/xsl' href='myfile.xslt'")
}
println builder.bind(person)
//===>

输出XML里的任意字符串 (Comments, CDATA)

def comment = ""
def cdata = " >< & Look 'at' me & >< "
def builder = new groovy.xml.StreamingMarkupBuilder().bind{
	person(id:99){
		firstname("John")
		lastname("Smith")
		
		mkp.yieldUnescaped(comment)
		unescaped << comment
		
		unescaped << ""
		
		mkp.yield(comment)
    out << comment
	}
}
println groovy.xml.XmlUtil.serialize(builder)

//===>

  John
  Smith
  
  < & Look 'at' me & >< ]]><!-- address is optional --><!-- address is optional -->

输出到一个文件里

def builder = new groovy.xml.StreamingMarkupBuilder()
def person = {
	person(id:99){
		firstname("John")
		lastname("Smith")
	}
}

def writer = new FileWriter("person.xml")
writer << builder.bind(person)
writer.close()

一个完整的输出XML的例子

def comment = ""
def builder = new groovy.xml.StreamingMarkupBuilder()
builder.encoding = "UTF-8"
def person = {
    mkp.xmlDeclaration()
    mkp.pi("xml-stylesheet": "type='text/xsl' href='myfile.xslt'" )
    mkp.declareNamespace('':'http://myDefaultNamespace')
    mkp.declareNamespace('location':'http://someOtherNamespace')
    person(id:100){
        firstname("Jane")
        lastname("Doe")
        mkp.yieldUnescaped(comment)
        location.address("123 Main")
    }
}
System.out << builder.bind(person)

//===>

JaneDoe123 Main

动态创建HTML

def h = {
    head{
        title("Search Results")
        link(rel:"stylesheet", type:"text/css", href:"http://main.css")
        script(type:"text/javascript", src:"http://main.js")
    }
}
def b = {
    body{
        h1("Search Results")
        div(id:"results", class:"simple"){
            table(border:1){
                tr{
                    th("Name")
                    th("Address")
                }
                tr{
                    td{
                        a(href:"http://abc.org?id=100","Jane Doe")
                    }
                    td("123 Main St")
                }
            }
        }
    }
}
def html = new groovy.xml.StreamingMarkupBuilder().bind{
    unescaped << ''
    html{
        out << h
        out << b
    }
}
println html.toString()

//===>
Search Results

Groovy秘诀

Groovy秘诀

Groovy具有的特性

自动导入

可选的分号;

可选的圆括号()

可选的返回语句

可选的变量类型 (Duck Typing)

可选的异常处理

操作符重载

安全取值?

自动装箱Autoboxing

对true的增强

嵌入的引号

三个引号"""

魔力字符串GStrings

列表List

创建空的列表

添加元素

获取元素

枚举

带索引的枚举

排序

倒转

弹出

连接

结合join

发现所有findAll

发现任何any

按条件拆分Listsplit

统计Max, Min, Sum

收集Collect

变平Flatten

蔓延Spread Operator (*)

映射Map

创建空的Map

获取元素

添加元素

枚举

连接Concatenating

查找keys

查找Values

范围Ranges

Size, From, To

遍历For

包含Contains

倒转Reverse

闭包Closures

接收参数

命名参数

固定参数Currying Parameters

Groovy与java集成的方式

GroovyClassLoader

GroovyShell

GroovyScriptEngine

GroovyBeans (aka POGOs)

自动生成Getters and Setters

Getter and Setter 的快捷方式

禁止自动生成Getters and Setters

getProperty 和setProperty

通过GStrings来存取属性

使属性事只读的

构造函数的简洁用法

可选参数/缺省值

私有方法

强大的AST注解

@TypeChecked静态类型检查

@CompileStatic静态编译

@Log

@TimedInterrupt

@ToString

@EqualsAndHashCode

@TupleConstructor

@Canonical

@Immutable

@Builder

@WithReadLock / @WithWriteLock

Groovy和Shell

简单运行shell脚本

如何处理Shell中的通配符

可选的分号`;`

可选的圆括号`()`

安全取值`?`

自动装箱`Autoboxing`

对`true`的增强

三个引号`"""`

魔力字符串`GStrings`

列表`List`

结合`join`

发现所有`findAll`

发现任何`any`

按条件拆分List`split`

统计`Max, Min, Sum`

收集`Collect`

变平`Flatten`

蔓延`Spread Operator (*)`

映射`Map`

连接`Concatenating`

范围`Ranges`

遍历`For`

包含`Contains`

倒转`Reverse`

闭包`Closures`

固定参数`Currying Parameters`

`getProperty` 和`setProperty`

通过`GStrings`来存取属性

`@TypeChecked`静态类型检查

`@CompileStatic`静态编译

`@Log`

`@TimedInterrupt`

`@ToString`

`@EqualsAndHashCode`

`@TupleConstructor`

`@Canonical`

`@Immutable`

求值字符串`evaluate`

添加自己的`copy`到File对象里

使用`AntBuilder`复制文件

移动/重命门文件

删除文件

删除目录

解压缩压缩文件

`XmlParser`与`XmlSlurper`的异同

命名空间`Namespaces`的处理

使用`MarkupBuilder`简单的创建XML

使用`MarkupBuilder`捕获输出

使用`MarkupBuilder`创建带命名空间的XML

`MarkupBuilder`与`StreamingMarkupBuilder`的不同之处

使用`StreamingMarkupBuilder`通过单独的闭包来创建XML

使用`StreamingMarkupBuilder`创建带命名空间的XML

输出XML的`Declaration`

输出XML的`Processing Instructions`