Groovy(多功能类型化与动态语言编程工具)

　　Apache Groovy是一款功能强大的可选类型化和动态语言，具有Java平台的静态类型和静态编译功能，旨在通过简洁，熟悉且易于学习的语法提高开发人员的工作效率；它可以与任何Java程序顺利集成，并立即为您的应用程序提供强大的功能，包括脚本编写功能，特定领域语言编写，运行时以及编译时元编程和函数式编程；Groovy带有集成支持，可在Groovy对象和JSON之间进行转换，groovy.json包中提供了专用于JSON序列化和解析的类；支持解析器变体，JsonSlurper带有一些解析器实现，每个解析器都适合不同的要求，很可能在某些情况下，JsonSlurper默认解析器并不是在所有情况下的最佳选择，这是附带的解析器实现的概述，该JsonParserCharArray分析器基本上采用JSON字符串和底层字符阵列上操作，在值转换期间，它会复制字符子数组并对其进行操作；Groovy的groovy-sql模块提供了Java JDBC技术之上的更高层次的抽象，JDBC本身提供了一个较低层但相当全面的API，该API提供对各种受支持的关系数据库系统的统一访问；在这里的示例中，系统将使用HSQLDB，用户也可以使用Oracle，SQL Server，MySQL和其他主机；groovy-sql模块中最常用的类是groovy.sql.Sql将JDBC抽象提升一级的类！

软件功能

　　学习曲线平坦

　　简洁，易读且富有表现力的语法，Java开发人员易于学习

　　流畅的Java集成

　　无缝和透明地集成Java和任何第三方库并与之互操作

　　充满活力的生态系统

　　Web开发，反应性应用程序，并发/异步/并行性库，测试框架，构建工具，代码分析，GUI构建强大的功能

　　闭包，构建器，运行时和编译时元编程，功能编程，类型推断和静态编译

　　领域特定语言

　　灵活可延展的语法，高级集成和自定义机制，可在您的应用程序中集成可读的业务规则

　　脚本和测试胶

　　非常适合编写简洁且可维护的测试，以及所有构建和自动化任务

软件特色

　　SC：子类对包私有或私有字段的访问未指示为错误

　　不存在的类的Groovsh导入将引发空指针而不是语法错误

　　将具有类型参数的特征实现为原始类型时为NPE

　　如果类型引用使用方法引用，则解析了错误的类型方法

　　在groovyc 3.0和4.0中回归，并在特征中使用通用静态方法编译静态

　　STC：UnionTypeClassNode是为简单的instanceof场景创建的

　　Groovy 3生成的lambda类被标记为合成

　　STC：从Closure到外部类私有字段的putAt快捷方式符号导致GroovyCastException

　　AnnotationCollectorTransform生成未标有@Generated的代码

　　静态上下文中与可调用属性不一致

　　避免潜在的NPE在antlr2 groovysh

　　SC：在条件块中分配的变量的强制转换异常

　　lambda参数类型错误时引发的Bootstrap方法初始化异常

　　SC：跨包保护的字段访问使用动态属性方法

　　使用方法引用会导致编译器错误，方法参考不接受参数的子类型

　　对象未与Groovy绑定（但在Java中工作正常）

　　@AutoImplement不考虑声明的属性，JSP API许可证似乎丢失

　　STC：CollType <的传播安全和列表属性访问错误<？扩展了ItemType>

　　STC中的StackOverflowError，用较新的可用变体替换一些旧的api用法

　　在某些情况下丢失了超级接口的接口常量

　　更好地传播了InterruptedException

　　静态内部类的静态内部类缺少内部类表属性

使用教程

　　1.默认导入

　　默认情况下，所有这些包和类都是导入的，即，您不必使用显式import语句来使用它们：

　　java.io. *

　　java.lang。*

　　java.math.BigDecimal

　　java.math.BigInteger

　　java.net。*

　　java.util。*

　　groovy.lang。*

　　groovy.util。*

　　2.多种方法

　　在Groovy中，将在运行时选择要调用的方法。这称为运行时调度或多方法。这意味着将在运行时根据参数的类型选择方法。在Java中，情况恰恰相反：方法是在编译时根据声明的类型选择的。

　　以下用Java代码编写的代码可以用Java和Groovy进行编译，但是它们的行为有所不同

　　而在Groovy中：

　　assertEquals(1, result);

　　这是因为Java将使用静态信息类型，该信息类型o被声明为Object，而Groovy将在运行时实际调用该方法时进行选择。由于它是带一个String，那么 String版本被调用。

　　3.数组初始化器

　　在Java中，数组初始化器采用以下两种形式之一：

　　int[] array = {1, 2, 3}; // Java array initializer shorthand syntax

　　int[] array2 = new int[] {4, 5, 6}; // Java array initializer long syntax

　　在Groovy中，该{ … }块保留用于闭包。这意味着您无法使用Java的数组初始化器简写语法创建数组文字。您改为借用Groovy的文字列表表示法，如下所示：

　　int[] array = [1, 2, 3]

　　对于Groovy 3+，可以选择使用Java的数组初始化程序长语法：

　　def array2 = new int[] {1, 2, 3} // Groovy 3.0+ supports the Java-style array initialization long syntax

　　4.包范围可见性

　　在Groovy中，在字段上省略修饰符不会像Java中那样导致程序包专用字段

　　Groovy 3+支持此类块。但是，Groovy提供了各种依赖于闭包的方法，这些方法具有相同的效果，但更加惯用

　　6.内部班级

　　匿名内部类和嵌套类的实现紧随Java，但是有一些区别，例如，从此类中访问的局部变量不必是最终的。我们groovy.lang.Closure 在生成内部类字节码时会使用一些实现细节。

　　静态内部类的使用是最受支持的一种。如果您绝对需要一个内部类，则应使其成为静态类。

　　但是请注意，Groovy支持使用一个参数调用方法而不给出参数。该参数的值将为null。基本上，相同的规则适用于调用构造函数。例如，存在编写新X（）而不是新X（this）的危险。由于这也可能是常规方法，因此我们尚未找到防止此问题的好方法。

　　Groovy 3.0.0支持Java样式语法来创建非静态内部类的实例。

　　7. Lambda表达式和方法引用运算符

　　Java 8+支持lambda表达式和方法引用运算符（::）：

　　Runnable run = () -> System.out.println("Run"); // Java

　　list.forEach(System.out::println);

　　Groovy 3及更高版本在Parrot解析器中也支持这些功能。在Groovy的早期版本中，应改为使用闭包：

　　Runnable run = { println 'run' }

　　list.each { println it } // or list.each(this.&println)

　　8. GStrings

　　由于将双引号字符串文字解释为GString值，因此如果String使用Groovy和Java编译器编译文字文字包含美元字符的类，则Groovy可能会因编译错误而失败或产生微妙的不同代码。

　　虽然通常情况下，Groovy的之间会自动施放GString和String如果API声明参数的类型，提防接受的Java API的Object参数，然后检查实际的类型。

　　9.字符串和字符文字

　　在Groovy单引号的文字被用于String和双引号的结果 String还是GString取决于是否有字面插值。

　　assert 'c'.getClass()==String

　　assert "c".getClass()==String

　　assert "c${1}".getClass() in GString

　　Groovy仅在分配给type变量时才会自动将单个字符String转换char为char。当使用类型为实参的方法调用方法时，char我们需要显式转换或确保值已预先转换。

　　Groovy支持两种类型的转换，在char转换多个字符字符串时，在转换的情况下存在细微的差异。Groovy样式的转换更为宽大，将采用第一个字符，而C样式的转换将异常失败。

　　10.基元和包装

　　因为Groovy对所有对象都使用对象，所以它会自动包装对基元的引用。因此，它不遵循Java的扩展行为，即优先于装箱。

　　这是Java会调用的方法，因为扩展优先于拆箱。

　　这是Groovy实际调用的方法，因为所有原始引用都使用其包装器类。

　　11.行为 ==

　　用Java==表示对象的原始类型或身份相等。在Groovy中，==在所有情况下都意味着平等。a.compareTo(b) == 0当评估Comparable对象的相等性时，它将转换为，a.equals(b)否则转换为。要检查身份（引用相等），请使用is方法：a.is(b)。在Groovy 3中，还可以使用===运算符（或否定的版本）：（a === b或c !== d）。

　　12.转换

　　Java会自动进行扩大和缩小 转换。

　　* 'Y'表示Java可以进行的转换，'C'表示在进行显式转换时Java可以进行的转换，'T'表示Java可以进行的转换但数据被截断，'N'表示Java可以进行的转换。做。

　　Groovy对此进行了很大的扩展。

　　* 'Y'表示Groovy可以进行的转换，'D'表示Groovy在动态或显式编译时可以进行的转换，'T'表示Groovy可以进行的转换但数据被截断，'B'表示装箱/拆箱操作，“ N”表示Groovy无法进行的转换。

　　转换为/时，截断使用Groovy Truth。从数字转换为字符会将转换为。从a或or转换时， 使用Groovy构造和using ，否则使用构造。其他转换的行为由定义。booleanBooleanNumber.intvalue()charBigIntegerBigDecimalNumber.doubleValue()FloatDoubletoString()java.lang.Number

　　读取文件

　　作为第一个示例，让我们看看如何在Groovy中打印文本文件的所有行：

　　new File(baseDir, 'haiku.txt').eachLine { line ->

　　println line

　　该eachLine方法是FileGroovy自动添加到类的方法，并且具有许多变体，例如，如果您需要知道行号，则可以使用此变体：

　　new File(baseDir, 'haiku.txt').eachLine { line, nb ->

　　println "Line $nb: $line"

　　如果出于任何原因在eachLine主体中引发异常，则该方法将确保正确关闭资源。对于Groovy添加的所有I / O资源方法，都是如此。

　　例如，在某些情况下，您将更喜欢使用Reader，但是仍然可以从Groovy的自动资源管理中受益。在下一个示例中，即使发生异常，阅读器也会关闭：

　　def count = 0, MAXSIZE = 3

　　new File(baseDir,"haiku.txt").withReader { reader ->

　　while (reader.readLine()) {

　　if (++count > MAXSIZE) {

　　throw new RuntimeException('Haiku should only have 3 verses')

　　如果需要将文本文件的行收集到列表中，可以执行以下操作：

　　def list = new File(baseDir, 'haiku.txt').collect {it}

　　或者，您甚至可以利用as运算符将文件的内容分成几行：

　　def array = new File(baseDir, 'haiku.txt') as String[]

　　您必须将文件的内容放入byte[]多少次，并且需要多少代码？Groovy实际上非常容易：

　　byte[] contents = file.bytes

　　使用I / O不仅限于处理文件。实际上，很多操作都依赖于输入/输出流，因此，为什么Groovy为此添加了许多支持方法，如您在文档中所看到的 。

　　举个例子，你可以获取InputStream从File非常容易：

　　def is = new File(baseDir,'haiku.txt').newInputStream()

　　// do something ...

　　is.close()

　　但是，您可以看到它需要您关闭输入流。在Groovy中，通常最好使用withInputStream惯用语为您解决：

　　new File(baseDir,'haiku.txt').withInputStream { stream ->

　　// do something ...

　　写文件

　　当然，在某些情况下，您将不希望读取而是写入文件。选项之一是使用Writer：

　　new File(baseDir,'haiku.txt').withWriter('utf-8') { writer ->

　　writer.writeLine 'Into the ancient pond'

　　writer.writeLine 'A frog jumps'

　　writer.writeLine 'Water’s sound!'

　　但是对于这样一个简单的示例，使用<<运算符就足够了：

　　new File(baseDir,'haiku.txt') << '''Into the ancient pond

　　A frog jumps

　　Water’s sound!'''

　　当然，我们并不总是处理文本内容，因此您可以使用Writer或直接写字节，如以下示例所示：

　　file.bytes = [66,22,11]

　　当然，您也可以直接处理输出流。例如，这是创建输出流以写入文件的方式：

　　def os = new File(baseDir,'data.bin').newOutputStream()

　　// do something ...

　　os.close()

　　但是，您可以看到它需要您关闭输出流。同样，总的来说，使用withOutputStream惯用法来处理异常并在任何情况下关闭流都是一个更好的主意：

　　new File(baseDir,'data.bin').withOutputStream { stream ->

　　// do something ...

　　运行时和编译时元编程

　　Groovy语言支持两种元编程形式：运行时和编译时。第一个允许在运行时更改类模型和程序的行为，而第二个仅在编译时发生。两者都有优点和缺点，我们将在本节中详细介绍。

　　1.运行时元编程

　　通过运行时元编程，我们可以将拦截，注入甚至综合类和接口方法的决策推迟到运行时。为了深入了解Groovy的元对象协议（MOP），我们需要了解Groovy对象和Groovy的方法处理。在Groovy中，我们处理三种对象：POJO，POGO和Groovy拦截器。Groovy允许以各种方式对所有类型的对象进行元编程。

　　POJO-常规Java对象，其类可以用Java或JVM的任何其他语言编写。

　　POGO-一个Groovy对象，其类用Groovy编写。默认情况下，它扩展java.lang.Object并实现了groovy.lang.GroovyObject接口。

　　Groovy拦截器-一个Groovy对象，该对象实现groovy.lang.GroovyInterceptable接口并具有方法拦截功能，将在GroovyInterceptable部分中进行讨论。

　　对于每个方法调用，Groovy都会检查对象是POJO还是POGO。对于POJO，GroovyMetaClass从groovy.lang.MetaClassRegistry中获取它，并将方法调用委托给它。对于POGO，Groovy采取了更多步骤，