gob.Register方法的目的是什么？

Question

我已经阅读了( gob)的文档，我有一些问题：

现在我知道如何对结构进行编码和解码了：

func main() {
    s1 := &S{
        Field1: "Hello Gob",
        Field2: 999,
    }
    log.Println("Original value:", s1)
    buf := new(bytes.Buffer)
    err := gob.NewEncoder(buf).Encode(s1)
    if err != nil {
        log.Println("Encode:", err)
        return
    }

    s2 := &S{}
    err = gob.NewDecoder(buf).Decode(s2)
    if err != nil {
        log.Println("Decode:", err)
        return
    }
    log.Println("Decoded value:", s2)
}

但是我不知道这个方法的目的，gob.Register()，有人能给我解释一下什么时候用吗?为什么用？

Answer 1

如果你只处理具体的类型(结构)，你实际上并不需要它。一旦你处理了接口，你必须首先注册你的具体类型。

例如，让我们假设我们有这些结构和接口(结构实现了接口)：

type Getter interface {
    Get() string
}


type Foo struct {
    Bar string
}

func (f Foo)Get() string {
    return f.Bar
}

要通过gob将Foo作为Getter发送并解码回来，我们必须首先调用

gob.Register(Foo{})

因此，流程将是：

// init and register
buf := bytes.NewBuffer(nil)
gob.Register(Foo{})    


// create a getter of Foo
g := Getter(Foo{"wazzup"})

// encode
enc := gob.NewEncoder(buf)
enc.Encode(&g)

// decode
dec := gob.NewDecoder(buf)
var gg Getter
if err := dec.Decode(&gg); err != nil {
    panic(err)
}

现在尝试删除Register，这将不起作用，因为gob不知道如何将对象映射回其适当的类型。

Answer 2

正如http://golang.org/pkg/encoding/gob/#Register所说：

只需要注册将作为接口值的实现传输的类型。

所以你的演示不需要它。

Answer 3

如果您想对map interface {}进行编码/解码，由于map的字段被封装为接口类型，那么我们需要在此之前注册具体的类型。

package main

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

type SomeStruct struct {
    Text string
}

func main() {
    var bytes bytes.Buffer

    // Remove one of these, then the decoding will produce error
    gob.Register(SomeStruct{})
    gob.Register([]interface{}{})
    gob.Register([]SomeStruct{})
    gob.Register(map[string]SomeStruct{})

    writer := gob.NewEncoder(&bytes)

    err := writer.Encode(map[string]interface{}{
        "SomeStruct": SomeStruct{"Halo"},
        "SomeSlice":  []interface{}{},
        "SomeSliceStruct": []SomeStruct{
            {
                Text: "SomeText",
            },
        },
        "SomeMapStruct": map[string]SomeStruct{
            "S": {"Test"},
        },
    })
    if err != nil {
        log.Fatalf("Error on encode process: %v\n", err)
        return
    }

    reader := gob.NewDecoder(&bytes)
    var aMap map[string]interface{}
    err = reader.Decode(&aMap)
    if err != nil {
        log.Fatalf("Error on decode process: %v\n", err)
        return
    }

    fmt.Printf("Decode is successful: %+v\n", aMap)
}