数据格式介绍

• 是系统中数据交互不可缺少的内容
• 这里主要介绍JSON、XML、MSGPack

JSON

• json是完全独立于语言的文本格式，是k-v的形式 name:zs

• 应用场景：前后端交互，系统间数据交互

  json使用go语言内置的encoding/json 标准库

  编码json使用json.Marshal()函数可以对一组数据进行JSON格式的编码

  func Marshal(v interface{}) ([]byte, error)

  示例过结构体生成json

点击查看代码

type Person struct {
    Name string `json:"name"`
    Hobby []string `json:"hobby"`
}

func main() {
    p := Person{Name: "lisi", Hobby: []string{"pingpang", "LOL"}}
    b, err := json.Marshal(&p)
    if err != nil {
        fmt.Println("Marshal err", err)
    }
    fmt.Println(string(b))

    // 格式化输出
    b2, err := json.MarshalIndent(p, "", "\t")
    if err != nil {
        fmt.Println("Marshal err", err)
    }
    fmt.Println(string(b2))
} 

struct tag

type Person struct {
    // "-" 是忽略的意思
    Name string `json:"-"`
    Hobby []string `json:"hobby"`
}

示例：通过map生成json

func main() {
    m1 := make(map[string]interface{})
    m1["name"] = "王五"
    m1["age"] = 88
    b , _ := json.Marshal(&m1)
    fmt.Println(string(b))
}

• 解码json使用json.Unmarshal()函数可以对一组数据进行JSON格式的解码

  func Unmarshal(data []byte, v interface{}) error

示例解析到结构体:

点击查看代码

type Person struct {
    Age int `json:"age,string"`
    Name string `json:"name"`
    Niubility bool `json:"niubility"`
}

func main() {
    b := []byte(`{"age": "18", "name": "王五", "niubibity": true}`)
    var p Person
    if err := json.Unmarshal(b, &p); err != nil {
        fmt.Println(err.Error())
    }
    fmt.Println(p)
} 

• 示例解析到interface

点击查看代码

func main() {
    // int和float64都当float64
    b := []byte(`{"age": 3.14, "name": "王五", "niubibity": true}`)
    var i interface{}
    if err := json.Unmarshal(b, &i); err != nil {
        fmt.Println(err.Error())
    }
    // 自动转到map
    fmt.Println(i)
    // 可以判断类型
    m := i.(map[string]interface{})
    for k, v := range m {
        switch vv := v.(type) {
        case float64:
            fmt.Println(k, "是float64类型", vv)
        case string:
            fmt.Println(k, "是string类型", vv)
        case bool:
            fmt.Println(k, "是bool类型", vv)
        default:
            fmt.Println("其它类型")
        }
    }
} 

XML

• 是可扩展标记语言，包含声明、根标签、子元素和属性

• 应用场景：配置文件以及webService

  示例：

  
  Shanghai_VPN 127.0.0.1 Beijing_VPN 127.0.0.2

点击查看代码

// 抽取单个server对象
type Server struct {
    ServerName string `xml:"serverName"`
    ServerIP string `xml:"serverIP"`
}
type Servers struct {
    Name xml.Name `xml:"servers"`
    Version string `xml:"version"`
    Servers []Server `xml:"server"`
}

func main() {
    b, err := ioutil.ReadFile("./my.xml")
    if err != nil {
        fmt.Println(err.Error())
        return
    }
    var s Servers
    if err := xml.Unmarshal(b, &s); err != nil {
        fmt.Println(err.Error())
        return
    }
    fmt.Printf("%#v", s)
} 

MSGPack

• MSGPack是二进制的json，性能更快，更省空间
• 需要安装第三方包：go get -u github.com/vmihailenco/msgpack

点击查看代码

package main

import (
    "encoding/json"
    "fmt"
    "github.com/vmihailenco/msgpack/v5"
)

type Person struct {
    Name string `json:"name"`
    Age int     `json:"age"`
}

func main() {
    p := Person{Name: "张三", Age: 35}
    b, err := msgpack.Marshal(&p)
    b2, _ := json.Marshal(&p)
    fmt.Println(len(b))  // 18
    fmt.Println(len(b2))  // 26
    // 很明显，二进制的json更省空间，性能也更高
    if err != nil {
        fmt.Println(err.Error())
        return
    }

    var p2 Person
    if err := msgpack.Unmarshal(b, &p2); err != nil {
        fmt.Println(err.Error())
        return
    }
    fmt.Println(p2)

    var m1 interface{}
    msgpack.Unmarshal(b, &m1)
    fmt.Println(m1)

} 

msgpackage写入到文件，从文件读取案例:

点击查看代码

package main

import (
    "fmt"
    "github.com/vmihailenco/msgpack/v5"
    "io/ioutil"
    "math/rand"
)

type Person struct {
    Name string
    Age  int
    Sex  string
}

// 结构体转成json并写入到文件
func writerJson(filename string) (err error) {
    var persons []*Person
    // 假数据
    for i := 0; i < 10; i++ {
        p := &Person{
            Name: fmt.Sprintf("name%d", i),
            Age:  rand.Intn(100),
            Sex:  "male",
        }
        persons = append(persons, p)
    }
    // 二进制json序列化
    data, err := msgpack.Marshal(persons)
    if err != nil {
        fmt.Println(err)
        return
    }
    err = ioutil.WriteFile(filename, data, 0666)
    if err != nil {
        fmt.Println(err)
        return
    }
    return
}

// 从json文件中读取json数据并转成结构体
func readJson(filename string) (err error) {
    bData, err := ioutil.ReadFile(filename)
    if err != nil {
        fmt.Println(err)
        return
    }
    var person []*Person  //      注意：此处必须传指针
    if err = msgpack.Unmarshal(bData, &person); err != nil {
        fmt.Println(err)
        return
    }
    for _, v := range person {
        fmt.Printf("%#v\n", *v)
    }
    return nil
}

func main() {
    err := writerJson("./data4.json")
    if err != nil {
        fmt.Println(err)
        return
    }

    if err := readJson("./data4.json"); err != nil {
        fmt.Println(err)
    }
} 

注意：Marshal将结构体序列化成json的时候，传值或指针都可以，推荐传递指针

Unmarshal将json数据转换成结构体的时候，必须传递指针类型，因为需要通过指针进行赋值

参考网址：msgpack