Sharding-JDBC读写分离探秘

最新推荐文章于 2024-09-22 21:58:06 发布
最新推荐文章于 2024-09-22 21:58:06 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： sharding-jdbc

前段时间写了篇如何使用Sharding-JDBC进行分库分表的例子，相信能够感受到Sharding-JDBC的强大了，而且使用配置都非常干净。官方支持的功能还包括读写分离、分布式主键、强制路由等。这里再介绍下如何在分库分表的基础上集成读写分离的功能。

读写分离的概念

就是为了缓解数据库压力，将写入和读取操作分离为不同数据源，写库称为主库，读库称为从库，一主库可配置多从库。

设置主从库后，第一个问题是如何进行主从的同步。官方不支持主从的同步，也不支持因为主从同步延迟导致的数据不一致问题。工程实践上进行主从同步有很多做法，一种常用的做法是每天定时同步或者实时同步。这个话题太大，暂不展开。

读写分离快速入门

读写可以单独使用，也可以配合分库分表进行使用，由于上个分库分表的例子是基于1.5.4.1版本进行说明的，这里为了紧跟官方的步伐，升级Sharding-JDBC到最新的2.0.0.M2

项目结构如下：

项目结构

pom依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>

         <!-- Sharding-JDBC核心依赖 -->
        <dependency>
            <groupId>io.shardingjdbc</groupId>
            <artifactId>sharding-jdbc-core</artifactId>
        </dependency>

        <!-- Sharding-JDBC Spring Boot Starter -->
        <dependency>
            <groupId>io.shardingjdbc</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

主从数据库配置

在配置前，我们希望分库分表规则和之前保持一致：

基于t_user表，根据city_id进行分库，如果city_id mod 2为奇数则落在ds_master_1库，偶数则落在ds_master_0库；根据user_id进行分表，如果user_id mod 2为奇数则落在t_user_1表，偶数则落在t_user_0表

读写分离规则：

读都落在从库，写落在主库

因为使用Sharding-JDBC Spring Boot Starter，所以只需要在properties配置文件配置主从库的数据源即可：


spring.application.name=spring-boot-mybatis-sharding-jdbc-masterslave
server.context-path=/springboot

mybatis.config-location=classpath:mybatis-config.xml

# 所有主从库
sharding.jdbc.datasource.names=ds_master_0,ds_master_1,ds_master_0_slave_0,ds_master_0_slave_1,ds_master_1_slave_0,ds_master_1_slave_1

# ds_master_0
sharding.jdbc.datasource.ds_master_0.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_0.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_0.url=jdbc:mysql://127.0.0.1:3306/ds_master_0?useSSL=false
sharding.jdbc.datasource.ds_master_0.username=travis
sharding.jdbc.datasource.ds_master_0.password=

# slave for ds_master_0
sharding.jdbc.datasource.ds_master_0_slave_0.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_0_slave_0.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_0_slave_0.url=jdbc:mysql://127.0.0.1:3306/ds_master_0_slave_0?useSSL=false
sharding.jdbc.datasource.ds_master_0_slave_0.username=travis
sharding.jdbc.datasource.ds_master_0_slave_0.password=
sharding.jdbc.datasource.ds_master_0_slave_1.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_0_slave_1.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_0_slave_1.url=jdbc:mysql://127.0.0.1:3306/ds_master_0_slave_1?useSSL=false
sharding.jdbc.datasource.ds_master_0_slave_1.username=travis
sharding.jdbc.datasource.ds_master_0_slave_1.password=

# ds_master_1
sharding.jdbc.datasource.ds_master_1.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_1.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_1.url=jdbc:mysql://127.0.0.1:3306/ds_master_1?useSSL=false
sharding.jdbc.datasource.ds_master_1.username=travis
sharding.jdbc.datasource.ds_master_1.password=

# slave for ds_master_1
sharding.jdbc.datasource.ds_master_1_slave_0.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_1_slave_0.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_1_slave_0.url=jdbc:mysql://127.0.0.1:3306/ds_master_1_slave_0?useSSL=false
sharding.jdbc.datasource.ds_master_1_slave_0.username=travis
sharding.jdbc.datasource.ds_master_1_slave_0.password=
sharding.jdbc.datasource.ds_master_1_slave_1.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds_master_1_slave_1.driverClassName=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds_master_1_slave_1.url=jdbc:mysql://127.0.0.1:3306/ds_master_1_slave_1?useSSL=false
sharding.jdbc.datasource.ds_master_1_slave_1.username=travis
sharding.jdbc.datasource.ds_master_1_slave_1.password=

# 分库规则
sharding.jdbc.config.sharding.default-database-strategy.inline.sharding-column=city_id
sharding.jdbc.config.sharding.default-database-strategy.inline.algorithm-expression=ds_${city_id % 2}

# 分表规则
sharding.jdbc.config.sharding.tables.t_user.actualDataNodes=ds_${0..1}.t_user_${0..1}
sharding.jdbc.config.sharding.tables.t_user.tableStrategy.inline.shardingColumn=user_id
sharding.jdbc.config.sharding.tables.t_user.tableStrategy.inline.algorithmExpression=t_user_${user_id % 2}
# 使用user_id作为分布式主键
sharding.jdbc.config.sharding.tables.t_user.keyGeneratorColumnName=user_id

# 逻辑主从库名和实际主从库映射关系
sharding.jdbc.config.sharding.master-slave-rules.ds_0.masterDataSourceName=ds_master_0
sharding.jdbc.config.sharding.master-slave-rules.ds_0.slaveDataSourceNames=ds_master_0_slave_0, ds_master_0_slave_1
sharding.jdbc.config.sharding.master-slave-rules.ds_1.masterDataSourceName=ds_master_1
sharding.jdbc.config.sharding.master-slave-rules.ds_1.slaveDataSourceNames=ds_master_1_slave_0, ds_master_1_slave_1

Test

测试代码如下：


@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    /** Logger */
    private static Logger log = LoggerFactory.getLogger(UserMapperTest.class);

    @Resource
    private UserMapper userMapper;

    @Before
    public void setup() throws Exception {
        create();
        clear();
    }

    private void create() throws SQLException {
        userMapper.createIfNotExistsTable();
    }

    private void clear() {
        userMapper.truncateTable();
    }

    @Test
    public void insert() throws Exception {
        UserEntity user = new UserEntity();
        user.setCityId(1);
        user.setUserName("insertTest");
        user.setAge(10);
        user.setBirth(new Date());
        assertTrue(userMapper.insert(user) > 0);
        Long userId = user.getUserId();
        log.info("Generated Key--userId:" + userId);
        userMapper.delete(userId);
    }

    @Test
    public void find() throws Exception {
        UserEntity userEntity = userMapper.find(138734796783222784L);
        log.info("user:{}", userEntity);
    }

}

先运行insert方法，插入一条数据后，获取插入的user_id为138734796783222784L（每次运行会不一样）,由于city_id=1，读写分离约定，会落在主库，又根据分库规则会落在ds_master_1，再根据分表规则，会落在t_user_0

结果

再运行find方法，指定userId，你会发现查出来是空的，这是因为Sharding-JDBC不支持主从同步以及主从同步延迟造成的数据不一致。这里我们显然术语第一种，因为根本就没有进行主从同步，那么从从库读取肯定是空的。

我们可以反向推理下，假如开启了主从同步，现在数据落在主库ds_master_1，这个主库有两个从库：ds_master_1_slave_0和ds_master_1_slave_1，所以我们可以往这两个主库的t_user_0表插入刚才的数据，语句如下：

INSERT INTO t_user_0(user_id,city_id,user_name,age,birth) values(138734796783222784,1,'insertTest',10,'2017-11-18 00:00:00');
  • 1
  • 2

先往ds_master_1_slave_0的t_user_0表插入该条数据，可以理解为主库同步到从库的数据。重新运行find方法，发现返回的数据和主库的一致，表明Sharding-JDBC从ds_master_1的从库ds_master_1_slave_0的t_user_0表查到了数据。

再删掉ds_master_1_slave_0的t_user_0表的数据，往ds_master_1_slave_1的t_user_0表插入刚才那条数据，重新运行发现返回的结果为空，表明从ds_master_1的从库ds_master_1_slave_1的t_user_0表没有查到数据。

最后往ds_master_1_slave_0的t_user_0表重新插入刚才的数据，再运行发现又返回了数据。

基于以上现象，可以推论选择从库查询的时候经过了某种算法得到访问的从库，然后在从库根据分表规则查询数据。

读写分离实现

这里包括几个问题：

  1. 读写分离的查询流程？
  2. 如何做结果归并？
  3. 如何路由到某个从库进行查询？
  4. 可以强制路由主库进行读操作吗？

读写分离的流程

  1. 获取主从库配置规则，数据源封装成MasterSlaveDataSource
  2. 根据路由计算，得到PreparedStatementUnit单元列表，合并每个PreparedStatementUnit的执行结果返回
  3. 执行每个PrepareStatementUnit的时候需要获取连接，这里根据轮询负载均衡算法RoundRobinMasterSlaveLoadBalanceAlgorithm得到从库数据源，拿到连接后就开始执行具体的SQL查询了，这里通过PreparedStatementExecutor.execute()得到执行结果
  4. 结果归并后返回

MasterSlaveDataSource:


public class MasterSlaveDataSource extends AbstractDataSourceAdapter {

    private static final ThreadLocal<Boolean> DML_FLAG = new ThreadLocal<Boolean>() {

        @Override
        protected Boolean initialValue() {
            return false;
        }
    };

    // 主从配置关系
    private MasterSlaveRule masterSlaveRule;

    public MasterSlaveDataSource(final MasterSlaveRule masterSlaveRule) throws SQLException {
        super(getAllDataSources(masterSlaveRule.getMasterDataSource(), masterSlaveRule.getSlaveDataSourceMap().values()));
        this.masterSlaveRule = masterSlaveRule;
    }

    private static Collection<DataSource> getAllDataSources(final DataSource masterDataSource, final Collection<DataSource> slaveDataSources) {
        Collection<DataSource> result = new LinkedList<>(slaveDataSources);
        result.add(masterDataSource);
        return result;
    }

    ...省略部分代码
// 获取数据源
public NamedDataSource getDataSource(final SQLType sqlType) {
        // 强制路由到主库查询
        if (isMasterRoute(sqlType)) {
            DML_FLAG.set(true);
            return new NamedDataSource(masterSlaveRule.getMasterDataSourceName(), masterSlaveRule.getMasterDataSource());
        }
        // 获取选中的从库数据源
        String selectedSourceName = masterSlaveRule.getStrategy().getDataSource(masterSlaveRule.getName(), 
                masterSlaveRule.getMasterDataSourceName(), new ArrayList<>(masterSlaveRule.getSlaveDataSourceMap().keySet()));
        DataSource selectedSource = selectedSourceName.equals(masterSlaveRule.getMasterDataSourceName())
                ? masterSlaveRule.getMasterDataSource() : masterSlaveRule.getSlaveDataSourceMap().get(selectedSourceName);
        Preconditions.checkNotNull(selectedSource, "");
        return new NamedDataSource(selectedSourceName, selectedSource);
    }

MasterSlaveRule：

public final class MasterSlaveRule {
    // 名称（这里是ds_0和ds_1）
    private final String name;

    // 主库数据源名称（这里是ds_master_0和ds_master_1）
    private final String masterDataSourceName;

    // 主库数据源
    private final DataSource masterDataSource;

    // 所属从库列表，key为从库数据源名称，value是真实的数据源
    private final Map<String, DataSource> slaveDataSourceMap;

    // 主从库负载均衡算法
    private final MasterSlaveLoadBalanceAlgorithm strategy;

RoundRobinMasterSlaveLoadBalanceAlgorithm:

// 轮询负载均衡策略，按照每个从节点访问次数均衡
public final class RoundRobinMasterSlaveLoadBalanceAlgorithm implements MasterSlaveLoadBalanceAlgorithm {

    private static final ConcurrentHashMap<String, AtomicInteger> COUNT_MAP = new ConcurrentHashMap<>();

    @Override
    public String getDataSource(final String name, final String masterDataSourceName, final List<String> slaveDataSourceNames) {
        AtomicInteger count = COUNT_MAP.containsKey(name) ? COUNT_MAP.get(name) : new AtomicInteger(0);
        COUNT_MAP.putIfAbsent(name, count);
        count.compareAndSet(slaveDataSourceNames.size(), 0);
        return slaveDataSourceNames.get(count.getAndIncrement() % slaveDataSourceNames.size());
    }
}

DefaultResultSetHandler:


@Override
  public List<Object> handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

    // 返回的结果集
    final List<Object> multipleResults = new ArrayList<Object>();

    int resultSetCount = 0;
    ResultSetWrapper rsw = getFirstResultSet(stmt);

    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    while (rsw != null && resultMapCount > resultSetCount) {
      ResultMap resultMap = resultMaps.get(resultSetCount);
      // 将ResultSetWrapper的结果集添加到multipleResults中
      handleResultSet(rsw, resultMap, multipleResults, null);
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }

    String[] resultSets = mappedStatement.getResultSets();
    if (resultSets != null) {
      while (rsw != null && resultSetCount < resultSets.length) {
        ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
        if (parentMapping != null) {
          String nestedResultMapId = parentMapping.getNestedResultMapId();
          ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
          handleResultSet(rsw, resultMap, null, parentMapping);
        }
        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
      }
    }

    return collapseSingleResultList(multipleResults);
  }


private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
    try {
      if (parentMapping != null) {
        handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
      } else {
        if (resultHandler == null) {
          DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
          // 按照resultMap解析到defaultResultHandler中
          handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
          // 最后的结果就是这里加进去的
          multipleResults.add(defaultResultHandler.getResultList());
        } else {
          handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
        }
      }
    } finally {
      // issue #228 (close resultsets)
      closeResultSet(rsw.getResultSet());
    }
  }

版权声明：本文为博主原创文章，转载请注明出处。 https://blog.csdn.net/u011116672/article/details/78576117

springboot整合mybatis+sharding-jdbc实现单库分表存储
qq_36831067的博客
07-09 935
最近公司项目要对数据库表做分表功能，今天弄了一天，总算把demo运行起来，存取都没问题了，在这里做下记录，希望能给有需要的小伙伴一点点帮助吧！ 项目架构：springboot2.3 + mybatis + sharding jdbc +mysql sharding jdbc :用来实现数据库分库、分表 ，推介去官网看看https://shardingsphere.apache.org/index_zh.html 其它就不做介绍了很基础的东西 1.先来张项目架构图 2. maven的pom.
spring-boot+sharding-jdbc+mybatis+druid
06-26
spring boot的配置文件配置无法具体配置druid连接池的各种属性（官网上我没找到），所以采用java类的方式配置，包括druid的wallFilter、statFilter、statViewServlet、webStatFilter等等
项目集成sharding-jdbc
最新发布
luosuss的博客
09-22 1132
目录项目集成sharding-jdbc1.业务分析 2.数据库构建3.分库分表策略 项目配置默认数据源一：导入sharding-jdbc依赖 二：在application文件中编写配置三：注释掉主配置文件中配置的数据源注意：这里添加了spring.main.allow-bean-definition-overriding: true四：测试项目配置广播表（公共表）一:application配置二：测试项目使用standard标准模式配置分库算法一.分库算法类 二.application中配置逻辑表对应的数据
Springboot2+JPA|MyBatis+Sharding-JDBC示例
07-24
Springboot2+JPA|MyBatis+Sharding-JDBC示例源码，可直接运行。
springBoot和sharding-jdbc、mybatis整合demo
02-25
这是sharding-jdbc spring boot的一个demo程序。分别使用了controller的单元测试及服务的单元测试resources / sql下的sql语句在两个不同的数据库下执行。
详解Spring Boot中整合Sharding-JDBC读写分离示例
08-26
Spring Boot 中整合 Sharding-JDBC 读写分离示例解析 本文主要介绍了在 Spring Boot 框架中如何整合 Sharding-JDBC 实现读写分离的示例。Sharding-JDBC 是一个开源的数据库中间件，提供了数据分片、读写分离、...
Sharding-JDBC实现读写分离demo
05-30
在这个“Sharding-JDBC实现读写分离demo”中，我们将深入探讨如何利用Sharding-JDBC来构建一个简单的读写分离系统。 首先，我们需要了解读写分离的基本概念。在高并发的Web应用中，为了保证数据的一致性和服务的...
使用sharding-jdbc快速实现自动读写分离-demo源码
07-07
在这个“使用sharding-jdbc快速实现自动读写分离-demo源码”中，我们将探讨如何利用Sharding-JDBC实现这一功能。 首先，我们需要理解Sharding-JDBC的基本原理。Sharding-JDBC作为一个数据库中间件，工作在JDBC层，...
springboot整合sharding-jdbc完整代码
05-14
SpringBoot整合Sharding-JDBC是将Sharding-JDBC这一分布式数据库中间件与SpringBoot框架结合，以实现数据分片、读写分离等高级数据库管理功能。这个完整的代码示例覆盖了Sharding-JDBC的主要技术点，使开发者可以...
基于 SpringBoot + ShardingSphere（Sharding-JDBC） 的水平分表测试项目+源代码+文档说明
11-29
一、Sharding-JDBC 与 JOOQ 的兼容性测试 - **测试项** - 不分片时，使用默认数据源的增、删、改、查 - 分片时，使用`ShardingDataSource`数据源的增、删、改、查 - 分片表与不分片表的连表查询...
Java+Springboot+mybatis+sharding jdbc 实现分库分表
10-28
Java+Springboot+mybatis+sharding jdbc 实现分库分表
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能
09-07
主要介绍了Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
SpringBoot + MyBatis + Sharding-JDBC4.X 实现数据库读写分离
qq_28014809的博客
04-14 696
1、说明，本文主要实现1主2从的读写分离 主库： 添加、更新以及删除数据操作所使用的数据库。 从库： 查询数据操作所使用的数据库。 2、引用依赖包 <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.42&lt
springboot + mybatis + Sharding-JDBC实现读写分离
xiaoxiaoxiao_Ming的博客
11-11 702
一、引入maven依赖，具体版本大家可根据自己实际需要选择，我这边使用的是4.0.0-RC1版本 <dependency> <groupId>org.apache.shardingsphere</groupId> <artifactId>sharding-jdbc-spring-boot-starter</artifactId> <version>${sharding-sphere.version}</versio
Spring Boot整合Mybatis、Druid和Sharding-jdbc
theonlytao的博客
11-24 3210
前言 Spring Boot的出现让开发人员摆脱了繁琐的配置文件和依赖冲突，让项目搭建变得快速而便捷。而数据往往承载着项目的核心，从最原始的JDBC数据操作到Hibernate的对象关系映射框架的出现，数据库的操作变得更加灵活。Mybatis则是比Hibernate更为强大与灵活的ORM框架，本文将着重讲解Spring Boot和Mybatis、Druid和Sharding-jdbc的整合。 ...
springboot+mybatis+sharding-jdbc单库分表
早起的鸟儿有虫吃的博客
09-17 497
缘由 由于在做考勤系统考虑到后期考勤数据量会非常大，到时候单表的数据量可能会很大，导致数据库的查询效率会很低，数据库的负载坚持不住，所以就开始考虑分库分表的事情了，一开始是看的比较主流的当初阿里图队的mycat，但是整合到后面发现mycat实现不了单库分表，只能多库分表。后面就开始往sharding-jdbc方向研究，sharding-jdbc又分为两个版本，dangdang（当当）和shardingsphere，也不知道这两者是什么关系应该都是同个社区的开发者开发的吧，当当的目前最新是1.5.3吧sha
SpringBoot+Mybatis-Plus整合Sharding-JDBC实现分库分表
qq_70009637的博客
04-17 767
先建一个数据库,创建三张表 把表名改成对应的。首先创建一个springboot单体工程。执行之后会把数据随机存入到一张表中。
最简单易懂的Spring boot，mybatis，sharding jdbc 分库分表教程
江南夜雨
08-31 397
网上的基于配置文件的文章太多了且有些写的乱七八糟对新手极为不友好，本篇文章采用 全部 Java 编码的方式，来实现数据的分库分表，并力求做到简单明了 工具准备 安装Spring boot，我这里是通过idea安装， java8，maven 这里采用mybatis逆向工程生成代码，生成插件选择Maven 连接池采用阿里巴巴的Druid 安装依赖 pom文件如下，主要依赖有，mybatis-spring-boot-starter，druid-spring-boot-starter，sharding-jdbc
Sharding-JDBC实现读写分离：配置与示例
"Sharding-JDBC读写分离技术详解" Sharding-JDBC是Apache ShardingSphere项目中的一个重要组件，它提供了一种在Java应用程序中实现数据库读写分离和分片的解决方案，使得大规模分布式数据库系统能够更有效地管理和...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值