动态代理模式的初实现

package com.it.Proxy;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//动态代理模式的实现
public class DynamicProxy {
    public static void main(String[] args) {
        //创建被代理类的对象
        superman superman = new superman();
        //获取代理类的对象
        Human instance = (Human) proxy.getInstance(superman);
        //代理类的对象调用其接口中重写的方法,实际是被代理类对象调用其内部的方法
        String believe = instance.getBelieve();
        instance.eat("水果");
        System.out.println(believe);

    }
}

interface   Human{
    String  getBelieve();
    void eat(String food);
}
//被代理类
class  superman   implements  Human{

    @Override
    public String getBelieve() {
        return "I    believe    I  can  fly! ";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}
//动态代理类
class   proxy{


    public static Object   getInstance(Object obj){
        //创建InvocationHandler接口实现类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        //调用bind绑定方法将被代理类的对象作为实参传递过去
        handler.bind(obj);
        //通过调用Proxy类中的newProxyInstance静态方法,传入被代理类,以及接口,以及调用处理器接口的实现类对象,
        //从而创建一个与被代理类,同加载器,同接口的代理类对象,而调用处理器接口使得在代理类对象调用其重写的方法时,实际
        //调用的是被代理类中的方法,从而达到动态代理模式的效果
        Object o = Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
                handler);
return o;
    }



    static class  MyInvocationHandler  implements java.lang.reflect.InvocationHandler {
        //提供一个Objcet类型的对象变量,使得任意对象都可以作为参数
           private   Object    obj;
    //通过bind方法,给被代理类对象初始化
        public  void bind(Object obj){
             this.obj =obj;
        }



        @Override
        //通过重写接口中的invoke方法,使得代理类对象在调用a方法时,会自动调用invoke方法,使被代理类对象调用a方法
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            //有返回值的话该方法可以直接将返回值返回,代理类对象调用方法处直接接收即可
            Object returnvalue = method.invoke(obj,args);
         
            return returnvalue;
        }
    }


}