java动态代理--比较容易理解的例子

前几天看到java的动态代理机制，不知道是啥玩意，而后看了看。死活不知道 
invoke(Object proxy, Method m, Object[] args)种的proxy是个什么东西，放在这里有什么用？因而网上处处搜刮，把本身的理解写了写。 

 

/** 
 * 相亲接口 
 *  
 * @author zhengt 
 * @time Jun 3, 2095 3:13:03 PM 
 */  
public interface XiangQinInterface {  
    /** 
     * 相亲方法 
     */  
    public void xiangQin();  
}  
/** 
 * 张三相亲实现类 
 *  
 * @author zhengt 
 * @time Jun 3, 2095 3:14:48 PM 
 */  
public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {  
    public void xiangQin() {  
        System.out.println("张三去相亲，娶个漂亮老婆。");  
    }  
}  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
  
/** 
 * 相亲但是一生的大事，相亲前要准备一下，打扮得帅气些。 
 *  
 * @author zhengt 
 * @time Jun 3, 2095 3:15:48 PM 
 */  
public class ReadyInvocationHandler implements InvocationHandler {  
    //相亲接口的实现类，也就是张三相亲类  
    private Object zhangSan = null;  
  
    public ReadyInvocationHandler(Object realSubject) {  
        this.zhangSan = realSubject;  
    }  
  
    public Object invoke(Object proxy, Method m, Object[] args) {  
        Object result = null;  
        try {  
            /** 
             * 动态代理类$Proxy0调用xiangQin方法时会调用它本身的xiangQin方法， 
             * 而它本身的xiangQin方法里面调用的是super.h.invoke(this, , )，也就是父类Proxy的h的invoke方法， 
             * 也就是ReadyInvocationHandler类的invoke方法。 
             * 因此，invoke(Object proxy, Method m, Object[] args)种的proxy实际上就是动态代理类$Proxy0， 
             * 若是你将其强转成XiangQinInterface而后调用它的xiangQin方法，而后它就会调用super.h.invoke(this, , )，这样就会死循环。 
             */  
            /** 
             * 网上关于这里最多问题就是Object proxy放在这里用来作什么呢？这个我也不知道， 
             * 不过至少咱们知道它究竟是个什么东西，具体作什么用嘛就不得而知了 
             */  
            System.out.println(proxy.getClass().getSimpleName());  
            System.out.println("张三相亲前，代理人给他打扮了打扮。");  
            result = m.invoke(zhangSan, args);  
        } catch (Exception ex) {  
            System.exit(1);  
        }  
        return result;  
    }  
}  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
  
/** 
 * 张三来到了婚介所(相亲现场)，开始相亲。 
 *  
 * @author zhengt 
 * @time Jun 3, 2095 3:17:16 PM 
 */  
public class HunJieSuo {  
    public static void main(String args[]) {  
        //先将张三相亲这个相亲的实现类实例化，也就是获得XiangQinInterface接口的一个实例对象  
        XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();  
        /** 
         * 获得ZhangSanXiangQinInterfaceImpl这个类的一个代理类，同时为代理类绑定了一个处理类ReadyInvocationHandler。 
         * 听着很绕口，其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时， 
         * 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用， 
         * 而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它本身的invoke方法, 
         * 这个invoke方法里呢能够调用zhangSan这个实例的xiangQin方法 
         */  
        /** 
         * 在java种怎样实现动态代理呢 
         * 第一步，咱们要有一个接口，还要有一个接口的实现类，而这个实现类呢就是咱们要代理的对象， 
         * 所谓代理呢也就是在调用实现类的方法时，能够在方法执行先后作额外的工做，这个就是代理。 
         * 第二步，咱们要本身写一个在要代理类的方法执行时，可以作额外工做的类，而这个类必须继承InvocationHandler接口， 
         * 为何要继承它呢？由于代理类的实例在调用实现类的方法的时候，不会调真正的实现类的这个方法， 
         * 而是转而调用这个类的invoke方法（继承时必须实现的方法），在这个方法中你能够调用真正的实现类的这个方法。 
         * 第三步，在要用代理类的实例去调用实现类的方法的时候，写出下面两段代码。 
         */  
        XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(  
                zhangSan.getClass().getClassLoader(),  
                zhangSan.getClass().getInterfaces(),  
                new ReadyInvocationHandler(zhangSan));  
        proxy.xiangQin();  
        /** 
         * 这里要解释下中部那段长长的代码的意思，以及具体作了哪些工做？ 
         * 第一，根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和 
         * zhangSan.getClass().getInterfaces()要代理类所实现的全部的接口 
         * 做为参数调用Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces) 
         * 的方法返回代理类的java.lang.Class对象，也就是获得了java动态生成的代理类$Proxy0的Class对象。 
         * 同时，java还让这个动态生成的$Proxy0类实现了要代理类的实现的全部接口，并继承了Proxy接口。 
         * 第二，实例化这个动态生成的$Proxy0类的一个实例，实例化代理类的构造函数为Proxy(InvocationHandler h)， 
         * 也就是说要实例化这个动态生成的$Proxy0类，必须给它一个InvocationHandler参数，也就是咱们本身实现的用来在代理类 
         * 方法执行先后作额外工做的类ReadyInvocationHandler。 
         * 这段代码Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan)) 
         * 获得的实际上是一个类名叫$Proxy0 extends Proxy implements XiangQinInterface的类。 
         * 第三，将这个$Proxy0类强制转型成XiangQinInterface类型，调用xiangQin方法。 
         */  
    }  
}