2. 程式人生 > 其它 >Cglib 動態代理

Cglib 動態代理

阿新 • • 發佈：2022-12-09 
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class MyCallback implements MethodInterceptor {
        @Override
        public Object intercept(Object o, Method method, Object[] params, MethodProxy methodProxy) throws
 
 Throwable {
                System.out.println("增強方法開始：" + method.getName());
                Object result = methodProxy.invokeSuper(o, params);
                System.out.println("  方法返回結果: " + result);
                System.out.println("增強方法結束：" + method.getName());
                return result;
        }
}
 
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;

public class ProxyFactory {
    public static Object createProxy(Class<?> clazz, Callback callback) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(callback);
        
 
return enhancer.create();
    }
}
import com.asiainfo.crm.xxx.service.Shape;
import com.asiainfo.crm.xxx.service.impl.Cycle;

public class Main {
    public static void main(String[] args) {
        System.setProperty("cglib.debugLocation", "D:\\develop\\idea-workspace\\gitee\\springbits-quickstart\\xxx-svc\\debug"); // 列印生成的代理類
        MyCallback myCallback = new MyCallback();
        Shape student = (Shape) ProxyFactory.createProxy(Cycle.class, myCallback);
        student.getName();
    }
}
增強方法開始：getName
  方法返回結果: 圓形
增強方法結束：getName

Process finished with exit code 0

什麼是 CGLIB？

CGLIB是一個功能強大，高效能的程式碼生成包。它為沒有實現介面的類提供代理，為 JDK 的動態代理提供了很好的補充。
通常可以使用 Java 的動態代理建立代理，但當要代理的類沒有實現介面或者為了更好的效能，CGLIB 是一個好的選擇。

CGLIB 的原理

CGLIB 原理：動態生成一個要代理類的子類，子類重寫要代理的類的所有不是 final 的方法。在子類中採用方法攔截的技術攔截所有父類方法的呼叫，織入橫切邏輯。
CGLIB 底層：採用 ASM 位元組碼生成框架，使用位元組碼技術生成代理類，比使用 Java 反射效率要高。

  

import java.lang.reflect.Method;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Factory;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class Cycle$$EnhancerByCGLIB$$a37d62f3 extends Cycle implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$getName$0$Method;
    private static final MethodProxy CGLIB$getName$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.asiainfo.crm.xxx.service.impl.Cycle$$EnhancerByCGLIB$$a37d62f3");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$1$Method = var10000[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
        CGLIB$getName$0$Method = ReflectUtils.findMethods(new String[]{"getName", "()Ljava/lang/String;"}, (var1 = Class.forName("com.asiainfo.crm.xxx.service.impl.Cycle")).getDeclaredMethods())[0];
        CGLIB$getName$0$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "getName", "CGLIB$getName$0");
    }

    final String CGLIB$getName$0() {
        return super.getName();
    }

    public final String getName() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$getName$0$Method, CGLIB$emptyArgs, CGLIB$getName$0$Proxy) : super.getName();
    }

    final boolean CGLIB$equals$1(Object var1) {
        return super.equals(var1);
    }

    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }

    final String CGLIB$toString$2() {
        return super.toString();
    }

    public final String toString() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString();
    }

    final int CGLIB$hashCode$3() {
        return super.hashCode();
    }

    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$4() throws CloneNotSupportedException {
        return super.clone();
    }

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone();
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$4$Proxy;
            }
            break;
        case 1218144844:
            if (var10000.equals("getName()Ljava/lang/String;")) {
                return CGLIB$getName$0$Proxy;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return CGLIB$equals$1$Proxy;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return CGLIB$toString$2$Proxy;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$3$Proxy;
            }
        }

        return null;
    }

    public Cycle$$EnhancerByCGLIB$$a37d62f3() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        Cycle$$EnhancerByCGLIB$$a37d62f3 var1 = (Cycle$$EnhancerByCGLIB$$a37d62f3)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (var10000 == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        Cycle$$EnhancerByCGLIB$$a37d62f3 var10000 = new Cycle$$EnhancerByCGLIB$$a37d62f3();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        Cycle$$EnhancerByCGLIB$$a37d62f3 var10000 = new Cycle$$EnhancerByCGLIB$$a37d62f3();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        Cycle$$EnhancerByCGLIB$$a37d62f3 var10000 = new Cycle$$EnhancerByCGLIB$$a37d62f3;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
            return var10000;
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        MethodInterceptor var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        default:
            var10000 = null;
        }

        return var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
        default:
        }
    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }

    static {
        CGLIB$STATICHOOK1();
    }
}

說明：

  • 生成的動態代理類繼承了父類 Cycle，並且實現了介面 Factory
  • 動態代理類持有 MethodInterceptor
  • 動態代理類會重寫父類 Cycle 的非 final、private 方法；也會構建自己的方法（cglib 方法），構建方式：CGLIB”+“$父類方法名$
  • cglib 方法的方法體：super.方法名，直接呼叫父類；重寫方法：它會呼叫攔截器中的 intercept() 方法
  • methodProxy.invokeSuper() 方法會呼叫動態代理類中的 cglib 方法；methodProxy.invoke() 方法會呼叫動態代理類中的重寫方法

JDK 動態代理和 CGLIB 動態代理比較

  • JDK 動態代理基於介面，CGLIB 動態代理基於類。因為 JDK 動態代理生成的代理類需要繼承 java.lang.reflect.Proxy，所以，只能基於介面；CGLIB 動態代理是根據類建立此類的子類，所以，此類不能被 final 修飾
  • JDK 和 CGLIB 動態代理都是在執行期生成位元組碼。而 JDK 是直接寫 Class 位元組碼；而 CGLIB 使用 ASM 框架寫 Class 位元組碼（不鼓勵直接使用ASM，因為它要求你必須對 JVM 內部結構包括 class 檔案的格式和指令集都很熟悉）
    • JDK 通過反射呼叫方法，CGLIB 通過 FastClass 機制直接呼叫方法。所以，CGLIB 執行的效率較高
  • JDK 動態代理是利用反射機制生成一個實現代理介面的類（這個類看不見摸不著，在 jvm 記憶體中有這個類），在呼叫具體方法前呼叫 InvokeHandler來處理。核心是實現 InvocationHandler介面，使用 invoke()方法進行面向切面的處理，呼叫相應的通知；CGLIB 動態代理是利用 asm 開源包，對代理物件類的 class 檔案載入進來，通過修改其位元組碼生成子類來處理。核心是實現 MethodInterceptor 介面，使用 intercept() 方法進行面向切面的處理，呼叫相應的通知。

優缺點


劣勢：

  • JDK：JDK的動態代理機制只能代理實現了介面的類，而不能實現介面的類就不能實現JDK的動態代理
  • CGLIB：CGLIB 的原理是對指定的目標類生成一個子類，並覆蓋其中方法實現增強，但因為採用的是繼承，所以不能對 final 修飾的類進行代理


優勢：

  • JDK：最小化依賴關係，減少依賴意味著簡化開發和維護，JDK本身的支援，可能比 cglib 更加可靠
  • JDK：平滑進行JDK版本升級，而位元組碼類庫通常需要進行更新以保證在新版Java 上能夠使用。程式碼實現簡單
  • CGLIB：從某種角度看，限定呼叫者實現介面是有些侵入性的實踐，類似cglib動態代理就沒有這種限制。只操作我們關心的類，而不必為其他相關類增加工作量。另外高效能。

相關推薦

Java使用JDK與Cglib動態代理技術統一管理日誌記錄

Java中動態代理主要有JDK和CGLIB兩種方式。 區別主要是jdk是代理介面，而cglib是代理類。

jdk動態代理與cglib動態代理

動態代理 動態代理23種設計模式之一 動態代理的基於反射的 代理模式： 作用：

jdk 動態代理與 cglib 動態代理原理

1. JDK動態代理 jdk 動態代理是通過實現被代理的介面來實現的，通過 jdk 動態代理生成的類會繼承 java.lang.reflect.Proxy，同時實現被代理的介面

【趣味設計模式系列】之【代理模式3--Cglib動態代理原始碼解析】

1. 圖解 上圖主要描述了Cglib動態代理的主要執行過程，下面做詳細分析，以下原始碼使用的Cglib版本為3.2.12。

JDK動態代理和CGLIB動態代理

JDK動態代理實現 被代理類（需實現介面） 1 public class UserServiceImp implements UserService{

代理模式詳解：靜態代理+JDK/CGLIB 動態代理實戰

1. 代理模式 代理模式是一種比較好的理解的設計模式。簡單來說就是我們使用代理物件來代替對真實物件(real object)的訪問，這樣就可以在不修改原目標物件的前提下，提供額外的功能操作，擴充套件目標物件的功能。

cglib動態代理

　　jdk的動態代理需要目標類必須實現一個介面； 　　cglib動態代理不需要實現介面就可以進行代理

JDK動態代理和CGLib動態代理的對比

JDK動態代理：利用反射機制生成一個實現代理介面的匿名類，在呼叫具體方法前呼叫InvokeHandler來處理。CGLib動態代理：利用ASM（開源的Java位元組碼編輯庫，操作位元組碼）開源包，將代理物件類的class檔案載入進來，

代理模式 - 實現有介面的CGLIB動態代理

技術標籤：Struts2+Spring+Hibernatessh有介面CGLIB動態代理 主業務介面： /** * 主業務介面：本介面中的方法將會被代理增強

代理模式 - 實現無介面的CGLIB動態代理

技術標籤：Struts2+Spring+Hibernatessh無介面CGLIB動態代理 未實現任何介面的目標類：

cglib動態代理原理分析

cglib動態代理原理分析 從一下四個方面深入理解cglib原理。 1、程式碼示例 2、代理類分析

Cglib動態代理，攔截器，過濾器

單個攔截器(setCallback)、多個攔截器(setCallbacks)、過濾器(setCallbackFilter)、簡單例子

動態代理模式的第二種方式：cglib動態代理

技術標籤：代理模式proxy動態代理模式proxy動態代理cglib動態代理代理模式 cglib是功能強大，效能高的開源專案，它可以在執行期擴充套件Java類與實現Java介面。cglib的底層需要依賴asm，asm是一個位元組碼處理的

Spring -- 06 -- JDK動態代理和CGLIB動態代理的區別

技術標籤：SpringSpringJDK動態代理CGLIB動態代理 一、相關概念 1、JDK 動態代理原理

cglib動態代理BeanCopier物件拷貝異常

技術標籤：springbug cglib動態代理BeanCopier物件拷貝異常 at java.lang.ClassLoader.defineClass1(Native Method)

CGLib動態代理分析

1. CGLib動態代理分析 JDK實現動態代理需要實現類通過介面定義業務方法，對於沒有介面的類，如何實現動態代理呢，這就需要CGLib了。CGLib採用了非常底層的位元組碼技術，其原理是通過位元組碼技術為一個類建立子類，

老生常談系列之Aop--CGLIB動態代理的底層實現原理

老生常談系列之Aop--CGLIB動態代理的底層實現原理 前言 上一篇老生常談系列之Aop--JDK動態代理的底層實現原理簡單講解了JDK動態代理的實現，動態代理常用實現裡面的雙子星還有另一位--CGLIB，那麼這一篇就會介紹CGL

在Spring中測試CGLIB動態代理遇到ClassNotFoundException: org.objectweb.asm.Type問題

在Spring專案中進行簡單的cglib動態代理的學習測試，主要程式碼如下： 一個目標類HaveDinnerServicepublic class HaveDinnerService {

Cglib 動態代理

import org.springframework.cglib.proxy.MethodInterceptor; import org.springframework.cglib.proxy.MethodProxy;

Java 靜態代理、動態代理以及cglib代理

代理模式介紹 代理模式是一種設計模式，顧名思義是對某個事物的代理，外界所有對該事物的訪問或操作，都會經過該代理。舉個例子，如果你有法律方面的糾紛，那麼你必然要找律師，此時對於律師而言你就是他的委託人，而