静态代理与JDK动态代理与CGLIB动态代理

最新推荐文章于 2024-04-17 17:28:09 发布
最新推荐文章于 2024-04-17 17:28:09 发布
阅读量372 收藏 1
点赞数 2
分类专栏： spring java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuqinduo/article/details/102584103
版权

为了理解spring的AOP。 理解JDK动态代理与CGLB动态代理，非常重要。

讲动态代理必讲静态代理。

静态代理与动态代理是一种设计思想

静态代理

静态代理是在编译期将扩展代码织入代理对象

实现方式

1.代理模式：可以理解为硬编码模式。就是代理类里持有被代理对象的引用。 通过调用代理类的实例。达到间接调用被代理对象的目的。

public interface UserInterface {
    void doSomething();
}

public class User implements UserInterface {
    @Override
    public void doSomething() {
        System.out.println("I'm doing something");
    }
}
public class UserProxy implements UserInterface {
    private UserInterface userInterface = null; // 持有被代理对象的引用
    @Override
    public void doSomething() {
        beforeDoSomething();
        if(operator == null){
            userInterface =  new User();
        }
        operator.doSomething();
        afterDoSomething();
    }
    private void beforeDoSomething() {
        System.out.println("before doing something");
    }
    private void afterDoSomething() {
        System.out.println("after doing something");
    }
}

2.AspectJ编译织入
AspectJ是一种面前切面的技术，通过在编译期把AspectJ内容编译到字节码文件.class （这里不做过多解析推荐文章关于 Spring AOP (AspectJ) 你该知晓的一切）

静态代理小结：

  • 静态代理不产生新的Class
  • 静态代理在编译期织入代理对象
  • 静态代理不灵活。

动态代理：

我们熟知的动态代理：JDK动态代理和CGLB动态代理 他们都有一个共同点， 在内存中生成了新的字节码，这点很重要。这节我们从生成的新字节码的角度来看看动态代理的两种方式

因为新生成的字节码在内存中，为了看到这些字节码我们需要其以文件的形式展现出来。我们在main方法里加下面两行代码就可以把内存的字节码拿出来了

//输出JDK动态代理
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
//输出CGLIB动态代理产生的类
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "./cglbproxy");

我们还是以User类为例看看JDK动态代理生成的字节码文件与CGLB生成的字码文件
详情代码参考springlean项目

1.JDK动态代理：

//------------------------------------接口
interface UserInterface {
    void doSomething();
}
//------------------------------------被代理类
class User implements UserInterface {
    @Override
    public void doSomething() {
        System.out.println("我是实现了接口的User");
    }
}
//------------------------------------代理类(也是拦截器)
class JDKProxy implements InvocationHandler {

    // 要被代理的目标对象
    private UserInterface target;

    public JDKProxy(UserInterface target){
        this.target=target;
    }
    public UserInterface createProxy(){
        return (UserInterface) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("JDK前置拦截");
        return method.invoke(target,args);
    }
}
//------------------------------------内存生成的新代理类。
final class $Proxy0 extends Proxy implements UserInterface {
    private static Method m3;
  	//省略其他代码
  	.....
    public final void doSomething() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }
    static {
        try {
            m3 = Class.forName("cn.wqd.UserInterface").getMethod("doSomething", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
    ....
}
//------------------------------------调用。
public static void main(String[] args) {
 		User a=new User();
        //创建JDK代理
        JDKProxy jdkProxy=new JDKProxy(a);
        //创建代理对象
        UserInterface proxy=jdkProxy.createProxy();
        System.out.println(proxy.getClass().getName());
        //执行代理对象方法
        proxy.doSomething();
}

System.out.println(proxy.getClass().getName()); 输出的是cn.wqd.$Proxy0。 我们没有定义过cn.wqd.$Proxy0类，所以 cn.wqd.$Proxy0就是新生成的代理类。

对比我们User类与$Proxy0类总结下新的代理类的特征

  • 新生成的代理类中定义了与被代理对象相同方法名的方法，如doSomething()方法
  • 新生成的代理类实现了与被代理类相同接口 ：UserInterface
  • 新生成的代理类继承了Proxy
  • 新生成的代理类是final类型

当我们调用proxy.doSomething()的时候，指的是cn.wqd.$Proxy0.doSomething()
，其内部调用时父类Proxy的.InvocationHandler的invoke()方法,传入的参数(1)代理类对象 ,(2)目标对象的方法。

InvocationHandler属性参数其实就是我们定义的JDKProxy,其invoke方法最终调用目标对象方法 method.invoke(target,args)。以此达到代理的目的。

小结一下：

  • JDK动态代理通过反射达到代理的目的
  • JDK动态代理会在内存生成一个继承了Proxy，实现了同被代理类实现的接口相同的接口的 代理类。

2.CGLB动态代理：

//====================user
class UserNoInterface{

    public void doSomething() {
        System.out.println("我是没有实现接口的User");
    }
}
//====================拦截器
class CglibProxyIntercepter implements MethodInterceptor {
    @Override
    public Object intercept(Object sub, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("执行前...");
        Object object = methodProxy.invokeSuper(sub, objects);
        System.out.println("执行后...");
        return object;
    }
}

//------------------------------------调用。
public static void main(String[] args) {
 		Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserNoInterface.class);
        enhancer.setCallback(new CglibProxyIntercepter());
        UserNoInterface proxyCGLB= (UserNoInterface)  enhancer.create();
        System.out.println(proxyCGLB.getClass().getName());
        proxyCGLB.doSomething();
}

CGLB动态代理不要求被代理类实现一个接口，就可以进行代理。
CGLB生成三个新的字码码文件，是不是很诡异。
file
System.out.println(proxyCGLB.getClass().getName()); 打印cn.wqd.UserNoInterface$$EnhancerByCGLIB$$b3361405
看来三个文件中。
cn.wqd.UserNoInterface$$EnhancerByCGLIB$$b3361405才是对应生成的代理类。
我们分析下代理类代码。（为了便于理解，我只贴出有助于理解的代码具体查看详情代码参考springlean项目）

public class UserNoInterface$$EnhancerByCGLIB$$b3361405 extends UserNoInterface 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$doSomething$0$Method;
    private static final MethodProxy CGLIB$doSomething$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("cn.wqd.UserNoInterface$$EnhancerByCGLIB$$b3361405");
        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$doSomething$0$Method = ReflectUtils.findMethods(new String[]{"doSomething", "()V"}, (var1 = Class.forName("cn.wqd.UserNoInterface")).getDeclaredMethods())[0];
        CGLIB$doSomething$0$Proxy = MethodProxy.create(var1, var0, "()V", "doSomething", "CGLIB$doSomething$0");
    }

    final void CGLIB$doSomething$0() {
        super.doSomething();
    }

    public final void doSomething() {
        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$doSomething$0$Method, CGLIB$emptyArgs, CGLIB$doSomething$0$Proxy);
        } else {
            super.doSomething();
        }
    }
	.....
}

总结下特征

  • 代理类继承了被代理类，
  • 代理类为每个目标类的方法都生成了两个方法，以doSomething()为例，一个是重写方法doSomething()，另一个是CGLIB$doSomething$0()，CGLIB$doSomething$0()方法内部调用的是super.doSomething()也就是目标方法的doSomething()方法
  • 代理类会获得所有在父类继承来的方法，并且会创建一个MethodProxy类型属性与之对应。以doSomething()例子，CGLIB$doSomething$0$Method获取的父类方法，CGLIB$doSomething$0$Proxy与之对应的MethodProxy
CGLIB$doSomething$0$Method = ReflectUtils.findMethods(new String[]{"doSomething", "()V"}, (var1 = Class.forName("cn.wqd.UserNoInterface")).getDeclaredMethods())[0];
CGLIB$doSomething$0$Proxy = MethodProxy.create(var1, var0, "()V", "doSomething", "CGLIB$doSomething$0");

因为拿到的proxyCGLB是代理类对象实例，所以proxyCGLB.doSomething()调用的就是

 public final void doSomething() {
        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$doSomething$0$Method, CGLIB$emptyArgs, CGLIB$doSomething$0$Proxy);
        } else {
            super.doSomething();
        }
    }

我们看看这段逻辑：
首先，检查(MethodInterceptor)CGLIB$CALLBACK_0是否为null，看到MethodInterceptor我们应该明白了这个地方的CGLIB$CALLBACK_0应该就是上文定义的CglibProxyIntercepter 。

不为null。则执行CglibProxyIntercepter.intercept()方法，入参分别为：
（1）this:代理类对象，
（2）CGLIB$doSomething$0$Method目标对象方法，
（3）CGLIB$emptyArgs方法入参
（4）CGLIB$doSomething$0$Proxy代理方法。

CglibProxyIntercepter.intercept()方法内部通过调用MethodProxy.invokeSuper(sub, objects)。

我们看看MethodProxy的内部：

public Object invoke(Object obj, Object[] args) throws Throwable {
        try {
            this.init();
            MethodProxy.FastClassInfo fci = this.fastClassInfo;
            return fci.f1.invoke(fci.i1, obj, args);
        } catch (InvocationTargetException var4) {
            throw var4.getTargetException();
        } catch (IllegalArgumentException var5) {
            if(this.fastClassInfo.i1 < 0) {
                throw new IllegalArgumentException("Protected method: " + this.sig1);
            } else {
                throw var5;
            }
        }
    }
    public Object invokeSuper(Object obj, Object[] args) throws Throwable {
        try {
            this.init();
            MethodProxy.FastClassInfo fci = this.fastClassInfo;
            return fci.f2.invoke(fci.i2, obj, args);
        } catch (InvocationTargetException var4) {
            throw var4.getTargetException();
        }
    }
    ///fastclass
 	private static class FastClassInfo {
        FastClass f1;
        FastClass f2;
        int i1;
        int i2;

        private FastClassInfo() {
        }
    }

这里有invoke()与invokeSuper()。为啥上面要调用invokeSuper()不调用invoke()呢。

这里就要涉及到CGLB的FastClass机制。
FastClass.机制：为代理类和被代理类各生成一个Class。这个Class会为代理类或被代理类的方法分配一个index(int类型)索引。通过这个索引可以直接定位到要调用的方法，省去了反射。
具体推荐阅读
参考1
参考2

这里我们只需知道结果:MethodProxy.FastClassInfo 属性的最终值会是

private static class FastClassInfo {
        FastClass f1;//被代理类UserNoInterface的FastClass
        FastClass f2;//代理类UserNoInterface$$EnhancerByCGLIB$$b3361405的FastClass
        int i1;//被代理类的doSomething()的索引
        int i2;//代理类CGLIB$doSomething$0()（内部调用被代理对象的方法）的索引。
        private FastClassInfo() {
        }
    }

三个文件分别为：

  • UserNoInterface$$EnhancerByCGLIB$$b3361405$$FastClassByCGLIB$$fc90c93c《代理类的FastClass》
  • UserNoInterface$$EnhancerByCGLIB$$b3361405《 cglb生成的代理类》
  • UserNoInterface$$FastClassByCGLIB$$29e52466《被代理类的FastClass》

我们在回头看看invoke()，invokeSuper()方法

  • invoke() 调用的是fci.f1.invoke(fci.i1, obj, args);也就是调用的是被代理类UserNoInterface的FastClass的invoke方法。
  • invokeSuper()调用的是fci.f2.invoke(fci.i2, obj, args);也就是调用的是代理类UserNoInterface$$EnhancerByCGLIB$$b3361405的FastClass的invoke方法.
//=================被代理对象的fastclass的invoke方法
public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
        UserNoInterface var10000 = (UserNoInterface)var2;
        int var10001 = var1;

        try {
            switch(var10001) {
            case 0:
                var10000.doSomething();
                return null;
            }
        } catch (Throwable var4) {
            throw new InvocationTargetException(var4);
        }

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

//=================代理对象的fastclass的invoke方法
public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
        b3361405 var10000 = (b3361405)var2;
        int var10001 = var1;
        try {
            switch(var10001) {
          
            case 7:
                var10000.doSomething();
                return null;
            case 15:
                var10000.CGLIB$doSomething$0();
                return null;
            }
        } catch (Throwable var4) {
            throw new InvocationTargetException(var4);
        }

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

我们看到如果调用了MethodProxy.invoke() 会调用被代理对象的fastclass的invoke方法，会调用var10000.doSomething()。而var10000其实就是代理对象,这样就出现了死循环。 这也是网上为啥说的不能在此处使用MethodProxy.invoke()的原因。

看看最终的调用链：

代理对象.doSomething()—>拦截器.intercept()—>MethodProxy.invokeSuper(sub, objects)—>代理类的FastClass类对象的.invoke()—>代理对象的CGLIB$doSomething$0()方法—>目标对象的方法doSomething()

小结：

  • CGLB动态代理可以代理没有实现接口的类
  • CGLB动态代理通过Enhancer 实现代理功能
  • CGLB动态代理生成一个目标对象的子类。

总结：

  • 静态代理从源头解决代理问题
  • 动态代理从运行使用时解决代理问题。
  • JDK动态代理通过InvocationHandler实现拦截。
  • GCLB通过MethodInterceptor实现拦截。

重点：
1.JDK动态是通过反射来实现的。两个要素是Proxy+InvocationHandler

  • Proxy 用于创建代理，并且内存中创建的类也继承Proxy
  • InvocationHandler增强器，实现对目标方法的增强。

2.CGLB动态代理：两要素Enhancer + MethodInterceptor(CallBack)

  • Enhancer创建代理
  • MethodInterceptor 增强器， 实现对目标方法增强。

3.JDK代理与CGLB动态代理都在内存中生成新的字节码，最终还是落在Class对象上，

要素是手段，字节码才是目的。JVM并不关心你java代码，他关心的是在内存中可被使用的字节码。

享学源码
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【JVM与性能调优】JVM动态代理、JDK动态代理和CGLib动态代理傻傻分不清楚
本本本添哥
04-14 1206
JDK动态代理和CGLib动态代理都是Java中用于创建动态代理的方法，但它们的实现方式不同。
浅谈Spring中JDK动态代理和CGLIB动态代理
CharlesYooSky的博客
10-21 1692
浅谈Spring中JDK动态代理和CGLIB动态代理
Spring AOP 实现原理
热门推荐
KevinJom的专栏
09-24 57万+
什么是AOP AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从
jdk动态代理和cglb动态代理
一个菜鸡的博客
06-14 815
动态代理和静态代理都是代理模式的实现方式，其主要区别在于代理类生成的时机和方式。静态代理是在编译时就确定了代理类的代码，在程序运行前就已经存在了代理类的class文件。代理类与委托类的关系在编译时就已经确定，因此被称为静态代理。在静态代理中，代理类需要实现与委托类相同的接口或者继承委托类的父类，以便能够对委托类进行代理操作。动态代理是在程序运行时生成代理类的代码，代理类通过反射机制动态生成。动态代理不需要像静态代理一样实现与委托类相同的接口或继承委托类的父类，它可以实现任意接口。
动态代理（JDK+CGLIB ）
最新发布
weixin_45134135的博客
04-17 872
动态代理是一种在运行时生成代理类的技术，它允许在不知道具体接口或类的情况下创建代理对象，并在代理对象的方法执行前后插入额外的逻辑。在 Java 中，通常有两种动态代理的实现方式：基于 JDK 的动态代理和基于 CGLIB 的动态代理。
java动态代理：jdk动态代理和cglib动态代理
记录学习点滴
02-20 2475
java动态代理
通俗易懂 快速理解 JDK动态代理 和 cglib动态代理
weixin_43935152的博客
05-05 1万+
动态代理有两种： ① jdk动态代理，要求必须有接口，最终生成的代理类和目标类实现相同的接口，在com.sun.proxy包下，类名为$proxy+数字 （例如：$proxy6） ② cglib动态代理，最终生成的代理类会继承目标类，并且和目标类在相同的包下
代理模式之静态代理，JDK动态代理和cglib动态代理
烟雨星空的博客
12-27 1218
代理模式，顾名思义，就是通过代理去完成某些功能。比如，你需要购买火车票，不想跑那么远到火车站售票窗口买，可以去附近的火车票代售点买，或者到携程等第三方网站买。这个时候，我们就把火车站叫做目标对象或者委托对象，也可以叫被代理对象，而火车票代售点和携程就叫做代理对象。 一、静态代理 静态代理是最简单的代理模式。需要定义一个接口，然后委托类和代理类分别实现这个接口 //待实现的接口 public int...
静态代理、jdk动态代理、cglib动态代理
02-27
静态代理的实现方式是：在编译时，创建一个代理类，该代理类继承自被代理的对象，并重写其中的一些方法，以便控制对被代理对象的访问。 静态代理的优点是：它的实现方式简单易懂，易于维护和扩展。但是，它的缺点是...
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
代理模式-静态动态代理-jdk动态代理-cglib动态代理
11-12
在Java中，代理模式有多种实现方式，包括静态代理、JDK动态代理和CGLIB动态代理。 **静态代理** 静态代理是最早也是最基础的代理实现方式。在静态代理中，我们需要创建一个代理类，这个代理类与原始类（被代理类）...
你必须会的 JDK 动态代理和 CGLIB 动态代理
12-21
本文将探讨静态代理、JDK动态代理以及CGLIB动态代理的区别和应用场景。 **静态代理** 静态代理是在编译阶段就已经确定的代理模式，代理类的字节码在程序运行前就已经生成。在静态代理中，代理类和目标类通常实现...
JDK 动态代理和 CGLIB 动态代理对比
zhanghuyi2022的博客
11-26 3643
JDK动态代理和CGLIB动态代理是Java中两种常见的动态代理方式，它们都用于在运行时动态地创建代理对象。
jdk动态代理和cglib代理
weixin_39825906的博客
08-01 3098
SpringAOP在目标累实现接口的情况下，默认采用JDK的动态代理方式进行目标类的代理。基于CGLIB的动态代理，底层是利用ASM技术实现的，ASM动态生成目标类的子类的字节码。我们的目标类是Bus，他实现了接口Car，然后我们实现一个JdkDynamicProxyTest，JdkDynamicProxyTest持有Bus，在调用invok的时候，织入增强逻辑。CGLIB代理类代理类是目标类的子类，依赖CGLIB.JAR。cglib封装了asm，可以在运行期动态生成新的class。...
【动态代理】—— JDK和cglib的动态代理
1+1=王的博客
03-19 3943
概述 设计模式中有一个代理模式，它为其他对象提供一种代理以控制对这个对象的访问。 关于代理模式可以参考：【每天一个java设计模式（七）】 - 代理模式：https://blog.csdn.net/weixin_43598687/article/details/122072282 代理模式是指的静态代理。使用静态代理很容易就完成了对一个类的代理操作。但是静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。 而动态代理可以在程序运行期间，在不修改源
JDK动态代理和CGLIB动态代理
努力努力再努力的小笼包
05-30 8059
在SpringAOP中基于动态代理实现功能的增强，也就是动态的生成代理类，在代理类中织入增强的逻辑然后调用目标对象的方法。动态代理中用的比较多的两种：JDK动态代理、CGLIB动态代理。 JDK动态代理 使用JDK的java.lang.reflect.Proxy类的newProxyInstance方法实现的代理。 用一个测试接口看下具体实现： public interface JdkProxyDemoService { void queryTrs(); } @Service public
cglip动态代理和jdk动态代理区别是什么,优缺点是什么
gxy156111的博客
07-31 950
3. 性能：CGLIB动态代理在创建代理类时需要使用ASM字节码操作库来修改字节码，相比之下，JDK动态代理的创建过程更加简单，性能略好一些。1. 实现方式：CGLIB动态代理通过继承被代理类来创建代理类，而JDK动态代理通过实现被代理接口来创建代理类。2. 支持的代理对象类型：CGLIB动态代理可以代理任意类，而JDK动态代理只能代理实现了接口的类。CGLIB动态代理和JDK动态代理是两种不同的代理实现方式，它们有一些区别和各自的优缺点。1. 只能代理实现了接口的类，无法代理未实现接口的类。
Spring framework Day17:JDK和CGLIB动态代理
zhiqiuqiu2的博客
10-16 514
动态代理是一种在运行时动态生成代理类的技术，它可以在不修改目标类代码的情况下为目标类提供代理功能，从而在被代理对象的方法执行前后添加额外的逻辑。动态代理主要由两个部分组成：代理工厂和回调处理器。代理工厂用于生成代理对象，通常使用类来实现。回调处理器则用于拦截对代理对象方法的调用，并实现增强逻辑。常见的回调处理器有接口、接口等。在调用代理对象的方法时，代理对象会将方法调用请求转发给回调处理器，并在回调处理器中执行增强逻辑。相比于静态代理，动态代理的优势在于可以动态地生成代理类，具有更好的灵活性和可扩展性。
JDK和CGLIB动态代理的区别
weixin_43731014的博客
05-04 973
1.jdk代理只能对实现了接口的类进行代理，而cglib代理可以对普通类进行代理；2.jdk代理是通过反射的方式来实现动态代理，而cglib则是通过为目标类生成一个子类的方式来实现动态代理；3.由于cglib代理是为目标类生成了一个子类，并对父类方法进行增强，所以目标类不能用final修饰；
jdk和cglib，静态动态代理差别
04-26
JDK和CGLIB都可以实现代理模式，但是它们实现的代理类型不同。JDK实现的代理是基于接口的，也称为接口代理。JDK通过反射机制动态生成代理类，该代理类实现了接口中的所有方法，并将方法调用委托给了被代理的对象。而CGLIB实现的代理是基于类的，也称为子类代理。CGLIB通过继承被代理类，动态生成一个子类，并重写其中的方法来实现代理。相比于JDK代理，CGLIB代理的效率更高，但是被代理的类必须有默认构造方法并且不能被final修饰。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值