2. 程式人生 > >深入理解系列之JAVA動態代理機制

深入理解系列之JAVA動態代理機制

阿新 • • 發佈：2019-02-02

代理的作用，就是生成代理物件使得真實物件的某些方法執行被代理物件攔截，從而在真實方法執行前、執行後新增額外的“動作”！動態代理則是指不需要修改原來的物件方法，在程式執行的過程中動態的生成代理物件，從而動態的生成這些“額外的”動作，主要從兩個方面來深入理解動態代理機制！

問題一、動態代理的基本實現是什麼？

動態代理本質上還是java中的“代理設計模式”，所以啟UML圖如下所示
這裡寫圖片描述
真正實現的時候分為以下幾個步驟：

1、建立被代理物件的介面

interface Subject{
      public void run();
    }

2、實現被代理的真實物件

class
 
 RealSubject implements Subject{
      @Override
      public void run(){
        System.out.println("真實物件正在執行");
      }
    }

3、建立呼叫處理器：

class SubjectInvocation implements InvocationHandler{

      private Subject subject;

      public SubjectInvocation(Subject subject){
        this.subject = subject;
      }

      @Override
      public
 
 Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("將要代理");
        Object result = method.invoke(subject,args);
        System.out.println("代理結束");
        return null;
      }
    }

呼叫處理器物件很關鍵，我們可以看到呼叫處理器物件持有被代理物件的介面，當invoke()執行的時候，通過method.invoke()執行實際物件的具體方法，這樣就相當於攔截了真實物件的執行，從而在實際方法執行的時候新增額外的動作！

4、生成代理物件：

public class ProxyTest {

      public static void main(String[] args){

        SubjectInvocation subjectInvocation = new SubjectInvocation(new RealSubject());
        Subject proxySubject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(),
                new Class[]{Subject.class},subjectInvocation);
        proxySubject.run();
        }
    }

重點關注程式碼：

Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),
                new Class[]{Subject.class},
                subjectInvocation);

我們發現，代理物件的型別是強制轉換為的被代理的介面型別，其中代理物件的生成是呼叫Proxy類的靜態方法實現的，

public static Object newProxyInstance(
ClassLoader loader, 
Class<?>[] interfaces, 
InvocationHandler h) 
throws IllegalArgumentException{…}

引數的含義如下：
loader：定義了代理類的ClassLoder,通常是interface.class.getClassLoader獲得；
interfaces：代理類實現的介面列表
h：呼叫處理器，也就是我們上面定義的實現了InvocationHandler介面的類例項
最後當呼叫proxySubject.run()時，實際上被攔截進而執行invoke()函式。我們執行一下，看看我們的動態代理是否能正常工作。我這裡執行後的輸出為：

將要代理
真實物件正在執行
代理結束

問題二、為什麼執行proxySubject.run()之後，會被攔截從而執行invoke()函式呢？

我們看到，invoke()函式其實是呼叫處理器裡的函式，而ProxySubject是Subject型別的，他們之間有什麼關係，為什麼執行run之後會跳到invoke函式呢？解開這個謎底的第一步是去看 Proxy.newProxyInstance()方法的原始碼！
第一步：

public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
            throws IllegalArgumentException
        {
            Objects.requireNonNull(h);

            final Class<?>[] intfs = interfaces.clone();
            final SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
            }

            /*
             * Look up or generate the designated proxy class.
             */
            Class<?> cl = getProxyClass0(loader, intfs);

            /*
             * Invoke its constructor with the designated invocation handler.
             */
            try {
                if (sm != null) {
                    checkNewProxyPermission(Reflection.getCallerClass(), cl);
                }

                final Constructor<?> cons = cl.getConstructor(constructorParams);
                final InvocationHandler ih = h;
                if (!Modifier.isPublic(cl.getModifiers())) {
                    AccessController.doPrivileged(new PrivilegedAction<Void>() {
                        public Void run() {
                            cons.setAccessible(true);
                            return null;
                        }
                    });
                }
                return cons.newInstance(new Object[]{h});
            } catch (IllegalAccessException|InstantiationException e) {
                throw new InternalError(e.toString(), e);
            } catch (InvocationTargetException e) {
                Throwable t = e.getCause();
                if (t instanceof RuntimeException) {
                    throw (RuntimeException) t;
                } else {
                    throw new InternalError(t.toString(), t);
                }
            } catch (NoSuchMethodException e) {
                throw new InternalError(e.toString(), e);
            }
        }

我們把多餘的異常處理等程式碼去除，只看核心程式碼：

public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
            throws IllegalArgumentException
        {

            final Class<?>[] intfs = interfaces.clone();
            Class<?> cl = getProxyClass0(loader, intfs);
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            return cons.newInstance(new Object[]{h});
         }

我們可以看到，代理物件的生成實際上是利用反射獲取建構函式，通過載入建構函式生成的，其中生成的物件持有呼叫處理器h。這裡有個很隱藏的問題：return cons.newInstance(new Object[]{h});到底返回的是什麼型別的物件？Subject？Proxy？其實都不是，我們可以打印出來該類的名稱來驗證一下，所以程式碼修改成這樣：

public class ProxyTest {

      public static void main(String[] args){
        SubjectInvocation subjectInvocation = new SubjectInvocation(new RealSubject());
        Subject proxySubject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(),
                new Class[]{Subject.class},subjectInvocation);
        System.out.println(proxySubject.getClass().getName());
        proxySubject.run();
        }
    }

執行輸出為：

proxySubject的型別是：$Proxy0
正在代理
真實物件正在執行
代理結束

OK，我們看到了一個意想不到的結果：Proxy0這個是什麼型別？還記得文章開始所說的代理類是動態生成的嗎？其中proxySubject就是代理類的例項物件，所以這個Proxy0就是動態生成的代理類，proxySubject就是根據這個類建立的動態代理物件！那麼這個類和Proxy、Subject又有什麼關係呢？為什麼它持有run方法而且能呼叫invoke方法呢？解開謎底的第二步就是研究Proxy0！
第二步：

按理說，生成的動態代理類是直接載入到記憶體中我們無法獲取的，直觀的方法可以通過反射還原這個類的內容，但實在複雜！但是好在JDK提供了代理類的生成函式，所以程式碼改成這樣：

public class ProxyTest {
    public static void main(String[] args){
//新增這一句
    System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    SubjectInvocation subjectInvocation = new SubjectInvocation(new RealSubject());
    Subject proxySubject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(),
                new Class[]{Subject.class},subjectInvocation);
    System.out.println(proxySubject.getClass().getName());
    proxySubject.run();
}

System.getProperties().put(“sun.misc.ProxyGenerator.saveGeneratedFiles”, “true”) 這句話執行後再進行動態代理生成就會在專案的根目錄下生成代理類的位元組碼檔案(實際路徑是包名+類名)然後再借用IDE的反編譯功能就能看到這個動態生成類的廬山真面目：

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;

    final class $Proxy0 extends Proxy implements Subject {
      private static Method m1;
      private static Method m3;
      private static Method m2;
      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 void run() throws  {
        try {
          super.h.invoke(this, m3, (Object[])null);
        } 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);
        }
      }

      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", Class.forName("java.lang.Object"));
          m3 = Class.forName("proxy.Subject").getMethod("run");
          m2 = Class.forName("java.lang.Object").getMethod("toString");
          m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
          throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
          throw new NoClassDefFoundError(var3.getMessage());
        }
      }
    }

我們很明顯的看到， Proxy0繼承了Proxy實現了Subject！這樣，因為繼承Proxy，所以Proxy0就持有了呼叫處理器物件，因為實現Subject，所以Proxy0就可以擁有run()方法。這樣我們繼續看程式碼就可以輕而易舉的找出run()方法時如何聯絡上呼叫處理器的invoke()方法的了！

首先看到，$Proxy0類聲明瞭m0~m3幾個Method型別的變數：

      private static Method m1;
      private static Method m3;
      private static Method m2;
      private static Method m0;

然後看最後的靜態程式碼塊(類載入的時候，靜態程式碼塊首先執行)：

static {
        try {
          m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
          m3 = Class.forName("Subject").getMethod("run");
          m2 = Class.forName("java.lang.Object").getMethod("toString");
          m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
          throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
          throw new NoClassDefFoundError(var3.getMessage());
        }
      }

可以看到，這些變數實際上是通過反射機制利用Class.forName().getMethod()動態載入的指向特定型別下的方法引用變數，這裡我們只看run()方法：

public final void run() throws  {
        try {
          super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
          throw var2;
        } catch (Throwable var3) {
          throw new UndeclaredThrowableException(var3);
        }
      }

“很巧合”的是，$Proxy0中“竟然”也有一個run()方法（實際上是因為繼承了Subject罷了），而且裡面傳入的方法引用便是m3，而執行run方法後，竟然呼叫的是h.invoke()！

到這裡基本可以說是真相大白了： ProxySubject是$Proxy0型別物件，而$Proxy0類因為繼承Proxy實現了Subject，所以持有了呼叫處理器h和run()方法，而且重寫了run方法：執行run()方法後實際執行的是invoke方法，而invoke方法因為傳入了由反射機制生成的方法引用，所以執行invoke方法後再執行method.invoke()，自然而然的執行了method也就是run方法！

讀者應該也注意到，$Proxy0除了包含run方法外還有hashcode、equals、toString方法，這是因為所有的類包括 Subject類都是繼承的Object類，$Proxy0自然也包含這些方法！ 這麼說來，JDK的動態代理機制的UML圖就變成了這樣：
這裡寫圖片描述

相關推薦

深入理解系列之JAVA動態代理機制

代理的作用，就是生成代理物件使得真實物件的某些方法執行被代理物件攔截，從而在真實方法執行前、執行後新增額外的“動作”！動態代理則是指不需要修改原來的物件方法，在程式執行的過程中動態的生成代理物件，從而動態的生成這些“額外的”動作，主要從兩個方面來深入理解動

深入理解系列之JAVA泛型機制

泛型是指在宣告（類，方法，屬性）的時候採用一個“標誌符”來代替，而只有在呼叫的時候才傳入真正的型別，我們最常見的泛型例項就是前面講述的集合類，集合類在宣告的時候都是通過泛型方式來宣告的，只有在呼叫（例項化）時我們才確定傳入的是Integer亦或是Strin

深入理解系列之JAVA多型機制(過載/重寫)

多型（Polymorphism）按字面的意思就是“多種狀態”。在面嚮物件語言中，介面的多種不同的實現方式即為多型（來自百度百科）。所以，按照這個意思其實多型的“主題”是物件，但是實際在我們運用中我們常把“過載”和“重寫”稱之為“多型”其實這是不嚴謹的！過載

深入理解系列之JAVA資料結構（4）——Hashtable

1、Hashtable和HashMap，從儲存結構和實現來講基本上都是相同的， Hashtable繼承自Dictionary類，而HashMap繼承自AbstractMap類，但二者都實現了Map介面。 2、它和HashMap的最大的不同是它是

深入理解系列之JAVA多執行緒（2）——synchronized同步原理

多執行緒中為了解決執行緒安全問題，一個重要的手段就是同步！所謂同步其實就是使得原本各個執行緒交叉執行（非同步），變成排隊執行（同步）。同步策略使得不同執行緒操作共享資料遵循“先來後到“，從而避免某個執行緒沒有處理完資料就被另一執行緒搶佔操作出現資料被覆蓋或

深入理解系列之JAVA資料結構（2）——LinkedList

1、LinkedList 是一個繼承於AbstractSequentialList的雙向連結串列。它也可以被當作堆疊、佇列或雙端佇列進行操作。 2、LinkedList相對於ArrayList來說，是可以快速新增，刪除元素，ArrayList新增刪除

深入理解 Java 動態代理機制

Java 有兩種代理方式，一種是靜態代理，另一種是動態代理。對於靜態代理，其實就是通過依賴注入，對物件進行封裝，不讓外部知道實現的細節。很多 API 就是通過這種形式來封裝的。 代理模式結構圖（圖片來自《大話設計模式》） 下面看下兩者在概念上的解釋： 靜態代理 靜態代理

［jvm解析系列］［十四］動態代理和裝飾模式，帶你看原始碼深入理解裝飾模式和動態代理的區別。

不知道大家知不知道設計模式中有一種叫做裝飾，舉一個簡單的例子。 一天一個年輕領導小王講話：咳咳，我們一定要xxx抓緊xxxx學習xxx的精神！好，今天的會議結束！ 然後有一個老領導李同志接過來說：那個我在補充兩點，個別同志xxx，一定要注意xxx。好散會。 然後另一天小王同

java 動態代理機制的理解和分析

引言 Java 動態代理機制的出現，使得 Java 開發人員不用手工編寫代理類，只要簡單地指定一組介面及委託類物件，便能動態地獲得代理類。代理類會負責將所有的方法呼叫分派到委託物件上反射執行，在分派執行的過程中，開發人員還可以按需調整委託類物件及其功能，這是一套非常靈活有彈

JAVA動態代理機制解析

定義 book lang 並不是 stat 控制 () highlight 什麽 1. 概述　　首先，我們來思考如下兩個問題：　　什麽是代理模式？為什麽要使用代理模式？ 　　簡單總結一下，所謂的代理模式就是在原有的服務上多加一個占位，通過這個占位去控制服務的訪問。通過代理模

深入理解系列之 float

子元素 out oat 理解 oom 20px 布局 空格 ble float的設計初衷： 僅僅是為了實現文字環繞效果 float的感性認知： 包裹性： 收縮：元素應用了float後，寬度收縮，緊緊地包裹住內容（即元素的寬度收縮到元素內的內容的寬度大小 堅挺：原來沒有高

Java動態代理機制詳解

 在學習spring的時候，我們知道Spring主要有兩大思想，一個是IoC，另一個就是AOP，對於IoC，依賴注入就不用多說了，而對於Spring的核心AOP來說，我們不但要知道怎麼通過AOP來滿足的我們的功能，我們更需要學習的是其底層是怎麼樣的一個原理，而AOP的原理就是Java的動態代理機制，所以本篇

深入理解Android之Java虛擬機器Dalvik

一、背景這個選題很大，但並不是一開始就有這麼高大上的追求。最初之時，只是源於對Xposed的好奇。Xposed幾乎是定製ROM的神器軟體技術架構或者說方法了。它到底是怎麼實現呢？我本意就是想搞明白Xposed的實現原理，但隨著程式碼研究的深入，我發現如果不瞭解虛擬機器的實現，

深入理解Android之Java Security第一部分

深入理解Android之Java Security（第一部分）從事Android工作4年以來，只有前1年不到的時間是用C++在開發東西（主要是開發DLNA元件，目前我已將它們全部開源，參考http://

Java動態代理機制小結

在java的動態代理機制中，有兩個重要的類或介面，一個是 InvocationHandler(Interface)、另一個則是 Proxy(Class)，這一個類和介面是實現我們動態代理所必須用到的。首先我們先來看看java的API幫助文件是怎麼樣對這兩個類進行描述的： I

深入理解Android之Java Security第二部分（Final）

深入理解Android之Java Security（第二部分，最後）程式碼路徑：Security.java：libcore/lunl/src/main/java/java/security/TrustedCertificateStore.java：libcore /crypt

Java動態代理機制詳解(JDK動態代理與CGLIB動態代理區別)

代理是一種常用的設計模式,其目的就是為其他物件提供一個代理以控制對某個物件的訪問。代理類負責為委託類預處理訊息,過濾訊息並轉發訊息,以及進行訊息被委託類執行後的後續處理。在講述動態代理前,我們先通過一個例子瞭解一下什麼是靜態代理,這裡以事務控制為例。 1.靜態

面試必問系列之JDK動態代理

掃描文末二維碼或者微信搜尋公眾號小李不禿，即可關注微信公眾號，獲取到更多 Java 相關內容。 1. 帶著問題去學習 面試中經常會問到關於 Spring 的代理方式有哪兩種？大家異口同聲的回答：JDK 動態代理和 CGLIB 動態代理。 這兩種代理有什麼區別呢？JDK 動態代理的類通過介面實現，CGL

深入理解Redis之簡單動態字串

[TOC] Redis沒有直接使用C語言傳統的字串表示(以空字元結尾的字元陣列，以下簡稱C字串)，而是自己構建了一種名為`簡單動態字串`(simple dynamic string,SDS)的抽象型別，並將SDS用作Redis的預設字串表示。Reids自己構建的sds要比預設的c字串效能更好，也更安全。

Java動態代理之通俗理解

java動態代理代理模式介紹 代理模式是一種常用的設計模式，其作用就是為目標對象提供額外的訪問方式，在不修改目標對象的前提下，擴展目標對象的額外功能，比如統計執行時間，打印日誌等。 代理模式分為兩種：靜態代理和動態代理。 需求：假如不想改動原有代碼情況下，並記錄用戶保存方法的執行時間。示例代碼如下： 接口 p