Golang 多部分文件表单请求

从现在开始，努力学习吧！本文《Golang 多部分文件表单请求》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

我正在针对 mapbox 编写一个 api 客户端，将一批 svg 图像上传到自定义地图。他们为此提供的 api 已记录在一个可以正常工作的 curl 调用示例中：

curl -f images=@include/mapbox/sprites_dark/aubergine_selected.svg "https://api.mapbox.com/styles/v1///sprite?access_token=$mapbox_api_key" --trace-ascii /开发/stdout

当尝试从 golang 执行相同操作时，我很快发现多形式库非常有限，并编写了一些代码来发出类似于上面提到的 curl 请求的请求。

func createmultipartformdata(filemap map[string]string) (bytes.buffer, *multipart.writer) {
    var b bytes.buffer
    var err error
    w := multipart.newwriter(&b)
    var fw io.writer
    for filename, filepath := range filemap {

        h := make(textproto.mimeheader)
        h.set("content-disposition",
            fmt.sprintf(`form-data; name="%s"; filename="%s"`, "images", filename))
        h.set("content-type", "image/svg+xml")

        if fw, err = w.createpart(h); err != nil {
            fmt.printf("error creating form file %v, %v", filename, err)
            continue
        }

        filecontents, err := ioutil.readfile(filepath)
        filecontents = bytes.replaceall(filecontents, []byte("\n"), []byte("."))

        blocksize := 64
        remainder := len(filecontents) % blocksize
        iterations := (len(filecontents) - remainder) / blocksize

        newbytes := []byte{}
        for i := 0; i < iterations; i++ {
            start := i * blocksize
            end := i*blocksize + blocksize
            newbytes = append(newbytes, filecontents[start:end]...)
            newbytes = append(newbytes, []byte("\n")...)
        }

        if remainder > 0 {
            newbytes = append(newbytes, filecontents[iterations*blocksize:]...)
            newbytes = append(newbytes, []byte("\n")...)
        }

        if err != nil {
            fmt.printf("error reading svg file: %v: %v", filepath, err)
            continue
        }

        _, err = fw.write(newbytes)

        if err != nil {
            log.debugf("could not write file to multipart: %v, %v", filename, err)
            continue
        }
    }

    w.close()

    return b, w
}

在实际请求中设置标头：

    bytes, formWriter := createMultipartFormData(filesMap)

    req, err := http.NewRequest("Post", fmt.Sprintf("https://api.mapbox.com/styles/v1/%v/%v/sprite?access_token=%v", "my_company", styleID, os.Getenv("MAPBOX_API_KEY")), &bytes)

    if err != nil {
        return err
    }

    req.Header.Set("User-Agent", "curl/7.64.1")
    req.Header.Set("Accept", "*/*")
    req.Header.Set("Content-Length", fmt.Sprintf("%v", len(bytes.Bytes())))
    req.Header.Set("Content-Type", formWriter.FormDataContentType())

    byts, _ := httputil.DumpRequest(req, true)
    fmt.Println(string(byts))

    res, err := http.DefaultClient.Do(req)

甚至想要限制行长度并复制 curl 使用的编码，但到目前为止还没有成功。有经验的人知道为什么这在 curl 中有效但在 golang 中无效吗？

解决方案

嗯，我承认解决你的任务的“谜题”的所有部分都可以在网上找到，这有两个问题：

• 他们经常错过某些有趣的细节。
• 有时，他们会给出完全错误的建议。

所以，这是一个可行的解决方案。

package main

import (
    "bytes"
    "fmt"
    "io"
    "io/ioutil"
    "mime"
    "mime/multipart"
    "net/http"
    "net/textproto"
    "net/url"
    "os"
    "path/filepath"
    "strconv"
    "strings"
)

func main() {
    const (
        dst   = "https://api.mapbox.com/styles/v1/acmeinc/style_001/sprite"
        fname = "path/to/a/sprite/image.svg"
        token = "an_invalid_token"
    )

    err := post(dst, fname, token)
    if err != nil {
        fmt.fprintln(os.stderr, err)
        os.exit(1)
    }
}

func post(dst, fname, token string) error {
    u, err := url.parse(dst)
    if err != nil {
        return fmt.errorf("failed to parse destination url: %w", err)
    }

    form, err := makerequestbody(fname)
    if err != nil {
        return fmt.errorf("failed to prepare request body: %w", err)
    }

    q := u.query()
    q.set("access_token", token)
    u.rawquery = q.encode()

    hdr := make(http.header)
    hdr.set("content-type", form.contenttype)
    req := http.request{
        method:        "post",
        url:           u,
        header:        hdr,
        body:          ioutil.nopcloser(form.body),
        contentlength: int64(form.contentlen),
    }

    resp, err := http.defaultclient.do(&req)
    if err != nil {
        return fmt.errorf("failed to perform http request: %w", err)
    }
    defer resp.body.close()

    _, _ = io.copy(os.stdout, resp.body)

    return nil
}

type form struct {
    body        *bytes.buffer
    contenttype string
    contentlen  int
}

func makerequestbody(fname string) (form, error) {
    ct, err := getimagecontenttype(fname)
    if err != nil {
        return form{}, fmt.errorf(
            `failed to get content type for image file "%s": %w`,
            fname, err)
    }

    fd, err := os.open(fname)
    if err != nil {
        return form{}, fmt.errorf("failed to open file to upload: %w", err)
    }
    defer fd.close()

    stat, err := fd.stat()
    if err != nil {
        return form{}, fmt.errorf("failed to query file info: %w", err)
    }

    hdr := make(textproto.mimeheader)
    cd := mime.formatmediatype("form-data", map[string]string{
        "name":     "images",
        "filename": fname,
    })
    hdr.set("content-disposition", cd)
    hdr.set("contnt-type", ct)
    hdr.set("content-length", strconv.formatint(stat.size(), 10))

    var buf bytes.buffer
    mw := multipart.newwriter(&buf)

    part, err := mw.createpart(hdr)
    if err != nil {
        return form{}, fmt.errorf("failed to create new form part: %w", err)
    }

    n, err := io.copy(part, fd)
    if err != nil {
        return form{}, fmt.errorf("failed to write form part: %w", err)
    }

    if int64(n) != stat.size() {
        return form{}, fmt.errorf("file size changed while writing: %s", fd.name())
    }

    err = mw.close()
    if err != nil {
        return form{}, fmt.errorf("failed to prepare form: %w", err)
    }

    return form{
        body:        &buf,
        contenttype: mw.formdatacontenttype(),
        contentlen:  buf.len(),
    }, nil
}

var imagecontenttypes = map[string]string{
    "png":  "image/png",
    "jpg":  "image/jpeg",
    "jpeg": "image/jpeg",
    "svg":  "image/svg+xml",
}

func getimagecontenttype(fname string) (string, error) {
    ext := filepath.ext(fname)
    if ext == "" {
        return "", fmt.errorf("file name has no extension: %s", fname)
    }

    ext = strings.tolower(ext[1:])
    ct, found := imagecontenttypes[ext]
    if !found {
        return "", fmt.errorf("unknown file name extension: %s", ext)
    }

    return ct, nil
}

一些关于实现的随机注释可以帮助您理解概念：

• 为了构造请求的有效负载（主体），我们使用 bytes.buffer 实例。
  它有一个很好的属性，即指向它的指针 (*bytes.buffer) 实现了 io.writer 和 io.reader，因此可以轻松地与处理 i/o 的 go stdlib 的其他部分组合。
• 在准备发送多部分表单时，我们不会将整个文件的内容放入内存中，而是将它们直接“管道”到“多部分表单编写器”中。
• 我们有一个查找表，它将要提交的文件名扩展名映射到其 mime 类型；我不知道 api 是否需要这个；如果不是真的需要，准备包含文件的表单字段的代码部分可以简化很多，但 curl 会发送它，我们也是如此。

只是好奇，这是做什么的？

filecontents = bytes.replaceall(filecontents, []byte("\n"), []byte("."))

        blocksize := 64
        remainder := len(filecontents) % blocksize
        iterations := (len(filecontents) - remainder) / blocksize

        newbytes := []byte{}
        for i := 0; i < iterations; i++ {
            start := i * blocksize
            end := i*blocksize + blocksize
            newbytes = append(newbytes, filecontents[start:end]...)
            newbytes = append(newbytes, []byte("\n")...)
        }

        if remainder > 0 {
            newbytes = append(newbytes, filecontents[iterations*blocksize:]...)
            newbytes = append(newbytes, []byte("\n")...)
        }

        if err != nil {
            fmt.printf("error reading svg file: %v: %v", filepath, err)
            continue
        }

将整个文件读入内存很少是一个好主意（ioutil.readfile）。

正如@muffin-top所说，这三行代码怎么样？

for fileName, filePath := range fileMap {

        // h := ...

        fw, _ := w.CreatePart(h) // TODO: handle error

        f, _ := os.Open(filePath) // TODO: handle error

        io.Copy(fw, f) // TODO: handle error

        f.Close() // TODO: handle error
    }

终于介绍完啦！小伙伴们，这篇关于《Golang 多部分文件表单请求》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！