当前位置：首页 > 文章列表 > Golang > Go教程 > Golang文件分块传输实现教程

Golang文件分块传输实现教程

2025-11-23 15:45:39 0浏览收藏

本篇文章向大家介绍《Golang文件分块传输实现方法》，主要包括，具有一定的参考价值，需要的朋友可以参考一下。

文件分块读取与写入：使用os.Open和固定大小（如5MB）分块，通过io.ReadAtLeast或bufio.Reader逐段读取，降低内存占用并提升传输效率。

Golang如何实现文件分块传输_Golang文件分块传输实践详解

在实际开发中，大文件传输常会遇到内存占用高、网络不稳定导致传输失败等问题。Golang 通过其高效的并发机制和 I/O 操作能力，非常适合实现文件的分块传输。本文将详细介绍如何使用 Golang 实现文件分块上传与下载，涵盖分块读取、并发上传、断点续传等核心逻辑。

1. 文件分块读取与写入

分块传输的第一步是将大文件切分为多个固定大小的数据块。通常每块设置为 1MB 到 5MB，既能减少单次内存压力，又能保证传输效率。

使用 os.Open 打开文件，并通过 io.ReadAtLeast 或 bufio.Reader 分段读取：

const chunkSize = 5 func readInChunks(filePath string) (<-chan []byte, error) {
file, err := os.Open(filePath)
if err != nil {
return nil, err
}ch := make(chan []byte, 10)
go func() {
    defer file.Close()
    defer close(ch)

    buffer := make([]byte, chunkSize)
    for {
        n, err := file.Read(buffer)
        if n > 0 {
            chunk := make([]byte, n)
            copy(chunk, buffer[:n])
            ch <- chunk
        }
        if err == io.EOF {
            break
        }
        if err != nil && err != io.EOF {
            panic(err)
        }
    }
}()
return ch, nil
}

上述代码返回一个只读 channel，每个元素是一个数据块，便于后续异步处理。

2. 基于 HTTP 的分块上传

使用标准库 net/http 实现分块上传，客户端逐个发送块，服务端按序接收并拼接。

关键点包括：添加分块索引、总块数、文件名等元信息，建议使用 multipart/form-data 格式：

func uploadChunk(chunk []byte, index, total int, filename string, serverURL string) error {
    var buf bytes.Buffer
    writer := multipart.NewWriter(&buf)
// 写入元信息
writer.WriteField("index", strconv.Itoa(index))
writer.WriteField("total", strconv.Itoa(total))
writer.WriteField("filename", filename)

// 写入文件块
part, _ := writer.CreateFormFile("chunk", "chunk")
part.Write(chunk)
writer.Close()

req, _ := http.NewRequest("POST", serverURL, &buf)
req.Header.Set("Content-Type", writer.FormDataContentType())

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

调用时结合分块 channel 并发上传（注意控制并发数，避免资源耗尽）：

chunks, _ := readInChunks("largefile.zip")
var wg sync.WaitGroup
semaphore := make(chan struct{}, 5) // 控制最多 5 个并发
for i := 0; ; i++ {
chunk, ok := <-chunks
if !ok {
break
}
wg.Add(1)
go func(idx int, data []byte) {
defer wg.Done()
semaphore <- struct{}{}
uploadChunk(data, idx, totalChunks, "largefile.zip", "http://server/upload")
<-semaphore
}(i, chunk)
}
wg.Wait()

3. 服务端接收与合并文件

服务端需解析 multipart 数据，提取块数据并写入临时目录，最后根据总块数判断是否完成合并。

示例处理函数：

var tempDir = "./uploads/tmp/"
var fileTracker = make(map[string][]bool) // 记录各文件块接收状态
func handleUpload(w http.ResponseWriter, r *http.Request) {
r.ParseMultipartForm(10 << 20) // 最大 10MB 表单
indexStr := r.FormValue("index")
totalStr := r.FormValue("total")
filename := r.FormValue("filename")

index, _ := strconv.Atoi(indexStr)
total, _ := strconv.Atoi(totalStr)

file, _, _ := r.FormFile("chunk")
defer file.Close()

// 创建临时文件路径
tempPath := filepath.Join(tempDir, filename+"."+indexStr)
dst, _ := os.Create(tempPath)
io.Copy(dst, file)
dst.Close()

// 更新接收状态
key := filename + ".parts"
if _, exists := fileTracker[key]; !exists {
    fileTracker[key] = make([]bool, total)
}
fileTracker[key][index] = true

// 检查是否全部接收完毕
complete := true
for _, received := range fileTracker[key] {
    if !received {
        complete = false
        break
    }
}

if complete {
    mergeFile(filename, total)
    delete(fileTracker, key)
}

w.WriteHeader(http.StatusOK)
}

合并函数示例：

func mergeFile(filename string, total int) {
    finalPath := filepath.Join(tempDir, filename)
    outFile, _ := os.Create(finalPath)
    defer outFile.Close()
for i := 0; i < total; i++ {
    chunkPath := filepath.Join(tempDir, filename+"."+strconv.Itoa(i))
    chunkData, _ := os.ReadFile(chunkPath)
    outFile.Write(chunkData)
    os.Remove(chunkPath) // 合并后删除临时块
}
}