Groovy语法学习(九)MOP探索之方法合成与委托

深碍√TFBOYSˉ_ 2022-05-27 07:09 119阅读 0赞

groovy不仅能方法注入，也可以方法合成，利用之前说的methodMissing方法。我们知道在找不到方法的时候会回调这个方法，然后我通过错误回调的时候进行方法注入。

#### 方法合成 ####

class Manager {
        
    
        def methodMissing(String name, def args) {
            println 'missing method'
            if (name.startsWith('distribute')){
                //生成的class文件 调用方式不一样
    //            println metaClass
                Manager p = this
    //            println p.metaClass
                def m=p.metaClass.invokeMethod(this,"respondsTo",name,args)
                if(!m){
                    println "inject method"
                    p.metaClass."$name" = {
                        println "invoke $name"
                    }
                }
    
                "$name"(args)
            }
            return null
        }
    }
    
    def p = new Manager()
    //println p.metaClass
    p.distribute()
    p.distribute()
    p.distribute()

结果

missing method
    inject method
    invoke distribute
    invoke distribute
    invoke distribute

#### 方法委托 ####

#### （一） 使用methodMissing进行注入。 ####

class Work1{
        
        def execute1(){
             "execute1"
        }
    }
    
    class Work2{
        
        def execute2(){
             "execute2"
        }
    }
    
    class WorkManager{
        
        Work1 work1 = new Work1()
        Work2 work2 = new Work2()
        def methodMissing(String name, def args) {
            WorkManager wm = this
            def response=null;
            if (work1.respondsTo(name,args)){
                wm.metaClass."$name" = {
                    response=  work1.invokeMethod(name,it)
                }
                "$name"(args)
            } else if(work2.respondsTo(name,args)){
                wm.metaClass."$name" = {
                    response=  work2.invokeMethod(name,it)
                }
                "$name"(args)
            }
            return response
        }
    }
    
    def wm = new WorkManager()
    assert  wm.execute1()=='execute1'
    assert  wm.execute2()=='execute2'

在找不到方法的时候，判断代理对象是否具有方法并且动态注入方法进行委托。

##### （二）使用delegate委托 #####

class Work1{
        
        def execute1(){
             "execute1"
        }
    }
    
    class Work2{
        
        def execute2(){
             "execute2"
        }
    }
    class WorkManager1{
        
    
        {
            delegate(Work1,Work2)
        }
    
    
    
        def delegate(Class... classes){
            //创建对应的对象
            def objects = classes.collect {it.newInstance()}
            WorkManager1 wm = this
            //注入methodMissing方法
            wm.metaClass.methodMissing = {
                String name, def args ->
                    //查找调用的方法的实现对象
                    def object = objects.find {
        it.respondsTo(name,args)}
                    if (object){
                        //动态注入方法
                        wm.metaClass."$name" = {
                            object.invokeMethod(name,it)
                        }
                        invokeMethod(name,args)
                    }
            }
        }
    
    }
    
    def wm1 = new WorkManager1()
    assert  wm.execute1()=='execute1'
    assert  wm.execute2()=='execute2'

##### （三） 使用@Delegate注解委托 #####

class Work1{
        
        def execute1(){
            "execute1"
        }
    }
    
    class Work2{
        
        def execute2(){
            "execute2"
        }
    }
    
    
    class WorkManager2{
        
        @Delegate Work1 work1 = new Work1()
        @Delegate Work2 work2 = new Work2()
    }
    
    def manager2 = new WorkManager2()
    assert  manager2.execute1()=='execute1'
    assert  manager2.execute2()=='execute2'

groovy的语法虽然灵活，其实对于运行的代价是比java要高一些的，具体使用就看取舍了。