动态代理原理解析 (二)：cglib

最新推荐文章于 2023-07-06 15:33:18 发布
最新推荐文章于 2023-07-06 15:33:18 发布
阅读量294 收藏
点赞数
分类专栏： 源码解析 文章标签： 代理模式 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45756124/article/details/122551092
版权

面对没有接口的类，可以使用基于cglib的动态代理，对于final方法无法代理。

cglib的底层是使用字节码处理框架asm操纵字节码生成代理类,操纵的级别是底层JVM的汇编指令级别。

使用案例：

<dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.2</version>
        </dependency>

public class CglibTest {
    public static void main(String[] args) {
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D://");
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(PlayGame.class);
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println("before method run...");
                Object result = proxy.invokeSuper(obj, args);
                System.out.println("after method run...");
                return result;
            }
        });
        PlayGame sample = (PlayGame) enhancer.create();
        sample.say("hahha");
    }
}

如同Proxy，上述代码同时也生成另一个Class文件：CglibTest$1.class，实现MethodInterceptor接口。

原理

其实和Proxy的原理类似，但不同于Proxy代理类继承的是Proxy,用cglib生成的代理类继承的是被代理类，实现的是Factory接口。

我们可以在代码前加上System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D://");即可以在指定位置生成代理类。它会生成三个class文件：

在这里插入图片描述
从上到下依次是1.代理类的fastclass 2.代理类 3.被代理类的fastclass
查看代理类反编译的代码：

public class PlayGame$$EnhancerByCGLIB$$74aa30cd extends PlayGame 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$say$0$Method;
    private static final MethodProxy CGLIB$say$0$Proxy;
    ............
	//最底下静态代码块调用这个方法初始化
    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.baiye.proxy.PlayGame$$EnhancerByCGLIB$$74aa30cd");
        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$say$0$Method = ReflectUtils.findMethods(new String[]{"say", "(Ljava/lang/String;)V"}, (var1 = Class.forName("com.baiye.proxy.PlayGame")).getDeclaredMethods())[0];
        CGLIB$say$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)V", "say", "CGLIB$say$0");
    }

    final void CGLIB$say$0(String var1) {
        super.say(var1);
    }

    public final void say(String var1) {
        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$say$0$Method, new Object[]{var1}, CGLIB$say$0$Proxy);
        } else {
            super.say(var1);
        }
    }
   }
public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -1853413644:
            if (var10000.equals("say(Ljava/lang/String;)V")) {
                return CGLIB$say$0$Proxy;
            }
            break;
        case -1574182249:
            if (var10000.equals("finalize()V")) {
                return CGLIB$finalize$1$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 PlayGame$$EnhancerByCGLIB$$74aa30cd() {
        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) {
        PlayGame$$EnhancerByCGLIB$$74aa30cd var1 = (PlayGame$$EnhancerByCGLIB$$74aa30cd)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(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        PlayGame$$EnhancerByCGLIB$$74aa30cd var10000 = new PlayGame$$EnhancerByCGLIB$$74aa30cd;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
            return var10000;
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }

    .....

    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();
    }

代理类会获得所有在父类继承来的方法，其中private MethodInterceptor CGLIB$CALLBACK_0;属性是关键，代理类持有它然后调用var10000.intercept(this, CGLIB$say$0$Method, new Object[]{var1}, CGLIB$say$0$Proxy);通过fastclass文件确定方法。

被代理类的class反编译：

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

package com.baiye.proxy;

import java.lang.reflect.InvocationTargetException;
import net.sf.cglib.core.Signature;
import net.sf.cglib.reflect.FastClass;

public class PlayGame$$FastClassByCGLIB$$5f92a78b extends FastClass {
    public PlayGame$$FastClassByCGLIB$$5f92a78b(Class var1) {
        super(var1);
    }

    public int getIndex(Signature var1) {
        String var10000 = var1.toString();
        switch(var10000.hashCode()) {
        case -1853413644:
            if (var10000.equals("say(Ljava/lang/String;)V")) {
                return 0;
            }
            break;
        。。。。。。
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return 6;
            }
        }

        return -1;
    }

    public int getIndex(String var1, Class[] var2) {
        switch(var1.hashCode()) {
        case -1776922004:
            if (var1.equals("toString")) {
                switch(var2.length) {
                case 0:
                    return 5;
                }
            }
            break;
       。。。。。
        case 113643:
            if (var1.equals("say")) {
                switch(var2.length) {
                case 1:
                    if (var2[0].getName().equals("java.lang.String")) {
                        return 0;
                    }
                }
            }
            break;
        。。。。。。
        case 1950568386:
            if (var1.equals("getClass")) {
                switch(var2.length) {
                case 0:
                    return 7;
                }
            }
        }

        return -1;
    }

    public int getIndex(Class[] var1) {
        switch(var1.length) {
        case 0:
            return 0;
        default:
            return -1;
        }
    }

    public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
        PlayGame var10000 = (PlayGame)var2;
        int var10001 = var1;

        try {
            switch(var10001) {
            case 0:
                var10000.say((String)var3[0]);
                return null;
            case 1:
                var10000.wait();
                return null;
            。。。。。。
            case 9:
                var10000.notifyAll();
                return null;
            }
        } catch (Throwable var4) {
            throw new InvocationTargetException(var4);
        }

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

    public Object newInstance(int var1, Object[] var2) throws InvocationTargetException {
        PlayGame var10000 = new PlayGame;
        PlayGame var10001 = var10000;
        int var10002 = var1;

        try {
            switch(var10002) {
            case 0:
                var10001.<init>();
                return var10000;
            }
        } catch (Throwable var3) {
            throw new InvocationTargetException(var3);
        }

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

    public int getMaxIndex() {
        return 9;
    }
}

代理类的class反编译和它差不多代码过多，不在展示。

通过观察其他两个FastClass文件可以知道，通过方法索引我们可以匹配到想要的方法并且调用，而不需要像 JDK 动态代理一样通过反射的方式调用，极大提高了执行效率。它的原理简单来说就是：为代理类和被代理类各生成一个Class，这个Class会为代理类或被代理类的方法分配一个index(int类型)。
这个index当做一个入参，FastClass就可以直接定位要调用的方法直接进行调用，这样省去了反射调用，所以调用效率比JDK动态代理通过反射调用高。

JDK动态代理和Gglib动态代理的区别：
1.JDK动态代理是实现了被代理对象的接口，Cglib是继承了被代理对象。
2.JDK和Cglib都是在运行期生成字节码，JDK是直接写Class字节码，Cglib使用ASM框架写Class字节码，Cglib代理实现更复杂，生成代理类比JDK效率低。
3.JDK调用代理方法，是通过反射机制调用，Cglib是通过FastClass机制直接调用方法，Cglib执行效率更高。

参考：https://www.cnblogs.com/monkey0307/p/8328821.html

白夜的Alice
关注
专栏目录
cglib 动态代理原理详解
u012094957的专栏
11-03 1088
cglib 动态代理详解 我们都知道jdk的动态代理内部调用切面无效的问题，而cglib则不会出现这种情况，这是为什么？cglib就一定不会出现内部调用切面无效的问题吗？cglib针对每一个类只创建了一个代理类吗？为什么cglib的效率要比jdk的动态代理低呢？ 首先我们看一下通常我们是如何使用cglib增强一个类的 public class Main { static class Test{ public void test(){ System.out.pr
JDK和CGLIB动态代理原理
m0_38033199的博客
07-27 1340
JDK和CGLIB动态代理原理解析
CGLib动态代理详解
艾利克斯冰的博客
06-29 1144
CGLib动态代理 　　上一篇我们说过了jdk动态代理，这一篇我们来看看CgLib动态代理，本来以为CGLib动态代理和JDK实现的方式差不多的，但是仔细了解一下之后还是有很大的差异的，这里我们先简单说一下这两种代理方式最大的区别，JDK动态代理是基于接口的方式，换句话来说就是代理类和目标类都实现同一个接口，那么代理类和目标类的方法名就一样了，这种方式上一篇说过了；CGLib动态代理是代理类去继承目标类，然后重写其中目标类的方法啊，这样也可以保证代理类拥有目标类的同名方法； 　　看一下CGL...
Cglib动态代理详解
Saltwater_leo的专栏
12-15 1433
Cglib动态代理  JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。 示例 ： 1、BookFacadeCglib.java package net.battier.dao;
CGLIB动态代理模式详解
Dream_it_possible！的博客
11-20 2302
此文章介绍的是动态代理模式中的CGLIB代理模式，此模式与jdk动态代理模式的区别是: 目标代理类不需要实现接口，同样也可以实现代理。 直接看一个简单的cglib应用，看他是如何实现代理的。 第一步，新建一个maven项目，并引入cglib依赖: <dependency> <groupId>cglib</gro...
CGLIB动态代理详解分析
weixin_43397326的博客
07-06 6079
CGLIB是强大的、高性能的代码生成库，被广泛应用于AOP框架，它底层使用ASM来操作字节码生成新的类，为对象引入间接级别，以控制对象的访问。CGLIB相比于JDK动态代理更加强大，JDK动态代理只能对接口进行代理，而CGLIB既可以代理普通类，也能够代理接口。
转载：cglib动态代理介绍(一)
08-10
### 动态代理原理 动态代理是一种编程技术，允许在运行时创建一个实现了特定接口的新类。在Java中，有两种主要的动态代理方式：JDK的`java.lang.reflect.Proxy`和第三方库如CGlib。JDK的Proxy需要目标类实现至少一个...
【Cglib Nodep基础篇】：Cglib动态代理技术深度解析与实践
[【Cglib Nodep基础篇】：Cglib动态代理技术深度解析与实践](https://gmoon92.github.io/md/img/aop/jdk-dynamic-proxy-and-cglib/cglib1.png) # 1. Cglib动态代理技术概述 在现代软件开发中，动态代理是提高系统...
Java 动态代理原理图解 (附：2种实现方式详细对比)
mikechen的互联网架构
10-31 2177
​动态代理在 Java 中有着广泛的应用，例如：Spring AOP 面向切面编程，Hibernate 数据查询、以及 RPC Dubbo 远程调用等，都有非常多的实际应用。本文深入：Java 动态代理原理、JDK 原生动态代理、CGLib 动态代理实现、JDK 动态代理与 CGLib 的区别​。
cglib代理模式要使用的相关jar包
最新发布
08-02
以上就是CGLIB代理模式的基本原理和使用方法。CGLIB的动态代理在很多场景下都非常实用，例如在AOP框架中拦截方法执行，进行日志记录、性能监控、事务管理等。然而，由于CGLIB是基于继承的，所以如果目标类为final...
cglib动态代理介绍
04-19
NULL 博文链接：https://agileshell.iteye.com/blog/1857897
CGlib实现动态代理(承接上面JDK实现动态代理)
03-18
NULL 博文链接：https://gz383.iteye.com/blog/591079
动态代理中clig包（Cglib代理模式）.zip
05-01
Cglib代理模式实现步骤 1) 需要引入cglib的jar文件 2) 在内存中动态构建子类，注意代理的类不能为final，否则报错 java.lang.IllegalArgumentException: 3) 目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的 业务方法.
cglib动态代理
huangwei18351的博客
10-05 1514
Cglib动态代理 具体类对象 package cn.huangwei.classLoader.Proxy; public class CglibService {     public CglibService(){        System.out.println("CglibService构造器");     }     public v...
【设计模式】代理模式之CGLIB动态代理（案例详解）
辰兮要努力
10-25 1738
【辰兮要努力】：hello你好我是辰兮，很高兴你能来阅读，昵称是希望自己能不断精进，向着优秀程序员前行！ 博客来源于项目以及编程中遇到的问题总结，偶尔会有读书分享，我会陆续更新Java前端、后台、数据库、项目案例等相关知识点总结，感谢你的阅读和关注，希望我的博客能帮助到更多的人，分享获取新知，大家一起进步! 吾等采石之人，应怀大教堂之心，愿大家奔赴在各自的热爱里… 文章目录一、初识代理模式二、代码案例学习三、断点深入探究 一、初识代理模式 关于jdk的动态代理和cglib的动态代理，我会通过两篇文.
cglib动态代理实现原理详细分析
南瓜灯cc
01-13 3722
在之前Java代理模式中大致的分析了下代理模式的类型及对每种代理类型简单的举例了下。在上篇JDK动态代理实现原理详细分析中，对其JDK代理的流程做了一个详细的分析。而本文，将介绍另一种动态代理模式:cglib动态代理。阅读完本文，你将对cglib代理模式的运行的流程有一个清晰的认识。 本文的目录如下: 目录 一:cglib动态代理的样例展示 二:cglib生成的代理类的分析 三:cgli...
【Java深入研究】6、CGLib动态代理机制详解
weixin_33868027的博客
08-03 41
一、首先说一下JDK中的动态代理： JDK中的动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的 但是，JDK中所要进行动态代理的类必须要实现一个接口，也就是说只能对该类所实现接口中定义的方法进行代理，这在实际编程中具有一定的局限性，而且使用反射的效率也并不是很高。 二、使用CGLib实现： 使用CGLib实现动态代理，完全不受代理类必须实现接口的限制，而且CGLi...
动态代理：Cglib原理讲解
猪大肠的博客
12-11 1209
Cglib动态代理不需要被代理类实现接口，根据原理我们知道生成的代理类是继承了被代理类，而且其方法调用方法是使用FastClass，这与JDK动态代理的反射有比较大的区别。JDK代理使用的是反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。CGLIB代理使用字节码处理框架ASM，对代理对象类的class文件加载进来，通过修改字节码生成子类。JDK创建代理对象效率较高，执行效率较低；CGLIB创建代理对象效率较低，执行效率高。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值