Groovy食谱: 第1章 介绍

Groovy是一种成功的、强大的、成熟的语言，所有优秀的Java开发人员都应该在他们的工具箱中拥有它。它可以用于使单元测试更富有表现力,脚本任务,比如XML解析或倒入数据,提供扩展点在您的应用程序中,最终用户可以自定义行为与自己的脚本,用于定义特定于域的语言表达可读的和简洁的业务规则,甚至作为一个成熟的通用语言编写应用程序的端到端基于groovy的Grails web框架。

Groovy的主要目标一直是通过提供一种优雅的语言来简化开发人员的工作，这种语言由于其类似java的语法而易于学习，但是它也为所有常见的编程任务提供了有用的特性和API。 Groovy还试图通过将Java推进到21世纪来解决Java的缺点。您现在就可以使用Groovy—无需等待Java 7、8或9—并且可以从闭包中获益;属性;列表、映射和正则表达式的本机语法;和更多。

关于Groovy的书籍已经有好几本了-这是Groovy受欢迎和成熟的又一个很好的标志-但Groovy Recipes的独特之处在于，它是最快掌握语言并在任何时间查找特定语言功能信息的最快方法 ，由于其结构清晰。 但它不仅仅是一堆技巧，因为如果你真的想学习Groovy，有一个故事可以读，一个引导之手，通过以一种非常自然和友好的方式逐步地教授你更多关于这门语言的知识，从而引导你获得启迪。说实话，我甚至发现了一些我自己都不知道的技巧!

我，Groovy项目经理！

我相信您会像我一样喜欢这本书，并且将其放在桌子上，以帮助您解决日常的开发工作。 借助Groovy Recipes，您将立即完成工作。

Guillaume Laforge (Groovy项目经理)
January 3, 2008

曾几何时，Java是您编写过一次并在任何地方运行的语言。能够在一个操作系统(比如OS X)上编写代码，然后不加修改地将代码放到另一个操作系统(Windows、Solaris或Linux)上，对于习惯于等待在自己机器上运行的版本的用户来说，这是一个巨大的胜利。在使用Java之前，您的操作系统似乎总是最不受支持的，不是吗?

随着我们对Java的进一步了解，平台(Java虚拟机，或JVM)提供了WORA的魔力，而不是语言。因此, 我们正处于第二次Java革命中——Java语言与150多种其他语言共享平台[^11]。 矛盾的是，随着Java语言失去其垄断地位，Java平台变得比以往任何时候都更加重要。

作为开发人员，我们有如此多的选择，是什么让Groovy从人群中脱颖而出呢?就这一点而言，为什么首先要超越古老的Java语言呢?我可以用一句话来概括:如果Java是在21世纪编写的，Groovy就是它的样子。

Groovy是一种新的语言。与其说它取代了旧技术，不如说它加强了旧技术。它是由Java开发人员创建的，他们希望代码编写的日常体验更简单。您不再需要费力地阅读所有这些样板代码。

然而，更重要的是，这不是“嘿，伙计们，让我们从头开始重写整个应用程序，以利用这种新的语言”的软件开发方法。不，这是一种“让我们使用一种与现有代码库无缝集成的语言”的方法。

Groovy在已经安装的JVM(1.4、1.5或1.6)上运行。您可以在用于Java开发的IDE中编写Groovy。您将其部署到生产中已有的相同应用程序服务器上。实际上，在类路径中放入一个groovy.jar，就可以“启用groovy”整个应用程序。

在本书中，我希望向经验丰富的Java资深人士展示将Groovy集成到现有代码库中有多么容易。 我希望通过展示一些可以立即解决日常问题的快速Groovy代码片段来吸引繁忙的Java开发人员。(“如何解析带有名称空间的XML文档？”) 但是最重要的是，我希望吸引希望将新生命注入一个拥有十几年历史的平台的Java开发人员。 闭包，特定于领域的语言和元编程等功能现在都可以在一个平台上使用，酷炫的孩子们似乎已经抛弃了那些落后于时代的平台。

一些技术书籍仅被阅读一次。 然后，在您学习了这些材料之后，这本书就坐在架子上，集尘。 如果我的预感是正确的，那么这将是您收藏中阅读的众多书籍之一， 在您成为Groovy大师之后，对您也还是很有帮助，就像您第一次阅读它一样。

我认为您会继续读这本书的原因是，为顺序访问而编写的书中，大多数人都会阅读，也就是说，除非您已阅读第1-6章，否则第7章没有意义。 本书针对随机访问进行了优化。 我试图以一种可以一遍又一遍地达到目的的方式来进行布局，因为您知道可以快速扫描目录以找到所需的代码片段。 每个部分都是一个独立的实体，包含大量面包屑，可为您指明相关主题。

在我写这本书的过程中，在我的笔记本电脑上保存一份PDF文档已经不止一次地证明了它的价值。如果一个PDF文件可以折角，那么我的文档就几乎是破旧不堪了。能够以电子方式搜索代码片段或短语(就在文本编辑器旁边的窗口中)绝对是无价的。它改变了我编写Groovy的方式，在我开始写这本书之前，我已经有多年的Groovy经验了!

Groovy的设计旨在吸引Java开发人员。 Groovy最终是Java。 在JVM上运行的其他语言就是其他语言。 JRuby [^12]的重点是使现有的Ruby代码在JVM上运行。 Jython [^13]的重点是使现有的Python代码在JVM上运行。 Groovy的重点是与您现有的Java代码集成。

我并不是要减少其他语言的价值。 如果您已经有使用另一种语言实现的现有代码库，那么好处是无可否认的。 但是，它们如何使现有Java代码库的Java开发人员受益呢？ Groovy和Java非常兼容，因此在大多数情况下，您可以获取Java文件foo.java，并将其重命名为foo.groovy。 您将拥有一个完全有效（和可执行）的Groovy文件。 该技巧不适用于JVM上的任何其他邻居。

但是，除了语言级别的兼容性之外，Groovy还使您可以大大减少通常用Java编写的代码量。 例如，让我们从一个名为Person.java的简单Java类开始，它具有两个属性firstName和lastName。 作为Java开发人员，我们从小就受过培训，可以创建具有私有属性的公共类。 所有对属性的外部访问都通过公共获取程序和设置程序进行路由。

public class Person {
  private String firstName;
  private String lastName;

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }
}

我并不反对现有的Java实践。封装提供了许多好处。不幸的是，它带来了沉重的啰嗦税。

我们花费了二十多行代码来定义一个具有两个属性的类。 每个新属性将使我们花六行代码来获取样板获取器和设置器。 现代IDE将为我们生成必需的getter和setter的事实并不能解决问题。 它使症状仅略微减轻痛苦。

相应的Groovy类是什么样的？ 您可以将Person.java重命名为Person.groovy，然后该文件将被编译，但是这并不是Groovy的习惯用法。

Java开发人员首先注意到Groovy是它的简洁。 好的Groovy代码是Java的精髓。 您可以在Person类的Groovy版本中立即看到以下内容：

class Person {
  String firstName
  String lastName
}

是的，仅此而已。 更好的是，它是Java类的直接替代。 将其编译为字节码，并且Groovy版本与Java版本没有区别。 您需要具有常规知识。 jar放在您的类路径中，但是就这样，您的Java代码可以无缝调用任何普通的旧Groovy对象（POGO）来代替具有相同名称和字段的POJO。

默认情况下，所有POGO都是公开的。 所有属性都是私有的。 每个字段都有getter和setter，但是这些方法是在字节码而不是源代码中自动生成的。 这会将新字段的6：1编码比率降低到正好1：1。 与Java类相比，看一下这个POGO，没有什么可以忽略的了。 它是POJO的核心，消除了所有语法噪声。

下面代码是用Groovy编译前生成的中间java源代码

public class Person extends java.lang.Object implements groovy.lang.GroovyObject {

    private java.lang.String firstName
    private java.lang.String lastName
    private static org.codehaus.groovy.reflection.ClassInfo $staticClassInfo
    public static transient boolean __$stMC
    private transient groovy.lang.MetaClass metaClass

    @groovy.transform.Generated
    public Person() {
        metaClass = 
    }

    protected groovy.lang.MetaClass $getStaticMetaClass() {
    }

    @groovy.transform.Generated
    @groovy.transform.Internal
    public groovy.lang.MetaClass getMetaClass() {
    }

    @groovy.transform.Generated
    @groovy.transform.Internal
    public void setMetaClass(groovy.lang.MetaClass mc) {
    }

    @groovy.transform.Generated
    @groovy.transform.Internal
    public java.lang.Object invokeMethod(java.lang.String method, java.lang.Object arguments) {
    }

    @groovy.transform.Generated
    @groovy.transform.Internal
    public java.lang.Object getProperty(java.lang.String property) {
    }

    @groovy.transform.Generated
    @groovy.transform.Internal
    public void setProperty(java.lang.String property, java.lang.Object value) {
    }

    @groovy.transform.Generated
    public java.lang.String getFirstName() {
    }

    @groovy.transform.Generated
    public void setFirstName(java.lang.String value) {
    }

    @groovy.transform.Generated
    public java.lang.String getLastName() {
    }

    @groovy.transform.Generated
    public void setLastName(java.lang.String value) {
    }

}

当然，您可以慢慢地开始一个接一个地添加Java语言特性。

如果您愿意，当然可以使用分号。您可以显式地说公共类Person和私有字符串firstName。没有什么可以阻止您在源代码中使用getter和setter。

回想一下，您可以将Person.java从字面上重命名为Person.groovy，并且在语法上仍然可以正确使用Groovy。 但是，当您看到Groovy版本的简单优雅之后，为什么还要增加所有这些复杂性呢？

让我们进一步探讨这个冗长的问题。考虑Java中规范的“Hello World”示例:

public class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello World");
  }
}

Groovy脚本隐式创建了公共类行以及公共静态void main()行，剩下的就是用于替换的代码：

println "Hello World"

同样，两者都是字节码兼容和完全可互换的。Groovy示例所做的工作与Java代码完全相同，只是使用了一小部分代码行。

最后一个例子是，打开一个简单的文本文件，逐行遍历它，然后打印结果，需要多少行Java代码?根据我的计算，大约有35行代码:

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class WalkFile {
  public static void main(String[] args) {
    BufferedReader br = null;
    try {
      br = new BufferedReader(new FileReader("../simpleFile.txt"));
      String line = null;
      while ((line = br.readLine()) != null) {
        System.out.println(line);
      }
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }

    finally {
      if (br != null) {
        try {
          br.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
}

我并不是在建议您仅考虑行数。 如果仅是您所关心的问题，则可以通过导入java.io.*而不是显式地导入每个类来简化此示例。 为了简洁起见，您可以将一些较短的捕获块上移到一行。 不，您对此代码应有的关注是固有的冗长性。 这是相应的Groovy代码：

new File("../simpleFile.txt" ).eachLine{ line ->
  println line
}

如果您想轻松快速地处理样式规则，您可以使用一个单行程序来替代Java示例中的35行。行数只是我喜欢Groovy的一个例子—我可以看到森林就是树木，这是一个真正的好处。 我编写的Groovy代码可以直接替代Java，这是另一个事实。 由于这些原因，我喜欢将Groovy视为“可执行伪代码”。

在科幻电影《黑客帝国》中，主角neo有两种选择。如果他吃了蓝色药丸，他将回到他的日常生活。没有什么变化。然而，如果他选择了红色药丸，他将获得一个全新的世界观。他会得到超级英雄的能力。(当然，他选择了红色药丸。如果他不这么做，那就算不上一部电影。)

Groovy同时提供了两个选择。

Groovy的“蓝色药丸”使Java更容易使用。正如所示的Person类示例，Groovy可以作为Java的替代，而不需要更改Java语言的任何语义。这应该会吸引保守组织。

在“红色药丸”下，Groovy引入了与Java不同的新语言构造。 File.eachLine是一个闭包-这是一种无需使用java.util.Iterator即可迭代文件的全新方法。 考虑将闭包包含在Java 1.8中，但是现在就在这里。 这应该使那些羡慕其他语言的炫酷功能的人们所希望，他们希望Java可以做类似的事情。

也许James Strachan在2003年8月29日说得最好，当时他向全世界介绍了他一直在做的一个小型开源项目。在一篇名为“Groovy: Java平台新动态语言的诞生”的博客中，他这样写道:

像Ruby和Python这样的动态类型语言似乎越来越受欢迎。我仍然不相信我们应该在不久的将来都转向动态类型语言——但是，我认为没有理由不能同时使用动态和静态类型语言，并选择最适合这项工作的工具。

“我一直想使用一种很酷的动态类型脚本语言，专门针对Java平台。有很多选择，但是没有一个是完全正确的，特别是从一个顽固的Java程序员的角度来看。Python和Ruby都很酷——尽管它们本身就是平台。我更喜欢一种动态语言，它构建在所有groovy Java代码和JVM之上。

因此，我一直在思考，Java平台是否应该从头开始设计自己的动态语言，以便更好地处理现有代码，创建/扩展普通Java可以使用的对象，反之亦然。Python/Jython[是]一个非常好的基础——添加Ruby中的一些好东西，可能还会添加一些AOP特性，这样我们就可以有一种真正groovy的新语言来编写Java对象脚本、编写测试用例，谁知道呢，甚至可以用它进行真正的开发。”

这就是Groovy的名字和世界观的由来。Groovy是一种具有您希望它具有的特性的语言。传统的Java开发变得更容易了，还是一种将其他语言的所有这些令人兴奋的新特性都放到JVM上的方法?答案是两者皆有。

安装Groovy与安装Ant、Tomcat或Java本身一样简单——解压缩发行版，创建环境变量，并确保二进制文件位于您的路径中。Groovy就绪后，您可以以任何方式运行它——编译或未编译，从shell或GUI控制台，或从命令行或web服务器。如果您有两分钟(或者更少)的时间，那么您就有足够的时间开始尝试Groovy。在您说“下一代Java开发”之前，本章将让您启动并运行。