Quelles sont les méthodes de sérialisation dans Golang ?

Les méthodes de sérialisation Golang incluent : 1. Utilisez le package Gob pour gérer le flux gob est lié au type S'il s'avère qu'il y en a plus ou moins, il sera rempli ou tronqué selon l'ordre. 2. À l'aide du package json, vous pouvez implémenter le codage et le décodage JSON définis dans la RFC 7159 pendant le processus de sérialisation. Si les membres de la structure sont en minuscules, une erreur se produira. 3. En utilisant le package Binary, une conversion simple entre les nombres et les séquences d'octets ainsi que le codage et le décodage des variantes peuvent être réalisés. 4. Utilisez le protocole protobuf.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Dans le processus de programmation, nous devons toujours rencontrer le problème de la transmission de nos objets de données sur le réseau ou de leur enregistrement dans des fichiers, ce qui nécessite des actions d'encodage et de décodage.

Il existe actuellement de nombreux formats d'encodage : json, XML, Gob, Google Protocol Buffer, etc. En langage Go, comment encoder et décoder des données de cette manière ?

Définition de la sérialisation et de la désérialisation

La sérialisation (sérialisation) est le processus de conversion des informations d'état d'un objet en un formulaire qui peut être stocké ou transmis. Lors de la sérialisation, un objet écrit son état actuel dans un stockage temporaire ou persistant.

À votre tour, relisez la variable de la zone de stockage et recréez l'objet, qui est la désérialisation.

Dans le langage Go, le package encoding est spécifiquement conçu pour gérer ce type de problèmes d'encodage et de décodage de sérialisation.

Mode de sérialisation – Gob

Le package gob gère les flux gob – valeurs binaires échangées entre l'encodeur (expéditeur) et le décodeur (récepteur). Une utilisation typique consiste à transporter les paramètres et les résultats des appels de procédure distante (RPC), tels que le flux gobs utilisé dans le package "net/rpc". 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

Pour plus de détails, veuillez vous référer à la documentation : https://docs.studygolang.com/pkg/encoding/gob/

Son site officiel donne un exemple :

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

Le résultat en cours d'exécution est :

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

Personnellement, je Je pense que cet exemple est vrai. Bien. Nous voyons que les structures P et Q sont différentes. Nous voyons qu'il manque une variable Z à Q.

Cependant, il peut toujours être analysé lors du décodage. Cela montre que lors de l'utilisation de gob, il est lié en fonction du type. S'il s'avère qu'il y en a plus ou moins, il sera rempli ou. tronqué selon l'ordre. Ensuite, parlons de la façon d'encoder en détail :

1 type bytes.Buffer

Tout d'abord, nous devons définir un Le type bytes.Buffer est utilisé pour accepter les structures qui doivent être sérialisées. Ce type est comme ceci :

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

En utilisant l'exemple ci-dessus, vous pouvez voir que la sortie est :

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

🎜Vous pouvez voir, Buffer est un nombre binaire (8 bits par octet, jusqu'à 255)🎜🎜🎜🎜2. Encodage Après l'encodage🎜🎜🎜, effectuez l'encodage et la sérialisation sur le structure Encodage : 🎜

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]

🎜Ici, la première chose est d'obtenir l'objet *Encoder Après avoir obtenu l'objet, utilisez la méthode Encode du *Encoder<. /code> objet à encoder. 🎜🎜🎜Ici, il convient de noter que si <code>Encode est utilisé pour la programmation réseau, vous pouvez réellement envoyer des messages directement à l'autre partie sans avoir à effectuer une opération d'envoi de socket. 🎜🎜🎜Par exemple : Il y a du code du côté srever : 🎜

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

🎜Du côté client : 🎜rrreee🎜Sortie : 🎜rrreee🎜🎜🎜3. decoding🎜 🎜🎜Enfin, les étapes pour le décoder sont : 🎜rrreee🎜🎜🎜Méthode de sérialisation – json🎜🎜🎜Le paquet json implémente le RFC 7159</ Encodage et décodage <code>JSON défini dans le code>. Le mappage entre les valeurs JSON et Go est décrit dans la documentation des fonctions Marshal et Unmarshal. 🎜🎜Pour une introduction à ce package, voir "JSON and Go" : https://www.php.cn/link/241200d15bc67211b50bd10815259e58json/🎜🎜Un exemple est le suivant : 🎜rrreee

🎜 🎜Remarque🎜

🎜Pendant le processus de sérialisation, si les membres de la structure sont en minuscules, une erreur se produira. 🎜Les deux méthodes ci-dessus produiront de tels résultats🎜🎜🎜Nous prenons la sérialisation json comme exemple pour voir quel sera le résultat s'il est en minuscule : 🎜rrreee🎜Sortie : 🎜rrreee 🎜Nous voyons que le la partie minuscule ne sera pas sérialisée, c'est-à-dire qu'elle aura une valeur nulle. 🎜🎜Bien que cela ne signale pas d'erreur, ce n'est évidemment pas le résultat que nous souhaitons voir. 🎜🎜🎜🎜🎜Erreur : gob : type xxx n'a pas de champs exportés🎜🎜🎜Regardons un exemple qui signalera une erreur :🎜rrreee🎜Ce code signalera une erreur :🎜rrreee🎜🎜Rappelez-nous que la majuscule de la structure est très sensible ! ! ! 🎜🎜

序列化方式–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视频教程、编程教学】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!