golang的序列化与反序列化的几种方式

golang用来序列化的模块有很多，我们来介绍3个。

json

首先登场的是json，这个几乎毋庸置疑。

序列化

package main

import (
	"encoding/json"
	"fmt"
)

type Girl struct {
	Name string
	Age int
	Gender string
	Where string
	Is_married bool
}

func main() {
	g := Girl{"satori", 16, "f","东方地灵殿", false}

	//可以直接使用json.Marshal，但是打印出来不好看，这里加上缩进
	ret, err := json.MarshalIndent(g, "", " ")
	if err != nil {
		fmt.Println(err)
	} else {
		//得到的是字节数组，需要转化成string
		fmt.Println(string(ret))
		/*
		{
		 "Name": "satori",
		 "Age": 16,
		 "Gender": "f",
		 "Where": "东方地灵殿",
		 "Is_married": false
		}
		*/
	}
}

当然golang的大小写我们知道是具有含义的，如果改成小写， 那么该字段是无法被序列化的。但是这样序列化之后的字段，也是大写，如果我们就想要小写该怎么办呢？

package main

import (
	"encoding/json"
	"fmt"
)

type Girl struct {
	//使用`json:"xxx"`相当于起了一个别名xxx，以后序列化出来的字段就叫这个名字，
	Name string `json:"name"`
	Age int `json:"age"`
	Gender string `json:"gender"`
	Where string `json:"where"`
	Is_married bool `json:"is_married"`
}

func main() {
	g := Girl{"satori", 16, "f","东方地灵殿", false}

	ret, err := json.MarshalIndent(g, "", " ")
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(string(ret))
		/*
		{
		 "name": "satori",
		 "age": 16,
		 "gender": "f",
		 "where": "东方地灵殿",
		 "is_married": false
		}
		*/
	}
}

反序列化

package main

import (
	"encoding/json"
	"fmt"
)

type Girl struct {
	Name string `json:"name"`
	Age int `json:"age"`
	Gender string `json:"gender"`
	Where string `json:"where"`
	Is_married bool `json:"is_married"`
}

func main() {
	g := Girl{"satori", 16, "f","东方地灵殿", false}

	ret, err := json.MarshalIndent(g, "", " ")
	if err != nil {
		fmt.Println(err)
		return
	}

	//创建一个变量
	g2 := Girl{}
	//传入json字符串，和指针
	err = json.Unmarshal(ret, &g2)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(g2)  //{satori 16 f 东方地灵殿 false}
	fmt.Println(g2.Name, g2.Age) // satori 16
}

gob

标准库gob是golang提供的“私有”的编解码方式，它的效率会比json，xml等更高，特别适合在Go语言程序间传递数据。

序列化

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
)

type Girl struct {
	Name       string
	Age        int    `json:"age"`
	Gender     string `json:"gender"`
	Where      string `json:"where"`
	Is_married bool   `json:"is_married"`
}

func main() {
	g := Girl{"satori", 16, "f", "东方地灵殿", false}

	//创建缓存
	buf := new(bytes.Buffer)
	//把指针丢进去
	enc := gob.NewEncoder(buf)

	//调用Encode进行序列化
	if err := enc.Encode(g); err != nil {
		fmt.Println(err)
		return
	} else {
		//序列化的内容会被放进buf里面
		fmt.Println(buf.String())
		/*
		G��Girl�� Name Age Gender Where
		Is_married   !��satori f东方地灵殿
		*/
	}
}

发现是乱码，因为这类似python的pickle，是该语言独有的。所以我们不认识没关系，golang认识就行了

反序列化

package main

import (
	"bytes"
	"encoding/gob"
	"fmt"
)

type Girl struct {
	Name       string
	Age        int    `json:"age"`
	Gender     string `json:"gender"`
	Where      string `json:"where"`
	Is_married bool   `json:"is_married"`
}

func main() {
	g := Girl{"satori", 16, "f", "东方地灵殿", false}

	buf := new(bytes.Buffer)
	enc := gob.NewEncoder(buf)
	if err := enc.Encode(g);err != nil {
		fmt.Println(err)
		return
	}

	var g1 = Girl{}
	//bytes.NewBuffer和bytes.Buffer类似，只不过可以传入一个初始的byte数组，返回一个指针
	dec := gob.NewDecoder(bytes.NewBuffer(buf.Bytes()))
	//调用Decode方法,传入结构体对象指针，会自动将buf.Bytes()里面的内容转换成结构体
	if err := dec.Decode(&g1);err != nil {
		fmt.Println(err)
		return
	} else {
		fmt.Println(g1)  // {satori 16 f 东方地灵殿 false}
	}
}

msgpack

MessagePack是一种高效的二进制序列化格式。它允许你在多种语言(如JSON)之间交换数据。但它更快更小。

安装

go get -u github.com/vmihailenco/msgpack

序列化和反序列化

接口和json是一致的

package main

import (
	"fmt"
	"github.com/vmihailenco/msgpack"
)

type Girl struct {
	Name       string
	Age        int    `json:"age"`
	Gender     string `json:"gender"`
	Where      string `json:"where"`
	Is_married bool   `json:"is_married"`
}

func main() {
	g := Girl{"satori", 16, "f", "东方地灵殿", false}

	//这个没有MarshalIndent
	if ret, err := msgpack.Marshal(g); err != nil {
		fmt.Println(err)
		return
	} else {
		fmt.Println(string(ret))  //��Name�satori�Age�       �Gender�f�Where�东方地灵殿�Is_married�
		var g1 = Girl{}
		if err := msgpack.Unmarshal(ret, &g1);err!=nil {
			fmt.Println(err)
			return
		} else {
			fmt.Println(g1) // {satori 16 f 东方地灵殿 false}
		}
	}
}