Unmarshaling In einem Interface{} und Anschließend Ausführen, Geben Sie Behauptung

Bekomme ich eine string durch ein rabbitmq-message-system. Vor dem senden,

Benutze ich json.Marshal konvertieren, das Ergebnis zu string und senden durch
rabbitmq.

Den Strukturen, die ich konvertieren und senden kann: (die Namen geändert und die Größe der Strukturen, aber es sollte keine Rolle spielen)

type Somthing1 struct{
   Thing        string    `json:"thing"`
   OtherThing   int64     `json:"other_thing"`
}

oder

type Somthing2 struct{
   Croc        int       `json:"croc"`
   Odile       bool      `json:"odile"`
}

Die Nachricht geht durch perfekt als string gedruckt
auf der anderen Seite (server)

Bis jetzt funktioniert alles.
Jetzt versuche ich, konvertieren Sie Sie zurück in Ihre Strukturen und die für die Geltendmachung der Arten.

ersten Versuch durch:

func typeAssert(msg string) {

 var input interface{}

 json.Unmarshal([]byte(msg), &input)

 switch input.(type){
 case Somthing1:
    job := Somthing1{}
    job = input.(Somthing1)
    queueResults(job)

  case Somthing2:
    stats := Somthing2{}
    stats = input.(Somthing2)
    queueStatsRes(stats)
 default:
}

Funktioniert das nicht. Beim Drucken die Art des input nach Unmarshaling
es ich bekomme map[string]interface{} (?!?)

- und noch seltsamer, als dass der map-key ist der string, den ich bekam und der map-Wert leer ist.

Habe ich einige andere versuche wie:

 func typeAssert(msg string) {

  var input interface{}

  json.Unmarshal([]byte(msg), &input)

  switch v := input.(type){
  case Somthing1:
    v = input.(Somthing1)
    queueResults(v)

   case Somthing2:
    v = input.(Somthing2)
    queueStatsRes(v)
  default:
}

und auch versucht, das schreiben der Schalter, wie schon erläutert, die in dieser Antwort:
Golang: nicht Typ-Schalter auf non-Schnittstelle Wert

switch v := interface{}(input).(type)

immer noch ohne Erfolg...

Irgendwelche Ideen?

InformationsquelleAutor Blue Bot | 2016-02-23
  1. 21

    Den Standard-Typen, die json Paket Unmarshals in der Anzeige in der Unmarshal Funktion Dokumentation

    bool, for JSON booleans
float64, for JSON numbers
string, for JSON strings
[]interface{}, for JSON arrays
map[string]interface{}, for JSON objects
nil for JSON null

    Da bist du unmarshaling in eine interface{} die zurückgegebenen Typen werden nur aus diesem Satz. Die json Paket gar nicht kennt Something1 und Something2. Sie müssen entweder konvertieren von map[string]interface{} Sie, dass das json-Objekt wird in deren Marshalling rückgängig gemacht wurde, oder unmarshal direkt in den struct-Typ Sie wollen.

    Wenn Sie nicht wollen, zu tun ist, entpacken Sie die Dateien aus einer generischen Schnittstelle, oder irgendwie tag die Daten, damit Sie wissen, was zu erwarten ist, könnte man iterativ nehmen Sie die json und versuchen, unmarshal es in jeder Art Sie wollen.

    Sie können auch pack die in einen wrapper-Struktur zu tun, die unmarshaling für Sie:

    type Something1 struct {
    Thing      string `json:"thing"`
    OtherThing int64  `json:"other_thing"`
}

type Something2 struct {
    Croc  int  `json:"croc"`
    Odile bool `json:"odile"`
}

type Unpacker struct {
    Data       interface{}
}

func (u *Unpacker) UnmarshalJSON(b []byte) error {
    smth1 := &Something1{}
    err := json.Unmarshal(b, smth1)

    //no error, but we also need to make sure we unmarshaled something
    if err == nil && smth1.Thing != "" {
        u.Data = smth1
        return nil
    }

    //abort if we have an error other than the wrong type
    if _, ok := err.(*json.UnmarshalTypeError); err != nil && !ok {
        return err
    }

    smth2 := &Something2{}
    err = json.Unmarshal(b, smth2)
    if err != nil {
        return err
    }

    u.Data = smth2
    return nil
}

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

    • Das ist mein problem, ich weiß nicht welche Art, ich bin immer "unter" der string. Also die Natalies option ist nicht gut. Über die erste, wie kann ich konvertieren Sie die map[string]interface{} wenn ich nicht weiß, welche Taste zu verwenden? @JimB
    • Was Sie tun, Sie bedeuten "unter die Schnur"? In der Karte? play.golang.org/p/0zZ8fsmO17
    • EDIT: Sorry, gerade kommentiert nun, bevor Sie sich mit Ihrem Spielplatz-Lösung. Das ist genau das, was mir fehlte! danke!!! Bitte posten Sie es als eine Lösung für andere sein, und ich werde bis-Abstimmung. Nochmals vielen Dank @JimB
    • Sie sind nicht immer ein struct ist, kann nur eine der 6 Standard-Typen, wenn unmarshaling in eine interface{}, und Sie können nicht behaupten, eine Schnittstelle, die ein Typ, der ist es nicht. Nehmen Sie die Daten aus der Karte, die Sie bekommen, und erstellen Sie eine neue Struktur der Art, die Sie wollen.
    • Ja, ich verstehe, dass. Mir fehlte der Teil über die Verwendung range... Wenn fügen Sie Ihre soulution zu meinem ursprünglichen code, den ich geltend machen kann, ist zurück zu den neuen Instanzen von der ursprünglichen Strukturen. Ich denke...
    • ein Typ assertion nur behauptet, dass die Schnittstelle enthält einen bestimmten Typ; Sie können nicht ändern die Art, die Sie enthält. Die range-Anweisung ändert nichts, es war nur eine einfache Möglichkeit zur Anzeige der Inhalte von der Karte.
    • JimB: Perfekt, vielen Dank, nach dem Versuch, verschiedene Dinge in den Boden spielen, ich denke das ist die beste Lösung, Danke!
    • Es scheint, dass diese Methode hängt ganz von einem Feld in einer der Strukturen. Gibt es einen anderen Weg, möglicherweise - ich kann nicht an nichts denken, ABER das?

    InformationsquelleAutor JimB
  2. 9

    Die Sie gefunden haben eine typische json vs typisierte Sprache problem!
    Da json nicht typisiert ist und schemaless, es ist nicht möglich zu folgern, was Daten "unter die Schnur", ohne tatsächlich Decodierung.

    Also Ihre einzige option ist unmarshal in eine interface{} das erzeugt immer einen map[string]interface{}. Sie könnte eine Reflexion der Magie zu bauen, die endgültige Struktur, aber das ist viel manuelle Arbeit und Fehler anfällig.
    Hier sind einige mögliche Lösungen:

    Quick 'n' dirty

    Lassen die json Paket die spiegelung Zeug. Versuch unmarshal in jeder erwartete Typ:

    func typeAssert(msg string) {

 var thing1 Something1

 err := json.Unmarshal([]byte(msg), &thing1)
 if err == nil{
    //do something with thing1
    return
 }    

 var thing2 Something2

 err = json.Unmarshal([]byte(msg), &thing2)
 if err == nil{
    //do something with thing2
    return
 }    

 //handle unsupported type

}

    Bauen Sie Ihre eigene "Art system" auf der Oberseite des json -

    Verzögern die Codierung, bis Sie wissen, was drin ist. Verwenden Sie diese Struktur als Zwischenprodukt Darstellung Ihrer Daten:

    type TypedJson struct{
  Type string 
  Data json.RawMessage
}

    Marschall: 

    thing := Something1{"asd",123}
tempJson, _ := json.Marshal(thing)

typedThing := TypedJson{"something1", tempJson}
finalJson, _ := json.Marshal(typedThing)

    Unmarshal:

    func typeAssert(msg string) {

  var input TypedJson  
  json.Unmarshal([]byte(msg), &input)

  switch input.Type{
  case "something1":
    var thing Something1
    json.Unmarshal(input.Data, &thing)
    queueStatsRes(thing)   
   case "something2":
    var thing Something2
    json.Unmarshal(input.Data, &thing)
    queueStatsRes(thing)
  default:
    //handle unsupported type
}

    Verwenden ein typisiertes Serialisierungsformat

    • Mochte die erste Lösung, seine genau, wie du Sie genannt hast...aber immer noch den job zu erledigen perfekt. Die zweite ist nicht, dass es praktisch ist, weil im wirklichen Leben habe ich eine sehr große struct erstellt aus vielen anderen komplexen Strukturen, die von vielen stellen im Programm, so dass Gebäude eine Struktur, die nur die zu nennen, die übertragenen Haupt-struct scheint mir falsch zu sein und nicht schön an alle.
    • Diese "wrapper-Struktur" wird nur für das senden und empfangen von Daten. Sie können weiterhin die original-Strukturen in das Programm. Ich denke, es ist die bessere Lösung, aber Sie sind natürlich frei zu wählen, was passt Ihr Fall am besten.
    • Dem Stimme ich in gewisser Weise, doch ist es immer noch seltsam erscheint mir die Angabe des Typs in einer Zeichenfolge. Ich mite falsch. Trotzdem vielen Dank für beide Lösungen - von Ihnen positiv bewertet werden
    • Die Type könnte alles sein, qualifiziert sich als ein Bezeichner (z.B. verschiedene int-Werte). Es sieht ganz komisch aus, weil es wirklich nur ein hack zum umgehen der Einschränkungen von json.
    • ja ein hack in der Tat, es ist ok, ich hasse das hinzufügen von zu vielen Objekten zu einem Typ, wenn es nicht notwendig ist. In dieser denke, du hast Recht
    • Super Antwort, json.RawMessage ist genau die richtige Lösung für diese Art von problem.

    InformationsquelleAutor fl0cke
Schreibe einen Kommentar