(二)自定义实现 Mybatis 框架

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量154 收藏
点赞数
分类专栏： MyBatis框架学习 文章标签： mybatis java jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyj_010/article/details/105582588
版权

 　　在本节内容，我们通过自定义实现一些 MyBatis 框架的核心组件类和相关类，来实现自己的 MyBatis 框架，这里主要是模拟实现 MyBatis 框架的查询功能。

1、创建工程环境

 　　为简便开发，我们直接在入门案例（(一)MyBatis入门）的基础上进行开发，在 pom.xml 中删除 MyBatis 的依赖，并添加解析 XML 文件的依赖：

	<dependencies>
        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.8</version>
            <scope>runtime</scope>
        </dependency>
        <!-- 日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!-- JUnit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!-- 解析 xml 的 dom4j -->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <!-- dom4j 的依赖包 jaxen -->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
    </dependencies>

 　　在移除 MyBatis 的依赖后，在配置文件中，删除 MyBatis 的约束：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

 　　在移除 MyBatis 的依赖后，可以看到以下都是需要我们自己实现的类和接口：
在这里插入图片描述

2、自定义实现

2.1 读取配置文件信息
  • Resources：读取配置文件类，用类加载器读取配置文件，并获取输入字节流。
public class Resources {
    public static InputStream getResourceAsStream(String filePath) {
        return Resources.class.getClassLoader().getResourceAsStream(filePath);
    }
}
2.2 封装配置文件信息
  • Mapper：映射器类，用于封装执行的 sql 语句和结果类型的全限定类名。
public class Mapper {
    private String queryString;
    private String resultType;

    public String getQueryString() {
        return queryString;
    }

    public void setQueryString(String queryString) {
        this.queryString = queryString;
    }

    public String getResultType() {
        return resultType;
    }

    public void setResultType(String resultType) {
        this.resultType = resultType;
    }

}
  • Configuration：MyBatis 的配置类，封装数据库连接信息和映射器map。
public class Configuration {
    private String driver;
    private String url;
    private String username;
    private String password;
    
    private Map<String, Mapper> mappers = new HashMap<String, Mapper>();

    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Map<String, Mapper> getMappers() {
        return mappers;
    }

    public void setMappers(Map<String, Mapper> mappers) {
        // 使用put的方式，存放所有的映射器
        this.mappers.putAll(mappers);
    }
}
2.3 工具类
  • DataSourceUtils：数据库工具类，负责创建与数据库的连接。
public class DataSourceUtils {
    public static Connection getConnection(Configuration cfg) {
        try {
            Class.forName(cfg.getDriver());
            return DriverManager.getConnection(cfg.getUrl(), cfg.getUsername(), cfg.getPassword());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
  • Select：自定义查询注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Select {
    // 查询sql语句
    String value();
}
  • XMLConfigBuilder：解析工具类，用来解析 XML 配置文件和 Dao 接口的注解。
public class XMLConfigBuilder {
    public static Configuration loadConfiguration(InputStream config){
        try{
            // 定义封装的配置对象
            Configuration cfg = new Configuration();

            // 1.获取SAXReader对象
            SAXReader reader = new SAXReader();
            // 2.根据字节输入流获取Document对象
            Document document = reader.read(config);
            // 3.获取根节点
            Element root = document.getRootElement();
            // 4.使用xpath中选择指定节点的方式，获取所有property节点
            List<Element> propertyElements = root.selectNodes("//property");
            // 5.遍历节点
            for(Element propertyElement : propertyElements){
                String name = propertyElement.attributeValue("name");
                if("driver".equals(name)){
                    // 获取驱动信息
                    String driver = propertyElement.attributeValue("value");
                    cfg.setDriver(driver);
                }
                if("url".equals(name)){
                    // 获取连接 url 信息
                    String url = propertyElement.attributeValue("value");
                    cfg.setUrl(url);
                }
                if("username".equals(name)){
                    // 获取用户名信息
                    String username = propertyElement.attributeValue("value");
                    cfg.setUsername(username);
                }
                if("password".equals(name)){
                    // 获取密码信息
                    String password = propertyElement.attributeValue("value");
                    cfg.setPassword(password);
                }
            }
            
            // 取出mappers中的所有mapper标签，判断他们使用了resource还是class属性
            List<Element> mapperElements = root.selectNodes("//mappers/mapper");
            for(Element mapperElement : mapperElements){
                Attribute attribute = mapperElement.attribute("resource");
                if(attribute != null){
                    System.out.println("基于XML开发");
                    // 获取映射 xml 文件路径
                    String mapperPath = attribute.getValue();
                    // 获取映射配置文件的内容，封装成一个map
                    Map<String, Mapper> mappers = loadMapperConfiguration(mapperPath);
                    // 添加到configuration中的mappers
                    cfg.setMappers(mappers);
                }else{
                    System.out.println("基于注解开发");
                    // 获取class属性的值
                    String daoClassPath = mapperElement.attributeValue("class");
                    // 根据daoClassPath获取封装的必要信息
                    Map<String,Mapper> mappers = loadMapperAnnotation(daoClassPath);
                    // 添加到configuration中的mappers
                    cfg.setMappers(mappers);
                }
            }
            return cfg;
        }catch(Exception e){
            throw new RuntimeException(e);
        }finally{
            try {
                config.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }

    }

    /**
     * 根据传入的参数，解析XML，并且封装到Map中
     * @param mapperPath    映射配置文件的位置
     * @return  key是由dao的全限定类名和方法名组成，value是一个Mapper对象
     */
    private static Map<String,Mapper> loadMapperConfiguration(String mapperPath)throws IOException {
        InputStream in = null;
        try{
            Map<String,Mapper> mappers = new HashMap<String,Mapper>();
            // 1.根据路径获取字节输入流
            in = Resources.getResourceAsStream(mapperPath);
            // 2.根据字节输入流获取Document对象
            SAXReader reader = new SAXReader();
            Document document = reader.read(in);
            // 3.获取根节点
            Element root = document.getRootElement();
            // 4.获取根节点的namespace属性取值
            String namespace = root.attributeValue("namespace");//是组成map中key的部分
            // 5.获取所有的select节点
            List<Element> selectElements = root.selectNodes("//select");
            // 6.遍历select节点集合
            for(Element selectElement : selectElements){
                // 取出id属性的值      组成map中key的部分
                String id = selectElement.attributeValue("id");
                // 取出resultType属性的值  组成map中value的部分
                String resultType = selectElement.attributeValue("resultType");
                // 取出文本内容            组成map中value的部分
                String queryString = selectElement.getText();
                // 创建Key
                String key = namespace+"."+id;
                // 创建Value
                Mapper mapper = new Mapper();
                mapper.setQueryString(queryString);
                mapper.setResultType(resultType);
                // 把key和value存入mappers中
                mappers.put(key,mapper);
            }
            return mappers;
        }catch(Exception e){
            throw new RuntimeException(e);
        }finally{
            in.close();
        }
    }

    /**
     * 根据传入的参数，得到dao中所有被select注解标注的方法。
     * 根据方法名称和类名，以及方法上注解value属性的值，组成Mapper的必要信息
     * @param daoClassPath
     * @return
     */
    private static Map<String,Mapper> loadMapperAnnotation(String daoClassPath)throws Exception{
        Map<String,Mapper> mappers = new HashMap<String, Mapper>();

        // 1.得到dao接口的字节码对象
        Class daoClass = Class.forName(daoClassPath);
        // 2.得到dao接口中的方法数组
        Method[] methods = daoClass.getMethods();
        // 3.遍历Method数组
        for(Method method : methods){
            // 取出每一个方法，判断是否有select注解
            boolean isAnnotated = method.isAnnotationPresent(Select.class);
            if(isAnnotated){
                // 创建Mapper对象
                Mapper mapper = new Mapper();
                // 取出注解的value属性值
                Select selectAnno = method.getAnnotation(Select.class);
                String queryString = selectAnno.value();
                mapper.setQueryString(queryString);
                // 获取当前方法的返回值，还要求必须带有泛型信息
                Type type = method.getGenericReturnType();//List<User>
                // 判断type是不是参数化的类型
                if(type instanceof ParameterizedType){
                    ParameterizedType ptype = (ParameterizedType)type;
                    // 得到参数化类型中的实际类型参数
                    Type[] types = ptype.getActualTypeArguments();
                    // 取出第一个，参数化类型可能为 <k,v> 形式
                    Class domainClass = (Class)types[0];
                    // 获取domainClass的类名
                    String resultType = domainClass.getName();
                    // 给Mapper赋值
                    mapper.setResultType(resultType);
                }
                // 组装key的信息
                String methodName = method.getName();
                String className = method.getDeclaringClass().getName();
                String key = className+"."+methodName;
                // 给map赋值
                mappers.put(key,mapper);
            }
        }
        return mappers;
    }
}
  • Executor：用于执行jdbc相关操作，负责执行SQL语句，并且封装结果集。
public class Executor {

    public <E> List<E> selectList(Mapper mapper, Connection conn) {
        PreparedStatement pstm = null;
        ResultSet rs = null;
        try {
            // 1.取出mapper中的数据
            String queryString = mapper.getQueryString();
            String resultType = mapper.getResultType();
            Class domainClass = Class.forName(resultType);
            // 2.获取PreparedStatement对象
            pstm = conn.prepareStatement(queryString);
            // 3.执行SQL语句，获取结果集
            rs = pstm.executeQuery();
            // 4.封装结果集
            List<E> list = new ArrayList<E>();
            while(rs.next()) {
                // 实例化要封装的实体类对象
                E obj = (E)domainClass.newInstance();

                // 取出结果集的元信息：ResultSetMetaData
                ResultSetMetaData rsmd = rs.getMetaData();
                // 取出总列数
                int columnCount = rsmd.getColumnCount();
                // 遍历总列数
                for (int i = 1; i <= columnCount; i++) {
                    // 获取每列的名称，列名的序号是从1开始的
                    String columnName = rsmd.getColumnName(i);
                    // 根据得到列名，获取每列的值
                    Object columnValue = rs.getObject(columnName);
                    // 给obj赋值：使用Java内省机制（借助PropertyDescriptor实现属性的封装）
                    // 要求：实体类的属性和数据库表的列名保持一致
                    PropertyDescriptor pd = new PropertyDescriptor(columnName,domainClass);
                    // 获取它的写入方法
                    Method writeMethod = pd.getWriteMethod();
                    // 把获取的列的值，给对象赋值
                    writeMethod.invoke(obj,columnValue);
                }
                // 把赋好值的对象加入到集合中
                list.add(obj);
            }
            return list;
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            release(pstm,rs);
        }
    }


    private void release(PreparedStatement pstm, ResultSet rs){
        if(rs != null){
            try {
                rs.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }

        if(pstm != null){
            try {
                pstm.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}
2.4 核心组件类
  • MapperProxy：代理类，在调用 Dao 接口方法时进行增强。
public class MapperProxy implements InvocationHandler {

    private Map<String, Mapper> mappers;
    private Connection conn;

    public MapperProxy(Map<String, Mapper> mappers, Connection conn) {
        this.mappers = mappers;
        this.conn = conn;
    }

    /**
     * 对方法进行增强，其实就是调用工具类的selectList方法
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 获取方法名
        String methodName = method.getName();
        // 获取方法所在的类的名称
        String className = method.getDeclaringClass().getName();
        // 组合key
        String key = className + "." + methodName;
        // 获取Mapper
        Mapper mapper = mappers.get(key);
        // 判断是否有mapper
        if (mapper == null) {
            throw new IllegalArgumentException("传入的参数有误");
        }
        // 调用工具类进行查询
        return new Executor().selectList(mapper, conn);
    }
}
  • SqlSession：自定义 Mybatis 中和数据库交互的核心类，可以创建dao接口的代理对象。
public interface SqlSession {
    
    // 根据参数创建一个代理对象
    <T> T getMapper(Class<T> daoInterfaceClass);

    // 释放资源
    void close();
}
  • DefaultSqlSession：SqlSession接口的实现类
public class DefaultSqlSession implements SqlSession {

    private Configuration cfg;
    private Connection conn;

    public DefaultSqlSession(Configuration cfg) {
        this.cfg = cfg;
        conn = DataSourceUtils.getConnection(cfg);
    }

    /**
     * 创建代理对象
     * @param daoInterfaceClass dao接口的字节码对象
     */
    public <T> T getMapper(Class<T> daoInterfaceClass) {
        return (T) Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(),
                new Class[]{daoInterfaceClass}, new MapperProxy(cfg.getMappers(), conn));
    }

    // 释放资源
    public void close() {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}
  • SqlSessionFactory
public interface SqlSessionFactory {
    // 用于打开一个新的SqlSession对象
    SqlSession openSession();
}
  • DefaultSqlSessionFactory：SqlSessionFactory接口的实现类
public class DefaultSqlSessionFactory implements SqlSessionFactory {
    private Configuration cfg;

    public DefaultSqlSessionFactory(Configuration cfg) {
        this.cfg = cfg;
    }

    // 用于创建SqlSession对象
    public SqlSession openSession() {
        return new DefaultSqlSession(cfg);
    }
}
  • SqlSessionFactoryBuilder：构建者类 ，用于构建SqlSessionFactory工厂
public class SqlSessionFactoryBuilder {
    // 通过字节输入流构建一个SqlSessionFactory工厂
    public SqlSessionFactory build(InputStream config) {
        Configuration cfg = XMLConfigBuilder.loadConfiguration(config);
        return new DefaultSqlSessionFactory(cfg);
    }
}
2.5 测试类
  • 测试类，重新导入需要的类后，报错消除
public class MybatisTest {

    public static void main(String[] args) throws Exception{
        // 1. 读取配置文件
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        // 2. 创建 SqlSessionFactory 工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        // 3. 获取 SqlSession 对象
        SqlSession sqlSession = factory.openSession();
        // 4. 使用 SqlSession 创建 Mapper 的代理对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        // 5. 使用代理对象执行查询
        List<User> users = mapper.findAll();
        for(User user : users){
            System.out.println(user);
        }
        // 6. 释放资源
        sqlSession.close();
        in.close();
    }
}

3、运行结果

  • 工程目录：
    在这里插入图片描述
  • 基于xml测试：
    在这里插入图片描述
  • 基于注解测试：
    在这里插入图片描述
lyj_010
关注
专栏目录
自定义Mybatis框架(XML)
05-14
自定义mybatis框架所需的工具类
mybatis自定义标签.zip
01-20
自定义标签是MyBatis框架的一大特色，它允许我们扩展XML映射文件中的标签，以满足特定的业务场景。下面我们将深入探讨如何在MyBatis中实现自定义标签，并通过具体的代码示例来展示其实现过程。 首先，创建自定义...
实现一个自定义的Mybatis
不喝阔落的博客
09-30 287
实现自定义的 Mybatis 框架 自定义Mybatis概述 原生 JDBC 存在的问题 问题描述 数据库链接信息、注册驱动、Sql 语句硬编码的问题，代码不易维护 频繁创建释放数据库链接造成资源的浪费 结果集需要手动封装，非常麻烦 解决方案 硬编码问题可以通过配置文件来解决 引入数据库连接池，解决频繁释放资源造成的问题 使用反射、动态代理，减少重复代码，根据执行条件动态执行sql 自定义 Mybatis 架构图 实现自定义 Mybatis 框架 pom 文件 <properties>
Mybatis（5）自定义Mybatis分析以及自定义实现
xiaobumi123的博客
11-01 339
执行查询所有和创建代理对象的分析 执行查询所有分析，是对selectList（）方法的执行，执行步骤如下 提供：连接信息和映射信息 1.读取配置文件，SqlMapConfig.xml->IUserDao.xml 2.对执行SQL查询 3.对查询结果进行封装 在封装时，Element是利用反射技术来获得对象 在封装时，使用反射技术为Element的属性赋值 创建代理对象的分析 主要是getMapper（）方法的实现 自定义实现 同Myatis（1）创建项目 更改1，删除po.
MyBatis学习笔记（一）MyBatis介绍、入门案例以及自定义实现MyBatis
sc的博客
11-06 186
一、MyBatis介绍、入门案例以及自定义实现MyBatis 1、什么是框架？ 它是我们软件开发中的一套解决方案，不同的框架解决的是不同的问题。 使用框架的好处： 框架封装了很多的细节，使开发者可以使用极简的方式实现功能。大大提高开发效率。 2、三层架构 表现层：是用于展示数据的 业务层：是处理业务需求（Spring不属于任何一个层） 持久层：是和数据库交互的 3、持久层技术解决方案 JDB...
Mybatis-@MapperScan和mybatis:scan分析
热门推荐
记录进步-Jinken
04-20 1万+
MyBatis-Spring-1.2.0 新增了两种新的扫描映射器 Mapper 接口的方法： 使用&lt;mybatis:scan/&gt;元素 使用@MapperScan 注解（需要 Spring3.1+版本） &lt;mybatis:scan&gt;&lt;mybatis:scan&gt;元素将在特定的以逗号分隔的包名列表中搜索映射器 Mapper 接口。 使用这个新的 MyBatis-...
支付宝二面：Mybatis接口Mapper内的方法为啥不能重载吗？我直接懵逼了...
<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd
10-10 257
Python实战社群Java实战社群长按识别下方二维码，按需求添加扫码关注添加客服进Python社群▲扫码关注添加客服进Java社群▲作者丨祖大俊my.oschina.net/zudaj...
自定义mybatis框架
qq_38634814的博客
08-26 916
首先我们来回顾下MyBatis完成一个简单查询的步骤: 1.创建maven工程,导入相关依赖的jar包 2.创建实体类User 3.创建接口UserDao,定义方法findAll() 4.配置UserDao.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;!DOCTYPE mapper PUBLIC "-//myba...
自定义mybatis插件
qq_39839075的博客
08-14 504
import org/*** 类 描 述：字段名,下划线转驼峰插件*/ //拦截的类和方法,除了ResultSetHandler.class,还有另外3个也可以拦截的类,可以自己查查用法 @Intercepts(@Signature(type = ResultSetHandler . class , method = "handleResultSets" , args = {//如果是map类型,就对map的key进行转换 if(object instanceof Map) {
自定义Mybatis框架教程（二）
weixin_44796239的博客
09-23 151
自定义Mybatis框架教程（二）自定义Mybatis框架设计使用端（MybatisDemo） 自定义Mybatis框架设计 使用端（MybatisDemo） 提供核心配置文件
Mybatis框架
weixin_73200795的博客
06-28 6070
也就是说，可以将内存中的数据模型转换为存储模型，以及将存储模型转换为内存中的数据模型。内存中的数据模型可以是任意数据结构或对象模型，存储数据的类型可以是XML，二进制流，关系模型等。Mybatis框架是一个基于ORM的持久化框架，Mybatis框架不是一个完整的ORM实现，而是半自动化的ORM实现。Mybatis框架的主要特点是SQL映射器机制。1）id属性：用来在单个Mapper中做唯一标识，要求和接口中的方法名保持一致。优点： 与JDBC相比，减少了50%以上的代码量，最简单的持久化框架。
Mybatis框架基础
07-12
Mybatis框架基础 Mybatis是一个流行的关系型数据库访问框架，它的主要目的是为了简化Java开发者对数据库操作的复杂性，提供了一种快速实现数据访问的方法。在传统的Java开发中，使用JDBC（Java Database ...
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 5452
【代码】MybatisPlus的LambdaQueryWrapper用法。
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 133
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 811
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 868
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 251
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 408
函数式接口与回调函数
手写实现mybatis框架
07-28
手写实现MyBatis框架可以分为以下几个步骤： 1. 创建Maven工程并引入需要的依赖坐标。\[3\] 2. 编写Mybatis-config.xml配置文件，配置数据库连接信息、映射文件路径等。\[3\] 3. 创建XMLConfigBuilder类，用于解析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值