事例
小張是一個普普通通的碼農，每天勤勤懇懇地碼代碼。某天中午小張剛要去吃飯，一個電話打到了他的手機上。“是XX公司的小張嗎？我是YY公司的王AA”。“哦，是王總啊，有什么事情嗎？”。溝通過后，小張弄明白了,原來客戶有個需求，剛好負責這方面開發的是小張，客戶就直接找到了他。不過小張卻沒有答應客戶的請求，而是讓客戶找產品經理小李溝通。
是小張著急去吃面而甩鍋嗎？并不是，只是為了使故事可以套到代理模式上。我們先看一下代理模式的定義： * 為其他對象提供一種代理，以控制對這個對象的訪問。(Provide a surrogate or placeholder for another object to control access to it)
對照定義，碼農小張可以映射為其他對象，產品經理小李為小張的代理。我們通過JAVA代碼，表述上面事例。
靜態代理
1.抽象角色
基于面向對象的思想，首先定義一個碼農接口,它有一個實現用戶需求的方法。
public interface ICoder {
public void implDemands(String demandName);
}
2.真實角色
我們假設小張是JAVA程序員，定義一個JAVA碼農類，他通過JAA語言實現需求。
public class JavaCoder implements ICoder{
private String name;
public JavaCoder(String name){
this.name = name;
}
@Override
public void implDemands(String demandName) {
System.out.println(name + " implemented demand:" + demandName + " in JAVA!");
}
}
3.代理角色
委屈一下產品經理，將其命名為碼農代理類，同時讓他實現ICoder接口。
public class CoderProxy implements ICoder{
private ICoder coder;
public CoderProxy(ICoder coder){
this.coder = coder;
}
@Override
public void implDemands(String demandName) {
coder.implDemands(demandName);
}
}
上面一個接口，兩個類，就實現了代理模式。Are you kidding me？這么簡單？是的，就是這么簡單。 我們通過一個場景類，模擬用戶找產品經理增加需求。
public class Customer {
public static void main(String args[]){
//定義一個java碼農
ICoder coder = new JavaCoder("Zhang");
//定義一個產品經理
ICoder proxy = new CoderProxy(coder);
//讓產品經理實現一個需求
proxy.implDemands();
}
}
運行程序，結果如下：
Zhang implemented demand:Add user manageMent in JAVA!
產品經理充當了程序員的代理，客戶把需求告訴產品經理，并不需要和程序員接觸。看到這里，有些機智的程序員發現了問題。你看，產品經理就把客戶的需求轉達了一下，怪不得我看產品經理這么不爽。
產品經理當然不只是轉達用戶需求，他還有很多事情可以做。比如，該項目決定不接受新增功能的需求了，對修CoderProxy類做一些修改：
public class CoderProxy implements ICoder{
private ICoder coder;
public CoderProxy(ICoder coder){
this.coder = coder;
}
@Override
public void implDemands(String demandName) {
if(demandName.startsWith("Add")){
System.out.println("No longer receive 'Add' demand");
return;
}
coder.implDemands(demandName);
}
}
這樣，當客戶再有增加功能的需求時，產品經理就直接回絕了，程序員無需再對這部分需求做過濾。
總結
我們對上面的事例做一個簡單的抽象：
代理模式包含如下角色：
Subject:抽象主題角色。可以是接口，也可以是抽象類。
RealSubject:真實主題角色。業務邏輯的具體執行者。
ProxySubject:代理主題角色。內部含有RealSubject的引用,負責對真實角色的調用，并在真實主題角色處理前后做預處理和善后工作。
代理模式優點：
職責清晰 真實角色只需關注業務邏輯的實現，非業務邏輯部分，后期通過代理類完成即可。
高擴展性 不管真實角色如何變化，由于接口是固定的，代理類無需做任何改動。
動態代理
前面講的主要是靜態代理。那么什么是動態代理呢？
假設有這么一個需求，在方法執行前和執行完成后，打印系統時間。這很簡單嘛，非業務邏輯，只要在代理類調用真實角色的方法前、后輸出時間就可以了。像上例，只有一個implDemands方法，這樣實現沒有問題。但如果真實角色有10個方法，那么我們要寫10遍完全相同的代碼。有點追求的碼農，肯定會對這種方法感到非常不爽。有些機智的小伙伴可能想到了用AOP解決這個問題。非常正確。莫非AOP和動態代理有什么關系？沒錯！AOP用的恰恰是動態代理。
代理類在程序運行時創建的代理方式被稱為動態代理。也就是說，代理類并不需要在Java代碼中定義，而是在運行時動態生成的。相比于靜態代理， 動態代理的優勢在于可以很方便的對代理類的函數進行統一的處理，而不用修改每個代理類的函數。對于上例打印時間的需求，通過使用動態代理，我們可以做一個“統一指示”，對所有代理類的方法進行統一處理，而不用逐一修改每個方法。下面我們來具體介紹下如何使用動態代理方式實現我們的需求。
與靜態代理相比，抽象角色、真實角色都沒有變化。變化的只有代理類。因此，抽象角色、真實角色，參考ICoder和JavaCodr。
在使用動態代理時，我們需要定義一個位于代理類與委托類之間的中介類，也叫動態代理類，這個類被要求實現InvocationHandler接口：
public class CoderDynamicProxy implements InvocationHandler{
//被代理的實例
private ICoder coder;
public CoderDynamicProxy(ICoder _coder){
this.coder = _coder;
}
//調用被代理的方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(System.currentTimeMillis());
Object result = method.invoke(coder, args);
System.out.println(System.currentTimeMillis());
return result;
}
}
當我們調用代理類對象的方法時，這個“調用”會轉送到中介類的invoke方法中，參數method標識了我們具體調用的是代理類的哪個方法，args為這個方法的參數。
我們通過一個場景類，模擬用戶找產品經理更改需求。
public class DynamicClient {
public static void main(String args[]){
//要代理的真實對象
ICoder coder = new JavaCoder("Zhang");
//創建中介類實例
InvocationHandler ?handler = new CoderDynamicProxy(coder);
//獲取類加載器
ClassLoader cl = coder.getClass().getClassLoader();
//動態產生一個代理類
ICoder proxy = (ICoder) Proxy.newProxyInstance(cl, coder.getClass().getInterfaces(), handler);
//通過代理類，執行doSomething方法；
proxy.implDemands("Modify user management");
}
}
執行結果如下：
1501728574978
Zhang implemented demand:Modify user management in JAVA!
1501728574979
通過上述代碼，就實現了，在執行委托類的所有方法前、后打印時間。還是那個熟悉的小張，但我們并沒有創建代理類，也沒有時間ICoder接口。這就是動態代理。
總結
總結一下，一個典型的動態代理可分為以下四個步驟：
創建抽象角色
創建真實角色
通過實現InvocationHandler接口創建中介類
通過場景類，動態生成代理類
如果只是想用動態代理，看到這里就夠了。但如果想知道為什么通過proxy對象，就能夠執行中介類的invoke方法，以及生成的proxy對象是什么樣的，可以繼續往下看。
源碼分析(JDK7)
看到這里的小伙伴，都是有追求的程序員。上面的場景類中，通過
//動態產生一個代理類
ICoder proxy = (ICoder) Proxy.newProxyInstance(cl, coder.getClass().getInterfaces(), handler);
動態產生了一個代理類。那么這個代理類是如何產生的呢？我們通過代碼一窺究竟。
Proxy類的newProxyInstance方法，主要業務邏輯如下：
//生成代理類class，并加載到jvm中
Class cl = getProxyClass0(loader, interfaces);
//獲取代理類參數為InvocationHandler的構造函數
final Constructor cons = cl.getConstructor(constructorParams);
//生成代理類，并返回
return newInstance(cons, ih);
上面代碼做了三件事：
根據傳入的參數interfaces動態生成一個類，它實現interfaces中的接口，該例中即ICoder接口的implDemands方法。假設動態生成的類為$Proxy0。
通過傳入的classloder,將剛生成的$Proxy0類加載到jvm中。
利用中介類，調用$Proxy0的$Proxy0(InvocationHandler)構造函數，創建$Proxy0類的實例，其InvocationHandler屬性，為我們創建的中介類。
上面的核心，就在于getProxyClass0方法：
private static Class getProxyClass0(ClassLoader loader,
Class... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// If the proxy class defined by the given loader implementing
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
return proxyClassCache.get(loader, interfaces);
}
在Proxy類中有個屬性proxyClassCache，這是一個WeakCache類型的靜態變量。它指示了類加載器和代理類之間的映射。所以proxyClassCache的get方法用于根據類加載器來獲取Proxy類，如果已經存在則直接從cache中返回，如果沒有則創建一個映射并更新cache表。
我們跟一下代理類的創建流程：
調用Factory類的get方法，而它又調用了ProxyClassFactory類的apply方法，最終找到下面一行代碼：
//Generate the specified proxy class.
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
就是它，生成了代理類。
查看動態生成的代理類
通過上面的分析，我們已經知道Proxy類動態創建代理類的流程。那創建出來的代理類到底是什么樣子的呢？我們可以通過下面的代碼，手動生成：
public class CodeUtil {
public static void main(String[] args) throws IOException {
byte[] classFile = ProxyGenerator.generateProxyClass("TestProxyGen", JavaCoder.class.getInterfaces());
File file = new File("D:/aaa/TestProxyGen.class");
FileOutputStream fos = new FileOutputStream(file);
fos.write(classFile);
fos.flush();
fos.close();
}
}
通過反編譯工具查看生成的class文件:
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import model.proxy.ICoder;
public final class TestProxyGen extends Proxy
implements ICoder
{
private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;
public TestProxyGen(InvocationHandler paramInvocationHandler)
throws
{
super(paramInvocationHandler);
}
public final boolean equals(Object paramObject)
throws
{
try
{
return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final int hashCode()
throws
{
try
{
return ((Integer)this.h.invoke(this, m0, null)).intValue();
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final void implDemands(String paramString)
throws
{
try
{
this.h.invoke(this, m3, new Object[] { paramString });
return;
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
public final String toString()
throws
{
try
{
return (String)this.h.invoke(this, m2, null);
}
catch (RuntimeException localRuntimeException)
{
throw localRuntimeException;
}
catch (Throwable localThrowable)
{
}
throw new UndeclaredThrowableException(localThrowable);
}
static
{
try
{
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
m3 = Class.forName("model.proxy.ICoder").getMethod("implDemands", new Class[] { Class.forName("java.lang.String") });
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
return;
}
catch (NoSuchMethodException localNoSuchMethodException)
{
throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
}
catch (ClassNotFoundException localClassNotFoundException)
{
}
throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
}
}
