MyBatis核心机制

于 2024-08-23 09:18:17 发布
阅读量605 收藏 4
点赞数 3
分类专栏： SSM底层机制 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64637029/article/details/141453239
版权

实现MyBatis核心机制环境搭建

1.核心框架示意图

img

2.模块搭建

1.创建maven项目

CleanShot 2024-08-08 at 15.29.52@2x

2.引入依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.sunxiansheng</groupId>
        <artifactId>core_mechanisms</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>sun-mybatis</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- 解析xml -->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.30</version>
        </dependency>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
        </dependency>
    </dependencies>

</project>
3.连接数据库
4.数据库表设计
CREATE DATABASE `sun_mybatis`;
USE `sun_mybatis`;

CREATE TABLE `monster`
(
    `id`       INT          NOT NULL AUTO_INCREMENT,
    `age`      INT          NOT NULL,
    `birthday` DATE DEFAULT NULL,
    `email`    VARCHAR(255) NOT NULL,
    `gender`   TINYINT      NOT NULL,
    `name`     VARCHAR(255) NOT NULL,
    `salary`   DOUBLE       NOT NULL,
    PRIMARY KEY (`id`)
) CHARSET = utf8;

INSERT INTO `monster` (`age`, `birthday`, `email`, `gender`, `name`, `salary`)
VALUES (25, '1998-01-15', 'example@example.com', 1, 'John Doe', 50000.00);

3.设计图

img

读取配置文件，得到数据库连接

1.目录

CleanShot 2024-08-08 at 16.57.51@2x

2.sun-config.xml 配置文件

<?xml version="1.0" encoding="utf-8" ?>
<!-- 配置数据库连接信息 -->
<database>
    <!-- 驱动 -->
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <!-- 连接地址 -->
    <property name="url" value="jdbc:mysql://bj--grp-.sql.tencentcdb.com:24169/sun_mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>    <!-- 用户名 -->
    <!-- 用户名 -->
    <property name="username" value=""/>
    <!-- 密码 -->
    <property name="password" value=""/>
</database>

3.SunConfiguration.java 读取配置文件获取数据库连接

package com.sunxiansheng.mybatis.sqlsession;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;

/**
 * Description: 读取xml配置文件
 *
 * @Author sun
 * @Create 2024/8/8 16:25
 * @Version 1.0
 */
public class SunConfiguration {

    private static final Logger log = LoggerFactory.getLogger(SunConfiguration.class);
    private static ClassLoader loader = ClassLoader.getSystemClassLoader();

    /**
     * 读取xml文件
     *
     * @param resource 这个必须是类路径下的文件路径，不用带第一个斜杠，sun-config.xml就可以
     * @return
     */
    public Connection build(String resource) {
        InputStream resourceAsStream = loader.getResourceAsStream(resource);
        // 使用dom4j解析配置文件
        SAXReader saxReader = new SAXReader();
        try {
            // 获取文档
            Document document = saxReader.read(resourceAsStream);
            // 根元素
            Element rootElement = document.getRootElement();
            // 根元素下的所有property元素
            List<Element> property = rootElement.elements("property");
            // 初始化连接信息
            String driverClassName = null;
            String url = null;
            String username = null;
            String password = null;
            // 遍历property元素获取连接信息
            for (Element element : property) {
                String name = element.attributeValue("name");
                String value = element.attributeValue("value");
                switch (name) {
                    case "driverClassName":
                        driverClassName = value;
                        log.info("加载驱动类:{}", value);
                        break;
                    case "url":
                        url = value;
                        log.info("加载url:{}", value);
                        break;
                    case "username":
                        username = value;
                        log.info("加载用户名:{}", value);
                        break;
                    case "password":
                        password = value;
                        log.info("加载密码:{}", value);
                        break;
                    default:
                        throw new RuntimeException("未知的property属性名");
                }
            }
            // 类加载驱动类
            Class.forName(driverClassName);
            return DriverManager.getConnection(url, username, password);
        } catch (DocumentException | ClassNotFoundException | SQLException e) {
            log.error("解析xml配置文件失败", e);
            throw new RuntimeException(e);
        }
    }

}

4.SunConfigurationTest.java 测试

package com.sunxiansheng.mybatis.sqlsession;

import org.junit.Test;

import java.sql.Connection;

/**
 * Description: 读取xml配置文件
 *
 * @Author sun
 * @Create 2024/8/8 16:25
 * @Version 1.0
 */
public class SunConfigurationTest {

    @Test
    public void build() {
        SunConfiguration sunConfiguration = new SunConfiguration();
        Connection build = sunConfiguration.build("sun-config.xml");
        System.out.println("build = " + build);
    }

}

使用SunExecutor来执行SQL

1.目录

CleanShot 2024-08-09 at 13.02.47@2x

2.Monster.java

package com.sunxiansheng.mybatis.entity;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

@Data
public class Monster implements Serializable {

    private Integer id;

    private Integer age;

    private Date birthday;

    private String email;

    private Byte gender;

    private String name;

    private Double salary;

    private static final long serialVersionUID = 1L;
}

3.Executor.java

package com.sunxiansheng.mybatis.sqlsession;

/**
 * Description: 执行器接口
 *
 * @Author sun
 * @Create 2024/8/9 12:37
 * @Version 1.0
 */
public interface Executor {

    public <T> T query(String sql, Object parameter);

}

4.SunExecutor.java 具体的执行器

package com.sunxiansheng.mybatis.sqlsession;

import com.sunxiansheng.mybatis.entity.Monster;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

/**
 * Description: 执行器
 *
 * @Author sun
 * @Create 2024/8/9 12:39
 * @Version 1.0
 */
public class SunExecutor implements Executor{

    public static final SunConfiguration configuration = new SunConfiguration();

    private static final Logger log = LoggerFactory.getLogger(SunExecutor.class);

    @Override
    public <T> T query(String sql, Object parameter) {
        // 获取DB连接
        Connection connection = configuration.build("sun-config.xml");
        log.info("获取连接:{}", connection);
        ResultSet resultSet = null;
        PreparedStatement preparedStatement = null;
        // 实体类
        Monster monster = new Monster();
        try {
            // sql预处理
            preparedStatement = connection.prepareStatement(sql);
            // 填参数
            preparedStatement.setString(1, parameter.toString());
            // 执行查询
            resultSet = preparedStatement.executeQuery();
            // 将结果封装到实体类中（写死了）
            while (resultSet.next()) {
                monster.setId(resultSet.getInt("id"));
                monster.setAge(resultSet.getInt("age"));
                monster.setBirthday(resultSet.getDate("birthday"));
                monster.setEmail(resultSet.getString("email"));
                monster.setGender(resultSet.getByte("gender"));
                monster.setName(resultSet.getString("name"));
                monster.setSalary(resultSet.getDouble("salary"));
            }
            log.info("查询结果:{}", monster);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            // 关闭资源
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
                if (preparedStatement != null) {
                    preparedStatement.close();
                }
                if (connection != null) {
                    connection.close();
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        // 这里的T是由类型推断来指定的，也就是使用什么类型接受，就返回什么类型
        return (T) monster;
    }

}

5.SunConfigurationTest.java 测试

@Test
public void executor() {
    SunExecutor sunExecutor = new SunExecutor();
    // 这里是使用的类型推断自动转换类型
    Monster monster = sunExecutor.query("select * from monster where id = ?", 1);
}

将SqlSession封装到执行器

1.目录

CleanShot 2024-08-09 at 13.17.02@2x

2.SunSqlSession.java

package com.sunxiansheng.mybatis.sqlsession;

/**
 * Description: SqlSession
 *
 * @Author sun
 * @Create 2024/8/9 13:08
 * @Version 1.0
 */
public class SunSqlSession {

    // 执行器（操作db）
    private Executor executor = new SunExecutor();
    // 配置（用于获取连接）
    private SunConfiguration configuration = new SunConfiguration();

    public <T> T selectOne(String statement, Object parameter) {
        return executor.query(statement, parameter);
    }
}

3.测试

@Test
public void selectOne() {
    SunSqlSession sunSqlSession = new SunSqlSession();
    Monster monster = sunSqlSession.selectOne("select * from monster where id = ?", 1);
    System.out.println("monster = " + monster);
}

开发MapperBean和Function

1.目录

CleanShot 2024-08-09 at 13.39.36@2x

2.MonsterMapper.java

package com.sunxiansheng.mapper;

import com.sunxiansheng.entity.Monster;

/**
 * Description: MonsterMapper
 *
 * @Author sun
 * @Create 2024/8/9 13:21
 * @Version 1.0
 */
public interface MonsterMapper {

    public Monster getMonsterById(Integer id);

}

3.MonsterMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<mapper namespace="com.sunxiansheng.mapper.MonsterMapper">
    <select id="getMonsterById" resultType="com.sunxiansheng.entity.Monster">
        select * from monster where id = ?
    </select>
</mapper>

4.Function.java 记录对应的mapper.xml的方法信息

package com.sunxiansheng.mybatis.config;

import lombok.Data;

/**
 * Description: 记录对应的mapper.xml的方法信息
 *
 * @Author sun
 * @Create 2024/8/9 13:31
 * @Version 1.0
 */
@Data
public class Function {

    /**
     * sql类型
     */
    private String sqlType;

    /**
     * 方法名
     */
    private String funcName;

    /**
     * SQL语句
     */
    private String sql;

    /**
     * 返回类型
     */
    private Object resultType;

}

5.MapperBean.java 将mapper接口信息进行封装

package com.sunxiansheng.mybatis.config;

import java.util.List;

/**
 * Description: 将mapper接口信息进行封装
 *
 * @Author sun
 * @Create 2024/8/9 13:35
 * @Version 1.0
 */
public class MapperBean {

    /**
     * 接口全路径
     */
    private String interfaceName;

    /**
     * 方法列表
     */
    private List<Function> functions;

}

读取xml文件解析MapperBean

1.目录

CleanShot 2024-08-09 at 14.03.00@2x

2.Function.java 加链式调用注解

CleanShot 2024-08-09 at 14.03.31@2x

3.MapperBean.java 加Data注解

CleanShot 2024-08-09 at 14.03.51@2x

4. SunConfiguration.java 增加解析MapperBean的方法

/**
 * 读取mapper.xml文件，构建MapperBean
 * @param path
 * @return
 */
public MapperBean readMapper(String path) {
    // 要返回的结果
    MapperBean mapperBean = new MapperBean();
    // 使用类加载器读取配置文件
    ClassLoader loader = ClassLoader.getSystemClassLoader();
    InputStream resourceAsStream = loader.getResourceAsStream(path);
    // 解析xml文件
    SAXReader saxReader = new SAXReader();
    try {
        // 获取文档
        Document document = saxReader.read(resourceAsStream);
        // 获取根元素
        Element rootElement = document.getRootElement();
        // 获取根元素的属性：namespace
        String namespace = rootElement.attributeValue("namespace");
        // 获取子元素
        List<Element> elements = rootElement.elements();
        // 遍历子元素
        List<Function> functions = elements.stream().map(
                element -> {
                    Function function = new Function();
                    // 获取sql类型
                    String sqlType = element.getName();
                    // 获取方法名
                    String funcName = element.attributeValue("id");
                    // 获取返回类型
                    String resultType = element.attributeValue("resultType");
                    // 获取sql语句
                    String sql = element.getTextTrim();
                    // 封装到Function对象中
                    function.setSqlType(sqlType)
                            .setFuncName(funcName)
                            .setResultType(resultType)
                            .setSql(sql);
                    return function;
                }
        ).collect(Collectors.toList());
        // 构建MapperBean
        mapperBean.setInterfaceName(namespace);
        mapperBean.setFunctions(functions);
    } catch (DocumentException e) {
        throw new RuntimeException(e);
    }
    // 输出mapperBean的日志
    log.info("mapperBean:{}", mapperBean);
    return mapperBean;
}

5.SunConfigurationTest.java 测试

    @Test
    public void readMapper() {
        SunConfiguration sunConfiguration = new SunConfiguration();
        sunConfiguration.readMapper("MonsterMapper.xml");
    }

CleanShot 2024-08-09 at 14.05.29@2x

动态代理Mapper方法

1.目录

CleanShot 2024-08-09 at 14.58.13@2x

2.MapperProxyFactory.java 代理工厂，可以获取接口的代理对象

package com.sunxiansheng.mybatis.sqlsession;

import java.lang.reflect.Proxy;

/**
 * Description: 代理工厂
 *
 * @Author sun
 * @Create 2024/8/9 14:14
 * @Version 1.0
 */
public class MapperProxyFactory {

    public static <T> T getMapperProxy(Class<T> clazz, SunSqlSession sunSqlSession, SunConfiguration sunConfiguration) {
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, new SunMapperProxy(sunSqlSession, clazz, sunConfiguration));
    }

}

3.SunMapperProxy.java 代理逻辑

package com.sunxiansheng.mybatis.sqlsession;

import com.sunxiansheng.mybatis.config.Function;
import com.sunxiansheng.mybatis.config.MapperBean;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.List;

/**
 * Description: 代理Mapper接口
 *
 * @Author sun
 * @Create 2024/8/9 14:08
 * @Version 1.0
 */
public class SunMapperProxy implements InvocationHandler {

    private static final Logger log = LoggerFactory.getLogger(SunMapperProxy.class);
    /**
     * 用于连接数据库和执行sql
     */
    private SunSqlSession sunSqlSession;

    /**
     * mapper文件名
     */
    private String mapperFile;

    /**
     * 配置类（可以根据mapper文件名来获取MapperBean）
     */
    private SunConfiguration sunConfiguration;

    public SunMapperProxy(SunSqlSession sunSqlSession, Class<?> mapperFile, SunConfiguration sunConfiguration) {
        this.sunSqlSession = sunSqlSession;
        this.mapperFile = mapperFile.getSimpleName() + ".xml";
        this.sunConfiguration = sunConfiguration;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 获取方法名
        String methodName = method.getName();
        // 获取MapperBean
        MapperBean readMapper = sunConfiguration.readMapper(mapperFile);
        // 获取Function列表，过滤出需要执行的Function
        List<Function> functions = readMapper.getFunctions();
        Function targetFunction = null;
        for (Function function : functions) {
            if (methodName.equals(function.getFuncName())) {
                targetFunction = function;
                break;
            }
        }
        // 获取Function的信息
        String sqlType = targetFunction.getSqlType();
        String sql = targetFunction.getSql();
        // 将sql的第一个问号使用参数替换，使用字符串处理
        // 根据sqlType执行sql
        if (sqlType.equals("select")) {
            Object selected = sunSqlSession.selectOne(sql, args[0]);
            log.info("invoke查询结果：{}", selected);
            return selected;
        }
        return null;
    }
}

4.测试

@Test
public void getResult() {
    MonsterMapper mapperProxy = MapperProxyFactory.getMapperProxy(MonsterMapper.class, new SunSqlSession(), new SunConfiguration());
    Monster monsterById = mapperProxy.getMonsterById(1);
}
S-X-S
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
MyBatis核心配置文件
qq_46926869的博客
11-24 1767
MyBatis核心配置文件解释
Mybatis核心的几个包
05-07
通过Mybatis的动态代理机制，当调用Mapper接口方法时，Mybatis会自动执行对应的SQL并处理结果。 5. **Executor**: 执行器是Mybatis内部处理SQL的核心组件，它负责执行SQL语句。Executor有SimpleExecutor、...
MyBatis 插件机制详解
FireFox1997
06-17 1222
MyBatis 的插件机制是基于 Java 的动态代理实现的，允许我们拦截 SQL 执行的某些步骤，如：创建 Executor、ParameterHandler、ResultSetHandler 和 StatementHandler 对象的过程。通过插件机制，开发者可以在这些步骤中添加自定义的逻辑。SQL 日志记录参数验证和修改查询结果处理性能监控MyBatis 插件机制提供了一种灵活的方式，允许开发者在 SQL 执行的各个阶段插入自定义逻辑，极大地增强了 MyBatis 的扩展能力。
Mybatis核心原理
SlagSea
07-18 3996
简介 Mybatis是一款流行的持久层框架，基于ORM(Object-Relation Mapper)思想，对针对JDBC的封装，通过xml配置支持灵活复杂的SQL查询。 框架组件架构图 Mybatis核心成员数据流 核心成员说明 核心成员 功能说明 Configuration 保存MyBatis大部分配置信息 SqlSession MyBatis主要的顶层API，与数据库交互，实现数据库增删改查功能。 Executor MyBatis 调度器，负责SQL语句的生成和查询缓存的维护
Mybatis的缓存机制
qq_45794852的博客
05-28 1704
mybatis提供查询缓存，用于减轻数据压力，提高数据库性能。mybaits提供一级缓存，和二级缓存。一级缓存是基于SqlSession的作用范围，而二级缓存是基于mapper的namespace作用范围的。
MyBatis 的缓存机制
weixin_61635597的博客
06-16 992
MyBatis 缓存包括：一级缓存：将查询到的数据存储到 SqlSession 中二级缓存：将查询到的数据存储到 SqlSessionFactory 中或者是集成其它第三方的缓存：比如 EhCache(Java语言开发的)，Memcache(C语言开发的)等。注意：缓存只针对于 DQL(查询)语句，也就是说缓存机制只对应 Select 语句。一级缓存默认是开启的一级缓存失效情况包括两种：第一种：第一次查询和第二次查询之间，手动清空了一级缓存。
MyBatis 缓存机制
m0_52861684的博客
11-22 1320
MyBatis 提供一级缓存和二级缓存，大大提高数据库的查询效率。
MyBatis插件机制
超级博客
06-09 1421
MyBatis拦截器的接口定义，plugin方法用于某些处理器(Handler)的构建过程。interceptor方法用于处理代理类的执行。MyBatis默认没有一个拦截器接口的实现类。
Mybatis的核心配置文件
m0_61925586的博客
03-25 1043
使用typeAliases标签 来给类起别名所有的别名都不区分大小写namespace不能使用别名机制。
MyBatis核心源码深度剖析工作机制和实现原理
赵广陆
05-17 1014
目录1 MyBatis源码分析导入1.1 为什么要看MyBatis框架的源码1.2 如何深入学习MyBatis源码1.3 源码分析的5大原则2 MyBatis架构体系深入剖析2.1 MyBatis的整体架构体系2.2 MyBatis的工作机制和实现原理2.2.1 接口层2.2.1.1 获取SqlSession流程分析2.2.1.2 SqlSession源码分析2.2.2 数据处理核心层2.2.2.1 配置解析(参数映射)2.2.2.2 SQL解析（SqlSource）2.2.2.3 SQL执行（Execut
MyBatis缓存机制
心态的博客
11-04 1982
Mybatis缓存机制分为一级缓存和二级缓存。为提高查询效率，更加减轻数据库的工作量。
Mybatis插件机制详解
06-17
Mybatis插件机制提供了一种强大的扩展方式，使得开发者能够在不影响核心代码的情况下增加额外的功能。通过深入了解Mybatis插件的工作原理，开发者可以更好地利用这一特性来增强应用程序的功能性和性能。
MyBatis核心教程
09-27
### MyBatis核心教程 #### 1. 引言 ##### 1.1 为何选择mybatis-guice——动机 在日常工作中，我们经常同时使用MyBatis SQL Mapper和Google Guice框架，并逐渐意识到在不同的项目中重复编写相同的代码片段。为了...
mybatis的插件机制示例详解
08-25
MyBatis插件机制详解 MyBatis是一个广泛应用的优秀的ORM框架，已经成了JavaWeb世界近乎...MyBatis插件机制是一个强大的功能，允许开发者对MyBatis的四大核心对象进行拦截和扩展，提高了MyBatis的灵活性和可扩展性。
Mybatis核心应用配置与原理解析1
08-08
Mybatis核心应用配置与原理解析 Mybatis 作为一个流行的持久层框架，提供了强大的缓存机制来提高应用程序的性能。缓存机制可以分为一级缓存和二级缓存两种。下面我们将对 Mybatis 的缓存机制进行详细的分析和解释。...
MyBatis的插件机制简介.pdf
最新发布
06-27
### MyBatis插件机制详解 #### 一、MyBatis插件机制概述 MyBatis作为一款优秀的持久层框架，提供了丰富的扩展性，其中插件机制是其灵活性的重要体现之一。通过插件机制，开发者可以在不修改源码的情况下对MyBatis...
mybatis demo
06-23
- 缓存：MyBatis提供了本地缓存机制，可以缓存单个Mapper的查询结果，提高性能。学习者会了解到一级缓存和二级缓存的配置和使用方式。 此外，这个MyBatis Demo还可能涉及到： - 使用MyBatis的Java API或者Spring...
mybatis查询匹配机制图文详解
09-07
在MyBatis中，查询匹配机制是其核心功能之一，它决定了如何根据Java代码中的方法调用来找到相应的SQL语句并执行。下面我们将深入探讨MyBatis的两种主要查询匹配机制。 ### 第一种查询方式匹配机制 1. **定位Mapper...
第三章 MyBatis的核心配置.docx
03-19
MyBatis核心配置 MyBatis是一款流行的持久层框架，它提供了强大的配置机制，允许开发者灵活地配置和customization。第三章MyBatis的核心配置是了解MyBatis的基础知识的关键。 3.1 MyBatis核心对象 MyBatis的核心...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

S-X-S

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值