golang json 处理方法

﹏ヽ暗。殇╰゛Y 2023-05-22 04:44 4阅读 0赞

# 目的 #

> 利用 golang 进行定义，输出 json 格式  
> golang 其实对 json 格式定义建议使用 struct 格式， 比较清晰，方便

# json 格式 #

> 常见 json 格式为 list , dict 两种

参考下面输出格式

## dict ##

{
    	"fstype": "ext4",
    	"host": "host1"
    }

## list ##

["host1", "host2", "host3", "host4"]

## dict + list ##

{
    	"fstype": "ext4",
    	"host": ["host1", "host2", "host3", "host4"]
    }

## list + dict ##

[{
    		"fstype": "ext4",
    		"host": "host1"
    	},
    	{
    		"fstype": "ext4",
    		"host": "host2"
    }]

## golang 输出 json 方法 ##

### dict ###

package main
    
    import (
            "fmt"
            "encoding/json"
    )
    
    
    func makeExtr() map[string]string {           //  定义
            testExtr := make(map[string]string,0)
            testExtr["fstype"] = "ext4"
            testExtr["host"] = "host1"
            return testExtr
    }
    
    func buildExtr() string  {                     // json 输出
            hardExtr := makeExtr()
            jsonExtr, _ := json.Marshal(hardExtr)
            return fmt.Sprintf(string(jsonExtr))
    }
    
    func main() {
            info := buildExtr()
            fmt.Println(info)
    }

输出结果

# go run json_001.go
    {"fstype":"ext4","host":"host1"}

### list ###

package main
    
    import (
            "fmt"
            "encoding/json"
    )
    
    
    func makeExtr() []string {
            testExtr := []string{
                    "host1",
                    "host2",
                    "host3",
                    "host4",
            }
            return testExtr
    }
    
    func buildExtr() string  {
            hardExtr := makeExtr()
            jsonExtr, _ := json.Marshal(hardExtr)
            return fmt.Sprintf(string(jsonExtr))
    }
    
    func main() {
            info := buildExtr()
            fmt.Println(info)
    }

执行结果如下

# go run json_002.go
    ["host1","host2","host3","host4"]

简单说明

> json dict 使用 key: value 方法可以通过 map\[string\]string 进行定义  
> json list 直接通过 \[\]string 进行定义  
> 最简单直接方法进行 json 格式定义为 map\[string\]string  
> 但假如 json 格式复杂时候，则很难维护

换个方式，我们使用 struct 进行重新定义上面例子

package main
    
    import (
            "fmt"
            "encoding/json"
    )
    
    type HostInfo struct {
            FsType    string `json:"fstype"`
            HostName  string `json:"host"`
    }
    
    func makeExtr() HostInfo {
            var testExtr HostInfo
            testExtr.FsType = "ext4"
            testExtr.HostName= "host1"
            return testExtr
    }
    
    func buildExtr() string  {
            hardExtr := makeExtr()
            jsonExtr, _ := json.Marshal(hardExtr)
            return fmt.Sprintf(string(jsonExtr))
    }
    
    func main() {
            info := buildExtr()
            fmt.Println(info)
    }

运行结果：

# go run json_003.go
    {"fstype":"ext4","host":"host1"}

看上去比直接定义麻烦，但请参考下面例子

{
    	"name": "monitorinfo",
    	"value": [{
    		"body": [{
    			"metric": "cpu_idel",
    			"datasourceId": 11,
    			"from": 1587005847,
    			"step": 60,
    			"source": "123456789abcdefg",
    			"to": 1587092247,
    			"type": "Augix"
    		}],
    		"chart": {
    			"legend": "myLegend",
    			"title": "mytitile"
    		},
    		"url": "http://www.m3db.com"
    	}]
    }

### 思路 ###

> 类似上述 json 格式，必须要通过 struct 进行解决才可以方便后续维护  
> struct 定义时候需要进行分组处理

参考 example

package main
    
    import (
        "fmt"
        "encoding/json"
        "time"
    )
    
    type MonitorData struct {
            Name  string    `json:"name"`
            Value []M3Value `json:"value"`
    }
    
    type M3Body struct {
            Metric       string `json:"metric"`
            DatasourceID int    `json:"datasourceId"`
            From         int64  `json:"from"`
            Step         int    `json:"step"`
            Source       string `json:"source"`
            To           int64  `json:"to"`
            Type         string `json:"type"`
    }
    
    type M3Chart struct {
            Legend string `json:"legend"`
            Title  string `json:"title"`
    }
    
    
    type M3Value struct {
            Value   []M3Body   `json:"body"`
            Chart   M3Chart    `json:"chart"`
            URL     string     `json:"url"`
    }
    
    func buildM3Chart() M3Chart{
            var newM3Chart M3Chart
            newM3Chart.Legend = "myLegend"
            newM3Chart.Title = "mytitile"
            return newM3Chart
    }
    
    func buildM3Body() M3Body {
            var newBody M3Body
            newBody.Metric = "cpu_idel"
            newBody.DatasourceID = 11
            newBody.From = time.Now().Unix()
            newBody.Step = 60
            newBody.Source = "123456789abcdefg"
            newBody.To = time.Now().Unix() + 86400
            newBody.Type = "Augix"
            return newBody
    }
    
    func buildM3Value() M3Value {
            var newM3Value M3Value
            var m3BodySlice []M3Body
            m3BodyData := buildM3Body()
            m3BodySlice = append(m3BodySlice, m3BodyData)
            newM3Value.Value = m3BodySlice
            newM3Value.Chart = buildM3Chart()
            newM3Value.URL = "http://www.m3db.com"
            return newM3Value
    }
    
    func buildMonitorData() MonitorData {
            var newMonitorData MonitorData
            var monitorDataValue M3Value
            var monitorDataValueSlice []M3Value
            monitorDataValue = buildM3Value()
            newMonitorData.Name = "monitorinfo"
            monitorDataValueSlice = append(monitorDataValueSlice, monitorDataValue)
            newMonitorData.Value = monitorDataValueSlice
            return newMonitorData
    }
    
    
    func main() {
    
            jsonInfo := buildMonitorData()
            goJson, _ := json.Marshal(jsonInfo)
            data := fmt.Sprintf( string(goJson))
            fmt.Println(data)
    
    }

思路

> 先对每个 dict 分别独立进行分层定义  
> 在获取数据时候分别进行组合  
> 注意一下 slice 的用法 （利用 struct + append 的方法实现）