Golang Gob编码

简介:

gob是Golang包自带的一个数据结构序列化的编码/解码工具。编码使用Encoder,解码使用Decoder。一种典型的应用场景就是RPC(remote procedure calls)。

gob和json的pack之类的方法一样,由发送端使用Encoder对数据结构进行编码。在接收端收到消息之后,接收端使用Decoder将序列化的数据变化成本地变量。

 

有一点需要注意,

发送方的结构和接受方的结构并不需要完全一致

结构体中缺省的字段将不会被发送。而且在接收方,并不需要所有的字段都要有对应的结构属性对应。godoc中的这个例子很形象:

clip_image001

当发送方传递的是struct{A, B int}结构的值的时候,接收方可以允许前9种结构,但是后面4种结构确实不允许的。

 

个人觉得这种设定是很符合逻辑的:接收端只接受和发送数据“相似”的数据结构。允许模拟相似,但是不允许矛盾。

 

各个类型的编解码规则

整型:分为sign int和usign int, 其中从上面例子也看到,int和uint是不能互相编解码的。float和int也是不能互相编解码的。

Struct,array,slice是可以被编码的。但是function和channel是不能被编码的。

bool类型是被当作uint来编码的,0是false,1是true。

浮点类型的值都是被当作float64类型的值来编码的

String和[]byte传递是uint(byte个数) + byte[]的形式编码的

Slice和array是按照uint(array个数) + 每个array编码 这样的形式进行编码的

Maps是按照 uint(Map个数) + 键值对 这样的形式进行编码的

 

Struct是按照一对对(属性名 + 属性值)来进行编码的。其中属性值是其自己对应的gob编码。前面说过,如果有一个属性值为0或空,则这个属性直接被忽略。每个属性的序号是由编码时候顺序决定的,从0开始顺序递增。Struct在序列化前会以-1代表序列化的开始,以0代表序列化结束。即Struct的序列化是按照 “-1 (0 属性1名字 属性1值) (1 属性2名字 属性2值) 0 ”来进行编码的。

 

非常重要的一点:

Struct中的属性应该是public的,即应该是大写字母开头。

这样才能被包外的函数访问!!(谢谢TreapDB提醒)

Gob提供的函数

clip_image002

 

Encode和Decode

对于Encoder和Decoder可以看这个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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
}
 
func main() {
     var  network bytes.Buffer       
     enc := gob.NewEncoder(&network)
     dec := gob.NewDecoder(&network)
     // Encode (send) the value.
     err := enc.Encode(P{3, 4, 5,  "Pythagoras" })
     if  err != nil {
         log.Fatal( "encode error:" , err)
     }
     // Decode (receive) the value.
     var  q Q
     err = dec.Decode(&q)
     if  err != nil {
         log.Fatal( "decode error:" , err)
     }
     fmt.Println(q)
     fmt.Printf( "%q: {%d,%d}\n" , q.Name, *q.X, *q.Y)
 
}

所有Encoder和Decoder的构造函数都有一个io结构,需要制定你将使用哪个io进行编码解码的传输。

这个代码要注意几个地方:

1 P和Q是两个结构体,应该说是“相似”的两个结构体

2 Encode是将结构体传递过来,但是Decode的函数参数却是一个pointer!

这点在godoc中有说:

f e is nil, the value will be discarded. Otherwise, the value underlying e must be a pointer to the correct type for the next data item received.

Decode的参数如果不是nil,那就一定是一个指针了。

3 如果你将Encode传入一个pointer,即

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
func main() {
     var  network bytes.Buffer         // Stand-in for a network connection
     enc := gob.NewEncoder(&network)  // Will write to network.
     dec := gob.NewDecoder(&network)  // Will read from network.
     // Encode (send) the value.
     err := enc.Encode(&P{3, 4, 5,  "Pythagoras" })
     if  err != nil {
         log.Fatal( "encode error:" , err)
     }
     // Decode (receive) the value.
     var  q Q
     err = dec.Decode(&q)
     if  err != nil {
         log.Fatal( "decode error:" , err)
     }
     fmt.Println(q)
     fmt.Printf( "%q: {%d,%d}\n" , q.Name, *q.X, *q.Y)
 
 
}

这个function也是没有问题的。

Register和RegisterName

这两个方法是当编解码中有一个字段是interface{}的时候需要对interface{}的可能产生的类型进行注册。具体就看一下下面这个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main
 
import (
     "bytes"
     "encoding/gob"
     "fmt"
     "log"
)
 
type P  struct  {
     X, Y, Z  int
     Name     interface {}
}
 
type Q  struct  {
     X, Y *int32
     Name  interface {}
}
 
type Inner  struct  {
     Test  int
}
 
func main() {
     var  network bytes.Buffer         // Stand-in for a network connection
     enc := gob.NewEncoder(&network)  // Will write to network.
     dec := gob.NewDecoder(&network)  // Will read from network.
     
     gob.Register(Inner{})
     
     // Encode (send) the value.
     inner := Inner{1}
     err := enc.Encode(P{1,2,3, inner})
     if  err != nil {
         log.Fatal( "encode error:" , err)
     }
     // Decode (receive) the value.
     var  q Q
     err = dec.Decode(&q)
     if  err != nil {
         log.Fatal( "decode error:" , err)
     }
     fmt.Println(q)
     fmt.Printf( "%q: {%d,%d}\n" , q.Name, *q.X, *q.Y)
 
 
}

这里使用了gob.Register(Inner{})告诉系统:所有的Interface是有可能为Inner结构的。

在这个例子中,如果你注释了gob.Register, 系统会报错。

RegisterName是和Register一样的效果,只是在Register的同时也为这个类型附上一个别名。

 

GebEncoder和GobDecoder

这是两个接口,如果你的数据结构实现了这两个接口,当调用encoder.Encode和decoder.Decode的时候就会调用这两个结构的对应函数

看一下下面这个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package main
 
import (
     "bytes"
     "encoding/gob"
     "fmt"
     "log"
)
 
type P  struct  {
     X, Y, Z  int
     Name     string
}
 
func ( this  *P)GobEncode() ([] byte , error) {
     return  [] byte {},nil
}
 
type Q  struct  {
     X, Y *int32
     Name  string
}
 
func main() {
     var  network bytes.Buffer       
     enc := gob.NewEncoder(&network)
     dec := gob.NewDecoder(&network)
     // Encode (send) the value.
     err := enc.Encode(P{3, 4, 5,  "Pythagoras" })
     if  err != nil {
         log.Fatal( "encode error:" , err)
     }
     // Decode (receive) the value.
     var  q Q
     err = dec.Decode(&q)
     if  err != nil {
         log.Fatal( "decode error:" , err)
     }
     fmt.Println(q)
     fmt.Printf( "%q: {%d,%d}\n" , q.Name, *q.X, *q.Y)
 
}

这里我的P实现了GobEncoder接口,因此在enc.Encode的时候会调用func (this *P)GobEncode() ([]byte, error)

当然我这个函数直接返回的是空byte,因此在解码的时候会报错:decode error:gob: type mismatch in decoder: want struct type main.Q; got non-struct

这两个接口暴露出来就代表你为自己定义的结构进行编解码规则制定。当然,如果使用自己的编解码规则,在编码和解码的过程就需要是一对的

后记

gob包是golang提供的“私有”的编解码方式,文档中也说了它的效率会比json,xml等更高(虽然我也没有验证)。因此在两个Go 服务之间的相互通信建议不要再使用json传递了,完全可以直接使用gob来进行数据传递。

目录
相关文章
|
6月前
|
Go
Go to Learn Go之Gob
Go to Learn Go之Gob
38 8
|
JSON Java Go
Go内置序列化库 - gob
Go内置序列化库 - gob
|
Go
golang - gob与rpc
  今天和大家聊聊golang中怎么使用rpc,rpc数据传输会涉及到gob编码,所以先讲讲gob,别担心,就算你完全没有接触过gob与rpc,只要知道rpc的中文是远程过程调用,剩下的我都能给你讲明白(带你入门不包你精通)! 一、数据结构编码之gob   gob全称为:Go binary   Golang自带的一个数据结构序列化编码/解码工具,也就是说gob可以讲go中的一个数据结构序列化成某种东西,还能反序列化!序列化成啥我们后面来看,不管是变成一个字符串,变成二进制流,变成啥先不管,反正作用就是序列化。
2126 0
|
14天前
|
运维 监控 算法
监控局域网其他电脑:Go 语言迪杰斯特拉算法的高效应用
在信息化时代,监控局域网成为网络管理与安全防护的关键需求。本文探讨了迪杰斯特拉(Dijkstra)算法在监控局域网中的应用,通过计算最短路径优化数据传输和故障检测。文中提供了使用Go语言实现的代码例程,展示了如何高效地进行网络监控,确保局域网的稳定运行和数据安全。迪杰斯特拉算法能减少传输延迟和带宽消耗,及时发现并处理网络故障,适用于复杂网络环境下的管理和维护。
|
15天前
|
编译器 Go
揭秘 Go 语言中空结构体的强大用法
Go 语言中的空结构体 `struct{}` 不包含任何字段,不占用内存空间。它在实际编程中有多种典型用法:1) 结合 map 实现集合(set)类型;2) 与 channel 搭配用于信号通知;3) 申请超大容量的 Slice 和 Array 以节省内存;4) 作为接口实现时明确表示不关注值。此外,需要注意的是,空结构体作为字段时可能会因内存对齐原因占用额外空间。建议将空结构体放在外层结构体的第一个字段以优化内存使用。
|
15天前
|
存储 缓存 安全
Go 语言中的 Sync.Map 详解:并发安全的 Map 实现
`sync.Map` 是 Go 语言中用于并发安全操作的 Map 实现,适用于读多写少的场景。它通过两个底层 Map(`read` 和 `dirty`)实现读写分离,提供高效的读性能。主要方法包括 `Store`、`Load`、`Delete` 等。在大量写入时性能可能下降,需谨慎选择使用场景。
|
15天前
|
存储 缓存 监控
企业监控软件中 Go 语言哈希表算法的应用研究与分析
在数字化时代,企业监控软件对企业的稳定运营至关重要。哈希表(散列表)作为高效的数据结构,广泛应用于企业监控中,如设备状态管理、数据分类和缓存机制。Go 语言中的 map 实现了哈希表,能快速处理海量监控数据,确保实时准确反映设备状态,提升系统性能,助力企业实现智能化管理。
29 3
|
16天前
|
SQL 安全 Java
阿里双十一背后的Go语言实践:百万QPS网关的设计与实现
解析阿里核心网关如何利用Go协程池、RingBuffer、零拷贝技术支撑亿级流量。 重点分享: ① 如何用gRPC拦截器实现熔断限流; ② Sync.Map在高并发读写中的取舍。
|
17天前
|
存储 算法 安全
基于 Go 语言的公司内网管理软件哈希表算法深度解析与研究
在数字化办公中,公司内网管理软件通过哈希表算法保障信息安全与高效管理。哈希表基于键值对存储和查找,如用户登录验证、设备信息管理和文件权限控制等场景,Go语言实现的哈希表能快速验证用户信息,提升管理效率,确保网络稳定运行。
27 0
|
19天前
|
开发框架 前端开发 Go
eino — 基于go语言的大模型应用开发框架(二)
本文介绍了如何使用Eino框架实现一个基本的LLM(大语言模型)应用。Eino中的`ChatModel`接口提供了与不同大模型服务(如OpenAI、Ollama等)交互的统一方式,支持生成完整响应、流式响应和绑定工具等功能。`Generate`方法用于生成完整的模型响应,`Stream`方法以流式方式返回结果,`BindTools`方法为模型绑定工具。此外,还介绍了通过`Option`模式配置模型参数及模板功能,支持基于前端和用户自定义的角色及Prompt。目前主要聚焦于`ChatModel`的`Generate`方法,后续将继续深入学习。
165 7