Spring AOP 源码分析 - 创建代理对象

最新推荐文章于 2022-10-20 17:28:24 发布
最新推荐文章于 2022-10-20 17:28:24 发布
阅读量606 收藏
点赞数
分类专栏： 源码剖析 文章标签： Spring  AOP  源码分析

1.简介

在上一篇文章中，我分析了 Spring 是如何为目标 bean 筛选合适的通知器的。现在通知器选好了，接下来就要通过代理的方式将通知器（Advisor）所持有的通知（Advice）织入到 bean 的某些方法前后。与筛选合适的通知器相比，创建代理对象的过程则要简单不少，本文所分析的源码不过100行，相对比较简单。在接下里的章节中，我将会首先向大家介绍一些背景知识，然后再去分析源码。那下面，我们先来了解一下背景知识。

 2.背景知识

 2.1 proxy-target-class

在 Spring AOP 配置中，proxy-target-class 属性可影响 Spring 生成的代理对象的类型。以 XML 配置为例，可进行如下配置：

1
2
3
4
5
6
7

<aop:aspectj-autoproxy proxy-target-class="true"/>

<aop:config proxy-target-class="true">
    <aop:aspect id="xxx" ref="xxxx">
        <!-- 省略 -->
    </aop:aspect>
</aop:config>

如上，默认情况下 proxy-target-class 属性为 false。当目标 bean 实现了接口时，Spring 会基于 JDK 动态代理为目标 bean 创建代理对象。若未实现任何接口，Spring 则会通过 CGLIB 创建代理。而当 proxy-target-class 属性设为 true 时，则会强制 Spring 通过 CGLIB 的方式创建代理对象，即使目标 bean 实现了接口。

关于 proxy-target-class 属性的用途这里就说完了，下面我们来看看两种不同创建动态代理的方式。

 2.2 动态代理

 2.2.1 基于 JDK 的动态代理

基于 JDK 的动态代理主要是通过 JDK 提供的代理创建类 Proxy 为目标对象创建代理，下面我们来看一下 Proxy 中创建代理的方法声明。如下：

1
2
3

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

简单说一下上面的参数列表：

  • loader - 类加载器
  • interfaces - 目标类所实现的接口列表
  • h - 用于封装代理逻辑

JDK 动态代理对目标类是有一定要求的，即要求目标类必须实现了接口，JDK 动态代理只能为实现了接口的目标类生成代理对象。至于 InvocationHandler，是一个接口类型，定义了一个 invoke 方法。使用者需要实现该方法，并在其中封装代理逻辑。

关于 JDK 动态代理的介绍，就先说到这。下面我来演示一下 JDK 动态代理的使用方式，如下：

目标类定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public interface UserService {

    void save(User user);

    void update(User user);
}

public class UserServiceImpl implements UserService {

    @Override
    public void save(User user) {
        System.out.println("save user info");
    }

    @Override
    public void update(User user) {
        System.out.println("update user info");
    }
}

代理创建者定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

public interface ProxyCreator {

    Object getProxy();
}

public class JdkProxyCreator implements ProxyCreator, InvocationHandler {

    private Object target;

    public JdkProxyCreator(Object target) {
        assert target != null;
        Class<?>[] interfaces = target.getClass().getInterfaces();
        if (interfaces.length == 0) {
            throw new IllegalArgumentException("target class don`t implement any interface");
        }
        this.target = target;
    }

    @Override
    public Object getProxy() {
        Class<?> clazz = target.getClass();
        // 生成代理对象
        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println(System.currentTimeMillis() + " - " + method.getName() + " method start");
        // 调用目标方法
        Object retVal = method.invoke(target, args);
        System.out.println(System.currentTimeMillis() + " - " + method.getName() + " method over");

        return retVal;
    }
}

如上，invoke 方法中的代理逻辑主要用于记录目标方法的调用时间，和结束时间。下面写点测试代码简单验证一下，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class JdkProxyCreatorTest {

    @Test
    public void getProxy() throws Exception {
        ProxyCreator proxyCreator = new JdkProxyCreator(new UserServiceImpl());
        UserService userService = (UserService) proxyCreator.getProxy();
        
        System.out.println("proxy type = " + userService.getClass());
        System.out.println();
        userService.save(null);
        System.out.println();
        userService.update(null);
    }
}

测试结果如下：

如上，从测试结果中。我们可以看出，我们的代理逻辑正常执行了。另外，注意一下 userService 指向对象的类型，并非是 xyz.coolblog.proxy.UserServiceImpl，而是 com.sun.proxy.$Proxy4。

关于 JDK 动态代理，这里先说这么多。下一节，我来演示一下 CGLIB 动态代理，继续往下看吧。

 2.2.2 基于 CGLIB 的动态代理

当我们要为未实现接口的类生成代理时，就无法使用 JDK 动态代理了。那么此类的目标对象生成代理时应该怎么办呢？当然是使用 CGLIB 了。在 CGLIB 中，代理逻辑是封装在 MethodInterceptor 实现类中的，代理对象则是通过 Enhancer 类的 create 方法进行创建。下面我来演示一下 CGLIB 创建代理对象的过程，如下：

本节的演示环节，打算调侃（无贬低之意）一下59式坦克，这是我们国家大量装备过的一款坦克。59式坦克有很多种改款，一般把改款统称为59改，59改这个梗也正是源于此。下面我们先来一览59式坦克的风采：


图片来源：百度图片搜索

下面我们的工作就是为咱们的 59 创建一个代理，即 59改。好了，开始我们的魔改吧。

目标类，59式坦克：

1
2
3
4
5
6
7
8
9
10

public class Tank59 {

    void run() {
        System.out.println("极速前行中....");
    }

    void shoot() {
        System.out.println("轰...轰...轰...轰...");
    }
}

CGLIB 代理创建者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class CglibProxyCreator implements ProxyCreator {

    private Object target;

    private MethodInterceptor methodInterceptor;

    public CglibProxyCreator(Object target, MethodInterceptor methodInterceptor) {
        assert (target != null && methodInterceptor != null);
        this.target = target;
        this.methodInterceptor = methodInterceptor;
    }

    @Override
    public Object getProxy() {
        Enhancer enhancer = new Enhancer();
        // 设置代理类的父类
        enhancer.setSuperclass(target.getClass());
        // 设置代理逻辑
        enhancer.setCallback(methodInterceptor);
        // 创建代理对象
        return enhancer.create();
    }
}

方法拦截器 - 坦克再制造：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class TankRemanufacture implements MethodInterceptor {

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        if (method.getName().equals("run")) {
            System.out.println("正在重造59坦克...");
            System.out.println("重造成功，已获取 ✨59改 之 超音速飞行版✨");
            System.out.print("已起飞，正在突破音障。");

            methodProxy.invokeSuper(o, objects);

            System.out.println("已击落黑鸟 SR-71，正在返航...");
            return null;
        }

        return methodProxy.invokeSuper(o, objects);
    }
}

好了，下面开始演示，测试代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class CglibProxyCreatorTest {

    @Test
    public void getProxy() throws Exception {
        ProxyCreator proxyCreator = new CglibProxyCreator(new Tank59(), new TankRemanufacture());
        Tank59 tank59 = (Tank59) proxyCreator.getProxy();
        
        System.out.println("proxy class = " + tank59.getClass() + "\n");
        tank59.run();
        System.out.println();
        System.out.print("射击测试：");
        tank59.shoot();
    }
}

测试结果如下：

如上，“极速前行中…” 和 “轰…轰…轰…轰…” 这两行字符串是目标对象中的方法打印出来的，其他的则是由代理逻辑打印的。由此可知，我们的代理逻辑生效了。

好了，最后我们来看一下，经过魔改后的 59，也就是超音速59改的效果图：


图片来源：未知

本节用59式坦克举例，仅是调侃，并无恶意。作为年轻的一代，我们应感谢那些为国防事业做出贡献的科技人员们。没有他们贡献，我们怕是不会有像今天这样安全的环境了（尽管不完美）。

到此，背景知识就介绍完了。下一章，我将开始分析源码。源码不是很长，主逻辑比较容易懂，所以一起往下看吧。

 3.源码分析

为目标 bean 创建代理对象前，需要先创建 AopProxy 对象，然后再调用该对象的 getProxy 方法创建实际的代理类。我们先来看看 AopProxy 这个接口的定义，如下：

1
2
3
4
5
6
7

public interface AopProxy {

    /** 创建代理对象 */
    Object getProxy();
    
    Object getProxy(ClassLoader classLoader);
}

在 Spring 中，有两个类实现了 AopProxy，如下：

Spring 在为目标 bean 创建代理的过程中，要根据 bean 是否实现接口，以及一些其他配置来决定使用 AopProxy 何种实现类为目标 bean 创建代理对象。下面我们就来看一下代理创建的过程，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

protected Object createProxy(
        Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    }

    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);

    /*
     * 默认配置下，或用户显式配置 proxy-target-class = "false" 时，
     * 这里的 proxyFactory.isProxyTargetClass() 也为 false
     */
    if (!proxyFactory.isProxyTargetClass()) {
        if (shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        }
        else {
            /*
             * 检测 beanClass 是否实现了接口，若未实现，则将 
             * proxyFactory 的成员变量 proxyTargetClass 设为 true
             */ 
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }

    // specificInterceptors 中若包含有 Advice，此处将 Advice 转为 Advisor
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    proxyFactory.addAdvisors(advisors);
    proxyFactory.setTargetSource(targetSource);
    customizeProxyFactory(proxyFactory);

    proxyFactory.setFrozen(this.freezeProxy);
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }

    // 创建代理
    return proxyFactory.getProxy(getProxyClassLoader());
}

public Object getProxy(ClassLoader classLoader) {
    // 先创建 AopProxy 实现类对象，然后再调用 getProxy 为目标 bean 创建代理对象
    return createAopProxy().getProxy(classLoader);
}

getProxy 这里有两个方法调用，一个是调用 createAopProxy 创建 AopProxy 实现类对象，然后再调用 AopProxy 实现类对象中的 getProxy 创建代理对象。这里我们先来看一下创建 AopProxy 实现类对象的过程，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

protected final synchronized AopProxy createAopProxy() {
    if (!this.active) {
        activate();
    }
    return getAopProxyFactory().createAopProxy(this);
}

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        /*
         * 下面的三个条件简单分析一下：
         *
         *   条件1：config.isOptimize() - 是否需要优化，这个属性没怎么用过，
         *         细节我不是很清楚
         *   条件2：config.isProxyTargetClass() - 检测 proxyTargetClass 的值，
         *         前面的代码会设置这个值
         *   条件3：hasNoUserSuppliedProxyInterfaces(config) 
         *         - 目标 bean 是否实现了接口
         */
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                return new JdkDynamicAopProxy(config);
            }
            // 创建 CGLIB 代理，ObjenesisCglibAopProxy 继承自 CglibAopProxy
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            // 创建 JDK 动态代理
            return new JdkDynamicAopProxy(config);
        }
    }
}

如上，DefaultAopProxyFactory 根据一些条件决定生成什么类型的 AopProxy 实现类对象。生成好 AopProxy 实现类对象后，下面就要为目标 bean 创建代理对象了。这里以 JdkDynamicAopProxy 为例，我们来看一下，该类的 getProxy 方法的逻辑是怎样的。如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public Object getProxy() {
    return getProxy(ClassUtils.getDefaultClassLoader());
}

public Object getProxy(ClassLoader classLoader) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
    }
    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
    
    // 调用 newProxyInstance 创建代理对象
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

如上，请把目光移至最后一行有效代码上，会发现 JdkDynamicAopProxy 最终调用 Proxy.newProxyInstance 方法创建代理对象。到此，创建代理对象的整个过程也就分析完了，不知大家看懂了没。好了，关于创建代理的源码分析，就先说到这里吧。

 4.总结

本篇文章对 Spring AOP 创建代理对象的过程进行了较为详细的分析，并在分析源码前介绍了相关的背景知识。总的来说，本篇文章涉及的技术点不是很复杂，相信大家都能看懂。限于个人能力，若文中有错误的地方，欢迎大家指出来。好了，本篇文章到此结束，谢谢阅读。

 参考

 附录：Spring 源码分析文章列表

 Ⅰ. IOC

更新时间标题
2018-05-30Spring IOC 容器源码分析系列文章导读
2018-06-01Spring IOC 容器源码分析 - 获取单例 bean
2018-06-04Spring IOC 容器源码分析 - 创建单例 bean 的过程
2018-06-06Spring IOC 容器源码分析 - 创建原始 bean 对象
2018-06-08Spring IOC 容器源码分析 - 循环依赖的解决办法
2018-06-11Spring IOC 容器源码分析 - 填充属性到 bean 原始对象
2018-06-11Spring IOC 容器源码分析 - 余下的初始化工作

 Ⅱ. AOP

更新时间标题
2018-06-17Spring AOP 源码分析系列文章导读
2018-06-20Spring AOP 源码分析 - 筛选合适的通知器
2018-06-20Spring AOP 源码分析 - 创建代理对象
2018-06-22Spring AOP 源码分析 - 拦截器链的执行过程

 Ⅲ. MVC

更新时间标题
2018-06-29Spring MVC 原理探秘 - 一个请求的旅行过程
2018-06-30Spring MVC 原理探秘 - 容器的创建过程

http://www.tianxiaobo.com/2018/06/20/Spring-AOP-%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90-%E5%88%9B%E5%BB%BA%E4%BB%A3%E7%90%86%E5%AF%B9%E8%B1%A1/ 

GarfieldEr007
关注
专栏目录
SpringAop源码分析---Spring面试系列--源码解析
java技术专家全栈成长之路
05-11 371
SpringAop源码分析 AOP简介 概念 切面（Aspect） ：官方的抽象定义为“一个关注点的模块化，这个关注点可能会横切多个对象”。连接点（Joinpoint） ：程序执行过程中的某一行为。通知（Advice） ：“切面”对于某个“连接点”所产生的动作。切入点（Pointcut） ：匹配连接点的断言，在AOP中通知和一个切入点表达式关联。目标对象（Target Object） ：被一个或者多个切面所通知的对象。AOP代理（AOP Proxy） 在Spring AOP中有两种代理方式，JDK动态
Spring AOP 源码分析——创建代理对象
最新发布
2401_83703999的博客
03-30 752
做任何事情都要用心，要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。当然要想成为一个技术大牛也需要一定的思想格局，思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局，未来你的路会走的更远。更多的技术点思维导图我已经做了一个整理，涵盖了当下互联网最流行99%的技术点，在这里我将这份导图分享出来，以及为金九银十准备的一整套面试体系，上到集合，下到分布式微服务《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》
Spring AOP源码解析-创建代理对象
努力找工作呀
03-16 414
一.简介 在上一篇文章中，分析了Spring是如何为目标bean筛选合适的通知器。现在通知器选好了，接下来就是通过代理的方式将通知器（Advisor）所持有的所有通知（Advice）织入到bean的某些方法前后，这篇文章就是分析创建代理的过程。 二.背景知识 2.1 proxy-target-class Spring AOP部分使用JDK动态代理或者CGLIB来为目标对象创建代理（建议尽量...
Spring源码剖析之AOP代理对象创建
白鸽
01-07 624
准备 我们通过AOP实现日志记录来剖析AOP /** * 日志切面 * * 实现日志记录 */ @Aspect @Component public class LogAspect { public LogAspect(){ System.out.println("LogAspect 构造方法"); } /** * 将指定注解作为切入点 */ @Pointcut("@annotation(com.xiaoxu.annotatio
spring基于aspectj的AOP配置 aop:aspectj-autoproxy proxy-target-class="true"
qq_36063677的博客
09-21 1万+
精通Spring4.x--企业应用开发实战 8.5.1@AfterReturning("@annotation()")切点函数详解   代码实现的目标是为NaugthyWaiter类的greetTo()方法实现后置增强，其中greetTo()方法被@NeedTest注解标注。增强类为TestAspect。 增强类： @Aspect @Component public class Te...
Spring源码学习(十八)---基于注解配置Aop的aspectj-autoproxy解析
https://juejin.cn/user/4248168663101239/posts
02-16 1422
这里主要是使用org.springframework:spring-beans:5.2.0.RELEASE进行分析 文章目录①. aspectj-autoproxy标签1. proxy-target-class属性2. expose-proxy属性②. aspectj-autoproxy标签解析③. DefaultBeanDefinitionDocumentReader类的parseBeanDefinitions方法④. 通过parseCustomElement解析自定义标⑤. Namespacehand.
【Spring】Spring AOP 源码分析-创建代理对象(三)
AloneYueCSDN
12-13 625
文章目录1.简介2.背景知识2.1 proxy-target-class2.2 动态代理2.2.1 基于 JDK 的动态代理2.2.2 基于 CGLIB 的动态代理3.源码分析4.总结 1.简介 原文链接 在上一篇文章中，我分析了 Spring 是如何为目标 bean 筛选合适的通知器的。现在通知器选好了，接下来就要通过代理的方式将通知器（Advisor）所持有的通知（Advice）织入到 bean 的某些方法前后。与筛选合适的通知器相比，创建代理对象的过程则要简单不少，本文所分析的源码不过100行，相对比
spring源码--AOP流程--笔记.docx
09-18
Spring AOP 源码分析笔记 Spring AOP（Aspect-Oriented Programming）是一种编程范式，它允许开发者 modularize cross-cutting concerns，即将横切关注点模块化。AOP 使得开发者可以将一些公共的功能模块化，以便在...
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
在 Spring AOP 中，`ObjenesisCglibAopProxy` 类负责使用 CGLIB 创建代理对象，它会将一系列的 `MethodInterceptor` 注册为 `Callback`，这些 `MethodInterceptor` 执行了 AOP 的逻辑。 在 Spring AOP 的自动代理...
配置@aspectj-autoproxy切面,生成代理对象
yasashii的博客
11-23 1392
有时候在调用一个方法时，可能需要在调用该方法之前需要做点其他的操作，比如我要做一个往数据库中插入数据的操作，这个插入的方法有一个json数据，但是我可能在插入之前还需要往这个json参数中塞入其他的数据。这个时候spring的aspectj-autoproxy就起到了作用了。 首先可以先在配置文件中配置一个aop，如下： studentInsertAspect"/> proxy-ta
spring代理对象的生成及运行机制源码解读
songyang19871115的博客
01-11 5698
spring有非常多的地方都是使用代理的，但是这些什么使用代理，使用哪种代理，代理是在什么时候创建的，怎么运行起效的。这些问题都会是下面的源码中实现的。 1、代理是怎么创建的，什么时候创建的，为什么创建 spring的代理创建类都是AbstractAutoProxyCreator的子类，这个抽象类同时又是InstantiationAwareBeanPostProcessor的实现类。由于它是Be
jdk动态代理执行流程
qq_41473383的博客
10-20 780
jdk动态代理执行流程
Spring JDK动态代理
记录我学习的点点滴滴
03-24 242
JDK动态代理和原理 jdk的动态代理：必须有接口 字节码加载： 本|------byte[]字节码流-------->类加载器 地| | ...
spring使用aop时需要设置proxy-target-class="true" 否则无法依赖注入
jbgtwang的专栏
12-28 1万+
在spring3以上版本中使用spring的依赖注入(注解或者xml方式)和aop功能时，发现了一个问题，如果不设置那么在获取bean时一直报：(无论通过name还是type都获取不到bean) org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type 或者 Java.lan
Spring： proxy-target-class 决定 用 CGlib 还是 JDK AOP 来生成代理
大树叶 技术专栏
03-01 5328
package salesdepart.service.app; import org.springframework.context.*; import org.springframework.context.support.*; import java.util.*; public class BeanTest {  public static void main(Strin
Spring AOP的proxy-target-class详解
蔡小波的博客
01-05 8802
proxy-target-class 该属性值默认为false,表示使用JDK动态代理织入增强;当值为true时,表示使用CGLib动态代理织入增强;但是,即使设置为false,如果目标类没有生命接口,则Spring将自动使用CGLib动态代理. proxy-target-class属性值决定是基于接口的还是基于类的代理被创建。 为true则是基于类的代理将起作用（需要cglib库）， 为...
Spring三种切面
热门推荐
筱进GG
12-02 1万+
Spring除了支持Schema方式配置AOP，还支持注解方式：使用@AspectJ风格的切面声明。 1 启用对@AspectJ的支持 Spring默认不支持@AspectJ风格的切面声明，为了支持需要使用如下配置： java代码： <aop:aspectj-autoproxy/> 这样Spring就能发现@AspectJ风格的切面并且将切面应用到目标对象...
Spring AOP详解：代理模式与源码分析
SpringAOP（面向切面编程）是软件开发中的一种重要设计模式，它是在面向对象编程（OOP）基础上发展起来的，旨在解决大型软件系统中常见的横切关注点问题，如日志记录、性能监控、事务管理等，这些关注点在不同的业务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值