groovy快速入門(ubuntu 14.04+IntelliJ)
本文適合於不熟悉 Groovy，但想快速輕鬆地瞭解其基礎知識的 Java開發人員。瞭解 Groovy 對 Java 語法的簡化變形，學習 Groovy 的核心功能，例如本地集合、內建正則表示式和閉包。編寫第一個 Groovy 類，然後學習如何使用 JUnit 輕鬆地進行測試。藉助功能完善的 Groovy 開發環境和使用技能，您將輕鬆完成本教程的學習。最重要的是，您將學會如何在日常 Java 應用程式開發中聯合使用 Groovy 和 Java 程式碼。
閱讀本文的前提條件：為了從本教程得到最大收穫，您應該熟悉 Java 語法和在 Java 平臺上進行面向物件開發的基本概念。如果熟悉C#的話，基本上也能很快上手。
本文預計時長：30分鐘
一、groovy簡介和環境搭建
本機環境：
ubuntu 14.04 64bit
JDK 1.7.67
IDE : intellij idea 13.1
1、groovy簡介
其官方介紹為,Groovy...
- is an agile and dynamic language for the Java Virtual Machine
- builds upon the strengths of Java but has additional power features inspired by languages like Python, Ruby and Smalltalk
- makes modern programming features available to Java developers with almost-zero learning curve
- provides the ability to statically type check and statically compile your code for robustness and performance
- supports Domain-Specific Languages and other compact syntax so your code becomes easy to read and maintain
- makes writing shell and build scripts easy with its powerful processing primitives, OO abilities and an Ant DSL
- increases developer productivity by reducing scaffolding code when developing web, GUI, database or console applications
- simplifies testing by supporting unit testing and mocking out-of-the-box
- seamlessly integrates with all existing Java classes and libraries
- compiles straight to Java bytecode so you can use it anywhere you can use Java
簡單說來：Groovy是一種執行在JVM上的動態語言，它吸取了Python,Ruby和Smalltalk等語言的優點，在Java語言的基礎之上增加了許多特色功能；對於Java開發人員來說掌握Groovy是沒有什麼太大障礙的；相比 Java 而言，語法更易懂，更易上手，更易除錯；無縫的集成了Java 的類和庫；編譯後的.groovy也是以class的形式出現的。
2、groovy下載
目前最新穩定版為Groovy 2.3 （2014-09-14）
這裡下載 ：
Download zip: groovy-binary-2.3.6.zip
3、groovy環境配置和Hello World!
1)首先解壓：
unzip groovy-binary-2.3.6.zip #解壓groovy unzip groovy-docs-2.3.6.zip #解壓docs
2) 進入到Groovy Shell命令介面：
[email protected]:~/developsoft/language/groovy/groovy-2.3.6/bin$ ./groovysh Groovy Shell (2.3.6, JVM: 1.7.0_67) Type ':help' or ':h' for help. ------------------------------------------------------------------------------- groovy:000> println "hello world!" hello world! ===> null groovy:000> :h
在Groovy Shell裡不必定義class可以直接寫程式碼，如下面進行一個for迴圈：
groovy:000> for(i=0;i<10;i++){
groovy:001> println("i:"+i);}
i:0
i:1
i:2
i:3
i:4
i:5
i:6
i:7
i:8
i:9
===> null
注意這裡，你可以發現i是沒有指定int型別的，這裡也是寫法上也是比較隨意的。
3)、將groovy加入到環境變數（可選）
將解壓後的groovy拷到/usr/local/groovy 目錄下：
[email protected]:/usr/local/groovy# cp -r /home/amosli/developsoft/language/groovy/groovy-2.3.6 .
將groovy路徑拷到/etc/profile裡：
gedit /etc/profile #使用gedit開啟profile,也可以使用vi等工具
將下面內容拷到profile裡最後位置：
export GROOVY_HOME=/usr/local/groovy/groovy-2.3.6 export PATH=$GROOVY_HOME/bin:$PATH:. export GROOVY_HOME export PATH
全部的profile內容：
# /etc/profile: system-wide .profile file for the Bourne shell (sh(1))
# and Bourne compatible shells (bash(1), ksh(1), ash(1), ...).
if [ "$PS1" ]; then
if [ "$BASH" ] && [ "$BASH" != "/bin/sh" ]; then
# The file bash.bashrc already sets the default PS1.
# PS1='\h:\w\$ '
if [ -f /etc/bash.bashrc ]; then
. /etc/bash.bashrc
fi
else
if [ "`id -u`" -eq 0 ]; then
PS1='# '
else
PS1='$ '
fi
fi
fi
# The default umask is now handled by pam_umask.
# See pam_umask(8) and /etc/login.defs.
if [ -d /etc/profile.d ]; then
for i in /etc/profile.d/*.sh; do
if [ -r $i ]; then
. $i
fi
done
unset i
fi
JAVA_HOME=/usr/local/java/jdk1.7.0_67
PATH=$PATH:$HOME/bin:$JAVA_HOME/bin
export JAVA_HOME
export PATH
export GROOVY_HOME=/usr/local/groovy/groovy-2.3.6
export PATH=$GROOVY_HOME/bin:$PATH:.
export GROOVY_HOME
export PATH
更新環境變數：
source /etc/profile
驗證是否成功：
# groovy -version Groovy Version: 2.3.6 JVM: 1.7.0_67 Vendor: Oracle Corporation OS: Linux
開啟groovyConsole:
4)、使用IDE進行開發(這裡以Intellij idea 13.1為例)
1. Enable the plugin
Before you create your first Groovy application make sure Groovy plugin is enabled in Settings → Plugins.
2. Create a new project
Open Project Wizard and select Scala template. Since Groovy requires Java you have to specify the Project SDK.
If you create a Groovy project for the first time IntelliJ IDEA will offer you to create Groovy SDK library. Press Create button and choose directory with a Groovy SDK.
The IDE will create an empty project.
3. Create a new class
The easiest way to create Groovy class or script is to use Ctrl + N shortcut from Project View or Navigation Bar.
Choose between class, interface, enum and annotation with Up and Down arrows.
Let's create a class with a method returning "Hello, world!" string.
4. Create a new script
Now we can create a script file via Ctrl + N shortcut.
Choose between script and GroovyDSL script with Up and Down arrows.
Now we can create an instance of our class and invoke hello method.
5. Run the project
In order to run the application you can manually create a Run configuration via Run → Edit configurations or run the active script automatically by pressing Ctrl + Shift + F10 shortcut.
使用Groovy Shell :
開啟Tools-->Groovy Shell...
使用Groovy Console :
開啟Tools-->Groovy Console...
二、Groovy初探
1、Groovy和Java對比
- Groovy 的鬆散的 Java 語法允許省略分號和修改符。
- 除非另行指定，Groovy 的所有內容都為
public。 - Groovy 允許定義簡單指令碼，同時無需定義正規的
class物件。 - Groovy 在普通的常用 Java 物件上增加了一些獨特的方法和快捷方式，使得它們更容易使用。
- Groovy 語法還允許省略變數型別。
- 關於閉包:可以將閉包 想像為一個程式碼塊，可以現在定義，以後再執行。可以使用這些強大的構造做許多漂亮的事，不過最著名的是簡化迭代。使用 Groovy 之後，就有可能再也不需要編寫
Iterator例項了。 -
動態的 Groovy: 從技術上講，Groovy 可能是您最近聽說過的型別最鬆散的動態語言之一。從這個角度講，Groovy 與 Java 語言的區別很大，Java 語言是一種固定型別語言。在 Groovy 中，型別是可選的，所以您不必輸入
String myStr = "Hello";來宣告String變數。可以直接使用def進行不指定型別定義，類似於js中的var。 - 與Java互用：用 Groovy 編寫的任何內容都可以編譯成標準的 Java 類檔案並在 Java 程式碼中重用。類似地，用標準 Java 程式碼編寫的內容也可以在 Groovy 中重用。
2、例項演示Java和Groovy的區別
用 Java 編寫的 Hello World
用 Java 編寫的典型的 Hello World 示例如下所示：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
編譯和執行 Java 示例
在這個簡單的 HelloWorld 類中，我省略了包，而且向控制檯輸出的時候沒有使用任何多餘的編碼約定。下一步是用 javac 編譯這個類，如下所示：
c:>javac HelloWorld.java
最後，執行經過編譯的類：
c:>java HelloWorld
迄今為止還不錯 — 很久以前就會編這麼基礎的程式碼了，所以這裡只是回顧一下。下面，請看用 Groovy 編碼的相同過程。
用 Groovy 編寫的 Hello World
就像前面提到過的，Groovy 支援鬆散的 Java 語法 — 例如，不需要為列印 “Hello World!” 這樣的簡單操作定義類。
而且，Groovy 使日常的編碼活動變得更容易，例如，Groovy 允許輸入 println，而無需輸入 System.out.println。當您輸入 println時，Groovy 會非常聰明地知道您指的是 System.out。
所以，用 Groovy 編寫 Hello World 程式就如下面這樣簡單：
println "Hello World!"
請注意，在這段程式碼周圍沒有類結構，而且也沒有方法結構！我還使用 println 代替了 System.out.println。
執行 Groovy 示例
假設我將程式碼儲存在檔案/home/amosli/developsoft/language/groovy/test/Hello.groovy 內，只要輸入以下程式碼就能執行這個示例：
[email protected]:~/developsoft/language/groovy/groovy-2.3.6/bin$ ./groovy ../../test/Hello.groovy Hello World!
如果已經配置了groovy的環境變數，那麼只需要輸入以下命令即可：
[email protected]:/home/amosli/developsoft/language/groovy/test# groovy Hello.groovy Hello World!
在控制檯上輸出 “Hello World!” 所需的工作就這麼多。
更快捷的方式
[email protected]:~/developsoft/language/groovy/groovy-2.3.6/bin$ ./groovy -e "println 'helloworld '" helloworld
如果已經配置了groovy的環境變數，那麼只需要輸入以下命令即可：
[email protected]:/home/amosli/developsoft/language/groovy/test# groovy -e "println 'helloworld '" helloworld
這會生成相同的結果，而且甚至無需定義任何檔案！
3、Groovy 是沒有型別的 Java 程式碼
很可能將 Groovy 當成是沒有規則的 Java 程式碼。但實際上，Groovy 只是規則少一些。這一節的重點是使用 Groovy 編寫 Java 應用程式時可以不用考慮的一個 Java 程式設計的具體方面：型別定義。
為什麼要有型別定義？
在 Java 中，如果要宣告一個 String 變數，則必須輸入：
String value = "Hello World";
但是，如果仔細想想，就會看出，等號右側的字元已經表明 value 的型別是 String。所以，Groovy 允許省略 value 前面的 String 型別變數，並用 def 代替。
def value = "Hello World"
實際上，Groovy 會根據物件的值來判斷它的型別。
執行程式！
將 HelloWorld.groovy 檔案中的程式碼編輯成下面這樣：
String message = "Hello World" println message.class //class java.lang.String
4、通過 Groovy 進行迴圈
方式1：
這裡可以定義i為int 或者 def ，或者不定義其型別
for(i = 0; i < 5; i++){
println i
}
方式2：
使用in進行迴圈，其中..表示“到”，0..5表示0到5，類似於0<=5;這裡迴圈6次；
for(i in 0..5){
println i
}
可以使用0..<5進行限定，類似於0<5,迴圈5次;
5、Groovy中的集合
1)、Groovy 中的List
def range = 0..4 println range.class assert range instanceof List
請注意，assert 命令用來證明範圍是 java.util.List 的例項。接著執行這個程式碼，證實該範圍現在是型別 List 的集合。
Groovy 的語法:
def coll = ["Groovy", "Java", "Ruby"] assert coll instanceof Collection assert coll instanceof ArrayList
你將會注意到，coll物件看起來很像 Java 語言中的陣列。實際上，它是一個Collection。要在普通的 Java 程式碼中得到集合的相同例項，必須執行以下操作：
Collection<String> coll = new ArrayList<String>();
coll.add("Groovy");
coll.add("Java");
coll.add("Ruby");
在 Java 程式碼中，必須使用 add() 方法向 ArrayList 例項新增項。
而Groovy中則提供了3種方法：
coll.add("Python")
coll << "Smalltalk"
coll[5] = "Perl"
查詢元素:
如果需要從集合中得到某個特定項，可以通過像上面那樣的位置引數獲取項。例如，如果想得到第二個項 “Java”，可以編寫下面這樣的程式碼（請記住集合和陣列都是從 0 開始）： assert coll[1] == "Java" Groovy 還允許在集合中增加或去掉集合，如下所示： def numbers = [1,2,3,4] assert numbers + 5 == [1,2,3,4,5] assert numbers - [2,3] == [1,4]
Groovy中的特殊方法：
def numbers = [1,2,3,4]
assert numbers.join(",") == "1,2,3,4"
assert [1,2,3,4,3].count(3) == 2
join() 和 count() 只是在任何項List上都可以呼叫的眾多方便方法中的兩個。分佈操作符（spread operator） 是個特別方便的工具，使用這個工具不用在集合上迭代，就能夠呼叫集合的每個項上的方法。
假設有一個 String 列表，現在想將列表中的專案全部變成大寫，可以編寫以下程式碼： assert ["JAVA", "GROOVY"] == ["Java", "Groovy"]*.toUpperCase() 請注意 *. 標記。對於以上列表中的每個值，都會呼叫 toUpperCase()，生成的集合中每個 String 例項都是大寫的。
2）Groovy中的Map
Java 語言中的對映是名稱-值對的集合。所以，要用 Java 程式碼建立典型的對映，必須像下面這樣操作：
Map<String, String>map = new HashMap<String, String>();
map.put("name", "Andy");
map.put("VPN-#","45");
Groovy 使得處理對映的操作像處理列表一樣簡單 — 例如，可以用 Groovy 將上面的 Java 對映寫成
def hash = [name:"Andy", "VPN-#":45]
請注意，Groovy 對映中的鍵不必是 String。在這個示例中，name 看起來像一個變數，但是在幕後，Groovy 會將它變成 String。
驗證hash格式：
assert hash.getClass() == java.util.LinkedHashMap
Groovy 中Hash的Set/Get
//方法1
hash.put("id", 23)
assert hash.get("name") == "Andy"
//方法2
hash.dob = "01/29/76"
//. 符號還可以用來獲取項。例如，使用以下方法可以獲取 dob 的值：
assert hash.dob == "01/29/76"
//方法3
assert hash["name"] == "Andy"
hash["gender"] = "male"
assert hash.gender == "male"
assert hash["gender"] == "male"
請注意，在使用 [] 語法從對映獲取項時，必須將項作為 String 引用。
6、Groovy 中的閉包
Java 的 Iterator 例項，用它在集合上迭代，就像下面這樣：
def acoll = ["Groovy", "Java", "Ruby"]
for(Iterator iter = acoll.iterator(); iter.hasNext();){
println iter.next()
}
請注意，each 直接在 acoll 例項內呼叫，而 acoll 例項的型別是 ArrayList。在 each 呼叫之後，引入了一種新的語法 —{，然後是一些程式碼，然後是 }。由 {} 包圍起來的程式碼塊就是閉包。
def acoll = ["Groovy", "Java", "Ruby"]
acoll.each{
println it
}
閉包中的 it 變數是一個關鍵字，指向被呼叫的外部集合的每個值 — 它是預設值，可以用傳遞給閉包的引數覆蓋它。下面的程式碼執行同樣的操作，但使用自己的項變數：
def acoll = ["Groovy", "Java", "Ruby"]
acoll.each{ value ->
println value
}
在這個示例中，用 value 代替了 Groovy 的預設 it。
def hash = [name:"Andy", "VPN-#":45]
hash.each{ key, value ->
println "${key} : ${value}"
}
請注意，閉包還允許使用多個引數 — 在這個示例中，上面的程式碼包含兩個引數（key 和 value）。
請記住，凡是集合或一系列的內容，都可以使用下面這樣的程式碼進行迭代。
> "amosli".each{
println it.toUpperCase();
}
A
M
O
S
L
I
def excite = {
word-> return "this is ${word} "
};
這段程式碼是名為 excite 的閉包。這個閉包接受一個引數（名為 word），返回的 String 是 word 變數加兩個感嘆號。請注意在 String 例項中替換 的用法。在 String 中使用 ${value}語法將告訴 Groovy 替換 String 中的某個變數的值。可以將這個語法當成 return word + "!!" 的快捷方式。
//可以通過兩種方法呼叫閉包：直接呼叫或者通過 call() 方法呼叫。
excite("Java");
excite.call("Groovy")
輸出：this is Groovy
7、Groovy 中的類
新建一個類song:
class Song {
def name
def artist
def genre
}
class SongExample {
static void main(args) {
def sng = new Song(name:"Le Freak",
artist:"Chic", genre:"Disco")
}
}
Groovy 自動提供一個建構函式，建構函式接受一個名稱-值對的對映，這些名稱-值對與類的屬性相對應。這是 Groovy 的一項開箱即用的功能 — 用於類中定義的任何屬性，Groovy 允許將儲存了大量值的對映傳給建構函式。對映的這種用法很有意義，例如，您不用初始化物件的每個屬性。
也可以新增下面這樣的程式碼：
def sng2 = new Song(name:"Kung Fu Fighting", genre:"Disco")
也可以像下面這樣直接操縱類的屬性：
def sng3 = new Song()
sng3.name = "Funkytown"
sng3.artist = "Lipps Inc."
sng3.setGenre("Disco")
assert sng3.getArtist() == "Lipps Inc."
在 Song 類中，新增以下程式碼：
String toString(){
"${name}, ${artist}, ${genre}"
}
8、Groovy中的單元測試
@Test
public void test(){
def sng2 = new Song(name:"Kung Fu Fighting", genre:"Disco")
println sng2.getArtist();
}
在Intellij 中只需要加入@Test註解就可以使用JUnit 測試
加個?可以防止空指標的錯誤：
def getArtist(){
artist?.toUpperCase();
}
9、擴充套件
如果需要用Groovy做web 專案的話可以去了解一下Grails框架。
本文原始碼:https://github.com/amosli/groovy
參考：
1.http://confluence.jetbrains.com/display/IntelliJIDEA/Groovy
2.http://www.ibm.com/developerworks/cn/education/java/j-groovy/j-groovy.html
3.http://groovy.codehaus.org/
4.http://confluence.jetbrains.com/display/IntelliJIDEA/Getting+Started+with+Grails