Docker容器 - 实现MySQL主从复制 + 读写分离（Docker + MySQL + MyCat）

已于 2022-10-09 19:44:01 修改
阅读量1.9k 收藏 22
点赞数 8
分类专栏： Docker MySQL MyCat 文章标签： docker mysql 数据库 容器 服务器
于 2022-07-26 11:37:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Trollz/article/details/125990254
版权

目录

一、主从复制 

新建主服务器容器实例3307

进入/mydata/mysql-master/conf新建my.cnf

修改完配置后重启master实例

进入mysql-master容器

master容器实例内创建数据同步用户

新建从服务器容器实例3308

进入/mydata/mysql-slave/conf新建my.cnf

修改完配置后重启slave实例

在主数据库中查看主从同步状态

进入mysql-slave容器

在从数据库中配置主从复制

在从数据库中查看主从同步状态

在从数据库中开启主从同步

再次查看从数据库状态

二、主从复制测试

主数据库

从数据库

三、读写分离

Docker安装MyCat

server.xml 

schema.xml 

sequence_conf.properties 

rule.xml

运行容器

容器中安装JDK

连接测试

使用Docker安装MySQL5.7的详细文章：Linux中使用Docker安装MySQL5.7（CentOS7）_不会调制解调的猫的博客-优快云博客

一、主从复制 

新建主服务器容器实例3307

这里就算没有拉取mysql5.7的镜像也可以直接运行，若发现没有镜像则会直接自动拉取。

这里的-v如果不懂，也可以查看之前的容器数据卷详解：Docker容器数据卷_不会调制解调的猫的博客-优快云博客

docker run -p 3307:3306 --name mysql-master -v /mydata/mysql-master/log:/var/log/mysql -v /mydata/mysql-master/data:/var/lib/mysql -v /mydata/mysql-master/conf:/etc/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7

 ps查看一下，确认它起来了

docker ps

进入/mydata/mysql-master/conf新建my.cnf

vim /mydata/mysql-master/conf/my.cnf

直接把以下内容全部复制粘贴进去，然后保存退出。 

[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=101 
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql  
## 开启二进制日志功能
log-bin=mall-mysql-bin  
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M  
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed  
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7  
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062

修改完配置后重启master实例

在宿主机上通过容器数据卷来修改配置，传导给docker内部，是需要重启的

docker restart mysql-master

再ps查看一下，要确认它已经up起来了

docker ps

进入mysql-master容器

docker exec -it mysql-master /bin/bash
mysql -uroot -proot

容器进入成功，继续下一步

master容器实例内创建数据同步用户

安全加固，添加一个用户，然后授权

create user 'slave'@'%' identified by '123456';
grant replication slave,replication client on *.* to 'slave'@'%';

新建从服务器容器实例3308

docker run -p 3308:3306 --name mysql-slave -v /mydata/mysql-slave/log:/var/log/mysql -v /mydata/mysql-slave/data:/var/lib/mysql -v /mydata/mysql-slave/conf:/etc/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7

ps以确认其up 

进入/mydata/mysql-slave/conf新建my.cnf

vim /mydata/mysql-slave/conf/my.cnf

直接粘贴然后保存退出

[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=102
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql  
## 开启二进制日志功能，以备Slave作为其它数据库实例的Master时使用
log-bin=mall-mysql-slave1-bin  
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M  
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed  
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7  
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062  
## relay_log配置中继日志
relay_log=mall-mysql-relay-bin  
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates=1  
## slave设置为只读（具有super权限的用户除外）
read_only=1

修改完配置后重启slave实例

docker restart mysql-slave

在主数据库中查看主从同步状态

show master status;

进入mysql-slave容器

docker exec -it mysql-slave /bin/bash

mysql -uroot -proot

在从数据库中配置主从复制

是在从数据库配置，不是主！

change master to master_host='宿主机ip', master_user='slave', master_password='123456', master_port=3307, master_log_file='mall-mysql-bin.000001', master_log_pos=617, master_connect_retry=30;

change master to master_host='192.168.150.30', master_user='slave', master_password='123456', master_port=3307, master_log_file='mall-mysql-bin.000001', master_log_pos=617, master_connect_retry=30;

参数说明：

master_host：主数据库的IP地址；

master_port：主数据库的运行端口；

master_user：在主数据库创建的用于同步数据的用户账号；

master_password：在主数据库创建的用于同步数据的用户密码；

master_log_file：指定从数据库要复制数据的日志文件，通过查看主数据的状态，获取File参数；

master_log_pos：指定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数；

master_connect_retry：连接失败重试的时间间隔，单位为秒。

在从数据库中查看主从同步状态

show slave status \G

\G 是竖着来查看，有点类似于键值对

这里的Slave_IO_Running和Slave_SQL_Running都还是NO，没有启动

在从数据库中开启主从同步

start slave;

再次查看从数据库状态

show slave status \G

 成功。

二、主从复制测试

主数据库

主数据库新建库，新建表，插入数据

create database dbtest1;
use dbtest1;
create table test1 (id int,name varchar(20));
insert into test1 values(1,'van');
select * from test1;

从数据库

从数据库进行查找

show databases;
use dbtest1;
select * from test1;

 测试成功！

三、读写分离

Docker安装MyCat

拉取MyCat镜像：

docker pull longhronshens/mycat-docker

创建目录并配置文件：

mkdir -p /usr/local/mycat

cd /usr/local/mycat

server.xml 

vim  /usr/local/mycat/server.xml

将以下内容复制进去：

<?xml version="1.0" encoding="UTF-8"?>
<!-- - - Licensed under the Apache License, Version 2.0 (the "License"); 
	- you may not use this file except in compliance with the License. - You 
	may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 
	- - Unless required by applicable law or agreed to in writing, software - 
	distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT 
	WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the 
	License for the specific language governing permissions and - limitations 
	under the License. -->
<!DOCTYPE mycat:server SYSTEM "server.dtd">
<mycat:server xmlns:mycat="http://io.mycat/">
	<system>
	<property name="useSqlStat">0</property>  <!-- 1为开启实时统计、0为关闭 -->
	<property name="useGlobleTableCheck">0</property>  <!-- 1为开启全加班一致性检测、0为关闭 -->
		<property name="sequnceHandlerType">0</property>
		<property name="processorBufferPoolType">0</property>
		<!--默认是65535 64K 用于sql解析时最大文本长度 -->
		<!--<property name="maxStringLiteralLength">65535</property>-->
		<!--<property name="sequnceHandlerType">0</property>-->
		<!--<property name="backSocketNoDelay">1</property>-->
		<!--<property name="frontSocketNoDelay">1</property>-->
		<!--<property name="processorExecutor">16</property>-->
		<!--
			<property name="serverPort">8066</property> <property name="managerPort">9066</property> 
			<property name="idleTimeout">300000</property> <property name="bindIp">0.0.0.0</property> 
			<property name="frontWriteQueueSize">4096</property> <property name="processors">32</property> -->
		<!--分布式事务开关，0为不过滤分布式事务，1为过滤分布式事务（如果分布式事务内只涉及全局表，则不过滤），2为不过滤分布式事务,但是记录分布式事务日志-->
		<property name="handleDistributedTransactions">0</property>
			<!--
			off heap for merge/order/group/limit      1开启   0关闭
		-->
		<property name="useOffHeapForMerge">1</property>
		<!--
			单位为m
		-->
		<property name="memoryPageSize">1m</property>
		<!--
			单位为k
		-->
		<property name="spillsFileBufferSize">1k</property>
		<property name="useStreamOutput">0</property>
		<!--
			单位为m
		-->
		<property name="systemReserveMemorySize">384m</property>
		<!--是否采用zookeeper协调切换  -->
		<property name="useZKSwitch">true</property>
	</system>
	<user name="root">
		<property name="password">root</property>
		<property name="schemas">test</property>
	</user>
</mycat:server>

schema.xml 

vim  /usr/local/mycat/schema.xml

继续复制：

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
	<schema name="test" checkSQLschema="false" sqlMaxLimit="100">
		<table name="tb_user"   primaryKey="id"  autoIncrement="true"  dataNode="dn1,dn2,dn3,dn4" rule="userrule" />
		<table name="tb_category" primaryKey="id" dataNode="dn1,dn2,dn3,dn4" rule="categoryrule" />
	</schema>
	<dataNode name="dn1" dataHost="localhost1" database="db1" />
	<dataNode name="dn2" dataHost="localhost1" database="db2" />
	<dataNode name="dn3" dataHost="localhost1" database="db3" />
	<dataNode name="dn4" dataHost="localhost1" database="db4" />
	<dataHost name="localhost1" maxCon="1000" minCon="10" balance="1"
			  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
		<heartbeat>select user()</heartbeat>
		<writeHost host="hostM1" url="192.168.21.55:3307" user="root"
				   password="root">
			<readHost host="hostS2" url="192.168.21.55:3308" user="root" password="root" />
		</writeHost>
	</dataHost>
</mycat:schema>

sequence_conf.properties 

vim  /usr/local/mycat/sequence_conf.properties

TB_USER.HISIDS=
TB_USER.MINID=1
TB_USER.MAXID=20000
TB_USER.CURID=1

rule.xml

vim  /usr/local/mycat/rule.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mycat:rule SYSTEM "rule.dtd">
<mycat:rule xmlns:mycat="http://io.mycat/">
	<tableRule name="userrule">
		<rule>
			<columns>id</columns>
			<algorithm>func1</algorithm>
		</rule>
	</tableRule>
	<tableRule name="categoryrule">
		<rule>
			<columns>id</columns>
			<algorithm>jump-consistent-hash</algorithm>
		</rule>
	</tableRule>

	<function name="murmur"
		class="io.mycat.route.function.PartitionByMurmurHash">
		<property name="seed">0</property><!-- 默认是0 -->
		<property name="count">2</property><!-- 要分片的数据库节点数量，必须指定，否则没法分片 -->
		<property name="virtualBucketTimes">160</property><!-- 一个实际的数据库节点被映射为这么多虚拟节点，默认是160倍，也就是虚拟节点数是物理节点数的160倍 -->
		<!-- <property name="weightMapFile">weightMapFile</property> 节点的权重，没有指定权重的节点默认是1。以properties文件的格式填写，以从0开始到count-1的整数值也就是节点索引为key，以节点权重值为值。所有权重值必须是正整数，否则以1代替 -->
		<!-- <property name="bucketMapPath">/etc/mycat/bucketMapPath</property> 
			用于测试时观察各物理节点与虚拟节点的分布情况，如果指定了这个属性，会把虚拟节点的murmur hash值与物理节点的映射按行输出到这个文件，没有默认值，如果不指定，就不会输出任何东西 -->
	</function>

	<function name="crc32slot"
			  class="io.mycat.route.function.PartitionByCRC32PreSlot">
		<property name="count">2</property><!-- 要分片的数据库节点数量，必须指定，否则没法分片 -->
	</function>
	<function name="hash-int"
		class="io.mycat.route.function.PartitionByFileMap">
		<property name="mapFile">partition-hash-int.txt</property>
	</function>
	<function name="rang-long"
		class="io.mycat.route.function.AutoPartitionByLong">
		<property name="mapFile">autopartition-long.txt</property>
	</function>
	<function name="mod-long" class="io.mycat.route.function.PartitionByMod">
		<!-- how many data nodes -->
		<property name="count">4</property>
	</function>

	<function name="func1" class="io.mycat.route.function.PartitionByLong">
		<property name="partitionCount">8</property>
		<property name="partitionLength">128</property>
	</function>
	<function name="latestMonth"
		class="io.mycat.route.function.LatestMonthPartion">
		<property name="splitOneDay">24</property>
	</function>
	<function name="partbymonth"
		class="io.mycat.route.function.PartitionByMonth">
		<property name="dateFormat">yyyy-MM-dd</property>
		<property name="sBeginDate">2015-01-01</property>
	</function>
	
	<function name="rang-mod" class="io.mycat.route.function.PartitionByRangeMod">
        	<property name="mapFile">partition-range-mod.txt</property>
	</function>
	
	<function name="jump-consistent-hash" class="io.mycat.route.function.PartitionByJumpConsistentHash">
		<property name="totalBuckets">4</property>
	</function>
</mycat:rule>

运行容器

docker run --name mycat -v /usr/local/mycat/schema.xml:/usr/local/mycat/conf/schema.xml -v /usr/local/mycat/rule.xml:/usr/local/mycat/conf/rule.xml -v /usr/local/mycat/server.xml:/usr/local/mycat/conf/server.xml -v /usr/local/mycat/sequence_conf.properties:/usr/local/mycat/conf/sequence_conf.properties --privileged=true -p 8066:8066 -p 9066:9066 -e MYSQL_ROOT_PASSWORD=root  -d longhronshens/mycat-docker

容器中安装JDK

将JDK的安装包传到容器内，格式为：

docker cp 宿主机内目录 容器ID:容器内目录

举个栗子：

docker cp /opt/software/jdk-8u201-linux-x64.rpm fe5162fd39ea:/

进入容器：

docker exec -it mycat bash

 解压安装：

rpm -ivh jdk-8u201-linux-x64.rpm

使用yum安装vim： 

yum install -y vim

修改配置文件：

vim /etc/profile.d/java.sh

将以下内容复制进去：

export JAVA_HOME=/usr/java/jdk1.8.0_201-amd64
export CLASSPATH=.:$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/dt.jar
export PATH=$JAVA_HOME/bin:$PATH

保存退出后source一下：

source /etc/profile

Ctrl+D退出，然后重启容器：

docker restart mycat

连接测试

进入MySQLMaster容器：

docker exec -it mysql-master bash

mysql -h192.168.150.30 -uroot -proot -P8066

打开Navicat进行连接，注意端口号 ：

连接成功

Mysql+haproxy+mycat+pxc+zookeeper实现高可用集群
02-15
Mysql+haproxy+mycat+pxc+zookeeper实现高可用集群 本文将详细介绍如何使用Mysql、Haproxy、Mycat、PXC、Zookeeper实现高可用集群，涵盖了整个架构图、应用程序的访问流程、数据的读写分离、负载均衡、数据库节点的...
Docker实现Mysql读写分离（主从同步）
wayhb的专栏
12-20 3204
概念 Mysql读写分离主要是通过主从数据库复制来实现，Mysql自带的二进制复制技术； Mysql5.7与Mysql8操作稍有差别，Mysql8的授权模式有改动，需要先创建用户； 实现主从同步后，使用MyCat等软件实现读写分离； 使用Docker来模拟两台服务器，原理和使用2台不同IP的服务器一样； 安装Docker 下载Docker Desktop https://www.docker.com/get-started，这个是有图形界面的Docker，可以省去很多命令操作，对系统有一定要求； 直接
基于docker搭建mysql主从复制和读写分离
jkjkjkll的博客
06-02 1272
基于docker搭建mysql主从复制和读写分离
如何使用 Docker 安装 MySQL
最新发布
03-03 1106
Docker 是一种轻量级的容器化技术，可以快速部署和管理应用程序。使用 Docker 运行 MySQL 既能简化安装过程，又能提高灵活性，非常适合开发和测试环境。本文将介绍如何使用 Docker 安装和配置 MySQL。
Docker 搭建MySQL主从复制-读写分离
m0_56659620的博客
01-29 1651
MySQL主从复制是一种常用的数据库高可用性解决方案，通过在主数据库上记录的数据变更，同步到一个或多个从数据库，实现数据的冗余备份和读写分离。在Docker环境下搭建MySQL主从复制和读写分离，不仅方便管理，还能充分发挥Docker的轻量、可移植性等特性。通过Docker搭建MySQL主从复制和读写分离，不仅简化了部署过程，还提高了系统的可维护性。合理配置主从关系和读写分离，可以优化数据库性能，提高系统的稳定性和可用性。
docker 部署MySQL实现主从复制读写分离
sozee910的博客
08-29 1283
详细阐述了通过Docker-Compose配置MySQL主架构，包括设置复制参数、配置用户权限等步骤。此外，并通过proxy SQL实现读写分离，旨在提高数据库系统的读取性能与可靠性。通过这一架构，系统能够自动将读请求分发到从节点，而写请求则保留在主节点，有效平衡了负载并增强了数据安全性，另介绍部署过程中的相关注意事项。。
【MySQL主从复制】快速配置
Saberman
12-05 787
【MySQL主从复制】快速配置
5.基于Mycat的MySQL主从复制读写分离docker实现.pdf
06-17
.基于Mycat的MySQL主从复制读写分离docker实现.
docker安装mysql5.7.27-主从并使用mycat中间件做读写分离
07-07
docker安装mysql5.7.27-主从并使用mycat中间件做读写分离
manondidi/mycat docker包 tar包 可用
10-28
Mycat是开源社区在阿里cobar基础上进行二次开发，解决了cobar存在的问题，并且加入了许多新的功能在其中。青出于蓝而胜于蓝 支持MySQL、SQLServer、Oracle、DB2、PostgreSQL 等主流数据库
云计算1+X试题样卷A卷（初级）-题目卷.pdf
03-21
试卷中询问了mysql主从复制的原理，包括binlog的使用、slave获取和执行复制操作等。 13. 容器技术 容器技术，特别是Docker，是云计算中实现快速部署、扩展和管理应用的重要技术。试卷中询问了不属于docker容器的...
DockerCompose安装Mysql配置读写分离
冒险的梦想家的博客~
08-25 1448
文章目录1、首先要安装Docker 以及Docker-composeDocker安装Docker-compose安装2、安装MySql3、配置主Master(主)修改容器配置添加用户赋权限4、配置从Slave(从)5、开启Master-Slave主从复制配置6、测试 1、首先要安装Docker 以及Docker-compose Docker安装 #查看内核 ➜ ~ uname -r 4.15.0-96-generic # 要求3.0以上 #查看Centos ➜ ~ cat /etc/os-rel
使用Docker进行MySQL读写分离
xirigh的博客
10-10 924
以下代码仅供测试学习，请勿用于生产环境。如果要在生产环境使用，请修改其中权限部分的暴力写法。
使用 Docker 搭建一个“一主一从”的 MySQL 读写分离集群（超详细步骤）
tigerhhzz的博客
11-03 833
下面在 master 中创建一个数据库与表，在 slave 中如果可以查看到，则说明搭建成功。在 slave 中查看 slave 状态发现，当前 slave 与 master 的同步复制还没有开始。为了保证数据的安全性，在生产环境下安装的 mysql 容器，在启动时都会使用数据卷来持久化数据。在 slave 中使用 start slave 命令开启 slave 的数据同步。在 slave 中可以查看到在 master 中写入的数据，说明集群搭建成功。此时再次查看 slave 的状态，发现同步已经开始。
docker中配置mysql主从分离
韩利巍
07-17 622
MySQL读写分离是将数据库的读操作和写操作分配到不同的数据库服务器上的一种架构设计。它的主要意义包括以下几个方面：提高性能：通过将读操作分散到多个从数据库上，可以分担主数据库的负载，提高整体的数据库性能和吞吐量。读写分离架构特别适合读多写少的应用场景。优化用户体验：将读操作分流到从数据库上，可以减少主数据库的并发访问压力，提高响应速度和用户访问体验。对于读密集型应用，如电商网站或新闻门户，读写分离可以优化用户访问速度。
Mysql主从复制原理、基于Docker搭建Mysql主从环境、分别使用Mycat和Sharding-jdbc进行分库分表、读写分离
加州暖阳的博客
09-12 695
MySQL 主从复制是指数据可以从一个MySQL数据库服务器主节点复制到一个或多个从节点。默认采用异步复制方式，从节点不用一直访问主服务器来更新自己的数据，数据的更新可以在远程连接上进行，从节点可以复制主数据库中的所有数据库或特定的数据库或特定的表。数据切分，通过某种条件，将我们之前存储在一台数据库上的数据，分散到多台数据库中，从而达到降低单台数据库负载的效果。数据切分大致分为垂直切分和水平切分。Mycat是服务端代理,不支持同一库内的水平切分 Sharding-Jdbc是客户端代理，支持同一库内的水平切分
Docker实现Mysql 主从复制实战
The Home Of Salt Fish
12-09 1375
一、部署主从Mysql服务器 利用docker实现mysql的主从复制，首先需要在服务器上安装好docker 及拉取相关mysql镜像，这里演示的版本为 mysql 5.7 ,Docker为 version 20.10.11 在服务器创建两个目录 master 与 slave 分别对应主从数据库的data和conf ，目录结构如下 然后在master/conf/ 路径下创建 my.cnf 里面内容如下 [mysqld] ## 同一局域网内注意要唯一 server-id=1024 ## 开启..
MySql之主从复制
猎户星座
04-19 475
为什么要做主从复制？ 在业务复杂的系统中，有这么一个情景，有一句sql语句需要锁表，导致暂时不能使用读的服务，那么就很影响运行中的业务，使用主从复制，让主库负责写，从库负责读，这样，即使主库出现了锁表的情景，通过读从库也可以保证业务的正常运作。通过做主从复制（读写分离）来减轻主数据库的负载 做数据的热备 业务量越来越大，I/O访问频率过高，单机无法满足，此时做多库的存储，降低磁盘I/...
mysql主从连接，提供文档理解
m19166的博客
04-09 1764
zz主从连接，网上的教程有很多，但只告诉你怎么做，却没告诉你怎么来的，本文对建立之中大家可能有问题的一些内容进行解答： GRANT REPLICATION SLAVE ON *.* TO 'slave'@'%' identified by 'slave'; 这句代码应该是网上流传最多的，其中的解释却很少。本文对其进行解释，如果你需要对某一对象授予权限，那么你需要做的是采用GRANT，而在建立主从建构上来说，官方说明是采用GRANT REPLICATION SLAVE ON *.*，这一段使我们不需要改
Docker中Mycat实现MySQL主从复制与读写分离教程
"该文档详细介绍了如何在Docker环境下，利用Mycat实现MySQL的主从复制和读写分离。" 在IT行业中，数据库管理是关键任务之一，尤其是在高并发和大数据量的应用场景中，读写分离和主从复制成为提升系统性能和可用性的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

不会调制解调的猫

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

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

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

打赏作者

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

抵扣说明：

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

余额充值