Groovy简单指南

        直白得说，对于这种脚本语言我一直都不是怎莫看好的。原因可能就是因为现在对于新的技术并没有那么渴求。但是我发现，这并不是一个好的想法。所以，我最终还是决定使用Groovy，看看风评颇好的它到底有什么过人之处。
        当然，我并没有十分了解这门语言，因此在我的论述中也可能存在有失偏驳之处。还望海涵。

环境搭建

        现在java的后端最流行的包管理构建工具莫过于maven。当然，本文的环境也将是基于maven构建的。其实构建的过程非常简单，只需要引入相应的JAR包依赖即可。

        <!-- https://mvnrepository.com/artifact/org.codehaus.groovy/groovy-all -->
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-all</artifactId>
            <version>2.4.5</version>
        </dependency>

---

        原则上只需要引入上述的依赖即可。

还是hello world

        似乎这是一个避不开的魔咒。程序入门的例子基本都要采取这个例子。实际上，我觉得这个例子已经有了一定的象征。啊哈哈，闲话不多说。开始正题。
        在你的项目里新建一个groovy的源文件即可，输入下面的一句代码。

package io.swagger.script
/**
 * Test
 * @author fulei.yang
 */
class Test {
    public static void main(String[] args) {
        println('hello world')
    }

}

        好了，让我们从这个最基本的例子来发掘信息，我们可以得到如下的一些信息：

1、groovy也可以像java有着严格的类结构，当然你只写一行println在groovy的文件里面也是完全可以执行的，之所以这麽做是因为这样可以方便java同groovy之间的相互调用。
2、groovy对一些基本的java操作进行了精简，当然，这还只是其中的很少一部分而已。

        好了接下来让我们看看运行的结果吧！你知道的这是非常重要的。

---

---

与java的区别

        事实上，groovy也是基于jvm的脚本语言，这一点大家能够在各种搜索引擎上找到相当丰富的答案，那阿福在这里也就不在赘述了。下面我们来看看比较基本的一些区别吧！

字符串

        在groovy中，单引号包裹的是字符串，然而，双引号包裹的就不是简单的字符串了，而是Gstring。这个GString可不简单。比如可以像下面这样用。

---

package io.swagger.script
/**
 *  Test
 * @author fulei.yang
 */
class Test {
    public static void main(String[] args) {
        def a= 12
        println("a===========${a}")
    }
}

---

        这句代码的结果也不难猜，这里是为了说明groovy会将Gstring中的$[}中的变量的值取出来。这是非常重要的一个特性，因为再也不需要使用+号连接字符串了好莫！当然，可能你很是关心这样的性能和效率，说实话，我也很担心，但是目前我在写这篇文章，这个问题就留待以后讨论！打个TODO在此哈！

基本数据类型

        对于java而言，有八种基本的数据类型，很多人其实都在一直讲这是上个时代的产物。因为这明显是上个面向过程的语言留下来的啊！伟大的面向对象的java怎么可能因为八种基本类型而玷污了面向对象的神圣誓言。实际上，这样的讨论在国外的论坛很是常见。那么，groovy是如何处理基本数据类型的。实际上，groovy将其视为对象，这是非常有意思的一件事。groovy作为一个脚本语言，完成了java向真正的面向对象的过渡。
        我们可以来看看简单的例子！

class Test {
    public static void main(String[] args) {
        def a= 12
        println("a===========${a}")
        println(a.byteValue())
    }
}

        在这里你就可以看到简单的例子，这里我们可以看到groovy即支持松散的脚本，也支持严格的class语法定义。爱与恨！

groovy中的集合

        我们知道，在java中最常用的类之一就是各种各样的容器，什么Map、List、Set等等。这很java。这些集合实际上就是各种各样的数据结构在java的source中的一种体现，这也就是强调去了解java源代码实现的原因了！因为只有你了解个各种实现，你才能选定在你当前的问题背景下的最适合的容器！
        好了，我们现在来看看groovy中都有哪些？
groovy的容器主要分为三种！lists、map、ranges。
        但是不一样的是，groovy为这些容器的操作提供了更加强大的功能。具体强大在哪里呢？

public static void main(String[] args) {
        //集合定义
        def lists=[1,3,4,5,6,7]
        //直接采取下标访问
        println(lists[1])
        //map定义
        def map=[
                '1':1,
                '2':2
        ]
        //map 访问
        println(map.get('1'))
        println(map."1")
        //range定义
        def range=1..10
        println(range.get(1))
    }

---

        从上面我们可以看得出来，当我们想初始化一个集合或者map的时候变的如此优雅，以至于大家不得不高兴的跳了起来，再也不用先new一个map，然后一个个的往里面put了。好吧，这里的range大家可能并不是很理解，但是实际上这就是一个范围，而groovy让你访问它也变的异常简单。
        说完了这些，我们来看看如何遍历lists吧！这里你会感觉到十分酸爽！

        //集合定义
        def lists=[1,3,4,5,6,7]
        lists.each {println(it)}

        什么就这一句，oh my god，这简直太简洁了好吗，当然越是简洁的代码其理解的成本就会越高，这是真理。那么，这里到底发生了什么，算了，让我们先来看下结果！

---

---

        果然，效果刚刚的，然而，我们需要考虑的是，为什么可以这样写！下面的章节为大家揭晓答案！

groovy的闭包

        我想大家如果或多或少的接触过脚本语言的话实际上都会接触过这个概念，这也是非常重要的一个概念，那么，实际上，闭包不是一个新的概念， 但是它通常用在函数式语言中， 它允许执行一个任意指定好的代码块。甚至你讲这个代码块当做函数的实参传入都完全莫有问题，好吧，这么强大的功能，阿福有些迫不及待了呢！
闭包不是一个新的概念， 但是它通常用在函数式语言中， 它允许执行一个任意指定好的代码块。通俗的说，一个闭包是一个用花括号围起来的语句块，像别的任何代码块，为了传递参数给闭包，闭包有一组可选的参数列表，通过“->”表示列表的结束。下面我们来试着定义一个自己的闭包的例子：

    def a={int a,int b -> return a+b}
    println(a.call(1,2))

        想要猜测到这里的结果实际上并不是什么难事！但是要理解内在的机理就比较复杂，而且对刚才遍历lists的例子有着根本性的帮助。
        我们继续的回到刚才的lists.each()上面去！永远记住，源代码包含的信息一定是最多的。

/**
     * Iterates through a List, passing each item to the given closure.
     *
     * @param self    the List over which we iterate
     * @param closure the closure applied on each element found
     * @return the self List
     * @since 2.4.0
     */
    public static <T> List<T> each(List<T> self, @ClosureParams(FirstParam.FirstGenericType.class) Closure closure) {
        return (List<T>) each((Iterable<T>) self, closure);
    }

        我们可以看到这个地方实际上传入了一个简单闭包和list本身。也就是说，每遍历一个元素，闭包将会执行一次。大家有兴趣的话，我们继续往进跟！

/**
     * Iterates through an Iterable, passing each item to the given closure.
     *
     * @param self    the Iterable over which we iterate
     * @param closure the closure applied on each element found
     * @return the self Iterable
     */
    public static <T> Iterable<T> each(Iterable<T> self, @ClosureParams(FirstParam.FirstGenericType.class) Closure closure) {
        each(self.iterator(), closure);
        return self;
    }

//
/**
     * Iterates through an Iterator, passing each item to the given closure.
     *
     * @param self    the Iterator over which we iterate
     * @param closure the closure applied on each element found
     * @return the self Iterator
     * @since 2.4.0
     */
    public static <T> Iterator<T> each(Iterator<T> self, @ClosureParams(FirstParam.FirstGenericType.class) Closure closure) {
        while (self.hasNext()) {
            Object arg = self.next();
            closure.call(arg);
        }
        return self;
    }

        问题的源头就在这里了，实际上这里依旧采取了迭代器的方式进行遍历，但是，这些操作都被放在了闭包的代码块中，我们使用它根本不需要care相关的东西好吗，再也不用百度一下！
        实际上，这里的高度抽象是因为我们把集合遍历的细节交给了所谓的闭包，而非我们亲手操作，那其实我们还可以这样做，我们将文件资源的管理依旧交给闭包！我们就可以做到只使用而不需要关注资源的释放问题了。事实上，groovy也是这样去简化IO操作的。下面来看看IO操作的例子！

        def file=new File("d://test.txt")
        file.eachLine {println(it)}

        好了，关于这个到处出现的it，该做出解释了！闭包实际上可以有参数也可以没有，这里的it即是隐含的参数，这一点很重要，lists的遍历还有文件的逐行读取均要使用到。

groovy数据库操作

        相比较java而言，groovy操作数据库的api就显得更加简洁了！先放示例代码！

//获取连接
def conn = Sql.newInstance(url: envMap.url, user: envMap.username, password: envMap.password, driverClassName: envMap.driver)
//执行查询并遍历
def sql='select * from test'
conn.eachRow(sql) {
               println(it.toString)
            }

---

        ok，就这么简单，我想这里最重要的是还是闭包，所以大家可以好好理解下闭包的概念，收益无穷啊！

总结

        终于来到了终点，下面我们总结下这篇文章的主旨，其主要描述了在groovy中与java不同之处以及groovy对一些基本java的操作的增强，当然，最重要也最难理解的概念就是闭包了！你知道的，这非常重要，可以说是groovy的灵魂。当然，groovy这么好，快点用起来吧！项目中可以直接调用groovy的。
        最后感谢大家能够看完这篇长文，祝大家技术不断进步！阿福在此拜谢！