基于GO语言实现分布式定时任务学习（四）---- master 代码开发与实现

最新推荐文章于 2024-06-20 14:24:50 发布
最新推荐文章于 2024-06-20 14:24:50 发布
阅读量1.4k 收藏 3
点赞数 2
分类专栏： 基于GO语言实现一个分布式定时任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39458593/article/details/106179142
版权

master 功能点

  1. 提供http接口供 任务录入、任务查看、任务强制杀死 等基础功能；
  2. 提供服务端启动等参数化设置；

master 启动

master启动需要做到解析配置文件、创建etcd连接交互、创建socket监听形成web服务。

  1. 配置文件解析：
    配置文件解析主要包括录入etcd信息、mysql信息、以及服务器端口等，我们把这些信息形成json文件。

master.json

	 {
	  "API接口服务端口": "提供任务增删改查服务",
	  "apiPort": 8070,
	  "API接口读超时": "单位是毫秒",
	  "apiReadTimeout": 5000,
	  "API接口写超时": "单位是毫秒",
	  "apiWriteTimeout": 5000,
	  "etcd的集群列表": "配置多个, 避免单点故障",
	  "etcdEndpoints": [
	    "127.0.0.1:2379"
	  ],
	  "etcd的连接超时": "单位毫秒",
	  "etcdDialTimeout": 5000,
	  "web页面根目录": "静态页面，前后端分离开发",
	  "webroot": "./webroot",
	  "mongodb地址": "采用mongodb URI",
	  "mongodbUri": "mongodb://127.0.0.1:2379:27017",
	  "mongodb连接超时时间": "单位毫秒",
	  "mongodbConnectTimeout": 5000
	}

并且提供对应的config struct 对json文件进行装填 ：

Config.go

import (
	"io/ioutil"
	"encoding/json"
)

// 程序配置
type Config struct {
	ApiPort int	`json:"apiPort"`
	ApiReadTimeout int	`json:"apiReadTimeout"`
	ApiWriteTimeout int	`json:"apiWriteTimeout"`
	EtcdEndpoints []string `json:"etcdEndpoints"`
	EtcdDialTimeout int `json:"etcdDialTimeout"`
	WebRoot string `json:"webroot"`
	MongodbUri string `json:"mongodbUri"`
	MongodbConnectTimeout int `json:"mongodbConnectTimeout"`
}

var (
	// 单例
	G_config *Config
)

// 加载配置
func InitConfig(filename string) (err error) {
	var (
		content []byte
		conf Config
	)

	// 1, 把配置文件读进来
	if content, err = ioutil.ReadFile(filename); err != nil {
		return
	}

	// 2, 做JSON反序列化
	if err = json.Unmarshal(content, &conf); err != nil {
		return
	}

	// 3, 赋值单例
	G_config = &conf

	return
}

下来在master main 函数中，基于命令行启动参数加载该配置文件

master.go （main包)

var (
	confFile string // 配置文件路径
)

// 解析命令行参数
func initArgs() {
	// arg1 : 解析结果赋值的变量
	// arg2 : 命令行中的key
	// arg3 : 默认的value
	// arg4 : 相应的描述
	// master -config ./master.json -xxx 123 -yyy ddd
	// idea 默认从gopath下执行，需要指定到该包下进行执行
	//
	flag.StringVar(&confFile, "config", "./master.json", "指定master.json")
	flag.Parse()
}

func main() {
	// 初始化命令行参数
	initArgs()
	// 加载配置
	if err = master.InitConfig(confFile); err != nil {
		goto ERR
	}

}
  1. Web服务启动加载

ApiServer.go

var (
	G_apiServer *ApiServer
)

// 任务Http接口
type ApiServer struct {
	httpServer *http.Server
}

//  初始化服务
func InitApiServer() (err error) {

	var (
		mux           *http.ServeMux //定制路由
		httpServer    *http.Server
		listener      net.Listener
		staticDir     http.Dir     // 静态文件根目录
		staticHandler http.Handler // 静态文件的HTTP回调
	)

	mux = http.NewServeMux()
	mux.HandleFunc("/job/save", handlerJobSave)
	mux.HandleFunc("/job/delete", handleJobDelete)
	mux.HandleFunc("/job/list", handleJobList)
	mux.HandleFunc("/job/kill", handleJobKill)
	//mux.HandleFunc("/job/log", handleJobLog)
	//mux.HandleFunc("/worker/list", handleWorkerList)

	// 静态文件目录
	staticDir = http.Dir(G_config.WebRoot)
	staticHandler = http.FileServer(staticDir)
	mux.Handle("/", http.StripPrefix("/", staticHandler)) //   ./webroot/index.html
	//strconv.ItoA  int转字符串
	if listener, err = net.Listen("tcp", ":"+strconv.Itoa(G_config.ApiPort)); err != nil {
		return
	}

	httpServer = &http.Server{
		ReadTimeout:  time.Duration(G_config.ApiReadTimeout) * time.Millisecond,
		WriteTimeout: time.Duration(G_config.ApiWriteTimeout) * time.Millisecond,
		Handler:      mux,
	}

	G_apiServer = &ApiServer{
		httpServer: httpServer,
	}

	go httpServer.Serve(listener)

	return nil

}

master.go （main包)

	//启动
	if err = master.InitApiServer(); err != nil {
		goto ERR
	}
  1. etcd 以及 job任务

JobMgr.go

var (
	// 单例
	G_jobMgr *JobMgr
)

// 任务管理器
type JobMgr struct {
	client *clientv3.Client
	kv     clientv3.KV
	lease  clientv3.Lease
}

// 初始化管理器
func InitJobMgr() (err error) {

	var (
		config clientv3.Config
		client *clientv3.Client
		kv     clientv3.KV
		lease  clientv3.Lease
	)

	// 初始化配置
	config = clientv3.Config{
		Endpoints:   G_config.EtcdEndpoints,                                     // 集群地址
		DialTimeout: time.Duration(G_config.EtcdDialTimeout) * time.Millisecond, // 连接超时
	}

	// 建立连接
	if client, err = clientv3.New(config); err != nil {
		return
	}

	// 得到KV和Lease的API子集
	kv = clientv3.NewKV(client)
	lease = clientv3.NewLease(client)

	// 赋值单例
	G_jobMgr = &JobMgr{
		client: client,
		kv:     kv,
		lease:  lease,
	}
	return
}

master.go （main包)

	//  任务管理器
	if err = master.InitJobMgr(); err != nil {
		goto ERR
	}

master 功能实现

1：录入任务
client ApiServer.go JobMgr.go etcd request for add cronJob for add KV for insert KV add kv par [ doPut ] 向ETCD 中添加任务 success success success client ApiServer.go JobMgr.go etcd

基于IDEA client 发送request如下：

###
POST http://localhost:8070/job/save
Accept: */*
Cache-Control: no-cache
Content-Type: application/x-www-form-urlencoded

job= {"name": "job1","command": "echo hello","cronExpr": "*/5 * * * * * *"}

涉及代码见下：

ApiServer.go

//路由中添加 url-func
mux.HandleFunc("/job/save", handlerJobSave)

//保存任务 Post  job = {"name" :"job1" , "command":"echo hello" , "cronExpr: "* * * * *"}
func handlerJobSave(resp http.ResponseWriter, req *http.Request) {
	var (
		err     error
		postJob string
		job     common.Job
		oldJob  *common.Job
		bytes   []byte
	)

	// 1, 解析POST表单
	if err = req.ParseForm(); err != nil {
		goto ERR
	}
	// 2, 取表单中的job字段
	postJob = req.PostForm.Get("job")
	// 3, 反序列化job
	if err = json.Unmarshal([]byte(postJob), &job); err != nil {
		goto ERR
	}
	// 4, 保存到etcd
	if oldJob, err = G_jobMgr.SaveJob(&job); err != nil {
		goto ERR
	}
	// 5, 返回正常应答 ({"errno": 0, "msg": "", "data": {....}})
	if bytes, err = common.BuildResponse(0, "success", oldJob); err == nil {
		resp.Write(bytes)
	}
	return

ERR:
	// 6, 返回异常应答
	if bytes, err = common.BuildResponse(-1, err.Error(), nil); err == nil {
		resp.Write(bytes)
	}

}

其中common.BuildResponse为包装http请求的一个应答结构体

// HTTP接口应答
type Response struct {
	Errno int `json:"errno"`
	Msg string `json:"msg"`
	Data interface{} `json:"data"`
}

// 应答方法
func BuildResponse(errno int, msg string, data interface{}) (resp []byte, err error) {
	// 1, 定义一个response
	var (
		response Response
	)

	response.Errno = errno
	response.Msg = msg
	response.Data = data

	// 2, 序列化json
	resp, err = json.Marshal(response)
	return
}

其中G_jobMgr.SaveJob 为etcd交互类中的方法，代码如下：

// 保存任务
func (jobMgr *JobMgr) SaveJob(job *common.Job) (oldJob *common.Job, err error) {

	// 把任务保存到/cron/jobs/任务名 -> json
	var (
		jobKey    string
		jobValue  []byte
		putResp   *clientv3.PutResponse
		oldJobObj common.Job
	)

	// etcd的保存key
	jobKey = common.JOB_SAVE_DIR + job.Name

	// 任务信息json
	if jobValue, err = json.Marshal(job); err != nil {
		return
	}

	// 保存到etcd
	if putResp, err = jobMgr.kv.Put(context.TODO(), jobKey, string(jobValue), clientv3.WithPrevKV()); err != nil {
		return
	}

	// 如果是更新, 那么返回旧值
	if putResp.PrevKv != nil {
		// 对旧值做一个反序列化
		if err = json.Unmarshal(putResp.PrevKv.Value, &oldJobObj); err != nil {
			err = nil //防止旧值不是一个正确的 job json ，所以做错误移除
			return
		}
		oldJob = &oldJobObj
	}

	return

}
2：删除任务

基于IDEA client 发送request如下：

###
POST http://localhost:8070/job/delete
Accept: */*
Cache-Control: no-cache
Content-Type: application/x-www-form-urlencoded

name=job1

流程与删除相同，不赘述流程。
部分代码如下 (//todo完整代码调试通过后随github给出)：

JobMgr.go

// 删除任务
func (jobMgr *JobMgr) DeleteJob(name string) (oldJob *common.Job, err error) {
	var (
		jobKey    string
		delResp   *clientv3.DeleteResponse
		oldJobObj common.Job
	)

	// etcd中保存任务的key
	jobKey = common.JOB_SAVE_DIR + name

	// 从etcd中删除它
	if delResp, err = jobMgr.kv.Delete(context.TODO(), jobKey, clientv3.WithPrevKV()); err != nil {
		return
	}

	// 返回被删除的任务信息
	if len(delResp.PrevKvs) != 0 {
		// 解析一下旧值, 返回它
		if err = json.Unmarshal(delResp.PrevKvs[0].Value, &oldJobObj); err != nil {
			err = nil
			return
		}
		oldJob = &oldJobObj
	}
	return
}

ApiServer.go

func InitApiServer() (err error) {
	//
	initAPmux.HandleFunc("/job/delete", handleJobDelete)
	//
}
// 删除任务接口
// POST /job/delete   name=job1
func handleJobDelete(resp http.ResponseWriter, req *http.Request) {
	var (
		err    error // interface{}
		name   string
		oldJob *common.Job
		bytes  []byte
	)

	// POST:   a=1&b=2&c=3
	if err = req.ParseForm(); err != nil {
		goto ERR
	}

	// 删除的任务名
	name = req.PostForm.Get("name")

	// 去删除任务
	if oldJob, err = G_jobMgr.DeleteJob(name); err != nil {
		goto ERR
	}

	// 正常应答
	if bytes, err = common.BuildResponse(0, "success", oldJob); err == nil {
		resp.Write(bytes)
	}
	return

ERR:
	if bytes, err = common.BuildResponse(-1, err.Error(), nil); err == nil {
		resp.Write(bytes)
	}
}
3：任务遍历

基于IDEA client 发送request如下：

POST http://localhost:8070/job/list
Content-Type: application/x-www-form-urlencoded

总体流程与上述一致，不进行赘述，相关代码如下：

JobMgr.go

//列举任务
func (jobMgr *JobMgr) ListJobs() (jobList []*common.Job, err error) {
	var (
		dirKey  string
		getResp *clientv3.GetResponse
		kvPair  *mvccpb.KeyValue
		job     *common.Job
	)

	// 任务保存的目录
	dirKey = common.JOB_SAVE_DIR

	// 获取目录下所有任务信息
	if getResp, err = jobMgr.kv.Get(context.TODO(), dirKey, clientv3.WithPrefix()); err != nil {
		return
	}

	// 初始化数组空间
	jobList = make([]*common.Job, 0) // len(jobList) == 0

	// 遍历所有任务, 进行反序列化
	for _, kvPair = range getResp.Kvs {
		job = &common.Job{}
		if err = json.Unmarshal(kvPair.Value, job); err != nil {
			err = nil
			continue
		}
		//赋值以避免首地址改变
		jobList = append(jobList, job)
	}
	return
}

ApiServer.go

func InitApiServer() (err error) {
	//
	initAPmux.HandleFunc("/job/delete", handleJobDelete)
	//
}

// 列举所有crontab任务
func handleJobList(resp http.ResponseWriter, req *http.Request) {
	var (
		jobList []*common.Job
		bytes   []byte
		err     error
	)

	// 获取任务列表
	if jobList, err = G_jobMgr.ListJobs(); err != nil {
		goto ERR
	}

	// 正常应答
	if bytes, err = common.BuildResponse(0, "success", jobList); err == nil {
		resp.Write(bytes)
	}
	return

ERR:
	if bytes, err = common.BuildResponse(-1, err.Error(), nil); err == nil {
		resp.Write(bytes)
	}
}
4：强杀一个任务

基于IDEA client 发送request如下：

###
POST http://localhost:8070/job/kill
Content-Type: application/x-www-form-urlencoded

name=job1

任务的执行是依赖worker执行的，呢么只有相应的worker才可以做到对任务线程进行移除，所以mater需要将强杀命令广播到所有的worker，令做该任务的worker收到command；

client ApiServer.go JobMgr.go etcd worker request for add cronJob for add KV with leased for insert KV with leased add kv with leased in kill path watch kill path notify par [ doPut ] success 移除kill path 下发布的任务 par [ doKill ] success success client ApiServer.go JobMgr.go etcd worker

相关代码如下：

JobMgr.go

// 杀死任务
func (jobMgr *JobMgr) KillJob(name string) (err error) {
	// 更新一下key=/cron/killer/任务名
	var (
		killerKey      string
		leaseGrantResp *clientv3.LeaseGrantResponse
		leaseId        clientv3.LeaseID
	)

	// 通知worker杀死对应任务
	killerKey = common.JOB_KILLER_DIR + name

	//让worker监听到一次put操作
	if leaseGrantResp, err = jobMgr.lease.Grant(context.TODO(), 1); err != nil {
		return
	}

	// 租约ID
	leaseId = leaseGrantResp.ID

	// 创建带有租约的kv
	if _, err = jobMgr.kv.Put(context.TODO(), killerKey, "", clientv3.WithLease(leaseId)); err != nil {
		return
	}
	return
}

强杀的KV没必要长期存在，因为worker监听得到消息之后就可以删除，所以设置一秒的生命周期，做自动移除使用。当然，也可以自己给自己加一个定时任务，去做定时删除该path下的任务。

ApiServer.go

func InitApiServer() (err error) {
	//
	mux.HandleFunc("/job/kill", handleJobKill)
	//
}

// 强制杀死某个任务
// POST /job/kill  name=job1
func handleJobKill(resp http.ResponseWriter, req *http.Request) {
	var (
		err   error
		name  string
		bytes []byte
	)

	// 解析POST表单
	if err = req.ParseForm(); err != nil {
		goto ERR
	}

	// 要杀死的任务名
	name = req.PostForm.Get("name")

	// 杀死任务
	if err = G_jobMgr.KillJob(name); err != nil {
		goto ERR
	}

	// 正常应答
	if bytes, err = common.BuildResponse(0, "success", nil); err == nil {
		resp.Write(bytes)
	}
	return

ERR:
	if bytes, err = common.BuildResponse(-1, err.Error(), nil); err == nil {
		resp.Write(bytes)
	}
}
LcyCoinEleP
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go-分布式定时任务库distributed-cron
08-13
分布式定时任务库 distributed-cron
Go-golang分布式多业务线定时任务系统
08-13
golang分布式多业务线定时任务系统
Golang分布式应用之定时任务
Qinng的博客
07-29 1867
本文主要总结了定时任务的两种实现方式，最小堆与时间轮，并分析其核心实现逻辑。
Go-Job让你的任务调度不再繁琐｜得物技术
最新发布
SmartCodeTech的博客
06-20 1959
在选择任务调度平台时，团队遇到了一些实际的问题。现有的开源项目如XXL-Job、Elastic-Job，虽然功能强大，但主要是围绕Java设计，而我们团队主要使用Go语言进行开发。这使得我们在集成和使用这些工具时遇到了诸多不顺。经过深入的调研和讨论，决定开发一个适合Go语言的任务调度框架，以满足我们的特定业务需求。于是，Go-Job应运而生。为了让大家有个全面的了解，接下来主要探讨它的架构设计和功能特性。
基于GO语言实现分布式定时任务学习（二）---- etcd学习笔记并完成分布式乐观锁case
Lcy
05-12 1365
etcd 基础入门： 一）etcd 功能介绍 数据存储在集群中的高可用K-V存储。 允许应用实时监听存储中的K-V变化。 可以容忍单点故障，并支持网络分区。 在传统的存储模型中： 如果存储节点是单点存储，呢么遇到宕机，即刻不可用； 如果是主从架构，当主库不可用的使用，虽然可以继续基于从库来读，单主从同步时延容忍度又是新的问题。 etcd 基于抽屉理论来解决该点，所谓的抽屉理论指： 假如我们有一个30人的班级，我将一个秘密告诉其中的16位同学，呢么随便挑选16个同学中，必然有一个是知道我秘密的
GO代码生成代码小思小试
三角室专栏
07-05 675
推进需求 GO 项目，可整体生成一个运行文件到处跑，是极爽之事。但如果有资源文件要得带着跑，则破坏了这种体验。 例如下边这个项目结构，resource 目录下为资源文件，main.go 中会通过路径引用到这些资源文件，于是新的需求产生了。 |- hello ----|- resource ---------|- note.txt ----|- main.go 需求推进一步：将资源...
基于go语言的大数据分布式有序计算(例如行情数据处理-定时任务调度等).zip
02-28
大数据分布式有序计算(例如行情数据处理-定时任务调度等).zip 分布式强有序实时计算 -- 第一版（一个master节点 多个slave节点，轻量级storm golang版本） 应用场景：大数据(行情数据)处理/定时任务调度等 功能： ...
xxl-job-executor-go-master
06-19
XXL-JOB是一个分布式任务调度平台，而"xxl-job-executor-go-master"则表示这个项目是XXL-JOB的Go语言实现版本的源码仓库。这个仓库是针对XXL-JOB执行器的一个Go语言实现，它使得开发者可以利用Go语言来编写调度任务...
go-xxl-executor-master
06-19
"Go-XXL Executor Master" 是一个基于 Go 语言实现的分布式任务执行框架，主要针对大规模并发任务处理场景。从项目名称我们可以推测，它可能是借鉴了 Java 的 XXL-Job 框架，并且进行了 Go 语言的移植或改造，以提供...
Go-ratelimit基于令牌桶算法和漏桶算法来实现的限速限流Golang实现
08-14
在`ratelimit-master`这个项目中，我们可以找到具体的源代码实现。库通常提供API供开发者创建和管理限速器。例如，可能有一个`NewTokenBucket()`函数用于创建令牌桶限速器，另一个`NewLeakyBucket()`函数用于创建漏...
Go-Gores-基于Redis的异步作业执行系统
08-14
`Go-Gores` 是一个用Go语言编写的高效、轻量级的异步作业执行系统，它利用了Redis作为中间件来实现任务的调度与分发。设计的目标是为分布式系统提供可靠且灵活的定时任务解决方案，支持高并发和大规模数据处理场景。...
go分布式定时任务代码.zip
09-12
在看gocron的时候，里面的黑科技挺多的，这里写了下它的grpc核心代码部分，与及简单任务的执行过程，可以帮助初学者更好的了解其原理
Go-gocron-使用Go语言开发的轻量级定时任务集中调度和管理系统
08-13
gocron - 使用Go语言开发的轻量级定时任务集中调度和管理系统, 用于替代Linux-crontab
masterGoProgramming：Master Go编程-Udemy课程
02-13
masterGo编程 Master Go（Golang）编程：完整的Golang训练营（由Andrei Dumitrescu通过Udemy提供）
Document-Management-Server:用 Go 编写的文件管理服务器
06-13
项目： 用go编写的简单快速的文档/文件管理服务器 特征： 上传文件的网页界面 自动解压缩 zip 文件 自动解压 tar 和 tar.gz 文件 在（所有）文件类型中搜索字符串 去做： 递归文件夹列表（walkpath） 增强 tar/untar 功能 过滤二进制文件 权限/登录系统 美化 要求： Go 安装并正确设置 GOPATH 学分： 由 Daniel Geers 撰写（ geers[-at-]cs[-dot-]uni-frankfurt[-dot-]de ） 使用开源项目“font awesome”（菜单图标） 焦油/解焦油：萨默菲尔德，马克。 在 Go 中编程。 艾迪生-韦斯利 2012。 文档/服务器 API： baseurl = 本地主机，端口 = 8080 API-Style: < baseurl> : < port> / < command> /
go-tdlib：Golang电报TdLib JSON绑定
02-04
go-tdlib Golang电报TdLib JSON绑定 介绍 Telegram Tdlib是用于创建电报客户端的完整库，它还具有一个简单的tdjson即用型库，可简化与不同编程语言和平台的集成。 go-tdlib是完整的tdlib-tdjson绑定软件包，可帮助您创建自己的Telegram客户端。 注意：基本的tdjson-golang绑定是受此软件包启发的： 使用自动生成工具导出了文件中声明的所有类和函数。 因此，您可以在Tdlib中使用每种类型和方法。 主要特点： tdlib .tl模式的自动生成的golang结构和方法 用户定义的自定义事件接收器（例如，仅从特定用户处获得
Go 代码生成利器 Go Generate
技术能量站
08-08 2381
在Go语言中，go generate​ 命令是一个非常有用的工具，它可以帮助我们自动化地生成代码。本文将详细介绍如何使用 go generate​ 命令，并提供一些示例来说明它的用法。go generate​ 命令是一个用于自动化生成Go代码的工具。它可以在Go源文件中的特殊注释中指定命令，然后在运行 go generate​ 命令时自动执行这些命令。这些命令可以用来生成代码、格式化代码、运行测试等等。
图解分布式定时器从零实现 | go语言（一）
qq_40318498的博客
03-31 1252
在许多业务场景中,我们需要使用定时器来执行一些定期任务或操作。订单管理当订单一直处于未支付状态时,需要及时关闭订单并退还库存对于处于退款状态的订单,需要定期检查是否已经退款成功用户激活对于新创建的店铺,如果在N天内没有上传商品,系统需要发送激活短信提醒数据统计需要定期统计并更新各种业务指标和报表数据缓存刷新需要定期刷新或更新缓存数据,以确保数据的及时性和准确性消息队列消费需要定期从消息队列中消费并处理消息系统维护需要定期执行一些系统维护任务,如日志清理、数据备份等。
PPGo_Job跨服务器分发定时任务系统V2.0
weixin_33747129的博客
07-27 272
PPGo_Job2.0发布 前言：PPGo_Job V1.x版本开源一年多，好几个朋友的公司都在用，反响还不错，当然，也有好多朋友提了不少合理的意见和建议，所以这次干脆重构了一下，连UI也重新编码。目前V2.x版本 已经用于生产环境。 github地址： https://github.com/george518/PPGo_Job V1.x版本是一个简单的...
分布式定时任务中间件Elastic-Job详解与实现
"分布式定时任务中间件架构及其实现" 分布式定时任务中间件在现代互联网应用中扮演着至关重要的角色，因为它们可以帮助管理和调度系统中广泛存在的定时任务，从而提高系统的自动化水平和稳定性。Elastic-Job是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值