การจัดการคำขอโพสต์ JSON ใน Go

ดังนั้นฉันจึงมีสิ่งต่อไปนี้ซึ่งดูเหมือนว่าแฮ็คอย่างไม่น่าเชื่อและฉันคิดกับตัวเองว่า Go มีการออกแบบห้องสมุดที่ดีกว่านี้ แต่ฉันไม่พบตัวอย่างของ Go ที่จัดการคำขอ POST ของข้อมูล JSON พวกเขาทั้งหมดฟอร์ม POST

นี่คือตัวอย่างคำขอ: curl -X POST -d "{\"test\": \"that\"}" http://localhost:8082/test

และนี่คือรหัสโดยมีบันทึกฝังอยู่:

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))
}

จะต้องมีวิธีที่ดีกว่าใช่มั้ย ฉันแค่นิ่งงันในการค้นหาสิ่งที่ปฏิบัติที่ดีที่สุด

(Go เป็นที่รู้จักกันว่า Golang สำหรับเครื่องมือค้นหาและกล่าวถึงที่นี่เพื่อให้ผู้อื่นสามารถค้นหาได้)

โดยใช้แทนjson.Decoderjson.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)
}

req.Bodyคุณจำเป็นต้องอ่านจาก ParseFormวิธีการอ่านจากreq.Bodyนั้นแยกในรูปแบบ HTTP เข้ารหัสมาตรฐาน สิ่งที่คุณต้องการคือการอ่านเนื้อหาและแยกวิเคราะห์ในรูปแบบ JSON

นี่คือรหัสของคุณอัพเดท

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))
}

ฉันกำลังขับรถบ้าด้วยปัญหาที่แน่นอนนี้ JSON Marshaller และ Unmarshaller ของฉันไม่ได้เติมโครงสร้าง Go ของฉัน จากนั้นฉันพบวิธีแก้ปัญหาที่https://eager.io/blog/go-and-json :

"เช่นเดียวกับ structs ทั้งหมดใน Go เป็นสิ่งสำคัญที่ต้องจำไว้ว่ามีเพียงเขตข้อมูลที่มีอักษรตัวใหญ่ตัวแรกที่ปรากฏให้เห็นในโปรแกรมภายนอกเช่น JSON Marshaller"

หลังจากนั้น Marshaller และ Unmarshaller ของฉันทำงานได้อย่างสมบูรณ์แบบ!

มีเหตุผลสองประการที่json.Decoderควรได้รับความนิยมมากกว่าjson.Unmarshalเพราะไม่ได้กล่าวถึงในคำตอบที่ได้รับความนิยมมากที่สุดในปี 2013:

1. กุมภาพันธ์ 2018 go 1.10แนะนำวิธีการใหม่json.Decoder.DisallowUnknownFields () ซึ่งเน้นความกังวลของการตรวจหา JSON-input ที่ไม่ต้องการ
2. req.Bodyio.Readerมีอยู่แล้ว อ่านเนื้อหาทั้งหมดแล้วทำการjson.Unmarshalสิ้นเปลืองทรัพยากรหากสตรีมพูดให้เป็นบล็อกขนาด 10MB ของ JSON ที่ไม่ถูกต้อง การแยกวิเคราะห์เนื้อหาคำร้องขอด้วยjson.Decoderขณะที่สตรีมเข้ามาจะทำให้เกิดข้อผิดพลาดในการแยกวิเคราะห์ก่อนหากพบ JSON ที่ไม่ถูกต้อง การประมวลผลสตรีม I / O แบบเรียลไทม์เป็นวิธีที่ต้องการ

การพูดถึงความคิดเห็นของผู้ใช้เกี่ยวกับการตรวจสอบอินพุตของผู้ใช้ที่ไม่ดี:

หากต้องการบังคับใช้ฟิลด์บังคับและการตรวจสอบด้านสุขาภิบาลอื่น ๆ ให้ลอง:

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)

สนามเด็กเล่น

เอาท์พุททั่วไป:

$ 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

ฉันพบตัวอย่างต่อไปนี้จากเอกสารที่เป็นประโยชน์จริง ๆ (แหล่งที่นี่ )

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)
    }
}

กุญแจสำคัญในที่นี้คือ OP ต้องการถอดรหัส

type test_struct struct {
    Test string
}

... ในกรณีนี้เราจะดรอปconst jsonStreamและแทนที่Messagestruct ด้วย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)
    }
}

อัปเดต : ฉันจะเพิ่มว่าโพสต์นี้ให้ข้อมูลที่ดีเกี่ยวกับการตอบสนองด้วย JSON เช่นกัน ผู้เขียนอธิบายstruct tagsซึ่งฉันไม่ทราบ

เนื่องจาก JSON ไม่ปกติ{"Test": "test", "SomeKey": "SomeVal"}แต่{"test": "test", "somekey": "some value"}คุณสามารถปรับโครงสร้างของคุณดังนี้:

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

... และตอนนี้ตัวจัดการของคุณจะวิเคราะห์ JSON โดยใช้ "some-key" ซึ่งตรงข้ามกับ "SomeKey" (ซึ่งคุณจะใช้ภายใน)

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)
}