groovy

最新推荐文章于 2024-04-13 10:00:00 发布

xmdu

最新推荐文章于 2024-04-13 10:00:00 发布

阅读量707

点赞数 1

分类专栏：随意研究文章标签： groovy

随意研究专栏收录该内容

5 篇文章

订阅专栏

Groovy是一种运行在JVM上的动态语言，拥有Python和Ruby的特性。它与Java高度兼容，可直接集成到Java项目中。本文介绍Groovy的基础安装、使用方法及语法特点。

title: Groovy 语言简介

Groovy 是什么

groovy 是运行在 JVM 中、具有象 Python，Ruby 语言特性的灵活动态语言，groovy 代码被编译成 java 字节码，然后能集成到 java 应用程序中或者 web 应用程序。groovy 与 java 平台非常融合，groovy 的许多代码是使用 java 实现的，其余部分是用groovy 实现的，Groovy 仅仅是创建 java 类的一种新的途径。

Groovy Eclipse插件安装

详见：http://wujq4java.iteye.com/blog/1947658

groovy被称为java的替代语言，通过上图可以看出，java和groovy都是建立在JVM基础上的语言，即groovy和java一样都可以编译成JVM可读的.class文件。而且groovy完全兼容java语言，即所有java代码放到groovy代码中都是可运行的。

Groovy 使用

只需在原有的java项目中添加如下dependency依赖：

<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>2.3.6</version>
</dependency>

只需简单的引用一个groovy-all.jar包就可以了，是不是很方便。如果你已经安装好了groovy 的eclipse插件，那么你就可以在你的java工程中通过右键：New -> Other -> Groovy -> Groovy Class来创建一个groovy类（比如类 GroovyTest），大概是这样：

class GroovyTest {
    public GroovyTest() {
    }

    static main(args) {
    }
}

你会发现这个新创建的groovy类看上去和java类几乎没有什么区别（除了缺少public 和 void 关键字以外，当然类文件变成了GroovyTest.groovy）。

Groovy 脚步特性

groovy能够在运行时对源文件进行解释（编译），从而具有了脚步语言的特性。这样的话同样是修改源代码，如果修改java源文件需要重新编译打包和发布工程，但是修改groovy源文件后你什么都不需要做，jvm会在第一次执行修改后的groovy源文件时把它编译成.class文件。正是这个特性，使我们在nemo-oil和nemo-mobile工程中使用groovy来管理各种业务上的返利规则（易变动），nemo-oil工程的nemo.oil.biz.OilRuleMasterBiz类示范了如何在java代码中调用groovy代码。

Groovy 完整代码示例

/**
 * 中石油返利规则委托实现
 * @author Medeson.Zh
 */
class O_CUC_COMMON{
    def PLATINUM = "1" //白金卡
    def DIAMOND = "2" //钻石卡
    def TALLEST = 75000
    def rate = 0  //返利比例,需要委托类定义

    /**
     * 加油卡充值返利;
     * @param amount 加油金额
     * @param cardtype 卡类型
     * @return 返利金额
     */
    public int recharge(int amount,String cardtype){
        int value
        if (PLATINUM==cardtype)
            value = amount * 0.02
        else if (DIAMOND==cardtype)
            value = amount * 0.025
        else
            value = 0
        return value
    }

    /**
     * 套餐返利上限
     * @return Map
     */
    public Object active(){
        int bonuse = TALLEST*rate
        return ["base":TALLEST,"amount":bonuse]
    }

    /**
     * 消费返利
     * @param amount
     * @return
     */
    public Object consume(int amount,String cardType){
        int cons_1=0,cons_2=0
        if (amount>TALLEST){
            cons_1 = TALLEST*rate
            cons_2 = recharge(amount-TALLEST,cardType)
        }
        else
            cons_1 = amount*rate

        return ["inner":cons_1,"outer":cons_2]
    }
}

Groovy 语法特性

1 没有类型的 java，groovy在运行时自动识别类型

def var= "hello world"
println var.class

程序输出：
java.lang.String

2 不需要的 public，groovy 中默认的修饰符就是 public，所以 public 修饰符你根本就不需要写

def repeat(val){
    for (i = 0 ; i < 5 ; i++){
        println val
    }
}

3 不需要的语句结束符，Groovy 中没有语句结束符，即每条语句后不需要加“；”号，但是如果一行上有多条语句，则需要使用“；”号。

def var = "hello world"
def var2 = "dog"; def var3 = "cat"; def var4 = "bird"

4 一切皆对象，听起来象是“众生平等”的味道，事实上 groovy 对于对象是什么类型并不关心，一个变量的类型在运行中随时可以改变，一切根据需要而定。如果你赋给它 boolean ，那么不管它原来是什么类型，它接受 boolean 值之后就会自动把类型转变为 boolean 值。看下面的代码：

def var = "hello world,groovy!"
println var
println var.class
var = 1001
println var.class

程序输出：
hello world,groovy!
class java.lang.String
class java.lang.Integer

5 除了标准的 java.lang.String 以外（用 ’ 号括住）， groovy 还支持 Gstring 字符串类型（用 “ 号括住），GString可以使用 $(变量名) 的形式获取变量的值，看下面的代码：

def var = "hello world,groovy!"
def repeat(val){
    for (i = 0; i < 5; i++){
        println "This is ${i}:${val}"
    }
}
repeat(var)

程序输出：
This is 0:hello world,groovy!
This is 1:hello world,groovy!
This is 2:hello world,groovy!
This is 3:hello world,groovy!
This is 4:hello world,groovy!

6 循环，可以使用for (i in 0 .. 5 ) 这样的用法，其中的 0 .. 5 是一个范围,范围是一系列的值。例如 “0..5” 表明包含整数 0、1、2、3、4、5。

def var = "hello world,groovy!"
def repeat(val){
    for (i in 0 .. 5){
        println val
    }
}
repeat(var)

程序输出：
hello world,groovy!
hello world,groovy!
hello world,groovy!
hello world,groovy!
hello world,groovy!

7 Groovy 支持最常见的两个 java 集合：java.util.Collection 和 java.util.Map。

//Groovy 中这样来定义一个 Collection：
def collect = ["a", "b", "c"]
//除了声明时往集合中添加元素外，还可以用以下方式向集合中添加元素：
collect.add(1)
collect << "come on"
collect[5] = 100 
//Collection 使用类似数组下标的方式进行检索：
println collect[collect.size() - 1]
println collect[5]
//groovy 支持负索引：
println collect[-1]      // 索引其倒数第 1 个元素
println collect[-2]      // 索引其倒数第 2 个元素
//如此可以定义一个 Map:
def map = ['name':'john', 'age':14 , 'sex':'boy']
//添加项：
map = map + ['weight':25]       // 添加 john 的体重
map.put('length', 175)      // 添加 john 的身高
map.father = 'Keller'          // 添加 john 的父亲
//可以用两种方式检索值：
println map['father']       // 通过 key 作为下标索引
println map.length          // 通过 key 作为成员名索引

8 闭包是用 { 符号括起来的代码块，它可以被单独运行或调用，也可以被命名。类似‘匿名类’或内联函数的概念。闭包中最常见的应用是对集合进行迭代，下面定义了 3 个闭包对 map 进行了迭代：

map.each ({key,value->    //key,value 两个参数用于接受每个元素的键-值对
    println "$key:$value"})
map.each {println it}     //it 是一个关键字，代表 map 集合的每个元素
map.each ({println it.getKey() + "-->" + it.getValue()})
//除了用于迭代之外，闭包也可以单独定义：
def say = {word->
    println "Hi,$word!"
}
//调用：
say('groovy')
say.call('groovy&grails')

程序输出：
Hi,groovy!
Hi,groovy&grails!

Groovy 优势

Groovy 的优势除了其所具有的运行期解释的特性外，还有它抛弃了 java 烦琐的文法，同时增加一些简洁的语法（如闭包）。同样的语句，使用 groovy 能在最大限度上减少你的击键次数——这确实是“懒惰程序员们”的福音，例如如果需要写一个程序列出一个文件中每一行的数据，在每一行前面输出行号，groovy只需下面几行代码而已：

def number = 0
new File ('test.groovy').eachLine {line ->
    number++
    println "$number: $line"
}

Groovy 进阶

精通groovy（博客）- http://www.ibm.com/developerworks/cn/education/java/j-groovy/j-groovy.html

groovy in action 中文版（书籍）- http://vdisk.weibo.com/s/CPOlB