Groovy基础——MetaClass详解

一、拦截方法调用和参数获取

示例1：

class MyClass{
 def hello(){
  ‘invoked hello directly‘
 }
 def invokeMethod(String name, Object args){
  return "unknown method $name(${args.join(‘, ‘)})"
 }
}
def mine= new MyClass()
assert mine.hello() == ‘invoked hello directly‘
assert mine.foo("Mark", 19) == ‘unknown method foo(Mark, 19)‘

首先我们在groovy脚本中定义了一个Myclass对象，在groovy中任何的对象都是实现GroovyObject并且继承GroovyObjectSupport的，在GroovyObject的接口中，我们可以看到几个方法首先是getMetaClass方法和setMetaClass方法，metaClass用来支持动态方法和动态参数的调用。另一组方法是getProperty和setProperty方法，这组方法是用来支持动态参数的设定与赋值的。最后还有一个invokeMethod方法，该方法则是用于调用动态方法的。在了解了上述概念后，我们可以理解为MyClass的invokeMethod方法覆盖了GroovyObjectSupport中对应的方法，所以调用未预先定义的foo方法就会进入invokeMethod的实现。而hello方法预先定义则照旧。

示例2：

class MyClass implements GroovyInterceptable{
	def hello(){
		‘invoked hello() directly‘
	}
	def invokeMethod(String name, Object args){
		"invoked method $name(${args.join(‘, ‘)})"
	}
}

def mine = new MyClass()
assert mine.hello() == ‘invoked method hello()‘
assert mine.foo(‘Mark‘,19) == ‘invoked method foo(Mark, 19)‘

assert mine.&hello() == ‘invoked hello() directly‘

该例子和示例1的不同在于实现了一个GroovyInterceptable接口，仔细看下这个接口的描述，可知道实现该接口的类被调用方法时都是默认使用invokeMethod方法，而不管该方法时动态生成或时静态生成；第2点不同是如果要再此情况下调用原有定义号的方法，需要变通的使用‘.&‘操作符。

示例3：

class MyClass{
	def greeting = ‘accessed greeting directly‘
	Object getProperty(String property){
		"read from property $property"
	}

	void setProperty(String property, Object newVlaue){
		throw new Exception("wrote to property $property")
	}
}
def mine = new MyClass()
assert mine.greeting == ‘read from property greeting‘
try{
	mine.greeting = ‘hi‘
}catch(e){
	assert e.message == ‘wrote to property greeting‘
}

assert mine.@greeting == ‘accessed greeting directly‘

该示例描述了属性的获取特性，在示例1中已经描述设置和获取属性的方法时继承来的，这里不做赘述。默认的通过Gpath(见Gpath具体概念)来处理属性的值，都是通过调用getProperty和SetProperty来代劳的。同样的如果你真希望直接访问参数的值，可以变通的使用‘.@‘操作符来达成。

通过Gpath来获得属性值。无论该属性在类中是否有，都是不会出错的执行那2个方法。但是对于类中不存在的属性，忌使用‘.@‘操作符，会抛出MissingFieldException。

示例4：

class MyClass implements GroovyInterceptable{
	def greeting = ‘accessed greeting‘
	def id =‘White: ‘
	
	Object getProperty(String property){
		try{
			return this.@id + //access field directly
					‘indirectly ‘ +
					this.@"$property"
		}catch(e){
			return "no such property $property"
		}
	}
	
	def hello(Object[] args){"invoked hello with (${args.join(‘, ‘)})"}
	
	def id(){‘Green: ‘}
	
	def invokeMethod(String name, Object args){
		try{
			return this.&id() + //call method directly
					‘indirectly ‘ +
					this.&"$name"(args)
		}catch(e){
			return "no such method $name"
		}
	}	
}

def mine = new MyClass()
assert mine.greeting == ‘White: indirectly accessed greeting‘
assert mine.farewell == ‘no such property farewell‘

assert mine.hello(1, ‘b‘, 3) == ‘Green: indirectly invoked hello with (1, b, 3)‘
assert mine.foo(‘Mark‘, 19) == ‘no such method foo‘

该示例是对示例 2,3的一个合并，同时他告诉我们我们可以通过操作符‘.@‘ 或者‘.&‘后使用双引号中定义变量的方法来动态的获取参数或者动态的方法。

二、MetaClass （描述类的类）

示例5：

public class MyMetaClass extends DelegatingMetaClass{
	MyMetaClass(Class thisClass){
		super(thisClass)
	}
	
	Object invokeMethod(Object object, String methodName, Object[] arguments){
		"MyMetaClass: ${super.invokeMethod(object, methodName, arguments)}"
	}
}

class A{
	def bark(){‘A: invoked bark()‘}
	def invokeMethod(String name, Object args){
		"A: missing $name(${args.join(‘, ‘)})"
	}
}

def amc = new MyMetaClass(A)
amc.initialize()
def a = new A()
a.metaClass = amc


assert a.bark() == ‘MyMetaClass: A: invoked bark()‘

Thread.start {
	assert a.bark() == ‘MyMetaClass: A: invoked bark()‘
}

assert new A().bark() == ‘A: invoked bark()‘

assert a.bleet() == ‘A: missing bleet()‘

具体的做法是：首先创建一个自定义的MetaClass类继承于DelegatingMetaClass，同时实现构造方法，以及自定义的方法调用行为（以后的内容将介绍，我们不仅可以改变方法行为）。然后我们可以通过自己创建的metaClass子类来包装你想改变行为的目标类。此处为类A。然后再创建目标类实例，对目标类中得metaClass属性进行设置。随后在该实例上的方法调用将会按照该实例的metaClass属性所对应的处理器，进行处理，该例中是再完成本身方法调用后在前面添加MyMetaClass字符串。

但是值得注意的是，1.对于另外新创建的A实例，如果没有进行metaClass属性赋值将按照原方法定义执行；2.动态定义的

方法不受metaClass方法行为改变的影响。见该示例的最后一行。3.上述的特性在新线程内同样有效。

示例6：

InvokerHelper.instance.metaRegistry.setMetaClass(A, amc)

该示例只是对示例5的补充，我们曾提到，我们可以通过为目标类实例设置metaClass属性来让metaClass的行为对该实例生效。但是如果要在类范围内生效的话，就需要通过上面的代码进行注册。这样注册过后，将对目标类的所有，任何时候创建的示例，都赋予metaClass的行为。

这个示例还有一点需要注意。试想这么一种情况，先创建了一个目标类实例，再用示例6的语句注册，再创建一个目标类的实例。metaClass的行为将在哪个对象上生效呢。答案是两者都生效。这点非常关键。一旦进行了类范围metaClass注册，那对于已创建和新创建的对象都生效。

注：对于高版本的groovy InvokerHelper的instance不存在。可以直接调用metaRegistry。

示例7:

import org.codehaus.groovy.runtime.InvokerHelper;

public class MyMetaClass extends DelegatingMetaClass{
	MyMetaClass(Class theClass){
		super(theClass)
	}

	Object invokeConstructor(Object[] arguments){
		[]
	}
}

class A{}

def amc = new MyMetaClass(A)
amc.initialize()

InvokerHelper.metaRegistry.setMetaClass(A,amc)

def a = new A()
assert a.class == ArrayList
assert (a<<1<<2<<3).size() == 3

在之前的示例已经略有提过metaClass不仅可以改变预定义的方法行为。在该示例中就以改变构造行为为例。该metaClass将构造行为变成创建一个数组对象。随后的操作是一目了然的。

在此值得一提的是，invokeConstructor方法时从metaClass的接口MetaObjectProtocol继承过来，其他的方法可能

是从不同的继承树而来的，所以可以参见DelegatingMetaClass中得方法签名。我们可以发现有很多invokeXXX和getXXX的方法，也就是说我们可以对这些metaClass行为做更改。主要的我们可以看到有getProperty方法invokeConstructor方法，当然我很兴奋的发现还有一个invokeMissingMethod方法，这个方法似乎就是对我们示例5中不能处理动态定义方法的metaClass行为的一个有用的补充了。

 三、ExpandoMetaClass

下面这个示例内容较多，在给出例子之前，需要先澄清一些细节，你可能会想我们之前人为的为groovyobject设置metaClass来改变类实例的行为，那默认不设置情况下这个metaClass是什么呢？ 其实无论是你设置或者没有设置metaClass它的metaClass都是HandleMetaClass类型的，但是区别在于，里面有一个getAdaptee方法返回的是DelegatingMetaClass中的MetaClass类型的delegate属性，默认情况下，这个delegate会事MetaClassImpl类型的，但是一旦你自己设置了目标类实例的metaClass属性那这个delegate属性就是你设置的了。我们下面要将的这个话题，也就是这一章的标题ExpandoMetaClass（MetaClassImpl的一个子类）正是又一个与MetaClassImpl以及自定义的MetaClass平行的delegate只是这个delegate，支持动态创建方法等等的特性。接着我们先引入示例

示例8：

class A{
	String text
  }
def a1= new A(text: ‘aBCdefG‘)
assert a1.metaClass.adaptee.class == MetaClassImpl

A.metaClass.inSameCase = {-> text.toUpperCase()}
//triggers conversion of MetaClass of A to ExpandoMetaClass
//then adds new instance method ‘inUpperCase‘ to class
//A.metaClass {  }

//
def a2 = new A(text:‘hiJKLmnOp‘)
assert a2.metaClass.adaptee.class == ExpandoMetaClass
//MetaClass of A changed for instances created after conversion trigger only
assert a2.inSameCase() == ‘HIJKLMNOP‘

//new method not available
assert a1.metaClass.adaptee.class == MetaClassImpl
try{ println a1.inSameCase();}
catch(e){assert e in MissingMethodException}

A.metaClass.inLowerCase = {-> text.toLowerCase()}
assert a2.inLowerCase() == ‘hijklmnop‘

//replace the method definition with another
A.metaClass.inSameCase = {-> text.toLowerCase()}
assert a2.inSameCase() == ‘hijklmnop‘

//add static methods
A.metaClass.‘static‘.inSameCase = {it.toLowerCase()}
assert A.inSameCase(‘qRStuVwXyz‘) == ‘qrstuvwxyz‘

ExpandoMetaClass类型的。这样我们就能够利用该类型的metaClass为我们做事了。同样的

A.metaClass.inSameCase = {-> text.toUpperCase()}方法只是在注册metaClass为ExpandoMetaClass的同时

为其动态添加一个实例方法。同时我们可以在最后几行的代码中获知，动态添加静态方法也是可行的。

几点需要注意的：1.只有在切换delegate为ExpandoMetaClass后创建的目标对象才能支持切换时所提供的动态方法。2.动态方法的添加存在覆盖关系。

示例9:

class A{

}

A.metaClass.character = ‘Cat in the Hat‘

def a1 = new A()
assert a1.character == ‘Cat in the Hat‘

def ourProperties = Collections.synchronizedMap([:])
A.metaClass.setType = {String value -> ourProperties["${delegate}Type"] = value }
A.metaClass.getType = { -> ourProperties["${delegate}Type"]}
a1.type = ‘Hatted Cat‘
assert a1.type == ‘Hatted Cat‘

def a2 = new A()
A.metaClass.constructor = { -> new A()}
try{
	a2 = new A()
}catch(Error e){
	assert e in StackOverflowError
}

A.metaClass.constructor = {String s -> new A(character :s)}
a2 = new A("Thing One")

A.metaClass.‘changeCharacterToThingTwo‘= {-> delegate.character = ‘Thing Two‘ }
a2.character= ‘Cat in the Hat‘
a2.changeCharacterToThingTwo()
assert a2.character == ‘Thing Two‘

[‘Hatted Cat‘, ‘Thing‘, ‘Boy‘, ‘Girl‘, ‘Mother‘].each{p->
  A.metaClass."changeTypeTo${p}"= {-> delegate.type= p}
}
a2.changeTypeToBoy()
assert a2.type == ‘Boy‘

a2.‘changeTypeToHatted Cat‘()
assert a2.type == ‘Hatted Cat‘

该示例的内容只要是示例8的一个补充，我们不仅可以动态添加方法，同时还可以动态添加属性和构造方法。

示例10：

ExpandoMetaClass.enableGlobally()
//call ‘enableGlobally‘ method before adding to supplied class
List.metaClass.sizeDoubled = {-> delegate.size() * 2 }
//add method to an interface
def list = [] << 1 << 2
assert list.sizeDoubled() == 4

所以请各位读者按照个人版本做尝试。

示例11：

class Bird{
	def name = ‘Tweety‘
	def twirp(){ ‘i taught i saw a puddy cat‘ }
}

Bird.metaClass.invokeMethod = {name, args->
	def metaMethod = Bird.metaClass.getMetaMethod(name, args)
	metaMethod?metaMethod.invoke(delegate,args): ‘no such method‘
}

def a = new Bird()
assert a.twirp() == ‘i taught i saw a puddy cat‘
assert a.bleet() ==‘no such method‘

Bird.metaClass.getProperty = {name->
	def metaProperty = Bird.metaClass.getMetaProperty(name)
	metaProperty?metaProperty.getProperty(delegate): ‘no such property‘	
}
def b = new Bird()
assert b.name == ‘Tweety‘
assert b.filling == ‘no such property‘

 该示例主要说明的是我们不仅可以用Expando特性来添加方法属性和构造方法，同样的我们可以对已经存在的方法进行覆盖。最后还要强调一下Bird.metaClass返回的是ExpandoMetaClass我们这里覆盖的getMetaMethod和

getProperty以及invokeMethod和getProperty方法都是对ExpandoMetaClass类和它父类对应的方法进行覆盖。

至此，Groovy的MetaClass内容已经介绍完了。该部分内容在groovy中非常重要。谨此记录下来作为日后参考，同时希望对大家有帮助。