CGLIB生成的代理类详解

最新推荐文章于 2024-04-17 16:08:00 发布
最新推荐文章于 2024-04-17 16:08:00 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： spring 文章标签： spring
原文链接：https://blog.csdn.net/P19777/article/details/103998918
版权

https://blog.csdn.net/P19777/article/details/103998918

此前一直有一个疑惑，那就是为什么[CGLIB](https://so.csdn.net/so/search?q=CGLIB&spm=1001.2101.3001.7020)生成代理类的时候会出现三个class文件，按道理说应该只有一个，多出来的两个类怎么回事？
其实多出来的这两个class类就是为CGLIB中重要的fastClass机制而生成的。

## 实验

```java
public class GoodsService {

    @Test
    public void placeOrder() {
        System.out.println("place order");
        MsgUtil.addMsg("place order");
    }

    public void place() {
        throw new RuntimeException();
    }

    @Override
    public String toString() {
        return "GoodsService{}";
    }
}

@Test
public void testEnhance() {
    // 获取CGLIB生成的字节码
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "C:\\Users\\12130\\Desktop\\新建文件夹");
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(GoodsService.class);
    enhancer.setCallback(new TransactionInterceptor());
    GoodsService goodsService = (GoodsService) enhancer.create();
    goodsService.placeOrder();
}

static class TransactionInterceptor implements MethodInterceptor {
    /**
     * 参数1：代理类对象实例
     * 参数2：被代理的原始方法
     * 参数3：方法参数
     * 参数4：fastClass机制相关
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("start interceptor");
        // 为什么要执行的是invokeSuper，而不是直接invoke？
        Object obj = methodProxy.invokeSuper(o, objects);
        System.out.println("end interceptor");
        return obj;
    }
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445
```

## FastClass机制

Jdk动态代理的拦截对象是通过反射的机制来调用被拦截实例方法的，反射的效率比较低，所以cglib采用了FastClass的机制来实现对被拦截方法的调用。FastClass机制就是对一个类的方法建立索引，调用方法时根据方法的签名来计算索引，通过索引来直接调用相应的方法。
这也就是为什么CGLIB生成的动态代理会包含3个class文件的原因，其中一个是生成的代理类，另外两个类都是FastClass机制需要的。另外两个类都继承了FastClass这个类。其中一个class为生成的代理类中的每个方法建立了索引，另外一个则为我们被代理类的所有方法包含其父类的方法建立了索引。
下面这个就是为被代理类中的方法建立的索引。

```java
public class GoodsService$$FastClassByCGLIB$$58067f53 extends FastClass {
    public GoodsService$$FastClassByCGLIB$$58067f53(Class var1) {
        super(var1);
    }

    public int getIndex(Signature var1) {
        String var10000 = var1.toString();
        switch(var10000.hashCode()) {
        case 1203662734:
            if (var10000.equals("placeOrder()V")) {
                return 1;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return 3;
            }
            break;
        case 1858883854:
            if (var10000.equals("place()V")) {
                return 2;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return 0;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return 4;
            }
        }

        return -1;
    }
    public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
        GoodsService var10000 = (GoodsService)var2;
        int var10001 = var1;

        try {
            switch(var10001) {
            case 0:
                return var10000.toString();
            case 1:
                var10000.placeOrder();
                return null;
            case 2:
                var10000.place();
                return null;
            case 3:
                return new Boolean(var10000.equals(var3[0]));
            case 4:
                return new Integer(var10000.hashCode());
            }
        } catch (Throwable var4) {
            throw new InvocationTargetException(var4);
        }

        throw new IllegalArgumentException("Cannot find matching method/constructor");
    }
}
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
```

可以看出，利用上面的invoke方法，只要我们传入对应方法的下标和实例对象，就可以非常快的调用到对应的方法。

## FastClass类是在哪生成的？是如何生效的？

我们先看看CGLIB为我们生成的代理类

## 代理类分析

在示例代码中我们通过设置DebuggingClassWriter.DEBUG_LOCATION_PROPERTY的属性值来获取cglib生成的代理类
下面是生成代理类的字节码

```java
public class GoodsService$$EnhancerByCGLIB$$b08e58d5 extends GoodsService implements Factory {
    // 标识拦截器是否已经绑定
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    // 下面的两个变量用来保存回调类，也就是我们设置所有的拦截器，CGLIB会将回调先设置到这两个变量上，然后再进行绑定
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    // 这就是我们的拦截器，因为只添加了一个CallBack，所以这里只有一个
    // CGLIB可以添加多个CallBack
    private MethodInterceptor CGLIB$CALLBACK_0;
    
    private static Object CGLIB$CALLBACK_FILTER;
    // 下面的所有Method都是被代理类的原始的Method
    private static final Method CGLIB$toString$0$Method;
    // MethodProxy与FastClass机制有关，下面会讲
    private static final MethodProxy CGLIB$toString$0$Proxy;
    // 空参数，一个默认值，当我们的方法没有参数的时候会传递给拦截器
    // 不传递空值，这是一种设置思想
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$placeOrder$1$Method;
    private static final MethodProxy CGLIB$placeOrder$1$Proxy;
    private static final Method CGLIB$place$2$Method;
    private static final MethodProxy CGLIB$place$2$Proxy;
    private static final Method CGLIB$equals$3$Method;
    private static final MethodProxy CGLIB$equals$3$Proxy;
    private static final Method CGLIB$hashCode$4$Method;
    private static final MethodProxy CGLIB$hashCode$4$Proxy;
    private static final Method CGLIB$clone$5$Method;
    private static final MethodProxy CGLIB$clone$5$Proxy;
    
    // 该方法会在静态代码块中被调用，对上面的变量进行初始化
    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.cp.v5.service.GoodsService$$EnhancerByCGLIB$$b08e58d5");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$3$Method = var10000[0];
        // 创建MethodProxy，每一个方法都会创建一个对应的MethodProxy
        // 当前代理会会为其所有父类的方法都创建对应的MethodProxy,
        CGLIB$equals$3$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$3");
        CGLIB$hashCode$4$Method = var10000[1];
        CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
        CGLIB$clone$5$Method = var10000[2];
        CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
        // 获取GoodsService这个父类的所有方法
        var10000 = ReflectUtils.findMethods(new String[]{"toString", "()Ljava/lang/String;", "placeOrder", "()V", "place", "()V"}, (var1 = Class.forName("com.cp.v5.service.GoodsService")).getDeclaredMethods());
        CGLIB$toString$0$Method = var10000[0];
        CGLIB$toString$0$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$0");
        CGLIB$placeOrder$1$Method = var10000[1];
        CGLIB$placeOrder$1$Proxy = MethodProxy.create(var1, var0, "()V", "placeOrder", "CGLIB$placeOrder$1");
        CGLIB$place$2$Method = var10000[2];
        CGLIB$place$2$Proxy = MethodProxy.create(var1, var0, "()V", "place", "CGLIB$place$2");
    }
    
    /**
     * 用来调用父类的原始方法
     * CGLIB生成代理利用的是继承，而不是JDK动态代理的利用接口的形式
     * 这样就有一个区别就出现了，JDK动态代理中必须要有一个被代理类的实例
     * 但是CGLIB实现的动态代理就不需要，因为是继承，所以就包含了被代理类的全部方法
     * 但是我们调用生成的代理类实例的toString()方法时，调用的就是CGLIB代理时候的方法
     * 如果调用被代理类的原始方法呢，就是靠下面的这个方法
     * CGLIB生成的代理类中每个原始方法都会有这两种类型的方法
     */
    final String CGLIB$toString$0() {
        return super.toString();
    }
    
    /**
     * 生成的代理方法，在该方法中会调用我们设置的Callback
     * 当调用代理类的toString方法时，先判断是否已经存在实现了MethodInterceptor接口的拦截对象
     * 如果没有的话就调用CGLIB$BIND_CALLBACKS方法来获取Callback
     */
    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$0$Method, CGLIB$emptyArgs, CGLIB$toString$0$Proxy) : super.toString();
    }
    
    /**
     * 删除了类似toString这样生成的方法，也都是一一对应的
     * 还有几个newInstance()方法,newInstance()方法来源于Factory接口
     * 从上面可以看到生成的代理类实现了Factory接口
     */

    public GoodsService$$EnhancerByCGLIB$$b08e58d5() {
        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;
    }
    
    /**
     * CGLIB$BIND_CALLBACKS 先从CGLIB$THREAD_CALLBACKS(一个ThreadLocal对象)中getCallback
     * 如果获取不到的话，再从CGLIB$STATIC_CALLBACKS来获取，如果也没有则认为该方法不需要代理。
     * 那么CallBack是如何设置到CGLIB$THREAD_CALLBACKS 或者 CGLIB$STATIC_CALLBACKS中的呢？
     * 在Jdk动态代理中拦截对象是在实例化代理类时由构造函数传入的
         * 在cglib中我们使用Enhancers生成代理类时。是调用Enhancer的firstInstance方法来生成代理类实例并设置回调。
     * firstInstance的调用轨迹为：
           1.Enhancer：firstInstance
           2.Enhancer：createUsingReflection
           3.Enhancer：setThreadCallbacks
           4.Enhancer：setCallbacksHelper
           5.Target$$EnhancerByCGLIB$$788444a0 ： CGLIB$SET_THREAD_CALLBACKS
     * 最终CGLIB实例化代理对象的时候，就在这里将所有的Callback成功设置了
     */
    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        GoodsService$$EnhancerByCGLIB$$b08e58d5 var1 = (GoodsService$$EnhancerByCGLIB$$b08e58d5)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 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();
    }
}

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167
```

在生成的代理类字节码中，有一个静态代码块，他执行了重要的方法

```java
static {
    CGLIB$STATICHOOK1();
}

static void CGLIB$STATICHOOK1() {
    CGLIB$THREAD_CALLBACKS = new ThreadLocal();
    CGLIB$emptyArgs = new Object[0];
    /**
     * 为被代理类所有方法生成一个MethodProxy对象，包含其所有父类的方法
     */
    Class var0 = Class.forName("com.cp.v5.service.GoodsService$$EnhancerByCGLIB$$b08e58d5");
    Class var1;
    // 获取Object这个父类的所有方法，会将其所有的方法保存到一个本地变量上，并且会生成一个MethodProxy
    // 这个MethodProxy的对象实例很重要，MethodInterceptor的intercept方法就需要该对象实例，用来进行快速调用
    Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
    CGLIB$equals$3$Method = var10000[0];
    CGLIB$equals$3$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$3");
    CGLIB$hashCode$4$Method = var10000[1];
    CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
    CGLIB$clone$5$Method = var10000[2];
    CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
    // 获取GoodsService这个父类的所有方法
    var10000 = ReflectUtils.findMethods(new String[]{"toString", "()Ljava/lang/String;", "placeOrder", "()V", "place", "()V"}, (var1 = Class.forName("com.cp.v5.service.GoodsService")).getDeclaredMethods());
    CGLIB$toString$0$Method = var10000[0];
    CGLIB$toString$0$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$0");
    CGLIB$placeOrder$1$Method = var10000[1];
    CGLIB$placeOrder$1$Proxy = MethodProxy.create(var1, var0, "()V", "placeOrder", "CGLIB$placeOrder$1");
    CGLIB$place$2$Method = var10000[2];
    CGLIB$place$2$Proxy = MethodProxy.create(var1, var0, "()V", "place", "CGLIB$place$2");
}    
123456789101112131415161718192021222324252627282930
```

`CGLIB$STATICHOOK1()`这个静态方法内执行了MethodProxy.create()方法，为被代理所有的方法都生成了对应的MethodProxy，在调用代理对象的每个方法是都会有一个对应的MethodProxy就会当参数被传递到`MethodInterceptor.intercept()`方法中，在intercept中就能利用MethodProxy类的方法，使用FastClass机制

MethodProxy中的部分方法

```java
/**
 * 一个MethodProxy对象，包含了两个方法的名称，一个是被代理类中的原始方法
 * 另外一个则是代理类中生成的用来调用被代理类原始方法的方法名
 * 当执行MethodProxy.invoke()方法时，其实就是用的被代理类的方法索引
 * 当执行MethodProxy.invokeSuper()方法时，用的是代理类中的方法的索引
 * 
 * c1是代理类实现的父类的class
 * c2是代理类的class
 * name1是被代理类中的原始方法名
 * name2是代理类中新增的用来调用被代理类原始方法的方法的名字
 */
public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
    MethodProxy proxy = new MethodProxy();
    // Signature是用来标识一个唯一的方法
    // 该标识可以用来获取fastClass中每一个方法的索引
    proxy.sig1 = new Signature(name1, desc);
    proxy.sig2 = new Signature(name2, desc);
    proxy.createInfo = new CreateInfo(c1, c2);
    return proxy;
}

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();
                // helper中生成了对应Class的FastClass实例，这里可以看出就是生成了两个Class的FastClass
                fci.f1 = helper(ci, ci.c1);
                fci.f2 = helper(ci, ci.c2);
                // 获取方法的下标,sig1原本的方法名,sig2是为了调用父类方法生成的特殊方法的方法名
                fci.i1 = fci.f1.getIndex(sig1);
                fci.i2 = fci.f2.getIndex(sig2);
                // 存储在本地变量上
                fastClassInfo = fci;
                createInfo = null;
            }
        }
    }
}

public Object invokeSuper(Object obj, Object[] args) throws Throwable {
    try {
        // 调用init方法，当前MethodProxy所代表的方法在在FastClass中的索引
        init();
        FastClassInfo fci = fastClassInfo;
        // 这里的f2就是一个FastClass，fci.i2就是在init方法中计算出来的索引
        return fci.f2.invoke(fci.i2, obj, args);
    } catch (InvocationTargetException e) {
        throw e.getTargetException();
    }
}

public Object invoke(Object obj, Object[] args) throws Throwable {
    try {
        init();
        FastClassInfo fci = fastClassInfo;
        return fci.f1.invoke(fci.i1, obj, args);
    } catch (InvocationTargetException e) {
        throw e.getTargetException();
    } catch (IllegalArgumentException e) {
        if (fastClassInfo.i1 < 0)
            throw new IllegalArgumentException("Protected method: " + sig1);
        throw e;
    }
}

private static class FastClassInfo
{
    // 被代理类的FastClass
    FastClass f1;
    // 代理类的FastClass
    FastClass f2;
    int i1;
    int i2;
}

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889
```

yygr
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
CGLIB 动态代理是另外一种动态代理方式，使用 ASM 字节码操作库来生成代理类。CGLIB 动态代理的优点是可以代理 final 类和 private 方法。 五、 对比分析 | 代理方式 | 优点 | 缺点 | | --- | --- | --- | | 静态...
java代理机制 JDK动态代理和cglib代理 详解
03-26
- **CGLIB代理**：更适合未实现接口的类，更灵活，但生成代理类的速度较慢，因为涉及到字节码的生成。 总结： Java代理机制为我们提供了在运行时扩展功能的能力，无论是JDK动态代理还是CGLIB代理，都是为了在不修改...
spring代理内部方法不生效的原因
kezehuang4192的博客
07-07 1651
原生CGLib内部方法互相调用时可以代理，但基于CGLib的Spring AOP却代理失效 这个问题是在工程中遇到的，想着写一个切面日志，然后用内部类调用了，结果发现没有生效，发现原因有2个： 第一：我的service类没有实现接口，由于不是接口的实现的类，导致spring默认使用cglib代理 第二：cglib在spring实现中会保留proxybean和实际bean类，因此，内部方法调用的时候是使用了实际bean类的实例 首先我们先把cglib的代码写一下 public class Cgl.
jvm 一之 类加载器
ws - 兮的博客空间
07-30 459
自定义一个类加载器加载指定磁盘的class文件}}}@Overridetry{//从磁盘中读取到一个class文件网络向服务器端发送rest请求拿到class文件//如何读取class文件class文件如何组成}}/***从文件中读取去class文件**///采用NIO读取break;}}}}//使用该自定义类加载器加载class//读取class加载到内存中Class...
Java动态代理与Spring AOP中的Cglib动态代理详解
最新发布
dazhong2012的专栏
04-17 1278
在Java编程中，动态代理是一种在运行时动态创建代理类及其对象的技术。通过动态代理，我们可以在不修改原有类代码的情况下，为这些类添加新的行为或功能。Java提供了两种主要的动态代理机制：基于接口的Java动态代理和基于类的Cglib动态代理。在Spring AOP（面向切面编程）中，Cglib动态代理扮演着重要角色。本文将详细讨论这两种动态代理的实现。
动态代理之JDK和CGLIB实现原理对比以及其生成的class的真实面目
weiwei1261559539的专栏
09-15 588
JDK动态代理以及CGLIB动态代理 1、Jdk动态代理以及jdk动态代理类的class的真正面目 jdk动态代理是利用反射机制生成的一个实现代理接口InvocationHandler和目标类接口的匿名类，InvocationHandler其中有一个invoke方法，在调用真正的目标方法method.invoke(target,args)之前或者之后做代理操作。 代码： 代理类 public class JdkTargetProxy implements InvocationHandler {
查看生成的cglib代理类源码详解
jcpp9527的博客
03-30 1419
原文：Cglib动态代理反编译生成类 一、CGLib使用示例 package com.wqc.cglib; import java.lang.reflect.Method; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; public class DynamicProxy implements Method
架构（二）Spring异步发布监听的使用
热门推荐
m0_69270256的博客
04-18 2万+
开发过程中一般使用mq进行功能解耦，但是当主业务上开启许多分支功能，不可能为每一个分支功能开启各自的mq，因此使用Spring的ApplicationEventPublisher进行发布监听。 同时大多数情况下分支功能与主业务需要解耦，因此发布的事件需要异步处理。
动态代理-cglib分析
BaldHead`s
02-08 531
生成动态代理对象流程-CGLIB
静态代理、jdk动态代理、cglib动态代理
02-27
静态代理的实现方式是：在编译时，创建一个代理类，该代理类继承自被代理的对象，并重写其中的一些方法，以便控制对被代理对象的访问。 静态代理的优点是：它的实现方式简单易懂，易于维护和扩展。但是，它的缺点是...
Java动态代理详解； CGLib实现动态代理1
08-08
CGLib 使用字节码技术创建代理类，它比基于接口的 Java 动态代理更加灵活，因为可以代理任何非 final 类。 以下是使用 CGLib 创建动态代理的基本步骤： 1. 引入 CGLib 库。 2. 创建一个 `Enhancer` 对象，它是 ...
cglib动态生成java类
01-26
cglib动态生成java类
cglib代理的依赖jar包
04-29
当创建代理类时，CGlib利用ASM生成字节码，构建目标类的子类，并在其中插入额外的逻辑，如方法拦截。 **将jar包添加到项目** 1. **手动添加** 将`asm-3.3.1.jar`和`cglib-2.2.2.jar`复制到项目的`lib`目录下，...
cglib动态代理
NCS123456的博客
06-13 1万+
CGLIB（Code Generation Library），是一个强大的，高性能，高质量的 Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。
cglib代理，生成的代理类字节码
jupiter_888的博客
12-08 1205
生成字节码文件 被代理的类 package com.example.demo.cglibtest; /** * @Package: org.vincent.proxy.cglibproxy <br/> * @Description： Cglib 代理模式中 被代理的委托类 <br/> * @author: lenovo <br/> * ...
填坑之动态代理生成的代理类文件在哪？
u010088278的博客
04-12 2453
获取动态代理生成的代理类文件、Mybatis、设计模式
基于子类的动态代理（Cglib）
你今天真好看呀
10-27 628
在上一篇博客中写了基于接口的动态代理，其实这两个原理基本差不多，对比学习更好理解。 文章目录1.导入依赖2.Producer类3.调用处理程序类MyMethodInterceptor4.测试类Client 基于子类的动态代理： 　涉及的类：Enhancer 　提供者：第三方库cglib库 　如何创建代理对象:使用Enhancer类中的create方法 　创建代理对象的要求：代理类不是最终类 1.导...
从源码角度理解Cglib动态代理
李哈zzz的博客
03-20 1008
Cglib是什么？ 生成动态子类以启用方法拦截。此类开始是作为 JDK 1.3 中包含的标准动态代理支持的替代品，但它允许代理扩展具体的基类，除了实现接口。动态生成的子类覆盖超类的非最终方法，并具有回调到用户定义的拦截器实现的钩子——来自源码中注释的翻译 简单的来说就是可以对接口或者类做一个代理，我们知道动态代理是肯定要操作字节码的，Cglib底层使用ASM技术来操作字节码文件，他是一个更轻量级的框架来操作字节码，但是使用起来非常的复杂，所以Cglib也是帮你封装了复杂的操作，让用户直接使用API实
Cglib源码分析 invoke和invokeSuper的差别
没有进步就是退步
03-17 1万+
Cglib的实例 本文重在源码的分析，Cglib的使用不再复述。 //被代理类 public class InfoDemo { public void welcome (String person){ System.out.println("welcome :" + person); } } public class CglibInfoProxy implem...
Spring框架系列(11) - Spring AOP实现原理详解之Cglib代理实现.doc
07-08
Cglib的核心优势在于其高效地操作类的字节码，使得代理类的生成无需预编译阶段，只需在运行时根据需求动态生成。 在Spring AOP中，Cglib被作为底层技术来实现代理功能。Spring AOP框架与Cglib结合，提供了简单易用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值