groovy元编程 方法拦截 动态改变

//元编程
/**
 * 只要实现了 GroovyInterceptable接口
 * 调用所有方法时  都会先调用invokeMethod方法
 */
/*
class Person1 implements GroovyInterceptable{
    def name
    def dream(){
        System.out.println('i have a dream')
    }

    @Override
    Object invokeMethod(java.lang.String name, Object args) {
        System.out.println('invokeMethod')
        if(metaClass.invokeMethod(this,'respondsTo',name,args)){
            metaClass.invokeMethod(this,name,null)
        }else{
            System.out.println('没实现')
        }
    }
}
def person = new Person1(name: 'name')
person.dream()
person.metaClass.invokeMethod(person,'dream',null)

//调用dream方法 的3种方式
person.invokeMethod('dream',null)
MetaMethod m = person.metaClass.getMetaMethod('dream',null)
m.invoke(person,null)
*/

/**
 * 单例模式下通过重写invokeMethod方法 对每个方法都进行同样的判断
 * 方法拦截
 */
/*class Mannager implements GroovyInterceptable{
    static Mannager instance
    def isInit
    static Mannager getInstance(){
        if(null == instance){
            synchronized (Mannager.class){
                if(null == instance){
                    instance = new Mannager()
                }
            }
        }
        return instance
    }
    def init(){
        isInit = true
    }
    def dream(){
        System.out.println('执行dream')
    }
    @Override
    Object invokeMethod(java.lang.String name, Object args) {
        if(name != 'init'){
            if(!isInit){
                System.out.println('请先执行inti方法')
                return
            }
        }
        if(metaClass.invokeMethod(this,'respondsTo',name,args)){
            metaClass.invokeMethod(this,name,args)
        }else{
            System.out.println('没有这个方法')
        }
    }
}
Mannager.instance
Mannager.instance.init()
Mannager.instance.dream()
*/

/**
 * 1、在类的单个对象上进行方法拦截
 * 2、在类上进行方法拦截
 */
/*
class Lin{
    def dream(){
        println('lin dream')
    }
}

//改变单个对象
def lin = new Lin()
lin.dream()
lin.metaClass.dream = {
    println('change dream')
}
lin.dream()
new Lin().dream()

//改写invokeMethod 跟继承GroovyInterceptable一样
lin.metaClass.invokeMethod = {
    String name,Object args->
        System.out.println('invoke')
        def method = delegate.metaClass.getMetaMethod(name,args)
        if(method){
            method.invoke(delegate,args)
        }
}
lin.dream()
//改变jdk里的方法
String.metaClass.plus = {
    CharSequence i->
        i
}
println( "123" + "abc")
*/

/**
 * 当方法和属性没有的话  会调用这些方法
 */
class Man{
    def propertyMissing(String name) {
        return null
    }

    def propertyMissing(String name, def arg) {

    }

    def methodMissing(String name, def args) {
        println('methdMissing')
        return 'meiyou'
    }

    def dream(){
        println 'dream'
    }
}
def man = new Man()
println(man.drea())
man.dream()

//动态改变类中的方法实现
def scanner = new Scanner(System.in)
Thread.start {
    while (true){
        def msg = scanner.nextLine()
        if(msg == 'exit'){
            break
        }
        if(man.respondsTo(msg)){
            man."$msg"()
        }else{
            def (name,body) = msg.split(':')
            man.metaClass."$name" = {
                evaluate(body)
            }
        }
    }
}