Groovy让JAVA更美好

Groovy 作为一种基于JVM 的敏捷开发语言, 在很多领域已经名声鹊起, 对于很多有经验的程序员来说都不会陌生。今天在这里把Groovy的一些基础和有趣之处介绍给大家。

首先，Groovy的诞生告诉了大家，JVM上并不是只能跑JAVA一种语言编写的东西，因为Groovy做到了，并且Groovy能和JAVA很好地结合使用，包括与Spring的集成，创造出1+1〉2的效应。

然后，接触过Groovy的人就会发现，由于能直接使用JAVA的类库，使得Groovy的使用变得极其简单，并且在学习了Groovy的语法以后，很多人会被那些极简而又朴素优美的语法和代码语句完全吸引住。

Groovy既是一种面向对象的语言，又可以纯粹作为脚本语言，因此在Groovy的语法上，能看到很多Ruby以及Python的影子，这点弥补了JAVA在这方面的劣势。而作为有JAVA基础的程序员，Groovy的学习成本几乎为零。

Groovy标志性的特点就是动态，以及其简便强大的闭包，还有对文件处理的精简。

众所周知，JAVA在定义变量的时候就必须决定它的类型，而作为动态语言的Groovy,在为变量赋值的时候，才决定这个对象的类型，动态的好处就是灵活。当然这只是Groovy的冰山一角，很多时候，Groovy还作为对JAVA在脚本语言方面的补充而被使用。

有时候，当我们需要把一些含有编译期不可知、只有在运行期才能获得参数的公式、规则在编译期进行处理的时候，我们就会发现我们需要依赖脚本语言，当然我们也可以让JAVA直接去跑JAVA Script，但是当你看到Groovy强大的语法的时候，你就会明白你有更好的选择。
我们来看一个例子

 class Human{

 void help(){
    println("human help")
   }
}

class Animal{
   void help(){
     println("animal help")
   }
}


def takeHelp(helper){
   helper.help()
}
//Human a = new Human()
//a.help()
takeHelp(new Human())
takeHelp(new Animal())

我们可以看到执行结果为
human help
animal help


这就是Groovy对于动态性体现的一个经典例子：可以看到在takeHelp（helper）这个方法里，完全没有指定参数的类型，我们看到只要传入的对象有help()方法即能被正确执行，如果你已用惯了JAVA需要继承一个统一父类这样的语法，一定能体会Groovy的优势了。

再让我们来看一个Groovy闭包的例子

def closureTst = {
 para1,para2,closure -> 
 println("hello! $para2 & $para1");
 closure.call();
}

Closure clo1 = closureTst(1,2,{println("hello")});

执行的结果为

hello! 2 & 1
hello



这个例子中我们看到，Groovy用{ }来定义一个闭包，使用->的把变量和方法联系起来。并且我们可以看到，我们在执行closureTst方法的时候，第三个参数本身也是一个闭包块，能被call()方法执行。可以看出Groovy的闭包比JAVA的匿名内部类简练多了。

Groovy有趣的特性还是相当多的，包括像

 String str ='''Hello 
World!
'''

println(str);

Hello
World

用三个引号的形式直接来支持String的跨行，在JAVA中让人厌恶的+号终于可以再见了。

接下来我们说说在JAVA中使用Groovy的几种方法。
其实在JAVA里使用Groovy的方法非常多，这里就举几个最常用的例子。

例如我们写了一个Groovy的文件EmailGroovy.groovy,在JAVA的类中，我们可以这样用：

package cn.newtouch.rdc.test.groovy;

import groovy.lang.GroovyShell;

import java.io.File;


public class GroovyTest {

	public static void main(String args[]) throws Exception{
	    ClassLoader parent = GroovyTest.class.getClassLoader();  

	    File file = new File("EmailGroovy.groovy");    

        GroovyShell gs = new GroovyShell(parent);

        Object r =  gs.evaluate(file);
        System.out.println(r);

	}
}

我们可以通过文件的形式把Groovy文件读进来执行，也可以直接通过字符串读进来， 可以通过GroovyShell 、evaluate来执行整个groovy文件，也可以通过像

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

  Class<?> groovyClass = loader.parseClass(file);  
  GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();
groovyObject.invokeMethod();

这样的写法来明确地执行需要的方法。

说到这里，我们不妨来看下这个EmailGroovy.groovy的内容。

def emails = new XmlParser().parse("emails.xml");

emails.email.each{

  println"${it.@id} ${it.subject.text()}";

  }

这段代码是用来解析一个XML的，emails.xml这个XMl的内容为
<emails>

　　<email id='1'>

　　<subject>hello world</subject>

　　<sender>test@163.com</sender>

　　<receivedDate>2010-11-01 10:10:30</receivedDate>

　　</email>

　　<email id='2'>

　　<subject>hello world demo 2</subject>

　　<sender>test@2163.com</sender>

　　<receivedDate>2010-11-02 10:10:30</receivedDate>

　　</email>

　　<email id='3'>

　　<subject>hello world demo 3</subject>

　　<sender>test3@163.com</sender>

　　<receivedDate>2010-11-03 10:10:30</receivedDate>

　　</email>

　　</emails>


我们可以跑一下，结果为

1 hello world
2 hello world demo 2
3 hello world demo 3

短短的三行代码就解决了XML的解析。
这让用DOM4J和JDOM的同学情何以堪阿！

再者，在业界普遍使用Spring的今天，Groovy与Spring的集成也是非常的方便，我们可以使用类似像
<lang:groovy id="groovyTst"
script-source="classpath: EmailGroovy.groovy"
refresh-check-delay="10000">
</lang:groovy>
直接把Groovy文件编译出的JAVA字节码通过Spring的IOC容器来管理，就像使用普通的JAVA BEAN一样简单，并且通过refresh-check-delay参数，你可以动态地去在运行期去读取groovy文件的变化，而无需重启应用。

由于篇幅有限，本文对Groovy的介绍就到此为止，希望对想要了解动态语言的同学有帮助。