用Go实现一个多线程HTTP下载服务器，支持暂停、断点续传、重新下载、限速下载、删除、多任务并行下载等功能

已于 2024-08-30 17:36:34 修改
阅读量1.5k 收藏 34
点赞数 28
文章标签： go gin sqlite http
于 2024-08-22 15:39:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74073836/article/details/141428045
版权

项目简介:

项目功能说明：

  1. 该网站包括file页面、transfer页面和settings页面。其中，file页面用于显示指定目录下的所有文件，可根据文件类型、名称或者大小进行排序筛选；transfer页面主要的使用场景是实现提交HTTP地址后下载到服务器上，这个服务器可以作为NAS或者云盘使用；settings页面用于设置下载路径、限速大小、最大并行任务数。
  2. transfer页面能够查看每个任务的下载进度、下载速度和下载剩余时间，用户可自行控制并发线程数。

 技术栈: Gin + Gorm + Sqlite + SSE

项目地址(欢迎star): 

JAVA版本：https://gitee.com/Liguangyu1017/HTTP-download-server 

GO版本: https://github.com/Lemon001017/HTTP-download-server​​​​​​​​​​​​​​

JAVA版本的实现细节见: http://t.csdnimg.cn/1T1Km

效果展示:

 API 文档:

查看方式：

项目运行后浏览器输入：http://localhost:8000/api/docs/

分片下载实现步骤:

  1. 用户提交下载 url
  2. 获取文件大小、保存路径、最大速度等
  3. 计算分片大小、分片数量，初始化所有分片
  4.  创建 goroutine 池，循环将所有分片丢入池中 （调用ants第三方库）
  5. 动态计算下载速度、进度、剩余时间，并通过 sse 发送到客户端
  6. 等待下载结束

1. 获取下载配置

func (h *Handlers) getSettingsInfo() (string, float64, uint, error) {
	settings, err := models.GetSettings(h.db, 1)
	if err != nil {
		return "", 0, 0, err
	}

	outputDir := settings.DownloadPath
	if outputDir == "" {
		outputDir, err = os.Getwd()
		if err != nil {
			return "", 0, 0, err
		}
	}

	maxDownloadSpeed := settings.MaxDownloadSpeed
	if maxDownloadSpeed == 0 {
		maxDownloadSpeed = 1e9
	}

	maxTasks := settings.MaxTasks
	if maxTasks == 0 {
		maxTasks = 4
	}
	return outputDir, maxDownloadSpeed, maxTasks, nil
}

 2. 计算分片大小、数量

分片策略: 
本项目采用固定分片大小，即根据文件大小来决定分片数量。
根据文件大小，文件大小小于等于10MB的按照32KB，10MB~100MB按照1MB,超过100MB按照10MB进行分片。

func (h *Handlers) getChunkInfo(fileSize int64) (int64, int64) {
	var chunkSize int64
	switch {
	case fileSize <= 10*1024*1024:
		chunkSize = models.MinChunkSize
	case fileSize <= 100*1024*1024:
		chunkSize = models.MidChunkSize
	default:
		chunkSize = models.MaxChunkSize
	}
	numChunks := (fileSize + chunkSize - 1) / chunkSize
	return chunkSize, numChunks
}

3. 获取文件信息

func (h *Handlers) getFileInfo(url string, outputDir string) (int64, string, string, error) {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return 0, "", "", err
	}

	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36")
	req.Header.Set("Accept", "*/*")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return 0, "", "", err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return 0, "", "", err
	}

	fileSize := resp.ContentLength
	fileName := extractFileName(resp, url)
	outputPath := filepath.Join(outputDir, fileName)

	return fileSize, outputPath, fileName, nil
}

func extractFileName(resp *http.Response, downloadURL string) string {
	if contentDisposition := resp.Header.Get("Content-Disposition"); contentDisposition != "" {
		_, params, err := mime.ParseMediaType(contentDisposition)
		if err == nil && params["filename"] != "" {
			return params["filename"]
		}
	}

	parsedURL, err := url.Parse(downloadURL)
	if err != nil {
		parsedURL.Path = "/unknown"
	}

	re := regexp.MustCompile(`[^\/]+\.[a-zA-Z0-9]+$`)
	fileName := re.FindString(parsedURL.Path)
	if fileName == "" {
		fileName = "unknown_file"
	}
	return fileName
}

4. 初始化一个下载任务

func (h *Handlers) initOneTask(url, key string) (*models.Task, error) {
	outputDir, _, _, err := h.getSettingsInfo()
	if err != nil {
		return nil, err
	}

	fileSize, outputPath, fileName, err := h.getFileInfo(url, outputDir)
	if err != nil {
		return nil, err
	}

	chunkSize, numChunks := h.getChunkInfo(fileSize)

	task := models.Task{
		ID:        key,
		Name:      fileName,
		Url:       url,
		Size:      fileSize,
		SavePath:  outputPath,
		FileType:  filepath.Ext(fileName),
		Threads:   models.DefaultThreads,
		Status:    models.TaskStatusPending,
		ChunkNum:  numChunks,
		ChunkSize: chunkSize,
		Chunk:     make([]models.Chunk, numChunks),
	}

	err = models.AddTask(h.db, &task)
	if err != nil {
		return nil, err
	}
	return &task, nil
}

 5. 提交下载任务，异步执行下载，动态计算下载数据并发送给客户端

注意：每个分片下载完成之后，存储到分片的起始位置中，这个过程由于文件句柄只有一个，需要加锁(mutex)后进行seek和write，保证存储位置的准确性。

// submit task
func (h *Handlers) handleSubmit(c *gin.Context) {
	var request DownloadRequest
	err := c.ShouldBindJSON(&request)
	if err != nil {
		carrot.AbortWithJSONError(c, http.StatusBadRequest, err)
		return
	}

	eventSource := h.createEventSource()

	task, err := h.initOneTask(request.URL, eventSource.key)
	if err != nil {
		carrot.AbortWithJSONError(c, http.StatusInternalServerError, err)
		return
	}

	// Open a goroutine to handle the download separately
	go func() {
		h.processDownload(eventSource, task, 0)
	}()
	c.JSON(http.StatusOK, EventSourceResult{Key: eventSource.key})
}

func (h *Handlers) processDownload(es *EventSource, task *models.Task, lastTotalDownloaded int64) {
	startTime := time.Now()
	carrot.Info("id:", task.ID, "fileSize:", task.Size, "savePath:", task.SavePath, "chunkSize:", task.ChunkSize, "numChunks:", task.ChunkNum)

	outputFile, err := os.OpenFile(task.SavePath, os.O_RDWR|os.O_CREATE, 0644)
	if err != nil {
		carrot.Error("open or create file error", "key:", es.key, "id:", task.ID, "url:", task.Url, "err:", err)
		return
	}

	_, maxDownloadSpeed, _, err := h.getSettingsInfo()
	if err != nil {
		carrot.Error("get settings error", "key:", es.key, "id:", task.ID, "url:", task.Url, "err:", err)
		return
	}

	// Init chunk info
	if task.TotalDownloaded == 0 {
		for i := 0; i < int(task.ChunkNum); i++ {
			start := int64(i) * task.ChunkSize
			end := math.Min(float64(start+task.ChunkSize), float64(task.Size)) - 1
			task.Chunk[i] = models.Chunk{
				TaskID: task.ID,
				Index:  i,
				Start:  int(start),
				End:    int(end),
			}
			models.AddChunk(h.db, &task.Chunk[i])
		}
	}

	task.Status = models.TaskStatusDownloading
	models.UpdateTask(h.db, task)

	// Create a pool of goroutines
	pool, _ := ants.NewPoolWithFunc(int(task.Threads), func(i interface{}) {
		err := h.downloadChunk(es, &task.Chunk[i.(int)], task, outputFile, startTime, maxDownloadSpeed, lastTotalDownloaded)
		if err != nil {
			if !errors.Is(err, context.Canceled) && !errors.Is(err, os.ErrClosed) {
				carrot.Error("download chunk failed", "key:", es.key, "url:", task.Url, "err:", err)
				task.Status = models.TaskStatusFailed
				models.UpdateTask(h.db, task)
				es.Emit(DownloadProgress{ID: task.ID, Name: task.Name, Status: models.TaskStatusFailed})
			}

			// Clean all resources
			outputFile.Close()
			h.cleanEventSource(task.ID)
			return
		}
	})
	defer pool.Release()

	for i := 0; i < int(task.ChunkNum); i++ {
		// Skip completed chunks
		if !task.Chunk[i].Done {
			_ = pool.Invoke(i)
		}
	}
}

func (h *Handlers) downloadChunk(es *EventSource, chunk *models.Chunk, task *models.Task,
	outputFile *os.File, startTime time.Time, maxDownloadSpeed float64, lastTotalDownloaded int64) error {
	req, err := http.NewRequest(http.MethodGet, task.Url, nil)
	if err != nil {
		carrot.Error("Failed to create HTTP request", "key:", es.key, "url:", task.Url)
		return err
	}

	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36")
	req.Header.Set("Accept", "*/*")
	req.Header.Set("Range", fmt.Sprintf("bytes=%v-%v", chunk.Start, chunk.End))
	req = req.WithContext(es.ctx)

	resp, err := h.client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusPartialContent {
		carrot.Error("key:", es.key, "url:", task.Url, "status:", resp.StatusCode)
		return err
	}

	buf := make([]byte, 2048)

	h.mu.Lock()

	_, err = outputFile.Seek(int64(chunk.Start), 0)
	if err != nil {
		h.mu.Unlock()
		return err
	}

	// Create a rate limiter
	maxDownloadSpeedInBytes := maxDownloadSpeed * 1000 * 1000
	limiter := rate.NewLimiter(rate.Limit(maxDownloadSpeedInBytes), int(maxDownloadSpeedInBytes*0.1))

	lastMessageTime := time.Now()

	for {
		n, err := resp.Body.Read(buf)
		if err != nil && err != io.EOF {
			h.mu.Unlock()
			return err
		}

		if n == 0 {
			break
		}

		err = limiter.WaitN(es.ctx, n)
		if err != nil {
			h.mu.Unlock()
			return err
		}

		_, err = outputFile.Write(buf[:n])
		if err != nil {
			h.mu.Unlock()
			return err
		}

		task.TotalDownloaded += int64(n)

		if time.Since(lastMessageTime) >= models.MessageInterval {
			speed, progress, remainingTime := h.calculateDownloadData(task, startTime, lastTotalDownloaded)
			es.Emit(DownloadProgress{
				ID:            task.ID,
				Name:          task.Name,
				Progress:      progress,
				Speed:         speed,
				RemainingTime: remainingTime,
				Status:        task.Status,
			})
			models.UpdateTask(h.db, task)
			lastMessageTime = time.Now()
		}
	}

	chunk.Done = true
	models.UpdateChunk(h.db, chunk)
	// download complete
	if task.TotalDownloaded == task.Size {
		task.Status = models.TaskStatusDownloaded
		models.UpdateTask(h.db, task)

		es.Emit(DownloadProgress{
			ID:     task.ID,
			Name:   task.Name,
			Status: task.Status,
		})

		carrot.Info("Download complete", "key:", es.key, "id:", task.ID, "url:", task.Url)

		models.DeleteChunks(h.db, task.ID)
		outputFile.Close()
		close(es.eventChan)
	} else if task.TotalDownloaded > task.Size {
		return models.ErrExpectedFileSize
	}

	models.UpdateTask(h.db, task)

	h.mu.Unlock()
	return nil
}

 6. 等待下载结束，判断是否下载成功，清理资源:

	// download complete
	if task.TotalDownloaded == task.Size {
		task.Status = models.TaskStatusDownloaded
		models.UpdateTask(h.db, task)

		es.Emit(DownloadProgress{
			ID:     task.ID,
			Name:   task.Name,
			Status: task.Status,
		})

		carrot.Info("Download complete", "key:", es.key, "id:", task.ID, "url:", task.Url)

		models.DeleteChunks(h.db, task.ID)
		outputFile.Close()
		close(es.eventChan)
	} else if task.TotalDownloaded > task.Size {
		return models.ErrExpectedFileSize
	}

暂停下载实现步骤：

  1. 获取所有 id
  2. 根据 id 获取所有任务
  3. 枚举所有任务，更新任务状态，然后调用 cleanEventSource 方法执行上下文取消
// Pause download
func (h *Handlers) handlePause(c *gin.Context) {
	var ids []string
	err := c.ShouldBindJSON(&ids)
	if err != nil {
		carrot.AbortWithJSONError(c, http.StatusBadRequest, err)
		return
	}

	tasks, err := models.GetTaskByIds(h.db, ids)
	if err != nil {
		carrot.AbortWithJSONError(c, http.StatusInternalServerError, err)
		return
	}

	for _, task := range tasks {
		if task.Status == models.TaskStatusDownloading {
			h.cleanEventSource(task.ID)

			task.Status = models.TaskStatusCanceled
			models.UpdateTask(h.db, &task)
		} else {
			carrot.AbortWithJSONError(c, http.StatusBadRequest, models.ErrStatusNotDownloading)
			return
		}
	}
	c.JSON(http.StatusOK, gin.H{"ids": ids})
}

// Clean resources
func (h *Handlers) cleanEventSource(key string) {
	v, ok := h.eventSources.LoadAndDelete(key)
	if !ok {
		return
	}

	eventSource, ok := v.(*EventSource)
	if !ok {
		return
	}

	eventSource.cancel()
	if eventSource.eventChan != nil {
		close(eventSource.eventChan)
		eventSource.eventChan = nil
	}
}

恢复下载实现步骤:

关键:  每个下载任务都对应一个记分牌，用于记录 taskId、分片索引、开始位置、结束位置和是否下载完成，这些数据存入 chunks 表中；当这个分片下载完成就会标记为 true 并更新数据库，这样再次开启下载只需要提交未下载的分片到 pool 中即可。

  1. 获取所有 id
  2. 根据 id 获取所有任务
  3. 枚举所有任务，更新任务状态，根据任务 id 获取所有分片，异步调用 processDownload 方法执行下载
  4. 等待下载结束
// Resume download
func (h *Handlers) handleResume(c *gin.Context) {
	var ids []string
	err := c.ShouldBindJSON(&ids)
	if err != nil {
		carrot.AbortWithJSONError(c, http.StatusBadRequest, err)
		return
	}

	tasks, err := models.GetTaskByIds(h.db, ids)
	if err != nil {
		carrot.AbortWithJSONError(c, http.StatusInternalServerError, err)
		return
	}

	for _, task := range tasks {
		if task.Status != models.TaskStatusCanceled {
			carrot.AbortWithJSONError(c, http.StatusBadRequest, models.ErrStatusNotCanceled)
			return
		}

		es := h.createEventSourceWithKey(task.ID)

		task.Status = models.TaskStatusPending
		task.Speed = 0
		task.Chunk = models.GetChunksByTaskId(h.db, task.ID)
		models.UpdateTask(h.db, &task)

		lastTotalDownloaded := task.TotalDownloaded

		go func() {
			h.processDownload(es, &task, lastTotalDownloaded)
		}()
	}
	c.JSON(http.StatusOK, gin.H{"ids": ids})
}

重新下载实现步骤:

  1. 获取所有 id
  2. 根据 id 获取所有任务
  3. 枚举所有任务，重置下载进度，根据 key 创建对应的 eventSource，更新任务状态，异步调用 processDownload 方法执行下载
  4. 等待下载结束
// Re download
func (h *Handlers) handleRestart(c *gin.Context) {
	var ids []string
	err := c.ShouldBindJSON(&ids)
	if err != nil {
		carrot.AbortWithJSONError(c, http.StatusBadRequest, err)
		return
	}

	tasks, err := models.GetTaskByIds(h.db, ids)
	if err != nil {
		carrot.AbortWithJSONError(c, http.StatusInternalServerError, err)
		return
	}

	for _, task := range tasks {
		if task.Status != models.TaskStatusDownloaded {
			carrot.AbortWithJSONError(c, http.StatusBadRequest, models.ErrStatusNotDownloaded)
			return
		}
		es := h.createEventSourceWithKey(task.ID)

		task.Status = models.TaskStatusPending
		task.TotalDownloaded = 0
		task.Progress = 0
		task.Speed = 0
		task.Chunk = make([]models.Chunk, task.ChunkNum)
		models.UpdateTask(h.db, &task)

		go func() {
			h.processDownload(es, &task, 0)
		}()
	}
	c.JSON(http.StatusOK, gin.H{"ids": ids})
}

限速下载实现步骤:

  1. 安装 `golang.org/x/time/rate` 库
  2. 创建一个限速器，设置每秒允许的请求数和桶的大小(这里限速单位是 MB/s，需要先将 MB/s 转换为 Bytes/s) 
    // Create a rate limiter
maxDownloadSpeedInBytes := maxDownloadSpeed * 1000 * 1000
limiter := rate.NewLimiter(rate.Limit(maxDownloadSpeedInBytes), int(maxDownloadSpeedInBytes*0.1))
  3. 集成到 `downloadChunk`方法中
    // Create a rate limiter
	maxDownloadSpeedInBytes := maxDownloadSpeed * 1000 * 1000
	limiter := rate.NewLimiter(rate.Limit(maxDownloadSpeedInBytes), int(maxDownloadSpeedInBytes))

	for {
		n, err := resp.Body.Read(buf)
		if err != nil && err != io.EOF {
			h.mu.Unlock()
			return err
		}

		if n == 0 {
			break
		}

		err = limiter.WaitN(es.ctx, n)
		if err != nil {
			h.mu.Unlock()
			return err
		}

		_, err = outputFile.Write(buf[:n])
		if err != nil {
			h.mu.Unlock()
			return err
		}

		task.TotalDownloaded += int64(n)

		speed, progress, remainingTime := h.calculateDownloadData(task, startTime, lastTotalDownloaded)
		es.Emit(DownloadProgress{
			ID:            task.ID,
			Name:          task.Name,
			Progress:      progress,
			Speed:         speed,
			RemainingTime: remainingTime,
			Status:        task.Status,
		})
	}
Lemon031017
关注
提供一个异步下载的类，支持批量下载。
07-03
- 多线程或多进程：在支持多线程或多进程的系统中，可以创建多个下载任务并发执行。 - 异步I/O库：如Python的aiohttp、Node.js的axios或Java的AsyncHttpClient，这些库都提供了异步HTTP请求的功能。 5. 监控和...
Android平台多线程文件下载器
07-21
文件分割下载，每个线程处理一部分，通过Range头指定起始位置，实现断点续传。 同步线程进度，更新UI需确保线程安全，使用Handler或HandlerThread。同时，处理网络故障、存储空间问题，提供下载控制功能。 高级特性...
从HTTP服务器下载文件
01-10
如何用HTTP协议下载WEB上的资源,网络程序开发的经典入门例子
Go语言使用http下载文件
sun007700的专栏
09-25 1400
参考 https://blog.csdn.net/a99361481/article/details/81751231 package main import ( "net/http" "log" "time" "net/url" "path" "os" "io" "bufio" "math" "strc...
Python搭建http下载服务器
cxd1314520的博客
04-24 542
使用： 保存为httpserver.py, 放在你想访问和下载文件夹下。网页搜索你自己本地ip:端口号，如 192.168.1.111:8002。python运行httpserver.py.
Linux——搭建http文件下载服务器
jin719的博客
09-12 1178
6、但是点击以后又出现一个新问题：You don't have permission to access /config on this server，意识到没有把文件压缩，它是打开了这个网页。把文件压缩就可以下载了。5、apache服务器的默认目录在/var/www/html，如果想利用http服务器下载文件，需要删除其index.html文件，然后把文件放在该目录即可。
tomcat作为http的下载服务器
最好的我们的博客
09-19 394
tomcat作为http的下载服务器，网上有很多办法 但我认为最简单的是： 1、直接把文件放在/var/lib/tomcat6/webapps/ROOT 目录下， 2、然后在网址中访问： http://192.168.2.31:8080/download.zip 便可下载。 但是，如何你不想放在webapps/ROOT下，就要对想要下载的目录进行配置： 1、在tomcat 安装
高效实现iOS断点续传与下载管理
iOS 断点续传和下载管理是移动应用开发中非常重要的功能，尤其是对于需要下载大文件的应用来说，它保证了在网络不稳定或者应用被关闭的情况下，用户可以接着上一次的进度继续下载，而不需要从头开始下载，这样不仅...
QT多线程下载器
01-26
QT多线程下载器是一种利用QT框架开发的高效文件下载工具，它采用了多线程技术来提高文件下载速度，尤其适合处理大文件或网络环境不稳定的情况。QT是Qt Company开发的一个开源C++图形用户界面应用程序开发框架，广泛...
多点续传下载
03-05
从提供的压缩包文件名称“多线程下载器_ab2c6c26__upload_app_530514490db17427a72.apk”来看，我们可以推测这是一个多线程下载工具的安卓应用版本。这个应用很可能是为了帮助用户更高效地下载大文件，如高清视频、...
http服务器
02-28
基于VC的http服务器，适合初学者，基于VC的http服务器，适合初学者
HTTP服务器
05-30
一个用VB做的HTTP服务器可以上传文件到服务器
基于HTTP文件下载工具--服务器端程序
11-30
执行http9090.exe启动服务器，监听端口9090，在浏览器中访问服务器即可下载ABC目录下的文档。例如，http9090.exe在IP地址为192.168.1.222的机器上启动，即可在局域网中的任何一台机器访问http://192.168.1.222:9090下载服务器上的文档。
自己写的功能简单的 http server 文件下载服务器 http服务器
baoecit的博客
01-29 2024
最近在项目中遇到过 通过ssh登录到某台机器A ，然后 又从A机器上ssh到机器B 而B机器是没有外网功能，这个时候如果想从B机器上传文件到A机器上就很不好办了 由于B机器没有外网 很多工具软件都没有 原来是是用python 起的http服务器 但是B机器没有安装python。于是就参照之前的项目经历写了一个简单的http server服务端 ，编译之后放在B机器上。运行环境ubuntu 18.04 依赖于libevent库。临时用可以了 解决了不能从B机器上下载文件到A机器上的问题。
linux http下载服务器,使用Apache打造完美限制的HTTP下载服务器
weixin_42398629的博客
04-28 477
一开始本来准备选择使用FTP作为下载服务器的，不过过了几天就发现很多都是通过盗链的方式来FTP下载。这下服务器在持续性全速提供上传，但是网站的页面浏览量却少得可怜。因为FTP天生不能放盗链的特性所以只能考虑放弃使用，最后决定用HTTP下载来替代。直接用HTTP服务器下载也不是很容易的事。最开始在IIS里面配置，IIS只能设定最大下载速度和最大连接数，这对于一些使用下载工具一来就开50+线程霸道下载...
Go-通过Http下载文件
luyaran的博客
07-23 2586
// DownFile 通过Http下载文件 func DownFile(imgUrl, projectID, uuid string) (string, error) { res, httpErr := http.Get(imgUrl) if httpErr != nil { return "Http Error", httpErr } defer res.Body.Close() defineConfig := global.GetConfig("define") imgPath :.
用Java实现一个多线程HTTP下载服务器，支持暂停、断点续传、重新下载、限速下载、删除、多任务并行下载等功能
m0_74073836的博客
04-29 2267
一个支持HTTP下载的网站，支持暂停、重新下载、删除、限速和并行多任务下载。包含完整代码和相关注释。
实现多线程下载文件的限速控制
最新发布
weixin_44617651的博客
11-01 473
实现多线程下载文件并控制下载速度可以通过 Python 的 threading 和 requests 库来完成。下面是一个示例，展示如何使用多线程下载文件，并在下载时实现限速控制。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值