bind json golang

Deshacerse de los objetos JSON anidados en Golang

Question

Hay few questions sobre el topic pero ninguna parece cubrir mi caso, así que estoy creando una nueva.

Tengo JSON como el siguiente:

{"foo":{ "bar": "1", "baz": "2" }, "more": "text"}

¿Hay alguna manera de desasignar la propiedad de barra anidada y asignarla directamente a una propiedad de estructura sin crear una estructura anidada?

La solución que estoy adoptando ahora es la siguiente:

type Foo struct {
    More String `json:"more"`
    Foo  struct {
        Bar string `json:"bar"`
        Baz string `json:"baz"`
    } `json:"foo"`
    //  FooBar  string `json:"foo.bar"`
}

Esta es una versión simplificada, por favor ignore la verbosidad. Como puede ver, me gustaría poder analizar y asignar el valor a

//  FooBar  string `json:"foo.bar"`

He visto personas usando un mapa, pero ese no es mi caso. Básicamente no me importa el contenido de foo (que es un objeto grande), excepto por algunos elementos específicos.

¿Cuál es el enfoque correcto en este caso? No estoy buscando hacks extraños, así que si este es el camino a seguir, estoy de acuerdo con eso.

Answer 1

¿Hay alguna manera de desasignar la propiedad de barra anidada y asignarla directamente a una propiedad de estructura sin crear una estructura anidada?

No, encoding / json no puede hacer el truco con "> some> deep> childnode" como encoding / xml puede hacer. Estructuras anidadas es el camino a seguir.

Answer 2

¿Qué hay de los campos anónimos? No estoy seguro de si eso constituirá una "estructura anidada", pero es más claro que tener una declaración de estructura anidada. ¿Qué sucede si quiere reutilizar el elemento anidado en otro lugar?

type NestedElement struct{
    someNumber int `json:"number"`
    someString string `json:"string"`
}

type BaseElement struct {
    NestedElement `json:"bar"`
}

Answer 3

Al igual que lo que Volker mencionó, las estructuras anidadas es el camino a seguir. Pero si realmente no desea estructuras anidadas, puede anular el func UnmarshalJSON.

http://play.golang.org/p/T0aZEDL0Nu

type A struct {
    FooBar string // takes foo.bar
    FooBaz string // takes foo.baz
    More   string `json:"more"`
}

func (a *A) UnmarshalJSON(b []byte) error {
    var f interface{}
    json.Unmarshal(b, &f)

    m := f.(map[string]interface{})

    foomap := m["foo"]
    v := foomap.(map[string]interface{})

    a.FooBar = v["bar"].(string)
    a.FooBaz = v["baz"].(string)

    return nil
}

Por favor, ignore el hecho de que no estoy devolviendo un error apropiado. Lo dejé por simplicidad.

Answer 4

Estaba trabajando en algo como esto. Pero está trabajando solo con estructuras generadas desde proto. https://github.com/flowup-labs/grpc-utils

en tu proto

message Msg {
  Firstname string = 1 [(gogoproto.jsontag) = "name.firstname"];
  PseudoFirstname string = 2 [(gogoproto.jsontag) = "lastname"];
  EmbedMsg = 3  [(gogoproto.nullable) = false, (gogoproto.embed) = true];
  Lastname string = 4 [(gogoproto.jsontag) = "name.lastname"];
  Inside string  = 5 [(gogoproto.jsontag) = "name.inside.a.b.c"];
}

message EmbedMsg{
   Opt1 string = 1 [(gogoproto.jsontag) = "opt1"];
}

Entonces su salida será

{
"lastname": "Three",
"name": {
    "firstname": "One",
    "inside": {
        "a": {
            "b": {
                "c": "goo"
            }
        }
    },
    "lastname": "Two"
},
"opt1": "var"
}

Answer 5

Este es un ejemplo de cómo deshacer las respuestas JSON del servidor proxy sbserver de Safebrowsing v4 API: https://play.golang.org/p/4rGB5da0Lt

// this example shows how to unmarshall JSON requests from the Safebrowsing v4 sbserver
package main

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

// response from sbserver POST request
type Results struct {
    Matches []Match     
}

// nested within sbserver response
type Match struct {
    ThreatType string 
    PlatformType string 
    ThreatEntryType string 
    Threat struct {
        URL string
    }
}

func main() {
    fmt.Println("Hello, playground")

    // sample POST request
    //   curl -X POST -H ''Content-Type: application/json'' 
    // -d ''{"threatInfo": {"threatEntries": [{"url": "http://testsafebrowsing.appspot.com/apiv4/ANY_PLATFORM/MALWARE/URL/"}]}}'' 
    // http://127.0.0.1:8080/v4/threatMatches:find

    // sample JSON response
    jsonResponse := `{"matches":[{"threatType":"MALWARE","platformType":"ANY_PLATFORM","threatEntryType":"URL","threat":{"url":"http://testsafebrowsing.appspot.com/apiv4/ANY_PLATFORM/MALWARE/URL/"}}]}`

    res := &Results{}
    err := json.Unmarshal([]byte(jsonResponse), res)
        if(err!=nil) {
            log.Fatal(err)
        }

    fmt.Printf("%v/n",res)
    fmt.Printf("/tThreat Type: %s/n",res.Matches[0].ThreatType)
    fmt.Printf("/tPlatform Type: %s/n",res.Matches[0].PlatformType)
    fmt.Printf("/tThreat Entry Type: %s/n",res.Matches[0].ThreatEntryType)
    fmt.Printf("/tURL: %s/n",res.Matches[0].Threat.URL)
}

Answer 6

La combinación de map y struct permite desasignar objetos JSON anidados donde la clave es dinámica. => mapa [cadena]

Por ejemplo: stock.json

{
  "MU": {
    "symbol": "MU",
    "title": "micro semiconductor",
    "share": 400,
    "purchase_price": 60.5,
    "target_price": 70
  },
  "LSCC":{
    "symbol": "LSCC",
    "title": "lattice semiconductor",
    "share": 200,
    "purchase_price": 20,
    "target_price": 30
  }
}

Ir a la aplicación

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "os"
)

type Stock struct {
    Symbol        string  `json:"symbol"`
    Title         string  `json:"title"`
    Share         int     `json:"share"`
    PurchasePrice float64 `json:"purchase_price"`
    TargetPrice   float64 `json:"target_price"`
}
type Account map[string]Stock

func main() {
    raw, err := ioutil.ReadFile("stock.json")
    if err != nil {
        fmt.Println(err.Error())
        os.Exit(1)
    }
    var account Account
    log.Println(account)
}

La clave dinámica en el hash es manejar una cadena, y el objeto anidado está representado por una estructura.

Answer 7

Sí. Con gjson todo lo que tienes que hacer ahora es:

bar := gjson.Get(json, "foo.bar")

bar podría ser una propiedad de estructura si lo desea. Además, no hay mapas.

Answer 8

sí puede asignar los valores de json anidado a struct hasta que conozca el tipo subyacente de claves json, por ejemplo.

package main

import (
    "encoding/json"
    "fmt"
)

// Object
type Object struct {
    Foo map[string]map[string]string `json:"foo"`
    More string `json:"more"`
}

func main(){
    someJSONString := []byte(`{"foo":{ "bar": "1", "baz": "2" }, "more": "text"}`)
    var obj Object
    err := json.Unmarshal(someJSONString, &obj)
    if err != nil{
        fmt.Println(err)
    }
    fmt.Println("jsonObj", obj)
}