简单理解java动态代理

2016-07-20

java动态代理，能干什么呢。假设有一种场景，我们调用某个类的所有方法，然后我们想记录下我们调用每个方法的调用时间，这个我们该怎么去实现它。比较笨的办法是我们每调用一个方法，都在方法的开始和返回之前，去计算一下时间。但是这样的话，我们写了很多重复的代码。通过动态代理，我们就能实现这样的功能，spring也是同样方式，去实现类似的功能。
首先我们定义一个接口

public interface Person {
    public void run();
    public void jump();
}

有两个方法，现在我们想统计调用这两个方法，占用的时长统计。

class Jack implements Person {
        @Override
        public void run() {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我是jack，我正在跑");
        }

        @Override
        public void jump() {
            System.out.println("我是jack，我正在跳");
        }
    }

让jack来实现这个接口，现在我们来统计jack的运行时间。

final Person jack = new Jack();
       Person jackPrxoxy = (Person) Proxy.newProxyInstance(Jack.class.getClassLoader(), new Class<?>[]{Person.class}, new InvocationHandler() {
           @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               long time = System.currentTimeMillis();
               method.invoke(jack, args);
               System.out.println("调用" + method.getName() + "方法，耗时：" + (System.currentTimeMillis() - time));
               return null;
           }
       });
       jackPrxoxy.run();
       jackPrxoxy.jump();

最终得到的结果是

我是jack，我正在跑
调用run方法，耗时：101
我是jack，我正在跳
调用jump方法，耗时：0

通过上面简单的代码，我们已经实现了我们最初的需求，那么我们来分析，分析背后的原理。
通过查看源码可知，Proxy.newProxyInstance这个类会动态生成一个java的class类，然后动态生成的这个class类，将被实例化，供我们调用。

byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0",new Class<?>[]{Person.class});
       String path = "./StuProxy.class";
       try(FileOutputStream fos = new FileOutputStream(path)) {
           fos.write(classFile);
           fos.flush();
           System.out.println("代理类class文件写入成功");
       } catch (Exception e) {
           System.out.println("写文件错误");
       }

可通过这个代码，去保存生成的类。

public final class $Proxy0 extends Proxy implements Person {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void run() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void jump() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("proxy.Person").getMethod("run");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m4 = Class.forName("proxy.Person").getMethod("jump");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

从上面的代码可以清晰的看出来，我们调用的方法最终都被代理给了InvocationHandler，我们在InvocationHandler又反射调用被代理的对象，最终实现整个代理过程。