Groovy学习笔记

Groovy诞生于2004年， 它是可选类型的（optionally typed）动态语言，是最流行的JVM语言之一，比起其它语言，Groovy能够与Java无缝集成、相互调用，这是它的最大优势。

Groovy可以作为脚本语言使用（但是执行时，即便是脚本也会编译为Java类），也可以编译为Java类。在运行时，你只需要把 groovy-all-*.jar 放在Classpath中，无需其它任何依赖或者执行引擎。

使用Groovy，你可以：

1. 让Java代码更加简洁
2. 自动化重复的任务
3. 使用DSLs（domain-specific languages）进行业务建模
4. 执行即席的脚本任务

Groovy有以下高级特性：

1. 支持闭包（Closures）
2. 支持动态方法（dynamic methods）
3.  为Java平台引入元对象协议（MOP，Meta Object Protocol）

可以到官网下载Groovy运行时，并将安装目录设置为环境变量 GROOVY_HOME ，同时把 $GROOVY_HOME/bin 添加到环境变量PATH中。

工具	说明
groovysh	启动交互式Shell
groovyConsole	运行一个GUI来交互执行Groovy代码
groovy	开始解释Groovy脚本。作为参数的脚本只需要在Classpath中存在即可

1. 预编译模式（Precompiled mode）：使用Groovy编译器——groovyc，把*.groovy编译为*.class文件。并把*.class放置到Classpath下，通过Java的类加载器加载这些类并运行
2. 直接模式（Direct mode）：通过groovy的类加载器，在运行时直接加载*.groovy文件，并动态的生成JVM对象，这种情况下，没有生成.class文件，但是在JVM中是有对应的java.lang.Class实例的

Groovy在源代码级别增强了Java，但是两者的字节码格式是完全相同的。

GDK即Groovy Development Kit，是Groovy对JDK的补充，引入了一些新的类，并为已经现有的一些Java类增强了功能。下面列出GDK的一些特性：

1. 为所有类型引入 size() 方法
2. 简化的数据库访问
3. 简化的XML处理

动态性是指在运行时修改程序结构的能力。

Groovy生成的字节码，会在运行时转换为普通的Java类。除非使用特殊的机制影响JVM，那么这些已加载的Java类的结构是无法动态改变的。

Groovy为什么能具有动态语言的特征，是因为其生成的字节码，不是直接调用方法，而是像这样：

也就是说，方法调用以反射的方式转给对象的MetaClass进行处理， 这就类似于Cglib等字节码增强工具一样，可以在运行时拦截、重定向、增加/删除方法。

Groovy和Java在语法上的共同点包括：

1. 相同的包处理机制（包括包的声明和import语句）
2. 类和方法的定义（嵌套类除外）
3. 控制结构语句（经典的C风格for循环除外）
4. 操作符、表达式和赋值
5. 异常处理
6. 变量声明
7. 对象实例化，引用和取消引用对象
8. 方法调用

Groovy和Java在语法上的差异点包括：

1. 非静态内部类的实例化语法：
   
   Groovy

   1	new OuterClass.NonStaticInnerClass( outClassInstance,args )

Groovy还引入了新的语法特性：

1. 通过新的表达式和操作符访问Java对象
2. 更多的对象声明方式
3. 引入新的控制结构
4. 引入新的数据类型、操作符和表达式
5. 顶级表达式中的方法调用的括号可以省略，前提是被调用方法有至少一个参数（这是为了防止与属性访问歧义，该限制可以通过元编程突破）。链式方法调用与该规则配合使用，可以形成自然语言风格，在DSL中常用
6. 作为最后一个入参的闭包，可以放在方法调用括号的外面，这一规则可以和上一条联用
7. 方法重载发生在运行期而非编译期

上述包和类自动导入，而Java仅仅导入java.lang包。

操作符	对应方法	适用于
a + b	a.plus(b)	Number, String,StringBuffer, Collection,Map, Date, Duration
a – b	a.minus(b)	Number, String, List, Set, Date, Duration  Groovy 1 "Alex Wong" - 'Alex ' == 'Wong'
a * b	a.multiply(b)	Number, String, Collection
a / b	a.div(b)	Number
a % b	a.mod(b)	Integral number
a++ (++a)	a.next()	Iterator, Number, String, Date, Range
a-- (--a)	a.previous()	Iterator, Number, String, Date, Range
-a	a.unaryMinus()	Number, ArrayList
+a	a.unaryPlus()	Number, ArrayList
a ** b	a.power(b)	Number
a | b	a.or(b)	Number, Boolean, BitSet, Process
a & b	a.and(b)	Number, Boolean, BitSet
a ^ b	a.xor(b)	Number, Boolean, BitSet
~a	a.bitwiseNegate()	Number, String（返回正则式）
a[b]	a.getAt(b)	Object, List, Map, CharSequence, Matcher
a[b] = c	a.putAt(b, c)	Object, List, Map, StringBuffer
a << b	a.leftShift(b)	integral number, StringBuffer, Writer, File, Socket, List
a >> b	a.rightShift(b)	Number
a >>> b	a.rightShiftUnsigned(b)	Number
a == b	a.equals(b)	Object
a != b	!(a == b)	Object
a <=> b	a.compareTo(b)	java.lang.Comparable
a > b	a.compareTo(b) > 0
a >= b	a.compareTo(b) >= 0
a < b	a.compareTo(b) < 0
a <= b	a.compareTo(b) <= 0
a as type	a.asType (typeClass)	Any type

自己实现操作符重载时，可以重载上述方法，以便针对具体类型实现二元操作符，例如： 

Groovy在语言层面支持一套数据类型，包括字符串、正则式、数字、范围、列表、映射等。此外，不像Java，Groovy不存在所谓基本类型。 

在groovy中，万事万物皆对象，这与Java不同，后者包含若干基本类型（int/double/char/byte），基本类型是专有类型，其它类型是引用类型。 这些专有类型：

1. 其变量存放了数据本身，而不是数据的地址
2. 不能应用面向对象的编程风格——方法调用、属性导航。不能从java.lang.Object继承方法
3. 能应用多种运算符，而对应的引用类型则基本不能应用这些运算符

Groovy扩展了Java数字类型的直接量表示：

Java类型	直接量语法
java.math.BigInteger	612g,1106G
java.math.BigDecimal	3.14, 6.02E23, 94605.56G

Groovy调用Java方法时，数字类型的拆装箱完全自动进行。

Groovy的变量声明可以没有类型信息，以 def 开头声明的对象，称为动态类型，动态类型指向的对象的类型可以动态变化： 

Groovy引入了 groovy.lang.GString  类型，用来支持占位符替换。Groovy支持多种字符串表示形式：

1. 单引号包围的字符串：不支持占位符替换，相当于Java的字符串。如果要表示 char 类型，则必须静态声明或者使用 as 操作符Cast
2. 双引号包围的字符缓存：支持占位符变量替换，占位符形式为： $varName 或 ${obj.propName} 
3. 三引号包围的字符串：支持多行。如果是三个双引号，则支持占位符替换
4. 斜杠包围的字符串：不需要对反斜杠进行转义，主要用于正则式

Groovy为字符串引入了一些新方法，包括： toInteger, toLong, toFloat, toDouble 等。

可以对字符串进行追加、修改等操作：

Groovy引入了三个操作符，专用于正则式处理 

操作符	说明
=~	正则式匹配操作符
==~	正则式匹配整串操作符
~String	正则式模式（Pattern）操作符，把字符串转换为java.util.regex.Pattern类型

下面是一些示例代码：

Groovy中的数字处理更加直观和符合预期，例如 1/2 的结果会是0.5而非0。

在Groovy中， + - * 运算满足下列规则：

1. 如果有一个数为Float或者Double，那么结果是Double
2. 否则，如果一个操作数为BigDecimal，结果为BigDecimal
3. 否则，如果一个操作数为BigInteger，结果为BigInteger
4. 否则，如果一个操作数为Long，那么结果为Long
5. 否则，结果为一个Integer

对于 / 运算：

1. 如果任何一个数是Float（或者Double）类型，那么运算结果为Double类型
2. 否则，结果为BigDecimal类型，精度以两个数的精度值较大的为准，采用四舍五入的方式，结尾没有无效的0
3. 整数除法可以使用 as 转换，或者使用 intdiv() 方法

当运算结果超过类型表示范围后，不会自动提升类型，幂运算除外。幂运算根据需要依 Integer,Long,Double 的次序提升。

 Groovy引入一个groovy.lang.Range类，表示一个连续的对象范围，并在语法级别上支持范围的直接量：

范围的元素不一定是数字。 日期、字符也可以：

Range的 toList() 方法用于生成对应的列表。

可以使用下面的方式遍历Range：

Groovy把Java数字和List的优点融合到了一起：基于索引的操作、动态增减元素。Groovy在语法上修改了List直接量的声明方式：

 Groovy缺省使用的List实现是 java.util.ArrayList ，你可以显示声明为其它类型。 Groovy为List重载了 [] 操作符，支持多种下标访问风格：

List支持多种操作符：

与List类似，Groovy也从语法上支持Map。和其它语言使用的花括号不同，Groovy用方括号界定Map：

如果要声明一个空的Map，使用 [:]  。Groovy默认使用java.util.HashMap。由于Map的Key往往是字符串，因此，Key的字符串标记可以省略： assert ['a':1] == [a:1] ，但是Key不能是Groovy关键字或者包含特殊符号。

除了数组语法外，还可以使用点号导航来访问Map元素：

所谓闭包（Closure），就是绑定了上下文中变量的匿名函数。闭包在很多语言中都可以见到，但是在Java领域，直到Java 8才通过Lambda语法提供闭包特性。Groovy引入 groovy.lang.Closure 表示闭包，并在语法层面上支持闭包的声明。闭包是普通对象，可以被传递。声明一个闭包很简单：

注意，闭包具有访问上下文中变量的能力（上面第4行），这意味着上下文变量以引用的形式（而不是值）传递给闭包。特别是，即使上下文变量的Scope已经终结，被闭包引用的那些变量依然存在：

在闭包中，关键字：

1. this 表示声明闭包的对象或者类
2. owner 表示直接包含闭包的对象或类
3. delegate 默认值为owner，该变量用于重新定位闭包体中引用的上下文变量，将它们解析为自己的属性/方法

下面的例子说明这三者的关系：

设置闭包的 resolveStrategy 属性可以改变默认的上下文变量搜索规则：

1. OWNER_FIRST ：默认，优先搜索owner
2. OWNER_ONLY ：仅搜索owner
3. DELEGATE_FIRST ：优先搜索delegate
4. DELEGATE_ONLY ：仅搜索delegate
5. TO_SELF ：owner、delegate都不搜索

当然，你随时可以使用 this 、 owner 、 delegate 显式的访问特定上下文对象的属性，不受上述搜索规则限制。此外，局部变量的优先级比上面的上下文对象高：

1. 当前闭包自己定义的局部变量优先级最高
2. 定义了当前闭包的函数/闭包——即owner——其局部变量的优先级次之。这是闭包的重要特点：在声明时绑定（back reference）owner定义的局部变量
3. 多层函数/闭包嵌套时，越外层的局部变量，优先级越低
4. 找不到局部变量，则在this、owner、delegate等上下文对象中寻找属性

如果闭包只有一个参数，那么不需要显式声明，Groovy允许使用 it  来访问唯一入参。

可以把对象方法（不支持静态方法）作为闭包引用： def closure = reference.&methodName 。Groovy支持在运行时进行重载闭包引用：

Groovy为闭包提供了以下重要方法：

方法	说明
call()	调用闭包，与()操作符一样
curry()	返回当前闭包绑定了若干参数（从左向右）的副本闭包： Groovy 1 2 3 def add = {x, y -> return x + y} def addOne = add.curry( 1 ) //绑定第一个参数 println addOne(100) // 101
isCase()	闭包实现了该方法，可以作为switch语句的分类器使用： Groovy 1 2 3 4 5 6 def i = 10 switch(i) {     //闭包作为分类器     case { it%2 == 0 }: println true; break }

在Groovy中可以和Java一样，声明和使用注解。下表列出重要的内置注解：

注解	说明
@Immutable	标记一个类型为不变类型：为class和所有字段添加final标记，对于那些本身可变的对象，Groovy会强制defensive copying。例如： Groovy 1 2 3 4 5 6 7 8 9 import groovy.transform.Immutable @Immutable class ClassRoom {     Map<Integer,String> students = new HashMap(); } ClassRoom cr = new ClassRoom();   //Caught: java.lang.UnsupportedOperationException cr.students.put( 020, "Alex Wong" );
@Grab	在脚本中显式的声明依赖，使其自包含。 Groovy 1 2 @Grab('commons-lang:commons-lang:2.4') import org.apache.commons.lang.ClassUtils  IDE或者Maven、Ivy等工具负责识别和定位依赖
@Category	用于声明一个Category，注解参数说明this指向的类型： Groovy 1 2 3 4 5 6 7 8 9 10 11 12 @Category(Integer) class IntegerMarshal {     String marshal()     {         toString()     } } use (IntegerMarshal) {     assert 1.marshal() == "1" }
@Mixin	轻松的把其他类定义的方法添加到某个类中： Groovy 1 2 3 4 5 6 7 8 9 10 11 12 13 14 @Mixin(MessageFeature) class Test {     void testWithMixinUsage()     {         send "Called from Test"     } } class MessageFeature {     void send(String msg)     {     } } 该特性自2.3开始已经废弃，由 trait 代替
@Delegate	自动添加被代理对象的全部行为到当前类： Groovy 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 class CountingList {     int counter = 0     //获得list的全部行为，即，默认的把所有调用转发给list     @Delegate LinkedList list = new LinkedList<>()     //覆盖下面的行为     boolean addAll(Collection<? extends E> c)     {         counter += c.size()         list.addAll(c)     }     boolean addAll(int index, Collection<? extends E> c)     {         counter += c.size()         list.addAll(index, c)     } } 在实现装饰、代理等模式时，可以避免写大量重复性代码

运行时数据类型	何时作为true处理
Boolean	如果对应的布尔值为true
Matcher	如果存在至少一个匹配
Collection	如果集合非空
Map	如果映射非空
String, GString	如果字符串非空
Number, Character	如果值为非0
其它所有类型	如果为非null

需要注意的是，在if语句中，赋值不能作为顶级表达式。这样会导致编译错误： def var ; if( var = 1 ){} 。除了上述布尔值转换规则以外，Groovy的if/else语句完全一样。三元操作符也被支持，和Java的三元操作符类似。

但是，Groovy优雅的增强了Java中的switch-case语句。其引入了灵活分类器机制——任何实现了 isCase() 方法的对象，都可以作为 case 子句的分类器，而Java中仅仅支持常量作为分类器：

只要isCase()返回true，那么当前case就匹配。Groovy中下面的类实现了isCase()： 

类型	实现方式
Object	a.equals(b)
Class	a.isInstance(b)
Collection	a.contains(b)
Range	a.contains(b)
Pattern	a.matcher(b.toString()).matches()
String	(a==null && b==null) || a.equals(b)
Closure	a.call(b)

Groovy中没有Java的 do{}while(condition) 或者 for(;;) 循环语法。支持 while(condition) 语法，并且引入 for (variable in iterable) { body } 语法（与Java5引入的新循环语法类似）。此外，基于闭包的循环也很常用：

在Groovy中，文件和类声明的关系不像Java那样的固定。一个Groovy文件可以包含多个public类声明：

1. 如果.groovy文件中不包含类声明，它被作为脚本处理。Groovy会生成一个名称与文件名一致的Script类，脚本内容被包含在 run() 方法中，并且新建一个main方法调用之
2. 如果.groovy文件中只包含一个类声明，并且起名称与文件名相同，那么和Java一样，具有一一对应关系
3. 如果.groovy文件中包含多个不同访问限定符的类，Groovy会分别生成.class
4. 如果.groovy文件中混合了脚本和类声明，脚本代码将变成和文件同名的类被执行。此时声明的类不应当和文件同名

Groovy的类声明语法和Java很类似，但是需要注意：

1. 属性、本地变量在使用前必须声明（注意在Groovy脚本中这不是必须的）
2. 支持Java的访问限定符 private protected public ，如果不加限定符：
   1. 对于成员变量，默认限定符为 private，Groovy会自动生成Getter/Setter方法
   2. 对于成员方法，默认作为 public 的
3. 成员变量或者方法返回值可以声明为动态类型，使用关键字def
4. 静态变量或者方法返回值可以声明为动态类型，使用关键字static
5. 方法参数的类型是可选的，如果不指定，默认Object
6. 方法参数可以提供默认值
7. 方法参数可以声明为单个Map，调用时使用命名参数方式传递

下面是一个类定义的例子：

这里我们使用前面定义的新类：

 在Groovy中，对象属性/方法的访问，可以使用点号导航或者下标语法，甚至，点号导航中可以使用变量：

构造Groovy对象，除了使用Java的构造器调用外，还有更多方式：

在进行多级点号导航的访问时，一旦路径上的对象为null，就会导致NullPointerException（NPE）的出现。在Java中这需要很繁琐的处理，在入参规格无法确定的情况下，方法实现者可能需要进行多次空指针检查。

Groovy引入特殊的操作符 ?. 来允许安全的属性导航——当路径中出现null时，当前表达式的估算中止，并返回null。下面是一个例子：

Groovy完整的支持Java的继承和接口机制，并且两者的代码可以几乎完美的交互。

但是Groovy提供了更加动态的能力，你可以把Map或者Closure强制转型为目标接口：

trait用于代替旧的Mixin机制，实现（而不是仅仅像接口那样声明）可共享的、可组合的行为，和Java 8 的Default method类似：

我们知道，Java的重载是静态的——调用哪个重载版本在编译期就确定，依据方法入参的声明类型来决定链接到哪个方法：

Groovy在这一点上与之完全相反，重载方法的选择是依据变量的运行时类型，动态决定的：

前面已经提到过，Groovy会默认访问限定符的实例变量自动生成getter/setter。另外需要注意：

1. 在类外部， ref.fieldName 会自动映射为getter/setter调用，要想规避这一点，必须使用特殊操作符： ref.@fieldName 
2. 在类内部， ref.fieldName 直接访问字段

任何类都可以实现 getProperty(name) 和 setProperty(name,value) ，改变Bean属性访问时的默认逻辑。

类似于Xpath，Gpath是Groovy语言强大的对象导航结构，它引入一个展开点操作符： *. 。

对于列表来说： list*.property 等价于 list.collect{ item -> item?.property } ，下面是一段示例代码：

可以使用 * 在当前位置把集合展开：

Groovy为Object类添加了一个 use() 方法，用于扩展/修改一个类的可用实例方法。use的入参是一种被称为Category的特殊类，这种类包含一组静态方法，use使得这些方法可以作为第一个入参的实例方法使用。下面是一个简单示例：

需要注意的是，use导致的扩展/修改是临时的，不会产生全局性的影响。 

如果一个链式调用（chain-of-method）类似： link(producer).to(consumer) 

则Groovy允许你将其编写为： link producer to consumer 。这非常类似于自然语言的语法，在DSL（领域特定语言）中非常有用。下面是更多的例子：

Groovy还允许把作为最后一个入参的闭包置于括号外面，有时可以达到很奇特的效果：

所谓动态编程，是指在运行时修改对象结构（添加状态、改变行为）的编程风格，是动态语言的优势所在。

当Groovy调用方法时，它不会直接调用，而是总是把调用请求转交给一个中间层——MOP——处理。MOP由相应的API定义。其一系列规则，这些规则限定了：

1. Groovy运行时如何处理方法调用请求
2. 如何控制中间层

为了寻找正确的目标方法，MOP需要很多信息，这些信息存放在元类中。元类可以在运行时改变或者替换，从而改变对象的行为。

即使不改变元类，Groovy也允许通过一系列钩子方法改变对象的行为。

注解	说明
@groovy.transform.ToString	生成人类可读的toString()方法
@groovy.transform.EqualsAndHashCode	生成equals()和hashCode()方法
@groovy.transform.TupleConstructor	生成基于各字段组合的构造函数： Groovy 1 2 3 4 5 @TupleConstructor(excludes=['lastName']) class Person {     String firstName     String lastName }
@groovy.transform.MapConstructor	生成入参为map的构造函数，键为字段名
@groovy.transform.Canonical	ToString + EqualsAndHashCode + TupleConstructor
@groovy.transform.InheritConstructors	生成匹配父类构造器的构造器
@groovy.lang.Category	简化Category的编写
@groovy.transform.IndexedProperty	为数组、列表字段生成索引化的Getter/Setter： Clojure 1 2 3 4 5 6 7 8 class SomeBean {     @IndexedProperty String[] someArray = new String[2]     @IndexedProperty List someList = [] }   def bean = new SomeBean() bean.setSomeArray(0, 'value') bean.setSomeList(0, 123)
@groovy.lang.Lazy	自动生成字段的延迟初始化逻辑： Groovy 1 2 3 4 5 6 7 8 9 10 11 12 13 class SomeBean {     @Lazy LinkedList myField }   // 等价于 List $myField List getMyField() {     if ($myField!=null) { return $myField }     else {         $myField = new LinkedList()         return $myField     } }
@groovy.lang.Newify	增加Python、Ruby风格的构造函数： Clojure 1 2 3 4 5 6 7 8 9 @Newify([Tree,Leaf]) class TreeBuilder {     Tree tree = Tree(Leaf('A'),Leaf('B'),Tree(Leaf('C'))) }   @Newify([Tree,Leaf]) class TreeBuilder {     Tree tree = Tree.new(Leaf.new('A'),Leaf.new('B'),Tree.new(Leaf.new('C'))) }
@groovy.transform.Sortable	辅助编写Comparable类
@groovy.transform.builder.Builder	生成Fluent API： Groovy 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 @Builder(builderStrategy=SimpleStrategy) class Person {     String first     String last     Integer born } def p1 = new Person().setFirst('Johnny').setLast('Depp').setBorn(1963)     @Builder(builderStrategy=SimpleStrategy, prefix="") class Person {     String first     String last     Integer born } def p = new Person().first('Johnny').last('Depp').born(1963)

这些注解用于简化设计模式的实现。

注解	说明
@groovy.transform.BaseScript	指定脚本需要继承自特定的自定义脚本，而非groovy.lang.Script
@groovy.lang.Delegate	代理模式： Groovy 1 2 3 4 5 class Event {     // 生成一个Date when字段，并将对Date方法的调用转发给when     @Delegate Date when     String title }
@groovy.transform.Immutable	实现不变模式
@groovy.transform.TailRecursive	将尾递归转换为迭代风格，避免栈过深
@groovy.lang.Singleton	实现单例模式： Groovy 1 2 3 4 5 6 @Singleton class GreetingService {     String greeting(String name) { "Hello, $name!" } }   assert GreetingService.instance.greeting('Bob') == 'Hello, Bob!'

注解	说明
@groovy.transform.Synchronized	实现类似于synchronized的功能，但是可以针对不同对象进行锁定，默认情况下创建$lock、$LOCK（用于静态方法）锁对象 Groovy 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Counter {     int cpt     @Synchronized     int incrementAndGet() {         cpt++     } }   // 生成 class Counter {     int cpt     private final Object $lock = new Object()       int incrementAndGet() {         synchronized($lock) {             cpt++         }     } }
@groovy.transform.WithReadLock	读写锁
@groovy.transform.WithWriteLock

注解	说明
@groovy.transform.AutoClone	辅助实现@java.lang.Cloneable接口，可以通过style自动克隆策略： AutoCloneStyle.CLONE，默认，先调用super.clone()，再针对每个可克隆属性调用clone() AutoCloneStyle.SIMPLE，调用构造器，并拷贝属性 AutoCloneStyle.COPY_CONSTRUCTOR 创建并使用拷贝构造器 AutoCloneStyle.SERIALIZATION，使用串行化机制克隆对象
@groovy.transform.AutoExternalize	指定外部化包括/排除的字段

注解	说明
@groovy.transform.Field	仅仅在脚本的上下文中有意义，将一个变量声明为脚本类的字段，而非run方法的局部变量 Groovy 1 @Field def x
@groovy.transform.PackageScope	包内可见的字段，不生成属性
@groovy.transform.AutoFinal	提示编译器自动插入final关键字

注解	说明
@Grab	添加一个依赖： Groovy 1 2 @Grab(group='org.springframework', module='spring-orm', version='3.2.5.RELEASE') import org.springframework.jdbc.core.JdbcTemplate  也可以使用下面的简写法： Groovy 1 @Grab('org.springframework:spring-orm:3.2.5.RELEASE')
@GrabResolver	指定仓库： Groovy 1 @GrabResolver(name='restlet', root='http://maven.restlet.org/')
@GrabConfig	使用系统类加载器加载： Groovy 1 2 @GrabConfig(systemClassLoader=true) @Grab(group='mysql', module='mysql-connector-java', version='5.1.6')

钩子方法	说明
methodMissing	调用任何对象不支持的方法，转交给该钩子处理： Groovy 1 2 3 4 5 6 7 8 class Pretender {     Object methodMissing(String name, Object arguments){         println "Method $name called"     } } def p = new Pretender(); p.hello()
propertyMissing	与上面类似， 当访问不存在的属性时，交由该钩子处理，下面的例子演示了一个DSL风格的二进制计算器： Groovy 1 2 3 4 5 6 7 8 9 10 11 def propertyMissing(String name) {     int result = 0     name.each     {         result <<= 1         if (it == 'I') result++     }     return result } assert IIOI + IOI == IOOIO

通过把逻辑委托给一个闭包，可以针对一个对象实例（而不是类），在运行时动态修改逻辑：

所有由Groovy类都实现了下面的接口（继承了 GroovyObjectSupport ）：

任何该接口的子类，都遵守下面的规则：

1. 对其属性的访问，委托给getter/setter
2. 对任何不存在的方法的调用，委托给invokeMethod()
3. 如果子类实现了GroovyInterceptable，那么对任何方法的调用委托给invokeMethod()

缺省适配 GroovyObjectSupport 的方法实现，通过委托调用给对象的元类，应用上述规则：

上面演示的动态编程方式，都是“侵入性”的——需要修改目标类的源码。Groovy还允许修改元类本身，来实现“非侵入性”的动态编程。

Groovy为任何一个类维护一个元类（metaclass）信息，元类使用类型 groovy.lang.MetaClass 表示。元类持有类的所有属性、方法信息，包括Groovy附加的方法。

一般情况下，类的所有实例共享一个元类，但是Groovy支持通过 setMetaClass( metaClass ) 修改单个实例的元类。

你可以很容易的和元类交互，例如：

默认情况下， getMetaClass() 通过元类注册表 MetaClassRegistry 来查找元类，除非你覆盖前述方法的实现。该注册表维护了类到元类的映射关系。

Groovy内置了若干元类实现：

1. 默认实现 MetaClassImpl ，大部分情况下使用
2. ExpandoMetaClass 用于扩展状态和行为
3. ProxyMetaClass 装饰一个元类，作为拦截器使用
4. 其它内部、测试用的元类

为元类添加状态/行为后，元类自动成为 ExpandoMetaClass ，类的所有实例获得新的状态/行为：

使用 Expando 可以在对象级别上动态添加状态/行为：