gob是golang包自带的一个数据结构序列化的编码/解码工具。编码使用encoder，解码使用decoder。一种典型的应用场景就是rpc(remote procedure calls)。
gob和json的pack之类的方法一样，由发送端使用encoder对数据结构进行编码。在接收端收到消息之后，接收端使用decoder将序列化的数据变化成本地变量。
基本使用
package main
import (
"bytes"
"encoding/gob"
"fmt"
)
type msgdata struct {
x, y, z int
name string
}
var network bytes.buffer //网络传递的数据载体
func main() {
err := senmsg()
if err!=nil {
fmt.println("编码错误")
return
}
err = revmsg()
if err!=nil {
fmt.println("解码错误")
return
}
}
func senmsg()error {
fmt.print("开始执行编码（发送端）")
enc := gob.newencoder(&network)
sendmsg:=msgdata{3, 4, 5, "jiangzhou"}
fmt.println("原始数据：",sendmsg)
err := enc.encode(&sendmsg)
fmt.println("传递的编码数据为：",network)
return err
}
func revmsg()error {
var revdata msgdata
dec:=gob.newdecoder(&network)
err:= dec.decode(&revdata) //传递参数必须为 地址
fmt.println("解码之后的数据为：",revdata)
return err
}
register和registername
1、编码的数据中有空接口类型，传递时赋值的空接口为：基本类型（int、float、string）、切片时，可以不进行注册。
package main
import (
"bytes"
"encoding/gob"
"fmt"
)
type msgdata struct {
x, y, z int
name string
msg interface{}
}
var network bytes.buffer //网络传递的数据载体
func main() {
err := senmsg()
if err!=nil {
fmt.println("编码错误")
return
}
err = revmsg()
if err!=nil {
fmt.println("解码错误")
return
}
}
func senmsg()error {
fmt.print("开始执行编码（发送端）")
enc := gob.newencoder(&network)
s:=make([]string,0)
s=append(s, "hello")
//sendmsg:=msgdata{3, 4, 5, "jiangzhou",msg{10001,"hello"}}
//sendmsg:=msgdata{3, 4, 5, "jiangzhou",66.66}
sendmsg:=msgdata{3, 4, 5, "jiangzhou",s}
fmt.println("原始数据：",sendmsg)
err := enc.encode(&sendmsg)
fmt.println("传递的编码数据为：",network)
return err
}
func revmsg()error {
var revdata msgdata
dec:=gob.newdecoder(&network)
err:= dec.decode(&revdata) //传递参数必须为 地址
fmt.println("解码之后的数据为：",revdata)
return err
}
编码的数据中有空接口类型，传递时赋值的空接口为：map、struct时，必须进行注册。
package main
import (
"bytes"
"encoding/gob"
"fmt"
)
type msgdata struct {
x, y, z int
name string
msg interface{}
}
var network bytes.buffer //网络传递的数据载体
func main() {
err := senmsg()
if err!=nil {
fmt.println("编码错误")
return
}
err = revmsg()
if err!=nil {
fmt.println("解码错误")
return
}
}
func senmsg()error {
fmt.print("开始执行编码（发送端）")
enc := gob.newencoder(&network)
m:=make(map[int]string)
m[10001]="hello"
m[10002]="jiangzhou"
sendmsg:=msgdata{3, 4, 5, "jiangzhou",m}
fmt.println("原始数据：",sendmsg)
err := enc.encode(&sendmsg)
fmt.println("传递的编码数据为：",network)
return err
}
func revmsg()error {
var revdata msgdata
dec:=gob.newdecoder(&network)
err:= dec.decode(&revdata) //传递参数必须为 地址
fmt.println("解码之后的数据为：",revdata)
return err
}
register和registername解决的主要问题是：当编解码中有一个字段是interface{}（interface{}的赋值为map、结构体时）的时候需要对interface{}的可能产生的类型进行注册。
正确代码为：
interface{}的赋值为map时：
package main
import (
"bytes"
"encoding/gob"
"fmt"
)
type msgdata struct {
x, y, z int
name string
msg interface{}
}
var network bytes.buffer //网络传递的数据载体
func main() {
err := senmsg()
if err!=nil {
fmt.println("编码错误")
return
}
err = revmsg()
if err!=nil {
fmt.println("解码错误")
return
}
}
func senmsg()error {
fmt.print("开始执行编码（发送端）")
enc := gob.newencoder(&network)
m:=make(map[int]string)
m[10001]="hello"
m[10002]="jiangzhou"
gob.register(map[int]string{}) //todo：进行了注册
sendmsg:=msgdata{3, 4, 5, "jiangzhou",m}
fmt.println("原始数据：",sendmsg)
err := enc.encode(&sendmsg)
fmt.println("传递的编码数据为：",network)
return err
}
func revmsg()error {
var revdata msgdata
dec:=gob.newdecoder(&network)
err:= dec.decode(&revdata) //传递参数必须为 地址
fmt.println("解码之后的数据为：",revdata)
return err
}
interface{}的赋值为结构体时：
package main
import (
"bytes"
"encoding/gob"
"fmt"
)
type msgdata struct {
x, y, z int
name string
msg interface{}
}
var network bytes.buffer //网络传递的数据载体
func main() {
err := senmsg()
if err != nil {
fmt.println("编码错误",err)
return
}
err = revmsg()
if err != nil {
fmt.println("解码错误")
return
}
}
type msg struct {
id int
detail string
}
func senmsg() error {
fmt.print("开始执行编码（发送端）")
enc := gob.newencoder(&network)
gob.register(msg{}) //todo：进行了注册
s:=msg{10001,"hello jiangzhou"}
sendmsg := msgdata{3, 4, 5, "jiangzhou", s}
fmt.println("原始数据：", sendmsg)
err := enc.encode(&sendmsg)
fmt.println("传递的编码数据为：", network)
return err
}
func revmsg() error {
var revdata msgdata
dec := gob.newdecoder(&network)
err := dec.decode(&revdata) //传递参数必须为 地址
fmt.println("解码之后的数据为：", revdata)
return err
}
注：特别注意：以上代码中的结构体msg对应的成员变量名称首字母一定要大写，不然会出现：编码错误编码错误 gob: type main.msg has no exported fields
这里使用了
gob.register(msg{})
告诉系统：所有的interface是有可能为msg结构的。
在这个例子中，如果你注释了gob.register, 系统会报错。
registername是和register一样的效果，只是在register的同时也为这个类型附上一个别名。
补充：go语音gob包的系列化和反序列化使用和遇到的错误
encoding/gob包实现了高效的序列化，特别是数据结构较复杂的，结构体、数组和切片都被支持。
package main
import (
"bytes"
"encoding/gob"
"fmt"
)
//定义一个结构体
type person struct {
age int
name string
}
func main() {
p1:=person{
age: 18,
name: "贪吃的猪",
}
//序列化
//这里是储存的buffer
var bufferr bytes.buffer
perencod:=gob.newencoder(&bufferr) //1.创建一个编码器
err:=perencod.encode(&p1) //编码
if err != nil {
fmt.println("编码器 解码错误",err)
return
}
//现在buffer就是完成储存序列化的
fmt.printf("序列化:buf%x\n",bufferr)
//创建一个空的结构体来接受
p2 :=person{}
//反序列化
perdecod:=gob.newdecoder(bytes.newreader(bufferr.bytes()))//创建一个反编码器
err=perdecod.decode(&p2)
if err != nil {
fmt.println("perdecod.decode err:",err)
return
}
fmt.println("反序列化:",p2)
//fmt.printf("反序列化数据:string",p2)
}
系列化和反系列化的常见的错误
如果是你的结构体的字段是小写开头 gob序列化你的结构体的时候会找不到字段
如果我把
type person struct {
age int
name string
}
改成
type person struct {
age int
name string
}
编码器 解码错误 gob: type main.person has no exported fields
解决方法就是把字段开头变成大写
这个错误还有一种可能造成的 你定义的结构里面还有一个结构 2
这个结构2的字段全部都是小写开头
解决方法就是把字段开头变成大写
今天是2019年11月2日 11:32 我的一个改了半天的bug 终于解决
gob在编译的时候 如果你的这个结构体里面包含另一个结构体
但是另一个结构体的字段开头没有大写
gob编译的时候是不会报错,他会不要没有大写的字段,
你反序列化的时候会发现这个字段是nil 空值
我去你码的
今天是2019年11月4日,今天新的序列化bug出現了
我生成秘钥对然后对密钥对进行数据序列化然后储存在文件里面
然后错误提示,在, gob: type not registered for interface: elliptic.p256curve
其实gob是可以序列化全部结构,但是它不能序列化interface接口
因为接口的大小是无法定义的
密钥对的中的公钥结构体里面一个字段elliptic.curve 他是接口
我们把这个接口进行注册就行了
gob提供了一个函数可以进行注册
gob.register(elliptic.p256())
要gob遇到这个接口的时候按照elliptic.p256格式进行编译
然后就解决了~
以上为个人经验，希望能给大家一个参考，也希望大家多多支持www.887551.com。如有错误或未考虑完全的地方，望不吝赐教。
