Groovy MOP3-metaclass

我会带着你远行 2023-02-11 04:49 20阅读 0赞

本章将简单讲解`metaclass`。

### `What MetaClass` ###

`MetaClass`是`Goorvy`实现语言动态核心类，用于路由方法/属性调用，扩展等.

### `Where MetaClass` ###

在`Groovy`中每个对象都有一个对应的`metaclass`  
对于`Java`和`Groovy`的`Class`的`metaclass`对象存在`groovy.lang.MetaClassRegistry`中。  
举个例子：

def registry = GroovySystem.getMetaClassRegistry()
    println registry.getMetaClass(Human)

输出：

groovy.lang.MetaClassImpl@31610302[class Human]

注意`Class`也是一个对象，所以他也存在对应的`metaClass`，而其实例对象也存在一个`metaclass`,而他存储对象实例的一个属性上。简单来说就是一个对象实例存在两个`metaclass`对象，当实例对象没有进行动态扩展时两者指向同一个`metaclass`对象。

请参考如下断言：

import com.MyGroovy
    
    def groovy = new MyGroovy()
    
    class Person {
    
        def test(outMetaClass) {
            println("test:::" + (metaClass.dump()))
        }
    }
    
    Person personOne = new Person()
    Person personTwo = new Person()
    
    //实例的metaclass 在没有进行动态注入方法时等价于类的metaclass
    assert personOne.metaClass == personTwo.metaClass
    assert personOne.metaClass == Person.metaClass
    
    //触发元编程动态扩展属性，让personOne生成一个独享的metaclass
    personOne.metaClass.name = ""
    
    assert personOne.metaClass != Person.metaClass
    assert personTwo.metaClass == Person.metaClass

### `When MetaClass` ###

`groovy`元编程可以帮助我们快速用代码生成一个`json`或者`xml`。  
比如下面的代码

def xml =new Xmlgenerate()
    
    def out=xml {
        book {
            name = "name"
        }
    }
    pritln out.xmlString()

### 自定义`MetaClass` ###

关于`groovy`方法路由大家简单了解下实现即可，其实调用每个对象的方法前都会调用到对象的`metaclass`上的`invokeMethod`上（每个类会有一个`metaclass`，每个实例也会存在一个`metaclass`），然后上图就是由这个方法路由形成的规则。请注意不要跟`GroovyObjec`t的`invokeMethod`混淆，`GroovyObject`的`invkeMethod`可能也是`metaclass`的`invokeMethod`路由路径之一而已(这里特别声明如果一个类声明了`GroovyInterceptable`接口那么默认会先调用到类的`invokeMethod`)。

假设我们需要自定义路由，可能要实现很多东西不如通过代理原本`metaclass`的`invkeMethod`。

下面的例子代理Person原始的`metaclass`,把返回结果变为大小

class Person {
    
    
        def test1() {
            System.out.println("invoke test1")
            return "test1"
        }
    
    }
    
    class MyDelegateMetaClass extends DelegatingMetaClass {
    
        MyDelegateMetaClass(MetaClass delegate) {
            super(delegate)
        }
    
        MyDelegateMetaClass(Class theClass) {
            super(theClass)
        }
    
    
        Object invokeMethod(Object object, String methodName, Object[] args) {
            println("metaclass invokeMethod $methodName")
    
            def result = super.invokeMethod(object, methodName.toLowerCase(), args)
            return result.toString().toUpperCase()
        }
    
    }
    
    def delegate = new MyDelegateMetaClass(Person.metaClass)
    delegate.initialize()
    
    Person.metaClass = delegate
    def person = new Person()
    
    
    println "函数调用结果+${person.test1()}"

*  更改默认的类的`metaclass`  
    上面的例子我们需要手动的将新建的`metaclass`赋值给`Person`,我们再看另一个方式.

package com
    class MyGroovy {
    }

我们假设想改变`MyGroovy`的默认`metaclass`，我们只需要在`groovy.runtime.metaclass.[包名]`下创建一个`[类名]MetaClass` 即可.

package groovy.runtime.metaclass.com
    
    class MyGroovyMetaClass extends DelegatingMetaClass {
        MyGroovyMetaClass(MetaClass delegate) {
            super(delegate)
        }
    
    
        Object invokeMethod(Object object, String name, Object[] args) {
            println("MyGroovyMetaClass invokeMethod")
        }
    
    }

测试:

def groovy = new MyGroovy()
    println groovy.sd()

输出：

MyGroovyMetaClass invokeMethod
    null

### ExpandoMetaClass ###

这个元类可以帮助我们实现元编程的动态化，如方法扩展，而其他的`MetaClass`默认不具备这样的能力。

举例：

import com.MyGroovy
    
    def groovy = new MyGroovy()
    
    class Person {
    
        def test(outMetaClass) {
            println("test:::" + (metaClass.dump()))
        }
    }
    
    def expando = new ExpandoMetaClass(Person)
    expando.myName = "XiaoMing"
    //metaClass必须初始化,并且扩展方法或属性必须在初始化之前
    expando.initialize()
    
    Person.metaClass = expando
    def person = new Person()
    assert person.myName=="XiaoMing"

如果你想初始化后还可以继续动态扩展属性/方法，请考虑使用如下的构造函数  
`ExpandoMetaClass(Class theClass, boolean register, boolean allowChangesAfterInit)`  
第二参数：是否注册到`MetaClassRegistry`,如果第二个参数为true那么直接替换某个类在`MetaClassRegistry`的`metaclass`.  
第三个参数：初始化后是否还能动态更新`方法/属性`

import com.MyGroovy
    
    def groovy = new MyGroovy()
    
    class Person {
        def test(outMetaClass) {
            println("test:::" + (metaClass.dump()))
        }
    }
    
    def expando = new ExpandoMetaClass(Person, true, true)
    
    expando.na=''
    expando.initialize()
    //allowChangesAfterInit第三个参数为true所以运行初始化后修改
    expando.nsda=''
    
    
    
    def registry = GroovySystem.getMetaClassRegistry()
    def clazz = registry.getMetaClass(Person)
    
    
    //因为register是true，所以直接输出ExpandoMetaClass
    println(clazz)

### HandleMetaClass ###

这个类是一个特殊的元类，我们在获取一个类的`metaclass`其实返回的这个类,然而这个类并不是和类所关联的`metaclass`，它的存在是方便让我们进行动态扩展属性/方法。默认关联的类的`metaclass`不是`ExpandoMetaClass`，所以我们无法进行动态扩展。  
举个例子：

import com.MyGroovy
    
    class Person {
        def test(outMetaClass) {
            println("test:::" + (metaClass.dump()))
        }
    }
    
    
    def registry = GroovySystem.getMetaClassRegistry()
    def relationMetaClass = registry.getMetaClass(Person)
    
    
    assert relationMetaClass != Person.metaClass
    
    println("relationMetaClass:" + relationMetaClass)
    println("Person.metaClass:" + Person.metaClass)

输出：

relationMetaClass:groovy.lang.MetaClassImpl@37d31475[class Person]
    Person.metaClass:org.codehaus.groovy.runtime.HandleMetaClass@37d31475[groovy.lang.MetaClassImpl@37d31475[class Person]]

注意在对象内部获取的`metaclass`是实际所关联的metaclass

class Person {
        def test() {
            return  metaClass
        }
    }
    
    
    def registry = GroovySystem.getMetaClassRegistry()
    def relationMetaClass = registry.getMetaClass(Person)
    
    
    assert relationMetaClass != Person.metaClass
    
    
    println("relationMetaClass:" + relationMetaClass)
    println("Person.metaClass:" + Person.metaClass)
    println("Person.test 返回的:" + new Person().test())

输出:

relationMetaClass:groovy.lang.MetaClassImpl@41c62850[class Person]
    Person.metaClass:org.codehaus.groovy.runtime.HandleMetaClass@41c62850[groovy.lang.MetaClassImpl@41c62850[class Person]]
    Person.test 返回的:groovy.lang.MetaClassImpl@41c62850[class Person]

为什么对象函数内部返回实际关联`metaclass`,而在外部调用获得一个`HandleMetaClass`？因为外部会经过方法路由（可以简单认为属性路由故意改变的）。而内部函数获取的没有经过路由，所以直接获取内部的属性。

我们可以看到类所关联的`metaclasss`是`MetaClassImpl`,而这个元类不支持动态编程所以借助`HandleMetaClass`来完成.

下面的例子来说明`MetaClassImpl`不可动态注入:

class Person {
        def test() {
            return  metaClass
        }
    }
    
    
    def registry = GroovySystem.getMetaClassRegistry()
    def relationMetaClass = registry.getMetaClass(Person)
    
    
    //13行 此处会抛出异常
    relationMetaClass.Xx=23

输出:

Caught: groovy.lang.MissingPropertyException: No such property: Xx for class: groovy.lang.MetaClassImpl
    groovy.lang.MissingPropertyException: No such property: Xx for class: groovy.lang.MetaClassImpl
    	at Main.run(Main.groovy:13)

`HandleMetaClass`又是如何帮助我们的呢?下面是`HandleMetaClass`伪代码

//由于HandleMetaClass继承DelegatingMetaClass,
    //所以我们简单看下构造函数保存了一个代理对象到delegate
    public class DelegatingMetaClass implements MetaClass, MutableMetaClass, GroovyObject {
        
        protected MetaClass delegate;
    
        public DelegatingMetaClass(final MetaClass delegate) {
        
            this.delegate = delegate;
        }
    }
    
        
    public class HandleMetaClass extends DelegatingMetaClass {
        
        private Object object;
        private static final Object NONE = new Object();
    
        public HandleMetaClass(MetaClass mc) {
        
            this(mc, null);
        }
    
        public HandleMetaClass(MetaClass mc, Object obj) {
        
            super(mc);
            if (obj != null) {
        
            	//判断当前metaclass是否是原始的类的metclass,这里自然是true
                if (InvokerHelper.getMetaClass(obj.getClass()) == mc || !(mc instanceof ExpandoMetaClass))
                  object = obj; 
                else
                  object = NONE; // object already has per instance meta class
            }
        }
    
        public void initialize() {
        
            replaceDelegate();
            delegate.initialize();
        }
    	//简单来说就是返回一个metaclass对象,这个对象是ExpandoMetaClass
        public GroovyObject replaceDelegate() {
        
            if (object == null) {
        
                if (!(delegate instanceof ExpandoMetaClass)) {
        
                  delegate = new ExpandoMetaClass(delegate.getTheClass(), true, true);
                  delegate.initialize();
                }
                DefaultGroovyMethods.setMetaClass(delegate.getTheClass(), delegate);
            }
            else {
        
              if (object != NONE) {
        
                  final MetaClass metaClass = delegate;
                  delegate = new ExpandoMetaClass(delegate.getTheClass(), false, true);
                  if (metaClass instanceof ExpandoMetaClass) {
        
                      ExpandoMetaClass emc = (ExpandoMetaClass) metaClass;
                      for (MetaMethod method : emc.getExpandoMethods())
                        ((ExpandoMetaClass)delegate).registerInstanceMethod(method);
                  }
                  delegate.initialize();
                  MetaClassHelper.doSetMetaClass(object, delegate);
                  object = NONE;
              }
            }
            return (GroovyObject)delegate;
        }
    	//调用某个类的所有方法前 都会先调用到这个方法进行最先的路由
        public Object invokeMethod(String name, Object args) {
        
        	//replaceDelegate作用就是替换了一个代理的metaclass变为ExpandoMetaClass对象
            return replaceDelegate().invokeMethod(name, args);
        }
        
    }

综上`HandleMetaClass`就是一个代理类,当调用类的方法时利用一个中间的代理`ExpandoMetaClass`对象去调用.