基于 Golang 实现大文件断点续传

运达 — Wed, 12 Nov 2025 07:56:49 +0000

最近工作中遇到一个实际问题：在将 BPF 数据转换为 Entier 格式时，生成的文件体积异常庞大，部分文件甚至达到 10G 级别。这类大文件上传至服务器时，不仅会占用大量带宽，还需耗费极长时间，一旦中途因网络波动或设备故障中断，就得重新上传，效率极低。
为此，我基于 Golang 开发了一套网页版断点续传工具 —— 通过前端页面交互配合后端逻辑，实现了文件分片传输与断点记录功能。即便夜间上传过程中出现中断，次日也能从断点处继续传输，极大提升了大文件上传的便捷性与稳定性。代码本人亲测（我设置了最大可上传单文件大小为20G），可以直接用。废话不多说了，咱们就言归正传，你需要创建main.go和index.html两个文件。
代码如下：main.go

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"strconv"
	"sync"
	"time"
)

// 文件上传状态记录
type UploadStatus struct {
	TotalChunks int       `json:"total_chunks"`
	Uploaded    []bool    `json:"uploaded"`
	Filename    string    `json:"filename"`
	UUID        string    `json:"uuid"`
	Path        string    `json:"path"`
	Completed   bool      `json:"completed"`
	Size        int64     `json:"size"`
	UploadedAt  time.Time `json:"uploaded_at"`
}

// 全局上传状态记录
var uploadsMutex sync.Mutex
var uploads = make(map[string]*UploadStatus)

func main() {
	// 创建上传目录
	os.MkdirAll("/home/datawork/uploads", 0755)
	os.MkdirAll("/home/datawork/chunks", 0755)

	// 注册路由
	http.HandleFunc("/api/upload", handleUpload)
	http.HandleFunc("/api/status", handleStatus)
	http.HandleFunc("/api/merge", handleMerge)
	http.HandleFunc("/", serveIndex)

	// 启动服务器
	fmt.Println("服务器启动在 http://10.25.77.4:8999")
	log.Fatal(http.ListenAndServe(":8999", nil))
}

// 处理文件块上传
func handleUpload(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "方法不允许", http.StatusMethodNotAllowed)
		return
	}

	// 解析表单数据
	err := r.ParseMultipartForm(32 << 20) // 32MB 缓冲区
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	// 获取文件信息
	file, _, err := r.FormFile("file")
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	defer file.Close()

	// 获取上传参数
	uuid := r.FormValue("uuid")
	chunkIndex := r.FormValue("chunkIndex")
	totalChunks := r.FormValue("totalChunks")
	filename := r.FormValue("filename")
	fileSize := r.FormValue("fileSize")

	// 验证参数
	if uuid == "" || chunkIndex == "" || totalChunks == "" || filename == "" || fileSize == "" {
		http.Error(w, "缺少必要参数", http.StatusBadRequest)
		return
	}

	// 转换参数类型
	index, err := strconv.Atoi(chunkIndex)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	total, err := strconv.Atoi(totalChunks)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	size, err := strconv.ParseInt(fileSize, 10, 64)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	// 创建文件块目录
	chunkDir := filepath.Join("/home/datawork/chunks", uuid)
	os.MkdirAll(chunkDir, 0755)

	// 保存文件块
	chunkPath := filepath.Join(chunkDir, fmt.Sprintf("%d", index))
	out, err := os.Create(chunkPath)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	defer out.Close()

	_, err = io.Copy(out, file)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// 更新上传状态
	uploadsMutex.Lock()
	defer uploadsMutex.Unlock()

	// 初始化上传状态（如果不存在）
	if _, exists := uploads[uuid]; !exists {
		uploads[uuid] = &UploadStatus{
			TotalChunks: total,
			Uploaded:    make([]bool, total),
			Filename:    filename,
			UUID:        uuid,
			Path:        filepath.Join("/home/datawork/uploads", filename),
			Completed:   false,
			Size:        size,
			UploadedAt:  time.Now(),
		}
	}

	// 标记当前块已上传
	if index < len(uploads[uuid].Uploaded) {
		uploads[uuid].Uploaded[index] = true
	}

	// 检查是否所有块都已上传
	allUploaded := true
	for _, uploaded := range uploads[uuid].Uploaded {
		if !uploaded {
			allUploaded = false
			break
		}
	}

	if allUploaded {
		uploads[uuid].Completed = true
	}

	// 返回当前上传状态
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(uploads[uuid])
}

// 获取上传状态
func handleStatus(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		http.Error(w, "方法不允许", http.StatusMethodNotAllowed)
		return
	}

	uuid := r.URL.Query().Get("uuid")
	if uuid == "" {
		http.Error(w, "缺少uuid参数", http.StatusBadRequest)
		return
	}

	uploadsMutex.Lock()
	defer uploadsMutex.Unlock()

	if status, exists := uploads[uuid]; exists {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(status)
	} else {
		http.Error(w, "找不到上传记录", http.StatusNotFound)
	}
}

// 合并文件块
func handleMerge(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "方法不允许", http.StatusMethodNotAllowed)
		return
	}

	uuid := r.FormValue("uuid")
	if uuid == "" {
		http.Error(w, "缺少uuid参数", http.StatusBadRequest)
		return
	}

	uploadsMutex.Lock()
	defer uploadsMutex.Unlock()

	if status, exists := uploads[uuid]; exists {
		if !status.Completed {
			http.Error(w, "文件尚未上传完成", http.StatusBadRequest)
			return
		}

		// 创建目标文件
		out, err := os.Create(status.Path)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		defer out.Close()

		// 按顺序合并文件块
		chunkDir := filepath.Join("/home/datawork/chunks", uuid)
		for i := 0; i < status.TotalChunks; i++ {
			chunkPath := filepath.Join(chunkDir, fmt.Sprintf("%d", i))
			chunk, err := os.Open(chunkPath)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			_, err = io.Copy(out, chunk)
			chunk.Close()
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}

			// 删除已合并的块
			os.Remove(chunkPath)
		}

		// 删除临时目录
		os.RemoveAll(chunkDir)

		// 返回成功信息
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]string{
			"status": "success",
			"path":   status.Path,
		})
	} else {
		http.Error(w, "找不到上传记录", http.StatusNotFound)
	}
}

// 提供前端页面
func serveIndex(w http.ResponseWriter, r *http.Request) {
	http.ServeFile(w, r, "./index.html")
}

网页代码如下：index.html




    
    
    大文件上传与断点续传
    
    
    
    
    
    


    
    
        
            
                 大文件上传系统
            
            
                
                     首页
                     帮助
                
            
        
    

    
    
        
            
                上传大文件
                支持超大文件上传和断点续传，最大支持 20GB 文件
            

            
            
                
                拖放文件到此处上传
                或点击选择文件
                
                     选择文件
                
                
            

            
            
                
                    文件名
                    0 MB
                
                
                
                    
                
                
                
                    0%
                    0 KB/s
                    计算中...
                
                
                
                    
                    
                    
                
            

            
            
                
                     上传历史
                
                
                    
                
            
        
    

    
    
        
            © 2023 大文件上传系统 | 支持断点续传和超大文件上传
            
                系统支持最大 20GB 文件上传，适用于各种大文件传输场景

到此就结束了，剩下的就是你放飞自我的去上传吧，还可以看上传历史呦！
效果图：
转载请注明转自:运达's blog 原文地址：https://www.yunda51.com/?p=2027

MacOs下fabric2.4搭建部署

运达 — Thu, 27 Oct 2022 02:53:37 +0000

一、环境准备

安装git brew install git
安装vim brew install vim
安装curl brew install curl
安装wget brew install wget
安装go1.14 以及以上版本
安装docker 17.06.2-ce 以及以上版本
安装docker-compose 1.14.0 以及以上版本
git 拉下 fabric 项目
下载docker image镜像

具体操作：
1.go安装
下载压缩包无法翻墙可以去这个网站：https://studygolang.com/dl
下载好之后依次执行以下命令：

tar -xzf go1. 17.7 darwin -amd64.tar.gz // 解压你下载的go包
sudo mv go /usr/local    	//移动
cd /Users/liuyunda		//进入自己账户目录下
mkdir -p workspace/go/	    //建立go工作空间
cd /Users/ liuyunda /workspace/go
mkdir src bin pkg			//建立go工作空间
cd src				//存放源码的地方mkdir github.com/hyperledger 	//一定要这样建立目录，然后在这目录下拉fabric源码，不然报错

路径配置：
执行 vim ~/.bash_profile ,然后把下面路径配置到其中,具体路径要按照你电脑的来，我这里是我自己的路径
编辑完成后记得 source ~/.bash_profile

到此GO语言部分准备完毕

二、docker安装：
mac用户直接 brew install docker 即可，或者去docker官网下载安装
mac 安装docker就自动安装了docker-compose
然后 docker version 、docker-compose version 看版本
像这样就没问题：

三、docker镜像下载：

cd /users/apple/privatespace/go/src/github.com/hyperledger  //进入源码存放目录
git clone https://github.com/hyperledger/fabric.git  		//下载fabric源码
cd fabric/scripts		//进入这个目录，里面有一个 bootstrap.sh 文件
sudo ./bootstrap.sh 	//执行这个文件 会下载fabric-samples 和 镜像

镜像下载有这些如图：

上面的工作完成后，当前目录多了一个fabric-samples文件夹，我们进去该目录下的test-network目录测试下搭建的环境是否成功：

cd fabric-samples/
cd test-network/

由于国内被墙，修改go代理

go env -w GOPROXY=https://goproxy.cn,direct

然后启动我们的测试网络：

sudo ./network.sh up

记得加sudo保平安哦。开始了一堆代码之后出现（如下图所示，表示启动成功）:

同样道理：

sudo ./network.sh down  // 关闭

如果出现权限不够的情况

直接 cd /users/liuyunda /go/src/github.com/
然后 sudo chmod -R 777 hyperledger

到此基本没问题了

接下来开始跟着官网文档走
一、使用fabric test network
1.启动:
首先进入对应目录：cd fabric-samples/test-network
然后启动： ./network.sh up
出现这个代表成功

接着可以看看docker容器:docker ps -a
应该有刚刚启动出来的order 和peer

2、创建通道:
./network.sh createChannel 默认名mychannel
也可以自定义名字创建： ./network.sh createChannel -c channel2 自定义名字channel2
3、测试:
首先执行：./network.sh deployCC
可能会出现如下图所示的错误，别着急：

我们继续执行如下命令：

sudo ./network.sh deployCC -ccn basic -ccp ../asset-transfer-basic/chaincode-go -ccl go

这样就搞定了，如下图所示，表示执行成功。

运达's blog » Go

基于 Golang 实现大文件断点续传

上传大文件

拖放文件到此处上传

文件名

上传历史

MacOs下fabric2.4搭建部署