handling - print json golang

Parcialmente JSON se unifica en un mapa en Go

Question

Mi servidor websocket recibirá y eliminará los datos JSON. Estos datos siempre estarán envueltos en un objeto con pares clave / valor. La cadena clave actuará como identificador de valor, indicando al servidor Go qué clase de valor es. Al saber qué tipo de valor, puedo pasar a JSON para poner el valor en el tipo correcto de estructura.

Cada objeto json puede contener múltiples pares clave / valor.

Ejemplo JSON:

{
    "sendMsg":{"user":"ANisus","msg":"Trying to send a message"},
    "say":"Hello"
}

¿Hay alguna manera fácil de usar el paquete "encoding/json" para hacer esto?

package main

import (
    "encoding/json"
    "fmt"
)

// the struct for the value of a "sendMsg"-command
type sendMsg struct {
    user string
    msg  string
}
// The type for the value of a "say"-command
type say string

func main(){
    data := []byte(`{"sendMsg":{"user":"ANisus","msg":"Trying to send a message"},"say":"Hello"}`)

    // This won''t work because json.MapObject([]byte) doesn''t exist
    objmap, err := json.MapObject(data)

    // This is what I wish the objmap to contain
    //var objmap = map[string][]byte {
    //  "sendMsg": []byte(`{"user":"ANisus","msg":"Trying to send a message"}`),
    //  "say": []byte(`"hello"`),
    //}
    fmt.Printf("%v", objmap)
}

Gracias por cualquier tipo de sugerencia / ayuda!

Answer 1

Además de la respuesta de Stephen Weinberg, desde entonces he implementado una herramienta práctica llamada iojson , que ayuda a poblar datos a un objeto existente fácilmente así como a codificar el objeto existente en una cadena JSON. También se proporciona un middleware iojson para trabajar con otros middlewares. Se pueden encontrar más ejemplos en iojson

Ejemplo:

func main() {
    jsonStr := `{"Status":true,"ErrArr":[],"ObjArr":[{"Name":"My luxury car","ItemArr":[{"Name":"Bag"},{"Name":"Pen"}]}],"ObjMap":{}}`

    car := NewCar()

    i := iojson.NewIOJSON()

    if err := i.Decode(strings.NewReader(jsonStr)); err != nil {
        fmt.Printf("err: %s/n", err.Error())
    }

    // populating data to a live car object.
    if v, err := i.GetObjFromArr(0, car); err != nil {
        fmt.Printf("err: %s/n", err.Error())
    } else {
        fmt.Printf("car (original): %s/n", car.GetName())
        fmt.Printf("car (returned): %s/n", v.(*Car).GetName())

        for k, item := range car.ItemArr {
            fmt.Printf("ItemArr[%d] of car (original): %s/n", k, item.GetName())
        }

        for k, item := range v.(*Car).ItemArr {
            fmt.Printf("ItemArr[%d] of car (returned): %s/n", k, item.GetName())
        }
    }
}

Muestra de salida:

car (original): My luxury car
car (returned): My luxury car
ItemArr[0] of car (original): Bag
ItemArr[1] of car (original): Pen
ItemArr[0] of car (returned): Bag
ItemArr[1] of car (returned): Pen

Answer 2

Esto se puede lograr mediante Unmarshalling en un map[string]*json.RawMessage .

var objmap map[string]*json.RawMessage
err := json.Unmarshal(data, &objmap)

Para analizar aún más sendMsg , podría hacer algo como:

var s sendMsg
err = json.Unmarshal(*objmap["sendMsg"], &s)

Por say , puedes hacer lo mismo y desmarcar en una cadena:

var str string
err = json.Unmarshal(*objmap["say"], &str)