cglib动态代理分析

最新推荐文章于 2023-08-13 02:23:16 发布
最新推荐文章于 2023-08-13 02:23:16 发布
阅读量478 收藏
点赞数
分类专栏： 设计模式 文章标签： java proxy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ranxiaochuan1994/article/details/105350349
版权

cglib动态代理原理


#cglib动态代理使用流程

  1. 创建被代理对象
public class UserService {
    public void say(){
        System.out.println("我是一位用户");
    }
}
  1. 实现MethodInterceptor接口，在接口方法中增强被代理方法的功能：
public class MyInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("方法前置处理");
        Object o1 = methodProxy.invokeSuper(o, objects);
        System.out.println("方法后置处理");
        return o1;
    }
}
  1. 设置父类和回调对象：
public class Main {
    public static void main(String[] args) {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/ranxiaochuan/Desktop");
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(UserService.class);
        //设置回调对象
        enhancer.setCallback(new MyInterceptor());
        //创建代理对象
        UserService userService = (UserService) enhancer.create();
        userService.say();
    }
}

代理对象源码分析

  以下代码由cglib动态代理生成的代理对象的class文件反编译而来：

public class UserService$$EnhancerByCGLIB$$ce4eb3fd extends UserService 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$say$0$Method;
    private static final MethodProxy CGLIB$say$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.dynamicProxy.cglib.UserService$$EnhancerByCGLIB$$ce4eb3fd");
        Class var1;
        //获取Object超类的四个方法对象
        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];
        //生成equals方法的MethodProxy对象
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        //生成toString方法的MethodProxy对象
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        //生成hashCode方法的MethodProxy对象
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        //生成clone方法的MethodProxy对象
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
        //获取被代理类的say(）方法对象
        CGLIB$say$0$Method = ReflectUtils.findMethods(new String[]{"say", "()V"}, (var1 = Class.forName("com.dynamicProxy.cglib.UserService")).getDeclaredMethods())[0];
        //生成say方法的MethodProxy对象
        CGLIB$say$0$Proxy = MethodProxy.create(var1, var0, "()V", "say", "CGLIB$say$0");
    }
	//代理对象为父类每一个非final方法生成一个方法，在该方法内直接调用父类的对应方法,此方法对应父类的say方法
    final void CGLIB$say$0() {
        super.say();
    }
	//子类say方法
    public final void say() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
		//判断方法拦截器是否为空
        if (var10000 != null) {
        	//调用方法拦截器的intercept方法，传入对应方法的MethodProxy对象和方法参数，便完成了方法代理
            var10000.intercept(this, CGLIB$say$0$Method, CGLIB$emptyArgs, CGLIB$say$0$Proxy);
        } else {
            super.say();
        }
    }

    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 -909388886:
            if (var10000.equals("say()V")) {
                return CGLIB$say$0$Proxy;
            }
            break;
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$4$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 UserService$$EnhancerByCGLIB$$ce4eb3fd() {
        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) {
        UserService$$EnhancerByCGLIB$$ce4eb3fd var1 = (UserService$$EnhancerByCGLIB$$ce4eb3fd)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);
        UserService$$EnhancerByCGLIB$$ce4eb3fd var10000 = new UserService$$EnhancerByCGLIB$$ce4eb3fd();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

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

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

  MethodProxy对象分析。

//c1:被代理类	c2:代理类	desc：描述	name:父类方法名	name2:代理类对象调用分类方法的方法名
public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
        MethodProxy proxy = new MethodProxy();
        proxy.sig1 = new Signature(name1, desc);
        proxy.sig2 = new Signature(name2, desc);
        proxy.createInfo = new MethodProxy.CreateInfo(c1, c2);
        return proxy;
    }

  cglib动态代理不但可以代理类，还可以代理接口，spring方法注入就是使用的cglib动态代理

ranxiaochuan1994
关注
专栏目录
深入理解动态代理：JDK动态代理与CGLIB动态代理
qq_40254606的博客
06-28 950
动态代理是一种在运行时创建代理对象的技术，通过代理对象来控制对原对象的访问，能够在不修改原对象的情况下添加额外的功能。JDK动态代理：基于Java反射机制，只能代理实现了接口的类。CGLIB动态代理：基于字节码生成技术，可以代理没有实现接口的类。// 抽象主题接口动态代理在Java中提供了一种灵活而强大的机制，能够在运行时为目标对象添加额外的功能。JDK动态代理和CGLIB动态代理各有优势和适用场景，开发者可以根据具体需求选择合适的代理机制。希望这篇文章对你理解动态代理有所帮助。
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
热门推荐
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
CGLIB源码易懂解析
m0_48333563的博客
08-08 1346
博主亲身实践，细嚼慢咽，提供了赌代码方式读代码，通俗易懂。如有指教，敬请提出！！！
CGLIB原理简析-前篇
最新发布
Pl_Sun的博客
08-13 420
回到最初的问题，当我们调用代理对象的对应方法时如何实现代理的？我们先回顾下JDK动态代理。JDK动态代理也是会生成并实例化一个代理类，该代理类继承的父类为Proxy类，且实现了接口下的所有方法。同样的，因为是运行时生成的代理类，代理对象一定是通过接口引用的多态对象存在。当代理对象调用任何接口方法时，其内部逻辑都会调用InvocationHandler对象(仅一个)的invoke方法进行调用。因此，使用者可以自定义InvocationHandler对象，在invoke方法中实现对指定对象的代理。
cglib动态代理原理分析（含部分源码分析）
m0_46356310的博客
05-28 576
cglib动态代理 给出一个例子，再做分析 目标类 public class AliSmsService { public String send(String message) { System.out.println("send message:" + message); return message; } } 实现一个 MothodInterceptor ，实现intercept方法，用做代理 public class DebugM
Cglib Callback使用、如何进行反编译
肃林的博客
01-14 509
Cglib Callback使用、反编译
从源码角度理解Cglib动态代理
李哈zzz的博客
03-20 1279
Cglib是什么？ 生成动态子类以启用方法拦截。此类开始是作为 JDK 1.3 中包含的标准动态代理支持的替代品，但它允许代理扩展具体的基类，除了实现接口。动态生成的子类覆盖超类的非最终方法，并具有回调到用户定义的拦截器实现的钩子——来自源码中注释的翻译 简单的来说就是可以对接口或者类做一个代理，我们知道动态代理是肯定要操作字节码的，Cglib底层使用ASM技术来操作字节码文件，他是一个更轻量级的框架来操作字节码，但是使用起来非常的复杂，所以Cglib也是帮你封装了复杂的操作，让用户直接使用API实
Cglib 动态代理
Fekerkk的博客
01-18 377
***cglib动态代理***和***jdk动态代理***都是在java运行过程中动态生成新的类，cglib是利用新生成的代理类来继承委托类，因为继承可以在代理类内拥有委托类的非private和非final方法，这样就达到了代理委托类去执行； 首先，要引进依赖 <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version&gt
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理） Java 动态代理是 Java 编程语言中的一种强大工具，广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...
JDK动态代理和Cglib动态代理实例源码
01-04
通过分析`DynamicProxyTest`源码，我们可以更深入地理解JDK和Cglib动态代理的工作原理，以及它们在实际应用中的用法。动态代理在AOP（面向切面编程）、缓存、日志记录、事务管理等多个场景中都有广泛应用，是Java...
CGLIB生成的代理类详解
yygr的博客
03-25 1759
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 pub
CGLIB代理使用与原理详解
小小默：进无止境
08-26 5263
JDK中提供的生成动态代理类的机制有个鲜明的特点是：某个类必须有实现的接口，而生成的代理类也只能代理某个类接口定义的方法。 那么如果一个类没有实现接口怎么办呢？ 这就有CGLIB的诞生了,前面说的JDK的动态代理的实现方式是实现相关的接口成为接口的实现类,那么我们自然可以想到用继承的方式实现相关的代理类。 【1】CGLIB简单实现 ① pom依赖如下 &amp;amp;amp;amp;amp;amp;amp;lt;!-- https://...
CGLIB动态代理--实例/原理
IT利刃出鞘的博客
02-13 2272
本文用示例介绍CGLIB动态代理的用法。
cglib原理解析
03-29 2340
先放上示例代码： //Person.java public class Person { public void sayHello() { System.out.println("Hello!"); } } //Test.java import org.objectweb.asm.ClassWriter; import net.sf.cglib.proxy....
【Spring基础】CGLIB动态代理实现原理
yhl_jxy的博客
06-09 8万+
前言 Github：https://github.com/yihonglei/thinking-in-spring 一 CGLIB介绍 CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库， 它可以在运行期扩展Java类与实现Java接口。Hibernate用它来实现PO(Persistent Object 持久化对象)...
基于cglib的接口代理和非接口代理的区别
tqy的博客
05-01 7422
这是目录jdk动态代理cglib动态代理cglib代理接口cglib代理实现类对比源码版权所有 jdk动态代理 jdk动态代理只可以代理接口，因为最后的实现类要继承Proxy并实现该接口 cglib动态代理 cglib既可代理接口又可以代理实现类，那背后的源码是如何实现的呢？ cglib代理接口 接口代码 package com.tqy.document.reader.extention.de...
CGLib动态代理原理
秋夫人
01-07 4837
CGLib动态代理原理 CGLib动态代理是代理类去继承目标类，然后重写其中目标类的方法啊，这样也可以保证代理类拥有目标类的同名方法； 看一下CGLib的基本结构，下图所示，代理类去继承目标类，每次调用代理类的方法都会被方法拦截器拦截，在拦截器中才是调用目标类的该方法的逻辑，结构还是一目了然的； 1.CGLib的基本使用 使用一下CGLib，在JDK动态代理中提供一个Proxy类来创建代理类，而在CGLib动态代理中也提供了一个类似的类Enhancer； 使用的CGLib版本是2.2.2，我是随便找的，不
CgLib动态代理学习【Spring AOP基础之一】
aai7747的博客
08-16 230
　　如果不了解JDK中proxy动态代理机制的可以先查看上篇文章的内容：Java动态代理学习【Spring AOP基础之一】 　　由于Java动态代理Proxy.newProxyInstance()的时候会发现其参数类型是ClassLoader classLoader, Class<?>[] interface, InvocationHandler handler， 只支持...
什么是CGLib动态代理
06-07
CGLib动态代理的实现依赖于ASM（一个轻量级的Java字节码操作和分析库），通过ASM可以对字节码进行操作，并生成代理类。使用CGLib动态代理可以避免手动编写大量代理类的工作，同时也可以提高代码的可重用性和灵活性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值