go json序列化和反序列化

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式。易于阅读和编写。同时也是易于机器解析和生成。JSON能有效提升网络传输效率，通常程序在网络传输时会先将数据（结构体、map等）序列化成json字符串，到接收方得到json字符串时，在反序列化恢复成原本的数据类型（结构体、map等）。这种方式已然成为各个语言的标准。使用encoding/json包

1.json的序列化

介绍：json序列化是指，将有key-value结构的数据类型（比如结构体、map、切片）序列化成json字符串的操作。

package main

import (
    "encoding/json"
    "fmt"
)

//定义结构体
type Monster struct {
    //对于结构体的序列号，如果希望序列号后的key的名字重新定制，可以给struct字段指定一个tag标签
    //使用json标签 反射机制
    Name  string `json:"monster_name"`
    Age   int    `json:"monster_age"`
    Skill string `json:"monster_skill"`
}

//1.结构体序列化
func testStruct() {
    monster := Monster{
        Name:  "牛魔王",
        Age:   240,
        Skill: "牛魔拳",
    }
    //将monster序列化
    data, err := json.Marshal(monster)
    if err != nil {
        fmt.Printf("序列号错误:%v", err)
    }
    fmt.Printf("monster序列号后=%v\n", string(data))
}

//2.map序列化
func testMap() {
    var a map[string]interface{}
    //map需要先make一下
    a = make(map[string]interface{})
    a["name"] = "红孩儿"
    a["age"] = 30
    a["address"] = "洪崖洞"
    //将a序列化
    data, err := json.Marshal(a)
    if err != nil {
        fmt.Printf("序列号错误:%v", err)
    }
    fmt.Printf("monster序列号后=%v\n", string(data))
}

//slice序列化
func testSlice() {
    var slice []map[string]interface{}
    var m1 map[string]interface{}
    m1 = make(map[string]interface{})
    m1["name"] = "孙悟空"
    m1["age"] = 300
    m1["address"] = "水帘洞"
    slice = append(slice, m1)
    var m2 map[string]interface{}
    m2 = make(map[string]interface{})
    m2["name"] = "猪八戒"
    m2["age"] = 287
    m2["address"] = "高老庄"
    slice = append(slice, m2)
    //将a序列化
    data, err := json.Marshal(slice)
    if err != nil {
        fmt.Printf("序列号错误:%v", err)
    }
    fmt.Printf("monster序列号后=%v\n", string(data))
}

//对基本类型进行序列号没有多大意义
func testFloat64() {
    var num1 float64 = 236.76
    data, err := json.Marshal(num1)
    if err != nil {
        fmt.Printf("序列号错误:%v", err)
    }
    fmt.Printf("monster序列号后=%v\n", string(data))
}

func main() {
    testStruct()
    testMap()
    testSlice()
    testFloat64()
}

2.反序列化

反序列化是指，将json字符串反序列化成对应的数据类型（比如结构体、map、切片）的操作

1)在反序列化一个json字符串时，要确保反序列化后的数据类型和原来序列化前的数据类型一致。

2）如果json字符串是通过程序获取到的，则不需要再对"进行转义处理

//struct反序列化
func unmarshalStruct() {
    str := "{\"monster_name\":\"牛魔王\",\"monster_age\":240,\"monster_skill\":\"牛魔拳\"}"
    monster := Monster{}
    //json.Unmarshal中的参数str应该是[]byte类型
    //因为要修改monster的数值，所以用的是地址传递 指针类型
    err := json.Unmarshal([]byte(str), &monster)
    if err != nil {
        fmt.Printf("反序列号错误:%v", err)
    }
    fmt.Printf("monster反序列化后=%v，monster.Name=%v\n", monster)
}

//map反序列化
func unmarshalMap() {
    str := "{\"address\":\"洪崖洞\",\"age\":30,\"name\":\"红孩儿\"}"
    //str := "{\"Name\":\"牛魔王\",\"Age\":240,\"Skill\":\"牛魔拳\"}" //结构体用了json 标签后，这样写是错误的
    var a map[string]interface{}
    //反序列化map类型不需要make,可以直接使用,因为make操作被封装到unmarshal方法中了
    //json.Unmarshal中的参数str应该是[]byte类型
    //因为要修改a的数值，所以用的是地址传递 指针类型
    err := json.Unmarshal([]byte(str), &a)
    if err != nil {
        fmt.Printf("反序列号错误:%v", err)
    }
    fmt.Printf("map反序列化后=%v\n", a)
}

//slice反序列化
//map反序列化
func unmarshalSlice() {
    str := "[{\"address\":\"水帘洞\",\"age\":300,\"name\":\"孙悟空\"},{\"address\":\"高老庄\",\"age\":287,\"name\":\"猪八戒\"}]"
    //str := "{\"Name\":\"牛魔王\",\"Age\":240,\"Skill\":\"牛魔拳\"}" //结构体用了json 标签后，这样写是错误的
    var a []map[string]interface{}
    //反序列化map类型不需要make,可以直接使用,因为make操作被封装到unmarshal方法中了
    //json.Unmarshal中的参数str应该是[]byte类型
    //因为要修改a的数值，所以用的是地址传递 指针类型
    err := json.Unmarshal([]byte(str), &a)
    if err != nil {
        fmt.Printf("反序列号错误:%v", err)
    }
    fmt.Printf("[]map反序列化后=%v\n", a)
}
func main() {
    unmarshalStruct()
    unmarshalMap()
    unmarshalSlice()
}