Java —— 动态代理

1 接口：

public interface ProxySubject { public void foo(Object[] args); }

2 实现类

public class RealSubject implements ProxySubject { @Override public void foo(Object[] args) { System.out.println("This is foo execute"); } }

3 自定义InvocationHandler

public class ProxyHandler implements InvocationHandler { private Object subject; public ProxyHandler(Object subject) { this.subject = subject; } public void before() { System.out.println("This is before"); } @Override /** 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象,第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行 */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(); method.invoke(subject, args); return null; } }

调用时刻：

//该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类
subject = (ProxySubject) Proxy.newProxyInstance(subject.getClass().getClassLoader(), new Class[] {ProxySubject.class}, handler); subject.foo();

反编译得到的动态代理类：

import com.nj.java.proxy.ProxySubject;import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method;import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; public final class Proxy$0 extends Proxy implements ProxySubject { private static Method m1; private static Method m2; private static Method m3; private static Method m0; public Proxy$0(InvocationHandler var1) throws { super(var1); } public final boolean equals(Object var1) throws { try { return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue(); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } 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 foo(Object[] var1) throws { try { super.h.invoke(this, m3, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final int hashCode() throws { try { return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue(); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } static { try { m1 = Class.forName("java.lang.Object") .getMethod("equals", new Class[]{Class.forName("java.lang.Object")}); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); m3 = Class.forName("com.nj.java.proxy.ProxySubject") .getMethod("foo", new Class[]{Class.forName("[Ljava.lang.Object;")}); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }

在静态块内，有通过反射生成的接口方法 foo()——m3，同时在构造器内有传入具体 InvocationHandler类，通过调用该类的invoke方法（该方法传入了静态块内反射生成的接口方法 foo()，以及其参数），执行了用户自己定义的foo()；
本质上还是通过反射生成一个类，java核心技术一书有类似打印一个类的练习，利用的原理也是反射，在此基础上可以进一步将字符转换成二进制文件，进而通过传入的类加载器装载.

这其中还有一些其他的点

1 . 动态代理的类有做缓存，并保存下来，下一次要是请求相同的动态代理类时，直接将已经生成的代理类传给用户。
2 . 接口的数量是有限的 65535。有校验。
3 . 所有动态生成的 Proxy$N 类都集成自Proxy类。所以只能代理代理接口类。

有待验证的一些想法：

1 . 获取动态代理类的时候，自定义InvocationHandler类中的invoke()方法中，除了 method.invoke(Object proxy, Method method, Object[] args)外，其他的代码都会被执行一遍，获取该动态代理类的类加载器时，也会发生同样的事情，尝试从类加载机制上去解释。

参考文献： IBM Java 动态代理机制分析及扩展，第 1 部分.

（未完！）