CGLIB入门系列三，CGLIB生成的代理类详解

最新推荐文章于 2024-10-03 16:41:03 发布
最新推荐文章于 2024-10-03 16:41:03 发布
阅读量3.8k 收藏 17
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/P19777/article/details/103998918
版权

此前一直有一个疑惑，那就是为什么CGLIB生成代理类的时候会出现三个class文件，按道理说应该只有一个，多出来的两个类怎么回事？
其实多出来的这两个class类就是为CGLIB中重要的fastClass机制而生成的。

实验

public class GoodsService {

    @Test
    public void placeOrder() {
        System.out.println("place order");
        MsgUtil.addMsg("place order");
    }

    public void place() {
        throw new RuntimeException();
    }

    @Override
    public String toString() {
        return "GoodsService{}";
    }
}

@Test
public void testEnhance() {
	// 获取CGLIB生成的字节码
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "C:\\Users\\12130\\Desktop\\新建文件夹");
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(GoodsService.class);
    enhancer.setCallback(new TransactionInterceptor());
    GoodsService goodsService = (GoodsService) enhancer.create();
    goodsService.placeOrder();
}

static class TransactionInterceptor implements MethodInterceptor {
	/**
	 * 参数1：代理类对象实例
	 * 参数2：被代理的原始方法
	 * 参数3：方法参数
	 * 参数4：fastClass机制相关
	 */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("start interceptor");
        // 为什么要执行的是invokeSuper，而不是直接invoke？
        Object obj = methodProxy.invokeSuper(o, objects);
        System.out.println("end interceptor");
        return obj;
    }
}

FastClass机制

Jdk动态代理的拦截对象是通过反射的机制来调用被拦截实例方法的，反射的效率比较低，所以cglib采用了FastClass的机制来实现对被拦截方法的调用。FastClass机制就是对一个类的方法建立索引，调用方法时根据方法的签名来计算索引，通过索引来直接调用相应的方法。
这也就是为什么CGLIB生成的动态代理会包含3个class文件的原因，其中一个是生成的代理类，另外两个类都是FastClass机制需要的。另外两个类都继承了FastClass这个类。其中一个class为生成的代理类中的每个方法建立了索引，另外一个则为我们被代理类的所有方法包含其父类的方法建立了索引。
下面这个就是为被代理类中的方法建立的索引。

public class GoodsService$$FastClassByCGLIB$$58067f53 extends FastClass {
    public GoodsService$$FastClassByCGLIB$$58067f53(Class var1) {
        super(var1);
    }

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

        return -1;
    }
    public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
        GoodsService var10000 = (GoodsService)var2;
        int var10001 = var1;

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

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

可以看出，利用上面的invoke方法，只要我们传入对应方法的下标和实例对象，就可以非常快的调用到对应的方法。

FastClass类是在哪生成的？是如何生效的？

我们先看看CGLIB为我们生成的代理类

代理类分析

在示例代码中我们通过设置DebuggingClassWriter.DEBUG_LOCATION_PROPERTY的属性值来获取cglib生成的代理类
下面是生成代理类的字节码

public class GoodsService$$EnhancerByCGLIB$$b08e58d5 extends GoodsService implements Factory {
	// 标识拦截器是否已经绑定
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    // 下面的两个变量用来保存回调类，也就是我们设置所有的拦截器，CGLIB会将回调先设置到这两个变量上，然后再进行绑定
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    // 这就是我们的拦截器，因为只添加了一个CallBack，所以这里只有一个
    // CGLIB可以添加多个CallBack
    private MethodInterceptor CGLIB$CALLBACK_0;
    
    private static Object CGLIB$CALLBACK_FILTER;
    // 下面的所有Method都是被代理类的原始的Method
    private static final Method CGLIB$toString$0$Method;
    // MethodProxy与FastClass机制有关，下面会讲
    private static final MethodProxy CGLIB$toString$0$Proxy;
    // 空参数，一个默认值，当我们的方法没有参数的时候会传递给拦截器
    // 不传递空值，这是一种设置思想
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$placeOrder$1$Method;
    private static final MethodProxy CGLIB$placeOrder$1$Proxy;
    private static final Method CGLIB$place$2$Method;
    private static final MethodProxy CGLIB$place$2$Proxy;
    private static final Method CGLIB$equals$3$Method;
    private static final MethodProxy CGLIB$equals$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.cp.v5.service.GoodsService$$EnhancerByCGLIB$$b08e58d5");
        Class var1;
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$3$Method = var10000[0];
        // 创建MethodProxy，每一个方法都会创建一个对应的MethodProxy
        // 当前代理会会为其所有父类的方法都创建对应的MethodProxy,
        CGLIB$equals$3$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$3");
        CGLIB$hashCode$4$Method = var10000[1];
        CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
        CGLIB$clone$5$Method = var10000[2];
        CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
        // 获取GoodsService这个父类的所有方法
        var10000 = ReflectUtils.findMethods(new String[]{"toString", "()Ljava/lang/String;", "placeOrder", "()V", "place", "()V"}, (var1 = Class.forName("com.cp.v5.service.GoodsService")).getDeclaredMethods());
        CGLIB$toString$0$Method = var10000[0];
        CGLIB$toString$0$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$0");
        CGLIB$placeOrder$1$Method = var10000[1];
        CGLIB$placeOrder$1$Proxy = MethodProxy.create(var1, var0, "()V", "placeOrder", "CGLIB$placeOrder$1");
        CGLIB$place$2$Method = var10000[2];
        CGLIB$place$2$Proxy = MethodProxy.create(var1, var0, "()V", "place", "CGLIB$place$2");
    }
	
	/**
	 * 用来调用父类的原始方法
	 * CGLIB生成代理利用的是继承，而不是JDK动态代理的利用接口的形式
	 * 这样就有一个区别就出现了，JDK动态代理中必须要有一个被代理类的实例
	 * 但是CGLIB实现的动态代理就不需要，因为是继承，所以就包含了被代理类的全部方法
	 * 但是我们调用生成的代理类实例的toString()方法时，调用的就是CGLIB代理时候的方法
	 * 如果调用被代理类的原始方法呢，就是靠下面的这个方法
	 * CGLIB生成的代理类中每个原始方法都会有这两种类型的方法
	 */
    final String CGLIB$toString$0() {
        return super.toString();
    }
	
	/**
	 * 生成的代理方法，在该方法中会调用我们设置的Callback
	 * 当调用代理类的toString方法时，先判断是否已经存在实现了MethodInterceptor接口的拦截对象
	 * 如果没有的话就调用CGLIB$BIND_CALLBACKS方法来获取Callback
	 */
    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$0$Method, CGLIB$emptyArgs, CGLIB$toString$0$Proxy) : super.toString();
    }
	
	/**
	 * 删除了类似toString这样生成的方法，也都是一一对应的
	 * 还有几个newInstance()方法,newInstance()方法来源于Factory接口
	 * 从上面可以看到生成的代理类实现了Factory接口
	 */

    public GoodsService$$EnhancerByCGLIB$$b08e58d5() {
        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;
    }
	
	/**
	 * CGLIB$BIND_CALLBACKS 先从CGLIB$THREAD_CALLBACKS(一个ThreadLocal对象)中getCallback
	 * 如果获取不到的话，再从CGLIB$STATIC_CALLBACKS来获取，如果也没有则认为该方法不需要代理。
     * 那么CallBack是如何设置到CGLIB$THREAD_CALLBACKS 或者 CGLIB$STATIC_CALLBACKS中的呢？
     * 在Jdk动态代理中拦截对象是在实例化代理类时由构造函数传入的
	     * 在cglib中我们使用Enhancers生成代理类时。是调用Enhancer的firstInstance方法来生成代理类实例并设置回调。
     * firstInstance的调用轨迹为：
		   1.Enhancer：firstInstance
		   2.Enhancer：createUsingReflection
		   3.Enhancer：setThreadCallbacks
		   4.Enhancer：setCallbacksHelper
		   5.Target$$EnhancerByCGLIB$$788444a0 ： CGLIB$SET_THREAD_CALLBACKS
	 * 最终CGLIB实例化代理对象的时候，就在这里将所有的Callback成功设置了
	 */
    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        GoodsService$$EnhancerByCGLIB$$b08e58d5 var1 = (GoodsService$$EnhancerByCGLIB$$b08e58d5)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 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();
    }
}

在生成的代理类字节码中，有一个静态代码块，他执行了重要的方法

static {
    CGLIB$STATICHOOK1();
}

static void CGLIB$STATICHOOK1() {
    CGLIB$THREAD_CALLBACKS = new ThreadLocal();
    CGLIB$emptyArgs = new Object[0];
    /**
     * 为被代理类所有方法生成一个MethodProxy对象，包含其所有父类的方法
     */
    Class var0 = Class.forName("com.cp.v5.service.GoodsService$$EnhancerByCGLIB$$b08e58d5");
    Class var1;
    // 获取Object这个父类的所有方法，会将其所有的方法保存到一个本地变量上，并且会生成一个MethodProxy
    // 这个MethodProxy的对象实例很重要，MethodInterceptor的intercept方法就需要该对象实例，用来进行快速调用
    Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
    CGLIB$equals$3$Method = var10000[0];
    CGLIB$equals$3$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$3");
    CGLIB$hashCode$4$Method = var10000[1];
    CGLIB$hashCode$4$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$4");
    CGLIB$clone$5$Method = var10000[2];
    CGLIB$clone$5$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
    // 获取GoodsService这个父类的所有方法
    var10000 = ReflectUtils.findMethods(new String[]{"toString", "()Ljava/lang/String;", "placeOrder", "()V", "place", "()V"}, (var1 = Class.forName("com.cp.v5.service.GoodsService")).getDeclaredMethods());
    CGLIB$toString$0$Method = var10000[0];
    CGLIB$toString$0$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$0");
    CGLIB$placeOrder$1$Method = var10000[1];
    CGLIB$placeOrder$1$Proxy = MethodProxy.create(var1, var0, "()V", "placeOrder", "CGLIB$placeOrder$1");
    CGLIB$place$2$Method = var10000[2];
    CGLIB$place$2$Proxy = MethodProxy.create(var1, var0, "()V", "place", "CGLIB$place$2");
}

CGLIB$STATICHOOK1()这个静态方法内执行了MethodProxy.create()方法，为被代理所有的方法都生成了对应的MethodProxy，在调用代理对象的每个方法是都会有一个对应的MethodProxy就会当参数被传递到MethodInterceptor.intercept()方法中，在intercept中就能利用MethodProxy类的方法，使用FastClass机制

MethodProxy中的部分方法

/**
 * 一个MethodProxy对象，包含了两个方法的名称，一个是被代理类中的原始方法
 * 另外一个则是代理类中生成的用来调用被代理类原始方法的方法名
 * 当执行MethodProxy.invoke()方法时，其实就是用的被代理类的方法索引
 * 当执行MethodProxy.invokeSuper()方法时，用的是代理类中的方法的索引
 * 
 * c1是代理类实现的父类的class
 * c2是代理类的class
 * name1是被代理类中的原始方法名
 * name2是代理类中新增的用来调用被代理类原始方法的方法的名字
 */
public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
    MethodProxy proxy = new MethodProxy();
    // Signature是用来标识一个唯一的方法
    // 该标识可以用来获取fastClass中每一个方法的索引
    proxy.sig1 = new Signature(name1, desc);
    proxy.sig2 = new Signature(name2, desc);
    proxy.createInfo = new CreateInfo(c1, c2);
    return proxy;
}

private void init()
{
    /* 
     * Using a volatile invariant allows us to initialize the FastClass and
     * method index pairs atomically.
     * 
     * Double-checked locking is safe with volatile in Java 5.  Before 1.5 this 
     * code could allow fastClassInfo to be instantiated more than once, which
     * appears to be benign.
     */
    if (fastClassInfo == null)
    {
        synchronized (initLock)
        {
            if (fastClassInfo == null)
            {
                CreateInfo ci = createInfo;
                FastClassInfo fci = new FastClassInfo();
                // helper中生成了对应Class的FastClass实例，这里可以看出就是生成了两个Class的FastClass
                fci.f1 = helper(ci, ci.c1);
                fci.f2 = helper(ci, ci.c2);
                // 获取方法的下标,sig1原本的方法名,sig2是为了调用父类方法生成的特殊方法的方法名
                fci.i1 = fci.f1.getIndex(sig1);
                fci.i2 = fci.f2.getIndex(sig2);
                // 存储在本地变量上
                fastClassInfo = fci;
                createInfo = null;
            }
        }
    }
}

public Object invokeSuper(Object obj, Object[] args) throws Throwable {
    try {
    	// 调用init方法，当前MethodProxy所代表的方法在在FastClass中的索引
        init();
        FastClassInfo fci = fastClassInfo;
        // 这里的f2就是一个FastClass，fci.i2就是在init方法中计算出来的索引
        return fci.f2.invoke(fci.i2, obj, args);
    } catch (InvocationTargetException e) {
        throw e.getTargetException();
    }
}

public Object invoke(Object obj, Object[] args) throws Throwable {
    try {
        init();
        FastClassInfo fci = fastClassInfo;
        return fci.f1.invoke(fci.i1, obj, args);
    } catch (InvocationTargetException e) {
        throw e.getTargetException();
    } catch (IllegalArgumentException e) {
        if (fastClassInfo.i1 < 0)
            throw new IllegalArgumentException("Protected method: " + sig1);
        throw e;
    }
}

private static class FastClassInfo
{
	// 被代理类的FastClass
    FastClass f1;
    // 代理类的FastClass
    FastClass f2;
    int i1;
    int i2;
}
P19777
关注
专栏目录
cglib动态生成java类
01-26
cglib动态生成java类
cglib生成的代理class
09-13
cglib生成的代理的class
Cglib 查看生成的class文件
iCheetor
03-15 498
cglib查看生成的class文件
CGLIB原理
最新发布
weixin_54574094的博客
10-03 975
CGLIB 动态代理基于子类继承，通过字节码操作技术（如 ASM）动态生成代理类。它可以在运行时增强类的功能，使得开发者无需修改原有类的代码就能实现日志、权限校验等功能。虽然 CGLIB 在性能上有一定的开销，但其强大的代理能力使得它在 Spring 等框架中得到了广泛应用。
输出cglib以及jdk动态代理产生的class文件
weixin_34082177的博客
09-25 213
  --该设置用于输出jdk动态代理产生的类 System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");    --该设置用于输出cglib动态代理产生的类 System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, ...
输出JDK和CGLib动态代理产生的class文件.zip
06-17
本压缩文件包含两个项目，用于演示如何输出JDK和CGLib动态代理产生的class文件，欢迎下载！
查看Cglib生成的Class(字节码)文件
01-24 738
CGLib详解：动态字节码生成与类加载机制
"CGLib是一个动态字节码生成库，它基于ASM库，用于在运行时动态生成被代理类的子类。CGLib弥补了Java.lang.reflect.Proxy只能针对接口生成代理的限制，允许对类进行代理。CGLIB的使用需要依赖asm.jar。在Java程序中...
Java 动态代理详解（代理模式+静态代理+JDK动态代理+CGLIB动态代理）
06-21
CGLIB 动态代理是另外一种动态代理方式，使用 ASM 字节码操作库来生成代理类。CGLIB 动态代理的优点是可以代理 final 类和 private 方法。 五、 对比分析 | 代理方式 | 优点 | 缺点 | | --- | --- | --- | | 静态...
CGLIB：动态代理与字节码生成技术详解
与JDK反射中的`newProxyInstance`不同，CGLIB在运行时会动态生成一个代理类，覆盖父类的非final方法，这使得代理过程更加灵活，尤其是在小型项目中无需额外设计复杂的接口结构。 3. **HelloWorld示例**：在Spring...
Java动态代理详解； CGLib实现动态代理1
08-08
CGLib 使用字节码技术创建代理类，它比基于接口的 Java 动态代理更加灵活，因为可以代理任何非 final 类。 以下是使用 CGLib 创建动态代理的基本步骤： 1. 引入 CGLib 库。 2. 创建一个 `Enhancer` 对象，它是 ...
cglibJava字节码生成库
08-06
字节码生成库拥有高级的API生成和转换Java字节码。
Spring框架系列(11) - Spring AOP实现原理详解之Cglib代理实现.doc
07-08
在这个例子中，当我们调用`targetProxy.doSomething()`时，实际执行的是Cglib生成的子类中的方法，这个方法会在调用`doSomething()`前后执行`MyAdvice`中的`intercept`方法，这就是Cglib代理的工作原理。 总的来说...
CGLIB动态代理生成什么样的代理类？
Greedy Hat的博客
04-08 365
需要注意的是，CGLIB生成的类名、方法名和其他细节在实际使用中可能会有所不同，并且通常会包含一些CGLIB内部的特定标识符。与JDK动态代理不同，CGLIB不需要接口来创建代理，它可以直接对类进行代理。当你使用CGLIB创建代理时，CGLIB会在运行时动态生成一个新的类，这个类是被代理类的子类。对于被代理类中的每个非final的方法，CGLIB生成的代理类将会覆盖这些方法，并在其中插入特定的拦截逻辑。这个过程中，CGLIB会使用自己的类加载器来加载生成的代理类。是CGLIB提供的一个接口，它包含一个。
使用 CGLIB 生成代理类
2301_78021017的博客
05-21 441
来生成代理，这个代理类同样可以实现 Spring AOP 代理所达到的效果。代理的方法则通过在目标对象的切入点动态地织入增强处理，从而完成。代理类，因此具有更好的性能，但需要使用特定的编译器进行处理；，它可以在调用目标方法之前、调用目标方法之后织入增强处理。通过程序最后的输出，不难发现这个代理对象的实现类是。执行目标方法，并保存目标方法执行后的返回值。所生成的代理类，这个代理类的格式与。来动态地生成代理对象，这个代理对象。所生成的代理类的格式完全相同。生成代理对象的关键代码，此时的。
JDK与CGLIB动态代理构建过程及反向输出他们产生的代理Class文件验证代理对象
weixin_42939612的博客
03-01 271
JDK动态代理：目标对象必须是某个接口的实现，通过在运行期间动态的创建（代理类）来完成对目标对象的代理 接口： public interface Person { public void talk(); } 目标类： public class Student implements Person { @Override public void talk() { ...
如何生成cglib代理类class文件
wt_better的博客
04-21 2018
在调用之前设置System的cglib.debugLocation属性 具体原理如下：
查看cglib动态生成的类、cglib增加功能: 生成字节码时写出文件 并 应用到 spring-boot-demo
_
08-11 790
查看cglib动态生成的类。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值