java代理模式

標籤：gen   項目   param   產生   chm   alc   with   使用   throw   

案例

小張是一個普普通通的碼農，每天勤勤懇懇地碼代碼。某天中午小張剛要去吃飯，一個電話打到了他的手機上。“是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");        }}

執行結果如下：

1501728574978Zhang implemented demand:Modify user management in JAVA!1501728574979

通過上述代碼，就實現了，在執行委託類的所有方法前、後列印時間。還是那個熟悉的小張，但我們並沒有建立代理類，也沒有時間ICoder介面。這就是動態代理。

總結

總結一下，一個典型的動態代理可分為以下四個步驟：

1. 建立抽象角色
2. 建立真實角色
3. 通過實現InvocationHandler介面建立中介類
4. 通過情境類，動態組建代理程式類

如果只是想用動態代理，看到這裡就夠了。但如果想知道為什麼通過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());  }}

這樣，我們就理解，為什麼調用代理類的implDemands方法，回去執行中介類的invoke方法了。

java代理模式