什么是代理模式？
代理模式的作用是：為其他對象提供一種代理以控制對這個對象的訪問。
什么是動態代理？
Java的java.lang.reflect包中有自己的代理支持，利用這個包你可以在運行時動態地創建一個代理類，實現一個或者多個接口，并將方法的調用轉發到你所指定的類。因為實際的代理類是運行時創建的，所以稱這個Java技術為：動態代理。
為什么需要使用動態代理？
因為傳統的代理方式見下圖，每次都要自己創建一個實現代理對象的接口的類，當需要很多這樣的需求的時候，就會發現這會變得非常復雜。
然后，自然而然的，作為一個程序員，當然要創建一個東西來很好地實現解決這個問題。然后就有了Java內置的動態代理。見下圖。通過反射來在運行時，動態地創建想對應的代理對象。
示例代碼
/**
* 抽象主題
*/
public interface Subject {
/**
* 聲明抽象請求方法
*/
void request();
}
/**
* 真實主題
*/
public class RealSubject implements Subject {
/**
* 實現請求方法
*/
@Override
public void request() {
System.out.println("Request.");
}
}
/**
* 代理主題
*/
public class ProxySubject implements Subject {
/**
* 被代理對象
*/
private RealSubject realSubject;
/**
* 通過被代理對象訪問方法
*/
@Override
public void request() {
System.out.println("Start.");
if (realSubject == null) {
realSubject = new RealSubject();
}
realSubject.request();
System.out.println("End.");
}
}
public class Client {
public static void main(String[] args) {
Subject subject = new ProxySubject();
subject.request();
}
}
這里就可以發現使用了代理之后，就可以對原來的主題中的request方法的調用之前和調用之后，都進行相應的行為。其實有點類似于Spring中AOP的意思，和裝飾器模式也有點像(都實現了想要代理或者想要裝飾的對象的接口)。
但是代理模式的目的是實現訪問控制之類的，而裝飾器其實更多的是為了改變對象的行為。
動態代理代碼
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class LogInvocationHandler implements InvocationHandler {
/**
* 被代理對象
*/
private Object obj;
public LogInvocationHandler(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("Start.");
method.invoke(obj, args);
System.out.println("End.");
return null;
}
}
import java.lang.reflect.Proxy;
public class Client {
public static void main(String[] args) {
//為了獲得動態的代理文件
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
Subject subject = new RealSubject();
// 使用 Proxy.newProxyInstance 方法生成代理對象
Subject proxy = (Subject) Proxy.newProxyInstance(subject.getClass()
.getClassLoader(), subject.getClass().getInterfaces(),
new LogInvocationHandler(subject));
System.out.println("自動生成代理類：" + proxy.getClass().getName());
proxy.request();
}
}
如果使用了動態代理的話，那么原來的代理的實現就不需要了，可以有Proxy.newProxyInstance()這個靜態方法來動態的生成。但是也是要注意用法，這里需要一個實現了InvocationHandler接口的類。
注意這里動態生成的代理對象繼承的Proxy類，然后實現的是給予的接口，所以這里才能夠將這個對象轉化為Subject對象。這里是必須轉化的，不然會出現一個錯誤就是返回的對象是一個Object類型的。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,InvocationHandler h) throws IllegalArgumentException
無論調用是代理類的哪一個方法，最后都會去調用InvocationHandler的invoke方法。
理解
到底是怎么通過反射來生成的相對應的代理類的？
網上找了很多資料看這個問題，但是只發現涉及到的知識點有安全機制，緩存，反射，還有很多很多東西，只能看最外層的API大致了解一下了。
/**
* 返回一個指定接口的代理類實例，將方法調用指派到指定的調用處理程序。
*/
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces, InvocationHandler h)
throws IllegalArgumentException {
if (h == null) {
throw new NullPointerException();
}
/*
* 調用 getProxyClass 方法查找或生成指定代理類。
用到查找是因為這里內部是有緩存的，用一個Map來維護。
當發現有重復是直接就可以取出來的。
使用類加載器和傳入的接口數組(因為可能這個subject會實現多個接口)。
最后就可以得到代理類的Class。
通過下面的代碼也可以知道這個Class的構造函數，
是需要一個**InvocationHandler**的引用的。
*/
Class<?> cl = getProxyClass(loader, interfaces);
/*
* 調用構造方法傳入構造管理器生成代理類實例。
*/
try {
// constructorParams = { InvocationHandler.class };
Constructor cons = cl.getConstructor(constructorParams);
// 生成實例
return cons.newInstance(new Object[] { h });
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString());
} catch (IllegalAccessException e) {
throw new InternalError(e.toString());
} catch (InstantiationException e) {
throw new InternalError(e.toString());
} catch (InvocationTargetException e) {
throw new InternalError(e.toString());
}
}
為什么最后無論調用哪一個方法都會去調用InvocationHandler的invoke方法？
其實這個東西看過動態生成的類就會比較清晰。
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.sun.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m2;
private static Method m3;
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})).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 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);
}
}
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("Subject").getMethod("request", new Class[0]);
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());
}
}
}
這里可以看到使用Java動態代理生成的類，其實傳統的實現原理都是一樣的。就是覆蓋了主題(Subject)接口中的相應方法，然后調用的是super.h.invoke(this, m3, (Object[])null);，雖然這個例子只是寫了一個方法，但是可以想象到的時，其實所有的方法都是這個邏輯，都調用了invoke方法，不同的只是傳遞過去的函數名字是不同的。
m3代表的是request，因為request是一個無參方法，所以有(Object[])null。
疑惑
之前也看到了動態生成的類的源代碼，但是當我在Client中對proxy.request()單步調試進入這句話的時候，并沒有出現和進入proxy的源代碼中，也就是說并沒有super.h.invoke(this, m3, (Object[])null);這句話的顯示并讓我進入，而是直接讓我進入了InvocationHandler，理論上不應該呀，那個對象應該已經存在內存中了呀？！！還有待進一步加深理解。
最后：
Java1.8的源碼比之前的都要復雜的多，如果1.8的看不懂的話，可以先理解一下1.7的版本。
參考：
java代理模式（proxy）及動態代理的源碼分析(講的Java1.8的源碼)
Java API 源碼閱讀：動態代理（Dynamic Proxy）(講的1.7,大量引用了例子)
JDK源碼分析——動態代理源碼(Proxy類)
JDK動態代理實現原理
Java的動態代理(dynamic proxy)
