Spring-动态代理-AOP详解-案例实现

最新推荐文章于 2021-08-19 21:28:07 发布
最新推荐文章于 2021-08-19 21:28:07 发布
阅读量364 收藏 1
点赞数 2
分类专栏： ssm_ 文章标签： spring java 数据库 aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ym15229994318ym/article/details/104280406
版权

相关概念

  • AOP：面向切面编程，实际上就是八个我们重复的代码抽取出来，使用动态代理结束，在不修改源码的基础上，对方法增强。减少重复重复代码、方便维护而且提高效率。
  • 举一个例子：我们要一次操作要执行多条sql语句时，就会要进行开启事务、提交事务、回滚事务、释放资源，那么如果我们有多个这样的操作，我们就可以抽取出开启事务、提交事务、回滚事务、释放资源这些代码。

动态代理

在运行时，动态创建一组指 定的接口的实现类对象! (在运行时，创建实现了指定的一组接口的对象)

  • 特点：字节码随用随创建，随用随加载

  • 作用：不修改源码的基础上对方法增强

  • 分类：基于接口的动态代理（本案例选用）、 基于子类的动态代理

  • 基于接口的动态代理：

    涉及的类：Proxy
    提供者：JDK官方
    如何创建代理对象：使用Proxy类中的newProxyInstance方法
    创建代理对象的要求：被代理类最少实现一个接口，如果没有则不能使用

  • newProxyInstance方法的参数：

    ClassLoader：类加载器,它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
    Class[]：字节码数组它是用于让代理对象和被代理对象有相同方法。固定写法。
    InvocationHandler：用于提供增强的代码,它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。此接口的实现类都是谁用谁写。

这是一个连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定。

public class ConnectionUtils {
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    private DataSource dataSource;
    
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    /**
     * 获取当前线程上的连接
     * @return
     */
    public Connection getThreadConnection() {
        try{
            //1.先从ThreadLocal上获取
            Connection conn = tl.get();
            //2.判断当前线程上是否有连接
            if (conn == null) {
                //3.从数据源中获取一个连接，并且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回当前线程上的连接
            return conn;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    /**
     * 把连接和线程解绑
     */
    public void removeConnection(){
        tl.remove();
    }
}

这是一个和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接，这也是动态代理对象进行增强方法。

public class TransactionManager {

    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    /**
     * 开启事务
     */
    public  void beginTransaction(){
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 提交事务
     */
    public  void commit(){
        try {
            connectionUtils.getThreadConnection().commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 回滚事务
     */
    public  void rollback(){
        try {
            connectionUtils.getThreadConnection().rollback();
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 释放连接
     */
    public  void release(){
        try {
            connectionUtils.getThreadConnection().close();//还回连接池中
            connectionUtils.removeConnection();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

这是用于创建service的代理对象的工厂，使用了动态代理。这样只要是使用BeanFactory创建的AccountService对象调用的每一个方法，都已经被代理对象进行了增强（开启事务，提交事务，回滚事务和释放连接）。

public class BeanFactory {
    private IAccountService accountService;
    private TransactionManager txManager;

    public final void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }

    public IAccountService getAccountService() {
        return (IAccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                /**
                 * 增强事务功能
                 */
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object returnValue = null;
                        try {
                            //1.开启事务
                            txManager.beginTransaction();
                            //2.执行操作
                            returnValue = method.invoke(accountService, args);
                            //3.提交事务
                            txManager.commit();
                            //4.返回结果
                            return returnValue;
                        } catch (Exception e) {
                            //5.回滚操作
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            //6.释放连接
                            txManager.release();
                        }
                    }
                });
    }
}

在spring的主配置文件xml中进行配置，用于创建对象，并放入spring容器中。

  • < bean id=“proxyAccountService” factory-bean=“beanFactory” factory-method=“getAccountService” >< /bean>：这个bean的创建用了工厂方法创建对象的方式。这就是那个动态代理对象。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置代理的service-->
    <bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean>

    <!--配置BeanFactory：增强了事务功能的的service对象-->
    <bean id="beanFactory" class="cn.itcast.factory.BeanFactory">
        <!--注入service-->
        <property name="accountService" ref="accountService"></property>
        <!--注入事务管理器-->
        <property name="txManager" ref="txManger"></property>
    </bean>

    <!-- 配置Service -->
    <bean id="accountService" class="cn.itcast.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!--配置Dao对象-->
    <bean id="accountDao" class="cn.itcast.dao.impl.AccountDaoImpl">
        <!-- 注入QueryRunner -->
        <property name="runner" ref="runner"></property>
        <!--注入ConnectionUtils-->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <!--<constructor-arg name="ds" ref="dataSource"></constructor-arg>-->
    </bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_study_db"></property>
        <property name="user" value="root"></property>
        <property name="password" value="admin"></property>
    </bean>

    <!--配置Connection的工具类， ConnectionUtils-->
    <bean id="connectionUtils" class="cn.itcast.utils.ConnectionUtils">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置事务管理器-->
    <bean id="txManger" class="cn.itcast.utils.TransactionManager">
        <!--注入ConnectionUtils-->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
</beans>

我们学习 spring 的 aop，其实就是通过配置的方式，实现这个动态代理的功能。

相关术语

重点理解一下切面和通知

  • Joinpoint(连接点):（接口中所有方法）所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的 连接点。
  • Pointcut(切入点):（接口中要增强的方法） 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
  • Advice(通知/增强):（invoke方法）所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：

前置通知：TxManger.beginTransaction();
后置通知：TxManger.commit();
异常通知：TxManger.rollback();
最终通知:TxManger.release();
环绕通知:整个invoke方法执行的就是环绕通知，在环绕通知中有明确的切入点方法调用。method.invoke(object,args);

  • Introduction(引介):(了解) 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方 法或 Field。
  • Target(目标对象):（被代理对象） 代理的目标对象。
  • Weaving(织入):（创建代理对象的过程，Proxy.newProxyInstance()执行的过程）是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
  • Proxy（代理）:（代理对象，也就是Proxy.newProxyInstance()的返回值）一个类被 AOP 织入增强后，就产生一个结果代理类。
  • Aspect(切面):（建立切入点方法和通知方法在执行调用关系，一般就是xml中进行配置） 是切入点和通知（引介）的结合。

spring中基于XML的AOP

配置步骤

  • 使用aop:config标签表明开始AOP的配置
  • 使用aop:aspect标签表明配置切面

id属性：是给切面提供一个唯一标识
ref属性：是指定通知类bean和id

  • aop:aspect内部使用对应标签来配置通知的类型

aop:before:前置通知：在切入点方法执行之前执行
aop:after-returning：后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个
aop:after-throwing ：异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个
aop:after：最终通知：无论切入点方法是否正常执行它都会在其后面执行
aop:around:环绕通知：……
method属性：用于指定Logger类中那个方法是前置通知
pointcut属性：用于hiding切入点表达式，该表达式的含义是对业务层中那些方法增强

环绕通知

  • 环绕通知：它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
  • Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。

改写增加TransactionManager 类中的环绕通知方法。

    public Object aroundPringLog(ProceedingJoinPoint pjp) {
        Object rtValue = null;
        try {
            Object[] args = pjp.getArgs();//得到方法执行所需参数
            beginTransaction();
            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）
            commit();
            return rtValue;
        } catch (Throwable t) {
            rollback();
            throw new RuntimeException(t);
        } finally {
            release();
        }
    }
}

切入点表达式

org.aspectjweaver 负责解析切入点表达式

  • 关键字： execution（表达式）
  • 表达式：访问修饰符 返回值 包名…包名.类名.方法名(参数列表)
  • 标准的表达式写法：

public void cn.itcast.service.impl.AccountServiceImpl.saveAccount()
execution(public void cn.itcast.service.impl.AccountServiceImpl.saveAccount())

  • 访问修饰符public可以省略
  • 返回值可以使用通配符，表示任意返回值，void可改为 *
  • 包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*
  • 包名可以使用…表示当前包及其子包
  • 类名和方法名都可以使用*来实现通配
  • 参数列表

可以直接写数据类型：
基本类型直接写名称 int
引用类型写包名.类名的方式 java.lang.String
可以使用通配符表示任意类型，但是必须有参数
可以使用…表示有无参数均可，有参数可以是任意类型

  • 全通配写法：* * . . * . * ( . . )

  • 实际开发中切入点表达式的通常写法：切到业务层实现类下的所有方法
    * cn.itcast.service.impl..(…)

改写主配置文件

使用AOP配置的方式改写配置文件实现动态代理

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置Service -->
    <bean id="accountService" class="cn.itcast.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!--配置Dao对象-->
    <bean id="accountDao" class="cn.itcast.dao.impl.AccountDaoImpl">
        <!-- 注入QueryRunner -->
        <property name="runner" ref="runner"></property>
        <!--注入ConnectionUtils-->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <!--<constructor-arg name="ds" ref="dataSource"></constructor-arg>-->
    </bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_study_db"></property>
        <property name="user" value="root"></property>
        <property name="password" value="admin"></property>
    </bean>

    <!--配置Connection的工具类， ConnectionUtils-->
    <bean id="connectionUtils" class="cn.itcast.utils.ConnectionUtils">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--配置事务管理器-->
    <bean id="txManger" class="cn.itcast.utils.TransactionManager">
        <!--注入ConnectionUtils-->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

    <!--配置transactionManager-->
    <bean id="txManager" class="cn.itcast.utils.TransactionManager"></bean>

    <!--配置AOP-->
    <aop:config>
        <aop:pointcut id="txManager1" expression="execution(* cn.itcast.service.impl..*.*(..))"/>
        <aop:aspect id="txAdvice" ref="txManger">
            <!-- 配置前置通知-->
            <aop:before method="beginTransaction" pointcut-ref="txManager1" ></aop:before>

            <!-- 配置后置通知-->
            <aop:after-returning method="commit" pointcut-ref="txManager1"></aop:after-returning>

            <!-- 配置异常通知-->
            <aop:after-throwing method="rollback" pointcut-ref="txManager1"></aop:after-throwing>

            <!-- 配置最终通知-->
            <aop:after method="release" pointcut-ref="txManager1"></aop:after>

            <!-- 配置环绕通知 -->
            <aop:around method="aroundPringLog" pointcut-ref="txManager1"></aop:around> 
        </aop:aspect>
    </aop:config>
</beans>

重点关注 < aop:config >：这个标签的配置就相当于动态代理的实现，就相当于那个BeanFactory类对象。

拿了桔子跑啊1
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AOP的动态代理
weixin_46075209的博客
04-17 1957
本文主要介绍的是spring的核心功能AOP中的动态代理，分别介绍了CGLIB和JDK的动态代理，希望能对各位小伙伴有帮助
Spring中AOP和动态代理的简单实例演示
qq_42041428的博客
06-01 376
Spring中AOP和动态代理的简单实例演示 AOP (Aspect-Oriented Programming) 面向切面编程 OOP (Object-Oriented Programming) 面向对象编程 想要了解AOP和动态代理，我们先看下面这个例子 假设我们现在有一个TestDao类中，有增删改查四种操作 @Repository public class TestDao implements Dao{ public void create(String table,String ar
spring(三)之动态代理的案例到AOP
qq_32719221的博客
11-22 345
目录 完善我们的account案例 分析案例中的问题 回顾动态代理 动态代理的另一种实现方式 解决案例中的问题 AOP中的概念 spring中AOP的相关术语 spring中基于XML和注解的AOP配置 1 完善account案例 IAccountService.java业务层接口上添加转账方法 public interface IAccountService { ..............
Spring AOP动态代理例子
Jadeon
10-21 1577
对Oracle数据库的部门表进行增删改查： 话不多说； 1.实体类可以不写.hbm.xml文件直接写注解方式： package com.jadeon.entity; import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.per...
JAVA动态代理实现aop的简单例子
梦想起飞的地方.........
10-27 1004
aop是面向切面编程，是对OO面向对象思想的补充。 下面的例子的利用动态代理实现简单的AOP不用引入任何jar包，spring的AOP的实现原理就是动态代理。 相关java类： 1、业务处理接口 package sinosoft.dj.aop.proxyaop; public interface IHello {       /**      * 业务处理A方法    
Spring AOP定义Before增加实战案例详解
08-25
主要介绍了Spring AOP定义Before增加,结合实例形式详细分析了Spring面向切面AOP定义Before增加相关定义与使用技巧,需要的朋友可以参考下
Spring AOP注解案例及基本原理详解
08-19
主要介绍了Spring AOP注解案例及基本原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【Spring AOP】@Aspect结合案例详解（二）: @Pointcut使用@within和within
01-12
虽然Spring AOP的切点表达式尚未 全部实现 @AspectJ 的切点指示符，但是也已经足够多和灵活，本文主要介绍@Pointcut切点表达式中的@within、within这两种切点指示符，结合案例，十分钟让你彻底搞懂！ 文末已附源码，...
【Spring AOP】@Aspect结合案例详解（一）: @Pointcut使用@annotation + 五种通知
01-09
在微服务流行的当下，在使用SpringCloud/Springboot框架开发中，AOP使用的非常广泛，尤其是@Aspect注解方式当属最流行的，不止功能强大，性能也很优秀，还很舒心！所以本系列就结合案例详细介绍@Aspect方式的切面的...
Spring高级之注解驱动开发视频教程
11-05
n 设计模式-代理模式 n 编程思想-AOP思想 n 基础应用-入门案例 n 基础应用-常用注解 n 高级应用-DeclareParents注解 n 高级应用-EnableLoadTimeWeaving n 源码分析-@EnableAspectJAutoproxy注解加载过程分析 n 源码...
Spring AOP原理之动态代理
热门推荐
Tyshawn的博客
12-29 5万+
什么是代理? 指为一个目标对象提供一个代理对象, 并由代理对象控制对目标对象的引用. 使用代理对象, 是为了在不修改目标对象的基础上, 增强目标对象的业务逻辑. 静态代理 静态代理的特点是, 为每一个业务增强都提供一个代理类, 由代理类来创建代理对象. 下面我们通过静态代理来实现对转账业务进行身份验证. (1) 转账业务 public interface IAccountService { ...
AOP结合ThreadLocal完成切面日志记录
a760352276的博客
01-18 3171
AOP结合ThreadLocal完成切面日志记录功能需求业务步骤代码演示引发的问题测试准备测试问题的产生解决方案优化小结 功能需求 在开发过程中有时候会碰到一些日志记录的需求。需要记录包括统计执行时间，调用者IP，调用者登录的用户名，调用方法的全限定类名......等等信息。 这时候，只需要使用Spring的AOP应用将系统一行一个切面插入，用前置通知和后置通知完成即可。 业务步骤 这里就不讲AOP配置啥的了，直接简单说明一下业务步骤 记录当前时间 通过JoinPaiont来获取要调用的方法信息 通过re
spring aop之对象内部方法间的嵌套失效
nobody
07-03 8196
spring aop之对象内部方法间的嵌套失效 先看一下spring 代理原理： *       spring代理嵌套方法调用不生效  *   *       Spring AOP defaults to using standard JDK dynamic proxies for AOP  *       proxies. This enables any interface
如何为spring代理类设置属性值
jinnianshilongnian的专栏
09-14 252
  在问答频道 有朋友问《如何为spring代理类设置属性值》 就写了个小工具 供使用。思想就不讲了。 现在有一个bean包含了私有属性，如下： Java代码    @Component   public class Bean {       String name;          public String getName() {           ...
AOP动态代理完整过程（超基础，超详细）
woongcha的博客
05-14 1470
AOP 动态代理 租房的时候，房屋中介就是代理（筛选符合自己要求的房子，再供自己选择）。 代理也需要和自己有相同的所有能力（自己有看房的能力，中介也有）。 在程序中，代理是一个对象。这个对象由一个类产生，这个类本身就是动态产生。 这个类本身不会被创建，在程序运行时动态产生。 InvocationHandler提供生成代理类的功能，InvocationHandler不是代理类，是帮助生成动态代理类的一个类。 代码分析 public class MyInvocationHandler imp
Spring事务原理深入解析（AOP,Threadlocal, 隔离级别,传播级别）
weixin_44366439的博客
05-20 3829
文章目录一、摘要二、基础知识介绍2.1 JDBC2.1.1 简单示例2.1.2 JDBC事务存在的问题：2.1.2 Spring事务解决该问题的方式2.2 AOP设计思想2.2.1 代理模式2.2.2 静态代理2.2.3 动态代理2.2.4 为什么使用AOP2.2.5 AOP会使用哪种代理2.2.6 AOP代码编写关键对象及AOP执行流程2.3 ThreadLocal实现原理2.4 Mysql存储...
Spring中的各种Utils（六）：AopProxyUtils详解
wolfcode_cn的博客
06-12 7459
原创文章，转载请注明出处本节介绍AopProxyUtils，这个工具类方法本身很少，但是涉及到很多AOP相关重要接口，所以本节主要会对涉及到的接口进行初步的介绍；Class&lt;?&gt; ultimateTargetClass(Object candidate)获取一个代理对象的最终对象类型，先做一个测试（测试的准备工作参考https://www.jianshu.com/p/a4a815f42...
透过现象看原理：详解 Spring 中 Bean 的 this 调用导致 AOP 失效的原因
qq_39951411的博客
05-18 1490
前言在我们使用Spring时，可能有前辈教导过我们，在bean中不要使用this来调用被@Async、@Transactional、@Cacheable等注解标注的方法，this下注解是不生效的。那么大家可曾想过以下问题为何致this调用的方法，注解会不生效这些注解生效的原理又是什么如果确实需要调用本类方法，且还需要注解生效，该怎么做？代理是否可以做到this调用注解就直接生效？通过本文，上面...
springAOP实现动态代理的两种方式
qq_51285237的博客
08-19 448
spring的面向切面编程是基于动态代理来实现的 静态代理：也就是自己手动创建的代理对象 动态代理：也就是在程序运行中通过配置参数产生 在spring中动态代理有两种 第一种JDK自带的动态代理（JDK是基于接口） JDK动态代理是利用反射机制生成一个实现代理接口的匿名类，JDK动态代理依赖于Proxy和InvocationHandler接口。 需要指定一个类加载器，然后生成的代理对象实现类的接口或类的类型，接着处理额外功能， 第...
spring-boot-starter-aop
最新发布
04-02
The spring-boot-starter-aop is a starter module in the Spring Boot framework that provides support for Aspect-Oriented Programming (AOP). AOP is a programming paradigm that enables the separation of ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值