Holen Sie Daten von verschachtelten dynamischen Schlüssel JSON in Golang

Question

Ich bin neu zu gehen, ich versuche, bestimmte Schlüssel aus der JSON-Struktur wie folgt zu extrahieren.

{ 
    "cluster_name": "escluster", 
    "nodes": { 
     "Sd2AvEXsswjTn6ErRYjg": { 
      "timestamp": 1460624696217, 
      "name": "master1", 
      "transport_address": "10.0.0.1:9300", 
      "host": "10.0.0.1:9300", 
      "ip": [ 
       "10.0.0.1:9300", 
       "NONE" 
      ], 
      "attributes": { 
       "data": "false", 
       "master": "true" 
      }, 
      "os": { 
       "timestamp": 1460624696217, 
       "cpu_percent": 0, 
       "load_average": 0, 
       "mem": { 
        "total_in_bytes": 163987664, 
        "free_in_bytes": 136357264, 
        "used_in_bytes": 26629400, 
        "free_percent": 84, 
        "used_percent": 16 
       }, 
       "swap": { 
        "total_in_bytes": 0, 
        "free_in_bytes": 0, 
        "used_in_bytes": 0 
       } 
      } 
     }, 
     "yzabB-OaTfOqvgAELIMq1Q": { 
      "timestamp": 1460624938213, 
      "name": "data_1", 
      "transport_address": "10.0.0.2:9300", 
      "host": "10.0.0.2", 
      "ip": [ 
       "10.0.0.2:9300", 
       "NONE" 
      ], 
      "attributes": { 
       "master": "false" 
      }, 
      "os": { 
       "timestamp": 1460624938213, 
       "cpu_percent": 0, 
       "load_average": 0.29, 
       "mem": { 
        "total_in_bytes": 623840000, 
        "free_in_bytes": 4127648, 
        "used_in_bytes": 666, 
        "free_percent": 1, 
        "used_percent": 99 
       }, 
       "swap": { 
        "total_in_bytes": 0, 
        "free_in_bytes": 0, 
        "used_in_bytes": 0 
       } 
      } 
     }, 
     "q5CdgUF2TRewujr-0RPMgQ": { 
      "timestamp": 1460624934417, 
      "name": "master_0", 
      "transport_address": "10.0.0.3:9300", 
      "host": "10.0.0.2", 
      "ip": [ 
       "10.0.0.3:9300", 
       "NONE" 
      ], 
      "attributes": { 
       "data": "false", 
       "master": "true" 
      }, 
      "os": { 
       "timestamp": 1460624934417, 
       "cpu_percent": 0, 
       "load_average": 0, 
       "mem": { 
        "total_in_bytes": 163898764, 
        "free_in_bytes": 139705616, 
        "used_in_bytes": 24194588, 
        "free_percent": 85, 
        "used_percent": 15 
       }, 
       "swap": { 
        "total_in_bytes": 0, 
        "free_in_bytes": 0, 
        "used_in_bytes": 0 
       } 
      } 
     } 
    } 
}  

Da die Knotennamen dynamisch sind, würde Ich mag mem für jeden Knoten abzurufen. Ich habe this gefunden, um Daten abzurufen, aber nicht den dynamischen Schlüssel. Wie können wir das machen?

Answer 1

Eine gute Referenz zu lernen, wie Daten in Gehe zu verarbeiten: http://blog.golang.org/json-and-go

In Bezug auf Ihr Problem scheint es mir, wie Sie Ihre Daten relativ gut strukturiert ist ... Ich habe ein Beispiel Extrahieren des mem Teil jedes Knotens gesetzt im folgenden Spielplatz Beispiel:

http://play.golang.org/p/0O5U-3N_tA

der Kern davon ist, dass, was auch immer ist angegeben stark kann als struct s codiert werden. Was dynamisch ist (z. B. Ihre Knotennamen), kann als Maps codiert werden. Beide können beliebig verwirbelt werden, so dass diese:

type Node struct { 
    Timestamp  uint64   `json:timestamp` 
    Name    string   `json:name` 
    TransportAddress string   `json:transport_address` 
    Host    string   `json:host` 
    Ip    []string   `json:ip` 
    Attributes  map[string]string `json:attributes` 
    Os    *OsInfo   `json:os` 
} 

type Payload struct { 
    Name string   `json:cluster_name` 
    Nodes map[string]*Node `json:nodes` 
} 

erfassen sowohl die allgemeine Struktur eines Knotens (über seine struct Definition) und die Tatsache, dass sie dynamisch indiziert sind (über die Tatsache, dass sich die Knoten gespeichert . in einem dynamischen map

Sobald entordnet, ist es dann trivial, Ihre Daten zu verarbeiten, um Ihre Speicher Informationen zu extrahieren: es nur gut bekannte Strukturen ist und ordnet den ganzen Weg nach unten:

var p Payload 
if err := json.Unmarshal([]byte(payload), &p); err != nil { 
    log.Fatal(err) 
} 
for k, node := range p.Nodes { 
    fmt.Printf("%s: %s\n", k, node.Os.Mem) 
} 

Outpu ts wie erwartet:

Sd2AvEXsswjTn6ErRYjg: map[total_in_bytes:%!s(uint64=163987664) free_in_bytes:%!s(uint64=136357264) used_in_bytes:%!s(uint64=26629400) free_percent:%!s(uint64=84) used_percent:%!s(uint64=16)] 
yzabB-OaTfOqvgAELIMq1Q: map[used_percent:%!s(uint64=99) total_in_bytes:%!s(uint64=623840000) free_in_bytes:%!s(uint64=4127648) used_in_bytes:%!s(uint64=666) free_percent:%!s(uint64=1)] 
q5CdgUF2TRewujr-0RPMgQ: map[total_in_bytes:%!s(uint64=163898764) free_in_bytes:%!s(uint64=139705616) used_in_bytes:%!s(uint64=24194588) free_percent:%!s(uint64=85) used_percent:%!s(uint64=15)] 

(Sie sind natürlich frei zu extrahieren/formatieren Sie Ihre Daten zuerst und Graben der Payload Objekt, sobald dies abgeschlossen ist)