Cglib源码分析

做个有趣的IT Man~

已于 2024-03-06 16:48:16 修改

阅读量713

点赞数 26

分类专栏： Java 文章标签： java jdk 源代码管理代理模式

于 2024-02-28 10:26:20 首次发布

本文链接：https://blog.csdn.net/weixin_43900726/article/details/136213521

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言
一、debugger源码
三、生成的代理文件分析

前言

1.Cglib动态代理是基于ASM字节码框架+FastClass机制针对类实现代理（无需接口实现），而JDK动态代理必须实现接口生成代理类
2.有关JDK动态代理源码分析就点击链接超简单的JDK动态代理源码分析

一、debugger源码

1.需要创建的类

被代理的类 People.java

package com.yl.spring.beandefinitionregistry.support.cglib;

public class People  {
    public void A() {
        System.out.println("这是A方法--");
    }

    public String B(int i) {
        System.out.println("执行了B()方法");
        return "这是B()方法. "+i;
    }
}

拦截器 MyCglib.java

package com.yl.spring.beandefinitionregistry.support.cglib;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class MyCglib 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;
    }
}

测试类 TestCgclib.java

package com.yl.spring.beandefinitionregistry.support.cglib;

import org.springframework.cglib.core.DebuggingClassWriter;
import org.springframework.cglib.proxy.Enhancer;

public class TestCgclib {
    public static void main(String[] args) {
        /** 动态代理创建的字节码文件存储到本地 */
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "com.yl.spring.beandefinitionregistry.support.cglib");
        /** 通过cg11b动态代理获取代理对象的过程，创建调用的对象 */
        Enhancer enhancer = new Enhancer();
        /** 设置enhancer对象的父类 */
        enhancer.setSuperclass(People.class);
        /** 设置enhancer的回调对象 */
        enhancer.setCallback(new MyCglib());
        /** 创建代理对象 */
        People people = (People) enhancer.create();
        /** 通过代理对象调用目标方法 */
        people.B(999);
        System.out.println(people.getClass());

    }
}

2.debug跟读源码

红点debug启动
在这里插入图片描述

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "com.yl.spring.beandefinitionregistry.support.cglib")

这段代码表示最终生成代理文件的地址，例如跑完后本地生成的：
在这里插入图片描述
继续下一步：

step into进入这个方法

AbstractClassGenerator是Enhancer的父类，现在是在初始化创建一些变量，继续debugger往下走到Enhancer类：

进入Enhancer类了，继续执行到 private static final EnhancerKey KEY_FACTORY =
(EnhancerKey) KeyFactory.create(EnhancerKey.class, KeyFactory.HASH_ASM_TYPE, null);
在这里插入图片描述
这里到了**关键知识点**了，这是一个创建代理类的过程，其中KeyFactory.HASH_ASM_TYPE 是自定义哈希码的生成的一个回调函数，现在还不会触发，先执行的是 KeyFactory.create 方法，然后在创建的对象中调用 customize 方法
我们可以先浏览哈KeyFactory.HASH_ASM_TYPE代码内部：
在这里插入图片描述
继续往下看直到：

我们看到了visitMethodInsn方法，这是啥，是ASM框架动态生成class的方法；有些小伙伴们有点迷糊“基于ASM框架”怎么动态生成，我这里简单给一个使用ASM 框架写一个“HelloWorld”的例子（要了解更多可以自行去百度一下）

原HelloWorld.java

public class HelloWorld{
    public static void main(){
        System.out.println("HelloWorld!");
    }
}

ASM动态生成的HelloWorld

import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;


public class HelloWorldByAsm {
    
    public static void main(String[] args) throws Exception {
        // 生成二进制字节码
        byte[] bytes = generate();
        // 使用自定义的ClassLoader
        MyClassLoader cl = new MyClassLoader();
        // 加载我们生成的 HelloWorld 类
        Class<?> clazz = cl.defineClass("com.dadiyang.asm.HelloWorld", bytes);
        // 反射获取 main 方法
        Method main = clazz.getMethod("main", String[].class);
        // 调用 main 方法
        main.invoke(null, new Object[]{new String[]{}});
    }

    private static byte[] generate() {
        ClassWriter cw = new ClassWriter(0);
        // 定义对象头：版本号、修饰符、全类名、签名、父类、实现的接口
        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "com/dadiyang/asm/HelloWorld",
                null, "java/lang/Object", null);
        // 添加方法：修饰符、方法名、描述符、签名、抛出的异常
        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, "main",
                "([Ljava/lang/String;)V", null, null);
        // 执行指令：获取静态属性
        mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        // 加载常量 load constant
        mv.visitLdcInsn("HelloWorld!");
        // 调用方法
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        // 返回
        mv.visitInsn(Opcodes.RETURN);
        // 设置栈大小和局部变量表大小
        mv.visitMaxs(2, 1);
        // 方法结束
        mv.visitEnd();
        // 类完成
        cw.visitEnd();
        // 生成字节数组
        return cw.toByteArray();
    }
}
/**
 * 自定义ClassLoader以支持加载字节数组形式的字节码
 */
class MyClassLoader extends ClassLoader {
    public Class<?> defineClass(String name, byte[] b) {
        // ClassLoader是个抽象类，而ClassLoader.defineClass 方法是protected的
        // 所以我们需要定义一个子类将这个方法暴露出来
        return super.defineClass(name, b, 0, b.length);
    }
}

最终工作台会输出一个“HelloWorld”字符，具体ASM动态生成代码小伙伴们可以自行去研究，这里我就不多叙述了

打住，回到我们源码
最终 KEY_FACTORY变量是长这样例如：Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f，
大致解释就是：通过CGLIB技术KeyFactory工厂类创建了Enhancer里内部类EnhancerKey的一个代理类；
继续step into →KeyFactory.create方法
在这里插入图片描述
这里是创建一个代理生成器Generator，后续是设置接口类型、设置hashcode哈希码定制器（前面传过来的）、设置类加载器，然后我们进入到gen.create()，

step into：

继续进入(KeyFactory) super.create(keyInterface.getName())：
在这里插入图片描述

前面的准备工作都做完了，真正创建过程现在开始了：
先看看这个 CACHE 是啥：

CACHE 就是一个WeakHashMap类，看看下面几行红框代码做了什么操作：

这里这个loader叫“Launcher$AppClassLoader@507”,就是最开始前面代码 keyInterface.getClassLoader() 那个方法的loader
在这里插入图片描述
我们细追一下data = new ClassLoaderData(loader);

step into 进去，来到了 GET_KEY 变量初始位置：

我们能看到GET_KEY 是一个Function类型函数式接口，返回的是gen.key,我们查看哈这个gen.key中的key是个啥：

还记得我们前面创建的Generator gen = new Generator(); 这个gen对象不，其实（public static class Generator extends AbstractClassGenerator）就是AbstractClassGenerator 的子类，我们其实大致可以猜测出来了这个key就是我们之前创建的那个key（最终其实就是代理类的类对象）：
在这里插入图片描述
继续再跟进data = new ClassLoaderData(loader); 代码，还没走完，继续step into走到下一步进入ClassLoaderData的构造方法中：

先判断classLoader，若为null则抛异常；反之给通过WeakReference给classLoader弱引用化，这里顺带提一句强引用、软引用、弱引用、虚引用

强引用（=）：关系存在，即不会被垃圾回收机制回收（内存溢出抛异常也不会回收）
软引用（SoftReference）：内存不够会被回收（回收后仍然OOM才会抛异常）
弱引用（WeakReference）：无论内存够不够，垃圾收集器一工作就会被回收
虚引用（PhantomReference）：约等于没有引用关系（甚至无法通过虚引用获取到对象实例），只是会在被回收后发送一条系统通知

回到正轨，继续看代码，后面先创建了load的Function函数，里面的逻辑我们后续回回调回来，请暂时记住这里；
最后generatedClasses = new LoadingCache<AbstractClassGenerator, Object, Object>(GET_KEY, load); 这里 GET_KEY 和load 都是Function函数，GET_KEY就是上一步创建的，把这两个函数变量放入LoadingCache缓存里面，看看LoadingCache构造器里面是啥：
图

LoadingCache

在这里插入图片描述
好了，data = new ClassLoaderData(loader);暂时就走完了，我们再次回到

接下来就是把前面创建的loader、data放入CACHE缓存中，

继续往下走：

进入这个data.get(this, getUseCache())方法：

这里useCache=true，所以直接走最后两行：
在这里插入图片描述
我们再回顾一下这个gen对象，有key，类加载器、定制器等等：

step into进入这个方法：

看到这个this.keyMapper.apply(key)，还记得我们之前创建的LoadingCache没，我们再回顾哈，

看出端倪没，这个 keyMapper其实就是之前 GET_KEY的Function函数，我们step into 这行代码：KK cacheKey = this.keyMapper.apply(key);
在这里插入图片描述
果然进入到了我们猜想的GET_KEY的Function函数中获取了key，继续往下跟进：

这个map从始至终没用过，所以获取的 v 肯定是 null，根据代码逻辑vnull，肯定走后面的this.createEntry(key, cacheKey, v) ：

图中逻辑很容易看懂，创建了一个叫task的函数，this.map里面肯定没有缓存，所以result等于null，就会调用task.run();方法，当然就走到了图中红箭头指向的函数方法体里面；注意这个LoadingCache.this.loader.apply(key);中的loader==，大家应该猜到也是我们前面创建的Function函数：
在这里插入图片描述

step into：

果然来到了我们的Function函数：一看
Class klass = gen.generate(ClassLoaderData.this);这行代码大家大概猜测到没，没错这就是创建字节码的方法；step into ：

这里是将之前生成的代理类图中的this 放入CURRENT中， CURRENT是一个ThreadLocal变量
在这里插入图片描述
继续向下进行：
获取了类加载器classLoader，然后准备生成需要代理类的名称：

step into进去看源码：
在这里插入图片描述
最终返回

org.springframework.cglib.proxy.Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f

这样的格式，大致解释哈名称的含义，由KeyFactory工厂类通过CGLIB技术创建了一个Enhancer中内部类（接口）EnhancerKey的代理类。
继续往下走：
在这里插入图片描述
这里就是准备用ASM字节码框架生成代理类的字节了，我们一起step into 看看里面:

step into:

我们可以看到这些语法就是基于ASM操作字节码创建代理类的一些语法，
图-字节码
在这里插入图片描述
后面就是创建代理类其他的过程（如写入变量， hashcode()、equals()、toString()方法啊等等）我们这里就不一一细说了，前面我们也给大家举了例子ASM手动创建一个HelloWord的程序，想要研究ASM操作字节码的java语法自行查找资料学习
1、大家可能在阅读源码过程中思考为啥要以EnhancerKey接口作为被代理的类？我预先给大家贴出EnhancerKey代理类的class文件（反编译），大家就清楚原因了
在这里插入图片描述
这就是Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f内存中创建的代理类源码，其实就是根据图-字节码这张图片中可以看到通过ASM框架生成了上面的代理类，而生成这个EnhancerKey代理类的目的就是就是后面创建People代理类时传参进来放到这个Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f实例对象的成员变量中，随时可以拿出来利用

言归正传，我们继续回到主线程源码：
byte[] b = strategy.generate(this); 就结束了，继续跟进
在这里插入图片描述

好了我们创建的代理类对象就完成了，准备实例化成实例对象（注意两者的区别）

一看上图firstInstance方法就是实例化的意思，跟进进入：

到这里KEY_FACTORY（EnhancerKey的代理类

Enhancer$EnhancerKey$$KeyFactoryByCGLIB$$4ce19e8f

）就创建完成了，我们回到Enhancer enhancer = new Enhancer();
在这里插入图片描述
上图中我们设置了People为父类对象，设置了new MyCglib()为回调函数，现在才开始真正的创建People的代理类，
进入 People people = (People) enhancer.create(); 方法：

进入 Object result = super.create(key);方法

Object obj = data.get(this, getUseCache());方法我之前debug过，当然内部还是有很多差异，总归一句就是创建代理类的字节码文件
在这里插入图片描述
所以不会再执行firstInstance方法了，要执行nextInstance方法

到这里我们几乎都完成了，nextInstance方法也是一样，创建一个实例对象，下面我把生成完以后的主要三个代理类的源码附上给大家参考：

三、生成的代理文件分析

主要三个重要字节码文件

1、People的FastClass类 People$$FastClassByCGLIB$$bb7be7f6.class：

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

package com.yl.spring.beandefinitionregistry.support.cglib;

import java.lang.reflect.InvocationTargetException;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.reflect.FastClass;

public class People$$FastClassByCGLIB$$bb7be7f6 extends FastClass {
    public People$$FastClassByCGLIB$$bb7be7f6(Class var1) {
        super(var1);
    }

    public int getIndex(Signature var1) {
        String var10000 = var1.toString();
        switch (var10000.hashCode()) {
            case -166974160:
                if (var10000.equals("B(I)Ljava/lang/String;")) {
                    return 0;
                }
                break;
            case 1976212:
                if (var10000.equals("A()V")) {
                    return 1;
                }
                break;
            case 1826985398:
                if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                    return 2;
                }
                break;
            case 1913648695:
                if (var10000.equals("toString()Ljava/lang/String;")) {
                    return 3;
                }
                break;
            case 1984935277:
                if (var10000.equals("hashCode()I")) {
                    return 4;
                }
        }

        return -1;
    }

    public int getIndex(String var1, Class[] var2) {
        switch (var1.hashCode()) {
            case -1776922004:
                if (var1.equals("toString")) {
                    switch (var2.length) {
                        case 0:
                            return 3;
                    }
                }
                break;
            case -1295482945:
                if (var1.equals("equals")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("java.lang.Object")) {
                                return 2;
                            }
                    }
                }
                break;
            case 65:
                if (var1.equals("A")) {
                    switch (var2.length) {
                        case 0:
                            return 1;
                    }
                }
                break;
            case 66:
                if (var1.equals("B")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("int")) {
                                return 0;
                            }
                    }
                }
                break;
            case 147696667:
                if (var1.equals("hashCode")) {
                    switch (var2.length) {
                        case 0:
                            return 4;
                    }
                }
        }

        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 {
        People var10000 = (People)var2;
        int var10001 = var1;

        try {
            switch (var10001) {
                case 0:
                    return var10000.B(((Number)var3[0]).intValue());
                case 1:
                    var10000.A();
                    return null;
                case 2:
                    return new Boolean(var10000.equals(var3[0]));
                case 3:
                    return var10000.toString();
                case 4:
                    return new Integer(var10000.hashCode());
            }
        } catch (Throwable var4) {
            throw new InvocationTargetException(var4);
        }

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

    public Object newInstance(int var1, Object[] var2) throws InvocationTargetException {
        People var10000 = new People;
        People 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 4;
    }
}

2、People的代理类 People$$EnhancerByCGLIB$$83bb32b5.class：

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

package com.yl.spring.beandefinitionregistry.support.cglib;

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

public class People$$EnhancerByCGLIB$$83bb32b5 extends People 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$B$0$Method;
    private static final MethodProxy CGLIB$B$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$A$1$Method;
    private static final MethodProxy CGLIB$A$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("com.yl.spring.beandefinitionregistry.support.cglib.People$$EnhancerByCGLIB$$83bb32b5");
        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$2$Method = var10000[0];
        CGLIB$equals$2$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
        CGLIB$toString$3$Method = var10000[1];
        CGLIB$toString$3$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
        CGLIB$hashCode$4$Method = var10000[2];
        CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
        CGLIB$clone$5$Method = var10000[3];
        CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
        var10000 = ReflectUtils.findMethods(new String[]{"B", "(I)Ljava/lang/String;", "A", "()V"}, (var1 = Class.forName("com.yl.spring.beandefinitionregistry.support.cglib.People")).getDeclaredMethods());
        CGLIB$B$0$Method = var10000[0];
        CGLIB$B$0$Proxy = MethodProxy.create(var1, var0, "(I)Ljava/lang/String;", "B", "CGLIB$B$0");
        CGLIB$A$1$Method = var10000[1];
        CGLIB$A$1$Proxy = MethodProxy.create(var1, var0, "()V", "A", "CGLIB$A$1");
    }

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

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

    final void CGLIB$A$1() {
        super.A();
    }

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

    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 -508378822:
                if (var10000.equals("clone()Ljava/lang/Object;")) {
                    return CGLIB$clone$5$Proxy;
                }
                break;
            case -166974160:
                if (var10000.equals("B(I)Ljava/lang/String;")) {
                    return CGLIB$B$0$Proxy;
                }
                break;
            case 1976212:
                if (var10000.equals("A()V")) {
                    return CGLIB$A$1$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 People$$EnhancerByCGLIB$$83bb32b5() {
        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) {
        People$$EnhancerByCGLIB$$83bb32b5 var1 = (People$$EnhancerByCGLIB$$83bb32b5)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);
        People$$EnhancerByCGLIB$$83bb32b5 var10000 = new People$$EnhancerByCGLIB$$83bb32b5();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

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

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

3、People的代理类的FastClass类People$$EnhancerByCGLIB$$83bb32b5$$FastClassByCGLIB$$131ba5bd.class：

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

package com.yl.spring.beandefinitionregistry.support.cglib;

import com.yl.spring.beandefinitionregistry.support.cglib.People..EnhancerByCGLIB..83bb32b5;
import java.lang.reflect.InvocationTargetException;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.reflect.FastClass;

public class People$$EnhancerByCGLIB$$83bb32b5$$FastClassByCGLIB$$131ba5bd extends FastClass {
    public People$$EnhancerByCGLIB$$83bb32b5$$FastClassByCGLIB$$131ba5bd(Class var1) {
        super(var1);
    }

    public int getIndex(Signature var1) {
        String var10000 = var1.toString();
        switch (var10000.hashCode()) {
            case -1870561232:
                if (var10000.equals("CGLIB$findMethodProxy(Lorg/springframework/cglib/core/Signature;)Lorg/springframework/cglib/proxy/MethodProxy;")) {
                    return 9;
                }
                break;
            case -1745842178:
                if (var10000.equals("setCallbacks([Lorg/springframework/cglib/proxy/Callback;)V")) {
                    return 22;
                }
                break;
            case -1641413109:
                if (var10000.equals("newInstance([Lorg/springframework/cglib/proxy/Callback;)Ljava/lang/Object;")) {
                    return 6;
                }
                break;
            case -1457535688:
                if (var10000.equals("CGLIB$STATICHOOK1()V")) {
                    return 10;
                }
                break;
            case -1411812934:
                if (var10000.equals("CGLIB$hashCode$4()I")) {
                    return 11;
                }
                break;
            case -1034266769:
                if (var10000.equals("CGLIB$SET_STATIC_CALLBACKS([Lorg/springframework/cglib/proxy/Callback;)V")) {
                    return 18;
                }
                break;
            case -1025895669:
                if (var10000.equals("CGLIB$SET_THREAD_CALLBACKS([Lorg/springframework/cglib/proxy/Callback;)V")) {
                    return 19;
                }
                break;
            case -988317324:
                if (var10000.equals("newInstance([Ljava/lang/Class;[Ljava/lang/Object;[Lorg/springframework/cglib/proxy/Callback;)Ljava/lang/Object;")) {
                    return 7;
                }
                break;
            case -978833750:
                if (var10000.equals("CGLIB$A$1()V")) {
                    return 15;
                }
                break;
            case -508378822:
                if (var10000.equals("clone()Ljava/lang/Object;")) {
                    return 3;
                }
                break;
            case -166974160:
                if (var10000.equals("B(I)Ljava/lang/String;")) {
                    return 4;
                }
                break;
            case 1976212:
                if (var10000.equals("A()V")) {
                    return 8;
                }
                break;
            case 374345669:
                if (var10000.equals("CGLIB$equals$2(Ljava/lang/Object;)Z")) {
                    return 16;
                }
                break;
            case 610042816:
                if (var10000.equals("newInstance(Lorg/springframework/cglib/proxy/Callback;)Ljava/lang/Object;")) {
                    return 5;
                }
                break;
            case 1132856532:
                if (var10000.equals("getCallbacks()[Lorg/springframework/cglib/proxy/Callback;")) {
                    return 20;
                }
                break;
            case 1246779367:
                if (var10000.equals("setCallback(ILorg/springframework/cglib/proxy/Callback;)V")) {
                    return 17;
                }
                break;
            case 1364367423:
                if (var10000.equals("getCallback(I)Lorg/springframework/cglib/proxy/Callback;")) {
                    return 21;
                }
                break;
            case 1517819849:
                if (var10000.equals("CGLIB$toString$3()Ljava/lang/String;")) {
                    return 13;
                }
                break;
            case 1826985398:
                if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                    return 0;
                }
                break;
            case 1901917287:
                if (var10000.equals("CGLIB$B$0(I)Ljava/lang/String;")) {
                    return 14;
                }
                break;
            case 1913648695:
                if (var10000.equals("toString()Ljava/lang/String;")) {
                    return 1;
                }
                break;
            case 1984935277:
                if (var10000.equals("hashCode()I")) {
                    return 2;
                }
                break;
            case 2011844968:
                if (var10000.equals("CGLIB$clone$5()Ljava/lang/Object;")) {
                    return 12;
                }
        }

        return -1;
    }

    public int getIndex(String var1, Class[] var2) {
        switch (var1.hashCode()) {
            case -1776922004:
                if (var1.equals("toString")) {
                    switch (var2.length) {
                        case 0:
                            return 1;
                    }
                }
                break;
            case -1295482945:
                if (var1.equals("equals")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("java.lang.Object")) {
                                return 0;
                            }
                    }
                }
                break;
            case -1053468136:
                if (var1.equals("getCallbacks")) {
                    switch (var2.length) {
                        case 0:
                            return 20;
                    }
                }
                break;
            case -772062997:
                if (var1.equals("CGLIB$A$1")) {
                    switch (var2.length) {
                        case 0:
                            return 15;
                    }
                }
                break;
            case -772062037:
                if (var1.equals("CGLIB$B$0")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("int")) {
                                return 14;
                            }
                    }
                }
                break;
            case -124978608:
                if (var1.equals("CGLIB$equals$2")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("java.lang.Object")) {
                                return 16;
                            }
                    }
                }
                break;
            case -60403779:
                if (var1.equals("CGLIB$SET_STATIC_CALLBACKS")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("[Lorg.springframework.cglib.proxy.Callback;")) {
                                return 18;
                            }
                    }
                }
                break;
            case -29025554:
                if (var1.equals("CGLIB$hashCode$4")) {
                    switch (var2.length) {
                        case 0:
                            return 11;
                    }
                }
                break;
            case 65:
                if (var1.equals("A")) {
                    switch (var2.length) {
                        case 0:
                            return 8;
                    }
                }
                break;
            case 66:
                if (var1.equals("B")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("int")) {
                                return 4;
                            }
                    }
                }
                break;
            case 85179481:
                if (var1.equals("CGLIB$SET_THREAD_CALLBACKS")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("[Lorg.springframework.cglib.proxy.Callback;")) {
                                return 19;
                            }
                    }
                }
                break;
            case 94756189:
                if (var1.equals("clone")) {
                    switch (var2.length) {
                        case 0:
                            return 3;
                    }
                }
                break;
            case 147696667:
                if (var1.equals("hashCode")) {
                    switch (var2.length) {
                        case 0:
                            return 2;
                    }
                }
                break;
            case 161998109:
                if (var1.equals("CGLIB$STATICHOOK1")) {
                    switch (var2.length) {
                        case 0:
                            return 10;
                    }
                }
                break;
            case 495524492:
                if (var1.equals("setCallbacks")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("[Lorg.springframework.cglib.proxy.Callback;")) {
                                return 22;
                            }
                    }
                }
                break;
            case 1154623345:
                if (var1.equals("CGLIB$findMethodProxy")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("org.springframework.cglib.core.Signature")) {
                                return 9;
                            }
                    }
                }
                break;
            case 1543336190:
                if (var1.equals("CGLIB$toString$3")) {
                    switch (var2.length) {
                        case 0:
                            return 13;
                    }
                }
                break;
            case 1811874389:
                if (var1.equals("newInstance")) {
                    switch (var2.length) {
                        case 1:
                            String var10001 = var2[0].getName();
                            switch (var10001.hashCode()) {
                                case -1997738671:
                                    if (var10001.equals("[Lorg.springframework.cglib.proxy.Callback;")) {
                                        return 6;
                                    }
                                    break;
                                case 1364160985:
                                    if (var10001.equals("org.springframework.cglib.proxy.Callback")) {
                                        return 5;
                                    }
                            }
                        case 2:
                        default:
                            break;
                        case 3:
                            if (var2[0].getName().equals("[Ljava.lang.Class;") && var2[1].getName().equals("[Ljava.lang.Object;") && var2[2].getName().equals("[Lorg.springframework.cglib.proxy.Callback;")) {
                                return 7;
                            }
                    }
                }
                break;
            case 1817099975:
                if (var1.equals("setCallback")) {
                    switch (var2.length) {
                        case 2:
                            if (var2[0].getName().equals("int") && var2[1].getName().equals("org.springframework.cglib.proxy.Callback")) {
                                return 17;
                            }
                    }
                }
                break;
            case 1905679803:
                if (var1.equals("getCallback")) {
                    switch (var2.length) {
                        case 1:
                            if (var2[0].getName().equals("int")) {
                                return 21;
                            }
                    }
                }
                break;
            case 1951977611:
                if (var1.equals("CGLIB$clone$5")) {
                    switch (var2.length) {
                        case 0:
                            return 12;
                    }
                }
        }

        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 {
        People..EnhancerByCGLIB..83bb32b5 var10000 = (People..EnhancerByCGLIB..83bb32b5)var2;
        int var10001 = var1;

        try {
            switch (var10001) {
                case 0:
                    return new Boolean(var10000.equals(var3[0]));
                case 1:
                    return var10000.toString();
                case 2:
                    return new Integer(var10000.hashCode());
                case 3:
                    return var10000.clone();
                case 4:
                    return var10000.B(((Number)var3[0]).intValue());
                case 5:
                    return var10000.newInstance((Callback)var3[0]);
                case 6:
                    return var10000.newInstance((Callback[])var3[0]);
                case 7:
                    return var10000.newInstance((Class[])var3[0], (Object[])var3[1], (Callback[])var3[2]);
                case 8:
                    var10000.A();
                    return null;
                case 9:
                    return 83bb32b5.CGLIB$findMethodProxy((Signature)var3[0]);
                case 10:
                    83bb32b5.CGLIB$STATICHOOK1();
                    return null;
                case 11:
                    return new Integer(var10000.CGLIB$hashCode$4());
                case 12:
                    return var10000.CGLIB$clone$5();
                case 13:
                    return var10000.CGLIB$toString$3();
                case 14:
                    return var10000.CGLIB$B$0(((Number)var3[0]).intValue());
                case 15:
                    var10000.CGLIB$A$1();
                    return null;
                case 16:
                    return new Boolean(var10000.CGLIB$equals$2(var3[0]));
                case 17:
                    var10000.setCallback(((Number)var3[0]).intValue(), (Callback)var3[1]);
                    return null;
                case 18:
                    83bb32b5.CGLIB$SET_STATIC_CALLBACKS((Callback[])var3[0]);
                    return null;
                case 19:
                    83bb32b5.CGLIB$SET_THREAD_CALLBACKS((Callback[])var3[0]);
                    return null;
                case 20:
                    return var10000.getCallbacks();
                case 21:
                    return var10000.getCallback(((Number)var3[0]).intValue());
                case 22:
                    var10000.setCallbacks((Callback[])var3[0]);
                    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 {
        People..EnhancerByCGLIB..83bb32b5 var10000 = new People..EnhancerByCGLIB..83bb32b5;
        People..EnhancerByCGLIB..83bb32b5 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 22;
    }
}