go语言中可以使用"encoding/json" 包对数据进行json的序列化和反序列化。

一般是对具有key-value这种格式的数据进行json转换。比如：struct、map，切片。

1.1.1. 一、示例如下：

1、对结构体struct实例序列化。

type Student struct {
    Name string
    Age int
}
func main() {
    stu := Student{
        Name:"张三",
        Age:15,
    }
    // 转换为json
    stuJsonByte, error:=json.Marshal(&stu) // 引用传递，避免拷贝结构体

    if  error != nil{
        fmt.Println("json序列化错误。。")
        return
    }

    // {"Name":"张三","Age":15}
    fmt.Println(string(stuJsonByte))
}

主要代码：stuJsonByte, error:=json.Marshal(&stu)// 引用传递，避免拷贝结构体

2、对map序列化。

func main()  {
    //定义一个 map，值为空接口interface{}类型，可以放任何数据
    var a map[string]interface{}
    //使用 map,需要 make
    a = make(map[string]interface{})
    a["name"] = "红孩儿"
    a["age"] = 30
    a["address"] = "洪崖洞"

    //json序列化
    data, err := json.Marshal(a)
    if err != nil {
        fmt.Printf("序列化错误 err=%v\n", err)
    }

    //序列化后={"address":"洪崖洞","age":30,"name":"红孩儿"}
    fmt.Printf("序列化后=%v\n", string(data))
}

主要代码还是：data, err := json.Marshal(a)

3、对切片（集合）序列化。

func main()  {
    var mapSlice []map[string]interface{}

    //定义一个 map，值为空接口interface{}类型，可以放任何数据
    var a map[string]interface{}
    //使用 map,需要 make
    a = make(map[string]interface{})
    a["name"] = "红孩儿"
    a["age"] = 30
    mapSlice = append(mapSlice, a) // 把数据添加到切片

    var b map[string]interface{} = make(map[string]interface{})
    b["name"] = "张三"
    b["age"] = 24
    mapSlice = append(mapSlice, b) // 把数据添加到切片


    //json序列化
    data, err := json.Marshal(mapSlice)
    if err != nil {
        fmt.Printf("序列化错误 err=%v\n", err)
    }

    //序列化后=[{"age":30,"name":"红孩儿"},{"age":24,"name":"张三"}]
    fmt.Printf("序列化后=%v\n", string(data))
}

主要代码还是：data, err := json.Marshal(mapSlice)

4、基本数据类型序列化。

基本数据类型json序列化不会出错，但是也没有意义。结果就是原来的值。

    var num1 float64 = 2345.67

    //json序列化
    data, err := json.Marshal(num1)
    if err != nil {
        fmt.Printf("序列化错误 err=%v\n", err)
    }
    //序列化后=2345.67
    fmt.Printf("序列化后=%v\n", string(data))

1.1.2. 二、用tag改变序列化后key的名字。

对于结构体的序列化，可以给struct 指定一个 tag 标签 ，改变序列化后的key 的名字。

type Student struct {
    Name string `json:"stu_name"`
    Age int `json:"stu_age"`
}
func main() {
    stu := Student{
        Name:"张三",
        Age:15,
    }
    // 转换为json
    stuJsonByte, error:=json.Marshal(&stu) // 引用传递，避免拷贝结构体

    if  error != nil{
        fmt.Println("json序列化错误。。")
        return
    }

    // key改变为tag里面指定的名字。 {"stu_name":"张三","stu_age":15}
    fmt.Println(string(stuJsonByte))
}

输出结果为：{"stu_name":"张三","stu_age":15}，key改变为tag里面指定的名字。

1.1.3. 三、字段名首字母小写时。序列化和反序列化都将忽略这个字段。

如果Student结构体定义时，某个字段（比如：name）首字母小写，那在json包中就访问不到这个字段，这时候序列化和反序列化都会忽略这个字段。

type Student struct {
    name string
    Age int `json:"stu_age"`
}

// 序列化函数
func Serialize()  {
    stu := Student{
        name:"张三",
        Age:23,
    }
    stuJsonBytes, err := json.Marshal(&stu)
    if  err != nil{
        fmt.Println("序列化错误。。")
        return
    }
    // 序列化结果。。 {"stu_age":23}
    fmt.Println("序列化结果。。",string(stuJsonBytes))
}

// 反序列化函数
func Deserialize()  {
    str := `{"name":"张三","stu_age":23}`
    var stu2 Student
    // 反序列化json
    error:=json.Unmarshal([]byte(str),&stu2)

    if  error != nil{
        fmt.Println("json反序列化错误。。")
        return
    }
    // 反序列化结果。。。 { 23}
    fmt.Println("反序列化结果。。。",stu2)
}


func main() {
    Serialize()
    Deserialize()
}