如何在Golang中将多部分POST请求重定向到第二个服务器？

本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《如何在Golang中将多部分POST请求重定向到第二个服务器？》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~

我正在尝试执行以下操作。

|upload file in html post file form|
              |
              ⌄
|server a forwards the multipart request| 
              |                                     
              ⌄                                     
|server b receives and stores the file from the forwarded multipart request|
              |
              ⌄
|server a receives response from server b when server b is done|

在服务器 a 上处理多部分请求很简单，但是当我尝试在服务器 b 上处理转发的请求时，它失败并显示 multipart: nextpart: eof。

我正在尝试创建单独的前端/后端服务。前端只处理ui相关的处理，而后端实际上会对文件做一些处理，因此需要多部分请求转发。

服务器a上的转发代码如下。 解决方案是从这里获取的。 https://stackoverflow.com/a/34725635/6569715

func forwardrequest(address string, path string, r *http.request) (interface{}, error) {
    body, err := ioutil.readall(r.body)
    if err != nil {
        return nil, err
    }

    r.body = ioutil.nopcloser(bytes.newreader(body))
    proxyreq, err := http.newrequest(r.method, fmt.sprintf("%s%s", address, path), bytes.newreader(body))
    if err != nil {
        return nil, err
    }

    for header, values := range r.header {
        for _, value := range values {
            proxyreq.header.add(header, value)
        }
    }

    client := &http.client{}
    resp, err := client.do(proxyreq)
    if err != nil {
        return nil, err
    }
    defer resp.body.close()
    return resp, nil
}

服务器b上处理转发请求的代码：

func testMultiPart(w http.ResponseWriter, r *http.Request) {
    if err := r.ParseMultipartForm(10 << 20); err != nil {
        err = errors.Wrap(errors.WithStack(err), "Backend: Failed to parse form")
        w.WriteHeader(http.StatusInternalServerError)
        fmt.Fprint(w, fmt.Sprintf("{\"error\":\"%s\"}", err.Error())
        return
    }
}

感谢任何帮助。

解决方案

我设法让它发挥作用。我相信这只是我自己的错误，没有正确填写 uri。无论如何，我都会发布解决方案中的片段以供将来参考。

客户端html文件表单部分：

<form action="/test-main/file-test" enctype="multipart/form-data" method="post">
    <label for="file-upload">upload your file :</label>
    &lt;input type=&quot;file&quot; id=&quot;file-upload&quot; name=&quot;file-upload&quot; accept=&quot;image/*&quot;&gt;
</form>

服务器a代码：

import (
    "net/http"
    "errors"
    "fmt"
    "log"
    "io/ioutil"
    "bytes"

    "github.com/gorilla/mux"
)

func fileupload(w http.responsewriter, r *http.request) {
    body, err := ioutil.readall(r.body)
    if err != nil {
        return log.fatal(err)
    }

    r.body = ioutil.nopcloser(bytes.newreader(body))
    // if server a and b are separate docker images, you may need to use their docker subnet ip, like below.
    proxyreq, err := http.newrequest(r.method, fmt.sprintf("http://172.18.0.2:8082%s", r.requesturi), bytes.newreader(body))
    if err != nil {
        return log.fatal(err)
    }

    for header, values := range r.header {
        for _, value := range values {
            proxyreq.header.add(header, value)
        }
    }

    client := &http.client{}
    resp, err := client.do(proxyreq)
    if err != nil {
        return log.fatal(err)   
    }
    defer resp.body.close()
    respbody, err := ioutil.readall(resp.body)
    if err != nil {
        return log.fatal(err)
    }

    // process server b response
    // ...
}

func createrouter() *mux.router {
    r := mux.newrouter()
    testpath := r.pathprefix("/test-main").subrouter()
    testpath.handlefunc("/file-test", fileupload)
    return r
}

func main() {
    // create server and route handlers
    srv := &http.server{
        handler:      createrouter(),
        addr:         ":8081",
        readtimeout:  30 * time.second,
        writetimeout: 30 * time.second,
    }

    // start server
    go func() {
        log.println("starting server")
        if err := srv.listenandserve(); err != nil {
            log.fatal(err)
        }
    }()
}

服务器b代码：

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"

    "github.com/gorilla/mux"
)

func uploadFile(w http.ResponseWriter, r *http.Request) {
    if err := r.ParseMultipartForm(10 << 20); err != nil {
        log.Fatal(err)
    }

    file, handler, err := r.FormFile("file-upload")
    if err == http.ErrMissingFile {
        return nil
    }

    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Uploaded File: %+v\n", handler.Filename)
    fmt.Printf("File Size: %+v\n", handler.Size)
    fmt.Printf("MIME Header: %+v\n", handler.Header)

    defer file.Close()

    // Create file
    dst, err := os.Create(fmt.Sprintf("/some-destination-folder/%s", handler.Filename))
    if err != nil {
        log.Fatal(err)
    }

    // Copy the uploaded file to the created file on the file system.
    if _, err := io.Copy(dst, file); err != nil {
        if err2 := dst.Close(); err2 != nil {
            log.Fatal(err)
        }
        log.Fatal(err)
    }
    dst.Close()

    return nil
}

func (c *Controller) createRouter() *mux.Router {
    r := mux.NewRouter()
    testPath := r.PathPrefix("/test-main").Subrouter()
    testPath.HandleFunc("/file-test", uploadFile)

    return r
}

func main() {
    // Create Server and Route Handlers
    srv := &http.Server{
        Handler:      createRouter(),
        Addr:         ":8082",
        ReadTimeout:  30 * time.Second,
        WriteTimeout: 30 * time.Second,
    }

    // Start Server
    go func() {
        log.Println("Starting Server")
        if err := srv.ListenAndServe(); err != nil {
            log.Fatal(err)
        }
    }()
}

祝未来的读者好运。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《如何在Golang中将多部分POST请求重定向到第二个服务器？》文章吧，也可关注golang学习网公众号了解相关技术文章。