Welche Serialisierungsmethoden gibt es in Golang?

Golang-Serialisierungsmethoden umfassen: 1. Verwenden Sie das Gob-Paket, um den Gob-Stream zu verwalten. Wenn mehr oder weniger vorhanden sind, wird er entsprechend der Reihenfolge gefüllt oder gekürzt. 2. Mit dem JSON-Paket können Sie die in RFC 7159 definierte JSON-Kodierung und -Dekodierung während des Serialisierungsprozesses implementieren. Wenn die Mitglieder in der Struktur klein geschrieben sind, tritt ein Fehler auf. 3. Mit dem Binary-Paket kann eine einfache Konvertierung zwischen Zahlen und Bytesequenzen sowie die Codierung und Decodierung von Varint erreicht werden. 4. Verwenden Sie das Protobuf-Protokoll.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Im Programmierprozess stoßen wir immer wieder auf das Problem, unsere Datenobjekte über das Netzwerk zu übertragen oder in Dateien zu speichern, was eine Kodierung und Dekodierung erfordert.

Derzeit gibt es viele Codierungsformate: JSON, XML, Gob, Google Protocol Buffer usw. Wie können Daten in der Go-Sprache auf diese Weise codiert und decodiert werden?

Definition von Serialisierung und Deserialisierung

Serialisierung (Serialisierung) ist der Prozess der Umwandlung der Statusinformationen eines Objekts in eine Form, die gespeichert oder übertragen werden kann. Bei der Serialisierung schreibt ein Objekt seinen aktuellen Zustand in den temporären oder dauerhaften Speicher.

Lesen Sie wiederum die Variable erneut aus dem Speicherbereich und erstellen Sie das Objekt neu, bei dem es sich um eine Deserialisierung handelt.

In der Go-Sprache ist das encoding-Paket speziell für die Behandlung dieser Art von Serialisierungskodierungs- und -dekodierungsproblemen konzipiert.

Serialisierungsmodus – Gob

gob-Paket verwaltet Gob-Streams – Binärwerte, die zwischen Encoder (Sender) und Decoder (Empfänger) ausgetauscht werden. Eine typische Verwendung ist der Transport von Parametern und Ergebnissen von Remote Procedure Calls (RPCs), wie zum Beispiel dem Gobs-Stream, der im Paket „net/rpc“ verwendet wird. 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://www.php.cn/link/241200d15bc67211b50bd10815259e58json/

示例如下：

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

Einzelheiten finden Sie in der Dokumentation: https://docs.studygolang.com/pkg/encoding/gob/

Seine offizielle Website gibt ein Beispiel:

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)
}

Das laufende Ergebnis ist:

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

Ich persönlich Ich denke, dieses Beispiel ist wahr. Gut. Wir sehen, dass die Strukturen P und Q unterschiedlich sind. Wir sehen, dass Q eine Z-Variable fehlt.

Es kann jedoch beim Dekodieren immer noch analysiert werden. Dies zeigt, dass es bei Verwendung von gob je nach Typ gebunden wird. Wenn festgestellt wird, dass mehr oder weniger vorhanden sind, wird es gefüllt oder je nach Reihenfolge gekürzt. Als nächstes sprechen wir über die Codierung im Detail:

1. bytes.Buffer Typ

Zuerst müssen wir einen Der Typ bytes.Buffer wird verwendet, um Strukturen zu akzeptieren, die serialisiert werden müssen:

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()))
}

Anhand des obigen Beispiels können Sie sehen, dass die Ausgabe lautet:

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

🎜Sie können sehen, Puffer ist eine Binärzahl (8 Bits pro Byte, bis zu 255)🎜🎜🎜🎜2. Kodieren Führen Sie nach der Kodierung🎜🎜🎜 die Kodierung und Serialisierung durch Struktur Kodierung: 🎜

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]

🎜Hier müssen Sie zunächst das Objekt *Encoder abrufen. Nachdem Sie das Objekt erhalten haben, verwenden Sie die Methode Encode des *Encoder Objekt zum Kodieren. 🎜🎜🎜Hier ist zu beachten, dass Sie bei Verwendung von <code>Encode für die Netzwerkprogrammierung tatsächlich Nachrichten direkt an die andere Partei senden können, ohne einen Socket-Sendevorgang durchführen zu müssen. 🎜🎜🎜Zum Beispiel: Es gibt Code auf der sreee-Seite: 🎜

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

🎜Auf der Client-Seite: 🎜rrreee🎜Ausgabe: 🎜rrreee🎜🎜🎜3. Dekodieren Dekodierung🎜 🎜🎜Abschließend sind die Schritte zum Dekodieren: 🎜rrreee🎜🎜🎜Serialisierungsmethode – json🎜🎜🎜json-Paket implementiert RFC 7159 <code>JSON-Kodierung und -Dekodierung im Code definiert>. Die Zuordnung zwischen JSON- und Go-Werten wird in der Dokumentation für die Funktionen Marshal und Unmarshal beschrieben. 🎜🎜Eine Einführung in dieses Paket finden Sie unter „JSON and Go“: https://www.php.cn/link/241200d15bc67211b50bd10815259e58json/🎜🎜Ein Beispiel lautet wie folgt: 🎜rrreee

🎜 🎜Hinweis🎜

🎜Wenn während des Serialisierungsprozesses die Mitglieder in der Struktur in Kleinbuchstaben geschrieben sind, tritt ein Fehler auf. 🎜Die beiden oben genannten Methoden führen zu solchen Ergebnissen🎜🎜🎜Wir nehmen die json-Serialisierung als Beispiel, um zu sehen, wie das Ergebnis aussieht, wenn es in Kleinbuchstaben geschrieben ist: 🎜rrreee🎜Ausgabe: 🎜rrreee 🎜Wir sehen, dass die Der kleingeschriebene Teil wird nicht serialisiert, d. h. es handelt sich um einen Nullwert. 🎜🎜Obwohl dies keinen Fehler meldet, ist es offensichtlich nicht das Ergebnis, das wir sehen möchten. 🎜🎜🎜🎜🎜Fehler: gob: Typ xxx hat keine exportierten Felder🎜🎜🎜Schauen wir uns ein Beispiel an, das einen Fehler meldet:🎜rrreee🎜Dieser Code meldet einen Fehler:🎜rrreee🎜🎜Erinnern Sie uns an die Großschreibung Die Struktur ist sehr empfindlich! ! ! 🎜🎜

序列化方式–Binary

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

通过读取和写入固定大小的值来转换数字。 固定大小的值可以是固定大小的算术类型（bool，int8，uint8，int16，float32，complex64等），也可以是仅包含固定大小值的数组或结构体。详情可参考：https://www.php.cn/link/241200d15bc67211b50bd10815259e58binary/#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

【相关推荐：Go视频教程、编程教学】

Das obige ist der detaillierte Inhalt vonWelche Serialisierungsmethoden gibt es in Golang?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!