1. 数据格式

1.1.1. 数据格式介绍

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

1.1.2. JSON

  • json是完全独立于语言的文本格式，是k-v的形式 name:zs
  • 应用场景：前后端交互，系统间数据交互

数据格式 - 图1

  • json使用go语言内置的encoding/json 标准库
  • 编码json使用json.Marshal()函数可以对一组数据进行JSON格式的编码 
  1.     func Marshal(v interface{}) ([]byte, error)

示例过结构体生成json

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. type Person struct {
  9.     Name  string
  10.     Hobby string
  11. }
  13. func main() {
  14.     p := Person{"5lmh.com", "女"}
  15.     // 编码json
  16.     b, err := json.Marshal(p)
  17.     if err != nil {
  18.         fmt.Println("json err ", err)
  19.     }
  20.     fmt.Println(string(b))
  22.     // 格式化输出
  23.     b, err = json.MarshalIndent(p, "", "     ")
  24.     if err != nil {
  25.         fmt.Println("json err ", err)
  26.     }
  27.     fmt.Println(string(b))
  28. }

struct tag

  1.     type Person struct {
  2.         //"-"是忽略的意思
  3.         Name  string `json:"-"`
  4.         Hobby string `json:"hobby" `
  5.     }

示例通过map生成json

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. func main() {
  9.     student := make(map[string]interface{})
  10.     student["name"] = "5lmh.com"
  11.     student["age"] = 18
  12.     student["sex"] = "man"
  13.     b, err := json.Marshal(student)
  14.     if err != nil {
  15.         fmt.Println(err)
  16.     }
  17.     fmt.Println(b)
  18. }
  • 解码json使用json.Unmarshal()函数可以对一组数据进行JSON格式的解码 
  1.     func Unmarshal(data []byte, v interface{}) error

示例解析到结构体

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. type Person struct {
  9.     Age       int    `json:"age,string"`
  10.     Name      string `json:"name"`
  11.     Niubility bool   `json:"niubility"`
  12. }
  14. func main() {
  15.     // 假数据
  16.     b := []byte(`{"age":"18","name":"5lmh.com","marry":false}`)
  17.     var p Person
  18.     err := json.Unmarshal(b, &p)
  19.     if err != nil {
  20.         fmt.Println(err)
  21.     }
  22.     fmt.Println(p)
  23. }

示例解析到interface

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. func main() {
  9.     // 假数据
  10.     // int和float64都当float64
  11.     b := []byte(`{"age":1.3,"name":"5lmh.com","marry":false}`)
  13.     // 声明接口
  14.     var i interface{}
  15.     err := json.Unmarshal(b, &i)
  16.     if err != nil {
  17.         fmt.Println(err)
  18.     }
  19.     // 自动转到map
  20.     fmt.Println(i)
  21.     // 可以判断类型
  22.     m := i.(map[string]interface{})
  23.     for k, v := range m {
  24.         switch vv := v.(type) {
  25.         case float64:
  26.             fmt.Println(k, "是float64类型", vv)
  27.         case string:
  28.             fmt.Println(k, "是string类型", vv)
  29.         default:
  30.             fmt.Println("其他")
  31.         }
  32.     }
  33. }

1.1.3. XML

  • 是可扩展标记语言，包含声明、根标签、子元素和属性
  • 应用场景：配置文件以及webService

示例：

  1.     <?xml version="1.0" encoding="UTF-8" ?>
  2.     <servers version="1">
  3.         <server>
  4.             <serverName>Shanghai_VPN</serverName>
  5.             <serverIP>127.0.0.1</serverIP>
  6.         </server>
  7.         <server>
  8.             <serverName>Beijing_VPN</serverName>
  9.             <serverIP>127.0.0.2</serverIP>
  10.         </server>
  11.     </servers>
  1. package main
  3. import (
  4.    "encoding/xml"
  5.    "fmt"
  6.    "io/ioutil"
  7. )
  9. // 抽取单个server对象
  10. type Server struct {
  11.    ServerName string `xml:"serverName"`
  12.    ServerIP   string `xml:"serverIP"`
  13. }
  15. type Servers struct {
  16.    Name    xml.Name `xml:"servers"`
  17.    Version int   `xml:"version"`
  18.    Servers []Server `xml:"server"`
  19. }
  21. func main() {
  22.    data, err := ioutil.ReadFile("D:/my.xml")
  23.    if err != nil {
  24.       fmt.Println(err)
  25.       return
  26.    }
  27.    var servers Servers
  28.    err = xml.Unmarshal(data, &servers)
  29.    if err != nil {
  30.       fmt.Println(err)
  31.       return
  32.    }
  33.    fmt.Printf("xml: %#v\n", servers)
  34. }

1.1.4. MSGPack

  • MSGPack是二进制的json，性能更快，更省空间
  • 需要安装第三方包：go get -u github.com/vmihailenco/msgpack 
  1. package main
  3. import (
  4.    "fmt"
  5.    "github.com/vmihailenco/msgpack"
  6.    "io/ioutil"
  7.    "math/rand"
  8. )
  10. type Person struct {
  11.    Name string
  12.    Age  int
  13.    Sex  string
  14. }
  16. // 二进制写出
  17. func writerJson(filename string) (err error) {
  18.    var persons []*Person
  19.    // 假数据
  20.    for i := 0; i < 10; i++ {
  21.       p := &Person{
  22.          Name: fmt.Sprintf("name%d", i),
  23.          Age:  rand.Intn(100),
  24.          Sex:  "male",
  25.       }
  26.       persons = append(persons, p)
  27.    }
  28.    // 二进制json序列化
  29.    data, err := msgpack.Marshal(persons)
  30.    if err != nil {
  31.       fmt.Println(err)
  32.       return
  33.    }
  34.    err = ioutil.WriteFile(filename, data, 0666)
  35.    if err != nil {
  36.       fmt.Println(err)
  37.       return
  38.    }
  39.    return
  40. }
  42. // 二进制读取
  43. func readJson(filename string) (err error) {
  44.    var persons []*Person
  45.    // 读文件
  46.    data, err := ioutil.ReadFile(filename)
  47.    if err != nil {
  48.       fmt.Println(err)
  49.       return
  50.    }
  51.    // 反序列化
  52.    err = msgpack.Unmarshal(data, &persons)
  53.    if err != nil {
  54.       fmt.Println(err)
  55.       return
  56.    }
  57.    for _, v := range persons {
  58.       fmt.Printf("%#v\n", v)
  59.    }
  60.    return
  61. }
  63. func main() {
  64.    //err := writerJson("D:/person.dat")
  65.    //if err != nil {
  66.    // fmt.Println(err)
  67.    // return
  68.    //}
  69.    err := readJson("D:/person.dat")
  70.    if err != nil {
  71.       fmt.Println(err)
  72.       return
  73.    }
  74. }