为了让数据结构能够在网络中传输或保存到文件，它必须被编码后再解码。目前有多种可用的编码方式，比如JSON、XML、Google的Protocol Buffers等。
Gob（go binary）是Golang自己以二进制形式序列化和反序列化程序数据的格式，位于encoding/gob包中。类似于Python中的pickle和Java中Serialization。
-
gob可用于传递远端程序调用（RPC）的参数和结果。 -
encoding/gob包实现了高效地序列化，特别是数据结构负责的，比如结构体、数字、切片。 -
encoding/gob用于管理gob流，gob流是指在编码器（发送器，encoder）和解码器（接收器，decoder）之间交换的字节流数据。
Gob和JSON一样由发送端使用Encoder对数据结构进行编码，当接收端接收到消息后使用Decoder将序列化的数据转换为本地变量。
Golang可通过JSON或Gob来序列化Struct对象，虽然JSON的序列化更为通用，但利用Gob编码可以实现JSON所不能支持的Struct的方法序列化，利用Gob包序列化Struct保存到本地会十分简单。
Gob不是可外部定义且语言无关的编码方式，首选的是二进制格式，不像JSON或XML的文本格式。
Gob并不是一种不同于Go的语言，而是在编码和解码过程中用到Go的反射。
Gob可用于远程方法调用（RPC）参数和结果的传输，以及应用程序和机器之间的数据传输。
Gob只能用于纯Go环境中，例如两个使用Golang编写的服务之间的通信，以实现更加高效和优化。
Gob文件或流是完全自描述的，它里面包含的所有类型都有一个对应的描述，且都是可用Go语言解码，而无需了解文件的内容。
编码器 gob.NewEncoder
-
gob.NewEncoder接口参数w需实现io.Writer接口类型
func NewEncoder(w io.Writer) *Encoder {
enc := new(Encoder)
enc.w = []io.Writer{w}
enc.sent = make(map[reflect.Type]typeId)
enc.countState = enc.newEncoderState(new(encBuffer))
return enc
}
编码 encoder.Encode
func (enc *Encoder) Encode(e interface{}) error {
return enc.EncodeValue(reflect.ValueOf(e))
}
Gob序列化
Gob使用io.Writer接口会通过NewEncoder()函数创建Encoder对象，通过调用Encoder对象的Encode()方法实现编码操作。
创建结构体
type User struct{
Id int
Name string
}
编码序列化，结构体转换为bytes.Buffer，编码生成字节切片。
user := &User{Id:1, Name:"root"}
buf := new(bytes.Buffer)
encoder := gob.NewEncoder(buf)//创建编码器
err := encoder.Encode(user)//编码
if err!=nil {
panic(err)
}
fmt.Printf("%x\n", buf.Bytes())
22ff81030101045573657201ff820001020102496401040001044e616d65010c0000000bff8201020104726f6f7400
封装编码生成字节切片
func encode(obj interface{}) (*bytes.Buffer, error){
buf := new(bytes.Buffer)
encoder := gob.NewEncoder(buf)
err := encoder.Encode(obj)
if err!=nil{
return nil, err
}
return buf, err
}
编码生成字节缓存并保存到磁盘文件
//write gob序列化后写入文件
func write(data interface{}, filename string) (*bytes.Buffer, error){
buf := new(bytes.Buffer)
encoder := gob.NewEncoder(buf)
err := encoder.Encode(data)
if err!=nil{
return nil, err
}
err = ioutil.WriteFile(filename, buf.Bytes(), 0600)
if err!=nil{
return nil, err
}
return buf, err
}
创建Gob文件
要使用Gob，首先需要通过NewEncoder()方法创建一个编码器，并向其提供一系列数据，然后再接收端通过调用NewDecoder()方法创建一个解码器，从数据流中恢复数据并将其填入本地变量中。
//write gob序列化后写入文件
func write(data interface{}, filename string) error{
file,err := os.OpenFile(filename, os.O_RDWR | os.O_CREATE, 0777)
if err!=nil{
return err
}
defer file.Close()
encoder := gob.NewEncoder(file)
err = encoder.Encode(data)
if err!=nil{
return err
}
return nil
}
user := &User{Id:1, Name:"root"}
write(user, "user.gob")
解码器gob.NewDecoder
func NewDecoder(r io.Reader) *Decoder {
dec := new(Decoder)
// We use the ability to read bytes as a plausible surrogate for buffering.
if _, ok := r.(io.ByteReader); !ok {
r = bufio.NewReader(r)
}
dec.r = r
dec.wireType = make(map[typeId]*wireType)
dec.decoderCache = make(map[reflect.Type]map[typeId]**decEngine)
dec.ignorerCache = make(map[typeId]**decEngine)
dec.countBuf = make([]byte, 9) // counts may be uint64s (unlikely!), require 9 bytes
return dec
}
反序列化decoder.Decode
func (dec *Decoder) Decode(e interface{}) error {
if e == nil {
return dec.DecodeValue(reflect.Value{})
}
value := reflect.ValueOf(e)
// If e represents a value as opposed to a pointer, the answer won't
// get back to the caller. Make sure it's a pointer.
if value.Type().Kind() != reflect.Ptr {
dec.err = errors.New("gob: attempt to decode into a non-pointer")
return dec.err
}
return dec.DecodeValue(value)
}
//反序列化
reader := bytes.NewReader(bs.Bytes())
decoder := gob.NewDecoder(reader)
var u User
err = decoder.Decode(&u)
if err!=nil{
panic(err)
}
fmt.Println(u) //{1 root}
读取Gob文件
file,err := os.Open("user.gob")
if err!=nil{
panic(err)
}
decoder := gob.NewDecoder(file)
var user User
err = decoder.Decode(&user)
if err!=nil{
panic(err)
}
fmt.Println(user)//{1 root}
有疑问加站长微信联系（非本文作者）
