jdk动态代理&cglb动态代理到底生成了啥（二）

最新推荐文章于 2024-08-05 07:30:00 发布
最新推荐文章于 2024-08-05 07:30:00 发布
阅读量326 收藏 1
点赞数 2
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yeluowan/article/details/127742362
版权

2.cglb动态代理是基于代理类生成其子类来实现的.

首先看这个被代理类,接下来需要对study方法进行逻辑增强

public class Tom {

    String stduy(String name){
        System.out.println("原生方法");
        return name;
    }
}

 实现接口MethodInterceptor在intercept中完成逻辑的增强,

public class MyMethodInterceptor implements MethodInterceptor {

    /**
     * 代理对象会调用此方法
     * @param o 代理的对象.
     * @param method 被代理对象执行的方法
     * @param objects 被代理的对象的方法入参
     * @param methodProxy
     * @return 返回值就是被代理方法执行后的返回值.这里必须要返回.否则原生方法执行完后没有返回值
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println(method.getName());
        //执行被代理的方法
        System.out.println("原生方法执行前");
        Object invoke = methodProxy.invokeSuper(o, objects);
        System.out.println("原生方法执行后");
        return invoke ;
    }
}

 代理工厂,用于获取代理类的对象.

public class CglbFactroy<T> {


    public T getProxy(T o){
        Enhancer enhancer = new Enhancer();
        //设置方法拦截.即方法增强的逻辑
        enhancer.setCallback(new MyMethodInterceptor());
        //设置谁需要被代理
        enhancer.setSuperclass(o.getClass());
        //创建一个代理对象并且返回
        return (T)enhancer.create();
    }
}

测试:

这里面加了一段代码

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"d://cglb_classes");

这样的话我们就可以去指定位置查看到cglb到底生成了个啥.

public class Test {
    public static void main(String[] args) {
        //设置源码的位置,可以看到代理类的生成情况
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"d://cglb_classes");
        Tom tom = new Tom();
        CglbFactroy<Tom> tomCglbFactroy = new CglbFactroy<>();
        Tom proxy = tomCglbFactroy.getProxy(tom);
        proxy.stduy("name");
    }
}

执行后去d盘查看:

注意这里面可能会生成多个类,最后找到这个:

拖拽到idea打开:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package cglbProxy;

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

public class Tom$$EnhancerByCGLIB$$8bcc110c extends Tom 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$stduy$0$Method;
    private static final MethodProxy CGLIB$stduy$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("cglbProxy.Tom$$EnhancerByCGLIB$$8bcc110c");
        Class var1;
        CGLIB$stduy$0$Method = ReflectUtils.findMethods(new String[]{"stduy", "(Ljava/lang/String;)Ljava/lang/String;"}, (var1 = Class.forName("cglbProxy.Tom")).getDeclaredMethods())[0];
        CGLIB$stduy$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "stduy", "CGLIB$stduy$0");
        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");
    }

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

    public final String stduy(String var1) {
        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$stduy$0$Method, new Object[]{var1}, CGLIB$stduy$0$Proxy) : super.stduy(var1);
    }

    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 6566728:
            if (var10000.equals("stduy(Ljava/lang/String;)Ljava/lang/String;")) {
                return CGLIB$stduy$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 Tom$$EnhancerByCGLIB$$8bcc110c() {
        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) {
        Tom$$EnhancerByCGLIB$$8bcc110c var1 = (Tom$$EnhancerByCGLIB$$8bcc110c)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);
        Tom$$EnhancerByCGLIB$$8bcc110c var10000 = new Tom$$EnhancerByCGLIB$$8bcc110c();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

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

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        Tom$$EnhancerByCGLIB$$8bcc110c var10000 = new Tom$$EnhancerByCGLIB$$8bcc110c;
        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();
    }
}

可以看到这里是集成了Tom类的,并且重写了方法stduy:

    public final String stduy(String var1) {
        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$stduy$0$Method, new Object[]{var1}, CGLIB$stduy$0$Proxy) : super.stduy(var1);
    }

关键的一段代码:

(String)var10000.intercept(this, CGLIB$stduy$0$Method, new Object[]{var1}, CGLIB$stduy$0$Proxy)

这里就是在调用前面类

MyMethodInterceptor

中重写的方法.

至此就可以发现完整的代理类就出来了.细心的小伙伴发现了,如果方法是final修饰或者private修饰是不能被代理的哦

叶落湾湾
关注
深入理解动态代理：JDK动态代理与CGLIB动态代理
qq_40254606的博客
06-28 1080
动态代理是一种在运行时创建代理对象的技术，通过代理对象来控制对原对象的访问，能够在不修改原对象的情况下添加额外的功能。JDK动态代理：基于Java反射机制，只能代理实现了接口的类。CGLIB动态代理：基于字节码生成技术，可以代理没有实现接口的类。// 抽象主题接口动态代理在Java中提供了一种灵活而强大的机制，能够在运行时为目标对象添加额外的功能。JDK动态代理和CGLIB动态代理各有优势和适用场景，开发者可以根据具体需求选择合适的代理机制。希望这篇文章对你理解动态代理有所帮助。
【JVM与性能调优】JVM动态代理、JDK动态代理和CGLib动态代理傻傻分不清楚
本本本添哥
04-14 1291
JDK动态代理和CGLib动态代理都是Java中用于创建动态代理的方法，但它们的实现方式不同。
【动态代理】—— JDK和cglib的动态代理
1+1=王的博客
03-19 3985
概述 设计模式中有一个代理模式，它为其他对象提供一种代理以控制对这个对象的访问。 关于代理模式可以参考：【每天一个java设计模式（七）】 - 代理模式：https://blog.csdn.net/weixin_43598687/article/details/122072282 代理模式是指的静态代理。使用静态代理很容易就完成了对一个类的代理操作。但是静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。 而动态代理可以在程序运行期间，在不修改源
JDK动态代理与CGLib动态代理
最新发布
weixin_74261199的博客
08-05 2278
动态代理（Dynamic Proxy）是在程序运行时给目标对象创建代理对象，代理对象可以对方法进行增强、控制等。在生成代理对象的过程中，目标对象不变，代理对象中方法对目标对象方法进行增强。代理对象执行目标方法时会被拦截，转而调用写好的代理方法。JDK代理、CGLib代理。
jdk动态代理和cglb动态代理
一个菜鸡的博客
06-14 880
动态代理和静态代理都是代理模式的实现方式，其主要区别在于代理类生成的时机和方式。静态代理是在编译时就确定了代理类的代码，在程序运行前就已经存在了代理类的class文件。代理类与委托类的关系在编译时就已经确定，因此被称为静态代理。在静态代理中，代理类需要实现与委托类相同的接口或者继承委托类的父类，以便能够对委托类进行代理操作。动态代理是在程序运行时生成代理类的代码，代理类通过反射机制动态生成。动态代理不需要像静态代理一样实现与委托类相同的接口或继承委托类的父类，它可以实现任意接口。
jdk动态代理和cglib代理
weixin_39825906的博客
08-01 3238
SpringAOP在目标累实现接口的情况下，默认采用JDK的动态代理方式进行目标类的代理。基于CGLIB的动态代理，底层是利用ASM技术实现的，ASM动态生成目标类的子类的字节码。我们的目标类是Bus，他实现了接口Car，然后我们实现一个JdkDynamicProxyTest，JdkDynamicProxyTest持有Bus，在调用invok的时候，织入增强逻辑。CGLIB代理类代理类是目标类的子类，依赖CGLIB.JAR。cglib封装了asm，可以在运行期动态生成新的class。...
java动态代理：jdk动态代理和cglib动态代理
记录学习点滴
02-20 2882
java动态代理
动态代理（JDK+CGLIB ）
weixin_45134135的博客
04-17 1379
动态代理是一种在运行时生成代理类的技术，它允许在不知道具体接口或类的情况下创建代理对象，并在代理对象的方法执行前后插入额外的逻辑。在 Java 中，通常有两种动态代理的实现方式：基于 JDK 的动态代理和基于 CGLIB 的动态代理。
（Java面试）JDK 动态代理和 CGLIB 动态代理的区别是什么？
qq_46158352的博客
05-11 362
JDK动态代理和CGLIB动态代理都是Java中常用的实现动态代理的方式。它们各有优缺点，适用于不同的场景。如果被代理的类已经实现了接口，那么我们可以使用JDK动态代理；如果被代理的类没有实现接口，那么我们可以使用CGLIB动态代理。在实际开发中，我们需要根据具体的场景来选择最合适的动态代理实现方式。动态代理的应用场景非常广泛，比如AOP、RPC框架等。在AOP中，我们可以通过动态代理来实现对方法的拦截和增强，从而实现面向切面编程；在RPC框架中，我们可以通过动态代理来实现客户端和服务端之间的通信。
经典面试题 之 JDK动态代理和CGLIB动态代理
weixin_69413377的博客
08-02 1049
jdk动态代理只能为接口创建代理，使用上有局限性。实际的场景中我们的类不一定有接口，此时如果我们想为普通的类也实现代理功能，我们就需要用到cglib来实现了。cglib是一个强大、高性能的字节码生成库，它用于在运行时扩展Java类和实现接口；本质上它是通过动态的生成一个子类去覆盖所要代理的类（非final修饰的类和方法）。Enhancer可能是CGLIB中最常用的一个类，和jdk中的Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。......
慌了，老大突然问我基于JDK和CGLib实现动态代理的区别和适用场景
duan18888的博客
05-17 347
在日常的开发中，Spring AOP 是一个非常常用的功能。谈到 AOP，自然离不开动态代理。 那么，基于 JDK 和 CGLib 如何实现动态代理，他们之间的区别和适用场景是什么呢？接下来，我们一起来探讨一下这个问题。 JDK 如何实现动态代理？ 话不多说，我们直接对照着代码来查看。 代码示例 Hello 接口 public interface HelloInterface { /** * 代理的目标方法 */ void sayHello();
JDK动态代理与CGLIB动态代理
weixin_43529092的博客
04-02 3145
设计模式之代理模式 下面假设一个常见的场景，假如你有一个法国的朋友叫Aice，有一天你想要购买一瓶法国香奈儿的香水，这种香水只在法国销售。你找到你的朋友Alice，请求她帮忙购买一瓶香奈儿的香水，你的朋友Alice于是乎就找到香奈儿的销售店购买了一瓶法国香奈儿的香水，并将香水交给了你。 在上面这个例子当中，你想要购买法国香水，但是无法直接向香奈儿供应商购买，只能通过中间人(Alice)购买，这就是我们生活中比较常见的代理模式。我们假设有一天，你突然想要一瓶法国红酒，但是由于Alice本身并不具备购买红
JDK和CGLB动态代理机制分析
qq_38166592的博客
04-28 310
JDK动态的代理： 先来一个大致的机制介绍，后面是详细的： 生成一个代理类实现了被代理类的接口，代理类实现目标方法，方法中会调用InvocationHandler 实现类的invoke方法； 大家都会的无脑使用方式，简单写个demo 1、定义一个接口： package com.bijian.proxy; public interface UserService { void update(); } 2、定义一个实现 类 package com.bijian.proxy; public clas
【Java】万字解读Java的动态代理（JDK原生动态代理、CGLIB动态代理）
✈ 正在努力 の 寒江（StudiousTiger) ✌ 呐 ✈
02-22 4611
动态代理在Java中有着广泛的应用，比如 Spring AOP、RPC 远程调用、Java 注解对象获取、日志、用户鉴权、全局性异常处理、性能监控，甚至事务处理等。JDK原生动态代理和CGLIB 动态代理。
Cglib--动态代理
zekeTao的博客
04-10 271
一、SayHello/** * 被代理类，使用cglib可以不必实现接口 */ public class SayHello { public void say() { System.out.println("success"); } }二、Cglibimport org.springframework.cglib.proxy.Enhancer; import ...
Spring的两种代理JDK和CGLIB的区别浅谈
tbdp6411的专栏
11-30 409
一、原理区别： java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。 而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。 1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP  2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP 
JDK和CGLIB动态代理
qq_51470789的博客
12-03 1008
JDK和CGLIB动态代理
CGlib 动态代理
ZTM2020的博客
12-04 144
CGlib 动态代理 Boy.java public class Boy { private int age; private String name; public void eat() { System.out.println("I am eating "); } public void playGame() { System.out.println("I am playing games"); } public void playGame(String game) {
深入解析JDK动态代理机制
Java动态代理是Java标准库（JDK）提供的一种机制，允许在运行时创建代理对象，这些代理对象可以作为原对象的“代理”，在调用原对象的方法时进行额外的操作。这种方式通常用于AOP（面向切面编程）或者实现事件监听器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值