一步一步想Java动态代理

版本一

试着只去看API，根据自己的理解，写出了Java动态代理的第一个版本

publicclass DynamicProxyTest

{

    publicstaticinterface IWorker {

       public String work();

    }

   

    publicstaticclass Worker implements IWorker{

        public String work() {

           System.out.println("working...");

           return"hello, work";

        }

    }

   

    publicstaticclass Invocator implements InvocationHandler {

       @Override

       public Object invoke(Object proxy, Method method, Object[] args)

              throws Throwable {

           System.out.println("before work...");

           String s = (String)method.invoke(proxy);

           System.out.println("after work...");

           returns;

       }

    }

    publicstaticvoid main(String[] args) {

       InvocationHandler invocator = new Invocator();

       IWorker proxyWorker = (IWorker)Proxy.newProxyInstance(DynamicProxyTest.class.getClassLoader(), new Class[]{IWorker.class}, invocator);

       System.out.println(proxyWorker.work());

    }

}

在不知道具体怎么使用动态代理的情况下，主要围绕Proxy.newProxyInstance这个方法猜测用法的。这个方法接收三个参数，如下：

ClassLoader loader:这个好办，把当前类加载器传入即可。

Class<?>[] interfaces:生成的代理类有哪些方法，是通过传入哪些接口类决定的（这也表明了java动态代理是基于接口的）；这个参数也没有疑问，直接把我们要代理的接口传入即可：new Class[]{IWorker.class}。

InvocationHandler h:实际上在实现InvocationHandler的时候不太清楚怎么实现，主要是不清楚接口中的Object proxy代表什么，于是写成了下面的样子；直接new了一个该实现类当参数传入了。

publicstaticclass Invocator implements InvocationHandler {

       @Override

       public Object invoke(Object proxy, Method method, Object[] args)

              throws Throwable {

           System.out.println("before work...");

           String s = (String)method.invoke(proxy);

           System.out.println("after work...");

           returns;

       }

    }

不出所料，挂掉了，而且错误信息根本停不下来啊。

想了一下，最有可能出问题的地方是：不太清楚InvocationHandler接口中接口方法invoke(Object proxy, Method method, Object[] args)中，参数proxy究竟是一个什么对象呢？

看Proxy.newProxyInstance的源代码（SUN JDK）:

第一步： 

/*

         * Look up or generate the designated proxy class.

         */

        Class<?> cl = getProxyClass0(loader, interfaces);

生成代理类的字节码，具体怎么生成的先不管。

第二步：

/** parameter types of a proxy class constructor */

privatefinalstatic Class[] constructorParams =

        { InvocationHandler.class };

final Constructor<?> cons = cl.getConstructor(constructorParams);

获取代理类的构造函数类（构造函数在JVM中使用Constructor类表示）。

第三部：

cons.newInstance(new Object[] {h} );

构造函数+构造函数参数生成代理类实例，一个我们需要的代理类就生成的。

现在关于生成的代理类，有以下几点可以确定：

1、代理类以一个InvocationHander实例为参数，该实例是通过Proxy.newProxyInstance传入的。

2、代理类具有它所代理的接口的所有方法，比如，Iworker的代理类，就一定会有一个work()方法，因为我们将来还要通过代理类调用work()方法的。

所以，IWorker生成的代理类大体长这样：

/**

     * 模仿JDK动态生成的代理类

     * Java为IWorker生成的代理类，应该类似我们这里实现的该类。

     * 只不过JDK使用字节码技术动态生成该类，因此灵活性更高。

     * @author Grucee

     */

    publicstaticclass ImitationProxy implements IWorker{

       private InvocationHandler handler;

       public ImitationProxy(InvocationHandler handler) {

           this.handler = handler;

       }

      

       @Override

       public String work() {

           returnnull;

       }

      

    }

那么它的work方法又是怎么实现呢，结合InvocationHandler的接口，该方法应该是知己调用InvocationHandler的invoke方法：

public String work() {

           return handler.invoke(this, method, args);

       }

上面的代码是编译不通过的，因为我们看似无法获取到method，args参数。其实不然，代理类怎么知道自己是有哪些方法要实现的，肯定是通过Proxy.newProxyInstance第二个参数（接口类数组），然后通过Class:getDeclaredMethods()获取到有哪些方法要实现，所以它在生成代理类的work方法的时候，肯定就知道它是Iworker.class. getDeclaredMethods[]中的work方法了；当然也就知道这个方法有哪些参数了。

至此，我们终于搞清楚了InvocationHandler:invoke(Object proxy, Method method, Object[] args)中，参数proxy代表什么？它代码的是JDK动态生成的代理类的一个实例。

再思考一个问题，动态生成的代理类会干活么？不会，只有我们自己的IWorker实现类Worker才知道work方法要做什么，所以我们必须要有一个Worker实例才能真正完成工作。因此有了下面的版本二。

版本二

publicclass DynamicProxyTest

{

    publicstaticinterface IWorker {

       public String work();

    }

   

    publicstaticclass Worker implements IWorker{

        public String work() {

           System.out.println("working...");

           return"hello, work";

        }

    }

   

   

    publicstaticclass Invocator implements InvocationHandler {

        private IWorker worker;

        public Invocator(IWorker worker) {

           this.worker = worker;

        }

       

       @Override

       public Object invoke(Object proxy, Method method, Object[] args)

              throws Throwable {

           System.out.println("before work...");

           String s = (String)method.invoke(worker);

           System.out.println("after work...");

           returns;

       }

    }

    publicstaticvoid main(String[] args) {

       IWorker worker = new Worker();

       InvocationHandler invocator = new Invocator(worker);

       IWorker proxyWorker = (IWorker)Proxy.newProxyInstance(DynamicProxyTest.class.getClassLoader(), new Class[]{IWorker.class}, invocator);

       System.out.println(proxyWorker.work());

    }

}

我们让InvocationHandler持有一个Worker实例，有实例、又有实例的方法，通过反射就可以完成具体的工作了。并且它可以在做具体工作前、后做任意的处理。

版本三

从上面版本二可以看出，要获取一个接口的代理类，我们要提供两个参数：接口类和实现类的一个实例。

如果接口类和实现类的包名再加一些约束条件，即通过接口类可以知道实现类的约束条件，那样我们就可以传入一个接口类，就可以返回一个代理类了。比如最简单的约束条件：接口类和实现类在同一包名下，接口类以IXXX命名，实现类以XXXImpl命名。

publicclass DynamicProxyTest

{

    publicstaticinterface IWorker {

       public String work();

    }

   

    publicstaticclass IWorkerImpl implements IWorker{

        public String work() {

           System.out.println("working...");

           return"hello, work";

        }

    }

   

   

    publicstaticclass Invocator implements InvocationHandler {

        private Object o;

        private Invocator(Object o) {

           this.o = o;

        }

       

       @Override

       public Object invoke(Object proxy, Method method, Object[] args)

              throws Throwable {

           System.out.println("before work...");

           String s = (String)method.invoke(o);

           System.out.println("after work...");

           returns;

       }

    }

   

    publicstatic Object getProxy(Class<?> iface) throws Exception {

        String ifaceName = iface.getName();

        String[] ifaceSplitted = ifaceName.split("[.]");

       

        String packageName = "";

        intlastSplit = ifaceName.lastIndexOf(".");

        if (lastSplit != -1) {

           packageName = ifaceName.substring(0, lastSplit);

        }

       

        String className = ifaceSplitted[ifaceSplitted.length - 1] + "Impl";

        if (!packageName.equals("")) {

           className = packageName + "." +  className;

        }

       

        //实例化实现类

        Object o = Class.forName(className).newInstance();

        InvocationHandler invocator = new Invocator(o);

        return Proxy.newProxyInstance(DynamicProxyTest.class.getClassLoader(), new Class[]{iface}, invocator);

    }

   

    publicstaticvoid main(String[] args) throws Exception {

       IWorker worker = (IWorker)getProxy(IWorker.class);

       worker.work();

    }

   

    /**

     * 模仿JDK动态生成的代理类

     * Java为IWorker生成的代理类，应该类似我们这里实现的该类。

     * 只不过JDK使用字节码技术动态生成该类，因此灵活性更高。

     * @author Grucee

     */

    publicstaticclass ImitationProxy implements IWorker{

       private InvocationHandler handler;

      

       public ImitationProxy(InvocationHandler handler) {

           this.handler = handler;

       }

      

       @Override

       public String work() {

           /**

            * Object proxy:这个好办，传入this

            * Method method:代理类怎么知道自己是有哪些方法要实现的，肯定是通过

            * Proxy.newProxyInstance第二个参数（接口类数组），然后通过

            * Class:getDeclaredMethods()获取到有哪些方法要实现，所以它在生成代理类的work方法

            * 的时候，肯定是知道Method是哪个了。

            * Object[] args：方法的参数

            */

           //return handler.invoke(this, method, args);

           return"";

       }

      

    }

}