Groovy MOP-2

迷南。 2023-02-10 07:50 99阅读 0赞

### 本章将讲解MOP协议下方法/属性调用路由 ###

对于`Groovy`创建的类`MOP`方法或者属性存在以下调用协议：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]

关于`groovy`方法路由大家简单了解下实现即可，其实调用每个对象的方法前都会调用到对象的`metaclass`上的`invokeMethod`上（每个类会有一个`metaclass`，每个实例也会存在一个`metaclass`），然后上图就是由这个方法路由形成的规则。请注意不要跟`GroovyObject`的`invkeMethod`混淆，`GroovyObject`的`invkeMethod`可能也是`metaclass`的`invokeMethod`路由路径之一而已。

`GroovyInterceptable`比较特殊所以这里举例说明:

对于一个`Groovy`创建的类（后面简写为`POGO`），如果实现了`GroovyInterceptable`接口，那么所有的方法调用都必须线调用`invokeMethod`

class Person implements GroovyInterceptable {
    
        @Override
        Object invokeMethod(String name, Object args) {
            //此处不能使用println()，否则会从Person寻找这个方法，
            //那么又会调用到这invokeMethod导致死循环
            System.out.println("invoke Person's invokeMethod")
        }
    
        def run() {
            System.out.println("invoke Person's run")
        }
    }
    
    
    def person = new Person()
    person.run()

输出：

invoke Person's invokeMethod

其实`invokeMethod`的默认方法实现，最终也会调用到`metaclass`的`invokeMethod`,如下文所述.

如果某个类的`metaclass`实现了`invokeMethod`函数，那么所有的方法都会调用到`metaclass`的`invokeMethod`函数（如果实现了`GroovyInterceptable`那么会调用自身的`invokeMethod`），

class Person {
    
    
    }
    
    
    def person = new Person()
    person.metaClass.invokeMethod = { name, args ->
    
        println("metaClass invoke method")
    }
    
    person.sd()

输出：

metaClass invoke method

注意如果一个对象实现了`GroovyInterceptable`接口并且又实现了`metaclass`的`invokeMethod`。那么会调用类的`invokeMethod`方法，然后在`super`默认实现中调用`metaclass`的`invokeMethod`

class Person implements GroovyInterceptable {
    
        @Override
        Object invokeMethod(String name, Object args) {
            System.out.println("invoke method")
            return super.invokeMethod(name, args)
        }
        def cry() {
            System.out.println("cry")
        }
    }
    
    
    def person = new Person()
    person.metaClass.invokeMethod = { name, args ->
        println("metaClass invoke method")
    }
    
    person.cry()

输出：

invoke method
    metaClass invoke method

--------------------

*  静态方法调用的流程

实现

未实现

存在

不存在

类的metaclass是否实现'static'.invokeMethod方法

调用metaclass的'static'.invokeMethod方法

是否存在对应的静态方法

调用静态方法

类是否存在$static\_methodMissing方法

抛出异常

调用$static\_methodMissing方法

说明类：

class Person {
        static def $static_methodMissing(String name, Object args) {
            println "Missing static method name is $name"
        }
    }
    
    Person.metaClass.'static'.invokeMethod = { String name, args ->
        println("调用静态方法前的invokeMethod")
    }

--------------------

*  静态属性访问调用流程：

不存在

存在

是否存在静态属性

调用类$static\_propertyMissing的方法

是否存在对应的get/set

*  静态属性设置流程：

不存在

存在

是否存在静态属性

抛出异常

调用get/set

class Person {
        static def $static_propertyMissing(String name) {
            println "static_propertyMissing name is $name"
        }
    }

--------------------

*  实例属性访问和设置流程

实现

未实现

存在

不存在

实现

未实现

是否实现getProperty/setProperty

调用getProperty/setProperty

是否存在对应的get/set

调用getProperty/setProperty

调用用get/set

是否实现propertyMissing

调用propertyMissing

抛出异常

全部实现方法的类如下：

class Person {
    
        def myName = "DefaultMyName"
    
        def getMyName() {
            println("invoke getMyName")
            return myName
        }
    
        def setMyName(String name) {
            println("invoke setMyName")
            myName = name
        }
    
        @Override
        Object getProperty(String propertyName) {
            println("invoke getProperty")
            return metaClass.getProperty(this, propertyName)
        }
    
        void setProperty(String name, Object value) {
            println("invoke setProperty")
            this.@"$name" = 'overridden'
        }
    
        def propertyMissing(String name, value) {
            println("propertyMissing(String name, value)")
        }
    
        def propertyMissing(String name) {
            println("propertyMissing(String name)")
            super.propertyMissing(name)
        }
    
    }

### Expando类 ###

利用以上述路由规则我们可以实现一个代理类，动态生成属性和方法.  
假设我需要一个对象 他具有name属性 和run方法,我们可以使用一个系统自带的实现帮我们完成而不是需要自己在创建一个类。

def expando = new Expando(name: "XiaoMing", run: { println("I'm $name and running") })
    expando.run()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200519220619691.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmYW5taW5neWlx,size_16,color_FFFFFF,t_70