转: gob编解码

要让数据对象能在网络上传输或存储，我们需要进行编码和解码。现在比较流行的编码方式有JSON,XML等。然而，Go在gob包中为我们提供了另一种方式，该方式编解码效率高于JSON。gob是Golang包自带的一个数据结构序列化的编码/解码工具

源和目的地值/类型不需要完全对应。在接收变量中，但从发送类型或值丢失的字段将在目标中被忽略。如果在两个字段中都存在同名的字段，则它们的类型必须兼容。接收器和发送器都会做所有必要的间接和迂回，以在实际值和实际值之间转换。

struct { A, B int }
can be sent from or received into any of these Go types:

struct { A, B int } // the same
*struct { A, B int } // extra indirection of the struct
struct { *A, **B int } // extra indirection of the fields
struct { A, B int64 } // different concrete value type; see below
It may also be received into any of these:

struct { A, B int } // the same
struct { B, A int } // ordering doesn't matter; matching is by name
struct { A, B, C int } // extra field (C) ignored
struct { B int } // missing field (A) ignored; data will be dropped
struct { B, C int } // missing field (A) ignored; extra field (C) ignored.
Attempting to receive into these types will draw a decode error:

struct { A int; B uint } // change of signedness for B
struct { A int; B float } // change of type for B
struct { } // no field names in common
struct { C, D int } // no field names in common
例子：

package main

import (
"bytes"
"encoding/gob"
"fmt"
)

type Person struct {
Name string
Age int
Action Run
}

type Run struct {
Speed int
}

func main() {
var dao bytes.Buffer

var encoder = gob.NewEncoder(&dao)
var decoder = gob.NewDecoder(&dao)

p := Person{Name:"chen",Age:18,Action:Run{80}}

err := encoder.Encode(&p)
if err != nil{
panic(err)
}

fmt.Println(dao.String())

var d Person
err = decoder.Decode(&d)
if err != nil{
panic(err)
}

fmt.Println(d)
}
如果Encode/Decode类型是interface或者struct中某些字段是interface{}的时候，需要在gob中注册interface可能的所有实现或者可能类型，不然会报：panic: gob: type not registered for interface: main.Run错误

例子2 编解码的struct中某些字段是interface{}的时候

package main

import (
"encoding/gob"
"fmt"
"bytes"
)

func init() {
gob.Register(&Run{})//必须在encoding/gob编码解码前进行注册
}

//panic: gob: type not registered for interface: main.Run
type Person struct {
Name string
Age int
Action interface{}
}

type Run struct {
Speed int
}

func main() {
var dao bytes.Buffer

encoder := gob.NewEncoder(&dao)
decoder := gob.NewDecoder(&dao)

p := Person{Name:"chen",Age:18,Action:Run{80}}

err := encoder.Encode(&p)
if err != nil{
panic(err)
}

fmt.Println(dao.String())

var d Person
err = decoder.Decode(&d)
if err != nil{
panic(err)
}

fmt.Println(d)

}
例子3 编解码的类型是interface

package main

import (
"fmt"
"bytes"
"encoding/gob"
)

func init() {
gob.Register(&Person{})//必须在encoding/gob编码解码前进行注册
gob.Register(&Dog{})
}

type Actioner interface {
Action()
}

type Person struct {
Name string
}

type Dog struct {
Name string
}

func (p *Person)Action() {
fmt.Println("person action")
}

func (p *Dog)Action() {
fmt.Println("dog action")
}

func main() {
var dao bytes.Buffer

encoder := gob.NewEncoder(&dao)
decoder := gob.NewDecoder(&dao)

var action Actioner
action = &Person{"chen"}
err := encoder.Encode(&action)
if err != nil{
panic(err)
}
action = &Dog{"jok"}
err = encoder.Encode(&action)
if err != nil{
panic(err)
}

err = decoder.Decode(&action)
if err != nil{
panic(err)
}
fmt.Println(action)
action.Action()

err = decoder.Decode(&action)
if err != nil{
panic(err)
}

fmt.Println(action)
action.Action()
}
我们也可以将*bytes.Buffer换成*os.File，将编码后的对象写入磁盘存储

性能测试

下面进行一下简单的性能测试，测试一下gob和json的编解码性能。

gob：

package main

import (
"bytes"
"encoding/gob"
"fmt"
"time"
)

type Person struct {
Name string
Age int
Action Run
}

type Run struct {
Speed int
}
var dao bytes.Buffer

var encoder = gob.NewEncoder(&dao)
var decoder = gob.NewDecoder(&dao)

func Gob() {

p := Person{Name:"chen",Age:18,Action:Run{80}}

err := encoder.Encode(&p)
if err != nil{
panic(err)
}

//fmt.Println(dao.String())

var d Person
err = decoder.Decode(&d)
if err != nil{
panic(err)
}

//fmt.Println(d)
}

func main() {
now := time.Now()
start := now.UnixNano()
for i := 0; i < 10000; i++ {
Gob()
}
now2 := time.Now()
end := now2.UnixNano()
fmt.Println(end - start) //25016400
}
gob编解码循环10000次所需时间为25016400纳秒

json：

package main

import (
"encoding/json"
"fmt"
"time"
)

type Person struct {
Name string `json:"name"`
Age int `json:"age"`
Action Run `json:"action"`
}

type Run struct {
Speed int `json:"speed"`
}

func Json() {
p := Person{Name:"chen",Age:18,Action:Run{80}}

data,err := json.Marshal(p)
if err != nil{
panic(err)
}

//fmt.Println(string(data))

var d Person
err = json.Unmarshal(data,&d)
if err != nil{
panic(err)
}

//fmt.Println(d)
}

func main() {
now := time.Now()
start := now.UnixNano()
for i := 0; i < 10000; i++ {
Json()
}
now2 := time.Now()
end := now2.UnixNano()
fmt.Println(end - start) //45037200
}
json编解码循环10000次所需时间为45037200纳秒

总结：粗略的测试gob的性能大概是json的两倍左右