Kaedah bersiri Golang ialah: 1. Gunakan pakej Gob untuk menguruskan aliran gob yang terikat dengan jenis Jika ada lebih atau kurang, ia akan diisi atau dipotong mengikut susunan. 2. Menggunakan pakej json, anda boleh melaksanakan pengekodan dan penyahkodan JSON yang ditakrifkan dalam RFC 7159 semasa proses bersiri, jika ahli dalam struktur adalah huruf kecil, ralat akan berlaku; 3. Menggunakan pakej Binari, penukaran mudah antara nombor dan jujukan bait serta pengekodan dan penyahkodan varian boleh dicapai. 4. Gunakan protokol protobuf.
Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.
Semasa proses pengaturcaraan, kami sentiasa menghadapi masalah menghantar objek data kami melalui rangkaian atau menyimpannya ke fail, yang memerlukan pengekodan dan penyahkodan.
Pada masa ini terdapat banyak format pengekodan: json, XML, Gob, Penampan Protokol Google, dll. Dalam bahasa Go, bagaimana untuk mengekod dan menyahkod data dengan cara ini?
Bersiri (Serialization) adalah untuk menukar maklumat keadaan objek kepada bentuk yang boleh disimpan atau dihantar proses. Semasa bersiri, objek menulis keadaan semasanya ke storan sementara atau berterusan.
Sebaliknya, membaca semula pembolehubah dari kawasan storan dan mencipta semula objek adalah penyahserialisasian.
Dalam bahasa Go, pakej pengekodan direka khusus untuk menangani isu pengekodan dan penyahkodan bersiri jenis ini.
gob Aliran gob pengurusan pakej – pengekod (penghantar) dan penyahkod (penerima) nilai binari ditukar antara. Penggunaan biasa adalah untuk mengangkut parameter dan hasil panggilan prosedur jauh (RPC), seperti aliran gobs yang digunakan dalam pakej "net/rpc".
Untuk butiran, sila rujuk dokumentasi: https://docs.studygolang.com/pkg/encoding/gob/
Laman web rasminya memberikan contoh:
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)
}Hasil larian ialah:
"Pythagoras": {3, 4}
"Treehouse": {1782, 1841}Secara peribadi, saya rasa contoh ini sangat bagus. Kami melihat bahawa struktur P dan Q adalah berbeza. Kami melihat bahawa Q tiada pembolehubah Z.
Walau bagaimanapun, ia masih boleh dihuraikan apabila menyahkod Ini menunjukkan bahawa apabila menggunakan gob, ia terikat mengikut jenis Jika didapati ada lebih atau kurang, ia akan diisi atau dipotong mengikut perintah.
Seterusnya, mari kita bincangkan tentang cara mengekod secara terperinci:
bytes.Buffer TaipPertama, kami Anda perlu menentukan jenis bytes.Buffer untuk menerima struktur yang perlu bersiri Jenis ini adalah seperti ini:
// 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.
}Menggunakan contoh di atas, anda boleh melihat bahawa outputnya ialah:
."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}Anda boleh melihat bahawa dalam Buffer, ia ialah nombor perduaan (bait mempunyai 8 bit, sehingga 255)
Selepas itu, kodkan struktur yang perlu dikodkan dan bersiri:
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)
}Di sini, perkara pertama ialah mendapatkan objek *Encoder Selepas memperoleh objek , gunakan kaedah *Encoder objekEncode Encode.
Di sini, perlu diperhatikan bahawa
Encodejika ia adalah pengaturcaraan rangkaian, anda sebenarnya boleh menghantar mesej terus kepada pihak lain tanpa melakukan operasi penghantaran soket.
Contohnya: Di sebelah srever terdapat kod:
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)
}
}Di sebelah klien terdapat:
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)
}Output:
{1 2 name}Akhir sekali, langkah untuk menyahkodnya ialah:
dec := gob.NewDecoder(&network) // Will read from network.
if err = dec.Decode(&q);err != nil {
log.Fatal("decode error 2:", err)
}json melaksanakan RFC 7159 pengekodan dan penyahkodan yang ditakrifkan dalam JSON. Pemetaan antara nilai JSON dan Go diterangkan dalam dokumentasi untuk fungsi Marshal dan Unmarshal.
Untuk pengenalan kepada pakej ini, lihat "JSON and Go": https://www.php.cn/link/241200d15bc67211b50bd10815259e58json/
Contohnya adalah seperti berikut:
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}]}Semasa proses bersiri, jika ahli dalam struktur menggunakan huruf kecil, ralat akan berlaku. Dua kaedah di atas akan menghasilkan hasil seperti itu
Mari kita ambil json siri sebagai contoh untuk melihat apakah hasilnya jika ia adalah huruf kecil:
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)
}Output:
{"id":3,"age":19,"Data":[{},{}]}
{3 19 [{ } { }]}Kami melihat bahawa bahagian huruf kecil tidak akan bersiri, iaitu, ia akan menjadi nilai nol.
Walaupun ini tidak akan melaporkan ralat, ia jelas bukan hasil yang kita mahu lihat.
Mari kita lihat contoh ralat:
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()))
}Kod ini akan melaporkan ralat:
2020/12/30 16:44:47 encode error:gob: type main.Message has no exported fields
Ingatkan kami bahawa struktur adalah sensitif huruf besar-besaran! ! !
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
Atas ialah kandungan terperinci Apakah kaedah bersiri dalam golang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Penggunaan kata kunci Jenis dalam Go
Cara melaksanakan senarai terpaut dalam go
Apakah perisian pengaturcaraan bahasa Go?
Bagaimana untuk belajar bahasa go dari 0 asas
Bagaimana untuk menentukan pembolehubah dalam golang
Apakah kaedah untuk melaksanakan lebihan beban operator dalam bahasa Go?
Apakah pengendali dalam bahasa Go?
Apakah kaedah penukaran data dalam golang?
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
