Golang--序列化和反序列化方法

孙凌

2023-12-01

在编程过程中，我们总是要遇到这样的问题，就是将我们的数据对象要在网络中传输或保存到文件，这就需要对其编码和解码动作。

目前存在很多编码格式：json, XML, Gob, Google Protocol Buffer 等，在Go 语言中，如何对数据进行这样的编码和解码呢？

序列化和反序列化定义

序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。

反过来，把变量从从存储区中重新读取，重新创建该对象，则为反序列化。

在Go语言中，encoding 包就是专门来处理这类序列化的编码和解码的问题。

序列化方式–Gob

gob 包管理 gob 流–编码器（发送器）和解码器（接收器）之间交换的二进制值。一个典型的用途是传输远程过程调用（RPCs）的参数和结果，如 "net/rpc "包中就使用了gobs 流。

具体可以参考文档：https://docs.studygolang.com/pkg/encoding/gob/

他的官网给出了一个示例：

package main

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

type P struct {
	X, Y, Z int
	Name    string
}

type Q struct {
	X, Y *int32
	Name string
}

// This example shows the basic usage of the package: Create an encoder,
// transmit some values, receive them with a decoder.
func main() {
	// Initialize the encoder and decoder. Normally enc and dec would be
	// bound to network connections and the encoder and decoder would
	// run in different processes.
	var network bytes.Buffer        // Stand-in for a network connection  //Buffer是具有Read和Write方法的可变大小的字节缓冲区。
	enc := gob.NewEncoder(&network) // Will write to network.
	dec := gob.NewDecoder(&network) // Will read from network.

	// Encode (send) some values.
	err := enc.Encode(P{3, 4, 5, "Pythagoras"})
	if err != nil {
		log.Fatal("encode error:", err)
	}
	err = enc.Encode(P{1782, 1841, 1922, "Treehouse"})
	if err != nil {
		log.Fatal("encode error:", err)
	}

	// Decode (receive) and print the values.
	var q Q
	err = dec.Decode(&q)
	if err != nil {
		log.Fatal("decode error 1:", err)
	}
	fmt.Printf("%q: {%d, %d}\n", q.Name, *q.X, *q.Y)
	err = dec.Decode(&q)
	if err != nil {
		log.Fatal("decode error 2:", err)
	}
	fmt.Printf("%q: {%d, %d}\n", q.Name, *q.X, *q.Y)

}

运行结果是：

"Pythagoras": {3, 4}
"Treehouse": {1782, 1841}

个人认为这个例子是真的好。我们看到，结构体P 和 Q 是不同的，我们看到Q 少了一个 Z 变量。

但是，在解码的时候，仍然能解析得出来，这说明，使用 gob 时，是根据类型绑定的，如果发现多了或者少了，会依据顺序填充或者截断。

接下来，我们详情说说怎么编码吧：

1. `bytes.Buffer` 类型

首先，我们需要定义一个 bytes.Buffer 类型，用来承接需要序列化的结构体，这个类型是这样的：

// A Buffer is a variable-sized buffer of bytes with Read and Write methods.(Buffer是具有Read和Write方法的可变大小的字节缓冲区)
// The zero value for Buffer is an empty buffer ready to use.
type Buffer struct {
	buf      []byte // contents are the bytes buf[off : len(buf)]
	off      int    // read at &buf[off], write at &buf[len(buf)]
	lastRead readOp // last read operation, so that Unread* can work correctly.
}

使用上面的例子，可以看到输出是：

"Pythagoras": {3, 4} ==>
{[42 255 129 3 1 1 1 80 1 255 130 0 1 4 1 1 88 1 4 0 1 1 89 1 4 0 1 1 90 1 4 0 1 4 78 97 109 101 1 12 0 0 0 21 255 130 1 6 1 8 1 10 1 10 80 121 116 104 97 103 111 114 97 115 0] 0 0}

可以看到，Buffer 里，是二进制数（一个字节8个bit，最高255）

2. Encode 编码

之后，对需要编码序列化的结构体进行编码：

enc := gob.NewEncoder(&network) // Will write to network.
// Encode (send) some values.
if err := enc.Encode(P{3, 4, 5, "Pythagoras"}); err != nil {
	log.Fatal("encode error:", err)
}

这里，首先是要获得 *Encoder 对象，获得对象后，利用 *Encoder 对象的方法 Encode 进行编码。

这里，需要注意的是，Encode 如果是网络编程的，其实是可以直接发送消息给对方的，而不必进行 socket 的send 操作。

比如：在 srever 端有代码：

func main() {
	l, err := net.Listen("tcp", "127.0.0.1:8000")  //监听端口
	if err != nil {
		log.Fatal("net Listen() error is ", err)
	}

	p := P{
		1, 2, 3,
		"name"}

	conn, err := l.Accept()
	if err != nil {
		log.Fatal("net Accept() error is ", err)
	}
	defer func() { _ = conn.Close() }()
	//参数是conn 时，即可发出
	enc := gob.NewEncoder(conn)
	if err = enc.Encode(p); err != nil {  //发生结构体数据
		log.Fatal("enc Encode() error is ", err)
	}
}

在客户端client有：

func main() {
	conn,err := net.Dial("tcp","127.0.0.1:8000")
	if err != nil {
		log.Fatal("net Dial() error is ", err)
	}
	defer func() { _ = conn.Close() }()
	/**
	type Q struct {
		X, Y int
		Name string
	}
	 */
	var q Q
	dec := gob.NewDecoder(conn)
	if err = dec.Decode(&q); err != nil {
		log.Fatal("enc Encode() error is ", err)
	}
	fmt.Println(q)
}

输出：

{1 2 name}

3. Decode 解码

最后，对其解码的步骤为：

dec := gob.NewDecoder(&network) // Will read from network.
if err = dec.Decode(&q);err != nil {
	log.Fatal("decode error 2:", err)
}

序列化方式–json

json 包实现了 RFC 7159 中定义的 JSON 编码和解码。JSON和Go值之间的映射在 Marshal 和 Unmarshal 函数的文档中进行了描述。

有关此程序包的介绍，请参见“ JSON和Go”：https://docs.studygolang.com/pkg/encoding/json/

示例如下：

type Message struct {
	QQ      string
	Address string
}

type Student struct {
	Id   uint64 `json:"id"` //可以保证json字段按照规定的字段转义，而不是输出 Id
	Age  uint64 `json:"age"`
	Data []Message
}

func main() {
	m1 := Message{QQ: "123", Address: "beijing"}
	m2 := Message{QQ: "456", Address: "beijing"}
	s1 := Student{3, 19, append([]Message{}, m1, m2)}
	var buf []byte
	var err error

	if buf, err = json.Marshal(s1); err != nil {
		log.Fatal("json marshal error:", err)
	}

	fmt.Println(string(buf))

	var s2 Student
	if err = json.Unmarshal(buf, &s2); err != nil {
		log.Fatal("json unmarshal error:", err)
	}
	fmt.Println(s2)
}
//输出：
//{"id":3,"age":19,"Data":[{"QQ":"123","Address":"beijing"},{"QQ":"456","Address":"beijing"}]}
//{3 19 [{123 beijing} {456 beijing}]}

注意

在序列化的过程中，如果结构体内的成员是小写的，则会出现错误。以上两种方式，都会出现这样的结果

我们以 json 序列化为例子，看一下如果是小写的话，会出现什么样的结果：

package main

import (
	"encoding/json"
	"fmt"
	"log"
)

type Message struct {
	qq      string
	address string
}

type Student struct {
	Id   uint64 `json:"id"` //可以保证json字段按照规定的字段转义，而不是输出 Id
	Age  uint64 `json:"age"`
	Data []Message
}

func main() {
	m1 := Message{"123", "beijing"}
	m2 := Message{"456", "beijing"}
	s1 := Student{3, 19, append([]Message{}, m1, m2)}
	var buf []byte
	var err error

	if buf, err = json.Marshal(s1); err != nil {
		log.Fatal("json marshal error:", err)
	}

	fmt.Println(string(buf))

	var s2 Student
	if err = json.Unmarshal(buf, &s2); err != nil {
		log.Fatal("json unmarshal error:", err)
	}
	fmt.Println(s2)
}

输出：

{"id":3,"age":19,"Data":[{},{}]}
{3 19 [{ } { }]}

我们看到，小写的部分将不会被序列化到，也就是说，会是空值。

这个虽然不会报错，但是很明显，不是我们想要看到的结果。

报错：gob: type xxx has no exported fields

我们来看一个会报错的例子：

type Message struct {
	qq      string
	address string
}

type Student struct {
	Id   uint64 `json:"id"` //可以保证json字段按照规定的字段转义，而不是输出 Id
	Age  uint64 `json:"age"`
	Data []Message
}

func main() {
	m1 := Message{"123", "beijing"}
	m2 := Message{"456", "beijing"}
	s1 := Student{3, 19, append([]Message{}, m1, m2)}

	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)
	if err := enc.Encode(s1); err != nil {
		log.Fatal("encode error:", err) //报错
	}
	fmt.Println(string(buf.Bytes()))
}

这段代码会报错：

2020/12/30 16:44:47 encode error:gob: type main.Message has no exported fields

提醒我们注意，结构体的大小写是很敏感的！！！

序列化方式–Binary

Binary 包实现数字和字节序列之间的简单转换以及varint的编码和解码。

通过读取和写入固定大小的值来转换数字。固定大小的值可以是固定大小的算术类型（bool，int8，uint8，int16，float32，complex64等），也可以是仅包含固定大小值的数组或结构体。详情可参考：https://docs.studygolang.com/pkg/encoding/binary/#Write

示例：

package main

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

func main() {
	buf := new(bytes.Buffer)
	var pi int64 = 255

	err := binary.Write(buf, binary.LittleEndian, pi)
	if err != nil {
		fmt.Println("binary.Write failed:", err)
	}
	fmt.Println( buf.Bytes())
}
//输出：
[255 0 0 0 0 0 0 0]

这里需要注意：如果序列化的类型是 int 类型的话，将会报错：

binary.Write failed: binary.Write: invalid type int

而且，序列化的值是空的。

这是由于，他在前面已经解释清楚了，只能序列化固定大小的类型（bool，int8，uint8，int16，float32，complex64…），或者是结构体和固定大小的数组。

其他序列化方法

当然，go语言还有其他的序列化方法，如 protobuf 协议，参考：https://geektutu.com/post/quick-go-protobuf.html

Golang--序列化和反序列化方法

序列化和反序列化定义

序列化方式–Gob

1. `bytes.Buffer` 类型

2. Encode 编码

3. Decode 解码

序列化方式–json

注意

报错：gob: type xxx has no exported fields

序列化方式–Binary

其他序列化方法

相关阅读

相关文章

相关问答

相关文档

Golang--序列化和反序列化方法

序列化和反序列化定义

序列化方式–Gob

1. bytes.Buffer 类型

2. Encode 编码

3. Decode 解码

序列化方式–json

注意

报错：gob: type xxx has no exported fields

序列化方式–Binary

其他序列化方法

相关阅读

相关文章

相关问答

相关文档

1. `bytes.Buffer` 类型