一、简单代理模式
简单代理模式就是为一个实现类找一个代理人类，由这个代理人持有这个实现类并对外提供服务。
假设我有一个RealSubject类，实现了Subject接口：
public class RealSubject implements Subject{
@Override
public void request() {
System.out.println("Real subject.");
}
}
Subject接口很简单，就定义了request方法：
public interface Subject {
void request();
}
那么写一个代理人类来代理RealSubject：
public class SubjectProxy implements Subject{
private Subject subject;
public SubjectProxy(Subject subject){
this.subject = subject;
}
public void request(){
...
subject.request();
...
}
}
使用的时候，只需要将RealSubject的实例对象交给代理类，再由代理类来对外提供服务：
public static void main(String[] args) {
Subject subject = new SubjectProxy(new RealSubject());
subject.request();
}
二、动态代理模式
代理模式的本质，就是在实际调用代码前后，先做一些处理。但是为了实现这个功能，简单代理模式(或者说静态代理模式)，需要为不同接口实现不同的代理类。比如说上文的Subject接口，实现代理模式需要一个SubjectProxy来实现这个接口。
假设我们需要代理很多接口，这些接口的代理者行为相近(比如房产中介都是代理雇主卖房子)，那么我却需要为每一个接口实现一个代理类。
其实不需要这样。使用动态代理可以解决这个问题。
Java中可以通过实现InvocationHandler接口来创建一个代处理类(有点拗口)。好比说刚刚的例子，可以把SubjectProxy改写为:
public class MyInvocation implements InvocationHandler {
private Object obj;
public MyInvocation(Object o){
this.obj = o;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before calling " + method);
method.invoke(obj, args);
System.out.println("after calling " + method);
return null;
}
}
好了，我们有了一个代处理类MyInvocation，如何用它来代理我们的RealSubject？答案在下面:
public static void main(String[] args) throws Throwable {
Subject rs = new RealSubject();
InvocationHandler ds = new MyInvocation(rs);
Class<?> cls = rs.getClass();
Subject subject=(Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), ds);
subject.request();
}
上面的代码中，我们首先实例化了一个需要被代理的类RealSubject，然后将其交给我们的MyInvocation持有。（简单代理模式到这一步就完成了代理，但是也因此使得代理类和具体接口绑定在一起）接下来，我们把MyInvocation、被代理类的一些信息传给Proxy类，由Proxy生成一个Subject对象。
此时调用新生成对象的方法，会发现已经完成了对RealSubject的代理。
三、动态代理的原理
通过debug上文的代码可以看到动态代理是如何实现的。
生成的代理对象实际类型是$Proxy0。$Proxy0继承自Proxy类，但并不是一个真实存在的类。而是在运行时动态生成的一个对象。
关于Java如何动态生成字节码可以参考这篇文章:Java动态代理机制详解。
通过下面的代码将$Proxy0对象导出为class文件:
String path = "/$Proxy0.class";
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", RealSubject.class.getInterfaces());
FileOutputStream out = null;
try {
out = new FileOutputStream(path);
out.write(classFile);
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
}
}
导出的$Proxy0.class如下所示：
public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m3;
private static Method m0;
private static Method m2;
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})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final void request() throws {
try {
super.h.invoke(this, m3, (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)).intValue();
} 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);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
m3 = Class.forName("com.mogujie.qiankun.proxy.Subject").getMethod("request", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
通过上面的代码可以知道，我们调用代理类的request方法时，实际执行的是：
public final void request() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
