Groovy10_元编程(方法合成与委托)

1. 创建动态类

// 1. 创建一个动态类
// 在运行的时候创建一个类（动态类）
def expand = new Expando(name:'hello',fun1:{"fun1"})
expand.height = 100
expand.fun2 = {
    "fun2"
}

println expand.name
println expand.height
println expand.fun1()
println expand.fun2()

2. 元编程 方法合成

// 元编程 方法合成

class Person {

    def methodMissing(String name, def args) {
        println "missing"
        if (name.startsWith('play')){
            // 生成的class文件 调用方式不一样
            // println metaClass // groovy.lang.MetaClassImpl@37e547da[class Person]
            // metaClass.fun={}  // 如果用这个metaClass 注入方法是会报错的，只能用外面的HandleMetaClass 来进行注入
            Person p = this
            // println p.metaClass // org.codehaus.groovy.runtime.HandleMetaClass@37e547da[groovy.lang.MetaClassImpl@37e547da[class Person]]
            p.metaClass."$name"={
                println "invoke $name"
            }
            "$name"(args)
        }
        return null
    }
}

def p = new Person()
println p.metaClass  // org.codehaus.groovy.runtime.HandleMetaClass@37e547da[groovy.lang.MetaClassImpl@37e547da[class Person]]


p.playGame()  // missing
              // invoke playGame
p.playGame()  // invoke playGame

3. 方法委托

// 1.方法委托

class Work1{
    def excute1(){
        println "excute1"
    }
}

class Work2{

    def excute2(){
        println "excute2"
    }
}


class WorkManager{
    Work1 work1 = new Work1()
    Work2 work2 = new Work2()

    def methodMissing(String name, def args) {
        WorkManager wm = this
        if (work1.respondsTo(name,args)){
            wm.metaClass."$name" = {
                work1.invokeMethod(name,it)
            }
            "$name"(args)
        }else if (work2.respondsTo(name,args)) {
            wm.metaClass."$name" = {
                work2.invokeMethod(name,it)
            }
            "$name"(args)
        }
        return null
    }
}

def wm = new WorkManager()
wm.work1.excute1()  // excute1
// 这是正常的调用过程，多了一个节点，我们可以通过methodMissing
// 来进行方法委托，达到 wm.excute1()

wm.excute1()    // excute1

// 2. 如果对象一多呢

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()
wm1.excute1() // excute1

// 使用注解来进行委托
class WorkManager2{
    @Delegate Work1 work11 = new Work1()
}

new WorkManager2().excute1()  // excute1