kapok

Andrew Glover （aglover@vanwardtechnologies.com）
CTO, Vanward Technologies
2004 年 8 月

雖然 Java 語言因其嚴(yán)密性和擴(kuò)展性的承諾而在整整一代程序員中勝出，但是 Groovy 預(yù)示了 Java 平臺(tái)上的一個(gè)編程新時(shí)代，這種語言是以方便性、適宜性和敏捷性為出發(fā)點(diǎn)定義的。在新的 alt.lang.jre 專欄的第二期文章中，Andrew Glover 對(duì)提議添加到 Java 平臺(tái)的標(biāo)準(zhǔn)編程語言作了非正式的介紹。

如果您在使用 Java 平臺(tái)（block），不管時(shí)間長(zhǎng)短，您都有可能聽說過 Groovy。Groovy 是超級(jí)明星開發(fā)人員 James Strachan 和 Bob McWhirter 發(fā)明的，它是一種敏捷開發(fā)語言，完全以 Java 編程 API 為基礎(chǔ)。Groovy 當(dāng)前正處于 Java Specification Request 的開始階段，它于 2004 年 3 月底獲得批準(zhǔn)。Groovy 還是一種腳本語言，有些人說它會(huì)永久性地改變您看待和使用 Java 平臺(tái)的方式。

在其對(duì) JSR 241 （請(qǐng)參閱 參考資料）的開放評(píng)論中，Groovy 的共同規(guī)范領(lǐng)導(dǎo)者 Richard Monson-Haefel 說他對(duì) Groovy 的支持是建立在總有一天 Java 平臺(tái)要包括一種敏捷開發(fā)語言這一信念上。與許多移植到 Java 平臺(tái)的腳本語言不同，Groovy 是 為 JRE 而寫的。在規(guī)范請(qǐng)求中（參閱 參考資料），Groovy 的制造者提出了“Java 不僅是一種編程語言，更是一個(gè)健壯的平臺(tái)，可以有多種語言在上面運(yùn)行和共存”（Monson-Haefel 語）的思想。

新 alt.lang.jre 專欄的這第二期文章的目的是讓讀者了解 Groovy。我首先回答關(guān)于這種新語言的一些最顯然的問題（為什么需要它？），然后以代碼為基礎(chǔ)概述 Groovy 最令人興奮的功能。

為什么需要另一種語言？
正如在 上個(gè)月的專欄 中介紹的，Groovy 不是與 JRE 兼容的惟一腳本語言。Python、Ruby 和 Smalltalk 就是成功地移植到 Java 平臺(tái)上的三種腳本語言。對(duì)于一些開發(fā)人員，這帶來了問題：為什么要另一種語言？畢竟，我們?cè)S多人已經(jīng)將 Java 代碼與 Jython 或者 JRuby 結(jié)合來快速開發(fā)應(yīng)用程序，為什么還要學(xué)習(xí)另一種語言？回答是 您不一定要學(xué)習(xí)一種新語言以用 Groovy 編碼。Groovy 與其他 JRE 兼容腳本語言的不同在于它的語法以及重用 Java 庫。Jython 和 JRuby 共享它們前身（分別是 Python 和 Ruby）的外觀，Groovy 讓人覺得就像是 Java 語言，不過限制要少得多。

關(guān)于本系列 雖然本系列的大多數(shù)讀者熟悉 Java 語言以及它是如何在跨平臺(tái)虛擬機(jī)上運(yùn)行的，但是只有少數(shù)人知道 Java Runtime Environment 可以承載 Java 語言之外的語言。本系列文章對(duì) JRE 的多種替代語言進(jìn)行了綜述。這里討論的大多數(shù)語言是開放源代碼的，許多是免費(fèi)使用的，有少數(shù)是商業(yè)產(chǎn)品，必須購買。在 alt.lang.jre 系列中介紹的所有語言都得到了 JRE 支持，并且作者相信它們?cè)鰪?qiáng)了 Java 平臺(tái)的動(dòng)態(tài)性和靈活性特征。

像 Jython 這樣的語言是在它們的父語言庫上建立的，而 Groovy 使用了 Java 開發(fā)人員最熟悉的功能和庫 —— 但是將它們放到了一個(gè)敏捷開發(fā)框架中。敏捷開發(fā)的基本宗旨是代碼應(yīng)該很好地適合范圍廣泛的任務(wù)，并可以不同的方式應(yīng)用。Groovy 通過以下方式落實(shí)了這些宗旨：

• 使開發(fā)人員不用編譯。
• 允許動(dòng)態(tài)類型。
• 使合成結(jié)構(gòu)容易。
• 使其腳本可以在普通 Java 應(yīng)用程序中使用。
• 提供一個(gè) shell 解析器。

這些特性使 Groovy 成為一種特別容易學(xué)習(xí)和使用的語言，不管您是有經(jīng)驗(yàn)的 Java 開發(fā)人員還是剛接觸 Java 平臺(tái)。在下面幾節(jié)中，我將詳細(xì)討論上述特性。

看呀，沒有 javac！
像許多腳本語言一樣，Groovy 不用為運(yùn)行時(shí)編譯。這意味著 Groovy 腳本是 在它們運(yùn)行時(shí) 解釋的，就像 JavaScript 是在觀看 Web 頁時(shí)由瀏覽器解釋的一樣。運(yùn)行時(shí)判斷會(huì)有執(zhí)行速度的代價(jià)，這有可能使腳本語言不能用于對(duì)性能有要求的項(xiàng)目，但是無編譯的代碼在構(gòu)建-運(yùn)行周期中可以提供很多好處。運(yùn)行時(shí)編譯使 Groovy 成為快速原型設(shè)計(jì)、構(gòu)建不同的實(shí)用程序和測(cè)試框架的理想平臺(tái)。

腳本的能力 腳本語言很流行，因?yàn)樗鼈內(nèi)菀讓W(xué)習(xí)并且為開發(fā)人員設(shè)置的限制較少。腳本語言通常使用簡(jiǎn)單的、相當(dāng)簡(jiǎn)潔的語法，這使開發(fā)人員可以用比大多數(shù)編程語言所需要的更少的代碼創(chuàng)建真實(shí)世界的應(yīng)用程序。像 Perl、Python、Ruby 和現(xiàn)在的 Groovy，用其敏捷方式編寫代碼而使編程工作達(dá)到一個(gè)新的效率水平。這種提高的敏捷性通常會(huì)使開發(fā)人員的效率提高。腳本語言的成功表明腳本不是一種小范圍內(nèi)使用的技術(shù)或者黑客的娛樂工具，而是一種由像 Google、Yahoo 和 IBM 這樣的世界級(jí)公司所使用的切實(shí)可行的技術(shù)。

例如，運(yùn)行腳本 Emailer.groovyin Groovy 就是在命令行鍵入 groovy Emailer.groovy 這么容易。如果希望運(yùn)行同樣的 Java 文件（Emailer.java），顯然必須鍵入額外的命令：javac Emailer.java，然后是 java Emailer。雖然這看起來可能有些微不足道，但是可以容易設(shè)想運(yùn)行時(shí)編譯在應(yīng)用程序開發(fā)的更大上下文中的好處。

可以在稍后看到，Groovy 還允許腳本放棄 main 方法以靜態(tài)地運(yùn)行一個(gè)關(guān)聯(lián)的應(yīng)用程序。

動(dòng)態(tài) dynamo
像其他主流腳本語言一樣，Groovy 不需要像 C++ 和 Java 語言這樣的正式語言的顯式類型。在 Groovy 中，一個(gè)對(duì)象的類型是在運(yùn)行時(shí)動(dòng)態(tài)發(fā)現(xiàn)的，這極大地減少了要編寫的代碼數(shù)量。首先可以通過分析清單 1 和 2 中的簡(jiǎn)單例子看到這一點(diǎn)。

清單 1 顯示了在 Java 語言中如何將一個(gè)本地變量聲明為 String。注意必須聲明類型、名和值。

String myStr = "Hello World";

在清單 2 中，您看到同樣的聲明，但是不需要聲明變量類型。

myStr = "Hello World"

您可能還注意到了，在清單 2 中我可以去掉聲明中的分號(hào)。在定義方法及其相關(guān)的參數(shù)時(shí)動(dòng)態(tài)類型有戲劇性的后果：多態(tài)具有了全新的意義！事實(shí)上，使用動(dòng)態(tài)類型，不使用 繼承就可以得到多態(tài)的全部能力。在清單 3 中，可以真正開始看到動(dòng)態(tài)類型在 Groovy 的靈活性方面所起的作用。

class Song{
  length
  name
}

class Book{
  name
  author
}

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

這里，我定義了兩個(gè) Groovy 類，Song 和 Book，我將在后面對(duì)它們進(jìn)一步討論。這兩個(gè)類都包含一個(gè) name 屬性。我還定義了一個(gè)函數(shù) doSomething，它以一個(gè) thing 為參數(shù)，并試圖打印這個(gè)對(duì)象的 name 屬性。

因?yàn)?doSomething 函數(shù)沒有定義其輸入?yún)?shù)的類型，只要對(duì)象包含一個(gè) name 屬性，那么它就可以工作。因此，在清單 4 中，可以看到在使用 Song 和 Book 的實(shí)例作為 doSomething 的輸入時(shí)會(huì)有什么現(xiàn)象。

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 中的動(dòng)態(tài)類型，清單 4 的最后兩行還揭示了創(chuàng)建對(duì)一個(gè)函數(shù)的引用有多容易。這是因?yàn)樵?Groovy 中 所有東西 都是對(duì)象，包括函數(shù)。

關(guān)于 Groovy 的動(dòng)態(tài)類型聲明最后要注意的是，它會(huì)導(dǎo)致更少的 import 語句。盡管 Groovy 需要 import 以顯式使用類型，但是這些 import 可以使用別名以提供更短的名字。

動(dòng)態(tài)類型綜述
下面兩個(gè)例子將到目前為止討論過的 Groovy 中的動(dòng)態(tài)類型的內(nèi)容放到一起。下面的 Java 代碼組和 Groovy 代碼組利用了 Freemarker（參閱 參考資料），這是一個(gè)開放源代碼模板引擎。這兩組代碼都只是簡(jiǎn)單地用一個(gè)目錄和文件名創(chuàng)建一個(gè) Template 對(duì)象，然后將相應(yīng)對(duì)象的內(nèi)容打印到標(biāo)準(zhǔn)輸出，當(dāng)然，不同之處是每一組代碼處理這項(xiàng)任務(wù)所需要的代碼量。

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 代碼相當(dāng)簡(jiǎn)單 —— 特別是如果以前從來沒見過腳本代碼時(shí)。幸運(yùn)的是，有清單 6 中的 Groovy 作為對(duì)比。現(xiàn)在這段代碼很簡(jiǎn)單！

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 代碼的一半那么長(zhǎng)，下面是原因：

• Groovy 代碼只需要一半的 import 語句。還要注意，freemarker.template.Configuration 使用了別名 tconf，使得語法更短。
  
  
• Groovy 允許類型為 Template 的變量 tmpl 不聲明其類型。
  
  
• Groovy 不需要 class 聲明或者 main 方法。
  
  
• Groovy 不關(guān)心任何相應(yīng)異常，使您可以不用導(dǎo)入 Java 代碼中需要的 IOException。

現(xiàn)在，在繼續(xù)之前，想一下您所編寫的最后一個(gè) Java 類。您可能不得不編寫很多 import 并聲明類型，并在后面加上同樣數(shù)量的分號(hào)。考慮用 Groovy 編寫同樣的代碼會(huì)是什么情況。可以使用簡(jiǎn)練得多的語法，不需要遵守這么多的規(guī)則，并且得到完全相同的行為。

想一下，如果您正好是剛剛開始……

特別靈活的語法
談到語法，靈活性是更有效地開發(fā)代碼的主要因素。很像其有影響的對(duì)手（Python、Ruby 和 Smalltalk），Groovy 極大地簡(jiǎn)化了核心庫的使用和它所模擬的語言（在這里是 Java 語言）的構(gòu)造。為了讓您對(duì) Groovy 語法的靈活性有一個(gè)大體概念，我將展示它的一些主要結(jié)構(gòu)，即類、函數(shù)（通過 def 關(guān)鍵詞）、閉包、集合、范圍、映射和迭代器。

類
在字節(jié)碼水平，Groovy 類是真正的 Java 類。不同之處在于 Groovy 將類中定義的所有內(nèi)容都默認(rèn)為 public，除非定義了特定的訪問修飾符。而且，動(dòng)態(tài)類型應(yīng)用到字段和方法，不需要 return 語句。

在清單 7 中可以看到 Groovy 中類定義的例子，其中類 Dog 有一個(gè) getFullName 方法，它實(shí)際上返回一個(gè)表示 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 中，推廣到有兩個(gè)屬性 —— fname 和 lname —— 的類 DogOwner ，就是這么簡(jiǎn)單！

class DogOwner{
  fname
  lname

  trainPet(pet){
    pet.obeyMaster()
  }
  
}

在清單 9 中，用 Groovy 設(shè)置屬性并對(duì) Dog 和 DogOwner 實(shí)例調(diào)用方法。現(xiàn)在很明顯，使用 Groovy 類比 Java 類要容易得多。雖然需要 new 關(guān)鍵詞，但是類型是可選的，且設(shè)置屬性（它隱式為 public）是相當(dāng)輕松的。

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 方法返回一個(gè) String 對(duì)象，在這里它是 “Mollie Waldo”。

第一類對(duì)象 第一類對(duì)象 是可以在運(yùn)行時(shí)用數(shù)據(jù)創(chuàng)建并使用的對(duì)象。第一類對(duì)象還可以傳遞給函數(shù)和由函數(shù)輸出、作為變量存儲(chǔ)、由其他對(duì)象返回。Java 語言自帶的基本數(shù)據(jù)類型，如 int 和 boolean，不認(rèn)為是第一類對(duì)象。許多面向?qū)ο蠹兇庹撜甙@這個(gè)小細(xì)節(jié)，一些人據(jù)此提出 Java 語言是否是真正的面向?qū)ο笳Z言。Groovy 通過將所有內(nèi)容聲明為對(duì)象而解決了這一問題。

Def
除了像許多腳本語言那樣將所有對(duì)象指定為第一類對(duì)象（見側(cè)欄），Groovy 還讓您創(chuàng)建 第一類函數(shù)，它本身實(shí)質(zhì)上就是對(duì)象。它們是用 def 關(guān)鍵詞定義的并在類定義之外。您實(shí)際上在 清單 3 中已經(jīng)看到了如何用 def 關(guān)鍵詞定義第一類函數(shù)，并在 清單 4 中看到使用了一個(gè)函數(shù)。Groovy 的第一類函數(shù)定義簡(jiǎn)單腳本時(shí)特別有用。

閉包
Groovy 中最令人興奮和最強(qiáng)大的功能是支持閉包。閉包（Closure） 是第一類對(duì)象，它類似于 Java 語言中的匿名內(nèi)部類。閉包和匿名內(nèi)部類都是可執(zhí)行的一段代碼，不過這兩者之間有一些細(xì)微的不同。狀態(tài)是自動(dòng)傳入傳出閉包的。閉包可以有名字。它們可以重復(fù)使用。而且，最重要且對(duì) Groovy 同樣成立的是，閉包遠(yuǎn)比匿名內(nèi)部類要靈活得多！

清單 10 展示了閉包的強(qiáng)大。清單中新的和改進(jìn)的 Dog 類包括一個(gè) train 方法，它實(shí)際上執(zhí)行創(chuàng)建了 Dog 實(shí)例的閉包。

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!

而且，閉包還可以接收參數(shù)。如清單 11 所示，postRequest 閉包接收兩個(gè)參數(shù)（location 和 xml），并使用 Jakarta Commons HttpClient 庫（參閱 參考資料）將一個(gè) XML 文檔發(fā)送給指定位置。然后這個(gè)閉包返回一個(gè)表示響應(yīng)的 String。閉包定義下面是一個(gè)使用閉包的例子。事實(shí)上，調(diào)用閉包就像調(diào)用函數(shù)一樣。

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

自動(dòng)裝箱 自動(dòng)裝箱或者裝箱轉(zhuǎn)換是一個(gè)自動(dòng)將像 int、double 和 boolean 這樣的基本數(shù)據(jù)類型自動(dòng)轉(zhuǎn)換為可以在 java.lang 包中找到的它們的相應(yīng)包裝類型的過程。這一功能出現(xiàn)在 J2SE 1.5 中，使開發(fā)人員不必在源代碼中手工編寫轉(zhuǎn)換代碼。

集合
將對(duì)象組織到像列表和映射這樣的數(shù)據(jù)結(jié)構(gòu)中是一項(xiàng)基本的編碼任務(wù)，是我們大多數(shù)人每天要做的工作。像大多數(shù)語言一樣，Groovy 定義了一個(gè)豐富的庫以管理這些類型的集合。如果曾經(jīng)涉足 Python 或者 Ruby，那么應(yīng)該熟悉 Groovy 的集合語法。如清單 12 所示，創(chuàng)建一個(gè)列表與在 Java 語言中創(chuàng)建一個(gè)數(shù)組很類似。（注意，列表的第二項(xiàng)自動(dòng)裝箱為一個(gè) Integer 類型。)

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

除了使列表更容易處理，Groovy 還為集合增加了幾個(gè)新方法。這些方法使得，如統(tǒng)計(jì)值出現(xiàn)的次數(shù)、將整個(gè)列表結(jié)合到一起、對(duì)列表排序變得非常容易。可以在清單 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 中非常容易處理的數(shù)據(jù)結(jié)構(gòu)。清單 14 中的映射包含兩個(gè)對(duì)象，鍵是 name 和 date。注意可以用不同的方式取得值。

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

println myMap["date"]

println myMap.date

范圍

在處理集合時(shí)，很可能會(huì)大量使用 范圍（Range）。 范圍 實(shí)際上是一個(gè)很直觀的概念，并且容易理解，利用它可以包含地或者排除地創(chuàng)建一組有序值。使用兩個(gè)點(diǎn) （..） 聲明一個(gè)包含范圍，用三個(gè)點(diǎn) （...） 聲明一個(gè)排除范圍，如清單 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

用范圍實(shí)現(xiàn)循環(huán)

在循環(huán)結(jié)構(gòu)中，范圍可以實(shí)現(xiàn)相當(dāng)巧妙的想法。在清單 16 中，將 aRange 定義為一個(gè)排除范圍，循環(huán)打印 a、b、c 和 d。

aRange = 'a'...'e'

for (i in aRange){
  println i
}

集合的其他功能

如果不熟悉 Python 和其他腳本語言，那么您在 Groovy 集合中發(fā)現(xiàn)的一些其他功能會(huì)讓您印象深刻。例如，創(chuàng)建了集合后，可以用負(fù)數(shù)在列表中反向計(jì)數(shù)，如清單 17 所示。

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

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

Groovy 還讓您可以用范圍分割列表。分割可獲得列表的準(zhǔn)確子集，如清單 18 所示。

fullName = "Andrew James Glover"

mName = fullName[7...13]

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

集合類似于 Ruby

如果愿意的話，還可以將 Groovy 集合作為 Ruby 集合。可以用類似 Ruby 的語法，以 << 語法附加元素、用 + 串接和用 - 對(duì)集合取差，甚至還可以用 * 語法處理集合的重復(fù)，如清單 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 中，迭代任何序列都相當(dāng)容易。迭代字符序列所需要的就是一個(gè)簡(jiǎn)單的 for 循環(huán)，如清單 20 所示。（正如您現(xiàn)在可能注意到的，Groovy 提供了比 Java 1.5 以前的傳統(tǒng)語法更自然的 for 循環(huán)語法。）

str = "uncle man, uncle man"

for (ch in str){
  println ch
}

Groovy 中的大多數(shù)對(duì)象具有像 each 和 find 這樣的以閉包為參數(shù)的方法。用閉包來迭代對(duì)象會(huì)產(chǎn)生幾種令人興奮的可能性，如清單 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 作為迭代器。在這里，閉包添加元素的值，完成時(shí) val 的值為 6。find 方法也是相當(dāng)簡(jiǎn)單的。每一次迭代傳遞進(jìn)元素。在這里，只是測(cè)試值是否為 3。

Groovy 的高級(jí)內(nèi)容
到目前為止，我著重講述的都是使用 Groovy 的基本方面，但是這種語言有比基本內(nèi)容多得多的內(nèi)容！我將以分析 Groovy 提供的一些高級(jí)開發(fā)功能作為結(jié)束，包括 Groovy 樣式的 JavaBeans 組件、文件 IO、正則表達(dá)式和用 groovyc 編譯。

GroovyBean！
永遠(yuǎn)不變的是，應(yīng)用程序最后要使用類似 struct 的對(duì)象表示真實(shí)世界的實(shí)體。在 Java 平臺(tái)上，稱這些對(duì)象為 JavaBean 組件，它們通常用于表示訂單、客戶、資源等的業(yè)務(wù)對(duì)象。Groovy 由于其方便的簡(jiǎn)寫語法，以及在定義了所需 bean 的屬性后自動(dòng)提供構(gòu)造函數(shù)，而簡(jiǎn)化了 JavaBean 組件的編寫。結(jié)果自然就是極大地減少了代碼，正如您可以自己從清單 22 和 23 中看到的。

在清單 22 中，可看到一個(gè)簡(jiǎn)單的 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 寫這個(gè) bean 時(shí)所發(fā)生的事。所要做的就是定義屬性，Groovy 會(huì)自動(dòng)給您一個(gè)很好的構(gòu)造函數(shù)以供使用。Groovy 還使您在操縱 LavaLamp 的實(shí)例時(shí)有相當(dāng)大的靈活性。例如，我們可以使用 Groovy 的簡(jiǎn)寫語法或者 傳統(tǒng)的冗長(zhǎng)的 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 操作很輕松，特別是與迭代器和閉包結(jié)合時(shí)。Groovy 使用標(biāo)準(zhǔn) Java 對(duì)象如 File、Reader 和 Writer，并用接收閉包作參數(shù)的額外方法增強(qiáng)了它們。如在清單 24 中，可以看到傳統(tǒng)的 java.io.File，但是帶有額外的、方便的 eachLine 方法。

import java.io.File

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

因?yàn)槲募?shí)質(zhì)上是一系列行、字符等，所以可以相當(dāng)簡(jiǎn)單地迭代它們。eachLine 方法接收一個(gè)閉包并迭代文件的每一行，在這里是 File-IO-Example.txt。 以這種方式使用閉包是相當(dāng)強(qiáng)大的，因?yàn)?Groovy 保證所有文件資源都是關(guān)閉的，不考慮任何異常。這意味著無需大量 try/catch/finally 子句就可以進(jìn)行文件 IO！

高級(jí)編譯
Groovy 腳本實(shí)際上是字節(jié)碼級(jí)別的 Java 類。因此，可以容易地用 groovyc 編譯 Groovy 腳本。可以通過命令行或者 Ant 使用 groovyc 以生成腳本的類文件。這些類可以用普通 java 命令運(yùn)行，只要 classpath 包括 groovy.jar 和 asm.jar，這是 ObjectWeb 的字節(jié)碼操縱框架。要了解更多編譯 Groovy 的內(nèi)容，請(qǐng)參閱 參考資料。

最大 RegEx
如果一種語言沒有正則表達(dá)式處理，則它是沒價(jià)值的。Groovy 使用 Java 平臺(tái)的 java.util.regex 庫 —— 但是做了少量基本的改變。例如，Groovy 使您可以用 ~ 表達(dá)式創(chuàng)建 Pattern 對(duì)象，用 =~ 表達(dá)式創(chuàng)建 Matcher 對(duì)象，如清單 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

您可能已經(jīng)注意到了，可以在上述清單中定義 String、str，而無需為每一新行添加結(jié)束引號(hào)和 +。這是因?yàn)?Groovy 放松了要求字符串串接的普通 Java 約束。運(yùn)行這段 Groovy 腳本會(huì)對(duì)匹配 water 的情況打印出 true，然后打印出一節(jié)詩，其中所有出現(xiàn) “every where”的地方都替換為 “nowhere”。

關(guān)于 （band）shell Groovy 提供了兩種不同的解釋器，使所有有效的 Groovy 表達(dá)式可以交互地執(zhí)行。這些 shell 是特別強(qiáng)大的機(jī)制，可以用它們迅速學(xué)習(xí) Groovy。

結(jié)束語
像所有嬰兒期的項(xiàng)目一樣，Groovy 是正在發(fā)展的語言。習(xí)慣于使用 Ruby 和 Python （或者 Jython）的開發(fā)人員可能會(huì)懷念 mixins、腳本導(dǎo)入（盡管可以將所需要的可導(dǎo)入腳本編譯為相應(yīng)的 Java 類）和方法調(diào)用的命名參數(shù)等這些功能的方便性。 但是 Groovy 絕對(duì)是一種發(fā)展中的語言。隨著其開發(fā)人員數(shù)量的增加，它很有可能結(jié)合這些功能及更多功能。

同時(shí)，Groovy 有很多優(yōu)點(diǎn)。它很好地融合了 Ruby、Python 和 Smalltalk 的一些最有用的功能，同時(shí)保留了基于 Java 語言的核心語法。對(duì)于熟悉 Java 平臺(tái)的開發(fā)人員，Groovy 提供了更簡(jiǎn)單的替代語言，且?guī)缀醪恍枰獙W(xué)習(xí)時(shí)間。對(duì)于剛接觸 Java 平臺(tái)的開發(fā)人員，它可以作為有更復(fù)雜語法和要求的 Java 語言的一個(gè)容易的入口點(diǎn)。

像在本系統(tǒng)討論的其他語言一樣，Groovy 不是要替代 Java 語言，而是作為它的另一種選擇。與這里討論的其他語言不一樣，Groovy 遵循 Java 規(guī)范，這意味著它有可能與 Java 平臺(tái)上的 Java 語言具有同等重要的作用。

在本月這一期 alt.lang.jre 文章中，介紹了 Groovy 的基本框架和語法，以及它的一些高級(jí)編程功能。下個(gè)月將介紹在 Java 開發(fā)人員中最受歡迎的腳本語言： JRuby。

參考資料

• 新 alt.lang.jre 系列是上個(gè)月開始的，首先是 Barry Feigenbaum 的文章 “Get to know Jython”（developerWorks，2004 年 7 月）。
  
  
• 從 Groovy 開放源代碼項(xiàng)目頁 下載 Groovy，在這里還可以學(xué)習(xí)更多有關(guān)編譯、單元測(cè)試、正則表達(dá)式等之類的內(nèi)容。
  
  
• 可以在 Java Community Process 主頁 找到“JSR 241: The Groovy programming language”。
  
  
• 閱讀 James Strachan 的“Groovy -- the birth of a new dynamic language for the Java platform”（Radio Userland，James Strachan 的 Weblog，2003 年 8 月），對(duì) Groovy 背后的思路有一個(gè)概念。
  
  
• 在 java.net weblogs 頁 上閱讀更多 Richard Monson-Haefel 對(duì) Groovy 的思想。
  
  
• Groovy 的一個(gè)最強(qiáng)大的功能是它的敏捷性。通過 Roy Miller 的“揭開極端編程的神秘面紗：重訪“XP 精華”，第 1 部分”（developerWorks，2002 年 8 月）學(xué)習(xí)有關(guān)敏捷開發(fā)（或者 XP） 的更多底層原理。
  
  
• Richard Hightower 和 Nicholas Lesiecki 的 Java tools for extreme programming（摘自 developerWorks，2002 年 7 月）是在 Java 平臺(tái)上進(jìn)行敏捷開發(fā)的從業(yè)者指導(dǎo)，包括關(guān)于“Building Java applications with Ant”的一章。
  
  
• 通過 Malcolm Davis 的 “利用 Ant 和 JUnit 進(jìn)行增量開發(fā)” （developerWorks，2000 年 11 月），學(xué)習(xí)有關(guān)用 Ant 構(gòu)建 Java（因而也包括 Groovy） 應(yīng)用程序的內(nèi)容。
  
  
• 在 “讓編譯和測(cè)試過程自動(dòng)化” （developerWorks，2001 年 8 月）中，Erik Hatcher 為您展示了如何結(jié)合 Ant 和 JUnit 以朝 XP 天堂更進(jìn)一步。
  
  
• Maven 是 Ant 的替代物，它可以很好地完成項(xiàng)目管理任務(wù)。通過 Charles Chan 的“項(xiàng)目管理：Maven 讓事情變得簡(jiǎn)單” （developerWorks，2003 年 4 月），學(xué)習(xí)有關(guān) Maven 的更多內(nèi)容。
  
  
• 面向方面的程序設(shè)計(jì)是一種構(gòu)建高度去耦和可擴(kuò)展的企業(yè)系統(tǒng)的敏捷開發(fā)技術(shù)。通過 Andrew Glover 的 “AOP 解決緊密耦合的難題” （developerWorks，2004 年 2 月），學(xué)習(xí)有關(guān) AOP 的更多內(nèi)容。
  
  
• JustGroovy 是一個(gè)專門針對(duì) Groovy 的 Web 網(wǎng)站。
  
  
• 在清單 6 中，開放源代碼模板引擎 Freemarker 結(jié)合了 Java 代碼和 Groovy 代碼段。
  
  
• 清單 11 中使用了 Jakarta Commons HttpClient 庫。
  
  
• Groovy 如果沒有像 Python 和 Ruby 這樣的語言的強(qiáng)大影響是不會(huì)變成今天這樣的。
  
  
• 可以在 developerWorks Java 技術(shù)專區(qū) 找到關(guān)于 Java 編程各個(gè)方面的文章。.
  
  
• 訪問 Developer Bookstore，獲取技術(shù)書籍的完整列表，其中包括數(shù)百本 Java 相關(guān)主題 的書籍。
  
  
• 還請(qǐng)參閱 Java 技術(shù)專區(qū)教程頁 以獲得 developerWorks 上關(guān)于 Java 的免費(fèi)教程的完整清單。
  
  
• 是否對(duì)無需通常的高成本入口點(diǎn)（entry point ）或短期評(píng)估許可證的 IBM 測(cè)試產(chǎn)品感興趣？developerWorks Subscription 針對(duì) WebSphere?、DB2?、Lotus?、Rational? 和 Tivoli? 產(chǎn)品提供了低成本的 12 個(gè)月單用戶許可證，包括基于 Eclipse 的 WebSphere Studio IDE，用于開發(fā)、測(cè)試、評(píng)估和展示您的應(yīng)用程序。