Gestione di JSON Post Request in Go

Question

Quindi ho il seguente, che sembra incredibilmente hacky, e ho pensato a me stesso che Go ha librerie progettate meglio di così, ma non riesco a trovare un esempio di Go che gestisce un POST richiesta di dati JSON. Sono tutti moduli POST.

Ecco un esempio di richiesta: curl -X POST -d "{\"test\": \"that\"}" http://localhost:8082/test

E qui è il codice, con i registri incorporati:

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

Ci

ha avuto modo di essere un modo migliore, giusto? Sono solo perplesso nel trovare quale potrebbe essere la migliore pratica.

(Go è anche conosciuto come Golang ai motori di ricerca, e di cui qui in modo che altri possano trovarla.)

Answer 1

Utilizzare json.Decoder invece di 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) 
    } 
    defer req.Body.Close() 
    log.Println(t.Test) 
} 

Answer 2

è necessario leggere da req.Body. Il metodo ParseForm sta leggendo da req.Body e quindi analizzandolo nel formato codificato HTTP standard. Quello che vuoi è leggere il corpo e analizzarlo in formato JSON.

Ecco il codice aggiornato.

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

Answer 3

ho trovato il seguente esempio dalla documentazione veramente utile (fonte here).

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

La chiave qui è che il PO stava cercando di decodificare

type test_struct struct { 
    Test string 
} 

... nel qual caso avremmo cadere il const jsonStream, e sostituire il Message struct con l'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) 
    } 
} 

Aggiornamento: Vorrei anche aggiungere che this post fornisce alcuni ottimi dati sulla risposta anche con JSON. L'autore spiega struct tags, di cui non ero a conoscenza.

Dal JSON normalmente non sembrano {"Test": "test", "SomeKey": "SomeVal"}, ma piuttosto {"test": "test", "somekey": "some value"}, è possibile ristrutturare la vostra struct in questo modo:

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

... e ora il tuo gestore analizzerà JSON utilizzando "un po 'in mano" in contrapposizione a "SomeKey" (che userete internamente).

Answer 4

Mi stavo facendo impazzire con questo problema esatto. My JSON Marshaller e Unmarshaller non stavano popolando la mia struttura Go. Quindi ho trovato la soluzione al https://eager.io/blog/go-and-json:

"Come in tutte le strutture di Go, è importante ricordare che solo i campi con la prima lettera maiuscola sono visibili a programmi esterni come il Marshaller JSON."

Successivamente, il mio Marshaller e Unmarshaller hanno funzionato perfettamente!