Xử lý yêu cầu bài viết JSON trong Go

Vì vậy, tôi có những điều sau đây, có vẻ như rất khó tin và tôi đã tự nghĩ rằng Go có các thư viện được thiết kế tốt hơn thế này, nhưng tôi không thể tìm thấy một ví dụ về việc xử lý yêu cầu POST của dữ liệu JSON. Chúng đều là dạng POST.

Đây là một yêu cầu ví dụ: curl -X POST -d "{\"test\": \"that\"}" http://localhost:8082/test

Và đây là mã, với các bản ghi được nhúng:

package main

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

type test_struct struct {
    Test string
}

func test(rw http.ResponseWriter, req *http.Request) {
    req.ParseForm()
    log.Println(req.Form)
    //LOG: map[{"test": "that"}:[]]
    var t test_struct
    for key, _ := range req.Form {
        log.Println(key)
        //LOG: {"test": "that"}
        err := json.Unmarshal([]byte(key), &t)
        if err != nil {
            log.Println(err.Error())
        }
    }
    log.Println(t.Test)
    //LOG: that
}

func main() {
    http.HandleFunc("/test", test)
    log.Fatal(http.ListenAndServe(":8082", nil))
}

Có một cách tốt hơn, phải không? Tôi chỉ bối rối trong việc tìm kiếm những gì thực hành tốt nhất có thể.

(Go còn được gọi là Golang cho các công cụ tìm kiếm và được đề cập ở đây để những người khác có thể tìm thấy nó.)

Vui lòng sử dụng json.Decoderthay vì json.Unmarshal.

func test(rw http.ResponseWriter, req *http.Request) {
    decoder := json.NewDecoder(req.Body)
    var t test_struct
    err := decoder.Decode(&t)
    if err != nil {
        panic(err)
    }
    log.Println(t.Test)
}

Bạn cần đọc từ req.Body. Các ParseFormphương pháp được đọc từ req.Bodyvà sau đó phân tích nó trong định dạng mã hóa HTTP chuẩn. Những gì bạn muốn là đọc phần thân và phân tích nó theo định dạng JSON.

Đây là mã của bạn được cập nhật.

package main

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

type test_struct struct {
    Test string
}

func test(rw http.ResponseWriter, req *http.Request) {
    body, err := ioutil.ReadAll(req.Body)
    if err != nil {
        panic(err)
    }
    log.Println(string(body))
    var t test_struct
    err = json.Unmarshal(body, &t)
    if err != nil {
        panic(err)
    }
    log.Println(t.Test)
}

func main() {
    http.HandleFunc("/test", test)
    log.Fatal(http.ListenAndServe(":8082", nil))
}

Tôi đã tự làm mình phát điên với vấn đề chính xác này. JSON Marshaller và Unmarshaller của tôi không tạo ra cấu trúc Go của tôi. Sau đó, tôi tìm thấy giải pháp tại https://eager.io/blog/go-and-json :

"Như với tất cả các cấu trúc trong Go, điều quan trọng cần nhớ là chỉ các trường có chữ cái đầu tiên được hiển thị cho các chương trình bên ngoài như JSON Marshaller."

Sau đó, Marshaller và Unmarshaller của tôi đã hoạt động hoàn hảo!

Có hai lý do tại sao json.Decodernên được ưu tiên hơn json.Unmarshal- không được đề cập trong câu trả lời phổ biến nhất từ ​​năm 2013:

1. Tháng 2 năm 2018, đã go 1.10giới thiệu một phương thức mới json.Decoder.DisallowUn UnknownFields () nhằm giải quyết mối quan tâm phát hiện đầu vào JSON không mong muốn
2. req.Bodyđã là một io.Reader. Đọc toàn bộ nội dung của nó và sau đó thực hiện json.Unmarshallãng phí tài nguyên nếu luồng là, giả sử một khối 10 MB JSON không hợp lệ. Phân tích phần thân yêu cầu, với json.Decoder, khi nó truyền vào sẽ gây ra lỗi phân tích cú pháp sớm nếu gặp phải JSON không hợp lệ. Xử lý I / O suối trong thời gian thực là ưa thích đi chiều .

Giải quyết một số ý kiến ​​của người dùng về việc phát hiện đầu vào của người dùng xấu:

Để thực thi các trường bắt buộc và kiểm tra vệ sinh khác, hãy thử:

d := json.NewDecoder(req.Body)
d.DisallowUnknownFields() // catch unwanted fields

// anonymous struct type: handy for one-time use
t := struct {
    Test *string `json:"test"` // pointer so we can test for field absence
}{}

err := d.Decode(&t)
if err != nil {
    // bad JSON or unrecognized json field
    http.Error(rw, err.Error(), http.StatusBadRequest)
    return
}

if t.Test == nil {
    http.Error(rw, "missing field 'test' from JSON object", http.StatusBadRequest)
    return
}

// optional extra check
if d.More() {
    http.Error(rw, "extraneous data after JSON object", http.StatusBadRequest)
    return
}

// got the input we expected: no more, no less
log.Println(*t.Test)

Sân chơi

Sản lượng tiêu biểu:

$ curl -X POST -d "{}" http://localhost:8082/strict_test

expected json field 'test'

$ curl -X POST -d "{\"Test\":\"maybe?\",\"Unwanted\":\"1\"}" http://localhost:8082/strict_test

json: unknown field "Unwanted"

$ curl -X POST -d "{\"Test\":\"oops\"}g4rB4g3@#$%^&*" http://localhost:8082/strict_test

extraneous data after JSON

$ curl -X POST -d "{\"Test\":\"Works\"}" http://localhost:8082/strict_test 

log: 2019/03/07 16:03:13 Works

Tôi tìm thấy ví dụ sau từ các tài liệu thực sự hữu ích (nguồn ở đây ).

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "log"
    "strings"
)

func main() {
    const jsonStream = `
        {"Name": "Ed", "Text": "Knock knock."}
        {"Name": "Sam", "Text": "Who's there?"}
        {"Name": "Ed", "Text": "Go fmt."}
        {"Name": "Sam", "Text": "Go fmt who?"}
        {"Name": "Ed", "Text": "Go fmt yourself!"}
    `
    type Message struct {
        Name, Text string
    }
    dec := json.NewDecoder(strings.NewReader(jsonStream))
    for {
        var m Message
        if err := dec.Decode(&m); err == io.EOF {
            break
        } else if err != nil {
            log.Fatal(err)
        }
        fmt.Printf("%s: %s\n", m.Name, m.Text)
    }
}

Chìa khóa ở đây là OP đang tìm cách giải mã

type test_struct struct {
    Test string
}

... trong trường hợp nào chúng ta sẽ bỏ const jsonStreamvà thay thế Messagestruct bằng test_struct:

func test(rw http.ResponseWriter, req *http.Request) {
    dec := json.NewDecoder(req.Body)
    for {
        var t test_struct
        if err := dec.Decode(&t); err == io.EOF {
            break
        } else if err != nil {
            log.Fatal(err)
        }
        log.Printf("%s\n", t.Test)
    }
}

Cập nhật : Tôi cũng sẽ thêm rằng bài đăng này cũng cung cấp một số dữ liệu tuyệt vời về việc phản hồi với JSON. Tác giả giải thích struct tags, điều mà tôi không nhận thức được.

Vì JSON thường không giống như {"Test": "test", "SomeKey": "SomeVal"}, nhưng thay vào đó {"test": "test", "somekey": "some value"}, bạn có thể cấu trúc lại cấu trúc của mình như thế này:

type test_struct struct {
    Test string `json:"test"`
    SomeKey string `json:"some-key"`
}

... và bây giờ trình xử lý của bạn sẽ phân tích cú pháp JSON bằng cách sử dụng "some-key" trái ngược với "someKey" (mà bạn sẽ sử dụng nội bộ).

type test struct {
    Test string `json:"test"`
}

func test(w http.ResponseWriter, req *http.Request) {
    var t test_struct

    body, _ := ioutil.ReadAll(req.Body)
    json.Unmarshal(body, &t)

    fmt.Println(t)
}