golang 如何写文件分块上传逻辑

要实现 Golang 的文件分块上传逻辑，可以按照以下步骤进行：

1. 客户端将上传文件分成若干块，每块的大小可以根据实际情况进行设置。同时，客户端需要记录文件的总大小和每个块的编号，用于服务端进行合并。

2. 客户端通过 HTTP 请求将每个块上传到服务端，每个块都需要指定块的编号和文件的总大小。服务端需要根据块的编号进行排序，然后将所有块的内容按顺序合并成完整的文件。

3. 服务端可以使用 Golang 的 multipart 包来处理分块上传的请求，multipart 包可以自动解析 HTTP 请求中的块编号、总大小和内容，并将内容写入到文件中。

下面是一个简单的分块上传示例代码：

const (
    maxChunkSize = 10 * 1024 * 1024 // 每个块的大小为 10MB
)

func uploadHandler(w http.ResponseWriter, r *http.Request) {
    // 解析 HTTP 请求
    err := r.ParseMultipartForm(32 << 20) // 限制上传文件大小为 32MB
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    // 获取文件总大小和块编号
    totalSize, _ := strconv.Atoi(r.FormValue("totalSize"))
    chunkIndex, _ := strconv.Atoi(r.FormValue("chunkIndex"))

    // 获取当前块的内容
    file, _, err := r.FormFile("file")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer file.Close()

    // 读取块内容
    chunkSize := maxChunkSize
    if chunkIndex == totalChunks-1 {
        chunkSize = totalSize - (totalChunks-1)*maxChunkSize
    }
    chunk := make([]byte, chunkSize)
    _, err = file.Read(chunk)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    // 将块内容写入到文件中
    f, err := os.OpenFile("upload/" + r.FormValue("fileName"), os.O_WRONLY|os.O_CREATE, 0666)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer f.Close()

    _, err = f.WriteAt(chunk, int64(chunkIndex*maxChunkSize))
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    // 返回上传成功的响应
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("Upload Success"))
}

在客户端，可以使用类似下面的代码来实现文件分块上传：

func uploadFile(filepath string) error {
    // 打开文件并计算块数量
    f, err := os.Open(filepath)
    if err != nil {
        return err
    }
    defer f.Close()

    fileInfo, err := f.Stat()
    if err != nil {
        return err
    }

    totalSize := fileInfo.Size()
    totalChunks := int(math.Ceil(float64(totalSize) / float64(maxChunkSize)))

    // 分块上传文件
    for i := 0; i < totalChunks; i++ {
        chunkSize := maxChunkSize
        if i == totalChunks-1 {
            chunkSize = int(totalSize) - i*maxChunkSize
        }

        // 创建 HTTP 请求并上传块内容
        req, err := http.NewRequest("POST", "http://localhost:8080/upload", nil)
        if err != nil {
            return err
        }

        formData := url.Values{}
        formData.Set("fileName", filepath)
        formData.Set("totalSize", strconv.FormatInt(totalSize, 10))
        formData.Set("chunkIndex", strconv.Itoa(i))

        body := &bytes.Buffer{}
        writer := multipart.NewWriter(body)

        part, err := writer.CreateFormFile("file", filepath)
        if err != nil {
            return err
        }

        io.CopyN(part, f, int64(chunkSize))

        writer.Close()

        req.Header.Set("Content-Type", writer.FormDataContentType())
        req.Body = ioutil.NopCloser(body)

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

        if resp.StatusCode != http.StatusOK {
            return fmt.Errorf("Upload Failed: %s", resp.Status)
        }
    }

    return nil
}

这样就可以实现 Golang 的文件分块上传逻辑了。