Tratamento da solicitação de postagem JSON no Go

Então, eu tenho o seguinte, que parece incrivelmente hacky, e eu tenho pensado comigo mesmo que o Go tem bibliotecas projetadas melhor do que isso, mas não consigo encontrar um exemplo de Go manipulando uma solicitação POST de dados JSON. Todos são POSTs de formulário.

Aqui está um exemplo de solicitação: curl -X POST -d "{\"test\": \"that\"}" http://localhost:8082/test

E aqui está o código, com os logs incorporados:

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

Tem que haver uma maneira melhor, certo? Estou perplexo ao descobrir qual poderia ser a melhor prática.

(Go também é conhecido como Golang para os mecanismos de pesquisa e mencionado aqui para que outros possam encontrá-lo.)

Por favor, use em json.Decodervez de 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)
}

Você precisa ler req.Body. O ParseFormmétodo está lendo req.Bodye analisando-o no formato codificado em HTTP padrão. O que você deseja é ler o corpo e analisá-lo no formato JSON.

Aqui está seu código atualizado.

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

Eu estava enlouquecendo com esse problema exato. Meu JSON Marshaller e Unmarshaller não estavam preenchendo minha estrutura Go. Encontrei a solução em https://eager.io/blog/go-and-json :

"Como em todas as estruturas do Go, é importante lembrar que apenas os campos com uma primeira letra maiúscula são visíveis para programas externos como o JSON Marshaller".

Depois disso, meu Marshaller e Unmarshaller funcionaram perfeitamente!

Há duas razões pelas quais json.Decoderdeve ser preferível ao invés json.Unmarshal- que não são abordadas na resposta mais popular de 2013:

1. Em fevereiro de 2018, go 1.10introduziu um novo método json.Decoder.DisallowUnknownFields (), que aborda a preocupação de detectar entradas JSON indesejadas
2. req.Bodyjá é um io.Reader. Lendo todo o seu conteúdo e, em seguida, realizando json.Unmarshaldesperdícios de recursos, se o fluxo for, digamos, um bloco de 10 MB de JSON inválido. A análise do corpo da solicitação, com json.Decoder, conforme ele é transmitido , acionaria um erro de análise antecipada se JSON inválido fosse encontrado. O processamento de fluxos de E / S em tempo real é o caminho preferido .

Abordando alguns dos comentários do usuário sobre a detecção de entrada incorreta do usuário:

Para impor campos obrigatórios e outras verificações de saneamento, tente:

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)

Parque infantil

Saída típica:

$ 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

Achei o exemplo a seguir dos documentos realmente útil (fonte aqui ).

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

A chave aqui é que o OP estava tentando decodificar

type test_struct struct {
    Test string
}

... nesse caso, soltaríamos o const jsonStreame substituiríamos a Messagestruct pelo 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)
    }
}

Atualização : Eu também acrescentaria que este post também fornece ótimos dados sobre como responder com JSON. O autor explica struct tags, do qual eu não estava ciente.

Desde JSON normalmente não parecer {"Test": "test", "SomeKey": "SomeVal"}, mas sim {"test": "test", "somekey": "some value"}, você pode reestruturar a sua estrutura como esta:

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

... e agora seu manipulador analisará JSON usando "some-key" em vez de "SomeKey" (que você usará internamente).

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