2. 程式人生 > >動態代理（二）—— CGLIB代理原理

動態代理（二）—— CGLIB代理原理

阿新 • • 發佈：2018-07-18
構建 ted err 包裝 appears 動態 調用棧 hook ces

前篇文章動態代理（一）——JDK中的動態代理中詳細介紹了JDK動態代理的Demo實現，api介紹，原理詳解。這篇文章繼續討論Java中的動態代理，並提及了Java中動態代理的幾種實現方式。這裏繼續介紹CGLIB代理方式。

CGLIB動態代理在AOP、RPC中都有所使用，是Java體系中至關重要的一塊內容。本篇文章的主要目標：

  • 掌握使用CGLIB生成代理類
  • 深入理解CGLIB的代理原理

從以上目標出發，本篇文章主要從以下幾個方面逐步深入探索CGLIB：

  • CGLIB的使用Demo
  • CGLIB重要API介紹
  • CGLIB代理原理
  • 總結

一.CGLIB的使用Demo

使用CGLIB的大致分為四步驟：

  1. 創建被代理對象
  2. 創建方法攔截器
  3. 創建代理對象
  4. 調用代理對象

1.創建被代理對象

public class EchoServiceImpl implements EchoService {

    public void echo(String message) {
        System.out.println(message);
    }

    public void print(String message) {
        System.out.println(message);
    }

    public int test() {
        return 1;
    }

    public final void finalTest() {
        System.out.println("I am final method.");
    }
}

2.創建方法攔截器

public class EchoServiceInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("before invoking!");
        Object object = methodProxy.invokeSuper(o, objects);
        System.out.println("after invoking!");
        return object;
    }
}

接口MethodInterceptor是CGLIB庫提供，用於應用開發者根據自己的業務邏輯進行擴展實現。

3.創建代理對象

//Enhancer是生成代理類的工廠
Enhancer enhancer = new Enhancer();
//設置代理的超類，即被代理對象
enhancer.setSuperclass(EchoServiceImpl.class);
//設置攔截方法
enhancer.setCallback(new EchoServiceInterceptor());
//生成代理對象
EchoService echoService = (EchoService) enhancer.create();

4.調用代理對象

echoService.echo("test");

執行結果：
before invoking!
test
after invoking!

二.CGLIB重要API介紹

CGLIB庫的體積很小，但是學習難度確非常高，畢竟涉及到bytecode。所以該篇文章後續關於原理介紹，只涉及代理原理方面，關於如何生成代理對象的方面，由於個人能力所及，不敢妄加說明。

下面是CGLIB的包結構，每個包都是負責一個模塊功能，定義非常明確，負責單一的功能職責:

  • net.sf.cglib.core
    低級別的字節碼操作的類，它們直接與ASM相關

  • net.sf.cglib.transform
    在運行或者構建時轉換類文件的一些類

  • net.sf.cglib.proxy
    創建代理和方法攔截器定義的類

  • net.sf.cglib.reflect
    實現快速反射的一些基礎類

  • net.sf.cglib.util
    用於集合排序的一些工具類

  • net.sf.cglib.beans
    與JavaBean相關的類

雖然cglib包含了如此多的功能模塊，但是對於使用者，我們並不需要關註如此多的細節，只需要掌握幾個重要的接口：

技術分享圖片

在看完上面的Demo，應該對Enhancer有一定了解。Enhancer字面義即增強，也正如其表述，Enhancer就是用來創建代理對象的接口。其中create方法可以生成代理對象，實際就是工廠模式。

在生成對象前，需要做關於代理方面的配置：

  • 配置被代理對象(目標)，即setSuperClass設置超類型，該superClass即Enhancer中持有的Class對象；
  • 配置統一攔截方法(中間人)，即setCallBack設置回調接口，對應上圖的CallBack。AOP的實現使用methodInterpretor型CallBack；
  • 可選性的配置攔截過濾器(核驗流程)，即setCallBackFilter，對應上圖的CallBackFiler；

Enhancer的create api提供了生成代理對象的。以上即在編寫cglib動態代理過程中使用的幾個重要api。雖然字節碼技術是非常晦澀深奧，但是cglib以簡單易用的api使字節碼增強技術變得非常容易上手。

通過以上的demo示例和幾個重要api的介紹應該都能掌握使用cglib庫生成代理類。下面依然通過反編譯的方式繼續深入cglib的動態代理的調用原理。

三.CGLIB代理原理

1.整體架構與調用過程概覽

在詳細查看被代理對象的原理之前，先了解下cglib的整體架構圖：

技術分享圖片

從圖中可以看出，cglib在字節碼層面的操作技術主要依賴ASM提供的能力。在上節中提到的net.sf.cglib.core包，正是與ASM相關。CGLIB上層直接面向應用層，將深奧晦澀的字節碼技術包裝成應用易用能理解的api，為aop，dynaminc proxy等技術提供了實現基礎。

在反編譯看代理對象的源代碼之前，先看下代理調用的過程圖：

技術分享圖片

從圖中可以看出：

  1. 客戶端調用代理對象的被代理方法
  2. 代理對象將調用委派給方法攔截器統一接口intercept
  3. 方法攔截器中執行前置操作，然後調用方法代理的統一接口invokeSuper
  4. 方法代理的invokeSuper初始化代理對象的和被代理對象的fastClass
  5. 初始化後，再調用代理對象的fastClass
  6. 代理對象的fastClass能夠fast的調用代理的代理對象
  7. 代理對象再調用被代理對象的被代理方法
  8. 調用棧彈出，到intercept中再執行後置操作，方法調用結束

通過以上的過程再來看下它們之間的UML:

技術分享圖片

在Enhancer中的配置的被代理對象、統一回調的最終都被聚合到生成的代理對象中。（工廠模式，零件組裝成產品）
代理對象聚合同一方法回調、繼承被代理對象，聚合方法代理的。

2.反編譯代理類字節碼

CGLIB提供生成代理類的class文件的配置項。在CGLIB中提供了DebuggingClassWriter類用於將字節碼的byte字節寫入class文件中。

public byte[] toByteArray() {
    
  return (byte[]) java.security.AccessController.doPrivileged(
    new java.security.PrivilegedAction() {
        public Object run() {
            
            // 獲取代理類的字節內容
            byte[] b = ((ClassWriter) DebuggingClassWriter.super.cv).toByteArray();
            if (debugLocation != null) {
                    // 轉換生成的class文件路徑分隔符
                String dirs = className.replace(‘.‘, File.separatorChar);
                try {
                     // 創建class文件
                    new File(debugLocation + File.separatorChar + dirs).getParentFile().mkdirs();
                    
                    File file = new File(new File(debugLocation), dirs + ".class");
                    OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
                    try {
                         // 將字節內容寫入class文件
                        out.write(b);
                    } finally {
                        out.close();
                    }
                    
                    if (traceCtor != null) {
                        file = new File(new File(debugLocation), dirs + ".asm");
                        out = new BufferedOutputStream(new FileOutputStream(file));
                        try {
                            ClassReader cr = new ClassReader(b);
                            PrintWriter pw = new PrintWriter(new OutputStreamWriter(out));
                            ClassVisitor tcv = (ClassVisitor)traceCtor.newInstance(new Object[]{null, pw});
                            cr.accept(tcv, 0);
                            pw.flush();
                        } finally {
                            out.close();
                        }
                    }
                } catch (Exception e) {
                    throw new CodeGenerationException(e);
                }
            }
            return b;
         }  
        });
        
    }

從以上可以看出只要配置文件的生成路徑變量debugLocation即可，再來看下該變量初始化賦值情況

static {
      // 從System中取出屬性DEBUG_LOCATION_PROPERTY賦值給文件class文件生成路徑變量
    debugLocation = System.getProperty(DEBUG_LOCATION_PROPERTY);
    if (debugLocation != null) {
        System.err.println("CGLIB debugging enabled, writing to ‘" + debugLocation + "‘");
        try {
          Class clazz = Class.forName("org.objectweb.asm.util.TraceClassVisitor");
          traceCtor = clazz.getConstructor(new Class[]{ClassVisitor.class, PrintWriter.class});
        } catch (Throwable ignore) {
        }
    }
}

可以看出只要應用啟動時

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,
    "/Users/lixinyou/Documents/code-space/java/java-base/java-proxy/target/proxy/impl");

設置DebuggingClassWriter.DEBUG_LOCATION_PROPERTY屬性，在運行時CGLIB便會生成代理類的class。

這種方式與JDK的動態代理中的class文件生成方式一致。這種用法，在日常應用開發中也可借鑒，利用應用啟動參數的不同，可以在運行時改變行為，代碼具有強擴展性。

3.fastClass機制

在看代理機制源碼之前，做好一切準備。再來了解下CGLIB中關於實現快速調用的fastClass機制。
在JDK的動態代理中使用反射調用目標對象，在CGLIB中為了更好的提升性能，采用fastClass機制。

FastClass機制：將類的方法信息解析出來，然後為其建立索引。調用的時候，只要傳索引，就能找到相應的方法進行調用。

  1. 為所有的方法建立索引
  2. 調用前先根據方法信息尋找到索引
  3. 調用時根據索匹配相應的方法進行直接調用

CGLIB在字節碼層面將方法和索引的對應關系建立，避免了反射調用：

public int getIndex(Signature var1) {
    String var10000 = var1.toString();
    switch(var10000.hashCode()) {
        case -2055565910:
            if (var10000.equals("CGLIB$SET_THREAD_CALLBACKS([Lnet/sf/cglib/proxy/Callback;)V")) {
                return 11;
            }
            break;
        case -1980342926:
            if (var10000.equals("print(Ljava/lang/String;)V")) {
                return 6;
            }
            break;
        case -1860420502:
            if (var10000.equals("CGLIB$clone$7()Ljava/lang/Object;")) {
            return 24;
            }
            break;
        case -1725733088:
            if (var10000.equals("getClass()Ljava/lang/Class;")) {
                return 29;
            }
            break;
}
return -1;

}

上述獲取方法的索引，下述代碼再根據索引進行調用：

public Object invoke(int index, Object var2, Object[] var3) throws InvocationTargetException {
    e77dd5ce var10000 = (e77dd5ce)var2;
    try {
        switch(index) {
        case 0:
            return new Boolean(var10000.equals(var3[0]));
        case 1:
            return var10000.toString();
   } catch (Throwable var4) {
        throw new InvocationTargetException(var4);
    }
    throw new IllegalArgumentException("Cannot find matching method/constructor");
}

4.運行時的代理類

CGLIB運行時，實際會生成三個class：

  • 代理類
  • 代理類對應的fastClass
  • 被代理類的fastClass

如上述Demo中生成的代理類和相應的代理類：

  1. EchoServiceImpl$$EnhancerByCGLIB$$e77dd5ce$$FastClassByCGLIB$$1b37f797.class
  2. EchoServiceImpl$$EnhancerByCGLIB$$e77dd5ce.class
  3. EchoServiceImpl$$FastClassByCGLIB$$44f86581.class

下面就看下生成的類的代碼片段，理解下CGLIB的運行時代理原理。

首先看下生成的代理類

public class EchoServiceImpl$$EnhancerByCGLIB$$e77dd5ce extends EchoServiceImpl implements Factory {

代理類是繼承自被代理類，這裏與JDK的不同是，JDK是實現了接口。

下面的即是對echo方法的代理方法：

public final void echo(String var1) {
    // 獲取方法攔截器
    MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
    if (this.CGLIB$CALLBACK_0 == null) {
        CGLIB$BIND_CALLBACKS(this);
        var10000 = this.CGLIB$CALLBACK_0;
    }

    if (var10000 != null) { // 如果不為空，則調用其統一攔截
        var10000.intercept(this, CGLIB$echo$2$Method, new Object[]{var1}, CGLIB$echo$2$Proxy);
    } else { // 如果為空，則直接調用父類即被代理類的方法
        super.echo(var1);
    }
}

最為讓人關註的是intercept方法調用時的參數MethodProxy:CGLIB$echo$2$Proxy

static {
    CGLIB$STATICHOOK1();
}

static void CGLIB$STATICHOOK1() {
    CGLIB$echo$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)V", "echo", "CGLIB$echo$2");
}

在代理類被加載時，執行靜態方法CGLIB$STATICHOOK1()，創建了echo方法對應的方法代理。

public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
    MethodProxy proxy = new MethodProxy();
    proxy.sig1 = new Signature(name1, desc);
    proxy.sig2 = new Signature(name2, desc);
    proxy.createInfo = new CreateInfo(c1, c2);
    return proxy;
}

這裏使用了工廠模式，在創建MethodProxy時，為期成員CreateInfo賦值。c1代表被代理類，c2代表代理類。desc代理方法和被代理方法的參數信息，name1是被代理方法名，name2是代理方法名。

下面再看來下intercepte方法中調用的methodProxy的invokeSuper方法：

public Object invokeSuper(Object obj, Object[] args) throws Throwable {
    try {
        // 先進行初始化
        init();
        // 獲取fastClassInfo對象
        FastClassInfo fci = fastClassInfo;
        // 獲取代理類對應的fastClass對象並按索引調用
        return fci.f2.invoke(fci.i2, obj, args);
    } catch (InvocationTargetException e) {
        throw e.getTargetException();
    }
}

先看下初始化中所執行的邏輯：

private void init()
{
    /* 
     * Using a volatile invariant allows us to initialize the FastClass and
     * method index pairs atomically.
     * 
     * Double-checked locking is safe with volatile in Java 5.  Before 1.5 this 
     * code could allow fastClassInfo to be instantiated more than once, which
     * appears to be benign.
     */
    if (fastClassInfo == null)
    {
        synchronized (initLock)
        {
            if (fastClassInfo == null)
            {
                CreateInfo ci = createInfo;

                FastClassInfo fci = new FastClassInfo();
                // 獲取被代理類
                fci.f1 = helper(ci, ci.c1);
                // 獲取代理類
                fci.f2 = helper(ci, ci.c2);
                // 獲取被代理類的被代理方法的索引
                fci.i1 = fci.f1.getIndex(sig1);
                // 獲取代理類的代理方法的索引
                fci.i2 = fci.f2.getIndex(sig2);
                fastClassInfo = fci;
                createInfo = null;
            }
        }
    }
}

這裏使用了單例模式，fastClassInfo對象是單例。所以初始化方法只會在第一次調用代理方法的時候，才響應的進行對其初始化。

初始化後，就將代理類和代理方法的索引獲取到了，然後再按照索引直接對代理方法進行調用：

public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
    e77dd5ce var10000 = (e77dd5ce)var2;
    int var10001 = var1;

    try {
        switch(var10001) {
        case 19:
            var10000.CGLIB$echo$2((String)var3[0]);
            return null;
        }
    } catch (Throwable var4) {
        throw new InvocationTargetException(var4);
    }
    throw new IllegalArgumentException("Cannot find matching method/constructor");
}

上述考慮到篇幅和簡潔的原因，這裏只摘取了case:19的代碼片段。

通過索引直接調用代理類代理方法：CGLIB$echo$2：

final void CGLIB$echo$2(String var1) {
    super.echo(var1);
}

在該方法中再調用被代理類（繼承了被代理類）的被代理方法。

至此，CGLIB的代理調用原理就是以上的內容。

四.總結

CGLIB是一種字節碼增強庫，利用其提供的字節碼技術可以實現動態代理。其底層依賴ASM字節碼技術。

CGLIB的動態代理與JDK動態代理的不同點：

  • JDK動態代理必須需要接口，JDK代理是基於接口進行動態代理。CGLIB中既支持對接口的代理，也支持對對象的代理。
  • CGLIB動態代理使用fastClass機制實現快速調用被代理類，JDK中使用了反射方式調用被代理。所以CGLIB的動態代理的方式性能上更有優勢。
  • CGLIB額外對來源於Object中的finalize和clone方法也做了攔截代理，JDK只為了equals、hashCode、toString進行代理

註：JDK中生成的代理類已經靜態解析了方法對象作為代理類的靜態變量，類似做緩存，從而部分解決反射的性能問題。

CGLIB的動態代理與JDK動態代理的相同點：

  • 都具有統一接口，JDK動態代理中中間統一接口是InvocationHandler，CGLIB中是MethodInteceptor。
  • 生成的代理類和其中的方法都是final
參考

neoremind/dynamic-proxy
Are there alternatives to cglib
Spring AOP 實現原理與 CGLIB 應用
深入淺出CGlib-打造無入侵的類代理
CGLib: The Missing Manual
Create Proxies Dynamically Using CGLIB Library

動態代理（二）—— CGLIB代理原理

相關推薦

動態代理（二）—— CGLIB代理原理

構建 ted err 包裝 appears 動態 調用棧 hook ces 前篇文章動態代理（一）——JDK中的動態代理中詳細介紹了JDK動態代理的Demo實現，api介紹，原理詳解。這篇文章繼續討論Java中的動態代理，並提及了Java中動態代理的幾種實現方式。這裏繼續介

Spring事務Transactional和動態代理（二）-cglib動態代理

系列文章索引： 1. [Spring事務Transactional和動態代理（一）-JDK代理實現](http://www.itrensheng.com/archives/spring_transaction_jdk_proxy) 2. [Spring事務Transactional和動態代理（二）-cglib

Spring學習總結（二）——靜態代理、JDK與CGLIB動態代理、AOP+IoC

AOP（Aspect Oriented Programming）意為：面向切面程式設計，通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數語言程式設計的一種衍生範型。利用AOP可以對業務邏輯的各個部分進行隔

動態代理（二）

object throws classname 什麽 ace mep sets finall 源碼分析 這是動態原理的第二篇，這裏要講述的是Cglib的東東。接下來，進正題。 參考文章：http://www.cnblogs.com/cruze/p/3843996.html

Java反射機制與動態代理（二）

導讀： 1. 代理模式 2. 靜態代理 3. 動態代理 4. 小結 一、代理模式 代理模式所涉及的角色有： 抽象主題角色：聲明瞭真實主題和代理主題的共同介面，這樣一來在任何可以使用真實主題的地方都可以使用代理主題。 真實主

Jmater （十七） 命令列（非GUI）模式詳解（二） 執行代理設定

閒話少述，接 上文繼續。。。 　　5、設定代理 　　　　jmeter -n -t Jmeter分散式測試示例.jmx -H 20.9.215.90 -P 9999 -1 report\01-result.csv -j report\01-log.log 　　　　注意：-H 20.9.215.9

代理（一）靜態代理，動態代理

昨天面試碰到了面試官問spring的時候，問完ioc，然後下個問題我以為是aop，後來才聽清是動態代理，感覺回答的不是太好，也是好久不接觸 1.靜態代理 代理模式也就委託模式。 三個角色： 1. Subject抽象主題角色：介面 2. RealSubject具體主題角色：介面的實現類，業務邏輯的具體

python 爬蟲（二）使用代理模擬瀏覽器

import urllib.request import random url = "http://www.baidu.com" #建立一個代理列表，每次隨機使用一個，防止被封IP agnetsList = [ "Mozilla/5.0 (iPad; U; CPU O

Java設計模式詳談（二）：代理

經過上一篇對於單例模式的心得分享，今天來聊一聊第二種設計模式 ，關於代理模式的個人理解。代理你可以把它想象成中間人、中介等等，不需要你親自去處理你想做的事，把你想要的告訴他們，讓他們去幫你實現，完成後再把最終的結果通知你。 總的來說代理模式分為兩種：一種是靜態代理，一種是動態代理。

自己實現Spring AOP（二）JDK代理實現AOP

前言 上一篇文章自己實現Spring AOP（一）環境搭建及知識準備，我搭建好了專案也寫了一個例子，接下來我就要實現這個例子中的AOP功能。 在Spring中如果目標物件實現了介面，預設情況下會採用JDK的動態代理實現AOP，如果目標物件沒有實現介面，必須採

設計模式（二）：代理模式（委託模式）

代理模式 組成： 抽象角色：通過介面或者抽象類宣告真實角色實現的業務方法 代理角色：實現抽象角色，是真實角色的代理，通過真實角色的業務邏輯方法來實現抽象方法，並可以附加自己的操作。 真實角色：實現抽象角色，定義真實角色所需要實現的業務邏輯，供代理角色呼叫 代理的基本作用

Spring事務Transactional和動態代理（一）-JDK代理實現

系列文章索引： 1. [Spring事務Transactional和動態代理（一）-JDK代理實現](http://www.itrensheng.com/archives/spring_transaction_jdk_proxy) 2. [Spring事務Transactional和動態代理（二）-cglib

Java靜態分派與動態分派（二）

xiang oid main isp 準備 center 使用 name 編譯過程 方法調用並不等於方法執行，方法調用階段唯一的任務就是確定被調用方法的版本（即調用哪一個方法），暫時還不涉及方法內部的具體運行過程。 在程序運行時，進行方法調用是最普遍、最頻繁的操作，但是Cl

圖解ARP協議（二）ARP攻擊原理與實踐

tcp/ip arp協議 網絡安全 局域網安全 一、ARP攻擊概述在上篇文章裏，我給大家普及了ARP協議的基本原理，包括ARP請求應答、數據包結構以及協議分層標準，今天我們繼續討論大家最感興趣的話題：ARP攻擊原理是什麽？通過ARP攻擊可以做什麽，賬號是否可以被竊取？有哪些常見的ARP滲透（攻

動態規劃法（二）找零錢問題

解答 time() 自己的 世界 結果 斐波那契數 自己 imp easy ??本次博客嘗試以storyline的方式來寫作，如有不足之處，還請多多包涵~~ 問題的誕生 ??我們故事的主人公叫做丁丁，他是一個十幾歲的小男孩，機智聰穎，是某某雜貨店的小學徒。在他生活的國度裏，

squid代理（一）--傳統代理

gnu 則表達式 dev 文件中 重啟 https協議 max 記錄 透明 squid代理（一）--傳統代理 Web代理的工作機制緩存網頁對象，減少重復請求 代理的基本類型傳統代理：適用於Internet，客戶端上網需明確指定服務端IP以及端代理口透明代理：適用於共享上網網

Vue 進階系列（二）之外掛原理及實現

Vue進階系列彙總如下，歡迎閱讀，歡迎加群討論（文末）。 Vue 進階系列（一）之響應式原理及實現 Vue 進階系列（二）之外掛原理及實現 使用方法 外掛的詳細使用方法詳情看Vue官網 Vue官網之外掛Plugins 概括出來就是 1、通過Vue.use(MyPlugin)使用，

ELF檔案載入與動態連結（二）

GOT應該儲存的是puts函式的絕對虛地址，這裡為什麼儲存的卻是[email protected]的第二條指令呢? 原來“直譯器”將動態庫載入記憶體後，並沒有直接將函式地址更新到GOT表中，而是在函式第一次被呼叫時，才會進行函式地址的重定位，這樣做的好處是可以加快程式載入速度，尤其對大型程式來說。有

Git+Gitlab+Ansible劇本實現一鍵部署動態網站（二）--技術流ken

  專案前言   之前已經寫了一篇關於git和ansible的部落格《Git+Gitlab+Ansible劇本實現一鍵部署Nginx--技術流ken》。關於git,gitliab,ansible在我以往的部落格中都已經詳細介紹，這裡就不再贅述。 上一篇部署的nginx是一個靜態的網

Jenkins+Git+Gitlab+Ansible實現持續整合自動化部署動態網站（二）--技術流ken

  專案前言   在上一篇部落格《Jenkins+Git+Gitlab+Ansible實現持續化整合一鍵部署靜態網站（一）--技術流ken》中已經詳細講解了如何使用這四個工具來持續整合自動化部署一個靜態的網站。 如果大家可以熟練掌握以上內容，勢必會在工作中減輕不小的工作量。 本篇