Groovy学习.doc

Groovy的基础语法
Groovy 的语法融合了 Ruby、Python 和 Smalltalk 的一些最有用的功能，同时保留了基于 Java 语言的核心语法。对于Java 开发人员，Groovy 提供了更简单的替代语言，且几乎不需要学习时间。
语句
Groovy的语句和Java类似，但是有一些特殊的地方。例如语句的分号是可选的。如果每行一个语句，就可以省略分号；如果一行上有多个语句，则需要用分号来分隔。
x = [1, 2, 3] println x y = 5; x = y + 7 println x assert x == 12
另外return关键字在方法的最后是可选的；同样，返回类型也是可选（缺省是Object）。
动态类型
像其他Script一 样，Groovy 不需要显式声明类型。在 Groovy 中，一个对象的类型是在运行时动态发现的，这极大地减少了要编写的代码数量。在Groovy中，类型对于值(variables)、属性 (properties)、方法(method)和闭包(closure)参数、返回值都是可有可无的，只有在给定值的时候，才会决定它的类型，(当然声 明了类型的除外）。例如：
//Groovy 动态类型 myStr = "Hello World"
由于使用了动态类型，不需要继承就可以得到多态的全部功能：

class Song{ Property length Property name }
class Book{ def public name def public author }
def doSomething(thing){ println "going to do something with a thing named = " + thing.name }
这里定义了两个Groovy 类，Song 和 Book。这两个类都包含一个 name 属性。函数 doSomething，它以一个 thing 为参数，并试图打印这个对象的 name 属性，但doSomething 函数没有定义其输入参数的类型，所以只要对象包含一个 name 属性，那么它就可以工作。可见， Song 和 Book 的实例都可以作为 doSomething 的输入参数。

mySong = new Song(length:90, name:"Burning Down the House") myBook = new Book(name:"One Duck Stuck", author:"Phyllis Root") doSomething(mySong) //prints Burning Down the House doSomething(myBook) //prints One Duck Stuck def doSth=this.&doSomething doSth(mySong) doSth(myBook)
在例子的最后，我们还创建了doSomething的一个函数指针 doSth，最后的执行结果与调用doSoemthing是一样的。
值得注意的是：与Groovy Beta不同，在使用新的JSR Groovy类时，类里面的所有的变量都必须加上 def 关键字或者 private、protected 或 public 这样的修饰符。当然，也可以用 @Property 关键字声明成员变量。在Script中则不必。
字符串
Groovy中的字符串允许使用双引号和单引号。
当使用双引号时，可以在字符串内嵌入一些运算式，Groovy允许您使用 与 bash 类似的 ${expression} 语法进行替换。可以在字符串中包含任意的Groovy表达式。
name="James" println "My name is ${name},'00${6+1}'" //prints My name is James,'007'
Groovy还支持"uXXXX" 引用（其中X是16进制数），用来表示特殊字符，例如 "u0040" 与"@"字符相同。
大块文本
如果有一大块文本（例如 HTML 和 XML）不想编码，你可以使用Here-docs. here-docs 是创建格式化字符串的一种便利机制。它需要类似 Python 的三重引号(""")开头，并以三重引号结尾。

name = "James" text = ""“ hello there ${name} how are you today? ”"" assert text != null println(text)
在Groovy-JSR中，不再支持下面这种多行字符串，个人觉得似乎与Here-docs功能重叠：

对字符串的操作
1. contains 字符串中是否包含子字符串，'groovy'.contains('oo')将返回true;
2. count 返回字符串中子字符串出现的次数，'groooovy'.count('oo')将返回3.
3. tokenize 根据分隔符将字符串分解成子串，'apple^banana^grap'.tokenize('^')返回['apple','banana','grape']。
4. 减操作 'groovy'-'oo'，结果是'grvy'。
5. 乘操作 'oo'*3，结果是'oooooo'。

foo = “hello there how are things?” println(foo)
对字符串的操作
1. contains 字符串中是否包含子字符串，'groovy'.contains('oo')将返回true;
2. count 返回字符串中子字符串出现的次数，'groooovy'.count('oo')将返回3.
3. tokenize 根据分隔符将字符串分解成子串，'apple^banana^grap'.tokenize('^')返回['apple','banana','grape']。
4. 减操作 'groovy'-'oo'，结果是'grvy'。
5. 乘操作 'oo'*3，结果是'oooooo'。
Groovy主要结构
接下来将展示Groovy的一些结构，包逻辑分支，类、闭包等等。
逻辑分支
if-else语句
Groovy提供Java相同的if-else语句。

x = false y = false if ( !x ) { x = true }
assert x == true if ( x ) { x = false } else{ y = true } assert x == y
Groovy也支持三元操作符。

y = 5 x = (y > 1) ? "worked" : "failed" assert x == "worked"
switch语句
Groovy的switch语句兼容Java代码，但是更灵活，Groovy的switch语句能够处理各种类型的switch值，可以做各种类型的匹配：
1. case值为类名，匹配switch值为类实例
2. case值为正则表达式，匹配switch值的字符串匹配该正则表达式
3. case值为集合，匹配switch值包含在集合中，包括ranges
除了上面的，case值与switch值相等才匹配。

x = 1.23 result = "" switch ( x ) { case "foo": result = "found foo" // lets fall through case "bar": result += "bar" case [4, 5, 6, ‘inList‘]: result = "list" break case 12..30: result = "range" break case Integer: result = "integer" break case Number: result = "number" break default: result = "default" } assert result == "number"
Switch语句的工作原 理：switch语句在做case值匹配时，会调用isCase(switchValue)方法，Groovy提供了各种类型，如类，正则表达式、集合等 等的重载。可以创建自定义的匹配类，增加isCase(switchValue)方法来提供自定义的匹配类型。
循环
while和do 循环
Groovy支持Java相同的while循环，但目前暂不支持do循环
x = 0 y = 5 while ( y-- > 0 ){ x++ } assert x == 5
for循环
Groovy的for循环更简单，而且能够和各种类型的数组、集合、Map、范围等一起工作，我们稍候会详细介绍这些内容。

// iterate over a range x = 0 for ( i in 0..9 ) { x += i }
assert x == 45
// iterate over a list
x = 0 for ( i in [0, 1, 2, 3, 4] ) { x += i }
assert x == 10
// iterate over an array array = (0..4).toArray() x = 0 for ( i in array ) { x += i }
assert x == 10
// iterate over a map
map = [‘abc‘:1, ‘def‘:2, ‘xyz‘:3] x = 0 for ( e in map ) { x += e.value }
assert x == 6
// iterate over values in a map x = 0 for ( v in map.values() ) {
x += v }
assert x == 6
// iterate over the characters in a string text = "abc" list = [] for (c in text) { list.add© } assert list == ["a", "b", "c"]
运行Groovy脚本
你可以象使用Perl一样编写Groovy脚本，不需要class，不需要Main入口点，也不需要声明变量；此外，你还可以用def语句来定义自己的函数，并在脚本中使用它。
像许多脚本语言一样，Groovy 是 在运行时解释的，无编译的代码在构建-运行周期中可以提供很多好处。运行时编译使 Groovy 成为快速原型设计、构建不同的实用程序和测试框架的理想平台。通过以下代码可以很简单的运行Groovy.

groovy HelloWorld.groovy
除了利用解释器来运行Groovy脚本外，Groovy 提供了两种不同的解释器Shell，使所有有效的 Groovy 表达式可以交互地执行：
1. 运行groovysh启动命令Shell，可以输入Groovy语句直接执行
2. 运行groovyConsole启动Swing方式的Groovy控制台，这是一个简单的Groovy编辑器
Groovy 脚本实际上是字节码级别的 Java 类。因此，还可以用 groovyc 编译 Groovy 脚本。可以通过命令行或者 Ant 使用 groovyc 以生成脚本的类文件。这些类可以用普通 java 命令运行，只要 classpath 包括 groovy.jar和asm.jar。（wang_wang）
Groovy 前言
前言
Groovy 是基于 JRE 的脚本语言( Script )，和Perl，Python等等脚本语言一样，它能以快速简洁的方式来完成一些工作：如访问数据库，编写单元测试用例(Unit Test Case)，快速实现产品原型等等。
Groovy 是由James Strachan 和 Bob McWhirter 这两位天才发明的，（JSR 241 2004 年 3 月）。Groovy 完全以Java API为基础，使用了Java开发人员最熟悉的功能和库。Groovy 的语法近似Java，并吸收了 Ruby 的一些特点，因此 Groovy 在某些场合可以扮演一种 “咖啡伴侣”的角色。
那么Groovy 和 Java 相比，有什么变化呢？ Groovy 通过以下方式提供了一种敏捷的开发方式：
· 不用编译。
· 允许动态类型。
· 合成结构容易。 其脚本可以在普通 Java 应用程序中使用。
· 提供一个 shell 解析器。
这 些特性使Groovy 成为一种特别容易学习和使用的语言. 我们先借用IBM Groovy教程中的例子，下面的代码利用了Freemarker模板引擎来创建一个Template对象，然后将内容打印到标准输出。例(1)是 Java代码，例(2)是Groovy代码。可以看到二者非常的类似。
// 简单的 TemplateReader Java 类 import java.io.File; import java.io.IOException; import freemarker.template.Configuration; import freemarker.template.Template; public class TemplateReader {     public static void main(String[] args){         try{             Configuration cfg = Configuration.getDefaultConfiguration();            cfg.setDirectoryForTemplateLoading(new File("C:\\dev\\projects\\http-tester\\src\\conf"));            Template temp = cfg.getTemplate("vendor-request.tmpl");             System.out.println(temp.toString());        } catch(IOException e){            e.printStackTrace();        }     } }
和例2 中的 Groovy 作为对比.

//用 Groovy 编写的更简单的 TemplateReader //语法目前基于Groovy 1.0-JSR3 import freemarker.template.Configuration as tconf import java.io.File cfg = tconf.getDefaultConfiguration() cfg.setDirectoryForTemplateLoading( new File("C:\\dev\\projects\\http-tester\\src\\conf")) temp = cfg.getTemplate("vendor-request.tmpl") println temp.toString()

Groovy显然精简得多：

· Groovy 代码只需要更少的import 语句。此外，freemarker.template.Configuration 还使用了别名 tconf。

· Groovy 允许直接使用类型为Template 的变量 tmpl 而不用声明其类型。

· Groovy 不需要class 声明或者main 方法。

· Groovy 不关心异常，可以不用导入Java需要的IOException。

******************************************************

1.闭包
先解释一下闭包的概念：
闭包是很多动态语言提供的一个很方便的功能，它有点像Java中的内部类，
不同的是闭包中只有一个方法，但这个方法可以有任意个参数。
下面看一个闭包的最简单的例子：
def closure={ param -> println "hello ${param}" }  
closure.call("world!")

def是一个关键字，相当于JavaScript中的Var，用来定义一个对象。
closure为闭包的名字。在大括号里面，参数和处理参数的语句用->隔开。
param是这个闭包的参数，参数的数目是任意的，不同的参数之间用","隔开。
下面处理这些参数的语句就可以直接调用这些参数了。

所有的闭包都是继承自groovy.lang.Closure类，闭包也是一个普通的类，
只是在Groovy中，这个语法比较特别。所以闭包也可以当作一个返回值。
或者当作一个参数传入一个方法。

闭包的返回值：
调用闭包的call方法，会有一个返回值，可以调用return来指定，如果不指定的话，
则返回闭包中最后一条有返回值的语句。

闭包可以调用的对象：
在方法里面，可以调用方法内的局部变量
作为类变量，可以调用类变量

关于0个参数以及对象it：
参数可以是任意个，没有参数就不需要"->"了。没有参数的话，但是传入了一个参数，
这个参数可以通过一个无类型的对象"it"来访问。比如上面的例子我们可以这么写：

def closure2={ println "hello ${it}" }  
closure2.call("world!")

关于闭包的调用：
定义以后就可以调用这个闭包，有两种方式，
closure.call("world!")
closure("world!")
这两种是没有任何区别的，第二个是第一个的简写
2.集合的本地化语法
这个比闭包更容易理解，Groovy对collections, lists, maps, arrays的声明和使用
提供了语言级的支持，可以直接声明一个list和map，无需调用new方法创建一个List或者
map对象。

看一个来自Groovy官方网站的例子：
def list = [5, 6, 7, 8]
assert list.get(2) == 7
assert list[2] == 7
assert list instanceof java.util.List

def emptyList = []
assert emptyList.size() == 0
emptyList.add(5)
assert emptyList.size() == 1

与Java的区别如下:
1.通过[value...]的方式来声明
2.通过list[index]的方式来访问和赋值
3.通过[]来声明一个空的map

看一个Map的例子：
def map = [name:"Gromit", likes:"cheese", id:1234]
assert map.get("name") == "Gromit"
assert map.get("id") == 1234
assert map["name"] == "Gromit"
assert map['id'] == 1234
assert map instanceof java.util.Map

def emptyMap = [:]
assert emptyMap.size() == 0
emptyMap.put("foo", 5)
assert emptyMap.size() == 1
assert emptyMap.get("foo") == 5

与Java的区别如下：
1.通过[name:value...]的方式来声明
2.通过map[name]的方式来访问和赋值
3.通过map.name的方式来访问和赋值
4.通过[:]来声明一个空的map

Range的使用：
Range是Groovy新添的一个集合类，继承自java.util.List，所以可以像使用List一样使用。
下面是关于Range的一个例子：
def range = 5..8
assert range.size() == 4
assert range.get(2) == 7
assert range[2] == 7
assert range instanceof java.util.List
assert range.contains(5)
assert range.contains(8)

range = 5..<8
assert range.size() == 3
assert range.get(2) == 7
assert range[2] == 7
assert range instanceof java.util.List
assert range.contains(5)
assert ! range.contains(8)

几个说明
1.Range的类型可以是int、char
2.通过min..max来声明
3.可以像其他集合一样使用

'*.'操作符号的使用：
可以用来使集合中的所有元素都调用同一个方法，返回一个同等size的List
List list = ["Rod", "Phil", "James", "Chris"]
println list*.size()

String的特殊使用：
String在Groovy中可以像char数组一样的使用，下面是一个例子：
def text = "nice cheese gromit!"
def x = text[2]

assert x == "c"
assert x.class == String

def sub = text[5..10]
assert sub == 'cheese'

说明：
1.通过text[index]的方式返回在index处的字符，不过返回的是string类型的，非char类型
2.通过text[min..max]方式来返回子字符串，包含max处的字符，String的subString不包含。
3.从这个例子中可以看到，可以使用'string'来表示String，不一定是"string"
Groovy 4 集合
将对象组织到像列表和映射这样的数据结构中是一项基本的编码任务。像大多数语言一样，Groovy 定义了一个丰富的库以管理这些类型的集合。
列表
创建一个列表与在 Java 语言中创建一个数组很类似。
collect = ['groovy', 29, 'Hello', 'Groovy']
empty=[]
assert empty.size() == 0
//添加元素
empty.add 1
assert empty.size() == 2
在上面的例子里，列表 collect 的第二项自动装箱为一个 Integer 类型。此外“[]”表示一个空列表,这个例子还演示了如何向列表中添加元素。
Groovy 还为集合增加了几个新方法，这些方法使得对列表的一些操作变得更加容易，如统计值出现的次数、将整个列表结合到一起、对列表排序等等。可以在例2 中看到这些集合方法的使用。
collect = [5, 9, 2, 2, 4, 5, 6]
println collect.join(' - ') // prints 5 - 9 - 2 - 2 - 4 - 5 - 6
println collect.count(2) // prints 2
println collect.sort() // prints [2, 2, 4, 5, 5, 6, 9]
Maps
像列表一样，映射也是一种在 Groovy 中非常容易处理的数据结构。例 3 中的映射包含两个对象，键是 name 和 date。注意可以用不同的方式取得值。 可以用“[:]”创造一个空的映射。
myMap = ["name" : "Groovy", "date" : new Date()]
println myMap["date"]
println myMap.date
Map可以象beans一样操作，但key值（类似属性名）必须为有效的String标识。下面的例子详细演示了Map的用法。
map = ["name":"Gromit", "likes":"cheese", "id":1234]
assert map.name == "Gromit"
assert map.id == 1234
//Create an empty maps
emptyMap = [:]
assert emptyMap.size() == 0
emptyMap.foo = 5
assert emptyMap.size() == 1
assert emptyMap.foo == 5
emptyMap.put("bar",6)
assert emptyMap.get("bar") == 6
players = ['baseball':'Albert Pujols', 'golf':'Tiger Woods']
println players['golf'] // prints Tiger Woods
println players.golf // prints Tiger Woods
for (player in players)
{
println "${player.value} plays ${player.key}"
}
// This has the same result as the previous loop.
players.each {
player |println "${player.value} plays ${player.key}"
}
范围
范围（Range）是Groovy的一大亮点Range允许创建连续值的列表。范围是一个很直观的概念，并且容易理解，利用它可以包含地或者排除地创建一 组有序值。使用“..”的Range是包括两个边界，使用“..<”（Groovy Beta3使用 “...”)的Range只包括开始边界，而不包括结束边界。
而且由于Range扩展java.util.List，所以Range可以作为List使用。
myRange = 29..<32
myInclusiveRange = 2..5
println myRange.size() // prints 3
println myRange[0] // prints 29
println myRange.contains(32) //prints false
println myInclusiveRange.contains(5) //prints true
// an inclusive range and operations
range = 'a'..'d'
assert range.size() == 4
assert range.get(2) == 'c'
assert range instanceof java.util.List
assert range.contains('a')
assert range.contains('d')
assert ! range.contains('e')
迭代器
迭代是各种编程环境中最常见、最有用的技术。迭代器可以让您迅速地访问任何集合或容器中的数据，每次一个数据。Groovy 把迭代器变成隐含的，使用起来更简单，从而改善了 Java 语言的迭代器概念。
我们可以直接在集合上使用类似迭代器的方法。而且， Groovy 的迭代器方法接受闭包，每个迭代中都会调用闭包。
class IteratorExample1{
static void main(args) {
coll = ["JMS", "EJB", "JMX"]
coll.each{ item | println item }
}
}
范围可以用于循环遍历。例如，将 rang 定义为一个排除范围，循环打印 a、b、c 和 d。
aRange = 'a'..<'e'
for (i in aRange){
println i
}
集合的其他功能
如果不熟悉 Python 和其他脚本语言，那么您在 Groovy 集合中发现的一些其他功能会让您印象深刻。例如，创建了集合后，可以用负数在列表中反向计数：
aList = ['python', 'ruby', 'groovy']
println aList[-1] // prints groovy
println aList[-3] // prints python
Groovy 还让您可以用范围分割列表。分割可获得列表的准确子集：
fullName = "Andrew James Glover"
mName = fullName[7..<13]
println "middle name: " + mName // prints James
Ruby的语法
集合类似于 Ruby如果愿意的话，还可以将 Groovy 集合作为 Ruby 集合。可以用类似 Ruby 的语法，以 << 语法附加元素、用 + 串接和用 - 对集合取差，甚至还可以用 * 语法处理集合的重复。 注意，还可以用 == 比较集合。
collec = [1, 2, 3, 4, 5]
collec << 6 //appended 6 to collec
acol = ['a','b','c'] * 3 //acol now has 9 elements
coll = [10, 11]
coll2 = [12, 13]
coll3 = coll + coll2 //10,11,12,13
difCol = [1,2,3] - [1,2] //difCol is 3
assert [1, 2, 3] == [1, 2, 3] //true
集合的索引
可以在字符串、Lists、Maps...中使用下标进行索引
text = "nice cheese gromit!"
x = text[2]
assert x == "c"
assert x.class == String
sub = text[5..10]
assert sub == 'cheese'
map = ["name":"Gromit", "likes":"cheese", "id":1234]
assert map['name'] == "Gromit"
list = [10, 11, 12]
answer = list[2]
assert answer == 12
list = 100..200
sub = list[1, 3, 20..25, 33]
assert sub == [101, 103, 120, 121, 122, 123, 124, 125, 133]
可以使用下标操作符更新项目：
list = ["a", "b", "c"]
list[2] = "d"
list[0] = list[1]
list[3] = 5
assert list == ["b", "b", "d", 5]
可以使用负索引从最后开始计数：
text = "nice cheese gromit!"
x = text[-1]
assert x == "!"
name = text[-7..-2]
assert name == "gromit"
也可以使用向后范围（开始索引大于结束索引），返回的结果是反转的
text = "nice cheese gromit!"
name = text[3..1]
assert name == "eci"

Groovy 5 JDBC编程
与Groovy的脚本特性相适应，Groovy JDBC 包含了一个精巧简单的GroovySql API，由于使用闭包和迭代器，GroovySql 把 JDBC 的资源管理职责从开发人员转移到 Groovy 框架内，从而消除了 JDBC 编程的繁琐，使得变成人员可以把注意力放在处理查询结果上。
GroovySql 简介
在 Java 中，我们是这样利用JDBC来打印Music CD的样品：
package cc.ejb.groovy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class CdList {
public static void main(String[] args) {
Connection con = null;
Statement stmt = null;
ResultSet rs = null;
try{
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection("jdbc:mysql://localhost:3306/samples","root", "");
stmt = con.createStatement();
rs = stmt.executeQuery("select * from cdbean");
while (rs.next()) {
System.out.println("id:" + rs.getLong(1) + " artist:" + rs.getString(2) + " type:" + rs.getString(3));
}
}catch(SQLException e){
e.printStackTrace();
}catch(ClassNotFoundException e){
e.printStackTrace();
}finally{
try{
rs.close();
}catch(Exception e){}
try{
stmt.close();
}catch(Exception e){}
try{
con.close(