如何在Go中通过POST请求发送JSON字符串

Question

如何在Go中通过POST请求发送JSON字符串

393

我尝试使用Apiary，并创建了一个通用模板，用于向模拟服务器发送JSON，以下是这段代码：

package main

import (
    "encoding/json"
    "fmt"
    "github.com/jmcvetta/napping"
    "log"
    "net/http"
)

func main() {
    url := "http://restapi3.apiary.io/notes"
    fmt.Println("URL:>", url)

    s := napping.Session{}
    h := &http.Header{}
    h.Set("X-Custom-Header", "myvalue")
    s.Header = h

    var jsonStr = []byte(`
{
    "title": "Buy cheese and bread for breakfast."
}`)

    var data map[string]json.RawMessage
    err := json.Unmarshal(jsonStr, &data)
    if err != nil {
        fmt.Println(err)
    }

    resp, err := s.Post(url, &data, nil, nil)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("response Status:", resp.Status())
    fmt.Println("response Headers:", resp.HttpResponse().Header)
    fmt.Println("response Body:", resp.RawText())

}

这段代码无法正确发送JSON数据，但我不知道原因。每次调用时JSON字符串可能会有所不同，因此我不能使用 Struct 。

- Ladislav Prskavec

我不熟悉你使用的一些库，但据我理解，你正在尝试发送一个Json映射。为什么不直接发送带有Json的字符串呢？ - Topo

2

如果您想发送 JSON，为什么要对 JSON 进行解组？ - JimB

一个小提示，你可以创建一个结构体或map[string]interface{}来添加所有你想要的值，然后使用json.Marshall将map或struct转换为json。 - Topo

@topo，我深入研究了napping的源代码，如果设置了有效载荷，他们会对其调用json.Marshall，我不确定为什么它对他没有起作用。 - OneOfOne

9个回答

173

您可以直接使用post方法来发布您的 JSON 数据。

values := map[string]string{"username": username, "password": password}

jsonValue, _ := json.Marshal(values)

resp, err := http.Post(authAuthenticatorUrl, "application/json", bytes.NewBuffer(jsonValue))

- gaozhidf

3

我收到了这个错误信息：

无法将 jsonValue（类型为 []byte）作为 http.Post 的 io.Reader 类型参数使用：[]byte 未实现 io.Reader（缺少 Read 方法）

。 - Mandar Vaze

@MandarVaze 我认为你可能在http.Post中使用了错误的io.Reader，而在我的代码中bytes.NewBuffer()运行良好。 - gaozhidf

2

我正在使用Go 1.7，如果有关系的话。 @OneOfOne列出的代码有效（它也使用了bytes.NewBuffer()，但是使用了http.NewRequest而不是http.Post）。 - Mandar Vaze

2

根据 https://golang.org/pkg/net/http/#Post，"调用者应在从中读取完毕后关闭`resp.Body`。如果提供的主体是`io.Closer`，则在请求之后关闭它。"作为Go新手，我如何判断主体是否为`io.Closer`，或者换句话说，这个示例是否安全？ - Dennis

1

这种方法的唯一限制是您无法设置自定义标头:/ - ba11b0y

49

如果您已经有一个结构体。

import (
    "bytes"
    "encoding/json"
    "io"
    "net/http"
    "os"
)

// .....

type Student struct {
    Name    string `json:"name"`
    Address string `json:"address"`
}

// .....

body := &Student{
    Name:    "abc",
    Address: "xyz",
}

payloadBuf := new(bytes.Buffer)
json.NewEncoder(payloadBuf).Encode(body)
req, _ := http.NewRequest("POST", url, payloadBuf)

client := &http.Client{}
res, e := client.Do(req)
if e != nil {
    return e
}

defer res.Body.Close()

fmt.Println("response Status:", res.Status)
// Print the body to the stdout
io.Copy(os.Stdout, res.Body)

完整的代码片段。

- Ninh Pham

14

除了标准的 net/http 包之外，您可以考虑使用我的 GoRequest。它包装了 net/http 并使您的生活更加轻松，无需过多考虑 JSON 或结构体。但是您也可以在一个请求中混合使用它们！（您可以在 gorequest 的 github 页面上了解更多详细信息）

因此，最终您的代码将变得像下面这样：

func main() {
    url := "http://restapi3.apiary.io/notes"
    fmt.Println("URL:>", url)
    request := gorequest.New()
    titleList := []string{"title1", "title2", "title3"}
    for _, title := range titleList {
        resp, body, errs := request.Post(url).
            Set("X-Custom-Header", "myvalue").
            Send(`{"title":"` + title + `"}`).
            End()
        if errs != nil {
            fmt.Println(errs)
            os.Exit(1)
        }
        fmt.Println("response Status:", resp.Status)
        fmt.Println("response Headers:", resp.Header)
        fmt.Println("response Body:", body)
    }
}

这取决于你想要实现什么。我创建了这个库是因为我和你一样遇到了同样的问题，我想写出更短、易于使用JSON格式并且在我的代码库和生产系统中更易于维护的代码。

- A-letubby

如果GoRequest包装了net/http。是否可以添加此内容以禁用TLS的不安全证书？tr：=＆http.Transport{ TLSClientConfig：＆tls.Config {InsecureSkipVerify：true}， } - user1513388

53

在任何情况下，在任何语言中贡献跳过TLS验证的代码示例都是一个可怕的想法......这会意外地使许多初学者在StackOverflow上复制粘贴"解决方法"，而不理解修复TLS错误的重要性。要么修复证书导入路径（如果是用于测试的自签名证书，请导入这些证书），要么修复您计算机上的证书链，或找出为什么您的服务器正在呈现无法由客户端验证的无效证书。 - Mike Atlas

3

我不太喜欢这个答案的一个方面，那就是它组成JSON对象的方式，这种方式可能会通过注入攻击进行利用。更好的方法是先组成一个对象，然后将其转换为JSON（并进行适当的转义）。 - John White

@JohnWhite 我同意，感觉非常像 Ruby/JS/Python 的风格。 - Rambatino

7

http或https的示例POST请求

    //Encode the data
       postBody, _ := json.Marshal(map[string]string{
          "name":  "Test",
          "email": "Test@Test.com",
       })
       responseBody := bytes.NewBuffer(postBody)
    //Leverage Go's HTTP Post function to make request
       resp, err := http.Post("https://postman-echo.com/post", "application/json", responseBody)
    //Handle Error
       if err != nil {
          log.Fatalf("An Error Occured %v", err)
       }
       defer resp.Body.Close()
    //Read the response body
       body, err := ioutil.ReadAll(resp.Body)
       if err != nil {
          log.Fatalln(err)
       }
       sb := string(body)
       log.Printf(sb)

- mesutpiskin

6

可以使用io.Pipe来处理大型请求体，就像另一个答案中提到的那样。这种方法通过从JSON编码器流式传输数据到网络来避免在内存中构建整个请求体。

本答案基于其他答案，展示了如何处理错误。一定要处理错误！

使用管道的CloseWithError函数将编码错误传播回从http.Post返回的错误。
处理从http.Post返回的错误
关闭响应体。

下面是代码:

r, w := io.Pipe()

go func() {
    w.CloseWithError(json.NewEncoder(w).Encode(data))
}()

// Ensure that read side of pipe is closed. This
// unblocks goroutine in scenario where http.Post
// errors out before reading the entire request body.
defer r.Close()

resp, err := http.Post(url, r)
if err != nil {
    // Adjust error handling here to meet application requrirements.
    log.Fatal(err)
}
defer resp.Body.Close()
// Use the response here.

- user13631587

3

如果您有大量数据要发送，可以使用管道：

package main

import (
   "encoding/json"
   "io"
   "net/http"
)

func main() {
   m := map[string]int{"SNG_ID": 75498415}
   r, w := io.Pipe()
   go func() {
      json.NewEncoder(w).Encode(m)
      w.Close()
   }()
   http.Post("https://stackoverflow.com", "application/json", r)
}

https://golang.org/pkg/io#Pipe

- Zombo

2

我会使用net/http包而不是napping。

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

func main() {
    url := "http://restapi3.apiary.io/notes"
    fmt.Println("URL:>", url)

    client := &http.Client{}

    var jsonStr = []byte(`
{
    "title": "Buy cheese and bread for breakfast."
}`)

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
    if err != nil {
        log.Fatal(err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-Custom-Header", "myvalue")

    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }

    defer resp.Body.Close()

    fmt.Println("response Status:", resp.Status)
    fmt.Println("response Headers:", resp.Header)

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("response Body:", string(body))
}

这将创建一个新的POST请求，其中JSON数据作为请求体，设置必要的标头，并使用http.Client发送请求。

替换占位符*。

- Isanka Wijerathne

1

如果您想这样做，您需要使用此地图来取消编组JSON字符串。

var data map[string]interface{}

但是，如果您需要每次更改JSON并使请求体的初始化更加方便，则可以使用此映射来创建JSON主体。

var bodyJsonMap map[string]interface{}{
    "key1": val1,
    "key2": val2,
    ...
}

然后将其转换为JSON字符串。

- Highdeger

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- OneOfOne · Accepted Answer

我对“napping”不太熟悉，但是使用Golang的“net/http”包是可以的（playground）：

func main() {
    url := "http://restapi3.apiary.io/notes"
    fmt.Println("URL:>", url)

    var jsonStr = []byte(`{"title":"Buy cheese and bread for breakfast."}`)
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
    req.Header.Set("X-Custom-Header", "myvalue")
    req.Header.Set("Content-Type", "application/json")

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

    fmt.Println("response Status:", resp.Status)
    fmt.Println("response Headers:", resp.Header)
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("response Body:", string(body))
}