JDK动态代理和CGLib动态代理的简单理解

最新推荐文章于 2024-05-27 18:56:24 发布
最新推荐文章于 2024-05-27 18:56:24 发布
阅读量981 收藏 6
点赞数 3
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36898943/article/details/109229965
版权

1.首先说明一点,这个动态代理只是一个名字,不要被这个名字吓坏了,不管什么代理不代理, 最终结果都是这个过程: 

类(你创建)--->字节码(编译)--->内存中的Class(加载)--->堆中的对象(你创建),  然后我们 使用  对象调用方法

上边是一个常规过程,比较好理解,而这个动态代理是个什么回事儿呢?   他直接这样干:

字节码(代理生成)--->内存中的Class(加载)--->堆中的对象(代理给你创建) ,然后我们 使用 对象调用方法

其实 上边两个过程本身都是容易理解的,但是由于第二个过程, 它类不让你创建, 对象不需要你创建, 所以你不知道发生了什么,你也不知道这个类的结构是什么, 因此你对于它给你的对象也是感到很陌生,觉得很NB,其实也就是那回事儿,不要慌;接下来我们就来分析分析他到底给你生成了个啥类,给你创建了个啥对象:

2.JDK动态代理 :   (代码可以先不看,我写的目的仅是为了你可以自证)

首先JDK动态代理需要你提供一个接口:   UserService 

public interface UserService {
   void save();
}

提供一个实现类: UserServiceImpl

public class UserServiceImpl implements UserService {
   @Override
   public void save() {
      System.out.println("save()无参数方法");
   }
}

再提供一个功能增强的类  MyInvocationHandler 

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    /**
     * 这是个增强方法,里边写得是增强逻辑,就是你要怎么增强
     * @param proxy 代理对象
     * @param method 被调用的方法
     * @param args 方法参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method.getName()+"开始调用了");
        Object invoke = method.invoke(target, args);
        System.out.println(method.getName()+"调用结束了");
        return invoke;
    }
}

可以了,接下来就由JDK登场了,他给我们提供了一个 类  工具类 Proxy

package java.lang.reflect;
public class Proxy implements java.io.Serializable {
        //此处代码省略
}

接下来我们就用这个工具类创建代理:


    public static void main(String[] args) throws IOException {
        //生成的代理类保存到磁盘，在项目的com.sun.proxy下面生成$Proxy0.class类
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        //创建目标类对象
        UserService target = new UserServiceImpl();
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler(target);
        UserService proxyInstance = (UserService)Proxy.newProxyInstance(
                UserServiceImpl.class.getClassLoader(),
                UserServiceImpl.class.getInterfaces(),
                myInvocationHandler);
        //代理对象调方法 
        proxyInstance.save();

    }

上边代码可以运行出来结果就是 目标类中的 save() 方法被代理对象增强了,我们需要做的是整理一下思路: 

         我们其实提供了三个东西 UserService / UserServiceImpl / MyInvocationHandler  

         然后JDK提供了一个东西 Proxy

          最后 proxy.newProxyInstance(目标类的加载器,目标类的实现接口,增强类的对象)  创建了代理对象,

                那既然创建了代理对象----->对象由Class而来---->Class由字节码而来---->字节码由类而来, 好的,接下来我们就是要拿出这个类:

        //生成的代理类保存到磁盘，在项目的com.sun.proxy下面生成$Proxy0.class类
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

好的,我们看一下生成的类(需要反编译):其实你认真看看这个类,我就不用废话了,但是这个类有点长,我估计你不想看,那还是听我跟你掰扯掰扯:  

 其实呢下边这个类就是 JDK代理对象  所对应的类 

                    public final class $Proxy0 extends Proxy implements UserService

你看它继承了 Proxy 实现了 UserService  (说个题外话: 这其实也说明了为啥JDK动态代理必须要让目标类实现接口的原因,因为代理类已经有个父类Proxy了, java又不能多继承, 这个代理呢又需要和目标对象具有同样的功能,你说咋办, 那就跟目标对象实现同一个接口吧) 我们接着说:  其实这个代理类中 持有了一个增强类 MyInvocationHandler  的对象, 而这个MyInvocationHandler  的对象中又持有了一个 目标类对象, 大概就是这样:

       代理对象-----持有----> MyInvocationHandler对象-----持有----> 目标类对象

所以我们每次使用代理对象调用方法的过程就是:  

   代理对象.save() -----触发----->  MyInvocationHandler对象.invoke() -----触发----->  目标类对象.save()方法被调用

如果还是不懂了就看看下边的图片,或者下边的代码,接下来你往下拉一下滚动条,我们去看看JDK动态代理:

 

public final class $Proxy0 extends Proxy implements UserService {
    private static Method m1;
    private static Method m4;
    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});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void save(String var1) throws  {
        try {
            super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void save() 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);
        } 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"));
            m4 = Class.forName("cn.proxy.dynamicProxy.ProxyTest.JDKProxy.UserService").getMethod("save", Class.forName("java.lang.String"));
            m3 = Class.forName("cn.proxy.dynamicProxy.ProxyTest.JDKProxy.UserService").getMethod("save");
            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());
        }
    }
}

 

3.CGLib动态代理 :   (代码可以先不看,我写的目的仅是为了你可以自证)

我们来看CGLib动态代理需要我们提供什么:

首先是目标类:  BookService

public class BookService {
    public void add(){
        System.out.println("add()方法执行了...");
    }
}

然后是增强类: MyMethodInterceptor

public class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("前置增强");
        methodProxy.invokeSuper(o,objects);
        System.out.println("后置增强");
        return null;
    }
}

可以了,接下来CGLib闪亮登场: 它提供了一个工具类  Enhancer

package net.sf.cglib.proxy;
public class Enhancer extends AbstractClassGenerator {
      //此处省去很多代码
}

接下来我们使用这个工具类来创建代理对象

public static void main(String[] args) throws IOException {
    //下边这一句是为了生成代理类  是的 你没看错 是代理类 就是代理类, 真正开发的时候肯定是不需要这一句的
    //有了代理类,其实你直接看代理类的源码自己也就懂了
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\classes");

    //下边这些才是生成代理对象的代码
    //1.创建工具类对象
    Enhancer enhancer = new Enhancer();
    //2.设置(代理的)父类
    enhancer.setSuperclass(BookService.class);
    //3.创建增强类对象
    MyMethodInterceptor myMethodInterceptor = new MyMethodInterceptor();
    //4.设置增强类对象
    enhancer.setCallback(myMethodInterceptor);
    //5.使用工具对象创建代理
    BookService bookService = (BookService)enhancer.create();
    //6.代理对象调用方法
    bookService.add();
}

好了上边代码已经为我们创建了CGLib代理对象, 运行的结果就是 BookService 类的add() 方法被增强了,我们来整理一下思路:

         我们其实提供了两个东西 BookService/ MyMethodInterceptor

         然后CGLib提供了一个东西 Enhancer

          最后  在设置了 父类 和 增强类对象 之后 :   BookService bookService = (BookService)enhancer.create();

就可以创建一个代理对象

                那既然创建了代理对象----->对象由Class而来---->Class由字节码而来---->字节码由类而来, 好的,接下来我们就是要拿出这个代理类:

 //下边这一句是为了生成代理类 是的 你没看错 是代理类 就是代理类, 真正开发的时候肯定是不需要这一句的
 //有了代理类,其实你直接看代理类的源码自己也就懂了 
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\classes");

好的,我们看一下生成的类(需要反编译):其实你认真看看这个类,我就不用废话了,但是这个类有点长,我估计你不想看,那还是听我跟你掰扯掰扯:  

 其实呢下边这个类就是 CGLib代理对象  所对应的类  

public class BookService$$EnhancerByCGLIB$$cdc837d extends BookService implements Factory

你看它继承了 BookService 实现了 Factory ,其实这个代理类中

        1.持有了一个增强类 MyMethodInterceptor 的对象, 

     private MethodInterceptor CGLIB$CALLBACK_0;

         2.代理类重写了父类方法,   

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

    if (var10000 != null) {
        var10000.intercept(this, CGLIB$add$0$Method, CGLIB$emptyArgs, CGLIB$add$0$Proxy);
    } else {
        super.add();
    }
} 

         3.这个代理类复制了父类方法,并且改了名字

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

大概就是这样:

       代理对象-----持有----> MyMethodInterceptor 对象

所以我们每次使用代理对象调用方法的过程就是:  

   代理对象.save() -----触发----->  MyMethodInterceptor 对象.intercept() -----触发----->  代理对象.CGLIB$add$0() 重命名方法被调用

其实也就是说 这个CGLib代理对象很邪乎,它首先继承了 目标类 BookService, 重写了里边的方法,然后就是把所有要重写的方法对应生成一个CGLib方法 ( 长这样:CGLIB$add$0() ) ,而这个方法内部,调用了父类的被重写的方法, 简单理解来说,父类里边只有一套方法, 代理对象是作为子类重写一套,作为代理对象又代理一套,总共有两套方法; 

如果还是不懂了就看看下边的图片,或者下边的CGLib代理对象的类的代码:

    

 

public class BookService$$EnhancerByCGLIB$$cdc837d extends BookService implements Factory {
    private boolean CGLIB$BOUND;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static final Method CGLIB$add$0$Method;
    private static final MethodProxy CGLIB$add$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$finalize$1$Method;
    private static final MethodProxy CGLIB$finalize$1$Proxy;
    private static final Method CGLIB$equals$2$Method;
    private static final MethodProxy CGLIB$equals$2$Proxy;
    private static final Method CGLIB$toString$3$Method;
    private static final MethodProxy CGLIB$toString$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("cn.proxy.dynamicProxy.ProxyTest.CGLibProxy.BookService$$EnhancerByCGLIB$$cdc837d");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$finalize$1$Method = var10000[0];
        CGLIB$finalize$1$Proxy = MethodProxy.create(var1, var0, "()V", "finalize", "CGLIB$finalize$1");
        CGLIB$equals$2$Method = var10000[1];
        CGLIB$equals$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
        CGLIB$toString$3$Method = var10000[2];
        CGLIB$toString$3$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
        CGLIB$hashCode$4$Method = var10000[3];
        CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
        CGLIB$clone$5$Method = var10000[4];
        CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
        CGLIB$add$0$Method = ReflectUtils.findMethods(new String[]{"add", "()V"}, (var1 = Class.forName("cn.proxy.dynamicProxy.ProxyTest.CGLibProxy.BookService")).getDeclaredMethods())[0];
        CGLIB$add$0$Proxy = MethodProxy.create(var1, var0, "()V", "add", "CGLIB$add$0");
    }

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

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

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$add$0$Method, CGLIB$emptyArgs, CGLIB$add$0$Proxy);
        } else {
            super.add();
        }
    }

    final void CGLIB$finalize$1() throws Throwable {
        super.finalize();
    }

    protected final void finalize() throws Throwable {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$finalize$1$Method, CGLIB$emptyArgs, CGLIB$finalize$1$Proxy);
        } else {
            super.finalize();
        }
    }

    final boolean CGLIB$equals$2(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$2$Method, new Object[]{var1}, CGLIB$equals$2$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }

    final String CGLIB$toString$3() {
        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$3$Method, CGLIB$emptyArgs, CGLIB$toString$3$Proxy) : super.toString();
    }

    final int CGLIB$hashCode$4() {
        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$4$Method, CGLIB$emptyArgs, CGLIB$hashCode$4$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$5() 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$5$Method, CGLIB$emptyArgs, CGLIB$clone$5$Proxy) : super.clone();
    }

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

        return null;
    }

    public BookService$$EnhancerByCGLIB$$cdc837d() {
        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) {
        BookService$$EnhancerByCGLIB$$cdc837d var1 = (BookService$$EnhancerByCGLIB$$cdc837d)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);
        BookService$$EnhancerByCGLIB$$cdc837d var10000 = new BookService$$EnhancerByCGLIB$$cdc837d();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

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

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        BookService$$EnhancerByCGLIB$$cdc837d var10000 = new BookService$$EnhancerByCGLIB$$cdc837d;
        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();
    }
}
hurricane_ning
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态代理(cglib与jdk)
热爱生活の李
10-27 900
动态代理(JDK与CGLIB)的对比以及demo演示
JDK动态代理和CGLib动态代理
javaergogoing的博客
03-28 1374
JDK动态代理和CCGLib动态代理小案例
jdk动态代理和cglib代理
weixin_39825906的博客
08-01 3100
SpringAOP在目标累实现接口的情况下，默认采用JDK的动态代理方式进行目标类的代理。基于CGLIB的动态代理，底层是利用ASM技术实现的，ASM动态生成目标类的子类的字节码。我们的目标类是Bus，他实现了接口Car，然后我们实现一个JdkDynamicProxyTest，JdkDynamicProxyTest持有Bus，在调用invok的时候，织入增强逻辑。CGLIB代理类代理类是目标类的子类，依赖CGLIB.JAR。cglib封装了asm，可以在运行期动态生成新的class。...
【Spring】Spring AOP底层原理：JDK动态代理和CGLIB动态代理
最新发布
m0_65277261的博客
05-27 1385
Spring AOP 的实现原理是基于动态代理和字节码操作的。而动态代理是基于反射机制的。 在编译时， Spring 会使用 AspectJ 编译器将切面代码编译成字节码文件。在运行时， Spring 会使用 Java 动态代理或 CGLIB 代理生成代理类，这些代理类会在目标对象方法执行前后插入切面代码，从而实现AOP的功能。
JDK和CGLIB动态代理的区别
热门推荐
qq_59527118的博客
10-18 2万+
学习动态代理的区别
通俗易懂 快速理解 JDK动态代理 和 cglib动态代理
weixin_43935152的博客
05-05 1万+
动态代理有两种： ① jdk动态代理，要求必须有接口，最终生成的代理类和目标类实现相同的接口，在com.sun.proxy包下，类名为$proxy+数字 （例如：$proxy6） ② cglib动态代理，最终生成的代理类会继承目标类，并且和目标类在相同的包下
基于JDK和CGLib的链式动态代理
思念
12-29 1085
动态代理与链式动态代理　　链式代理就是将多个代理串链在一起，一个一个的去执行，执行的顺序取决于链上的先后顺序。JDK的动态代理只能代理实现了接口的类实例，而CGLib则可以代理普通的类实例。执行链式代理的样子大概如下图所示：这很像Spring Aop的前后增强，实际上我也是基于这个想到，如果增强有多个，那么就是链式动态代理的样子了。好像Filter也是这样的，Node.js中如Express的中间件
JDK动态代理和Cglib动态代理实例源码
01-04
本篇将详细探讨JDK动态代理和Cglib动态代理，并通过源码实例来加深理解。 首先，JDK动态代理是Java内置的一种机制，它依赖于`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口。`Proxy`类...
你必须会的 JDK 动态代理和 CGLIB 动态代理
12-21
CGLIB代理适用于不依赖接口的目标类。 总结来说，静态代理简单直观，但灵活性差；JDK动态代理基于接口，适用于接口众多的情况，但不支持非接口类；CGLIB则弥补了JDK动态代理的这一不足，适用于没有接口或接口较少的...
浅谈JDK动态代理与CGLIB代理去区别
03-01
本篇文章将深入探讨JDK动态代理和CGLIB代理的区别，以及它们在实际应用中的选择。 首先，JDK动态代理主要依赖于java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。Proxy类用于创建一个代理对象...
代理模式-静态动态代理-jdk动态代理-cglib动态代理
11-12
在Java中，代理模式有多种实现方式，包括静态代理、JDK动态代理和CGLIB动态代理。 **静态代理** 静态代理是最早也是最基础的代理实现方式。在静态代理中，我们需要创建一个代理类，这个代理类与原始类（被代理类）...
java动态代理(JDK和cglib)共10页.pdf.z
10-29
下面是一个简单的CGLIB代理示例： ```java import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; public class CglibProxy implements ...
【spring】jdk动态代理和cglib动态代理的区别
王佑辉的博客
03-19 3598
6.性能上：在老版的jdk，jdk代理生成的类速度快，通过反射调用慢，cglib是jdk代理速度的10倍左右，jdk在版本每次升级都会有很大的性能提升，cglib停滞不前，jdk7 8的动态代理性能在1万次实验中比cglib要快20%左右。5.jdk动态代理如果目标类未实现接口则无法代理，cglib是通过继承的方式来动态代理，若目标类被final关键字修饰，则无法使用cglib做动态代理。1.jdk动态代理只提供实现接口的目标类代理，不支持没有实现接口的目标类的代理。3.从限制角度讨论区别。
JDK 动态代理和 CGLIB 动态代理对比
zhanghuyi2022的博客
11-26 3827
JDK动态代理和CGLIB动态代理是Java中两种常见的动态代理方式，它们都用于在运行时动态地创建代理对象。
（转帖）Cglib和jdk动态代理的区别及运行性能比较
cleble的专栏
11-09 8051
Cglib和jdk动态代理的区别及运行性能比较
JDK动态代理和CGLIB代理的区别
taxusw的博客
08-09 583
总的来说JDK动态代理利用接口实现，CGLIB动态代理基于继承实现。
Jdk动态代理和Cglib动态代理的区别
qq_48157004的博客
03-25 1006
最后我们总结一下JDK动态代理和Gglib动态代理的区别：1.JDK动态代理是实现了被代理对象的接口，Cglib是继承了被代理对象。2.JDK和Cglib都是在运行期生成字节码，JDK是直接写Class字节码，Cglib使用ASM框架写Class字节码，Cglib代理实现更复杂，生成代理类比JDK效率低。3.JDK调用代理方法，是通过反射机制调用，Cglib是通过FastClass机制直接调用方法，Cglib执行效率更高。
【动态代理】—— JDK和cglib的动态代理
1+1=王的博客
03-19 3946
概述 设计模式中有一个代理模式，它为其他对象提供一种代理以控制对这个对象的访问。 关于代理模式可以参考：【每天一个java设计模式（七）】 - 代理模式：https://blog.csdn.net/weixin_43598687/article/details/122072282 代理模式是指的静态代理。使用静态代理很容易就完成了对一个类的代理操作。但是静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。 而动态代理可以在程序运行期间，在不修改源
Java静态与动态代理对比：JDK+CGLIB+AspectJ详解
本文将深入探讨Java中的三种代理模式：JDK动态代理、CGLIB代理和AspectJ代理，以便于理解和比较它们在实际开发中的应用和优缺点。首先，我们回顾代理模式的基本概念，它允许在不修改源代码的情况下增强对象的行为，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值