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

已于 2024-08-22 15:59:50 修改
阅读量629 收藏 12
点赞数 12
文章标签： 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

项目地址: 

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

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

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

效果展示:

分片下载实现步骤:

  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:         4,
		Status:          models.TaskStatusPending,
		ChunkNum:        numChunks,
		ChunkSize:       chunkSize,
		Chunk:           make([]models.Chunk, numChunks),
		TotalDownloaded: 0,
	}

	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 {
			// Clean all resources
			outputFile.Close()
			h.cleanEventSource(task.ID)

			if !errors.Is(err, context.Canceled) && !errors.Is(err, os.ErrClosed) {
				carrot.Error("download chunk failed", "key:", es.key, "url:", task.Url, "err:", err)
				es.Emit(DownloadProgress{ID: task.ID, Name: task.Name, Status: models.TaskStatusFailed})
			}
			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))

	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,
		})
	}

	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)
	}

	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)
}

暂停下载实现步骤：

  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) 
    	maxDownloadSpeedInBytes := maxDownloadSpeed * 1000 * 1000
	limiter := rate.NewLimiter(rate.Limit(maxDownloadSpeedInBytes), int(maxDownloadSpeedInBytes))
  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
关注
  • 12
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
IDM下载管理工具的详细介绍
技术探秘者的博客
04-17 1476
IDM是由美国公司Tonec Inc.开发的一款下载管理器，它能够提供强大的下载功能，帮助用户更加高效地管理和加速下载任务。IDM具有以下几个主要特点： 下载加速： IDM可以通过多线程下载和分段下载等技术，显著提高文件下载速度，让用户更快地获取所需文件。 任务管理： IDM提供了便捷的任务管理功能，用户可以轻松添加、暂停、恢复和删除下载任务，灵活控制下载进程。 浏览器集成： IDM能够与主流的网络浏览器（如Chrome、Firefox、Edge等）完美集成，方便用户直接从浏览器中发起下载。
linux下aria2的安装与配置
nowtd的博客
05-08 4870
前言: 众所周知，在linux系统下是不可以直接执行exe的文件的，理所当然地我们平时用的迅雷与百度网盘等这些下载工具自然就无法使用了，所以在下载一些文件的时候可能有些麻烦。当然如果是有直链的话，直接用wget来下载就可以了，但是要下载bt文件或磁力文件时就无处下手了。 在ubuntu系统下自带一个bt下载工具(transmission)，可以在命令行输入打开: sudo transmissi...
用JAVA实现一个多线程HTTP下载服务器，支持暂停、断点续传、重新下载、限速下载、删除、多任务并行下载等功能
m0_74073836的博客
04-29 1934
一个支持HTTP下载的网站，支持暂停、重新下载、删除、限速和并行多任务下载。包含完整代码和相关注释。
超大文件上传下载以及秒传、提速和限速方案完整（包含前后端）
weixin_52041354的博客
11-14 1576
文件上传是一个老生常谈的话题了，在文件相对比较小的情况下，可以直接把文件转化为字节流上传到服务器，但在文件比较大的情况下，用普通的方式进行上传，这可不是一个好的办法，毕竟很少有人会忍受，当文件上传到一半中断后，继续上传却只能重头开始上传，这种让人不爽的体验。断点续传是在下载或上传时，将下载或上传任务（一个文件或一个压缩包）人为的划分为几个部分，每一个部分采用一个线程进行上传或下载，如果碰到网络故障，可以从已经上传或下载的部分开始继续上传或者下载未完成的部分，而没有必要从头开始上传或者下载。
IDM百度网盘不限速下载，油猴插件完美解决下载
weixin_55412152的博客
12-25 2333
百度网盘相信大家都不陌生，可以说百度网盘是当今最流行的网盘之一！我们很多在网上找到的资料大部分都是利用百度网盘分享链接+提取码的方式进行分享的！然后根据我们当时的所需，进行资源的下载以完成信息传输的这么一个目。
axel多线程下载
weixin_34126215的博客
03-28 82
Axel 通过打开多个 HTTP/FTP 连接来将一个文件进行分段下载，从而达到加速下载的目的。对于下载大文件，该工具将特别有用。支持断点续传。一般使用：axel url（下载文件地址）。限速使用：加上 -s 参数，如 -s 10240，即每秒下载的字节数，这里是 10 Kb。限制连接数：加上 -n 参数，如 -n 5，即打开 5 个连接。基本的用法如下：axel [选项] ...
服务器文档下载zip格式 SQL Server SQL分页查询 C#过滤html标签 EF 延时加载与死锁 在JS方法中返回多个值的三种方法（转载） IEnumerable,ICollect...
weixin_33892359的博客
06-24 372
服务器文档下载zip格式        刚好这次项目中遇到了这个东西，就来弄一下，挺简单的，但是前台调用的时候弄错了，浪费了大半天的时间，本人也是菜鸟一枚。开始吧。（MVC的）     @using Rattan.Core.Utility;@{ string ButtonScript = string.Empty;}@if (Rattan.Basic.Globals.GetIsAuth(Vie...
下载速率提升40% ，《斗罗大陆：魂师对决》是如何做到的?
HarmonyOS SDK闭源开放能力技术团队
10-14 9079
用户在使用移动应用的过程中，文件传输的场景有很多，如文件发送、云盘备份、视频缓存、应用下载和更新等。在移动游戏行业，优质的3D建模，丰富的场景都成为吸引玩家的重要因素，随着游戏品质的不断提升，游戏包也逐步变得越来越大，由于还有很多玩家不具备长时间大流量的下载条件，首包大小就会影响到游戏的拉新效果，每次版本更新也不可避免带来用户流失。 如何提升游戏资源包的下载体验，成了众多开发者关注的问题，业界较为通用的做法是游戏分包下载，用户首次下载游戏只包含游戏主体部分和新手地图资源，在玩家逐步成长的过程中不断更新地图、
HTTP性能极限优化
陶辉：聚焦分布式系统的程序员
01-13 8497
无论你在做前端、后端还是运维，HTTP都是不得不打交道的网络协议。它是最常用的应用层协议，对它的优化，既能通过降低时延带来更好的体验性，也能通过降低资源消耗带来更高的并发性。 可是，学习HTTP不久的同学，很难全面说出HTTP的所有优化点。这既有可能是你没好好准备过大厂的面试:-)，也有可能你没有加入一个快速发展的项目，当产品的用户量不断翻番时，需求会倒逼着你优化HTTP协议。 这篇文章是根据...
百度云下载的一些骚操作
tsvico的博客
06-11 8620
转载请注明出处，原文地址http://blog.peoplevip.cn/2018/06/%E7%99%BE%E5%BA%A6%E4%BA%91%E4%B8%8B%E8%BD%BD%E7%9A%84%E4%B8%80%E4%BA%9B%E9%AA%9A%E6%93%8D%E4%BD%9C.html 更多原创内容 请访问我的博客 如果图片显示失败请访问原文 前言 百度云盘曾几何时凭着...
QT多线程下载器
01-26
QT多线程下载器是一种利用QT框架开发的高效文件下载工具，它采用了多线程技术来提高文件下载速度，尤其适合处理大文件或网络环境不稳定的情况。QT是Qt Company开发的一个开源C++图形用户界面应用程序开发框架，广泛...
提供一个异步下载的类，支持批量下载。
07-03
- 多线程或多进程：在支持多线程或多进程的系统中，可以创建多个下载任务并发执行。 - 异步I/O库：如Python的aiohttp、Node.js的axios或Java的AsyncHttpClient，这些库都提供了异步HTTP请求的功能。 5. 监控和...
多点续传下载
03-05
从提供的压缩包文件名称“多线程下载器_ab2c6c26__upload_app_530514490db17427a72.apk”来看，我们可以推测这是一个多线程下载工具的安卓应用版本。这个应用很可能是为了帮助用户更高效地下载大文件，如高清视频、...
Android平台多线程文件下载器
07-21
文件分割下载，每个线程处理一部分，通过Range头指定起始位置，实现断点续传。 同步线程进度，更新UI需确保线程安全，使用Handler或HandlerThread。同时，处理网络故障、存储空间问题，提供下载控制功能。 高级特性...
基于QT多任务下载功能管理.zip
04-26
总而言之，"基于QT多任务下载功能管理.zip"项目涉及了QT库的多个核心组件，包括但不限于信号与槽机制、多线程、网络编程、队列管理和文件I/O，这些都是构建一个高效、易用的多任务下载管理器所必需的关键技术。...
goweb框架-gin
最新发布
z3551906947的博客
08-20 733
基数树（Radix Tree），又称前缀树（Trie），是一种用于快速检索的数据结构，特别适用于处理字符串的前缀匹配问题。节点：基数树由多个节点组成，每个节点代表字符串中的一个字符。根节点：代表空字符串，是树的起点。路径：从根节点到某一节点的序列，代表一个字符串的前缀。叶子节点：代表一个完整的字符串或模式。压缩：如果一个节点的所有子节点都只有一个子节点，该节点可以被压缩，从而节省空间。基数树的工作原理基于字符串的公共前缀，通过共享这些前缀来减少存储空间。
基于django的双选宠物托管服务平台/python宠物托管系统
weixin_47958760的博客
08-18 1027
伴随着社会以及科学技术的发展，互联网已经渗透在人们的身边，网络慢慢的变成了人们的生活必不可少的一部分，紧接着网络飞速的发展，系统管理这一名词已不陌生，越来越多的双选宠物托管服务等机构都会定制一款属于自己个性化的管理系统。 本毕业设计的内容是设计并且实现一个基于Django框架的双选宠物托管服务平台。采用MYSQL为数据库开发平台，Python语言，网络信息服务作为应用服务器。双选宠物托管服务平台的功能已基本实现，主要宠物托管、托管预约、托管订单、服务评价、优惠活动、联系我们等。
djnago之序列化器的用法
点点滴滴
08-17 519
author = AuthorSerializer() # 嵌套序列化器modelreturn f"fields 属性中字段的顺序决定了序列化的顺序。
django之BaseSerializer
点点滴滴
08-18 779
首先定义一个简单的Book接下来定义一个，并在其中使用"""将模型实例转换为原生 Python 数据类型"""return {"""将原生数据转换为验证后的数据"""return {"""对输入数据进行验证"""= 13:"""使用验证后的数据创建并返回一个新实例""""""使用验证后的数据更新并返回一个现有实例"""首先定义接下来定义，并在其中使用pass。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值