go http multipart/form-data文件上传，不加载文件到内存

go chunked multipart文件上传。

在日常开发中发现，如果要上传文件，在构造form表单的时候要将文件内容全部读取到内存中，所有研究了一下multipart/form-data,看看有没有什么方法能够使用流的方式上传，发现可以使用chunked流模式来上传。

下面是一个示例需要将数据全部读取到内存中。

上传文件示例

package main

import (
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func main() {
    // 打开要上传的文件
    file, err := os.Open("example.txt")
    if err != nil {
       fmt.Println("Error opening file:", err)
       return
    }
    defer file.Close()

    // 创建一个缓冲区，用于存储multipart/form-data
    var requestBody bytes.Buffer
    writer := multipart.NewWriter(&requestBody)

    // 创建一个multipart文件字段
    part, err := writer.CreateFormFile("file", "example.txt")
    if err != nil {
       fmt.Println("Error creating form file:", err)
       return
    }

    // 将文件内容复制到part中
    _, err = io.Copy(part, file)
    if err != nil {
       fmt.Println("Error copying file content:", err)
       return
    }

    // 创建一个额外的文本字段
    err = writer.WriteField("description", "This is an example file upload.")
    if err != nil {
       fmt.Println("Error writing form field:", err)
       return
    }

    // 关闭multipart writer
    err = writer.Close()
    if err != nil {
       fmt.Println("Error closing writer:", err)
       return
    }

    // 创建HTTP请求
    req, err := http.NewRequest("POST", "http://www.example.com/upload", &requestBody)
    if err != nil {
       fmt.Println("Error creating request:", err)
       return
    }

    // 设置Content-Type头
    req.Header.Set("Content-Type", writer.FormDataContentType())

    // 发送请求
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
       fmt.Println("Error sending request:", err)
       return
    }
    defer resp.Body.Close()

    // 读取响应
    respBody, err := io.ReadAll(resp.Body)
    if err != nil {
       fmt.Println("Error reading response:", err)
       return
    }

    fmt.Println("Response:", string(respBody))
}

###

multipart/form-data 协议的详细介绍

multipart/form-data 是一种 MIME 类型，用于在 HTTP 请求中上传文件和发送表单数据。它允许在单个请求中包含多个部分，每个部分可以包含不同类型的数据，如文本字段和文件。

协议概述

• Content-Type：请求头中会包含 Content-Type: multipart/form-data; boundary=—-WebKitFormBoundary7MA4YWxkTrZu0gW，其中 boundary 是一个唯一的字符串，用于分隔每个部分。
• 每个部分的格式：每个部分包含其自己的头部和内容，头部描述该部分的数据类型、名称等信息。

请求结构

一个典型的 multipart/form-data 请求由以下几部分组成：

1. 请求行：指定HTTP方法和路径。
2. 头部字段：包括 Content-Type 和 boundary。
3. 多个数据部分：

• • 每个部分由分隔符 boundary 开头。
  • 每个部分有自己的头部和内容。

1. 结束标志：使用终止分隔符 –boundary– 表示数据传输结束。

示例

假设我们上传一个名为 example.txt 的文件，并包含一个名为 description 的文本字段。请求结构如下：

http
Copy code
POST /upload HTTP/1.1
Host: www.example.com
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW

------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="description"

This is an example file upload.
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="file"; filename="example.txt"
Content-Type: text/plain

<file content here>
------WebKitFormBoundary7MA4YWxkTrZu0gW--

修改后的代码

思路就是，按照multipart/form-data 协议构建数据，查看go的相关源码会发现，除了strings.Reader bytes.Reader这几种已知长度的reader，会被指定长度，其他不知道长度的reader，go http客户端都是使用chunked传递的。

文件放到字段的后面，自定义read方法，当读取到的时候，使用我们自定义的reader即可。具体代码如下github地址

github.com/luxun9527/go-lib/tree/m... 如果对您有帮助，帮我点个star就是对我的鼓励。

package stream

import (
    "bytes"
    "errors"
    "fmt"
    "io"
    "mime/multipart"
)

/*
实现功能
1. 创建一个multipart/form-data格式的流，在读取文件的时候不将整个文件读入内存。
使用chunkded模式传输数据
*/
type MultipartReaderWriter struct {
    buf            *bytes.Buffer
    closeData      *bytes.Buffer
    r              io.Reader
    hasStartedFile bool
    boundary       string
    contentType    string
    writer         *multipart.Writer
    FileFiledList  []*FileField
}

func (fr *MultipartReaderWriter) Read(p []byte) (int, error) {
    // 如果文件读取还未开始，先从 buffer 中读取数据
    if !fr.hasStartedFile {
       n, err := fr.buf.Read(p)
       if n > 0 || err != io.EOF {
          return n, err
       }

       fr.hasStartedFile = true
    }
    n, err := fr.r.Read(p)
    if err != nil {
       //读取文件数据后，将close数据读取出来
       if errors.Is(err, io.EOF) {
          return fr.closeData.Read(p)
       }
       return 0, err
    }
    return n, err
}

func (fr *MultipartReaderWriter) WriteFiled(key, value string) error {
    return fr.writer.WriteField(key, value)
}

func (fr *MultipartReaderWriter) WriteFileField(filedName, fileFiledName string, data io.Reader) error {
    if data == nil {
       return errors.New("data is nil")
    }

    field, err := NewFileField(data, filedName, fileFiledName, fr.boundary, fr.buf.Len() > 0)
    if err != nil {
       return err
    }
    fr.FileFiledList = append(fr.FileFiledList, field)
    return err
}

func (fr *MultipartReaderWriter) Close() error {
    fields := make([]io.Reader, 0, len(fr.FileFiledList))
    for _, v := range fr.FileFiledList {
       fields = append(fields, v)
    }
    fr.r = io.MultiReader(fields...)

    return nil
}

func NewMultipartReaderWriter() (*MultipartReaderWriter, error) {
    buffer := bytes.NewBuffer(make([]byte, 0, 500))
    closeData := bytes.NewBuffer(make([]byte, 0, 500))

    writer := multipart.NewWriter(buffer)

    if _, err := fmt.Fprintf(closeData, "\r\n--%s--\r\n", writer.Boundary()); err != nil {
       return nil, err
    }
    multipartReader := &MultipartReaderWriter{
       buf:         buffer,
       closeData:   closeData,
       contentType: writer.FormDataContentType(),
       boundary:    writer.Boundary(),
       writer:      writer,
    }

    return multipartReader, nil
}

type FileField struct {
    r              io.Reader
    buf            *bytes.Buffer
    hasStartedFile bool
    hasPrev        bool
}

func NewFileField(r io.Reader, fileName, fieldName, boundary string, hasPrev bool) (*FileField, error) {

    buffer := bytes.NewBuffer(make([]byte, 0, 500))
    if hasPrev {
       if _, err := fmt.Fprintf(buffer, "\r\n"); err != nil {
          return nil, err
       }
    }
    writer := multipart.NewWriter(buffer)
    if err := writer.SetBoundary(boundary); err != nil {
       return nil, err
    }
    if _, err := writer.CreateFormFile(fieldName, fileName); err != nil {
       return nil, err
    }
    return &FileField{
       r:              r,
       buf:            buffer,
       hasStartedFile: false,
    }, nil
}

func (fr *FileField) Read(p []byte) (int, error) {
    // 如果文件读取还未开始，先从 buffer 中读取数据
    if !fr.hasStartedFile {
       n, err := fr.buf.Read(p)
       if n > 0 || err != io.EOF {
          return n, err
       }

       fr.hasStartedFile = true
    }

    return fr.r.Read(p)
}

package stream

import (
    "io"
    "log"
    "os"

    "net/http"
    "testing"
)

func TestMultiPart1(t *testing.T) {
    rd, err := NewMultipartReaderWriter()
    if err := rd.WriteFiled("key", "value"); err != nil {
        log.Panicf("WriteFiled failed err %v", err)
    }

    fs1, err := os.Open("example.txt")
    if err != nil {
        log.Panicf("err = %v", err)
    }
    defer fs1.Close()
    if err := rd.WriteFileField("example.txt", "file1", fs1); err != nil {
        log.Panicf("WriteFileField1 failed err %v", err)
    }
    fs2, err := os.Open("example.txt")
    if err != nil {
        log.Panicf("err = %v", err)
    }
    defer fs2.Close()

    if err := rd.WriteFileField("example.txt", "file2", fs2); err != nil {
        log.Panicf("WriteFileField2 failed err %v", err)

    }
    _ = rd.Close()
    data, err := io.ReadAll(rd)
    if err != nil {
        log.Panicf("ReadAll failed err %v", err)
    }
    log.Println(data)
}

func TestMultiPart2(t *testing.T) {
    rd, err := NewMultipartReaderWriter()
    if err := rd.WriteFiled("key", "value"); err != nil {
        log.Panicf("WriteFiled failed err %v", err)
    }

    fs1, err := os.Open("example.txt")
    if err != nil {
        log.Panicf("err = %v", err)
    }
    defer fs1.Close()
    if err := rd.WriteFileField("example.txt", "file1", fs1); err != nil {
        log.Panicf("WriteFileField1 failed err %v", err)
    }
    fs2, err := os.Open("example.txt")
    if err != nil {
        log.Panicf("err = %v", err)
    }
    defer fs2.Close()

    if err := rd.WriteFileField("example.txt", "file2", fs2); err != nil {
        log.Panicf("WriteFileField2 failed err %v", err)

    }
    _ = rd.Close()

    url := "http://localhost:10011/" // 服务器URL

    req, err := http.NewRequest("POST", url, rd)
    if err != nil {
        log.Panicf("new request error %v", err)
    }
    req.Header.Set("Content-Type", rd.contentType)
    req.TransferEncoding = []string{"chunked"}

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        log.Printf("do requeset  error %v", err)
    }
    d, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Printf("read error %v", err)
    }
    log.Println(string(d))
}
func TestMultServer(t *testing.T) {
    if err := http.ListenAndServe(":10011", http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
        // 获取文件
        file1, handler, err := request.FormFile("file1")
        if err != nil {
            http.Error(writer, "Error retrieving file", http.StatusInternalServerError)
            return
        }

        defer file1.Close()
        data, _ := io.ReadAll(file1)
        log.Printf("file size: %v content %v filename %v size %v", len(data), string(data), handler.Filename, handler.Size)
        // 获取文件
        file2, handler, err := request.FormFile("file2")
        if err != nil {
            http.Error(writer, "Error retrieving file", http.StatusInternalServerError)
            return
        }
        defer file2.Close()
        data, _ = io.ReadAll(file2)
        log.Printf("file size: %v content %v filename %v size %v", len(data), string(data), handler.Filename, handler.Size)
        value := request.FormValue("key")
        log.Printf("key: %v", value)

        writer.Write([]byte("hello world"))
    })); err != nil {
        log.Panicf("http server error: %v", err)
    }
}

本作品采用《CC 协议》，转载必须注明作者和本文链接