2004 年 8 月 03 日

虽然 Java 语言因其严密性和扩展性的承诺而在整整一代程序员中胜出，但是 Groovy 预示了 Java 平台上的一个编程新时代，这种语言是以方便性、适宜性和敏捷性为出发点定义的。在新的 alt.lang.jre专栏的第二期文章中，Andrew Glover 对提议添加到 Java 平台的标准编程语言作了非正式的介绍。

如果您在使用 Java 平台（block），不管时间长短，您都有可能听说过 Groovy。Groovy 是超级明星开发人员 James Strachan 和 Bob McWhirter 发明的，它是一种敏捷开发语言，完全以 Java 编程 API 为基础。Groovy 当前正处于 Java Specification Request 的开始阶段，它于 2004 年 3 月底获得批准。Groovy 还是一种脚本语言，有些人说它会永久性地改变您看待和使用 Java 平台的方式。

在其对 JSR 241 （请参阅 参考资料）的开放评论中，Groovy 的共同规范领导者 Richard Monson-Haefel 说他对 Groovy 的支持是建立在总有一天 Java 平台要包括一种敏捷开发语言这一信念上。与许多移植到 Java 平台的脚本语言不同，Groovy 是 为JRE 而写的。在规范请求中（参阅 参考资料），Groovy 的制造者提出了“Java 不仅是一种编程语言，更是一个健壮的平台，可以有多种语言在上面运行和共存”（Monson-Haefel 语）的思想。

新 alt.lang.jre专栏的这第二期文章的目的是让读者了解 Groovy。我首先回答关于这种新语言的一些最显然的问题（为什么需要它？），然后以代码为基础概述 Groovy 最令人兴奋的功能。

为什么需要另一种语言？

正如在 上个月的专栏中 介绍的，Groovy 不是与 JRE 兼容的惟一脚本语言。Python、Ruby 和 Smalltalk 就是成功地移植到 Java 平台上的三种脚本语言。对于一些开发人员，这带来了问题：为什么要另一种语言？毕竟，我们许多人已经将 Java 代码与 Jython 或者 JRuby 结合来快速开发应用程序，为什么还要学习另一种语言？回答是 您不一定要学习一种新语言以用 Groovy 编码。Groovy 与其他 JRE 兼容脚本语言的不同在于它的语法以及重用 Java 库。Jython 和 JRuby 共享它们前身（分别是 Python 和 Ruby）的外观，Groovy 让人觉得就像是 Java 语言，不过限制要少得多。

关于本系列 虽 然本系列的大多数读者熟悉 Java 语言以及它是如何在跨平台虚拟机上运行的，但是只有少数人知道 Java Runtime Environment 可以承载 Java 语言之外的语言。本系列文章对 JRE 的多种替代语言进行了综述。这里讨论的大多数语言是开放源代码的，许多是免费使用的，有少数是商业产品，必须购买。在 alt.lang.jre系列中介绍的所有语言都得到了 JRE 支持，并且作者相信它们增强了 Java 平台的动态性和灵活性特征。

像 Jython 这样的语言是在它们的父语言库上建立的，而 Groovy 使用了 Java 开发人员最熟悉的功能和库 —— 但是将它们放到了一个敏捷开发框架中。敏捷开发的基本宗旨是代码应该很好地适合范围广泛的任务，并可以不同的方式应用。Groovy 通过以下方式落实了这些宗旨：

• 使开发人员不用编译。
• 允许动态类型。
• 使合成结构容易。
• 使其脚本可以在普通 Java 应用程序中使用。
• 提供一个 shell 解析器。

这些特性使 Groovy 成为一种特别容易学习和使用的语言，不管您是有经验的 Java 开发人员还是刚接触 Java 平台。在下面几节中，我将详细讨论上述特性。

回页首

看呀，没有 javac！

像许多脚本语言一样，Groovy 不用为运行时编译。这意味着 Groovy 脚本是 在它们运行时解 释的，就像 JavaScript 是在观看 Web 页时由浏览器解释的一样。运行时判断会有执行速度的代价，这有可能使脚本语言不能用于对性能有要求的项目，但是无编译的代码在构建-运行周期中可以提供很 多好处。运行时编译使 Groovy 成为快速原型设计、构建不同的实用程序和测试框架的理想平台。

脚本的能力 脚 本语言很流行，因为它们容易学习并且为开发人员设置的限制较少。脚本语言通常使用简单的、相当简洁的语法，这使开发人员可以用比大多数编程语言所需要的更 少的代码创建真实世界的应用程序。像 Perl、Python、Ruby 和现在的 Groovy，用其敏捷方式编写代码而使编程工作达到一个新的效率水平。这种提高的敏捷性通常会使开发人员的效率提高。脚本语言的成功表明脚本不是一种小 范围内使用的技术或者黑客的娱乐工具，而是一种由像 Google、Yahoo 和 IBM 这样的世界级公司所使用的切实可行的技术。

例如，运行脚本 Emailer.groovyin Groovy 就是在命令行键入 groovy Emailer.groovy 这么容易。如果希望运行同样的 Java 文件（Emailer.java），显然必须键入额外的命令： javac Emailer.java ，然后是 java Emailer 。虽然这看起来可能有些微不足道，但是可以容易设想运行时编译在应用程序开发的更大上下文中的好处。

可以在稍后看到，Groovy 还允许脚本放弃 main 方法以静态地运行一个关联的应用程序。

动态 dynamo

像其他主流脚本语言一样，Groovy 不需要像 C++ 和 Java 语言这样的正式语言的显式类型。在 Groovy 中，一个对象的类型是在运行时动态发现的，这极大地减少了要编写的代码数量。首先可以通过分析清单 1 和 2 中的简单例子看到这一点。

清单 1 显示了在 Java 语言中如何将一个本地变量声明为 String 。注意必须声明类型、名和值。

												
														
String myStr = "Hello World";

										

在清单 2 中，您看到同样的声明，但是不需要声明变量类型。

												
														
myStr = "Hello World"

										

您可能还注意到了，在清单 2 中我可以去掉声明中的分号。在定义方法及其相关的参数时动态类型有戏剧性的后果：多态具有了全新的意义！事实上，使用动态类型， 不使用继承就可以得到多态的全部能力。在清单 3 中，可以真正开始看到动态类型在 Groovy 的灵活性方面所起的作用。

												
														
class Song{
  length
  name
}

class Book{
  name
  author
}

def doSomething(thing){
  println "going to do something with a thing named = " + thing.name
}

										

这里，我定义了两个 Groovy 类， Song 和 Book ，我将在后面对它们进一步讨论。这两个类都包含一个 name 属性。我还定义了一个函数 doSomething ，它以一个 thing 为参数，并试图打印这个对象的 name 属性。

因为 doSomething 函数没有定义其输入参数的类型，只要对象包含一个 name 属性，那么它就可以工作。因此，在清单 4 中，可以看到在使用 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

anotherSomething = doSomething

anotherSomething(myBook) //prints One Duck Stuck

										

除了展示 Groovy 中的动态类型，清单 4 的最后两行还揭示了创建对一个函数的引用有多容易。这是因为在 Groovy 中 所有东西都是对象，包括函数。

关于 Groovy 的动态类型声明最后要注意的是，它会导致更少的 import 语句。尽管 Groovy 需要 import 以显式使用类型，但是这些 import 可以使用别名以提供更短的名字。

动态类型综述

下面两个例子将到目前为止讨论过的 Groovy 中的动态类型的内容放到一起。下面的 Java 代码组和 Groovy 代码组利用了 Freemarker（参阅 参考资料），这是一个开放源代码模板引擎。这两组代码都只是简单地用一个目录和文件名创建一个 Template 对象，然后将相应对象的内容打印到标准输出，当然，不同之处是每一组代码处理这项任务所需要的代码量。

												
														
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();
      }
  }
}

										

初看之下，清单 5 中的 Java 代码相当简单 —— 特别是如果以前从来没见过脚本代码时。幸运的是，有清单 6 中的 Groovy 作为对比。现在这段代码很简单！

												
														
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 代码只有 Java 代码的一半那么长，下面是原因：

• Groovy 代码只需要一半的 import 语句。还要注意， freemarker.template.Configuration 使用了别名 tconf ，使得语法更短。
  
  
• Groovy 允许类型为 Template 的变量 tmpl 不声明其类型。
  
  
• Groovy 不需要 class 声明或者 main 方法。
  
  
• Groovy 不关心任何相应异常，使您可以不用导入 Java 代码中需要的 IOException 。

现在，在继续之前，想一下您所编写的最后一个 Java 类。您可能不得不编写很多 import 并声明类型，并在后面加上同样数量的分号。考虑用 Groovy 编写同样的代码会是什么情况。可以使用简练得多的语法，不需要遵守这么多的规则，并且得到完全相同的行为。

想一下，如果您正好是刚刚开始……

特别灵活的语法

谈 到语法，灵活性是更有效地开发代码的主要因素。很像其有影响的对手（Python、Ruby 和 Smalltalk），Groovy 极大地简化了核心库的使用和它所模拟的语言（在这里是 Java 语言）的构造。为了让您对 Groovy 语法的灵活性有一个大体概念，我将展示它的一些主要结构，即类、函数（通过 def 关键词）、闭包、集合、范围、映射和迭代器。

类

在字节码水平，Groovy 类是真正的 Java 类。不同之处在于 Groovy 将类中定义的所有内容都默认为 public ，除非定义了特定的访问修饰符。而且，动态类型应用到字段和方法，不需要 return 语句。

在清单 7 中可以看到 Groovy 中类定义的例子，其中类 Dog 有一个 getFullName 方法，它实际上返回一个表示 Dog 的全名的 String 。并且所有方法都隐式地为 public 。

												
														
class Dog{
  name

  bark(){
    println "RUFF! RUFF!"
  }

  getFullName(master){
    name + " " + master.lname
  }

  obeyMaster(){
    println "I hear you and will not obey."
  }
}

										

在清单 8 中，推广到有两个属性 —— fname 和 lname —— 的类 DogOwner ，就是这么简单！

												
														
class DogOwner{
  fname
  lname

  trainPet(pet){
    pet.obeyMaster()
  }

}

										

在清单 9 中，用 Groovy 设置属性并对 Dog 和 DogOwner 实例调用方法。现在很明显，使用 Groovy 类比 Java 类要容易得多。虽然需要 new 关键词，但是类型是可选的，且设置属性（它隐式为 public）是相当轻松的。

												
														

														
myDog = new Dog()
myDog.name = "Mollie"

myDog.bark()
myDog.obeyMaster() 

me = new DogOwner()
me.fname = "Ralf"
me.lname = "Waldo"

me.trainPet(myDog)

str = myDog.getFullName(me)
println str  // prints Mollie Waldo


										

注意在 Dog 类中定义的 getFullName 方法返回一个 String 对象，在这里它是 “ Mollie Waldo ”。

第一类对象 第一类对象 是可以在运行时用数据创建并使用的对象。第一类对象还可以传递给函数和由函数输出、作为变量存储、由其他对象返回。Java 语言自带的基本数据类型，如 int 和 boolean ，不认为是第一类对象。许多面向对象纯粹论者哀叹这个小细节，一些人据此提出 Java 语言是否是真正的面向对象语言。Groovy 通过将所有内容声明为对象而解决了这一问题。

Def

除了像许多脚本语言那样将所有对象指定为第一类对象（见侧栏），Groovy 还让您创建 第一类函数，它本身实质上就是对象。它们是用 def 关键词定义的并在类定义之外。您实际上在 清单 3 中已经看到了如何用 def 关键词定义第一类函数，并在 清单 4中看到使用了一个函数。Groovy 的第一类函数定义简单脚本时特别有用。

闭包

Groovy 中最令人兴奋和最强大的功能是支持闭包。 闭包（Closure）是 第一类对象，它类似于 Java 语言中的匿名内部类。闭包和匿名内部类都是可执行的一段代码，不过这两者之间有一些细微的不同。状态是自动传入传出闭包的。闭包可以有名字。它们可以重复 使用。而且，最重要且对 Groovy 同样成立的是，闭包远比匿名内部类要灵活得多！

清单 10 展示了闭包的强大。清单中新的和改进的 Dog 类包括一个 train 方法，它实际上执行创建了 Dog 实例的闭包。

												
														
class Dog{  
  action

  train(){
    action.call()
  }
}

sit = { println "Sit, Sit! Sit! Good dog"}
down = { println "Down! DOWN!" }


myDog = new Dog(action:sit)
myDog.train()  // prints Sit, Sit! Sit! Good dog

mollie = new Dog(action:down)
mollie.train() // prints Down! DOWN!

										

而且，闭包还可以接收参数。如清单 11 所示， postRequest 闭包接收两个参数（ location 和 xml ），并使用 Jakarta Commons HttpClient 库（参阅 参考资料）将一个 XML 文档发送给指定位置。然后这个闭包返回一个表示响应的 String 。闭包定义下面是一个使用闭包的例子。事实上，调用闭包就像调用函数一样。

												
														
import org.apache.commons.httpclient.HttpClient
import org.apache.commons.httpclient.methods.PostMethod

postRequest = { location, xml |

  clint = new HttpClient()
  mthd = new PostMethod(location)  	
  mthd.setRequestBody(xml)
  mthd.setRequestContentLength(xml.length())
  mthd.setRequestHeader("Content-type", 
     "text/xml; charset=ISO-8859-1")

  statusCode = clint.executeMethod(mthd)
  responseBody = mthd.getResponseBody()
  mthd.releaseConnection()	
  return new String(responseBody)	  
}

loc = "http://localhost:8080/simulator/AcceptServlet/"
vxml = "<test><data>blah blah blah</data></test>"

str = postRequest(loc, vxml)
println str

										

自动装箱 自动装箱或者装箱转换是一个自动将像 int 、 double 和 boolean 这样的基本数据类型自动转换为可以在 java.lang 包中找到的它们的相应包装类型的过程。这一功能出现在 J2SE 1.5 中，使开发人员不必在源代码中手工编写转换代码。

集合

将对象组织到像列表和映射这样的数据结构中是一项基本的编码任务，是我们大多数人每天要做的工作。像大多数语言一样，Groovy 定义了一个丰富的库以管理这些类型的集合。如果曾经涉足 Python 或者 Ruby，那么应该熟悉 Groovy 的集合语法。如清单 12 所示，创建一个列表与在 Java 语言中创建一个数组很类似。（注意，列表的第二项自动装箱为一个 Integer 类型。)

												
														
collect = ['groovy', 29, 'here', 'groovy']

										

除了使列表更容易处理，Groovy 还为集合增加了几个新方法。这些方法使得，如 统计 值出现的次数、将整个列表 结合 到一起、对列表 排序 变得非常容易。可以在清单 13 中看到这些集合方法的使用。

												
														
aCollect = [5, 9, 2, 2, 4, 5, 6] 

println aCollect.join(' - ')  // prints 5 - 9 - 2 - 2 - 4 - 5 - 6
println aCollect.count(2)     // prints 2
println aCollect.sort()       // prints [2, 2, 4, 5, 5, 6, 9]

										

Maps

像列表一样，映射也是一种在 Groovy 中非常容易处理的数据结构。清单 14 中的映射包含两个对象，键是 name 和 date 。注意可以用不同的方式取得值。

												
														
myMap = ["name" : "Groovy", "date" : new Date()]

println myMap["date"]

println myMap.date

										

范围

在处理集合时，很可能会大量使用 范围（Range） 。 范围 实际上是一个很直观的概念，并且容易理解，利用它可以包含地或者排除地创建一组有序值。使用两个点 （ .. ） 声明一个包含范围，用三个点 （ ... ） 声明一个排除范围，如清单 15 所示。

												
														
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

										

用范围实现循环

在循环结构中，范围可以实现相当巧妙的想法。在清单 16 中，将 aRange 定义为一个排除范围，循环打印 a、b、c 和 d。

												
														
aRange = 'a'...'e'

for (i in aRange){
  println i
}

										

集合的其他功能

如果不熟悉 Python 和其他脚本语言，那么您在 Groovy 集合中发现的一些其他功能会让您印象深刻。例如，创建了集合后，可以用负数在列表中反向计数，如清单 17 所示。

												
														
aList = ['python', 'ruby', 'groovy']

println aList[-1] // prints groovy
println aList[-3] // prints python

										

Groovy 还让您可以用范围分割列表。分割可获得列表的准确子集，如清单 18 所示。

												
														
fullName = "Andrew James Glover"

mName = fullName[7...13]

print "middle name: " + mName // prints James

										

集合类似于 Ruby

如果愿意的话，还可以将 Groovy 集合作为 Ruby 集合。可以用类似 Ruby 的语法，以 << 语法附加元素、用 + 串接和用 - 对集合取差，甚至还可以用 * 语法处理集合的重复，如清单 19 所示。 注意，还可以用 == 比较集合。

												
														
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

										

迭代器

在 Groovy 中，迭代任何序列都相当容易。迭代字符序列所需要的就是一个简单的 for 循环，如清单 20 所示。（正如您现在可能注意到的，Groovy 提供了比 Java 1.5 以前的传统语法更自然的 for 循环语法。）

												
														
str = "uncle man, uncle man"

for (ch in str){
  println ch
}

										

Groovy 中的大多数对象具有像 each 和 find 这样的以闭包为参数的方法。用闭包来迭代对象会产生几种令人兴奋的可能性，如清单 21 所示。

												
														
[1, 2, 3].each {  
  val = it 
  val += val
  println val
}

[2, 4, 6, 8, 3].find { x |
     if (x == 3){
       println x
     }
}

										

在清单 21 中，方法 each 作为迭代器。在这里，闭包添加元素的值，完成时 val 的值为 6。 find 方法也是相当简单的。每一次迭代传递进元素。在这里，只是测试值是否为 3。

Groovy 的高级内容

到目前为止，我着重讲述的都是使用 Groovy 的基本方面，但是这种语言有比基本内容多得多的内容！我将以分析 Groovy 提供的一些高级开发功能作为结束，包括 Groovy 样式的 JavaBeans 组件、文件 IO、正则表达式和用 groovyc 编译。

GroovyBean！

永 远不变的是，应用程序最后要使用类似 struct 的对象表示真实世界的实体。在 Java 平台上，称这些对象为 JavaBean 组件，它们通常用于表示订单、客户、资源等的业务对象。Groovy 由于其方便的简写语法，以及在定义了所需 bean 的属性后自动提供构造函数，而简化了 JavaBean 组件的编写。结果自然就是极大地减少了代码，正如您可以自己从清单 22 和 23 中看到的。

在清单 22 中，可看到一个简单的 JavaBean 组件，它是用 Java 语言定义的。

												
														
public class LavaLamp {
  private Long model;
  private String baseColor;
  private String liquidColor;
  private String lavaColor;

  public String getBaseColor() {
    return baseColor;
  }

  public void setBaseColor(String baseColor) {
    this.baseColor = baseColor;
  }

  public String getLavaColor() {
    return lavaColor;
  }

  public void setLavaColor(String lavaColor) {
    this.lavaColor = lavaColor;
  }

  public String getLiquidColor() {
    return liquidColor;
  }

  public void setLiquidColor(String liquidColor) {
    this.liquidColor = liquidColor;
  }

  public Long getModel() {
    return model;
  }

  public void setModel(Long model) {
    this.model = model;
  }
}

										

在清单 23 中，可以看到用 Groovy 写这个 bean 时所发生的事。所要做的就是定义属性，Groovy 会自动给您一个很好的构造函数以供使用。Groovy 还使您在操纵 LavaLamp 的实例时有相当大的灵活性。例如，我们可以使用 Groovy 的简写语法 或者传统的冗长的 Java 语言语法操纵 bean 的属性。

												
														
class LavaLamp{
  model
  baseColor
  liquidColor
  lavaColor
}

llamp = new LavaLamp(model:1341, baseColor:"Black", 
  liquidColor:"Clear", lavaColor:"Green")

println llamp.baseColor
println "Lava Lamp model ${llamp.model}"

myLamp = new LavaLamp()
myLamp.baseColor = "Silver"
myLamp.setLavaColor("Red")

println "My Lamp has a ${myLamp.baseColor} base"
println "My Lava is " + myLamp.getLavaColor()

										

轻松的 IO

Groovy IO 操作很轻松，特别是与迭代器和闭包结合时。Groovy 使用标准 Java 对象如 File 、 Reader 和 Writer ，并用接收闭包作参数的额外方法增强了它们。如在清单 24 中，可以看到传统的 java.io.File ，但是带有额外的、方便的 eachLine 方法。

												
														
import java.io.File

new File("File-IO-Example.txt").eachLine{ line |
 println "read the following line -> " + line
}

										

因为文件实质上是一系列行、字符等，所以可以相当简单地迭代它们。 eachLine 方法接收一个闭包并迭代文件的每一行，在这里是 File-IO-Example.txt 。 以这种方式使用闭包是相当强大的，因为 Groovy 保证所有文件资源都是关闭的，不考虑任何异常。这意味着无需大量 try / catch / finally 子句就可以进行文件 IO！

高级编译

Groovy 脚本实际上是字节码级别的 Java 类。因此，可以容易地用 groovyc 编译 Groovy 脚本。可以通过命令行或者 Ant 使用 groovyc 以生成脚本的类文件。这些类可以用普通 java 命令运行，只要 classpath 包括 groovy.jar 和 asm.jar ，这是 ObjectWeb 的字节码操纵框架。要了解更多编译 Groovy 的内容，请参阅 参考资料。

最大 RegEx

如果一种语言没有正则表达式处理，则它是没价值的。Groovy 使用 Java 平台的 java.util.regex 库 —— 但是做了少量基本的改变。例如，Groovy 使您可以用 ~ 表达式创建 Pattern 对象，用 =~ 表达式创建 Matcher 对象，如清单 25 所示。

												
														
str =  "Water, water, every where,
        And all the boards did shrink;
        Water, water, every where,
        Nor any drop to drink."

if (str =~ 'water'){
  println 'found a match'
}

ptrn = ~"every where"

nStr = (str =~ 'every where').replaceAll('nowhere')

println nStr

										

您可能已经注意到了，可以在上述清单中定义 String 、 str ，而无需为每一新行添加结束引号和 + 。这是因为 Groovy 放松了要求字符串串接的普通 Java 约束。运行这段 Groovy 脚本会对匹配 water 的情况打印出 true ，然后打印出一节诗，其中所有出现 “ every where ”的地方都替换为 “ nowhere ”。

关于 （band）shell Groovy 提供了两种不同的解释器，使所有有效的 Groovy 表达式可以交互地执行。这些 shell 是特别强大的机制，可以用它们迅速学习 Groovy。

结束语

像 所有婴儿期的项目一样，Groovy 是正在发展的语言。习惯于使用 Ruby 和 Python （或者 Jython）的开发人员可能会怀念 mixins、脚本导入（尽管可以将所需要的可导入脚本编译为相应的 Java 类）和方法调用的命名参数等这些功能的方便性。 但是 Groovy 绝对是一种发展中的语言。随着其开发人员数量的增加，它很有可能结合这些功能及更多功能。

同时，Groovy 有很多优点。它很好地融合了 Ruby、Python 和 Smalltalk 的一些最有用的功能，同时保留了基于 Java 语言的核心语法。对于熟悉 Java 平台的开发人员，Groovy 提供了更简单的替代语言，且几乎不需要学习时间。对于刚接触 Java 平台的开发人员，它可以作为有更复杂语法和要求的 Java 语言的一个容易的入口点。

像在本系统讨论的其他语言一样，Groovy 不是要替代 Java 语言，而是作为它的另一种选择。与这里讨论的其他语言不一样，Groovy 遵循 Java 规范，这意味着它有可能与 Java 平台上的 Java 语言具有同等重要的作用。

在本月这一期 alt.lang.jre文章中，介绍了 Groovy 的基本框架和语法，以及它的一些高级编程功能。下个月将介绍在 Java 开发人员中最受欢迎的脚本语言： JRuby。

关于作者

		Andrew Glover 是 Stelligent Incorporated 公司的 President，该公司位于华盛顿特区大都会地区，公司的专业领域是自动测试框架的构造，自动测试框架可以降低软件 bug 数量，减少集成和测试的时间，提高整体的代码稳定性。他还是 Java Testing Patterns （Wiley，2004 年 9 月）的合著者。

2006 年 10 月 17 日

Groovy 简洁的语法将开发人员从那种需要进行代码编译但却无助于表达 什么 是程序真正想要实现的典型的 Java™ 结构中解放了出来。在实战 Groovy 系列的这一复兴篇中，Groovy 开发人员兼特约专栏作家 J. Scott Hickey 带您进行一系列对常规 Java 代码和 Groovy 代码的比较，展示这门令人兴奋的语言如何将您解放出来，让您能够专注于编码的重要方面。

通常，程序员们转而选择诸如 Groovy 之类的编程语言，是为了构建快速的实用程序，快速编写测试代码，甚至创建构成大型的 Java 应用程序的组件，而 Groovy 先天具有这样一种能力，它能够减少传统的基于 Java 系统所固有的许多冗余并降低其复杂度。Groovy 简洁而灵活的语法将开发人员从那种需要进行代码编译却无助于表达什么 是程序真正想要实现的典型的 Java 结构中解放出来。不仅如此，Groovy 轻松的类型通过减少一些接口和超类使代码不再复杂，这些接口和超类都是常规 Java 应用程序用以支持不同具体类型间的通用行为所需的。

为了举例说明 Groovy 如何减少 Java 应用程序所涉及的无用数据，我将使用 Bruce Tate 和 Justin Ghetland 的 Spring: A Developer's Notebook（参见 参考资料） 中的样例代码，该书介绍了如何使用 Spring 进行控制反转。每当回顾一个 Java 样例，我都会将其与实现相同功能的相应的 Groovy 源代码进行比较，您将很快发现 Groovy 通过减少 Java 编程的不同方面（冗余且不必要地传递了应用程序的行为）而使应用程序代码变得多么地清晰。

Groovy 之声

在 Bruce 和 Justin 这本书的第一章中，创建了一个简单的自行车商店应用程序，其中包含有四个类。首先，我将向您展示一个简单的名为 Bike 的 JavaBean 类，该类代表了一辆库存的自行车。然后，我会考查自行车商店的类型，名为 RentABike。它包含了一个 Bike 集。还有一个命名为 CommandLineView 的用于显示自行车列表的类，该类依赖于 RentABike 类型。最后，有一个用于集成这些部分以创建工作应用程序的类，该类利用 Spring 来传递完整地配置了 RentABike 类型的 CommandLineView 类 —— 免去了复杂的硬编码。

停用 JavaBean！

清单 1 中一个代表自行车的类在常规 Java 代码中被实现为一个简单的 JavaBean，它是 Java 开发人员可能已经编写好的成百上千的类的一个典型。通常来说，JavaBean 并没有什么特殊之处 —— 其属性被声明为 private，且可通过 public getter 和 setter 对其进行访问。

												
import java.math.BigDecimal;

public class Bike {
   private String manufacturer;
   private String model;
   private int frame;
   private String serialNo;
   private double weight;
   private String status;
   private BigDecimal cost;

   public Bike(String manufacturer, String model, int frame, 
     String serialNo, double weight, String status) {
      this.manufacturer = manufacturer;
      this.model = model;
      this.frame = frame;
      this.serialNo = serialNo;
      this.weight = weight;
      this.status = status;
   }

   public String toString() {
      return "com.springbook.Bike : " +
            "manufacturer -- " + manufacturer +
            "\n: model -- " + model +
            "\n: frame -- " + frame +
            "\n: serialNo -- " + serialNo +
            "\n: weight -- " + weight +
            "\n: status -- " + status +
            ".\n"; }

   public String getManufacturer() { return manufacturer; }

   public void setManufacturer(String manufacturer) {
      this.manufacturer = manufacturer;
   }

   public String getModel() { return model; }

   public void setModel(String model) { this.model = model; }

   public int getFrame() { return frame; }

   public void setFrame(int frame) { this.frame = frame; }

   public String getSerialNo() { return serialNo; }

   public void setSerialNo(String serialNo) { this.serialNo = serialNo; }

   public double getWeight() { return weight; }

   public void setWeight(double weight) { this.weight = weight; }

   public String getStatus() { return status; }

   public void setStatus(String status) { this.status = status; }

   public BigDecimal getCost() { return cost; }

   public void setCost(BigDecimal cost) {
     this.cost = cost.setScale(3,BigDecimal.ROUND_HALF_UP);
   }

}  

清单 1 是一个只有一个构造方法和六个属性的小例子，但其代码却填满了浏览器的整个页面！清单 2 显示了在 Groovy 中定义的相同的 JavaBean：

												
class Bike {

  String manufacturer
  String model
  Integer frame
  String serialNo
  Double weight
  String status
  BigDecimal cost

  public void setCost(BigDecimal newCost) {
    cost = newCost.setScale(3, BigDecimal.ROUND_HALF_UP)
  }


  public String toString() {
    return """Bike:
         manufacturer --  ${manufacturer} 
         model -- ${model}
         frame -- ${frame} 
         serialNo -- ${serialNo}  
      """
  }
}

您认为哪一个没那么多冗余呢？

Groovy 版的代码要少很多很多，这是因为 Groovy 的默认属性语义用 public 访问器和存取器自动定义了 private 域。例如，上述 model 属性现在有了自动定义的 getModel() 方法和 setModel() 方法。可以看到，这项技术的好处是，不必在一种类型中按照属性手工定义两个方法！这也解释了 Groovy 中的一条反复强调的定律：使普通的编码规则变得简单。

Groovy 更新了的属性语法 最新版的 Groovy, JSR-06 简化了 Groovy 的属性语法。在此版本之前，属性要在变量声明前跟一个特定的 @Property 符号。但这个符号现在已经不再需要。在 JSR-06 中，只需指定一个类型和一个变量名，就会自动生成一个有着 public getter 和 setter 的 private 属性。也可以使用 def 关键字来代替特定的类型。

另外，在 Groovy 中，类的默认函数表达得更为简洁，而在常规 Java 代码（如 清单 1）中该函数必须显式编码。当需要用构造函数或 getter 或 setter 来完成一些特殊任务时，Groovy 真的很出色，因为只需瞥一眼代码，其精彩的行为就会立即变得十分明显。例如，在 清单 2 中很容易看出，setCost() 方法会将 cost 属性换算为三个十进制的位。

将这段不太显眼的 Groovy 代码同 清单 1 中的 Java 源代码进行比较。第一次阅读这段代码时，您注意到 setCost() 方法中嵌入了特殊的函数了吗？除非仔细观察，否则太容易看漏了！

Groovy 测试

清单 3 中 Bike 类的测试用例展示了如何使用自动生成的访问器。同时，出于进一步简化通用编程任务的考虑，测试用例也使用了更为简便的 Groovy 点属性名 标记来访问属性。相应地，能够通过 getModel() 方法或更为简洁的 b.model 形式来引用 model 属性。

												
class BikeTest extends GroovyTestCase {
  void testBike() {
    // Groovy way to initialize a new object
    def b = new Bike(manufacturer:"Shimano", model:"Roadmaster")

    // explicitly call the default accessors
    assert b.getManufacturer() == "Shimano"
    assert b.getModel() == "Roadmaster"

    // Groovier way to invoke accessors
    assert b.model == "Roadmaster"
    assert b.manufacturer == "Shimano"
  }
}

也注意到在上述 Groovy 例子中，不必定义一个如 清单 1 中定义的 Java 构造函数那样的能够接受全部六个属性的构造函数。同时，也不必要创建另一个 只含两个参数的构造函数来支持测试用例 —— 在对象创建过程中设置对象属性的 Groovy 的语义不需要这种冗余、烦人的构造函数（它们综合有多个参数但其作用却只是初始化变量）。

Groovy 和 IDE 像 Eclipse 那样的 IDE 使得自动创建 getter 和 setter 变得十分简单。这些工具也便利了从具体类中提取接口以利于对其进行重构。但我敢说，读那段代码的次数要比写它的次数多很多。 不幸的是，开发人员仍需要通过已经生成的代码和源文件来费力地分辨程序真正在实现什么。用这个高质量的 Java 工具究竟能不能节省创建 Groovy 源代码的敲键次数尚有争议，但一看即明的是 Groovy 代码更为简洁、更易于解释，且没那么复杂。在实际的有着数百个类和数千行代码的应用程序，这种优势就更为突出。

降低的复杂性

在前面的部分中，Bike GroovyBean 利用了 Groovy 的属性和构造语义以减少源代码中的冗余。在这一部分中，Groovy 版的自行车商店也将受益于额外的冗余减少特性，如针对多态的 duck-typing、集合类的改进及操作符重载。

Grooving 中使用多态

在 Java 自行车应用程序中，名为 RentABike 的接口是用来定义由自行车商店支持的 public 方法的。正如在清单 4 中说明的那样，RentABike 定义了一些简单的方法，这些方法用来返回商店中单个的 Bike 或所有 Bike 的列表。

												
import java.util.List;

public interface RentABike {
   List getBikes();
   Bike getBike(String serialNo);
   void setStoreName(String name);
   String getStoreName();
}

此接口允许多态行为并在下面两种重要情况下提供了灵活性。其一，如果要决定将实现由 ArrayList 转变为数据库形式，余下的应用程序与该变化是隔绝的。其二，使用接口为单元测试提供灵活性。例如，如果要决定为应用程序使用数据库，可以轻易地创建一个该类型的模拟实现，而且它不依赖于实时数据库。

清单 5 是 RentABike 接口的 Java 实现，它使用 ArrayList 来存储多个 Bike 类：

												
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListRentABike implements RentABike {
   private String storeName;
   final List bikes = new ArrayList();

   public void setStoreName(String name) {
      this.storeName = name;
   }

   public String getStoreName() {
      return storeName;
   }

   public ArrayListRentABike(String storeName) {
      this.storeName = storeName;
      bikes.add(new Bike("Shimano", "Roadmaster", 20, "11111", 15, "Fair"));
      bikes.add(new Bike("Cannondale", "F2000 XTR", 18, "22222",12, "Excellent"));
      bikes.add(new Bike("Trek","6000", 19, "33333", 12.4,"Fair"));
   }

   public String toString() { return "com.springbook.RentABike: " + storeName; }

   public List getBikes() { return bikes; }

   public Bike getBike(String serialNo) {
      Iterator iter = bikes.iterator();
      while(iter.hasNext()) {
         Bike bike = (Bike)iter.next();
         if(serialNo.equals(bike.getSerialNo())) return bike;

      }
      return null;
   }
}

现在将 清单 4 和 5 中的 Java 代码同 清单 6 中的 Groovy 代码进行比较。Groovy 版的代码很灵巧地避免了对 RentABike 接口的需求。

												
public class ArrayListRentABike {
  String storeName
  List bikes = []
  public ArrayListRentABike(){		
    // add new instances of Bike using Groovy's initializer syntax
    bikes << new Bike(manufacturer:"Shimano", model:"Roadmaster",
      frame: 20, serialNo:"11111", weight:15,	status:"Fair")
    bikes << new Bike(manufacturer:"Cannondale", model:"F2000",
      frame: 18, serialNo:"22222", weight:12,	status:"Excellent")
    bikes << new Bike(manufacturer:"Trek", model:"6000",
      frame: 19, serialNo:"33333", weight:12.4,	status:"Fair")
  }

  // Groovy returns the last value if no return statement is specified
  public String toString() { "Store Name:=" + storeName }

  // Find a bike by the serial number
  def getBike(serialNo) { bikes.find{it.serialNo == serialNo} }

}

Groovy 像其他动态语言（如 Smalltalk 或 Ruby）一样支持具有 “duck typing” 的多态 —— 在运行时，如果一个对象表现得像个 duck ，它就会被视为 duck ，从而支持无 接口的多态。有了 Groovy ArrayListRentABike 实现，不但减少了成行的代码，而且由于少创建和维护一个模块，复杂性也降低了。那是非常重要的冗余减少！

除了 duck typing，清单 6 中的默认属性语法还简单地定义了两个普通属性，storeName 和 bikes，如同拥有了 getter 和 setter 一样。这样做的好处和在 清单 1 和 2 中比较 JavaBean-GroovyBean 时所说明的好处是一样的。尤其是，清单 6 还阐明了另一个用以减少代码冗余的 Groovy 特性 —— 操作符重载。请注意如何使用 << 操作符来代替add() 方法。通过减少一层嵌套的括号使代码的可读性得以改善。这也是 Groovy 众多通过减少冗余而改善代码可读性的特性中的一种。

Groovy 方式下的和谐集合 用诸如 each 和 find 的方法来使用闭包简化了最常见的任务集，如循环和查找。将 清单 5 中 Java 版本的 getBike() 同 清单 6 中 Groovy 版的进行比较。在 Groovy 中，很明显是通过其序列号来寻找 Bike。而在 Java 版中，定义了一个 Iterator 并计算列表中下一个条目，这很多余，且不利于理解该应用程序真正要实现的功能，即寻找一辆自行车。

透明的代码

Groovy 中的 duck-typing 和属性语义通过减少代码行数来减少冗余；然而，也可以通过增加透明度来减少冗余。在 清单 6 中，请注意在 ArrayListRentABike 构造函数中创建新 Bike 对象的方式。Groovy 名称和值的初始化语法比 Java 版的略微详细，但这些额外的代码却使整个代码更为透明 —— 将这一点与 清单 5 中 Java 版的进行比较，哪个属性被初始化为哪个值会立即明显 起来。不回过头来看 Bike JavaBean 源代码，您能记起哪个参数是 frame，哪个是 new Bike("Shimano"、 "Roadmaster"、20、 "11111"、15、 "Fair") 的 weight 吗？尽管我刚写过，但我还是记不起来！

一个更小的、更加 Groovy 化的自行车商店视图

到目前为止，我将 Bike 和自行车商店类型在 Java 和 Groovy 下进行了比较。现在，到了更近距离地看一下自行车商店的视图 的时候了。在清单 7 中，该视图类具有一个 rentaBike 属性，该属性引用 RentABike 接口并在行动上说明 Java 版的多态。由于 Java 要求所有类属性都必须是声明过的类型，而不是针对某个特定的实现进行编码，我向一个接口编程，该接口使这个类跟 RentABike 实现的改变分隔开来。这是很好的、扎实的 Java 编程实践。

												
public class CommandLineView {
   private RentABike rentaBike;

   public CommandLineView() {}

   public void setRentaBike(RentABike rentaBike) {
      this.rentaBike = rentaBike;
   }

   public RentABike getRentaBike() { return this.rentaBike; }

   public void printAllBikes() {
      System.out.println(rentaBike.toString());
      Iterator iter = rentaBike.getBikes().iterator();
      while(iter.hasNext()) {
         Bike bike = (Bike)iter.next();
         System.out.println(bike.toString());
      }
   }
}

将清单 7 中的 Java 视图与清单 8 中的 Groovy 视图进行比较，请注意我声明了带 def 关键字的 rentaBike。这是 duck-typing 的实践，与 Java 版的很像。我正在实践好的软件设计，这是因为我还没有将视图和特定的实现耦合起来。但我也能够不 定义接口就实现解耦。

												
public class CommandLineView {
  def rentaBike  // no interface or concrete type required, duck typing in action

  def printAllBikes() {
    println rentaBike
    rentaBike.bikes.each{ println it}  // no iterators or casting
  }
}

与 Bike 和自行车商店类型一样，Groovy 的 CommandLineView 没有了为 RentABike 属性所显式编写 的 getter 或 setter 的冗余。同样，在 printAllBikes() 方法中，通过使用 each 来打印在集合里找到的每辆自行车，我再一次利用了 Groovy 强大的集合功能的改进。

使用 Spring 进行组装

在前面的部分中，已经介绍了 Groovy 相比 Java 是如何定义自行车、自行车商店和自行车商店视图的。现在该介绍如何将整个应用程序组装起来并在命令行视图中使用 Spring 来显示库存自行车列表了。

工厂的工厂

在 Java 编程中，一旦定义了一个接口，就可以使用工厂模式将创建真实的实现类的责任委派给一个对象工厂。使用 Spring 作为一个工厂极大地减少了冗余，并在 Groovy 和 Java 中都能够使用，在最终的代码样例中，Spring 负责在 Java 和 Groovy 中创建一个 CommandLineView 类型的实例。

在清单 9 中，配置 Spring 是为了在返回一个 CommandLineView 实例前，创建并将自行车商店的 ArrayList 实现注入 CommandLineView 中。这意味着，不需要引用在 清单 7 和 8 的 Java 或是 Groovy 版的命令行视图中的 ArrayList 实现。在 Java 版中，被注入的类通常都会引用一个接口而不是实现。在 Groovy 中，由于使用 def 关键字，而允许利用 duck-typing。无论在哪个实例中，配置 Spring 的目的都是为了将自行车商店视图的实例和自行车商店类型的实例完整地配置起来！

												
<beans>
    <bean id="rentaBike" class="ArrayListRentABike">
        <property name="storeName"><value>"Bruce's Bikes (spring bean)"</value></property>
    </bean>
    <bean id="commandLineView" class="CommandLineView">
        <property name="rentaBike"><ref bean="rentaBike"/></property>
    </bean>
</beans>

在清单 10 和 11 中，自行车商店组装类型用清单 9 中的配置文件创建了一个 Spring 的 ClassPathXmlApplicationContext 实例，然后，请求自行车商店视图的实例：

												
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class RentABikeAssembler {
   public static final void main(String[] args) {
      // Create a Spring application context object
      ClassPathXmlApplicationContext ctx = 
        new ClassPathXmlApplicationContext("RentABike-context.xml");

      // retrieve an object from Spring and cast to a specific type
      CommandLineView clv = (CommandLineView)ctx.getBean("commandLineView");

      clv.printAllBikes();
   }
}

请注意Java 版的清单 10 中，用以请求一个命令行视图实例的对 Spring 的调用要求向一个支持 printAllBikes() 方法的对象类型强制转换。在本例中，由 Spring 导出的对象将被强制转换为 CommandLineView。

有了 Groovy 及其对 duck-typing 的支持，将不再需要强制转换。只需确保由 Spring 返回的类能够对合适的方法调用（printAllBikes()）作出响应。

												
import org.springframework.context.support.ClassPathXmlApplicationContext

class RentABikeAssembler {
  public static final void main(String[] args) {
    // Create a Spring application context object
    def ctx = new ClassPathXmlApplicationContext("RentABike-context.xml")

    //Ask Spring for an instance of CommandLineView, with a 
    //Bike store implementation set by Spring
    def clv = ctx.getBean("commandLineView")

    //duck typing again
    clv.printAllBikes()
  }
}

正如在清单 11 中看到的那样，在 Groovy 中，duck-typing 对减少冗余的贡献不仅体现在无需声明接口即可支持由 Spring 自动配置对象，其贡献还体现在简化了对完全配置的 bean 的使用（一旦它从 Spring 容器中返回）。

与 Groovy 相协调

至此，希望我已经阐明了 Groovy 的强大功能及其如何能如此深远地改变源代码的性质。与上述 Java 样例相比，Groovy 代码更简短也更易理解。任何人，无论是经验丰富的 Java 架构师还是非 Java 程序员，都能轻易地掌握 Groovy 代码的意图。Groovy 及其对动态类型的支持减少了要管理的文件。总之，使用 Groovy 减少了在典型的 Java 程序中所常见的大量冗余。这实在是福音啊！

2005 年 11 月 30 日

Java™ 取消了操作符重载，但是新兴的 Groovy 又使之浮出水面。在实战 Groovy 定期连载的“Groovy 每日应用”的最后一期中，请随着 Andrew Glover 介绍的三类可重载操作符，重新寻回自己多年来失去的东西。

许多以前使用 C++ 的开发人员会怀念操作符重载，例如 + 和 -。虽然它们很方便，但是被覆盖的操作符的多态实质会造成混淆，所以操作符重载在 Java 语言中被取消了。这个限制的好处是清晰：Java 开发人员不必猜想两个对象上的 + 是把它们加在一起还是把一个对象附加到另一个对象上。不好的地方则是丧失了一个有价值的简写形式。

现在，期望放任自由的 Groovy 把这个简写形式带回来！在 实战 Groovy 的这一期中，我将介绍 Groovy 对操作符即时多态（也称为操作符重载）的支持。正如 C++ 开发人员会告诉您的，这个东西既方便又有趣，虽然必须小心谨慎才能接近。

三类可重载操作符

我把 Groovy 的可重载操作符分成三个逻辑组： 比较操作符、算术类操作符和数组类操作符。这几组只涵盖了普通 Java 编程中可用操作符的一个子集。例如，像 & 和 ^ 这样的逻辑操作符目前在 Groovy 中不可用。

表 1 显示了 Groovy 中可用的三组可重载操作符：

比较操作符

比较操作符对应着 Java 语言中的 equals 和 compareTo 实现，通常用作集合中排序的快捷方式。表 2 显示了 Groovy 的两个比较操作符：

操作符 == 是 Java 语言中表示对象相等的简写形式，但是不代表对象引用的相等。换句话说，放在两个对象之间的 Groovy 的 == 意味着它们相同，因为它们的属性是相等的，虽然每个对象指向独立的引用。

根据 Javadoc，Java 语言的 compareTo() 方法返回负整数、0 或正整数，代表对象小于、等于或大于指定对象。因为这个方法能够返回三个值，所以 Groovy 用四个附加值扩充了 <=> 语法，如表 3 所示：

比较购物

还记得我最初在“感受 Groovy”一文中定义的磁盘友好的 LavaLamp 类么，它还在“实战 Groovy: Groovy 的腾飞”一文中充当迁移到新的 JSR 语法的示例，我要再次使用这个类来演示使用比较操作符的一些漂亮的技巧。

在清单 1 中，我通过实现普通 Java 的 equals() 方法（以及它的可恶伙伴 hashCode）增强了 LavaLamp 类。另外，我让 LavaLamp 实现了 Java 语言的 Comparable 接口并创建了 compareTo() 方法的实现：

package com.vanward.groovy
import org.apache.commons.lang.builder.CompareToBuilder
import org.apache.commons.lang.builder.EqualsBuilder
import org.apache.commons.lang.builder.HashCodeBuilder
import org.apache.commons.lang.builder.ToStringBuilder
class LavaLamp implements Comparable{
 @Property model
 @Property baseColor
 @Property liquidColor
 @Property lavaColor

  def String toString() {
    return new ToStringBuilder(this).
        append(this.model).
	    append(this.baseColor).
	    append(this.liquidColor).
	    append(this.lavaColor).
	    toString()
  } 

  def boolean equals(obj) {
      if (!(obj instanceof LavaLamp)) {
         return false
      }
      LavaLamp rhs = (LavaLamp) obj
         return new EqualsBuilder().
             append(this.model, rhs.model).
             append(this.baseColor, rhs.baseColor).
             append(this.liquidColor, rhs.liquidColor).
             append(this.lavaColor, rhs.lavaColor).  	    
             isEquals()
   }
   def int hashCode() {
      return new HashCodeBuilder(17, 37).  
           append(this.model).
           append(this.baseColor).
           append(this.liquidColor).          
           append(this.lavaColor).
           toHashCode()
   }
   def int compareTo(obj) {
      LavaLamp lmp = (LavaLamp)obj
         return new CompareToBuilder().
             append(lmp.model, this.model).          
             append(lmp.lavaColor, this.lavaColor).
             append(lmp.baseColor, this.baseColor).
             append(lmp.liquidColor, this.liquidColor).
             toComparison()
   }	
}

注：因为我是重用狂，所以我的这些实现严重依赖 Jakarta 的 Commons Lang 项目（甚至 toString() 方法也是如此！）如果您还在自己编写 equals() 方法，那么您可能想花一分钟来签出这个库。（请参阅 参考资料。）

在清单 2 中，可以看到我在清单 1 中设置的操作符重载的效果。我创建了五个 LavaLamp 实例（没错，我们在开 party！）并用 Groovy 的比较操作符来区分它们：

lamp1 = new LavaLamp(model:"1341", baseColor:"Black", 
         liquidColor:"Clear", lavaColor:"Red")
lamp2 = new LavaLamp(model:"1341", baseColor:"Blue", 
         liquidColor:"Clear", lavaColor:"Red")
lamp3 = new LavaLamp(model:"1341", baseColor:"Black", 
         liquidColor:"Clear", lavaColor:"Blue")
lamp4 = new LavaLamp(model:"1342", baseColor:"Blue", 
         liquidColor:"Clear", lavaColor:"DarkGreen")
lamp5 = new LavaLamp(model:"1342", baseColor:"Blue", 
         liquidColor:"Clear", lavaColor:"DarkGreen")

println lamp1 <=> lamp2  //  1
println lamp1 <=> lamp3  // -1
println lamp1 < lamp3    //  true
println lamp4 <=> lamp5  //  0
assert lamp4 == lamp5
assert lamp3 != lamp4

注意 lamp4 和 lamp5 是如何相同的，以及其他对象之间具有什么样的细微差异。因为 lamp1 的 baseColor 是 Black 而lamp2 的 baseColor 是 Blue，所以 <=> 返回 1（black 中的 a 比 blue 中的 u 靠前）。类似地，lamp3 的 lavaColor 是 Blue，而 lamp1 的是 Red。因为条件 lamp1 <=> lamp3 返回 -1，所以语句 lamp1 < lamp3 返回 true。llamp4 和 llamp5 是相等的，所以 <=> 返回 0。

而且，可以看到 == 也适用于对象相等。lamp4 和 lamp5 是同一对象。当然，我应当用 assert lamp4.equals(lamp5) 证实这一点，但是 == 更快捷！

我想要我的引用相等

现在，如果真的想测试对象引用相等该怎么办？显然，我不能用 ==，但是 Groovy 为这类事情提供了 is() 方法，如清单 3 所示：

lamp6 = new LavaLamp(model:"1344", baseColor:"Black", 
             liquidColor:"Clear", lavaColor:"Purple")
lamp7 = lamp6
assert lamp7.is(lamp6)

在清单 3 中可以看出，lamp6 和 lamp7 是相同的引用，所以 is 返回 true。

顺便说一句，如果感觉迷糊，不要惊讶：使用重载操作符差不多让 Groovy 语言退步了。但是我认为是有趣的。

算术类操作符

Groovy 支持以下算术类操作符的重载：

您可能已经注意到 Groovy 中的 + 操作符已经在几个不同的领域重载了，特别是在用于集合的时候。您是否想过，这怎么可能？或者至少想过对自己的类能否这么做？现在我们来看答案。

添加操作符

还记得“在 Java 应用程序中加一些 Groovy 进来”一文中的 Song 类么？我们来看看当我创建一个 JukeBox 对象来播放 Song 时，发生了什么。在清单 4 中，我将忽略实际播放 MP3 的细节，把重点放在从 JukeBox 添加和减去 Song 上：

package com.vanward.groovy
import com.vanward.groovy.Song
class JukeBox {

  def songs  
  JukeBox(){   
    songs = []      
  }
  def plus(song){
    this.songs << song
  }
  def minus(song){    
    def val = this.songs.lastIndexOf(song)
    this.songs.remove(val)
  }

  def printPlayList(){
     songs.each{ song -> println "${song.getTitle()}" }
  }
}

通过实现 plus() 和 minus() 方法，我重载了 + 和 -，现在可以把它们用在脚本中了。清单 5 演示了它们从播放列表添加和减少歌曲的行为：

sng1 = new Song("SpanishEyes.mp3")
sng2 = new Song("RaceWithDevilSpanishHighway.mp3")
sng3 = new Song("Nena.mp3")
jbox = new JukeBox()
jbox + sng1
jbox + sng2
jbox + sng3
jbox.printPlayList() //prints Spanish Eyes, Race with the Devil.., Nena
jbox - sng2
jbox.printPlayList() //prints Spanish Eyes, Nena

重载，重载的，重载器

继续进行这个重载的 主题，您可能注意到，在表 3 中有一个可以重载的算术类操作符 <<，它恰好也为 Groovy 的集合重载。在集合的情况下，<< 覆盖后的作用像普通的 Java add() 方法一样，把值添加到集合的尾部（这与 Ruby 也很相似）。在清单 6 中，可以看到当我模拟这个行为，允许 JukeBox 的用户通过 << 操作符以及 + 操作符添加 Song 时发生的情况：

def leftShift(song){
   this.plus(song)
}

在清单 6 中，我实现了 leftShift 方法，它调用 plus 方法添加 Song 到播放列表。清单 7 显示了 << 操作符的效果：

jbox << sng2 //re-adds Race with the Devil...

可以看出，Groovy 的算术类重载操作符不仅能负重，而且能做得很快！

数组类操作符

Groovy 支持重载标准的 Java 数组存取语法 []，如表 4 所示：

数组存取语法很好地映射到集合，所以我在清单 8 中更新了 JukeBox 类，把两种情况都做了重载：

def getAt(position){    
  return songs[position]
}
def putAt(position, song){
  songs[position] = song
}

现在我实现了 getAt 和 putAt，我可以使用 [] 语法了，如清单 9 所示：

println jbox[0] //prints Spanish Eyes
jbox[0] = sng2  //placed Race w/the Devil in first slot
println jbox[0] //prints Race w/the Devil

更 Groovy 化的 JDK 方法

一旦掌握了操作符重载的概念和它在 Groovy 中的实现，就可以看到许多日常的 Java 对象已经 被 Groovy 的作者做了改进。

例如，Character 类支持 compareTo()，如清单 10 所示：

def a = Character.valueOf('a' as char)
def b = Character.valueOf('b' as char)
def c = Character.valueOf('c' as char)
def g = Character.valueOf('g' as char)
println a < b  //prints true
println g < c  //prints false

同样，StringBuffer 可以用 << 操作符进行添加，如清单 11 所示：

def strbuf = new StringBuffer()
strbuf.append("Error message: ")
strbuf << "NullPointerException on line ..."
println strbuf.toString() //prints Error message: NullPointerException on line ...

最后，清单 12 表示 Date 可以通过 + 和 - 来操纵。

def today = new Date()
println today   //prints Tue Oct 11 21:15:21 EDT 2005
println "tomorrow: " + (today + 1)  //Wed Oct 12 21:15:21 EDT 2005
println "yesterday: " + (today - 1) //Mon Oct 10 21:15:21 EDT 2005

结束语

可 以看到，操作符的即时多态，或操作符重载，对于我们来说，如果小心使用和记录，会非常强大。但是，要当心不要滥用这个特性。如果决定覆盖一个操作符去做一 些非常规的事情，请一定要清楚地记录下您的工作。对 Groovy 类进行改进，支持重载非常简单。小心应对并记录所做的工作，对于由此而来的方便的简写形式来说，代价非常公道。

2005 年 10 月 17 日

将耳朵贴到地上仔细听 —— MOP 正在前进！了解一下元对象协议（Meta Object Protocol，MOP）吧，这是一种将应用程序、语言和应用程序构建为 语言的翻新方法。

在最近的一次采访中，Groovy 项目经理 Guillaume Laforge 提到，他最喜欢的 Groovy 特性是它实现了元对象协议（Meta Object Protocol） 或称 MOP。在运行时向一个对象传递方法，或者消息 时，这个协议使对象可以作出影响它自己的状态或者行为的特定选择。正如在 PARC Software Design Area 项目主页上所描述的（请参阅 参考资料）：

元对象协议方法……基于这样一种想法，即人们可以并且应当使语言开放，使用户可以根据他们的特定需要调整设计和实现。换句话说，鼓励用户参与语言设计过程。

显然，这种大胆的思路提出了构建更智能的应用程序、甚至语言 的令人激动的可能性。在本月的专栏中，我将展示 Groovy 是如何实现 MOP 的，然后用一个实际的例子介绍它最令人激动的实际应用：作为一种迷你语言的字典！

在 下载 一节中提供了字典应用程序示例的源代码。下面的例子中需要下载 DbUnit，请参阅 参考资料。

魔术般的 MOP

元对象协议不是 Groovy 独有的，它也不是由 Groovy 发明者发明的。事实上，它的身世可追溯到 LISP 和 AOP 背后的一些人。考虑到这种身世，MOP 受到 Groovy 的见多识广的创造者们的欢迎就毫不奇怪了。

在 Groovy 中可以实现 MOP 是因为，在 Groovyland 中每一个对象都隐式地实现 groovy.lang.GroovyObject，它定义了 invokeMethod() 和 getProperty() 两个方法。在运行时，如果向一个对象传递消息，而这个对象不是作为类或者其子类中定义的属性或者方法存在，那么就调用 getProperty() 或者 invokeMethod() 方法。

在清单 1 中，我定义了 Groovy 类 MOPHandler，它实现了 invokeMethod() 和 getProperty()。当创建了 MOPHandler 的一个实例后，可以调用任意数量的方法或者属性，并看到它打印出说明调用了什么的消息。

class MOPHandler {	

  def invokeMethod(String method, Object params) { 	
    println "MOPHandler was asked to invoke ${method}"
    if(params != null){
	 params.each{ println "\twith parameter ${it}" }
    }
  }

  def getProperty(String property){
     println "MOPHandler was asked for property ${property}"
  }  
}
def hndler = new MOPHandler()
hndler.helloWorld()
hndler.createUser("Joe", 18, new Date())
hndler.name

继续，运行清单 1 中的代码，就会看到如清单 2 所示的输出。

aglover@glove-ubutu:~/projects/groovy-mop$ groovy 
  ./src/groovy/com/vanward/groovy/MOPHandler1.groovy
MOPHandler was asked to invoke helloWorld
MOPHandler was asked to invoke createUser
        with parameter Joe
        with parameter 18
        with parameter Sun Sep 04 10:32:22 EDT 2005
MOPHandler was asked for property name

是不是很不错？MOP 就像一个安全网，捕捉传递错误的消息，但是这不是它最妙的功能。用它创建可以以一般的方式 智能地对传递进来的任何消息作出响应的智能对象，才是它的最大亮点。

让我成为一种迷你语言

用 MOP 可以做的一件有趣的事情是创建伪领域专用语言，或者称为迷你语言。这些是专门用于解决特定问题的独特语言。与像 Java、C# 或者甚至 Groovy 这样的流行语言不同，它们被看成是用来解决任何问题的一般性语言，而迷你语言只针对特定问题。需要一个例子？请考虑 Unix 及其 shell，如 Bash。

只是为了练习 —— 并且这样可以真正感受 MOP —— 我将在本文的其余部分创建一个字典应用程序，它本身实际就是一个迷你语言。这个应用程序将提供一个查询字典的界面。它让用户可以创建新的单词项、得到给定单词的定义、得到给定单词的同义字、查询单词的词性以及删除单词。表 1 总结了这个迷你语言。

字典应用程序

字典应用程序基于表结构如图 1 所示的数据库。如果您经常读我们的文章，那么您可能会看出这个表结构源自专栏文章“Mark it up with Groovy Builders”。

注意：我将忽略 definition 的 EXAMPLE_SENTENCE 这一列。

我将创建一个简单的 facade，它将作为用户与数据库之间的接口。这个 facade 将通过提供 invokeMethod 和 getProperty 的实现来利用 Groovy 的 MOP 特性。invokeMethod 方法将确定命令并将责任委派给相应的内部 private 方法。

一些前提条件

因为这个应用程序依赖于数据库，在继续之前，可能需要复习一下 GroovySql。我还会使用 Groovy 的正则表达式（在 感受 Groovy 中介绍）来确定传递给 facade 的消息。

我会在写这个 facade 时，用 Groovy 测试它，因此需要回顾 Groovy 的单元测试能力，请参阅我的“Unit test your Java code faster with Groovy”。

最后，在测试过程中，我将用 DbUnit 管理数据库状态。因为在本系列中没有写过 DbUnit 的内容，我将在继续之前简单介绍在 Groovy 中使用 DbUnit。

DbUnit，结合 Groovy

DbUnit 是一项 JUnit 扩展，它在每一次运行测试之前，使数据库处于一种已知状态。在 Groovy 中使用 DbUnit 非常简单，因为 DbUnit 提供了一个 API，可以在测试用例中进行委派。为了使用 DbUnit，需要向它提供一个数据库连接和一个包含作为数据库种子的文件。将它们插入到 JUnit 的 fixture 机制中（即 setUp()）后，就可以继续了！ 清单 3 显示了字典应用程序的开始测试类。

package test.com.vanward.groovy
import com.vanward.groovy.SimpleDictionary
import groovy.util.GroovyTestCase
import java.io.File
import java.sql.Connection
import java.sql.DriverManager
import org.dbunit.database.DatabaseConnection
import org.dbunit.database.IDatabaseConnection
import org.dbunit.dataset.IDataSet
import org.dbunit.dataset.xml.FlatXmlDataSet
import org.dbunit.operation.DatabaseOperation
class DictionaryTest extends GroovyTestCase{  
   def dictionary

   void setUp() {        
      this.handleSetUpOperation()  
      dictionary = new SimpleDictionary()    
   } 

   def handleSetUpOperation() {
      def conn = this.getConnection()
      def data = this.getDataSet()       
      try{
          DatabaseOperation.CLEAN_INSERT.execute(conn, data)
      }finally{
          conn.close()
      }
    }

    def getDataSet()  {
      return new FlatXmlDataSet(new File("test/conf/words-seed.xml"))
    }

    def getConnection()  {
       Class.forName("org.gjt.mm.mysql.Driver")
       def jdbcConnection = DriverManager.
        	getConnection("jdbc:mysql://localhost/words", 
       	         "words", "words")             
       return new DatabaseConnection(jdbcConnection)
    }  
}

在清单 3 中，我创建了类 shell，它作为在编写字典应用程序时的测试类。调用测试时，JUnit 会调用 setUp()，它又会调用 DbUnit 的 API。DbUnit 会将在文件 test/conf/words-seed.xml 中找到的数据插入到数据库中。文件 test/conf/words-seed.xml 的内容可见清单 4。

<?xml version='1.0' encoding='UTF-8'?>
<dataset>
 <word WORD_ID="1" SPELLING="pugnacious" PART_OF_SPEECH="Adjective"/>   
 <definition DEFINITION_ID="10" 
             DEFINITION="Combative in nature; belligerent." 
             WORD_ID="1" />
 <synonym SYNONYM_ID="20" WORD_ID="1" SPELLING="belligerent"/>
 <synonym SYNONYM_ID="21" WORD_ID="1" SPELLING="aggressive"/>  
 <word WORD_ID="2" SPELLING="glib" PART_OF_SPEECH="Adjective"/>
 <definition DEFINITION_ID="11" 
     	       DEFINITION="Performed with a natural, offhand ease" 
             WORD_ID="2" />             
 <definition DEFINITION_ID="12" 
  	      DEFINITION="Marked by ease and fluency of speech or 
  	      writing that often suggests or stems from insincerity, 
  	      superficiality, or deceitfulness" 
         WORD_ID="2" />              
 <synonym SYNONYM_ID="30" WORD_ID="2" SPELLING="artful"/>
 <synonym SYNONYM_ID="31" WORD_ID="2" SPELLING="suave"/>  
 <synonym SYNONYM_ID="32" WORD_ID="2" SPELLING="insincere"/>  
 <synonym SYNONYM_ID="33" WORD_ID="2" SPELLING="urbane"/>  

 <word WORD_ID="3" SPELLING="rowel" PART_OF_SPEECH="Verb"/>  
 <definition DEFINITION_ID="50" 
             DEFINITION="to vec, trouble" 
             WORD_ID="13" />
</dataset>

种子文件的 XML 元素（如清单 4 所示）匹配表名。元素的属性匹配对应的表列。

构建一种迷你语言

定义了测试类后，就可以开始开发（并测试）这个应用程序了。我将按 表 1 的排列顺序处理每一项特性。

正则表达式组 正则表达式组在字典例子中起了主要作用。在 Groovy 中，可以通过 =~ 语法创建一个普通 Java Matcher 实例。可以用 Matcher 实例，通过调用 group() 方法获得 String 代码段。使用括号在一个正则表达式中创建组。例如，正则表达式 (synonymsOf)(.*) 创建两个组。一个组完全匹配 String"synonymsOf"，而另一个匹配 "synonymsOf" 后面的任何 字符。不过要记住，在要获得组值之前，首先必须调用 Matcher 的 matches() 方法。

1. 词性

如果用户想要查询一个单词的词性，他或者她可以在消息中传递像 isRowelAVerb 或者 isEstivalAnAdjective 这样的内容。（注意，我使用了 camel-case 语义，并通过同时允许 a 和 an 以尽量符合正规的英语。）回答问题的智能逻辑就变成了确定正确的单词，在第一种情况下它是 Rowel，而在第二种情况下是 Estival。还必须确定词性，在本例中分别为 Verb 和 Adjective。

使用正则表达式，逻辑就变得简单了。模式成为 is(.*)(An|A)(Verb|Adjective|Adverb|Noun)。我只对第一和第三组感兴趣（单词和词性）。有了这些，就可以编写一个简单的数据库查询，以获取词性并比较问题和答案，如清单 5 所示。

private determinePartOfSpeech(question){
  def matcher = question =~ 'is(.*)(An|A)(Verb|Adjective|Adverb|Noun)'
  matcher.matches()
  def word = matcher.group(1)
  def partOfSpeech = matcher.group(3)
  def row = sql.firstRow("select part_of_speech from word 
  	where spelling=?", [word])	
  return row[0] == partOfSpeech
}

清单 5 看起来很简单，但是我为它编写了几个测试用例，看看会是什么情况。

void testPartOfSpeechFalse() {
  def val = dictionary.isPugnaciousAVerb()
  assertFalse("pugnacious is not a verb", val)
}	
void testPartOfSpeechTrue() {
  def val = dictionary.isPugnaciousAnAdjective()
  assertTrue("pugnacious is an Adjective", val)
}

再看看清单 4 中的 XML。因为我用 DbUnit 让数据库在每次测试之前处于一种已知状态，因此可以假定单词 pugnacious 是有效的，且其词性设置为 Adjective。在清单 6 中，我在 DictionaryTest 中加入了两个简单的测试（请参阅 清单 3），以确保逻辑正确地工作。

2. 同义词

查询同义词的语义模式如下：synonymsOfBloviate，其中所要查的单词（Bloviate）跟在 synonymsOf 后面。正则表达式更简单：(synonymsOf)(.*)。找到所需要的单词后，逻辑就进行一个数据库查询，该查询会连接 word 和 synonym 表。返回的同义词加入到一个 List 中并返回，如清单 7 所示。

private getSynonyms(question){
  def matcher = question =~ '(synonymsOf)(.*)'
  matcher.matches()
  def word = matcher.group(2).toLowerCase()
  def syns = []	
  sql.eachRow("select synonym.spelling from synonym, word " +
      "where synonym.word_id = word.word_id and " +
      "word.spelling = ?", [word]){ arow ->
          syns << arow.spelling
       }	   
  return syns		
}

清单 8 中的测试验证了，定义了同义词的单词可以正确地返回同义词，而没有同义词的单词（Rowel）返回一个空 List。

void testSynonymsForWord() {
  def val = dictionary.synonymsOfPugnacious()
  def expect = ["belligerent","aggressive"]
  assertEquals("should be: " + expect, expect, val)
}
void testNoSynonymsForWord() {
  def val = dictionary.synonymsOfRowel()
  def expect = []
  assertEquals("should be: " + expect, expect, val)
}

3. 删除单词

清单 9 中的删除逻辑是灵活的，因为我允许使用 remove 或者 delete 后面加单词的命令。例如，removeGlib 和 deleteGlib 都是有效的命令。因此正则表达式变成：(remove|delete)(.*)，而逻辑是一个 SQL delete。

private removeWord(word){
  def matcher = word =~ '(remove|delete)(.*)'
  matcher.matches()
  def wordToRemove = matcher.group(2).toLowerCase()	
  sql.execute("delete from word where spelling=?" , [wordToRemove])	
}

当然，这种灵活意味着我必须为删除单词编写至少 两个测试用例，如清单 10 所示。要验证单词真的被删除了，我要获取它们的定义（更多信息请参阅 5. 获取单词的定义）并确定没有返回任何东西。

void testDeleteWord() {
  dictionary.deleteGlib()
  def val =  dictionary.glib()
  def expect = []
  assertEquals("should be: " + expect, expect, val)
}
void testRemoveWord() {
  dictionary.removePugnacious()
  def val =  dictionary.pugnacious()
  def expect = []
  assertEquals("should be: " + expect, expect, val)
}

4. 创建单词

创建一个新单词的语义是一个不匹配任何查询模式并且包含一个参数清单的消息。例如，一个像 echelon("Noun", ["a level within an organization"]) 这样的消息就符合这种模式。单词是 echelon，第一个参数是词性，然后是包含定义的 List，还有可选的第三个参数，它可以是同义词的 List。

如清单 11 所示，在数据库中创建一个新单词就是在正确的表（word 和 definition）中插入这个单词及其定义，而且，如果有同义词 List 的话，那么要把它们都要加入。

private createWord(word, defsAndSyms){
  def wordId = id++
  def definitionId = wordId + 10
  sql.execute("insert into word 
  	(word_id, part_of_speech, spelling) values (?, ?, ?)" , 
    [wordId, defsAndSyms[0], word])
  for(definition in defsAndSyms[1]){	
    sql.execute("insert into definition 
    	(definition_id, definition, word_id) " +
      "values (?, ?, ?)" , [definitionId, definition, wordId])
    }
  //has a list of synonyms has been passed in
  if(defsAndSyms.length > 2){
    def synonyms = defsAndSyms[2]
    synonyms.each{ syn ->
      sql.execute("insert into synonym 
      	(synonym_id, word_id, spelling) values (?, ?, ?)" , 
        [id++, wordId, syn])
      }
    }
}

在清单 11 中，主键逻辑过于简单了，不过我可以用几个测试证明我的信心。

void testCreateWord() {	
  dictionary.bloviate("Verb", 
  	["To discourse at length in a pompous or boastful manner"], 
    ["orate", "gabble", "lecture"])
  def val = dictionary.bloviate()
  def expect = "To discourse at length in a pompous or boastful manner"
  assertEquals("should be: " + expect, expect, val[0])
}
void testCreateWordNoSynonyms() {	
  dictionary.echelon("Noun", ["a level within an organization"])
  def val = dictionary.echelon()
  def expect = "a level within an organization"
  assertEquals("should be: " + expect, expect, val[0])
}

与通常一样，我在清单 12 中编写了几个测试用例以验证它按预想的那样工作。创建单词后，我查询这个单词的 dictionary 实例以确认它被加入了数据库。

5. 获取单词的定义

任何传递给字典应用程序的、不匹配前面任何查询类型（词性和同义词）、并且不包含任何参数的消息都被认为是定义查询。例如，一个像 .glib 或者 .glib() 的消息会返回 glib 的定义。

private getDefinitions(word){	
  def definitions = []			   	  
  sql.eachRow("select definition.definition from definition, word " +
    "where definition.word_Id = word.word_id and " +
    "word.spelling = ?", [word]){ arow ->
      definitions << arow.definition
    }	   
  return definitions	
}

因为我同时允许让方法调用和属性调用作为定义查询，因此在清单 14 中必须编写至少两个测试。就像在清单 6 中一样，可以假定 pugnacious 已经在数据库中了。DbUnit 是不是很方便？

void testFindWord() {
  def val = dictionary.pugnacious()
  def expect = "Combative in nature; belligerent."
  assertEquals("should be: " + expect, expect, val[0])
}
void testFindWordAsProperty() {
  def val = dictionary.pugnacious
  def expect = "Combative in nature; belligerent."
  assertEquals("should be: " + expect, expect, val[0])
}

这就是字典应用程序的语义。现在让我们更深入地分析应用程序背后的逻辑。

MOP 逻辑

字典应用程序的关键是 invokeMethod 和 getProperty 的实现。 我要在这些方法中做出智能的决定，即在向应用程序传递消息之后，应该如何继续。决定是通过一组条件语句而确定的，它们进行 String 操作以确定消息的类型。

清单 15 中惟一 麻烦的条件就是第一条，它要验证消息是一个定义查询而不是其他可能的组合，如 is...、remove...、delete... 或者 synonymOf...。

def invokeMethod(String methodName, Object params) { 	
  if(isGetDefinitions(methodName, params)){
    return getDefinitions(methodName)
  }else if (params.length > 0){	 
    createWord(methodName, params)
  }else if(methodName[0..1] == 'is'){
    return determinePartOfSpeech(methodName)
  }else if
  (methodName[0..5] == 'remove' || methodName[0..5] == 'delete'){	
  	 removeWord(methodName)
  }else if (methodName[0..9] == 'synonymsOf'){
    return getSynonyms(methodName)
  }
}

private isGetDefinitions(methodName, params){
  return !(params.length > 0) && 
    ( (methodName.length() <= 5 
    && methodName[0..1] != 'is' ) || 
    (methodName.length() <= 10 
    && isRemoveDeleteIs(methodName) ) || 
    (methodName.length() >= 10 
    && methodName[0..9] != 'synonymsOf' 
    && isRemoveDeleteIs(methodName)))	
}

private isRemoveDeleteIs(methodName){
	return (methodName[0..5] != 'remove' 
      && methodName[0..5] != 'delete' 
      && methodName[0..1] != 'is')
  }

isGetDefinitions 方法做了很多工作，其中一些工作依赖于 isRemoveDeleteIs。当它确定一个消息不符合定义查询时，逻辑就变得简单多了。

清单 16 中的 getProperty 方法很简单，因为我规定用户只能按属性查询定义，因此，调用 getProperty 时，我调用 getDefinitions 方法。

def getProperty(String property){
  return getDefinitions(property)
}

就是这样了！真的。清单 5 到 16 中的逻辑创建了一个应用程序，它给予用户相当的灵活性，同时又不会太复杂。当然，如前所述，应用程序中的主键逻辑并不是很保险。在这方面有多种改进方法， 从数据库序列到像 Hibernate 这样的框架都可以，Hibernate 框架用于相当得体地处理 ID。

眼见为实，清单 17 展示了字典应用程序的语言的实际能力。（如果在使用 SAT 之前有这样的东西该多好！）

import com.vanward.groovy.SimpleDictionary
def dict = new SimpleDictionary()  
dict.vanward("Adjective", ["Being on, or towards the front"], 
	["Advanced"])
dict.pulchritude("Noun", ["Great physical beauty and appeal"])
dict.vanward             //prints "Being on, or towards the front"
dict.pulchritude()       //prints "Great physical beauty and appeal"
dict.synonymsOfVanward() //prints "Advanced"
dict.isVanwardANoun()    //prints "false"
dict.removeVanward()
dict.deletePulchritude()

MOP 的好处

现在，您可能会问 有什么好处？ 我本可以轻易地公开这些 private 方法，重新安排几项内容，就可以给出一个正常工作的应用程序（即，可以公开 getDefinition 方法、createWord 方法等），而无需使用 MOC。

让我们分析这种提议 —— 假定我要不使用 Goovy 的 MOC 实现来创建完全相同的字典应用程序。我需要重新定义 createWord() 方法的参数清单，使它变成类似 def createWord(word, partOfSpeech, defs, syns=[]){} 的样子。

可以看出，第一步是去掉 private 修饰符，用 def 替换它，这与将方法声明为 public 是一样的。然后，要定义参数，并让最后一个参数为可选的（syns=[]）。

还要定义一个 delete 方法，它至少要调用 remove 方法以同时支持 remove 和 delete。词性查询也应该修改。可以加入另一个参数，这样它看起来像 determinePartOfSpeech(word, partOfSpeech) 这样。

实际上，经过以上步骤，字典应用程序的概念复杂性就从 MOP 实现转移到了静态 API 上了。这就带来了这个问题 —— 这样做 的好处是什么？当然您可以看出由于实现 MOP，我为应用程序的使用者提供了无可比拟的灵活性。得到的 API 是一组静态定义的方法，灵活完全比不上语言 本身！

结束语

如果现在头有些发晕了，那么想一下这个：如果可以构建这样一个字典应用程序，使用户可以随意创建查询会怎么样呢？例如，findAllWordsLikeGlib 或者 findAllWordsWithSynonymGlib 等等，这些语义对于 MOP 来说这只是文字解析罢了，而对用户来说，则是强大的查询功能！

现在再进一步：如果可以创建另一种迷你语言，它对一项业务更有用一些，比如针对股市交易的迷你语言，那会怎么样呢？如果更进一步，将这个应用程序构建为有友好的控制台呢？不用编写脚本，用户使用的是 Groovy 的 shell。（记住我是怎么说 Bash 的？）

如果您认为这种“炼金术”工具只是痴迷于 Emacs 扩展的古怪的 LISP 家伙们用的，那就错了！只要看看马路对面那些喧嚷的 Ruby on Rails 老手们就会知道这种平台是多么的令人激动。深入了解您就会看到当 MOP 发挥作用时，只要 遵守命名规范，不用深入 SQL 就可创建很好的查询。谁在那儿乐呢？

2005 年 9 月 23 日

在 Groovy 中处处都是闭包，Groovy 闭包惟一的问题是：当每天都使用它们的时候，看起来就有点平淡了。在本文中，客座作者 Ken Barclay 和 John Savage 介绍了如何对标准的闭包（例如闭包复合和 Visitor 设计模式）进行 curry 处理。curry() 方法是由 Haskell Curry 发明的，在 JSR 标准发布之前就已经在 Groovy 语言中了。

几乎从一年前实战 Groovy 系列开始，我就已经提供了多个让您了解闭包的机会。在首次作为 alt.lang.jre 系列的一部分写 Groovy 时（“感受 Groovy”，2004 年 8 月），我介绍了 Groovy 的闭包语法，而且 就在上一期文章中，我介绍了最新的 JSR 标准对相同语法的更新。学习至今，您知道了 Groovy 闭包是代码块，可以被引用、带参数、作为方法参数传递、作为返回值从方法调用返回。而且，它们也可以作为其他闭包的参数或返回值。因为闭包是 Closure 类型的对象，所以它们也可以作为类的属性或集合的成员。

虽然这些技术都是很神奇的，但是本期文章要学习的闭包技术要比您迄今为止尝试过的都要更火辣一些。客座作者 John Savage 和 Ken Barclay 已经用 Groovy 闭包中的 curry() 方法做了一些有趣的实验，我们非常有幸可以见识他们的技艺。

Barclay 和 Savage 的 curry 过的闭包不仅会重新激起您对熟悉的操作（例如复合）和 Visitor 设计模式的兴奋，还会用 Groovy 打开函数式编程的大门。

进行 curry 处理

curry 过的函数 一般可在函数式编程语言（例如 ML 和 Haskell）中找得到（请参阅 参考资料）。curry 这个术语来自 Haskell Curry，这个数学家发明了局部函数的概念。Currying 指的是把多个参数放进一个接受许多参数的函数，形成一个新的函数接受余下的参数，并返回结果。令人兴奋的消息是，Groovy 的当前版本（在编写本文时是 jsr-02 版）支持在闭包上使用 curry() 方法 —— 这意味着，我们这些 Groovy 星球的公民，现在可以利用函数式编程的某些方面了！

您以前可能从未用过 curry()，所以我们先从一个简单的、熟悉的基础开始。清单 1 显示了一个叫做 multiply 的闭包。它有形式参数 x 和 y，并返回这两个值的乘积。假设没有歧义存在，然后代码演示了用于执行 multiply 闭包的两种方法：显式（通过 call 的方式）或隐式。后一种样式引起了函数调用方式。

def multiply = { x, y -> return x * y } // closure
def p = multiply.call(3, 4)             // explicit call
def q = multiply(4, 5)                  // implicit call
println "p: ${p}"                       // p is 12
println "q: ${q}"                       // q is 20

这个闭包当然很好，但是我们要对它进行 curry 处理。在调用 curry() 方法时，不需要提供所有的实际参数。curry 过的 调用只引起了闭包的部分应用程序。闭包的 部分应用程序 是另一个 Closure 对象，在这个对象中有些值已经被修正。

清单 2 演示了对 multiply 闭包进行 curry 处理的过程。在第一个例子中，参数 x 的值被设置为 3。名为 triple 的闭包现在有效地拥有了 triple = { y -> return 3 * y } 的定义。

def multiply = { x, y -> return x * y }  // closure
def triple = multiply.curry(3)           // triple = { y -> return 3 * y }
def quadruple = multiply.curry(4) 
// quadruple = { y -> return 4 * y }
def p = triple.call(4)                   // explicit call
def q = quadruple(5)                     // implicit call
println "p: ${p}"                        // p is 12
println "q: ${q}"                        // q is 20

可以看到，参数 x 已经从 multiply 的定义中删除，所有它出现的地方都被 3 这个值代替了。

curry 过的数学 101

从基本数学可能知道，乘法运算符是可交换的（换句话说 x * y = y * x）。但是，减法运算符是不可交换的；所以，需要两个操作来处理减数和被减数。清单 3 为这个目的定义了闭包 lSubtract 和 rSubtract（分别在左边和右边），结果显示了 curry 函数的一个有趣的应用。

def lSubtract = { x, y -> return x - y }
def rSubtract = { y, x -> return x - y }
def dec = rSubtract.curry(1)            
 // dec = { x -> return x - 1 }
def cent = lSubtract.curry(100)          
// cent = { y -> return 100 - y }
def p = dec.call(5)                      // explicit call
def q = cent(25)                         // implicit call
println "p: ${p}"                        // p is 4
println "q: ${q}"                        // q is 75

迭代和复合

您会回忆起这个系列以前的文章中，闭包一般用于在 List 和 Map 集合上应用的迭代器方法 上。例如，迭代器方法 collect 把闭包应用到集合中的每个元素上，并返回一个带有新值的新集合。清单 4 演示了把 collect 方法应用于 List 和 Map。名为 ages 的 List 被发送给 collect() 方法，使用单个闭包 { element -> return element + 1 } 作为参数。注意方法的最后一个参数是个闭包，在这个地方 Groovy 允许把它从实际参数列表中删除，并把它直接放在结束括号后面。在没有实际参数时，可以省略括号。用名为 accounts 的 Map 对象调用的 collect() 方法可以展示这一点。

def ages = [20, 30, 40]
def accounts = ['ABC123' : 200, 'DEF456' : 300, 'GHI789' : 400]
def ages1 = ages.collect({ element -> return element + 1 })
def accounts1 = accounts.collect 
  { entry -> entry.value += 10; return entry }
println "ages1: ${ages1}" 
// ages1: [21, 31, 41]
println "accounts1: ${accounts1}"
// accounts1: [ABC123=210, GHI789=410, DEF456=310]
def ages2 = ages.collect { element -> return dec(element) }
println "ages2: ${ages2}"
 // ages2: [19, 29, 39]

最后一个例子搜集名为 ages 的 List 中的所有元素，并将 dec 闭包 （来自清单 3）应用于这些元素。

闭包复合

闭包更重要的一个特征可能就是复合（composition），在复合中可以定义一个闭包，它的目的是组合其他闭包。使用复合，两个或多个简单的闭包可以组合起来构成一个更复杂的闭包。

清单 5 介绍了一个漂亮的 composition 闭包。现在请注意仔细阅读：参数 f 和 g 代表 单个参数闭包。到现在还不错？现在，对于某些参数值 x，闭包 g 被应用于 x，而闭包 f 被应用于生成的结果！哦，只对前两个闭包参数进行了 curry 处理，就有效地形成了一个组合了这两个闭包的效果的新闭包。

清单 5 组合了闭包 triple 和 quadruple，形成闭包 twelveTimes。当把这个闭包应用于实际参数 3 时，返回值是 36。

def multiply = { x, y -> return x * y }    
// closure
def triple = multiply.curry(3)            
// triple = { y -> return 3 * y }
def quadruple = multiply.curry(4) 
// quadruple = { y -> return 4 * y }
def composition = { f, g, x -> return f(g(x)) }
def twelveTimes = composition.curry(triple, quadruple)
def threeDozen = twelveTimes(3)
println "threeDozen: ${threeDozen}"		 
// threeDozen: 36

非常漂亮，是么？

五星计算

现在我们来研究闭包的一些更刺激的方面。我们先从一个机制开始，用这个机制可以表示包含计算模式 的闭包，计算模式是一个来自函数式编程的概念。计算模式的一个例子就是用某种方式把 List 中的每个元素进行转换。因为这些模式发生得如此频繁，所以我们开发了一个叫做 Functor 的类，把它们封装成 static Closure。清单 6 显示了一个摘要。

package fp
abstract class Functor {
 //  arithmetic (binary, left commute and right commute)
 public static Closure bMultiply     = { x, y -> return x * y }
 public static Closure rMultiply     = { y, x -> return x * y }
 public static Closure lMultiply     = { x, y -> return x * y }

 // ...
 // composition
 public static Closure composition   = { f, g, x -> return f(g(x)) }

 // lists
 public static Closure map    = 
   { action, list -> return list.collect(action) }

 public static Closure apply  = { action, list -> list.each(action) }

 public static Closure forAll = { predicate, list ->
                                  for(element in list) {
                                    if(predicate(element) == false) {
                                        return false
                                    }
                                  }
                                  return true
                               }
    // ...
}

在这里可以看到名为 map 的闭包，不要把它与 Map 接口混淆。map 闭包有一个参数 f 代表闭包，还有一个参数 list 代表（不要惊讶）List。它返回一个新 List，其中 f 已经映射到 list 中的每个元素。当然，Groovy 已经有了用于 Lists 的 collect() 方法，所以我们在我们的实现中也使用了它。

在清单 7 中，我们把事情又向前进行了一步，对 map 闭包进行了 curry 处理，形成一个块，会将指定列表中的所有元素都乘以 12。

import fp.*
def twelveTimes = { x -> return 12 * x }
def twelveTimesAll = Functor.map.curry(twelveTimes)
def table = twelveTimesAll([1, 2, 3, 4])
println "table: ${table}"		
// table: [12, 24, 36, 48]

现在，这 就是我们称之为五星计算的东西！

业务规则用 curry 处理

关于闭包的技艺的讨论很不错，但是更关注业务的人会更欣赏下面这个例子。在考虑计算特定 Book 条目净值的问题时，请考虑商店的折扣和政府的税金（例如 增值税）。如果想把这个逻辑作为 Book 类的一部分包含进来，那么形成的解决方案可能是个难缠的方案。因为书店可能会改变折扣，或者折扣只适用于选定的存货，所以这样一个解决方案可能会太刚性了。

但是猜猜情况如何。变化的业务规则非常适合于使用 curry 过的闭包。可以用一组简单的闭包来表示单独的业务规则，然后用复合把它们以不同的方式组合起来。最后，可以用 计算模式 把它们映射到集合。

清单 8 演示了书店的例子。闭包 rMultiply 是个局部应用程序，通过使用一个不变的第二操作数，把二元乘法改变成一元闭包。两个图书闭包 calcDiscountedPrice 和 calcTax 是 rMultiply 闭包的实例，为乘数值设置了值。闭包 calcNetPrice 是计算净价的算法：先计算折扣价格，然后在折扣价格上计算销售税。最后， calcNetPrice 被应用于图书价格。

import fp.*
class Book {
    @Property name
    @Property author
    @Property price
    @Property category
}
def bk = new Book(name : 'Groovy', author : 
  'KenB', price : 25, category : 'CompSci')
// constants
def discountRate = 0.1
def taxRate = 0.17
//  book closures
def calcDiscountedPrice = Functor.rMultiply.curry(1 - discountRate)
def calcTax = Functor.rMultiply.curry(1 + taxRate)
def calcNetPrice = 
  Functor.composition.curry(calcTax, calcDiscountedPrice)
//  now calculate net prices
def netPrice = calcNetPrice(bk.price)
println "netPrice: ${netPrice}"		// netPrice: 26.325

更加 groovy 的访问者

已经看到了如何把 curry 过的闭包应用于函数模式，所以现在我们来看看在使用相似的技术重新访问重要的面向对象设计模式时发生了什么。对于面向对象系统来说，必须遍历对象集合并在 集合中的每个元素上执行某个操作，是非常普通的使用情况。假设一个不同的场景，系统要遍历相同的集合，但是要执行不同的操作。通常，需要用 Visitor 设计模式（请参阅 参考资料）来满足这一需求。Visitor 接口引入了处理集合元素的动作协议。具体的子类定义需要的不同行为。方法被引进来遍历集合并对每个元素应用 Visitor 动作。

如果到现在您还没猜出来，那么可以用闭包实现同的效果。这种方法的一个抽象是：使用闭包，不需要开发访问者类的层次结构。而且，可以有效地使用闭包复合和映射来定义集合的动作和效果遍历。

例如，考虑用来表示图书馆库存的类 Library 和类 Book 之间的一对多关系。可以用 List 或 Map 实现这个关系；但是 Map 提供的优势是它能提供快速的查询，也就是说用图书目录编号作为键。

清单 9 显示了一个使用 Map 的简单的一对多关系。请注意 Library 类中的两个显示方法。引入访问者时，两者都是重构的目标。

class Book {    
    @Property title
    @Property author
    @Property catalogNumber
    @Property onLoan = false
	String toString() {
        return "Title: ${title}; author: ${author}"
    }
}
class Library {
    @Property name
    @Property stock = [ : ]

	def addBook(title, author, catalogNumber) {
        def bk = new Book(title : title, author : 
          author, catalogNumber : catalogNumber)
        stock[catalogNumber] = bk
    }

    def lendBook(catalogNumber) {
        stock[catalogNumber].onLoan = true
    }

    def displayBooksOnLoan() {
        println "Library: ${name}"
        println "Books on loan"
        stock.each { entry ->
            if(entry.value.onLoan == true) println entry.value
        }
    }

    def displayBooksAvailableForLoan() {
        println "Library: ${name}"
        println "Books available for loan"
        stock.each { entry ->
            if(entry.value.onLoan == false) println entry.value
        }
    }    
}
def lib = new Library(name : 'Napier')
lib.addBook('Groovy', 'KenB', 
  'CS123')
lib.addBook('Java', 'JohnS', 'CS456')
lib.addBook('UML', 'Ken and John', 
  'CS789')
lib.lendBook('CS123')
lib.displayBooksOnLoan()	// Title: Groovy; author: KenB
lib.displayBooksAvailableForLoan()	// Title: UML; author: Ken and John
	// Title: Java; author: JohnS

清单 10 包含 Library 类中的几个闭包，模拟了访问者的用法。action 闭包（与 map 闭包有点相似）把 action 闭包应用于 List 的每个元素。如果某本书被借出，则闭包 displayLoanedBook 显示它；如果某本书未被借出，则闭包 displayAvailableBook 显示它。两者都扮演访问者和相关的动作。用 displayLoanedBook 对 apply 闭包进行 curry 处理，会形成闭包 displayLoanedBooks，它为处理图书集合做好了准备。类似的方案也用来生成可供借阅的图书显示，如清单 10 所示。

import fp.*
class Book {
    @Property title
    @Property author
    @Property catalogNumber
    @Property onLoan = false
    String toString() {
        return "    Title: ${title}; author: ${author}"
    }

}
class Library {      
    @Property name
    @Property stock = [ : ]
    def addBook(title, author, catalogNumber) {
        def bk = new Book(title : title, author : 
          author, catalogNumber : catalogNumber)
        stock[catalogNumber] = bk
    }

    def lendBook(catalogNumber) {
        stock[catalogNumber].onLoan = true
    }

    def displayBooksOnLoan() {
        println "Library: ${name}"
        println "Books on loan"
        displayLoanedBooks(stock.values())
    }

    def displayBooksAvailableForLoan() {
        println "Library: ${name}"
        println "Books available for loan"
        displayAvailableBooks(stock.values())
    }


    private displayLoanedBook = { bk -> if(bk.onLoan == true) 
      println bk }
    private displayAvailableBook = { bk -> if(bk.onLoan == false) 
      println bk }

    private displayLoanedBooks = 
      Functor.apply.curry(displayLoanedBook)
    private displayAvailableBooks = 
      Functor.apply.curry(displayAvailableBook)
}
def lib = new Library(name : 'Napier')
lib.addBook('Groovy', 'KenB', 
  'CS123')
lib.addBook('Java', 'JohnS', 'CS456')
lib.addBook('UML', 'Ken and John', 
  'CS789')
lib.lendBook('CS123')
lib.displayBooksOnLoan()	// Title: Groovy; author: KenB
lib.displayBooksAvailableForLoan() // Title: UML; author: Ken and John
                             // Title: Java; author: JohnS

用闭包进行测试

在结束之前，我们来看一下 Groovy 闭包的一个附加用途。请考虑一个被建模为具有许多 Employee 的 Company 的应用程序。递归的关系在单个 Employee（团队领导）和许多 Employee（团队成员）之间进一步建立起一对多的聚合。图 1 是这样一个组织的类图。

可以用闭包来表述模型架构上的完整性。例如，在这个例子中，可能想确保每个员工都分配了一个经理。简单的闭包 hasManager 为每个员工表达了这个需求： def hasManager = { employee -> return (employee.manager != null) }。

来自清单 6 的 Functor 类中的 forAll 闭包的局部应用程序能够描述架构的需求：def everyEmployeeHasManager = Functor.forAll.curry(hasManager)。

清单 11 演示了 curry 过的闭包的应用：测试系统架构的完整性。

import fp.*
/**
 *  A company with any number of employees. 
 *  Each employee is responsible
 *  to a team leader who, in turn, manages a team of staff.
 */
import java.util.*
class Employee {
	@Property id
    @Property name
    @Property staff = [ : ]
    @Property manager = null
    String toString() {
        return "Employee: ${id} ${name}"
    }

    def addToTeam(employee) {
        staff[employee.id] = employee
        employee.manager = this
    }

}
class Company {
	@Property name
    @Property employees = [ : ]
    def hireEmployee(employee) {
        employees[employee.id] = employee
    }

    def displayStaff() {
        println "Company: ${name}"
        println "===================="
        employees.each { entry -> println "    
          ${entry.value}" }
    }


}
def co = new Company(name : 'Napier')
def emp1 = new Employee(id : 123, name : 'KenB')
def emp2 = new Employee(id : 456, name : 'JohnS')
def emp3 = new Employee(id : 789, name : 'JonK')
co.hireEmployee(emp1)
co.hireEmployee(emp2)
co.hireEmployee(emp3)
emp3.addToTeam(emp1)
emp3.addToTeam(emp2)
co.displayStaff()
//  Architectural closures
def hasManager = { employee -> return (employee.manager != null) }
def everyEmployeeHasManager = Functor.forAll.curry(hasManager)
def staff = new ArrayList(co.employees.values())
println "Every employee has a manager?: 
  ${everyEmployeeHasManager.call(staff)}"    // false

curry 是优秀的

在本文中您已看到了大量闭包，但是希望能激起您对更多闭包的渴望。在学习乘法例子时，curry 过的闭包使得实现计算的函数模式出奇得容易。一旦掌握了这些模式，就可以把它们部署到常见的企业场景中，例如我们在书店例子中把它们应用于业务规则。把闭 包应用于函数模式是令人兴奋的，一旦这么做了之后，再把它们应用于面向对象设计模式，就不是什么大事情了。Curry 过的闭包可以用来模拟 Visitor 模式的基本元素，正如在 Library 例子中显示的。它们在软件测试期间执行完整性测试时也会有用，就像用 Company 例子所展示的。

本文中看到的全部例子都是企业系统常见的用例。看到 Groovy 闭包和 curry 方法能够如此流畅地应用于众多编程场景、函数模式和面向对象模式，真是激动人心。Haskell Curry 肯定发现了这个可怕的 groovy！

2005 年 8 月 22 日

随 着 Groovy JSR-1（及其后续发行版本）的发布，Groovy 语法的变化已经规范化 —— 这意味着如果以前没有对此加以注意，那么现在是开始注意它的时候了。这个月，Groovy 的常驻实践者 Andrew Glover 将介绍 Groovy 语法最重要的变化，以及在经典 Groovy 中找不到的一个方便特性。

从我在 alt.lang.jre 的系列文章“Feeling Groovy” 中介绍 Groovy 开始，差不多有一年时间了。从那时起，通过发行许多版本，逐步解决了语言实现中的问题，并满足开发人员社区的一些特性请求，Groovy 已经成熟了许多。最后，在今年四月，Groovy 有了一个重大飞跃，它正式发布了新的解析器，该解析器的目标就是将这门语言标准化为 JSR 进程的一部分。

在本月“实战 Groovy”这一期的文章中，我将祝贺 Groovy 的成长，介绍通过 Groovy 非常好用的新解析器规范化的一些最重要的变化：即变量声明和闭包。因为我要将一些新 Groovy 语法与我在关于 Groovy 的第一篇文章中介绍的经典语法进行比较，所以您可以在另一个浏览器窗口中打开“ alt.lang.jre: 感受 Groovy”这篇文章。

为什么会发生这些变化？

如果您一直在跟踪 Groovy，不管是阅读文章和 blog，还是自己编写代码，您都可能已经遭遇过这门语言的一、两个微妙的问题。在进行一些灵敏的操作，例如对象导航，特别是使用闭包的时候， Groovy 偶尔会遇到歧义性问题和语法受限的问题。几个月之前，作为 JSR 进程的一部分，Groovy 团队开始着手解决这些问题。四月份，随 groovy-1.0-jsr-01 发行版本提供的解决方案是一个更新过的语法以及一个用来对语法进行标准化的新语法内容解析器。

好消息是：新语法是对语言的完全增强。另一个好消息是：它和以前的语法没有很大不同。像所有 Groovy 一样，语法的设计目标是较短的学习曲线和较大的回报。

当 然，符合 JSR 的解析器也给新 Groovy 带来一些与目前“经典”语法不兼容的地方。如果用新的解析器运行本系列以前文章中的代码示例，那么您自己就可以看，代码示例可能无法工作！现在，这一点看 起来可能有点苛刻 —— 特别是对 Groovy 这样自由的语言来说 —— 但是解析器的目标是确保作为 Java 平台的标准化 语言的 Groovy 的持续成长。可以把它当作新 Groovy 的一个有帮助的指南。

Groovy 依然是 Groovy！

在深入研究变化的内容之前，我要花几秒钟谈谈什么没有改变。首先，动态类型化的基本性质没有改变。变量的显式类型化（即将变量声明为 String 或 Collection） 依然是可选的。稍后，我会讨论对这一规则的一点新增内容。

知道分号依然是可选的时候，许多人都会感到轻松。对于放松对这个语法的使用，存在许多争论，但是最终少数派赢得了胜利。底线是：如果愿意，也可以使用分号。

集合（Collection）的使用大部分还保持不变。仍然可以用 array 语法和 map，像以前那样（即最初从文章“alt.lang.jre: 感受 Groovy”中学到的方式）声明类似 list 的集合。但范围上略有变化，我将在后面部分展示这一点。

最后，Groovy 对标准 JDK 类的增加没有发生多少变化。语法糖衣和漂亮的 API 也没变， 就像普通的 Java File 类型的情况一样，我稍后将展示这一点。

容易变的变量

Groovy 的变量规则对新的符合 JSR 的语法的打击可能最大。经典的 Groovy 在变量声明上相当灵活（而且实际上很简洁）。而使用新的 JSR Groovy 时，所有的变量前都必须加上 def 关键字或者 private、protected 或 public 这样的修饰符。当然，也可以声明变量类型。另外，如果正在定义类，希望声明属性（使用 JavaBeans 样式的 getter 和 setter 公开），那么也可以用 @Property 关键字声明成员变量。请注意 —— Property 中的 P 是大写的！

例如，在“alt.lang.jre: 感受 Groovy”中介绍 GroovyBeans 时，我在文章的清单 22 中定义了一个叫做 LavaLamp 的类型。这个类不再符合 JSR 规范，如果要运行它，则会造成解析器错误。幸运的是，迁移这个类不是很困难：我要做的全部工作就是给所有需要的成员变量添加 @Property 属性，如清单 1 所示：

package com.vanward.groovy
class LavaLamp{
  @Property model
  @Property baseColor
  @Property liquidColor
  @Property lavaColor
}
llamp = new LavaLamp(model:1341, baseColor:"Black", 
  liquidColor:"Clear", lavaColor:"Green")
println llamp.baseColor
println "Lava Lamp model ${llamp.model}"
myLamp = new LavaLamp()
myLamp.baseColor = "Silver"
myLamp.setLavaColor("Red")
println "My Lamp has a ${myLamp.baseColor} base"
println "My Lava is " + myLamp.getLavaColor()

不是太坏，不是吗？

正如上面描述的，对于任何 变量，如果没有修饰符、@Property 关键字或者类型，则需要具有 def 关键字。例如，清单 2 的代码在 toString 方法中包含一个中间变量 numstr ，如果用 JSR 解析器运行此代码，则会造成一个错误：

class Person { 
  @Property fname
  @Property lname
  @Property age
  @Property address
  @Property contactNumbers
  String toString(){

   numstr = new StringBuffer()

   if (contactNumbers != null){
	   contactNumbers.each{
		numstr.append(it)
		numstr.append(" ")
	   }
   }

   "first name: " + fname + " last name: " + lname + 
	" age: " + age + " address: " + address + 
	" contact numbers: " + numstr.toString()
 }
}

认识这个代码吗？它借用来自“在 Java 应用程序中加一些 Groovy 进来 ”一文的清单 1 中的代码。在清单 3 中，可以看到运行代码时弹出的错误消息：

c:\dev\projects>groovy BusinessObjects.groovy

 BusinessObjects.groovy: 13: The variable numstr is undefined in the current scope
 @ line 13, column 4.
      numstr = new StringBuffer()
      ^
1 Error

当然，解决方案也是在 toString 方法中将 def 关键字添加到 numstr。清单 4 显示了这个更合适的 def 解决方案。

  String toString(){

   def numstr = new StringBuffer()

   if (contactNumbers != null){
	   contactNumbers.each{
		numstr.append(it)
		numstr.append(" ")
	   }
   }

   "first name: " + fname + " last name: " + lname + 
	" age: " + age + " address: " + address + 
	" contact numbers: " + numstr.toString()
 }

另外，我还可以为 numstr 提供一个像 private 这样的修饰符，或者将它声明为 StringBuffer。不论哪种方法，重要的一点是：在 JSR Groovy 中，必须在变量前加上某些东西。

封闭闭包（closure）

闭包的语法发生了变化，但是大多数变化只与参数有关。在经典的 Groovy 中，如果为闭包声明参数，就必须用 | 字符作为分隔符。您可能知道，| 也是普通 Java 语言中的位操作符；结果，在 Groovy 中，只有在某个闭包的参数声明的上下文中，才能使用 | 字符。

在“alt.lang.jre: 感受 Groovy”的清单 21 中，我演示了迭代，查看了用于闭包的经典 Groovy 参数语法。可以回想一下，我在集合上运用了 find 方法，该方法试图找到值 3。然后我传入了参数 x，它代表 iterator 的下一个值 （有经验的 Groovy 开发人员会注意到，x 完全是可选的，我可以引用隐式变量 it）。使用 JSR Groovy 时，必须删除 | ，并用 Nice 样式的 -> 分隔符代替它，如清单 5 所示：

[2, 4, 6, 8, 3].find { x ->
  if (x == 3){
    println "found ${x}"
  }
}

新的闭包语法有没有让您想起 Nice 语言的块语法呢？如果不熟悉 Nice 语言，请参阅 alt.lang.jre: Nice 的双倍功能，这是我在 alt.lang.jre 系列上贡献的另一篇文章。

正如我在前面提到过的，Groovy 的 JDK 没有变。但是就像刚才所学到的，闭包却发生了变化；所以，使用 Groovy 的 JDK 中那些漂亮的 API 的方式也发生了变化，但仅仅是轻微的变化。在清单 6 中，可以看到这些变化对 Groovy IO 的影响根本是微不足道的：

import java.io.File
new File("maven.xml").eachLine{ line ->
  println "read the following line -> " + line
}

改编过滤器

现在，不得不让您跳过很大一部分，但您还记得在“用 Groovy 进行 Ant 脚本编程”一文中，我是如何介绍闭包的威力和工具的吗？谢天谢地，我在这个专栏的示例中所做的多数工作都很容易针对新语法重新进行改编。在清单 7 中，我只是将 @Property 属性添加到 Filter 的成员 strategy（最初在那篇文章的清单 2 和清单 3 中显示）。然后在闭包中添加 -> 分隔符，万岁 —— 它可以工作了！

package com.vanward.groovy
class Filter{
 @Property strategy
 boolean apply(str){
  return strategy.call(str)
 }
}
simplefilter = { str -> 
  if(str.indexOf("java.") >= 0){
    return true
  }else{
    return false
  }
}

fltr = new Filter(strategy:simplefilter)
assert !fltr.apply("test")
assert fltr.apply("java.lang.String")

rfilter = { istr ->
  if(istr =~ "com.vanward.*"){
    return true
  }else{
    return false
  }
}

rfltr = new Filter(strategy:rfilter)
assert !rfltr.apply("java.lang.String")
assert rfltr.apply("com.vanward.sedona.package") 

目前为止还不坏，您觉得呢？新的 Groovy 语法很容易掌握！

对范围（range）的更改

Groovy 的范围语法的变化非常小。在经典的 Groovy 中，您可以通过使用 ... 语法指明排他性（即上界）来避开这些变化。在 JSR Groovy 中，只要去掉最后一个点（.），并用直观的 < 标识替代它即可。

请注意观察我在下面的清单 8 中对来自“Feeling Groovy”一文中的范围示例进行的改编：

myRange = 29..<32
myInclusiveRange = 2..5
println myRange.size() // still prints 3
println myRange[0]   // still prints 29
println myRange.contains(32) //  still prints false
println myInclusiveRange.contains(5) // still prints true

您是说存在歧义？

您可能注意到，在使用 Groovy 时，有一项微妙的功能可以让您获得方法引用，并随意调用这个引用。可以将方法指针当作调用对象方法的方便机制。关于方法指针，有意思的事情是：它们的使用可能就表明代码违反了迪米特法则。

您可能会问“什么是迪米特法则”呢？迪米特法则使用只与直接朋友对话 这句格言指出：我们应当避免调用由另一个对象方法返回的对象上的方法。例如，如果 Foo 对象公开了一个 Bar 对象类型，那么客户应当通过 Foo 访问 Bar 的行为。结果可能是一些脆弱的代码，因为对某个对象的更改会传播到整个范围。

一位受尊敬的学者写了一篇优秀的文章，叫做“The Paperboy, the Wallet, and the Law of Demeter”（请参阅 参考资料）。这篇文章中的示例是用 Java 语言编写的；但是，我在下面用 Groovy 重新定义了这些示例。在清单 9 中，可以看到这些代码演示了迪米特法则 —— 如何用它洗劫人们的钱包！

package com.vanward.groovy
import java.math.BigDecimal
class Customer {
 @Property firstName
 @Property lastName
 @Property wallet
}
class Wallet {
 @Property value;
 def getTotalMoney() {
  return value;
 }

 def setTotalMoney(newValue) {
  value = newValue;
 }
 def addMoney(deposit) {
  value = value.add(deposit)
 }
 def subtractMoney(debit) {
  value = value.subtract(debit)
 }
}

在清单 9 中，有两个定义的类型 —— 一个 Customer 和一个 Wallet。请注意 Customer 类型公开自己的 wallet 实例的方式。正如前面所说的，代码简单的公开方式存在问题。例如，如果我（像原文章的作者所做的那样）添加了一个坏报童，去抢劫那些不知情客户的钱包，又 会怎么样？在清单 10 中，我使用了 Groovy 的方法指针来做这件坏事。请注意我是如何使用 Groovy 新的 & 方法指针语法，通过 Customer 实例夺取对 subtractMoney 方法的引用。

iwallet = new Wallet(value:new BigDecimal(32))
victim = new Customer(firstName:"Lane", lastName:"Meyer", wallet:iwallet)
victim.getWallet().subtractMoney(new BigDecimal("0.10"))//Didn't *ask* for a dime. Two Dollars.
//paperboy turns evil by snatching a reference to the subtractMoney method
mymoney = victim.wallet.&subtractMoney
mymoney(new BigDecimal(2)) // "I want my 2 dollars!"
mymoney(new BigDecimal(25)) // "late fees!"

现在，不要误会我：方法指针不是为了侵入代码或者获得对人们 现金的引用！方法指针只是一种方便的机制。方法指针也很适合于重新连接上您喜爱的 80 年代的老电影！但是，如果您把这些可爱的、漂亮的东西弄湿了，那么它们可就帮不上您的忙了。严格地说，可以把 Groovy 的 println 快捷方式当作 System.out.println 的隐式方法指针。

如果一直都很留心，那么您可能已经注意到，JSR Groovy 要求我使用新的 & 语法来创建 subtractMoney 方法的指针。您可能已经猜到，这个添加消除了经典 Groovy 中的歧义性。

一些新东西！

如果在 Groovy 的 JSR 发行版中没有什么新东西，那就没有意思了，不是吗？谢天谢地，JSR Groovy 引入了 as 关键字，它是一个方便的类型转换机制。这个特性与新的对象创建语法关系密切，新的语法可以用类似数组的语法很容易地在 Groovy 中创建非定制 类。所谓非定制，指的是在 JDK 中可以找到的类，例如 Color、Point、File，等等。

在清单 11 中，我用这个新语法创建了一些简单类型：

def nfile = ["c:/dev", "newfile.txt"] as File
def val = ["http", "www.vanwardtechnologies.com", "/"] as URL
def ival = ["89.90"] as BigDecimal
println ival as Float

注意，我用便捷语法创建了一个新 File 和 URL，还有 BigDecimal ，还要注意的是，我可以用 as 把 BigDecimal 类型转换成 Float 类型。

接下来是什么呢？

JSR 对 Groovy 的规范化过程并没有结束，特别是在有些东西在 Groovy 的当前版本中（在本文发布时是 JSR-2）仍然不起作用的情况下。例如，在新的 Groovy 中，不能用 do/while 循环。此外，新的 Groovy 还无法完全支持 Java 5.0 的 for 循环概念。结果是，可以使用 in 语法，但是不能使用新推出的 : 语法。

这些都是重要的特性，不能没有，但是不用担心 —— Groovy 小组正在努力工作，争取在未来几个月内实现它们。请参阅 参考资料，下载最新的发行版本，并学习更多关于 JSR Groovy 进程的内容；还请继续关注下个月的“实战 Groovy”，下个月我（和两个客座专栏作家）将深入讨论 Groovy 闭包的更精彩的细节。

Andrew Glover (aglover@vanwardtechnologies.com), CTO, Vanward Technologies

2005 年 6 月 13 日

您有没有想过在自己相对复杂的 Java 程序中嵌入 Groovy 简单的、易于编写的脚本呢？在这一期 实战 Groovy 系列文章中，Andrew Glover 将介绍把 Groovy 集成到 Java 代码中的多种方法，并解释在什么地方、什么时候适合这么做。

如果您一直在阅读这个系列，那么您应该已经看到有各种各样使用 Groovy 的有趣方式，Groovy 的主要优势之一就是它的生产力。Groovy 代码通常要比 Java 代码更容易编写，而且编写起来也更快，这使得它有足够的资格成为开发工作包中的一个附件。在另一方面，正如我在这个系列中反复强调的那样，Groovy 并不是 —— 而且也不打算成为 —— Java 语言的替代。所以，这里存在的问题是，能否把 Groovy 集成到 Java 的编程实践中？或者说这样做有什么用？什么时候 这样做有用？

这个月，我将尝试回答这个问题。我将从一些熟悉的事物开始，即从如何将 Groovy 脚本编译成与 Java 兼容的类文件开始，然后进一步仔细研究 Groovy 的编译工具（groovyc）是如何让这个奇迹实现的。了解 Groovy 在幕后做了什么是在 Java 代码中使用 Groovy 的第一步。

注意，本月示例中演示的一些编程技术是 Groovlets 框架和 Groovy 的 GroovyTestCase 的核心，这些技术我在前面的文章中已经讨论过。

天作之合？

在本系列中以前的文章中，当我介绍如何 用 Groovy 测试普通 Java 程序 的时候，您可能已经注意到一些奇怪的事：我 编译了 那些 Groovy 脚本。实际上，我将 groovy 单元测试编译成普通的 Java .class 文件，然后把它们作为 Maven 构建的一部分来运行。

这种编译是通过调用 groovyc 命令进行的，该命令将 Groovy 脚本编译成普通的 Java 兼容的 .class 文件。例如，如果脚本声明了一个类，那么调用 groovyc 会生成至少三个 .class 。文件本身会遵守标准的 Java 规则：.class 文件名称要和声明的类名匹配。

作为示例，请参见清单 1，它创建了一个简单的脚本，脚本声明了几个类。然后，您自己就可以看出 groovyc 命令生成的结果：

package com.vanward.groovy
class Person {
  fname
  lname
  age
  address
  contactNumbers
  String toString(){

    numstr = new StringBuffer()
    if (contactNumbers != null){
     contactNumbers.each{
       numstr.append(it)
       numstr.append(" ")
     }
    }
    "first name: " + fname + " last name: " + lname + 
    " age: " + age + " address: " + address + 
    " contact numbers: " + numstr.toString()
  }
}
class Address {
  street1
  street2
  city
  state
  zip
  String toString(){
   "street1: " + street1 + " street2: " + street2 +
     " city: " + city + " state: " + state + " zip: " + zip
  }
}
class ContactNumber {
  type
  number
  String toString(){
   "Type: " + type + " number: " + number 
  }
}
nums = [new ContactNumber(type:"cell", number:"555.555.9999"), 
	new ContactNumber(type:"office", number:"555.555.5598")]
addr = new Address(street1:"89 Main St.", street2:"Apt #2", 
	city:"Utopia", state:"VA", zip:"34254")
pers = new Person(fname:"Mollie", lname:"Smith", age:34, 
	address:addr, contactNumbers:nums)
println pers.toString()

在清单 1 中，我声明了三个类 —— Person、Address 和 ContactNumber。之后的代码根据这些新定义的类型创建对象，然后调用 toString() 方法。迄今为止，Groovy 中的代码还非常简单，但现在来看一下清单 2 中 groovyc 产生什么样的结果：

aglover@12d21 /cygdrive/c/dev/project/target/classes/com/vanward/groovy
$ ls -ls  
total 15
 4 -rwxrwxrwx+ 1 aglover  user   3317 May  3 21:12 Address.class
 3 -rwxrwxrwx+ 1 aglover  user   3061 May  3 21:12 BusinessObjects.class
 3 -rwxrwxrwx+ 1 aglover  user   2815 May  3 21:12 ContactNumber.class
 1 -rwxrwxrwx+ 1 aglover  user   1003 May  3 21:12 
   Person$_toString_closure1.class
 4 -rwxrwxrwx+ 1 aglover  user   4055 May  3 21:12 Person.class

哇！五个 .class 文件！我们了解 Person、Address 和 ContactNumber 文件的意义，但是其他两个文件有什么作用呢？

研究发现，Person$_toString_closure1.class 是 Person 类的 toString() 方法中发现的闭包的结果。它是 Person 的一个内部类，但是 BusinessObjects.class 文件是怎么回事 —— 它可能是什么呢？

对 清单 1 的深入观察指出：我在脚本主体中编写的代码（声明完三个类之后的代码）变成一个 .class 文件，它的名称采用的是脚本名称。在这个例子中，脚本被命名为 BusinessObjects.groovy，所以，类定义中没有包含的代码被编译到一个名为 BusinessObjects 的 .class 文件。

反编译

反编译这些类可能会非常有趣。由于 Groovy 处于代码顶层，所以生成的 .java 文件可能相当巨大；不过，您应当注意的是 Groovy 脚本中声明的类（如 Person） 与类之外的代码（比如 BusinessObjects.class 中找到的代码）之间的区别。在 Groovy 文件中定义的类完成了 GroovyObject 的实现，而在类之外定义的代码则被绑定到一个扩展自 Script 的类。

例如，如果研究由 BusinessObjects.class 生成的 .java 文件，可以发现：它定义了一个 main() 方法和一个 run() 方法。不用惊讶， run() 方法包含我编写的、用来创建这些对象的新实例的代码，而 main() 方法则调用 run() 方法。

这个细节的全部要点再一次回到了：对 Groovy 的理解越好，就越容易把它集成到 Java 程序中。有人也许会问：“为什么我要这么做呢？”好了，我们想说您用 Groovy 开发了一些很酷的东西；那么如果能把这些东西集成到 Java 程序中，那不是很好吗？

只是为了讨论的原因，我首先试图 用 Groovy 创建一些有用的东西，然后我再介绍把它嵌入到普通 Java 程序中的各种方法。

再制作一个音乐 Groovy

我热爱音乐。实际上，我的 CD 收藏超过了我计算机图书的收藏。多年以来，我把我的音乐截取到不同的计算机上，在这个过程中，我的 MP3 收藏乱到了这样一种层度：只是表示品种丰富的音乐目录就有一大堆。

最近，为了让我的音乐收藏回归有序，我采取了第一步行动。我编写了一个快速的 Groovy 脚本，在某个目录的 MP3 收藏上进行迭代，然后把每个文件的详细信息（例如艺术家、专辑名称等）提供给我。脚本如清单 3 所示：

package com.vanward.groovy
import org.farng.mp3.MP3File
import groovy.util.AntBuilder
class Song {

  mp3file
  Song(String mp3name){   
    mp3file = new MP3File(mp3name)   
  }
  getTitle(){
    mp3file.getID3v1Tag().getTitle()
  }
  getAlbum(){
    mp3file.getID3v1Tag().getAlbum()
  }
  getArtist(){
    mp3file.getID3v1Tag().getArtist()
  }
  String toString(){
    "Artist: " + getArtist() + " Album: " + 
      getAlbum() + " Song: " + getTitle()
  }
  static getSongsForDirectory(sdir){
    println "sdir is: " + sdir
    ant = new AntBuilder()
    scanner = ant.fileScanner {
       fileset(dir:sdir) {
         include(name:"**/*.mp3")
       }
    }
    songs = []
    for(f in scanner){   
      songs << new Song(f.getAbsolutePath())   
    }
    return songs
  }
}
songs = Song.getSongsForDirectory(args[0])
songs.each{
 println it
}

正如您所看到的，脚本非常简单，对于像我这样的人来说特别有用。而我要做的全部工作只是把某个具体的目录名传递给它，然后我就会得到该目录中每个 MP3 文件的相关信息（艺术家名称、歌曲名称和专辑） 。

现在让我们来看看，如果要把这个干净的脚本集成到一个能够通过数据库组织音乐甚至播放 MP3 的普通 Java 程序中，我需要做些什么。

Class 文件是类文件

正如前面讨论过的，我的第一个选项可能只是用 groovyc 编译脚本。在这个例子中，我期望 groovyc 创建 至少 两个 .class 文件 —— 一个用于 Song 类，另一个用于 Song 声明之后的脚本代码。

实际上，groovyc 可能创建 5 个 .class 文件。这是与 Songs.groovy 包含三个闭包有关，两个闭包在 getSongsForDirectory() 方法中，另一个在脚本体中，我在脚本体中对 Song 的集合进行迭代，并调用 println。

因为 .class 文件中有三个实际上是 Song.class 和 Songs.class 的内部类，所以我只需要把注意力放在两个 .class 文件上。Song.class 直接映射到 Groovy 脚本中的 Song 声明，并实现了 GroovyObject，而 Songs.class 则代表我在定义 Song 之后编写的代码，所以也扩展了 Script。

此时此刻，关于如何把新编译的 Groovy 代码集成到 Java 代码，我有两个选择：可以通过 Songs.class 文件中的 main() 方法运行代码 （因为它扩展了 Script），或者可以将 Song.class 包含到类路径中，就像在 Java 代码中使用其他对象一样使用它。

变得更容易些

通过 java 命令调用 Songs.class 文件非常简单，只要您记得把 Groovy 相关的依赖关系和 Groovy 脚本需要的依赖关系包含进来就可以。把 Groovy 需要的类全都包含进来的最简单方法就是把包含全部内容的 Groovy 可嵌入 jar 文件添加到类路径中。在我的例子中，这个文件是 groovy-all-1.0-beta-10.jar。要运行 Songs.class，需要记得包含将要用到的 MP3 库（jid3lib-0.5.jar>），而且因为我使用 AntBuilder，所以我还需要在类路径中包含 Ant。清单 4 把这些放在了一起：

c:\dev\projects>java -cp  ./target/classes/;c:/dev/tools/groovy/
  groovy-all-1.0-beta-10.jar;C:/dev/tools/groovy/ant-1.6.2.jar;
  C:/dev/projects-2.0/jid3lib-0.5.jar  
  com.vanward.groovy.Songs c:\dev09\music\mp3s
Artist: U2 Album: Zooropa Song: Babyface
Artist: James Taylor Album: Greatest Hits Song: Carolina in My Mind
Artist: James Taylor Album: Greatest Hits Song: Fire and Rain
Artist: U2 Album: Zooropa Song: Lemon
Artist: James Taylor Album: Greatest Hits Song: Country Road
Artist: James Taylor Album: Greatest Hits Song: Don't Let Me 
  Be Lonely Tonight
Artist: U2 Album: Zooropa Song: Some Days Are Better Than Others
Artist: Paul Simon Album: Graceland Song: Under African Skies
Artist: Paul Simon Album: Graceland Song: Homeless
Artist: U2 Album: Zooropa Song: Dirty Day
Artist: Paul Simon Album: Graceland Song: That Was Your Mother

把 Groovy 嵌入 Java 代码

虽然命令行的解决方案简单有趣，但它并不是所有问题的最终解决方案。如果对更高层次的完善感兴趣，那么可能将 MP3 歌曲工具直接导入 Java 程序。在这个例子中，我想导入 Song.class ，并像在 Java 语言中使用其他类那样使用它。类路径的问题与上面相同 ：我需要确保包含了 uber-Groovy jar 文件、Ant 和 jid3lib-0.5.jar 文件。在清单 5 中，可以看到如何将 Groovy MP3 工具导入简单的 Java 类中：

package com.vanward.gembed;
import com.vanward.groovy.Song;
import java.util.Collection;
import java.util.Iterator;
public class SongEmbedGroovy{
 public static void main(String args[]) {
  Collection coll = (Collection)Song.getSongsForDirectory
    ("C:\\music\\temp\\mp3s");
  for(Iterator it = coll.iterator(); it.hasNext();){
    System.out.println(it.next());
  }	
 }
}

Groovy 类加载器

就在您以为自己已经掌握全部的时候，我要告诉您的是，还有更多在 Java 语言中使用 Groovy 的方法。除了通过直接编译把 Groovy 脚本集成到 Java 程序中的这个选择之外，当我想直接嵌入脚本时，还有其他一些选择。

例如，我可以用 Groovy 的 GroovyClassLoader ，动态地 加载一个脚本并执行它的行为，如清单 6 所示：

package com.vanward.gembed;
import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyObject;
import groovy.lang.MetaMethod;
import java.io.File;
public class CLEmbedGroovy{
 public static void main(String args[]) throws Throwable{

  ClassLoader parent = CLEmbedGroovy.class.getClassLoader();
  GroovyClassLoader loader = new GroovyClassLoader(parent);

  Class groovyClass = loader.parseClass(
    new File("C:\\dev\\groovy-embed\\src\\groovy\\
      com\\vanward\\groovy\\Songs.groovy"));

  GroovyObject groovyObject = (GroovyObject) 
    groovyClass.newInstance();

  Object[] path = {"C:\\music\\temp\\mp3s"};
  groovyObject.setProperty("args", path);
  Object[] argz = {};

  groovyObject.invokeMethod("run", argz);

 }
}

Meta，宝贝 如果您属于那群疯狂的人中的一员，热爱反射，喜欢利用它们能做的精彩事情，那么您将热衷于 Groovy 的 Meta 类。就像反射一样，使用这些类，您可以发现 GroovyObject 的各个方面（例如它的方法），这样就可以实际地 创建 新的行为并执行它。而且，这是 Groovy 的核心 —— 想想运行脚本时它将如何发威吧！

注意，默认情况下，类加载器将加载与脚本名称对应的类 —— 在这个例子中是 Songs.class，而不是 Song.class>。因为我（和您）知道 Songs.class 扩展了 Groovy 的 Script 类，所以不用想也知道接下来要做的就是执行 run() 方法。

您记起，我的 Groovy 脚本也依赖于运行时参数。所以，我需要恰当地配置 args 变量，在这个例子中，我把第一个元素设置为目录名。

更加动态的选择

对于使用编译好的类，而且，通过类加载器来动态加载 GroovyObject 的替代，是使用 Groovy 优美的 GroovyScriptEngine 和 GroovyShell 动态地执行 Groovy 脚本。

把 GroovyShell 对象嵌入普通 Java 类，可以像类加载器所做的那样动态执行 Groovy 脚本。除此之外，它还提供了大量关于控制脚本运行的选项。在清单 7 中，可以看到 GroovyShell 嵌入到普通 Java 类的方式：

package com.vanward.gembed;
import java.io.File;
import groovy.lang.GroovyShell;
public class ShellRunEmbedGroovy{
 public static void main(String args[]) throws Throwable{

  String[] path = {"C:\\music\\temp\\mp3s"};		
  GroovyShell shell = new GroovyShell();
  shell.run(new File("C:\\dev\\groovy-embed\\src\\groovy\\
    com\\vanward\\groovy\\Songs.groovy"), 
    path);
 }
}

可以看到，运行 Groovy 脚本非常容易。我只是创建了 GroovyShell 的实例，传递进脚本名称，然后调用 run() 方法。

还可以做其他事情。如果您喜欢，那么也可以得到自己脚本的 Script 类型的 GroovyShell 实例。使用 Script 类型，您就可以传递进一个 Binding 对象，其中包含任何运行时值，然后再继续调用 run() 方法，如清单 8 所示：

package com.vanward.gembed;
import java.io.File;
import groovy.lang.Binding;
import groovy.lang.GroovyShell;
import groovy.lang.Script;
public class ShellParseEmbedGroovy{
 public static void main(String args[]) throws Throwable{
  GroovyShell shell = new GroovyShell();
  Script scrpt = shell.parse(
    new File("C:\\dev\\groovy-embed\\src\\groovy\\
      com\\vanward\\groovy\\Songs.groovy"));

  Binding binding = new Binding();
  Object[] path = {"C:\\music\\temp\\mp3s"};
  binding.setVariable("args",path);			
  scrpt.setBinding(binding);

  scrpt.run();
 }
}

Groovy 的脚本引擎

GroovyScriptEngine 对象动态运行脚本的时候，非常像 GroovyShell。区别在于：对于 GroovyScriptEngine，您可以在实例化的时候给它提供一系列目录，然后让它根据要求去执行多个脚本，如清单 9 所示：

package com.vanward.gembed;
import java.io.File;
import groovy.lang.Binding;
import groovy.util.GroovyScriptEngine;
public class ScriptEngineEmbedGroovy{
 public static void main(String args[]) throws Throwable{

  String[] paths = {"C:\\dev\\groovy-embed\\src\\groovy\\
    com\\vanward\\groovy"};
  GroovyScriptEngine gse = new GroovyScriptEngine(paths);
  Binding binding = new Binding();
  Object[] path = {"C:\\music\\temp\\mp3s"};
  binding.setVariable("args",path);

  gse.run("Songs.groovy", binding);
  gse.run("BusinessObjects.groovy", binding);
 }
}

在清单 9 中，我向实例化的 GroovyScriptEngine 传入了一个数组，数据中包含我要处理的路径，然后创建大家熟悉的 Binding 对象，然后再执行仍然很熟悉的 Songs.groovy 脚本。只是为了好玩，我还执行了BusinessObjects.groovy 脚本，您或许还能回忆起来，它在开始这次讨论的时候出现过。

Bean 脚本框架

最后，当然并不是最不重要的，是来自 Jakarta 的古老的 Bean 脚本框架（ Bean Scripting Framework —— BSF）。BSF 试图提供一个公共的 API，用来在普通 Java 应用程序中嵌入各种脚本语言（包括 Groovy）。这个标准的、但是有争议的最小公因子方法，可以让您毫不费力地将 Java 应用程序嵌入 Groovy 脚本。

还记得前面的 BusinessObjects 脚本吗？在清单 10 中，可以看到 BSF 可以多么容易地让我把这个脚本插入普通 Java 程序中：

package com.vanward.gembed;
import org.apache.bsf.BSFManager;
import org.codehaus.groovy.runtime.DefaultGroovyMethods;
import java.io.File;
import groovy.lang.Binding;
public class BSFEmbedGroovy{
 public static void main(String args[]) throws Exception {
  String fileName = "C:\\dev\\project\\src\\groovy\\
    com\\vanward\\groovy\\BusinessObjects.groovy";
  //this is required for bsf-2.3.0
  //the "groovy" and "gy" are extensions
  BSFManager.registerScriptingEngine("groovy", 
    "org.codehaus.groovy.bsf.GroovyEngine", new 
      String[] { "groovy" });
  BSFManager manager = new BSFManager();
  //DefaultGroovyMethods.getText just returns a 
  //string representation of the contents of the file
  manager.exec("groovy", fileName, 0, 0, 
    DefaultGroovyMethods.getText(new File(fileName)));
  }
}

结束语

如果在本文中有一件事是清楚的话，那么只件事就是 Groovy 为了 Java 代码内部的重用提供了一堆选择。从把 Groovy 脚本编译成普通 Java .class 文件，到动态地加载和运行脚本，这些问题需要考虑的一些关键方面是灵活性和耦合。把 Groovy 脚本编译成普通 .class 文件是 使用 您打算嵌入的功能的最简单选择，但是动态加载脚本可以使添加或修改脚本的行为变得更容易，同时还不必在编译上牺牲时间。（当然，这个选项只是在接口不变的情况下才有用。）

把脚本语言嵌入普通 Java 不是每天都发生，但是机会确实不断出现。这里提供的示例把一个简单的目录搜索工具嵌入到基于 Java 的应用程序中，这样 Java 应用程序就可以很容易地变成 MP3 播放程序或者其他 MP3 播放工具。虽然我 可以 用 Java 代码重新编写 MP3 文件搜索器，但是我不需要这么做：Groovy 极好地兼容 Java 语言，而且，我很有兴趣去摆弄所有选项！

2005 年 4 月 12 日

Groovy 生成器让您能够利用诸如 Swing 这样的框架来模拟标记语言（如 XML、HTML、Ant） 任务以及 GUI。它们对于快速原型化非常有 用，并且正像 Andrew Glover 这个月在“实战 Groovy”专栏中向您展示的那样，当您马上需要可消费的标记时，它们是数据绑定框架的一种便利的替代方案。

几个月前，当我最初撰写有关 实战 Groovy: 用 Groovy 进行 Ant 脚本编程 的文章时，我提及了 Groovy 中的生成器 概念。在那篇文章里，我向您展示了，使用一个叫做 AntBuilder 的 Groovy 类，构建富有表现力的 Ant 构建文件是多么容易。本文中，我将深入 Groovy 生成器的世界，向您展示您还能用这些强大的类做些什么。

用生成器进行构建

Groovy 生成器让您能够利用诸如 Swing 这样的框架来模拟标记语言（如 XML、HTML、Ant） 任务以及 GUI。使用生成器，您可以迅速地创 建复杂的标记（如 XML），而无须理会 XML 本身。

生成器的范例非常简单。生成器的实例的方法表示该标记（如 HTML 中的 <body> 标 签）的元素。方法的创建于闭包中的对象表示子节点（例如，<body> 标签中所包含的 <p> 标签）。

为了便于您查看这一过程，我将创建一个简单的生成器，以程序方式来表示一个具有清单 1 所示结构的 XML 文档。

 <person>
   <name first="Megan" last="Smith">
     <age>32</age>
     <gender>female</gender>
   </name>
   <friends>
     <friend>Julie</friend>
     <friend>Joe</friend>
     <friend>Hannah</friend>
   </friends>
 </person>

要表示这个结构非常简单。首先将 person 方法连接到生成器实例，现在它表示 XML 的根节点，即 <person>。要创建子节点，我创建一个闭包并声明一个名叫 name 的新对象（它接收 map 形式的参数。顺便说一下，这些参数是元素的属性的基础。

接下来，在 name 对象中，将两个附加对象连接到闭包，一个对象是 age，另 一个是 gender，它们对应于 <name> 的类似子元素。您明白其中的诀窍了么？确实很简单。

<friends> 元素是 <person> 的兄弟元素，于是我跳出这个闭包，声明了一个 friends 对象，当然，还附加了一个集合了多个 friend 元素的闭包，如清单 2 所示。

import groovy.xml.*
import java.io.*
class XMLBuilder{

  static void main(args) {

    writer = new StringWriter()	 	
    builder = new MarkupBuilder(writer)
    friendnames = [ "Julie", "Joey", "Hannah"]

	builder.person() {
       name(first:"Megan", last:"Smith") {
         age("33")
         gender("female")
       }
       friends() {
         for (e in friendnames) { friend(e) }
       }
    }
    println writer.toString()
  }
}

如您所见，这里的 Groovy 表示非常优雅，且易于映射到相应的标记表示。在底层，Groovy 显然在处理烦人的标记元素（如 < and >），使我们可以将更多精力放在内容上，而不必过分在意结构的细节。

显示 HTML

生成器也可以有助于构建 HTML，这在开发 Groovlet 时可以派上用场。如同小菜一碟，假设我要创建一个如清单 3 所示的 HTML 页面。

 <html>
  <head>
   <title>Groov'n with Builders</title>
  </head>
  <body>
   <p>Welcome to Builders 101. As you can see this Groovlet is fairly simple.</p>
  </body>
 </html>

我可以轻易地将它编码在 Groovy 中，清单 4 所示。

import groovy.xml.*
import java.io.*
class HTMLBuilderExample{

  static void main(args) {
   writer = new StringWriter()	 	
   builder = new MarkupBuilder(writer)

   builder.html(){
     head(){
       title("Groov'n with Builders"){}
     }
     body(){
       p("Welcome to Builders 101. As you can see " +
         "this Groovlet is fairly simple.") 
     }
   }
   println writer.toString()
}

来点有意思的，让我们再看看用生成器建立一个成熟的 GUI 有多么容易。前面我曾提到过，Groovy 的 SwingBuilder 使它能够以一种极为简单的方式构造 GUI。您可以查阅清单 5 中 SwingBuilder 是如何工作的。

import java.awt.FlowLayout
import javax.swing.*
import groovy.swing.SwingBuilder
class SwingExample{

  static void main(args) {
    swinger = new SwingBuilder()
    langs = ["Groovy", "Ruby", "Python", "Pnuts"]

	gui = swinger.frame(title:'Swinging with Groovy!', size:[290,100]) {
      panel(layout:new FlowLayout()) {
        panel(layout:new FlowLayout()) {
          for (lang in langs) {
            checkBox(text:lang)
          }
        }
        button(text:'Groovy Button', actionPerformed:{ 
          swinger.optionPane(message:'Indubitably Groovy!').createDialog(null, 'Zen Message').show()
        })
        button(text:'Groovy Quit', actionPerformed:{ System.exit(0)})
     }
   }
   gui.show()
   }
}

图 1 显示了上面的结果，还不错吧？

可以想像，对于原型化，SwingBuilder 是一个多么强大的工具，不是么？

一些事实

这 些例子虽然琐碎，却也有趣。我希望我能让您明白，Groovy 的生成器可以让您避免特定语言（如 XML）中的底层标记。显然，有时避免 XML 或 HTML 会更好，并且，那些标记协助器（facilitator）对 Java 平台来说并不陌生。例如，我最喜欢的 XML 协助框架是 JiBX。

使用 JiBX，您可以轻易地将 XML 结构映射到对象模型，反之亦然。绑定是个强大的范例，有不计其数的类似工具拥有此功能，如 JAXB、 Castor 和 Zeus 等。

绑定框架的惟一缺点是，它们恐怕 要耗费不少时间。幸运的是，您可以使用 Groovy 的生成器作为一个较简单的 解决方案，这在某些情况下是有效的。

用生成器进行伪绑定

假设有一个英文词典的简单数据库。有一个表用于 word，另一个表用于 definition ，最后还有一个表用于 synonym。图 2 是这个数据库的简单表示。

如您所见，这个数据库非常直观：word 与 definition 和 synonym 具有一对多的关系。

词典数据库拥有一个消费者，他在寻求一种表示数据库内容的关键方面的 XML 结构。所寻求的 XML 结构如清单 6 所示。

<words>
  <word spelling="glib" partofspeech="adjective">
    <defintions>
      <defintion>Performed with a natural, offhand ease.</defintion>
      <defintion>Marked by ease and fluency of speech or writing that often suggests 
	  or stems from insincerity, superficiality, or deceitfulness</defintion>
    </defintions>
    <synonyms>
      <synonym spelling="artful"/> 
      <synonym spelling="urbane"/> 
    </synonyms>
  </word>	
</words>

如果选择使用 JiBX 这样的绑定框架来解决这个问题，则很可能需要创建一些中间对象模型，以从关系模型到达最终的 XML 模型。然后必须将数据库内容读取到对象模型中，并请求底层框架将其内部的结构编组为 XML 格式。

这一过程内含了将对象结构映射到 XML 格式的步骤（使用所需的框架过程）。某些框架，如 JAXB，实际上是从 XML 和其他框架（如 JiBX ）生成 Java 对象，允许您自定义自己的 Java 对象到 XML 格式的映射。总之，这都需要大量的工作。

并且，这是一项宏伟的计划。我并不提倡避免使用绑定框架。这里，我要声明：我已经预先警告过您。我计划向您展示的是一个生成 XML 的便捷方式。

可消费的 XML 很简单

使用 Groovy 的 MarkupBuilder，结合新的数据库访问框架 GroovySql，您可以轻易地生成可消费的 XML。您 所要做的只是计算出所需的查询，并将结果映射到生成器实例 —— 然后，您马上就可以得到表示词典数据库内容的 XML 文档。

让我们逐步来了解这一过程。首先，创建一个生成器实例，在本例中是 MarkupBuilder，因为您想要生成 XML。最外面的 XML 元 素（也就是“根”）是 words，这样就创建了一个 words 方法。在闭包里， 调用第一个查询，并在迭代中将查询结果映射到 word 子节点。

接着，通过两个新的查询，创建 word 的两个子节点。创建一个 definitions 对象，并在迭代中映射它，接着用同样的方法处理 synonyms。

import groovy.sql.Sql
import groovy.xml.MarkupBuilder
import java.io.File
import java.io.StringWriter
class WordsDbReader{
  static void main(args) {
    sql = Sql.newInstance("jdbc:mysql://localhost/words", 
      "words", "words", "org.gjt.mm.mysql.Driver")
    writer = new StringWriter()	 	
    builder = new MarkupBuilder(writer)
    builder.words() {
      sql.eachRow("select word_id, spelling, part_of_speech from word"){ row |
        builder.word(spelling:row.spelling, partofspeech:row.part_of_speech){

		 builder.definitions(){
            sql.eachRow("select definition from definition where word_id = ${row.word_id}"){ defrow |
              builder.definition(defrow.definition)
            }
         }

		 builder.synonyms(){  		       		
            sql.eachRow("select spelling from synonym where word_id = ${row.word_id}"){ synrow |
              builder.synonym(synrow.spelling)
            }		       					       		
         }
       }
      }
    }
   new File("dbouuput.xml").withPrintWriter{ pwriter |
      pwriter.println writer.toString()
   }
 }
}

结束语

这里，我向您展示的绑定解决方案似乎简单得让人难以置信，特别是以 Java 纯化论者的观点看来更是如此。尽管该解决方案不比使用绑定框架（如 JABX 和 JiBX） 更好，但它确实更快一些 —— 而且，我主张使用这样较简单的方法。是不是我在简单的 Java 代码中做一些类似的事情？是的，但我敢肯定，某些时候我也不得不处理 XML。

用 Groovy 生成器进行开发的速度和简易性，在调用标记的时候可大显神威。例如，就像在第二个例子里展示的那样，我可以马上加快数据库的 XML 表示。对于原型化，或者当需要以最少的开发时间和精力来产生可工作的解决方案时，生成器也是一个不错的选择。

在下个月的实战 Groovy 中我会讲些什么呢？哦，当然是在 Java 语言中使用 Groovy！

2005 年 3 月 28 日

Groovlet 和 GroovyServer Pages（GSP）框架都是建立在 Java Servlet API 基础之上。不过，与 Strut 和 JSF 不同，Groovy 的服务器端实现不意味着适用于所有情况。相反，它提供了一种快速而又方便地开发服务器端应用程序的简化方法。下面请跟随 Groovy 的鼓吹者 Andrew Glover，听听他如何介绍这些框架，并展示它们的应用。

Java 平台为自己赢得了服务器端应用程序开发的首选平台的名声。Servlet 是服务器端 Java 技术的强大支柱，因此有无数的框架是围绕着 Servlet API 建立 起来的，其中包括 Strut、JavaServer Faces (JSF) 和 Tapestry。您可能已经猜到，Groovy 也是以 Servlet API 为基础建立起来的框架，不过，这个框架的目的是简化开发。

Groovlet 和 GroovyServer Pages（GSP）框架的目的是提供一种优雅而又简单的平台，将它用于构建复杂程度不高的 Web 应用程序。就像 GroovySql 不是数据库开发的惟一选择一样，Groovlet 框架也不是 像 Strut 那样具有更丰富功能的框架的替代品。Groovlet 只是 开发人员寻求容易配置和产生工作代码的快速方法时的一种选择。

例如，不久前，我需要 —— 快速地 —— 提供一个 stub 应用程序，以测试像 xml-rpc API 这样的客户端。显然可以用一个 servlet 快速编写出所需要的功能，但是我从没想过钻研 Strut，一秒钟也没有。我考虑过使用基本的普通 Java Servlet API 编写 servlet 及其相关的逻辑，但是由于需要尽快地使用这项功能，所以我选择了使用 Groovlet 快速完成它。

很快您就可看到，这种选择是显而易见的。

在深入研究使用 Groovlet 进行编程之前，我想简单介绍一个在示例代码中会用到的 Groovy 特性。 在几个月前的 alt.lang.jre: 感受 Groovy 一文中，我第一次介绍了 def 关键字。

在脚本中定义函数

在普通 Java 编程中，方法必须存在于类对象中。事实上，所有行为都必须在类的上 下文中定义。不过在 Groovy 中，行为可以在函数 中定义，而函数可以在类定义之外定义 。

这些函数可以直接用名称引用，并且可以在 Groovy 脚本中定义，这样非常 有助于它们的重复使用。Groovy 函数需要 def 关键字， 可以将关键字想像为在脚本范围内可用的全局静态方法。因为 Groovy 是动态类型的语言，所以 def 不需要对参数作任何类型声明，def 也不需要 return 语句。

例如，在清单 1 中，我定义了一个简单的函数，它将输出一个集合的内容，而不管这个集合是 list 还是 map。然后我定义 一个 list，填充它，并调用我新定义的 def。之后，我创建一个 map，并对这个集合做了同样的操作。

def logCollection(coll){
  counter = 0;
  coll.each{ x | 
    println "${++counter} item: ${x}"
  }
}
lst = [12, 3, "Andy", 'c']
logCollection(lst)
mp = ["name" : "Groovy", "date" : new Date()]
logCollection(mp)

def 不需要 return 语句，因此如果最后一行产生某个 值，那么这个值由 def 返回。例如，在清单 2 中，代码定义了一个 def，它返回传递进来的变量的名称。 我可以编写它，让它带有或者不带 return 语句，得到的结果是相同的。

def getJavaType(val){
  val.class.getName()
}
tst = "Test"
println getJavaType(tst)

在编写简单的脚本时，def 关键字会非常好用。您很快就会看到，在开发 Groovlet 时，这个关键字也会派上用场。

Groovlet 和 GSP

使用 Groovlet 和 GSP 的前提条件相当简单：需要一个 servlet 容器，以及最新、最伟大 版本的 Groovy。这些框架的好处是它们通过一个 web.xml 文件将所选模式的所有 URL 映射到特定的 servlet。因此， 建立 Groovlet 和 GSP 的实现的第一步是定义一个 Web 应用程序上下文，并更新它的相关 web.xml 文件。 这个文件将包括特定的 servlet 类定义以及它们对应的 URL 模式。

我将使用 Apache Jakarta Tomcat，并且已创建了一个名为 groove 的上下文。目录结构如清单 3 所示：

./groove:
drwxrwxrwx+   3 aglover  users        0 Jan 19 12:14 WEB-INF
./WEB-INF:
-rwxrwxrwx+   1 aglover  users      906 Jan 16 14:37 web.xml
drwxrwxrwx+   2 aglover  users        0 Jan 19 17:12 lib
./WEB-INF/lib:
-rwxrwxrwx+   1 aglover  users   832173 Jan 16 14:28 groovy-1.0-beta-9.jar
-rwxrwxrwx+   1 aglover  users    26337 Jan 16 14:29 asm-1.5.2.jar

在 WEB-INF 目录中要有一个 web.xml 文件，它至少有一个清单 4 中的元素：

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation=
    "http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">
    <servlet>
      <servlet-name>GroovyServlet</servlet-name>
      <servlet-class>groovy.servlet.GroovyServlet</servlet-class>
    </servlet>
    <servlet>
        <servlet-name>GroovyTemplate</servlet-name>
        <servlet-class>groovy.servlet.TemplateServlet</servlet-class>    
	</servlet>
    <servlet-mapping>
        <servlet-name>GroovyServlet</servlet-name>
        <url-pattern>*.groovy</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>GroovyTemplate</servlet-name>
        <url-pattern>*.gsp</url-pattern>
    </servlet-mapping>
</web-app>

上述 web.xml 文件中的定义声明了以下内容：所有以 .groovy 结尾的请求（如 http://localhost:8080/groove/hello.groovy）都将发送给 类 groovy.servlet.GroovyServlet， 而所有以 .gsp 结尾的请求 都将送给类 groovy.servlet.TemplateServlet。

下一步是将两个 jar 放到 lib 目录中：groovy 发行版本的 jar（在这里是 groovy-1.0-beta-9.jar）和 对应的 asm jar （对于 groovy beta-9 来说是 asm-1.5.2.jar）。

瞧，就是这么简单 —— 我已经准备好了。

Groovlet，请出场

编写 Groovlet 无疑很简单，因为 Groovy 只有很少的几个 对类继承扩展的要求。使用 Groovlet 不需要扩展 javax.servlet.http.HttpServlet、javax.servlet.GenericServlet 或者一些华而不实的 GroovyServlet 类。事实上，创建 Groovlet 就像创建一个 Groovy 脚本一样简单。甚至不必 创建一个类。在清单 5 中，我编写了一个简单的 Groovlet，它 做两件事：打印一些 HTML，然后提供一些关于它所在的容器的信息。

println """
<html><head>
<title>Groovlets 101</title>
</head>
<body>
<p>
Welcome to Groovlets 101. As you can see
this Groovlet is fairly simple.
</p>
<p>
This course is being run on the following servlet container: </br>
${application.getServerInfo()}
</p>
</body>
</html>
"""

如果在浏览器中观看这个 Groovy，它看起来与图 1 所示类似。

仔细观察清单 5 中的 Groovlet，会让您回想起第一次编写 Groovy 脚本的时候。 首先，没有 main 方法或者类定义，只有一些简单的代码。而且，Groovlet 框架隐式地提供实例变量，比如 ServletRequest、ServletResponse、ServletContext 和 HttpSession。注意我是如何通过 application 变量引用 ServletContext 的实例的。如果想获得 HttpSession 的实例，那么就要使用 session 变量名。与此类似，可以对 ServletRequest 和 ServletResponse 分别使用 request 和 response。

一个诊断 Groovlet

编写 Groovlet 不仅像创建一个 Groovy 脚本那样简单，而且还可以用 def 关键字定义函数，并在 Groovlet 中直接调用它们。为了展示这一点，我将 创建一个非凡的 Groovlet，它将对 Web 应用程序进行一些诊断。

假设您编写了一个 Web 应用程序，它被世界上不同的客户所购买。您有一个 大客户群，并且不断发布这个应用程序有一段时间了。从过去的支持问题中，您 注意到许多急切的客户电话都与错误的 JVM 版本和错误的对象关系映射（ORM）所导致的问题有关。

您很忙，所以让我拿出一个解决方案。我用 Groovlet 迅速地 创建了一个简单的 诊断脚本，它将验证 VM 版本，并试图创建一个 Hibernate 会话（请参阅参考资料）。我首先创建 两个函数，并在浏览器连接脚本时调用它们。 清单 6 定义了这个诊断 Groovlet：

import com.vanward.resource.hibernate.factory.DefaultHibernateSessionFactory
/**
 * Tests VM version from environment- note, even 1.5 will
 * cause an assertion error.
 */
def testVMVersion(){
  println "<h3>JVM Version Check: </h3>"
  vers = System.getProperty("java.version")
  assert vers.startsWith("1.4"): "JVM must be at least 1.4"
  println "<p>JVM version: ${vers} </p>"
}
/**
 * Attempts to create an instance of a hibernate session. If this
 * works we have a connection to a database; additionally, we 
 * have a properly configured hibernate instance.
 */
def testHibernate(){
  println "<h3>Hibernate Configuration Check: </h3>"
  try{
    sessFactory = DefaultHibernateSessionFactory.getInstance()
    session = sessFactory.getHibernateSession()
    assert session != null: "Unable to create hibernate session. 
    Session was null"
    println "<p>Hibernate configuration check was successful</p>"
  }catch(Throwable tr){
    println """
    <p>Unable to create hibernate session. Exception type is: <br/>
    <i>${tr.toString()} </i><br/>		
    </p>
    """
  }   
}
println """
<html><head>
<title>Diagnostics Check</title></head>
<body>
"""
testVMVersion()
testHibernate()
println """
</body></html>
"""

这个 Groovlet 的验证逻辑非常简单，但是它可以完成这项工作。只要将 诊断脚本绑定到 web 应用程序即可，当客户服务台收到电话时，它们将指点客户用浏览器 访问 Diagnostics.groovy 脚本，并让这些脚本报告它们的发现。 结果可能看起来像图 2 这样。

那些 GSP 呢？

到目前为止，我主要关注于编写 Groovlet。不过，正如您将会看到的那样， 很容易用 Groovy 的 GSP 页对 Groovlets 框架进行补充，就像 JSP 补充 Servlet API 一样。

表面上，GSP 看起来很像 JSP，实际上它们不可能有太大的差别，因为 GSP 框架其实就是一个模板引擎。如果不熟悉模板引擎，那么可能需要快速地 回顾一下上月的文章。

虽然 GSP 和 JSP 是根本不同的技术，但是 GSP 是加入表达 Web 应用程序的视图的很 好候选人，这一点它们是类似的。您可能会想起来，在上月的文章中，有一项促进视图的技术可以将应用程序的业务逻辑问题与其相应的视图分离。 如果快速查看一下清单 6 中的诊断 Groovlet，就可以看出 GSP 代码改进了哪些地方。

是的，Groovlet 有些简陋，不是吗？问题在于它混合了应用程序逻辑和大量输出 HTML 的 println。幸运的是，可以通过创建一个简单的 GSP 来补充这个 Groovlet，从而解决这个问题。

示例 GSP

创建 GSP 与创建 Groovlet 一样容易。GSP 开发的关键是认识到 GSP 实质上 是一个模板，因此，它最适合有限的逻辑。我将在清单 7 中创建一个 简单的 GSP 作为开始：

<html>
<head><title>index.gsp</title></head>
<body>
<b><% println "hello gsp" %></b>
<p>
<% wrd = "Groovy"
   for (i in wrd){ 
 %>
 <h1> <%=i%> <br/>

 <%} %>
</p>
</body>
</html>

观察上面的 GSP 可能很容易让您回想起标准 Groovy 模板开发。 像 JSP 一样，它使用 <%， 但是， 与 Groovlet 框架类似，它允许您访问常用 servlet 对象，比如 ServletRequest、ServletResponse、ServletContext 和 HttpSession 对象。

重构应用程序 ...

在练习编程语言或者平台发展的时候，重构老的代码可以学到很多东西。我将重构一月份专栏中的简单报告应用程序，那时候您才刚开始学习 GroovySql。

您还记得吗，我构建了一个快速但不完善的报告应用程序，它可以在组织中有 多次使用。但结果是，它变成了研究公司数据库活动的相当流行的应用程序。 现在，非技术人员希望可以访问这个巨大的报告，但是他们不想很费事地在自已的 计算机上安装 Groovy 来运行它。

我多少预计到了这种情况的发生，解决方案实际上 是显而易见的：让报告应用程序支持 Web。很幸运，Groovlet 和 GSP 使重构变成小事一桩。

重构报告应用程序

首先，我将处理 > GroovySql 一文的清单 12 中的简单应用程序。重构这个应用程序很容易：只要将所有 println 替换成用 setAttribute() 方法，然后将实例变量放入 HttpRequest 对象的逻辑中即可。

下一步是用 RequestDispatcher 将 request 转发给 GSP，它会处理报告应用程序的视图部分。清单 8 定义了新的报告 Groovlet：

import groovy.sql.Sql
/**
 * forwards to passed in page
 */
def forward(page, req, res){
  dis = req.getRequestDispatcher(page);
  dis.forward(req, res);
}
sql = Sql.newInstance("jdbc:mysql://yourserver.anywhere/tiger", "scott",
        "tiger", "org.gjt.mm.mysql.Driver")

uptime = null
questions = null
insertnum = null
selectnum = null
updatenum = null
sql.eachRow("show status"){ status |
  if(status.variable_name == "Uptime"){
         uptime =  status[1]
	 request.setAttribute("uptime", uptime)
  }else if (status.variable_name == "Questions"){
         questions =  status[1]
	 request.setAttribute("questions", questions)
  }
}
request.setAttribute("qpm", Integer.valueOf(questions) / 
Integer.valueOf(uptime) )
sql.eachRow("show status like 'Com_%'"){ status |
    if(status.variable_name == "Com_insert"){
         insertnum =  Integer.valueOf(status[1])
    }else if (status.variable_name == "Com_select"){
         selectnum =  Integer.valueOf(status[1])
    }else if (status.variable_name == "Com_update"){
          updatenum =  Integer.valueOf(status[1])
    }
}
request.setAttribute("qinsert", 100 * (insertnum / Integer.valueOf(uptime)))
request.setAttribute("qselect", 100 * (selectnum / Integer.valueOf(uptime)))
request.setAttribute("qupdate", 100 * (updatenum / Integer.valueOf(uptime)))
forward("mysqlreport.gsp", request, response)

清单 8 中的代码应当是您相当熟悉的。我只是将以前应用程序中的所有 println 替换掉，并添加了 forward 函数来处理报告的视图部分。

添加视图部分

下一步是创建 GSP 来处理报告应用程序的视图。 因为我是工程师而不是一个艺术家，所以我的视图是相当 简单的 —— 一些 HTML 加上一个表，如清单 9 所示：

<html><head>
<title>MySql Health Report</title>
</head>
<body>
<table>
<tr>
  <td>Database Uptime:</td><td><% println
  "${request.getAttribute("uptime")}" %></td>
</tr>
<tr>
  <td>Number of Queries:</td><td><% println
  "${request.getAttribute("questions")}" %></td>
</tr>
<tr>
  <td>Queries per Minute =</td><td><% println
  "${request.getAttribute("qpm")}" %></td>
</tr>
<tr>
  <td>% Queries Inserts =</td><td><% println
  "${request.getAttribute("qinsert")}" %></td>
</tr>
<tr>
  <td>% Queries Selects =</td><td><% println
  "${request.getAttribute("qselect")}" %></td>
</tr>
<tr>
  <td>% Queries Updates =</td><td><% println
  "${request.getAttribute("qupdate")}" %></td>
</tr>
</table>
</body>
</html>

运行新的报告应当生成如图 3 所示的输出，数字会有变化。

结束语

如您所见，当所需要的功能相当简单并且需要尽快完成时，Groovlet 和 GSP 是进行服务器端开发的当然之选。 这两个框架都特别灵活，并且其代码到视图的转化时间事实上是无可匹敌的。

不过，需要强调的是，Groovlet 不是 Strut 的替代品。GSP 框架不是直接 在速度上与其他产品竞争。GroovySql 不是 Hibernate 的替代品。而 Groovy 也不是 Java 语言的替代品。

无论如何，这些技术是补充，在大多数情况下，Groovy 是快速开发的更简单的一种选择。 就像 GroovySql 是直接使用 JDBC 的替代方法一样，Groovlet 和 GSP 实际上是直接使用 Servlet API 的替代品。

下个月，我将探讨 GroovyMarkup 的奇妙世界。

2005 年 2 月 15 日

视图是 MVC 编程的一个重要部分，而 MVC 编程本身又是企业应用程序开发的一个重要组件。在这篇实战 Groovy 的文章中，Andrew Glover 向您介绍了 Groovy 的模板引擎框架是如何用来简化视图编程的，并如何使您的代码更加经久容易维护。

在最近的 实战 Groovy 系列中，我们已经介绍过 Groovy 是构建报表统计程序的一个非常好的工具。我们使用了一个校验和报表统计应用程序的例子向您介绍了 使用 Groovy 编写 Ant 脚本 和一个数据库报表统计来展示 使用 GroovySql 进行 JDBC 编程。这两个示例统计报表都是在 Groovy 脚本中生成的，而且都具有一个相关的“视图”。

在 校验和统计报表的例子中，视图代码有些混乱。更糟糕的是，它可能会对维护造成一些困难：如果我曾经希望修改视图的某个特定方面，就必须修改脚本中的代码。 因此在本月的文章中，我将向您展示如何使用 Groovy 模板引擎和上一篇文章中的统计报表应用程序来对统计报表进行简化。

模 板引擎与 XSLT 很类似，可以产生模板定义的任何格式，包括 XML、HTML、SQL 和 Groovy 代码。与 JSP 类似，模板引擎会简化将视图关注的内容分隔成单独的实体，例如 JSP 或模板文件。例如，如果一个报表希望的输出是 XML，那么您就可以创建一个 XML 模板，它可以包含一些占位符，在运行时替换为实际的值。模板引擎然后可以通过读取该模板并在这些占位符和运行时的值之间建立映射来实现对模板的转换。这个 过程的输出结果是一个 XML 格式的文档。

在开始介绍 Groovy 模板之前，我想首先来回顾一下 Groovy 中 String 类型的概念。所有的脚本语言都试图使字符串的使用变得异常简单。再次声明，Groovy 并不是让我们的技能逐步退化。在开始之前，请点击本页面顶部或底部的 Code 图标（或者参阅 下载 一节的内容），下载本文的源代码。

不能获得充足的 Strings

不幸的是，Java™ 代码中的 Strings 非常有限，不过 Java 5.0 应用程序承诺将有一些引人注目的新特性。现在，Groovy 解决了两个最差的 Java String 限制，简化了编写多行字符串和进行运行时替换的功能。有一些简单的例子可以对 Groovy String 类型进行加速，在本文中我们将使用这些例子。

如果您在普通的 Java 代码中编写一个多行的 String 类型，就会最终要使用很多讨厌的 + 号，对吗？但是在清单 1 中您可以看到，Groovy 不用再使用这些 + 号了，这使您可以编写更加清晰、简单的代码。

String example1 = "This is a multiline
  string which is going to
  cover a few lines then
  end with a period."

Groovy 还支持 here-docs 的概念，如清单 2 所示。here-doc 是创建格式化 String（例如 HTML 和 XML）的一种便利机制。注意 here-doc 语法与普通的 String 声明并没有很大的不同，不过它需要类 Python 的三重引号。

itext =
"""
This is another multiline String
that takes up a few lines. Doesn't
do anything different from the previous one.
"""

Groovy 使用 GString 来简化运行时替换。如果您不知道 GString 是什么，我可以确信您之前肯定见过它，而且还可能使用过它。简单来说，GString 允许您使用 与 bash 类似的${} 语法进行替换。GString 的优势是您从来都不需要知道自己正在使用的是 GString 类型；只需要在 Groovy 中简单地编写 String 即可，就仿佛是在 Java 代码中一样。

关于模板引擎 模 板引擎已经存在很长一段时间了，几乎在每个现代语言中都可以找到。普通的 Java 语言具有 Velocity 和 FreeMarker；Python 有 Cheetah 和 Ruby ERB；Groovy 也有自己的引擎。要学习更多有关模板引擎的内容，请参阅 参考资料。

lang = "Groovy"
println "Uncle man, Uncle man, I dig ${lang}."

在清单 3 中，我们创建了一个名为 lang 的变量，并将其值设置为“Groovy”。我们打印了一个 GString 类型的 String，并要求将单词 “dig” 后面的内容替换为 ${lang} 的值。如果实际运行一下，这段代码会打印“Uncle man, Uncle man, I dig Groovy.” 一切都不错，不是吗？

运行时替换实际上是动态语言的一个通用特性；与其他情况一样，Groovy 还会更进一步。Groovy 的 GString 允许您对替换的值调用 autocall 方法，当开始构建动态文本时，这会产生很多变化。例如，在清单 4 中，我可以对指定的变量按照 String 对象类型调用一个方法（在本例中是 length() 方法）。

lang = "Groovy"
println "I dig any language with ${lang.length()} characters in its name!"

清单 4 中的代码会打印出“I dig any language with 6 characters in its name!”在下一节中，我将向您展示如何使用 Groovy 的自动调用特性在您的模板中启用一些复杂的特性。

Groovy 模板

对 模板的使用可以分解为两个主要的任务：首先，创建模板；其次，提供映射代码。使用 Groovy 模板框架创建模板与创建 JSP 非常类似，因为您可以重用 JSP 中见过的语法。创建这些模板的关键在于对那些运行时要替换的变量的定义。例如，在清单 5 中，我们为创建 GroovyTestCase 定义了一个模板。

import groovy.util.GroovyTestCase
class <%=test_suite %> extends GroovyTestCase {
  <% for(tc in test_cases) {
     println "\tvoid ${tc}() { } "
  }%>
}

清单 5 中的模板就类似于一个 JSP 文件，因为我们使用了 <% 和 <%= 语法。然而，由于 Groovy 的灵活性很好，因此您并不局限于使用 JSP 语法。您还可以自由使用 Groovy 中杰出的 GString，如清单 6 所示。

<person>
  <name first="${p.fname}" last="${p.lname}"/>
</person>

在清单 6 中，我创建了一个简单的模板，它表示一个定义 person 元素集合的 XML 文档。您可以看到这个模板期望一个具有 fname 和 lname 属性、名为 p 的对象。

在 Groovy 中定义模板相当简单，其实应该就是这样简单才对。Groovy 模板并不是火箭科学，它们只不过是一种简化从模型中分离视图过程的手段。下一个步骤是编写运行时的映射代码。

运行时映射

既然已经定义了一个模板，我们就可以通过在已定义的变量和运行时值之间建立映射来使用这个模板了。与 Groovy 中常见的一样，有些看来似乎很复杂的东西实际上是非常简单的。我所需要的是一个 映射，其关键字是模板中的变量名，键值是运行时的值。

例如，如果一个简单的模板有一个名为 favlang 的变量，我就需要与 favlang 键值建立一个 映射。这个键值可以是根据我自己的喜好选择的任何脚本语言（在本例中，当然是 Groovy）。

在清单 7 中，我们定义了这样一个简单的模板，在清单 8 中，我将向您展示对应的映射代码。

My favorite dynamic language is ${favlang}

清单 8 显示了一个简单的类，它一共做了 5 件事，其中有 2 件是很重要的。您可以说出它们是什么吗？

package com.vanward.groovy.tmpl
import groovy.text.Template
import groovy.text.SimpleTemplateEngine
import java.io.File
class SimpleTemplate{
  static void main(args) {
    fle = new File("simple-txt.tmpl")
    binding = ["favlang": "Groovy"]
    engine = new SimpleTemplateEngine()
    template = engine.createTemplate(fle).make(binding)
    println template.toString()
  }
}

在清单 8 中为这个简单的模板映射值简单得令人吃惊。

首先，我创建了一个 File 实例，它指向模板 simple-txt.tmpl。

然后创建了一个 binding 对象；实际上，这就是一个 映射。我将在模板中找到的值 favlang 映射到 String Groovy 上。这种映射是在 Groovy 中使用模板最重要的步骤，或者说在任何具有模板引擎的语言中都是如此。

接下来，我创建了一个 SimpleTemplateEngine 实例，在 Groovy 中，它恰巧就是模板引擎框架的一个具体实现。然后我将模板（simple-txt.tmpl）和 binding 对象传递给这个引擎实例。在清单 8 中，第二个重要的步骤是将模板及其 binding 对象绑定在一起，这也是使用模板引擎的关键所在。从内部来说，框架将在从 binding 对象中找到的值与对应模板中的名字之间建立映射。

清单 8 中的最后一个步骤是打印进程的输出信息。正如您可以看到的一样，创建一个 binding 对象并提供正确的映射是件轻而易举的小事，至少在我们这个简单的例子中是如此。在下一节中，我们将会使用一个更加复杂的例子对 Groovy 模板引擎进行测试。

更复杂的模板

在清单 9 中，我已经创建了一个 Person 类来表示在 清单 6 中定义的 person 元素。

class Person{
 age
 fname
 lname
 String toString(){
  return "Age: " + age + " First Name: " + fname + " Last Name: " + lname
 }
}

在清单 10 中，您可以看到对上面定义的 Person 类的实例进行映射的代码。

import java.io.File
import groovy.text.Template
import groovy.text.SimpleTemplateEngine
class TemplatePerson{
  static void main(args) {
    pers1 = new Person(age:12, fname:"Sam", lname:"Covery")
    fle = new File("person_report.tmpl")
    binding = ["p":pers1]
    engine = new SimpleTemplateEngine()
    template = engine.createTemplate(fle).make(binding)
    println template.toString()
  }
}

上面的代码看起来很熟悉，不是吗？实际上，它与 清单 8 非常类似，不过增加了一行创建 pers1 实例的代码。现在，再次快速查看一下 清单 6 中的代码。您看到模板是如何引用属性 fname 和 lname 的了吗？我所做的操作是创建一个 Person 实例，其 fname 属性设置为“Sam”，属性 lname 设置为“Covery”。

在运行清单 10 中的代码时，输出结果是 XML 文件，用来定义 person 元素，如清单 11 所示。

<person>
  <name first="Sam" last="Covery"/>
</person>

映射一个列表

在 清单 5 中，我为 GroovyTestCase 定义了一个模板。现在如果您看一下这个模板，就会注意到这个定义有一些逻辑用于在一个集合上迭代。在清单 12 中，您将看到一些非常类似的代码，不过这些代码的逻辑是用来映射一个测试用例 列表的。

fle = new File("unit_test.tmpl")
coll = ["testBinding", "testToString", "testAdd"]
binding = ["test_suite":"TemplateTest", "test_cases":coll]
engine = new SimpleTemplateEngine()
template = engine.createTemplate(fle).make(binding)
println template.toString()

查看一下 清单 5，它显示了模板期望一个名为“test_cases”的 列表 —— 在清单 12 中它定义为 coll，包含 3 个元素。我简单地将 coll 设置为“test_cases”绑定对象中的键值，现在代码就准备好运行了。

现在应该十分清楚了，Groovy 模板非常容易使用。它还可以促进无所不在的 MVC 模式的使用；更重要的是，它们可以通过表示视图来支持转换为 MVC 代码。在下一节中，我将向您展示如何对上一篇文章中的一个例子应用本文中所学到的知识。

使用模板重构之前的例子

在使用 Groovy 编写 Ant 脚本的专栏中，我曾经编写了一个简单的工具，它对类文件产生校验和报告。如果您还记得，我当时笨拙地使用 println 语句来产生 XML 文件。尽管我只能接受这段代码，但它是如此地晦涩，这您只需要看一下清单 13 就会一目了然。

nfile.withPrintWriter{ pwriter |
  pwriter.println("<md5report>")
    for(f in scanner){
       f.eachLine{ line |
         pwriter.println("<md5 class='" + f.path + "' value='" + line + "'/>")
       }
    }
  pwriter.println("</md5report>")
}

为了帮您回顾一下有关这段内容的记忆，清单 13 中的代码使用了一些数据，并使用 PrintWriter 将其写入一个文件中（nfile 实例）。注意我是如何将报告的视图组件（XML）硬编码在 println 中的。这种方法的问题是它不够灵活。之后，如果我需要进行一些修改，就只能进入到 Groovy 脚本的逻辑中进行修改。在更糟糕的情况下，设想一下一个非程序员想要进行一些修改会是什么样子。Groovy 代码会受到很大的威胁。

将该脚本中的视图部分移动到模板中可以使维护更加方便，因为修改模板是任何人都会涉及的一个过程，因此我在此处也会这样做。

定义模板

现在我将开始定义模板了 —— 它看起来更加类似于想要的输出结果，采用了一些逻辑来循环遍历一组类。

<md5report>
<% for(clzz in clazzes) {
  println "<md5 class=\"${clzz.name}\" value=\"${clzz.value}\"/>"
}%>
</md5report>

清单 14 中定义的模板与为 GroovyTestCase 定义的模板类似，其中包括循环遍历一个集合的逻辑。还要注意我在此处混合使用了 JSP 和 GString 的语法。

编写映射代码

定义好模板之后，下一个步骤是编写运行时的映射代码。我需要将原来的写入文件的逻辑替换为下面的代码：构建一个 ChecksumClass 对象集合，然后将这些对象放到 binding 对象中。

这个模型然后就会变成清单 15 中定义的 ChecksumClass。

class CheckSumClass{
  name
  value
  String toString(){
   return "name " + name + " value " + value
  }
}

Groovy 中类的定义非常简单，不是吗？

创建集合

接下来，我需要重构刚才写入文件的那段代码 —— 这一次采用一定的逻辑使用 ChecksumClass 构造一个列表，如清单 16 所示。

clssez = []
for(f in scanner){
  f.eachLine{ line |
   iname = formatClassName(bsedir, f.path)
   clssez << new CheckSumClass(name:iname, value:line)
  }
}

清单 16 显示了使用类 Ruby 的语法将对象添加到 列表 中是多么简单 —— 这就是 奇妙的 groovy。我首先使用 [] 语法创建 清单。然后使用简短的 for 循环，后面是一个带有闭包的迭代器。这个闭包接受每一个 line（在本例中是一个校验和值），并创建一个新定义的 CheckSumClass 实例（使用 Groovy 的自动生成的构造函数），并将二者添加到集合中。还不错 —— 这样编写起来也很有趣。

添加模板映射

我需要做的最后一件事情是添加模板引擎特定的代码。这段代码将执行运行时映射，并将对应的格式化后的模板写入原始的文件中，如清单 17 所示。

fle = new File("report.tmpl")
binding = ["clazzes": clzzez]
engine = new SimpleTemplateEngine()
template = engine.createTemplate(fle).make(binding)
nfile.withPrintWriter{ pwriter |
  pwriter.println template.toString()
}

现在，清单 17 中的代码对您来说太陈旧了。我利用了清单 16 中的 列表，并将其放入 binding 对象。然后读取 nfile 对象，并将相应的输出内容从 清单 14 中的映射模板写入文件中。

在将这些内容都放入清单 18 之前，您可能希望返回 清单 13 最后看一眼开始时使用的那段蹩脚的代码。下面是新的代码，您可以进行比较一下：

/**
 *
 */
buildReport(bsedir){
 ant = new AntBuilder()
 scanner = ant.fileScanner {
   fileset(dir:bsedir) {
     include(name:"**/*class.md5.txt")
   }
 }
 rdir = bsedir + File.separator + "xml" + File.separator
 file = new File(rdir)
 if(!file.exists()){
   ant.mkdir(dir:rdir)
 }
 nfile = new File(rdir + File.separator + "checksum.xml")
 clssez = []
 for(f in scanner){
   f.eachLine{ line |
    iname = formatClassName(bsedir, f.path)
    clssez << new CheckSumClass(name:iname, value:line)
   }
 }
 fle = new File("report.tmpl")
 binding = ["clazzes": clzzez]
 engine = new SimpleTemplateEngine()
 template = engine.createTemplate(fle).make(binding)
 nfile.withPrintWriter{ pwriter |
   pwriter.println template.toString()
 }
}

现在，虽然我没有声明要编写非常漂亮的代码，但是这些代码当然不会像原来的代码一样 糟糕 了。回顾一下，我所干的事情不过是将一些蹩脚的 println 替换成 Groovy 的更精巧的模板代码。（一些熟悉重构的人可能会说我应该使用 Extract Method 进一步对代码进行优化。）

结束语

在本月的教程中，我希望已经向您展示了 Groovy 的 视图。更明确地 说，当您需要快速开发一些需要视图的简单程序时，Groovy 的模板框架是普通 Java 编码的一种很好的替代品。模板是很好的一种抽象，如果使用正确，它可以极大地降低应用程序的维护成本。

下一个月，我将向您展示如何使用 Groovy 来构建使用 Groovlets 的 Web 应用程序。现在，享受使用 Groovy 的模板开发吧！

2005 年 1 月 11 日

这 个月，随着 Andrew Glover 向您演示如何用 GroovySql 构建简单的数据报告应用程序，您对 Groovy 的实用知识会更进一步。GroovySql 结合利用闭包（closure）和迭代器（iterator），把资源管理的负担转移到 Groovy 框架本身，从而简化了 Java 数据库连通性（Java Database Connectivity，JDBC）的编程。

在 实战 Groovy 系列的前几期中，您已经了解了 Groovy 的一些非常优美的特性。在 第 1 期 中，学习了如何用 Groovy 对普通的 Java™ 代码进行更简单、更迅速的单元测试。在 第 2 期 中，看到了 Groovy 能够给 Ant 构建带来的表现能力。这一次您会发现 Groovy 的另一个实际应用，即如何用它迅速地构建基于 SQL 的报告应用程序。

脚 本语言对于迅速地构建报告应用程序来说是典型的优秀工具，但是构建这类应用程序对于 Groovy 来说特别容易。Groovy 轻量级的语法可以消除 Java 语言的 JDBC 的一些繁冗之处，但是它真正的威力来自闭包，闭包很优雅地把资源管理的责任从客户机转移到框架本身，因此更容易举重若轻。

在本月的文章中，我先从 GroovySql 的概述开始，然后通过构建一个简单的数据报告应用程序，向您演示如何将它们投入工作。为了从讨论中得到最大收获，您应当熟悉 Java 平台上的 JDBC 编程。您可能还想回顾 上个月对 Groovy 中闭包的介绍，因为它们在这里扮演了重要的角色。但是，本月关注的重点概念是迭代（iteration），因为迭代器在 Groovy 对 JDBC 的增强中扮演着重要角色。所以，我将从 Groovy 中迭代器的概述开始。

进入迭代器

迭代是各种编程环境中最常见、最有用的技术。 迭代器 是某种代码助手，可以让您迅速地访问任何集合或容器中的数据，每次一个数据。Groovy 把迭代器变成隐含的，使用起来更简单，从而改善了 Java 语言的迭代器概念。在清单 1 中，您可以看到使用 Java 语言打印 String 集合的每个元素需要做的工作。

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class JavaIteratorExample {
  public static void main(String[] args) {
     Collection coll = new ArrayList();
     coll.add("JMS");
     coll.add("EJB");
     coll.add("JMX");
     for(Iterator iter = coll.iterator(); iter.hasNext();){
        System.out.println(iter.next());
     }
  }
}

在清单 2 中，您可以看到 Groovy 如何简化了我的工作。在这里，我跳过了 Iterator 接口，直接在集合上使用类似迭代器的方法。而且， Groovy 的迭代器方法接受闭包，每个迭代中都会调用闭包。清单 2 显示了前面基于 Java 语言的示例用 Groovy 转换后的样子。

class IteratorExample1{
   static void main(args) {
     coll = ["JMS", "EJB", "JMX"]
     coll.each{ item | println item }
   }
}

您可以看到，与典型的 Java 代码不同，Groovy 在允许我传递进我需要的行为的同时，控制了特定于迭代的代码。使用这个控制，Groovy 干净漂亮地把资源管理的责任从我手上转移到它自己身上。让 Groovy 负责资源管理是极为强大的。它还使编程工作更加容易，从而也就更迅速。

GroovySql 简介

Groovy 的 SQL 魔力在于一个叫做 GroovySql 的精致的 API。使用闭包和迭代器，GroovySql 干净漂亮地把 JDBC 的资源管理职责从开发人员转移到 Groovy 框架。这么做之后，就消除了 JDBC 编程的繁琐，从而使您可以把注意力放在查询和查询结果上。

如果您忘记了普通的 Java JDBC 编程有多麻烦，我会很高兴提醒您！在清单 3 中，您可以看到用 Java 语言进行的一个简单的 JDBC 编程示例。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JDBCExample1 {
  public static void main(String[] args) {
    Connection con = null;
    Statement stmt = null;
    ResultSet rs = null;
    try{
      Class.forName("org.gjt.mm.mysql.Driver");
      con = DriverManager.getConnection("jdbc:mysql://localhost:3306/words",
           "words", "words");
      stmt = con.createStatement();
      rs = stmt.executeQuery("select * from word");
      while (rs.next()) {
        System.out.println("word id: " + rs.getLong(1) +
            " spelling: " + rs.getString(2) +
            " part of speech: " + 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();}catch(Exception e){}
   }
  }
}

哇。清单 3 包含近 40 行代码，就是为了查看表中的内容！如果用 GroovySql，您猜要用多少行？如果您猜超过 10 行，那么您就错了。请看清单 4 中，Groovy 替我处理底层资源，从而非常漂亮地让我把注意力集中在手边的任务 —— 执行一个简单的查询。

import groovy.sql.Sql
class GroovySqlExample1{
  static void main(args) {
    sql = Sql.newInstance("jdbc:mysql://localhost:3306/words", "words",
           "words", "org.gjt.mm.mysql.Driver")
    sql.eachRow("select * from word"){ row |
       println row.word_id + " " + row.spelling + " " + row.part_of_speech
    }
  }
}

真不错。只用了几行，我就编码出与清单 3 相同的行为，不用关闭 Connection，也不用关闭 ResultSet，或者在 JDBC 编程中可以找到的任何其他熟悉的重要特性。这是多么激动人心的事情啊，并且还是如此容易。现在让我来仔细介绍我是如何做到的。

执行简单的查询

在 清单 4 的第一行中，我创建了 Groovy 的 Sql 类的实例，用它来连接指定的数据库。在这个例子中，我创建了 Sql 实例，指向在我机器上运行的 MySQL 数据库。到现在为止都非常基本，对么？真正重要的是一下部分，迭代器和闭包一两下就显示出了它们的威力。

请把 eachRow 方法当成传进来的查询生成的结果上的迭代器。在底层，您可以看到返回了 JDBC ResultSet 对象，它的内容被传递进 for 循环。所以，每个迭代都要执行我传递进去的闭包。如果在数据库中找到的 word 表只有三行，那么闭包就会执行三次 —— 打印出 word_id、 spelling 和 part_of_speech 的值。

如果将等式中我指定的变量 row 去掉，而使用 Groovy 的一个隐含变量 it（它恰好就是迭代器的实例），代码可以进一步简化。如果我这样做，那么前面的代码就可以写成清单 5 所示的这样：

import groovy.sql.Sql
class GroovySqlExample1{
  static void main(args) {
    sql = Sql.newInstance("jdbc:mysql://localhost:3306/words", "words",
           "words", "org.gjt.mm.mysql.Driver")
    sql.eachRow("select * from word"){ println it.spelling +  " ${it.part_of_speech}"}
  }
}

在这个代码中，我可以删除 row 变量，用 it 代替。而且，我还能在 String 语句中引用 it 变量，就像我在 ${it.part_of_speech} 中所做的那样。

执行更复杂的查询

前面的例子相当简单，但是 GroovySql 在处理更复杂的数据操纵查询（例如 insert、 update 和 delete 查询）时，也是非常可靠的。 对于这些查询，您没有必要用迭代器，所以 Groovy 的 Sql 对象另外提供了 execute 和 executeUpdate 方法。这些方法让人想起普通的 JDBC statement 类，它也有 execute 和 executeUpdate 方法。

在清单 6 中，您看到一个简单的 insert，它再次以 ${} 语法使用变量替换。这个代码只是向 word 表插入一个新行。

 wid = 999
 spelling = "Nefarious"
 pospeech = "Adjective"
 sql.execute("insert into word (word_id, spelling, part_of_speech) 
   values (${wid}, ${spelling}, ${pospeech})")

Groovy 还提供 execute 方法的一个重载版本，它接收一列值，这些值与查询中发现的 ? 元素对应。在清单 7 中，我简单地查询了 word 表中的某个行。在底层，GroovySql 创建了普通 Java 语言 java.sql.PreparedStatement 的一个实例。

val = sql.execute("select * from word where word_id = ?", [5])

更新的方式基本相同，也使用 executeUpdate 方法。还请注意，在清单 8 中 executeUpdate 方法接收一列值，与查询中的 ? 元素对应。

 nid = 5
 spelling = "Nefarious"
 sql.executeUpdate("update word set word_id = ? where spelling = ?", [nid, spelling])

删除实际上与插入相同，当然，语法不同，如清单 9 所示。

 sql.execute("delete from word where word_id = ?" , [5])

简化数据操纵

任何想简化 JDBC 编程的 API 或工具最好有一些好的数据操纵特性，在这一节中，我要向您再介绍三个。

数据集(DataSet)

构建于 GroovySql 简单性的基础之上，GroovySql 支持 DataSet 类型的概念，这基本上是数据库表的对象表示。使用 DataSet，您可以在行中遍历，也可以添加新行。实际上，用数据集是方便地表示表格的公共数据集合的方式。

但是，目前 GroovySql DataSet 类型的不足之处是它们没有代表关系；它们只是与数据库表的一对一映射。在清单 10 中，我创建了一个来自 word 表的 DataSet。

import groovy.sql.Sql
class GroovyDatasetsExample1{
  static void main(args) {
    sql = Sql.newInstance("jdbc:mysql://localhost:3306/words", "words",
          "words", "org.gjt.mm.mysql.Driver")
    words = sql.dataSet("word")
    words.each{ word |
     println word.word_id + " " + word.spelling
    }
    words.add(word_id:"9999", spelling:"clerisy", part_of_speech:"Noun")
  }
}

您可以看到，GroovySql 的 DataSet 类型可以容易地用 each 方法对表的内容进行遍历，容易地用 add 方法添加新行， add 方法接受一个 map 表示需要的数据。

使用存储过程和负索引

存储过程调用和负索引（negative indexing）可能是数据操纵的重要方面。GroovySql 使存储过程调用简单得就像在 Sql 类上使用 call 方法一样。对于负索引， GroovySql 提供了自己增强的 ResultSet 类型，它工作起来非常像 Groovy 中的 collections。例如，如果您想获取结果集中的最后一个项目，您可以像清单 11 所示的那样做：

 sql.eachRow("select * from word"){ grs |
   println "-1  = " + grs.getAt(-1) //prints spelling
   println "2  = " + grs.getAt(2) //prints spelling
 }

您在清单 11 中可以看到，提取结果集的最后一个元素非常容易，只要用 -1 作索引就可以。如果想试试，我也可以用索引 2 访问同一元素。

这些例子非常简单，但是它们能够让您很好地感觉到 GroovySql 的威力。我现在要用一个演示目前讨论的所有特性的实际例子来结束本月的课程。

编写一个简单的报告应用程序

报告应用程序通常要从数据库拖出信息。在典型的业务环境中，可能会要求您编写一个报告应用程序，通知销售团队当前的 Web 销售情况，或者让开发团队对系统某些方面（例如系统的数据库）的性能进行日常检测。

为 了继续这个简单的例子，假设您刚刚部署了一个企业范围的 Web 应用程序。当然，因为您在编写代码时还（用 Groovy）编写了充足的单元测试，所以它运行得毫无问题；但是您还是需要生成有关数据库状态的报告，以便调优。您想知道客户是如何使用应用程序的，这 样才能发现性能问题并解决问题。

通常，时间约束限制了您在这类应用程序中能够使用的提示信息的数量。但是您新得到的 GroovySql 知识可以让您轻而易举地完成这个应用程序，从而有时间添加更多您想要的特性。

细节

在这个例子中，您的目标数据库是 MySQL，它恰好支持用查询发现状态信息这一概念。以下是您有兴趣的状态信息：

• 运行时间。
• 处理的全部查询数量。
• 特定查询的比例，例如 insert、 update 和 select。

用 GroovySql 从 MySQL 数据库得到这个信息太容易了。由于您正在为开发团队构建状态信息，所以您可能只是从一个简单的命令行报告开始，但是您可以在后面的迭代中把报告放在 Web 上。这个报告例子的用例看起来可能像这样：

在清单 12 中，您可以看到最终结果：一个将会报告所需数据库统计信息的应用程序。代码开始的几行获得到生产数据库的连接，接着是一系列 show status 查询，让您计算每分钟的查询数，并按类型把它们分开。请注意像 uptime 这样的变量如何在定义的时候就创建。

import groovy.sql.Sql
class DBStatusReport{
  static void main(args) {
     sql = Sql.newInstance("jdbc:mysql://yourserver.anywhere/tiger", "scott",
        "tiger", "org.gjt.mm.mysql.Driver")
     sql.eachRow("show status"){ status |
        if(status.variable_name == "Uptime"){
           uptime =  status[1]
        }else if (status.variable_name == "Questions"){
           questions =  status[1]
        }
     }
     println "Uptime for Database: " + uptime
     println "Number of Queries: " + questions
     println "Queries per Minute = " + Integer.valueOf(questions) / Integer.valueOf(uptime)
     sql.eachRow("show status like 'Com_%'"){ status |
        if(status.variable_name == "Com_insert"){
           insertnum =  Integer.valueOf(status[1])
        }else if (status.variable_name == "Com_select"){
           selectnum =  Integer.valueOf(status[1])
        }else if (status.variable_name == "Com_update"){
           updatenum =  Integer.valueOf(status[1])
       }
    }
    println "% Queries Inserts = " + 100 * (insertnum / Integer.valueOf(uptime))
    println "% Queries Selects = " + 100 * (selectnum / Integer.valueOf(uptime))
    println "% Queries Updates = " + 100 * (updatenum / Integer.valueOf(uptime))
    }
}

结束语

在 实战 Groovy 本月的这一期文章中，您看到了 GroovySql 如何简化 JDBC 编程。这个干净漂亮的 API 把闭包和迭代器与 Groovy 轻松的语法结合在一起，有助于在 Java 平台上进行快速数据库应用程序开发。最强大的是，GroovySql 把资源管理任务从开发人员转移到底层的 Groovy 框架，这使您可以把精力集中在更加重要的查询和查询结果上。但是不要只记住我这句话。下次如果您被要求处理 JDBC 的麻烦事，那时可以试试小小的 GroovySql 魔力。然后给我发封电子邮件告诉我您的体会。

在 实战 Groovy 下一月的文章中，我要介绍 Groovy 模板框架的细节。您会发现，用这个更加聪明的框架创建应用程序的视图组件简直就是小菜一碟。

Andrew Glover (aglover@vanwardtechnologies.com), CTO, Vanward Technologies

2004 年 11 月 09 日

不久以前，developerWorks 的作者 Andrew Glover 撰写了一篇介绍 Groovy 的文章，该文章是 alt.lang.jre 系列的一部分，而 Groovy 是一个新提议的用于 Java 平台的标准语言。读者对这篇文章的反应非常热烈，所以我们决定开办这个专栏，提供使用这项热门新技术的实用指导。本文是第一期，将介绍使用 Groovy 和 JUnit 对 Java 代码进行单元测试的一个简单策略。

开始之前，我首先要招认：我是一个单元测试狂。实际上，我总是无法编写足够的单元测试。如果我相当长一段时间都在进行开发，而 没有编写相应的单元测试，我就会觉得紧张。单元测试给我信心，让我相信我的代码能够工作，而且我只要看一下，可以修改它，就不会害怕它会崩溃。

而且，作为一个单元测试狂，我喜欢编写多余的测试用例。但是，我的兴奋不是来自 编写测试用例，而是 看着它们生效。所以，如果我能用更快的方式编写测试，我就能更迅速地看到它们的结果。这让我感觉更好。更快一些！

后 来，我找到了 Groovy，它满足了我的单元测试狂，而且至今为止，对我仍然有效。这种新语言给单元测试带来的灵活性，非常令人兴奋，值得认真研究。本文是介绍 Groovy 实践方面的新系列的第一部分，在文中，我将向您介绍使用 Groovy 进行单元测试的快乐。我从概述开始，概述 Groovy 对 Java 平台上的开发所做的独特贡献，然后转而讨论使用 Groovy 和 JUnit 进行单元测试的细节，其中重点放在 Groovy 对 JUnit 的 TestCase 类的扩展上。最后，我用一个实用的示例进行总结，用第一手材料向您展示如何把 groovy 的这些特性与 Eclipse 和 Maven 集成在一起。

不要再坚持 Java 纯粹主义了！

在 我开始介绍用 Groovy 进行单元测试的实际经验之前，我认为先谈谈一个更具一般性的问题 —— 它在您的开发工具箱中的位置，这非常重要。事实是，Groovy 不仅是运行在 Java 运行时环境（JRE）中的脚本语言，它还被提议作为用于 Java 平台的标准语言。正如您们之中的人已经从 alt.lang.jre 系列（请参阅 参考资料）中学习到的，在为 Java 平台进行脚本编程的时候，有无数的选择，其中大多数是面向快速应用程序开发的高度灵活的环境。

虽然有这么丰富的选择，但还是有许多开发人选择坚持自己喜欢的、最熟悉的范式：Java 语言。虽然大多数情况下，Java 编程都是很好的选择，但是它有一个非常重要的缺点，蒙住了只看见 Java 的好处的这些人的眼睛。正如一个智者曾经指出的： 如果您仅有的一个工具是一把锤子，那么您看每个问题时都会觉得它像是钉子。我认为这句谚语道出了适用于软件开发的许多事实。

虽然我希望用这个系列说服您 Java 不是也不应当是开发应用程序的惟一选择，但该脚本确实既有适用的地方也有不适用的地方。专家和新手的区别在于：知道什么时候 运用该脚本，什么时候 避免使用它。

关于本系列 把工具整合到开发实践中的关键是了解什么时候使用它，以及什么时候把它留在工具箱中。脚本语言能够成为工具包中极为强大的附件，但是只有正确地应用在适当的场合时才是这样。为了实现 实战 Groovy 系列文章这个目标，我专门研究了 Groovy 的一些实战，教给您什么时候怎样才能成功地应用它们。

例如，对于高性能、事务密集型、企业级应用程序，Groovy 脚本通常不太适合；在这些情况下，您最好的选择 可能是 普通的 J2EE 系统。但另一方面，一些脚本 —— 特别是用 Groovy 编写的脚本 —— 会非常有用，因为它能迅速地为小型的、非常特殊的、不是性能密集型的应用程序（例如配置系统/生成系统）快速制作原型。对于报表应用程序来说， Groovy 脚本也是近乎完美的选择，而最重要的是，对单元测试更是如此。

为什么用 Groovy 进行单元测试？

是 什么让 Groovy 比起其他脚本平台显得更具有吸引力呢？是它与Java 平台无缝的集成。还是因为它是基于 Java 的语言（不像其他语言，是对 JRE 的替代，因此可能基于旧版的处理器），对于 Java 开发人员来说，Groovy 意味着一条短得让人难以置信的学习曲线。而且一旦将这条学习曲线拉直，Groovy 就能提供一个无与伦比的快速开发平台。

从这个角度来说，Groovy 成功的秘密，在于它的语法 就是 Java 语法，但是规则更少。例如，Groovy 不要求使用分号，变量类型和访问修饰符也是可选的。而且，Groovy 利用了标准的 Java 库，这些都是您已经很熟悉的，包括 Collections 和 File/IO。而且，您还可以利用任何 Groovy 提供的 Java 库，包括 JUnit。

事实上，令人放松的类 Java 语法、对标准 Java 库的重用以及快捷的生成-运行周期，这些都使 Groovy 成为快速开发单元测试的理想替代品。但是会说的不如会做的，还是让我们在代码中看看它的实际效果！

JUnit 和 Groovy

用 Groovy 对 Java 代码进行单元测试简单得不能再简单了，有很多入门选择。最直接的选择是沿袭行业标准 —— JUnit。Unit 的简单性和其功能的强大都是无与伦比的，作为非常有帮助的 Java 开发工具，它的普遍性也是无与伦比的，而且没有什么能够阻挡 JUnit 和 Groovy 结合，所以为什么多此一举呢？实际上，只要您看过 JUnit 和 Groovy 在一起工作，我敢打赌您就永远再也不会回头！在这里，要记住的关键的事，您在 Java 语言中能用 JUnit 做到的事，在 Groovy 中用 JUnit 也全都能做到；但是需要的代码要少得多。

入门

在您下载了 JUnit 和 Groovy（请参阅 参考资料）之后，您将有两个选择。第一个选择是编写普通的 JUnit 测试用例，就像以前一直做的那样，扩展 JUnit 令人称赞的 TestCase。第二个选择是应用 Groovy 简洁的 GroovyTestCase 扩展，它会扩展 JUnit 的 TestCase。第一个选项是您最快的成功途径，它拥有最多 与 Java 类似的相似性。而另一方面，第二个选择则把您推进了 Groovey 的世界，这个选择有最大的敏捷性。

开始的时候，我们来想像一个 Java 对象，该对象对指定的 string 应用了一个过滤器，并根据匹配结果返回 boolean 值。该过滤器可以是简单的 string 操作，例如 indexOf()，也可以更强大一些，是正则表达式。可能要通过 setFilter() 方法在运行时设置将使用的过滤器， apply() 方法接受要过滤的 string。清单 1 用普通的 Java 代码显示了这个示例的 Filter 接口：

public interface Filter {
  void setFilter(String fltr);  
  boolean applyFilter(String value);
}

我们的想法是用这个特性从大的列表中过滤掉想要的或者不想要的包名。所以，我建立了两个实现： RegexPackageFilter 和 SimplePackageFilter。

把 Groovy 和 JUnit 的强大功能与简单性结合在一起，就形成了如清单 2 所示的简洁的测试套件：

import junit.framework.TestCase
import com.vanward.sedona.frmwrk.filter.impl.RegexPackageFilter
class RegexFilterTest extends TestCase {  
  void testSimpleRegex() {
    fltr = new RegexPackageFilter()
    fltr.setFilter("java.*")
    val = fltr.applyFilter("java.lang.String")		
    assertEquals("value should be true", true, val)		
  }
}

不管您是否熟悉 Groovy，清单 2 中的代码对您来说应当很面熟，因为它只不过是没有分号、访问修饰符或变量类型的 Java 代码而已！上面的 JUnit 测试中有一个测试用例 testSimpleRegex()，它试图断言 RegexPackageFilter 用正则表达式 "java.*" 正确地找到了与 “ java.lang.String”匹配的对象。

Groovy 扩展了 JUnit

扩展 JUnit 的 TestCase 类，加入附加特性，实际上是每个 JUnit 扩展通常采用的技术。例如，DbUnit 框架（请参阅 参考资料）提供了一个方便的 DatabaseTestCase 类，能够比以往任何时候都更容易地管理数据库的状态，还有重要的 MockStrutsTestCase（来自 StrutsTestCase 框架；请参阅 参考资料），它生成虚拟的 servlet 容器，用来执行 struts 代码。这两个强大的框架都极好地扩展了 JUnit，提供了 JUnit 核心代码中所没有的其他特性；而现在 Groovy 来了，它也是这么做的！

与 StrutsTestCase 和 DbUnit 一样，Groovy 对 JUnit 的 TestCase 的扩展给您的工具箱带来了一些重要的新特性。这个特殊的扩展允许您通过 groovy 命令运行测试套件，而且提供了一套新的 assert 方法。可以用这些方法很方便地断言脚本的运行是否正确，以及断言各种数组类型的长度和内容等。

享受 GroovyTestCase 的快乐

了解 GroovyTestCase 的能力最好的办法，莫过于实际看到它的效果。在清单 3 中，我已经编写了一个新的 SimpleFilterTest，但是这次我要扩展 GroovyTestCase 来实现它：

import groovy.util.GroovyTestCase
import com.vanward.sedona.frmwrk.filter.impl.SimplePackageFilter
class SimpleFilterTest extends GroovyTestCase {

  void testSimpleJavaPackage() {
    fltr = new SimplePackageFilter()
    fltr.setFilter("java.")		
    val = fltr.applyFilter("java.lang.String")		
    assertEquals("value should be true", true, val)
  }	
}

请注意，可以通过命令行来运行该测试套件，没有运行基于 Java 的 JUnit 测试套件所需要的 main() 方法。实际上，如果我用 Java 代码编写上面的 SimpleFilterTest，那么代码看起来会像清单 4 所示的那样：

import junit.framework.TestCase;
import com.vanward.sedona.frmwrk.filter.Filter;
import com.vanward.sedona.frmwrk.filter.impl.SimplePackageFilter;
public class SimplePackageFilterTest extends TestCase {       
   public void testSimpleRegex() {
	Filter fltr = new SimplePackageFilter();
	fltr.setFilter("java.");
	boolean val = fltr.applyFilter("java.lang.String");
	assertEquals("value should be true", true, val);
   }

   public static void main(String[] args) {
 	junit.textui.TestRunner.run(SimplePackageFilterTest.class);
   }
}

用断言进行测试

除了可以让您通过命令行运行测试之外， GroovyTestCase 还向您提供了一些特别方便的 assert 方法。例如， assertArrayEquals，它可以检查两个数据中对应的每一个值和各自的长度，从而断言这两个数据是否相等。从清单 5 的示例开始，就可以看到 Groovy 断言的实际效果，清单 5 是一个简洁的基于 Java 的方法，它把 string 分解成数组。（请注意，我可能使用了 Java 1.4 中新添加的 string 特性编写以下的示例类。我采用 Jakarta Commons StringUtils 类来确保与 Java 1.3 的后向兼容性。）

import org.apache.commons.lang.StringUtils;
public class StringSplitter {
  public static String[] split(final String input, final String separator){
   return StringUtils.split(input, separator);
  }
}

清单 6 展示了用 Groovy 测试套件及其对应的 assertArrayEquals 方法对这个类进行测试是多么简单：

import groovy.util.GroovyTestCase
import com.vanward.resource.string.StringSplitter
class StringSplitTest extends GroovyTestCase {

  void testFullSplit() {
    splitAr = StringSplitter.split("groovy.util.GroovyTestCase", ".")		
    expect = ["groovy", "util", "GroovyTestCase"].toArray()
    assertArrayEquals(expect, splitAr)		
  }	
}

其他方法

Groovy 可以让您单独或成批运行测试。使用 GroovyTestCase 扩展，运行单个测试毫不费力。只要运行 groovy 命令，后面跟着要运行的测试套件即可，如清单 7 所示：

$./groovy test/com/vanward/sedona/frmwrk/filter/impl/SimpleFilterTest.groovy
.
Time: 0.047
OK (1 test)

Groovy 还提供了一个标准的 JUnit 测试套件，叫作 GroovyTestSuite。只要运行该测试套件，把脚本的路径传给它，它就会运行脚本，就像 groovy 命令一样。这项技术的好处是，它可以让您在 IDE 中运行脚本。例如，在 Eclipse 中，我只是为示例项目建立了一个新的运行配置（一定要选中 “Include external jars when searching for a main class”），然后找到主类 groovy.util.GroovyTestSuite，如图 1 所示：

在图 2 中，您可以看到当点击 Arguments 标签，写入脚本的路径时，会发生了什么：

运行一个自己喜欢的 JUnit Groovy 脚本，实在是很简单，只要在 Eclipse 中找到对应的运行配置就可以了。

用 Ant 和 Maven 进行测试

这 个像 JUnit 一样的框架的美妙之处还在于，它可以把整套测试作为 build 的一部分运行，不需要人工进行干预。随着越来越多的人把测试用例加入代码基（code base），整体的测试套件日益增长，形成一个极好的回归平台（regression platform）。更妙的是，Ant 和 Maven 这样的 build 框架已经加入了报告特性，可以归纳 Junit 批处理任务运行的结果。

把一组 Groovy 测试用例整合到某一个构建中的最简单的方法是把它们编译成普通的 Java 字节码，然后把它们包含在 Ant 和 Maven 提供的标准的 Junit 批命令中。幸运的是，Groovy 提供了一个 Ant 标签，能够把未编译的 Groovy 脚本集成到字节码中，这样，把脚本转换成有用的字节码的处理工作就变得再简单不过。例如，如果正在使用 Maven 进行构建工作，那么只需在maven.xml 文件中添加两个新的目标、在 project.xml 中添加两个新的相关性、在 build.properties 文件中添加一个简单的标志就可以了。

我要从更新 maven.xml 文件开始，用新的目标来编译示例脚本，如清单 8 所示：

 <goal name="run-groovyc" prereqs="java:compile,test:compile">

   <path id="groovy.classpath">
     <pathelement path="${maven.build.dest}"/>
     <pathelement path="target/classes"/>
     <pathelement path="target/test-classes"/>
     <path refid="maven.dependency.classpath"/>
   </path>
 <taskdef name="groovyc" classname="org.codehaus.groovy.ant.Groovyc">
    <classpath refid="groovy.classpath"/>
 </taskdef>
 <groovyc destdir="${basedir}/target/test-classes" srcdir="${basedir}/test/groovy" 
          listfiles="true">
	<classpath refid="groovy.classpath"/>
 </groovyc>
 </goal>

上面代码中发生了以下几件事。第一，我定义一个名为 run-groovyc 的新目标。该目标有两个前提条件， java:compile 编译示例源代码， test:compile 编译普通的 Java-JUnit 类。我还用 <path> 标签创建了一个 classpath。在该例中，classpath 把 build 目录（保存编译后的源文件）和与它相关的所有依存关系（即 JAR 文件）整合在一起。接着，我还用 <taskdef> Ant 标签定义了 groovyc 任务。

而且，请您注意我在 classpath 中是如何告诉 Maven 到哪里去找 org.codehaus.groovy.ant.Groovyc 这个类。在示例的最后一行，我定义了 <groovyc> 标签，它会编译在 test/groovy 目录中发现的全部 Groovy 脚本，并把生成的 .class 文件放在 target/test-classes 目录中。

一些重要细节

为了编译 Groovy 脚本，并运行生成的字节码，我必须要通过 project.xml 文件定义两个新的依存关系（ groovy 和 asm），如清单 9 所示：

  <dependency>
    <groupId>groovy</groupId>
    <id>groovy</id>
    <version>1.0-beta-6</version>
  </dependency>
  <dependency>
    <groupId>asm</groupId>
    <id>asm</id>
    <version>1.4.1</version>
  </dependency>

一旦将脚本编译成普遍的 Java 字节码，那么任何标准的 JUnit 运行器就都能运行它们。因为 Ant 和 Maven 都拥有 JUnit 运行器标签，所以下一步就是让 JUnit 挑选新编译的 Groovy 脚本。而且，因为 Maven 的 JUnit 运行器使用模式匹配来查找要运行的测试套件，所以需要在 build.properties 文件中添加一个特殊标记，如清单 10 所示，该标记告诉 Maven 去搜索类而不是搜索 .java 文件。

 maven.test.search.classdir = true

最后，我在 maven.xml 文件中定义了一个测试目标（ goal），如清单 11 所示。这样做可以确保 在单元测试运行之前，使用新的 run-groovyc 目标编译 Groovy 脚本。

  <goal name="test">
    <attainGoal name="run-groovyc"/>
    <attainGoal name="test:test"/>    	
  </goal>

最后一个，但并非最不重要

有了新定义的两个目标（一个用来编译脚本，另外一个用来运行 Java 和 Groovy 组合而成的单元测试），剩下的事就只有运行它们，检查是不是每件事都顺利运行！

在清单 12 中，您可以看到，当我运行 Maven，给 test 传递目标之后，会发生了什么，它首先包含 run-groovyc 目标（而该目标恰好还包含 java:compile 和 test:compile 这两个目标），然后包含 Maven 中自带的标准的 test:test 目标。请注意观察目标 test:test 是如何处理新生成的 Groovy 脚本（在该例中，是新 编译的 Groovy 脚本） 以及普通的 Java JUnit 测试。

$ ./maven test
test:
java:compile:
    [echo] Compiling to /home/aglover/dev/target/classes
    [javac] Compiling 15 source files to /home/aglover/dev/target/classes
test:compile:
    [javac] Compiling 4 source files to /home/aglover/dev/target/test-classes
run-groovyc:
    [groovyc] Compiling 2 source files to /home/aglover/dev/target/test-classes
    [groovyc] /home/aglover/dev/test/groovy/test/RegexFilterTest.groovy
    [groovyc] /home/aglover/dev/test/groovy/test/SimpleFilterTest.groovy
test:test:    
    [junit] Running test.RegexFilterTest
    [junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.656 sec    
    [junit] Running test.SimpleFilterTest
    [junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.609 sec
    [junit] Running test.SimplePackageFilterTest
    [junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.578 sec    
BUILD SUCCESSFUL
Total time: 42 seconds
Finished at: Tue Sep 21 17:37:08 EDT 2004