解码JSON保持所有键

Question

予有这种类型

{ 
    "<server>": { 
     "<guest>": { 
      "<service>": { 
       "<part>": { 
        "num": "<number>", 
        "type": "<type>", 
        "timestamp": "2016-02-01T12:53:12Z" 
       } 
      } 
     } 
    } 
} 

的JSON结构在上述JSON对象解编我需要例如保存键server,guest等。我想到了下面的结构，但我无法解开上面的JSON对象，因为键在解组过程中丢失。

type Section struct { 
    Bytes  int  
    Files  int  
    Timestamp time.Time 
} 
type Report struct { 
    Server string 
    Guest string 
    Service string 
    Part string 
    Details Section 
} 

有没有什么办法解开上面的JSON对象到结构保持键完好无损。

编辑：
<server>中的文字正在改变。这就是为什么我需要在不加修饰的情况下保存它，以便我可以继续努力。

Answer 1

1-尝试在The Go Playground：

package main 

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

func main() { 
    s := `{ 
    "<server1>": { 
     "<guest2>": { 
      "<service3>": { 
       "<part4>": { 
        "num": 12, 
        "type": 14, 
        "timestamp": "2016-02-01T12:53:12Z" 
       } 
      } 
     } 
    } 
}` 

    var data map[string]map[string]map[string]map[string]Section 
    err := json.Unmarshal([]byte(s), &data) 
    if err != nil { 
     fmt.Println(err) 
    } 

    fmt.Println(data) 
} 

type Section struct { 
    Bytes  int  `json:"num"` 
    Files  int  `json:"type"` 
    Timestamp time.Time `json:"timestamp"` 
} 
type Report struct { 
    Server string 
    Guest string 
    Service string 
    Part string 
    Details Section 
} 

输出：

map[<server1>:map[<guest2>:map[<service3>:map[<part4>:{12 14 2016-02-01 12:53:12 +0000 UTC}]]]] 

---

2-转换为Report struct，尝试在The Go Playground：

package main 

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

func main() { 
    s := `{ 
    "<server1>": { 
     "<guest2>": { 
      "<service3>": { 
       "<part4>": { 
        "num": 12, 
        "type": 14, 
        "timestamp": "2016-02-01T12:53:12Z" 
       } 
      } 
     } 
    } 
}` 

    var data map[string]map[string]map[string]map[string]Section 
    err := json.Unmarshal([]byte(s), &data) 
    if err != nil { 
     fmt.Println(err) 
    } 
    r := Report{} 
    for k, v := range data { 
     r.Server = k 
     for k2, v2 := range v { 
      r.Guest = k2 
      for k3, v3 := range v2 { 
       r.Service = k3 
       for k4, v4 := range v3 { 
        r.Part = k4 
        r.Details = v4 
       } 
      } 
     } 
    } 
    fmt.Println(r) 
} 

type Section struct { 
    Bytes  int  `json:"num"` 
    Files  int  `json:"type"` 
    Timestamp time.Time `json:"timestamp"` 
} 
type Report struct { 
    Server string 
    Guest string 
    Service string 
    Part string 
    Details Section 
} 

输出：

{<server1> <guest2> <service3> <part4> {12 14 2016-02-01 12:53:12 +0000 UTC}} 

Answer 2

对于上面的JSON，这个结构可以正常工作。

type Report struct { 
     Server struct { 
      Guest struct { 
       Service struct { 
        Part struct { 
         Num string `json:"num"` 
         Type string `json:"type"` 
         Timestamp time.Time `json:"timestamp"` 
        } `json:"<part>"` 
       } `json:"<service>"` 
      } `json:"<guest>"` 
     } `json:"<server>"` 
    } 

Answer 3

我写a library，可以使这个更容易使用。该Reports可解组对你的JSON格式：

package main 

import (
    "time" 

    "github.com/go-restit/lzjson" 
) 

type Section struct { 
    Bytes  int  `json:"num"` 
    Files  int  `json:"type"` 
    Timestamp time.Time `json:"timestamp"` 
} 

type Report struct { 
    Server string 
    Guest string 
    Service string 
    Part string 
    Details Section 
} 

type Reports []Report 

func (reports *Reports) UnmarshalJSON(content []byte) (err error) { 

    root := lzjson.NewNode() 
    if err = json.Unmarshal(content, &root); err != nil { 
     return 
    } 

    // reset the slice of reports 
    *reports = make([]Report, 0, 10) 

    for _, serverName := range root.GetKeys() { 
     server := root.Get(serverName) 
     if err = server.Error(); err != nil { 
      return 
     } 
     for _, guestName := range server.GetKeys() { 
      guest := server.Get(guestName) 
      if err = guest.Error(); err != nil { 
       return 
      } 
      for _, serviceName := range guest.GetKeys() { 
       service := guest.Get(serviceName) 
       if err = service.Error(); err != nil { 
        return 
       } 
       for _, partName := range service.GetKeys() { 
        part := service.Get(partName) 
        if err = part.Error(); err != nil { 
         return 
        } 
        var report Report 
        timestamp, _ := time.Parse("2006-01-02T15:04:05Z", part.Get("timestamp").String()) 
        report.Server = serverName 
        report.Guest = guestName 
        report.Service = serviceName 
        report.Part = partName 
        report.Details = Section{ 
         Bytes:  part.Get("num").Int(), 
         Files:  part.Get("type").Int(), 
         Timestamp: timestamp, 
        } 
        *reports = append(*reports, report) 
       } 
      } 
     } 
    } 
    return 
} 

现在你可以这样做：

package main 

import (
    "encoding/json" 
    "log" 
) 

func main() { 
    raw := ` 
    { 
     "<server 1>": { 
      "<guest>": { 
       "<service>": { 
        "<part>": { 
         "num": "<number>", 
         "type": "<type>", 
         "timestamp": "2016-02-01T12:53:12Z" 
        } 
       } 
      } 
     }, 
     "<server 2>": { 
      "<guest>": { 
       "<service>": { 
        "<part>": { 
         "num": "<number>", 
         "type": "<type>", 
         "timestamp": "2016-02-01T12:53:12Z" 
        } 
       } 
      } 
     } 
    }` 
    var reports Reports 
    err := json.Unmarshal([]byte(raw), &reports) 
    if err != nil { 
     log.Fatalf("error reading reports: %s", err.Error()) 
    } 
    log.Printf("Reports: %#v", reports) 
}