java代理模式

阿新 • • 發佈：2018-03-23

nal dos log model 小夥伴 ams stp 變化 dna

事例

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

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

java代理模式

java代理模式

事例

靜態代理

1.抽象角色

2.真實角色

3.代理角色

總結

動態代理

總結

源碼分析(JDK7)

查看動態生成的代理類

Java 代理模式

對Java代理模式的理解

java代理模式與裝飾者模式

java 代理模式（靜態代理、動態代理、Cglib代理）轉載

java代理模式詳解

java代理模式

Java代理模式(Cplig)代理模式

java代理模式學習，靜態代理，JDK動態代理，CGLIB動態代理

不學無數——Java代理模式

Java代理模式之動態代理

一個小姐姐引發的java代理模式

Java代理模式實現的三種方式

Java 代理模式及動態代理

java代理模式和動態代理

淺談自己對Java代理模式的理解--即為什麼要用&怎麼用

談談java代理模式的認識二——動態代理（JDK)

java 代理模式的實現及應用

Java代理模式及應用（三）Cglib實現

Java代理模式實現與原理詳解（一）

java代理模式以及實現

java代理模式

事例

靜態代理

1.抽象角色

2.真實角色

3.代理角色

總結

動態代理

總結

源碼分析(JDK7)

查看動態生成的代理類

相關推薦