Apakah kaedah bersiri dalam golang?

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?

Definisi bersiri dan penyahserikatan

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.

Kaedah siri – Gob

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:

1 bytes.Buffer Taip

Pertama, 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)

2

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 Encode jika 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}

3. Nyahkod Penyahkod

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

Pakej siri –json

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

Nota

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.

Ralat: gob: jenis xxx tidak mempunyai medan yang dieksport

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

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视频教程、编程教学】

Atas ialah kandungan terperinci Apakah kaedah bersiri dalam golang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!