我有一个客户端服务器应用程序,使用TCP连接

客户:

type Q struct {
    sum int64
}

type P struct {
    M, N int64
}

func main() {
    ...
    //read M and N
    ...
    tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
    ...
    var p P
    p.M = M
    p.N = N
    err = enc.Encode(p)
}

服务器:

type Q struct {
    sum int64
}

type P struct {
    M, N int64
}

func main() {
    ...
    tcpAddr, err := net.ResolveTCPAddr("ip4", service)
    listener, err := net.ListenTCP("tcp", tcpAddr)
    ...
    var connB bytes.Buffer
    dec …

gob 无法编码 map[string]interface{}

gob: type not registered for interface: map[string]interface {}

http://play.golang.org/p/Si4hd8I0JE

package main

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

func CloneObject(a, b interface{}) []byte {
    buff := new(bytes.Buffer)
    enc := gob.NewEncoder(buff)
    dec := gob.NewDecoder(buff)
    err := enc.Encode(a)
    if err != nil {
        log.Panic("e1: ", err)
    }
    b1 := buff.Bytes()
    err = dec.Decode(b)
    if err != nil {
        log.Panic("e2: ", err)
    }
    return b1
}

func main() {
    var a interface{}
    a = map[string]interface{}{"X": 1}
    b2, err := …

我正在尝试对包含Interface {}作为字段的结构进行解析和编码.

问题在于,编码工作正常,但如果我尝试将数据解码data为值得到{ <nil>}.

它实际上是有效的,如果我Data interface{}改为Data substring,但这不是我的解决方案,因为我想将查询的结果缓存到具有不同类型的数据库,具体取决于查询.(例如Users或Cookies)

最小的工作示例

资源

http://play.golang.org/p/aX7MIfqrWl

package main

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

type Data struct {
    Name string
    Data interface{}
}

type SubType struct {
    Foo string
}

func main() {
    // Encode
    encodeData := Data{
        Name: "FooBar",
        Data: SubType{Foo: "Test"},
    }
    mCache := new(bytes.Buffer)
    encCache := gob.NewEncoder(mCache)
    encCache.Encode(encodeData)

    fmt.Printf("Encoded: ")
    fmt.Println(mCache.Bytes())

    // Decode
    var data Data
    pCache := bytes.NewBuffer(mCache.Bytes())
    decCache := …

我将创建一个或多或少形式的结构:

type FileState struct {
    LastModified int64
    Hash string
    Path string
}

我想将这些值写入文件并在后续调用中读取它们.我最初的计划是使用密钥(Path)将它们读入地图并查找值(Hash和LastModified).在Go中有这样一种光滑的方式吗？

如果没有,您可以推荐哪种文件格式？我在以前的项目中读过并试验过一些键/值文件存储,但没有使用Go.现在,我的要求可能相当简单,因此大型数据库服务器系统会过度.我只想要一些我可以快速,轻松,便携地阅读和阅读的内容(Windows,Mac,Linux).因为我必须在多个平台上部署,所以我试图将我的非依赖性依赖性保持在最低限度.

我考虑过XML,CSV,JSON.我简单地看了Go中的gob包并注意到Go包仪表板上有一个BSON包,但我不确定是否适用.

我的主要目标是快速启动和运行,这意味着我需要编写的代码量最少,易于部署.

我正在寻找一个很好的解决方案,用于使用Go语言的UDP套接字进行客户端/服务器通信.

我在互联网上找到的例子告诉我如何将数据发送到服务器,但他们没有教导如何将它们发送回客户端.

为了演示,我的程序执行以下操作:

我的客户端程序在4444端口上创建一个套接字,如下所示:

con, err := net.Dial("udp", "127.0.0.1:4444")

我发送了一个字符串和本地地址到服务器,因此它可以打印字符串并发送OK消息.我正在使用gob:

enc := gob.NewEncoder(con)
enc.Encode(Data{"test", con.LocalAddr().String()})

我的Data结构如下所示:

type Data struct{
    Msg string
    Addr string
}

我的服务器侦听4444端口并正确解码Gob,但是如何发送OK消息？我正在使用客户端地址(在服务器.go文件上):

con, err := net.Dial("udp", data.Addr)

然后,我得到一个错误代码:

write udp 127.0.0.1:35290: connection refused

当客户端尝试连接到服务器的端口4444时,客户端会创建一个带有随机数的端口(在本例中为35290),以便它们可以进行通信.我知道我不应该将客户端的地址传递给服务器,但是conn.RemoteAddress()不起作用.发现客户地址的解决方案将是最受欢迎的.

Obs.:我知道有ReadFromUDP,所以我可以阅读包.我应该阅读它,发现客户的地址,并将数据发送到Gob,以便它可以解码吗？

我正在GO中编写一个应用程序,它使用encoding/gob在节点之间通过UDP发送结构和切片.它工作正常,但我注意到encoding/json也有类似的API.搜索并找到此信息(https://golang.org/pkg/encoding/):

gob Package gob管理gobs流 - 在编码器(发送器)和解码器(接收器)之间交换的二进制值.
json包json实现了RFC 4627中定义的JSON编码和解码.

有人可以向我解释一个人是否比另一个人更有效率,并且一般比较何时选择什么？另外如果我需要与非golang应用程序接口,我想json会更受欢迎？

我正在尝试解码我​​通过另一个 fasthttp 端点发送的 gob 输出并收到错误 Fasthttp 端点（通过 gob 编码 []string）----> Fasthttp 端点（接收和解码）

buffer := &bytes.Buffer{}
buffer  = ctx.PostBody()
backToStringSlice := []string{}  
gob.NewDecoder(buffer).Decode(&backToStringSlice)

我收到错误：ctx.PostBody() (type []byte) as type *bytes.Buffer in assignment

我如何转换[]byte为*bytes.Buffer.

任何帮助表示赞赏。

我的任务是将C++代码替换为Go,而我是Go API的新手.我使用gob将数百个键/值条目编码到磁盘页面,但gob编码有太多膨胀,不需要.

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
)
type Entry struct {
    Key string
    Val string
}

func main() {
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)
    e := Entry { "k1", "v1" }
    enc.Encode(e)
    fmt.Println(buf.Bytes())
}

这会产生很多我不需要的臃肿:

[35 255 129 3 1 1 5 69 110 116 114 121 1 255 130 0 1 2 1 3 75 101 121 1 12 0 1 3 86 97 108 1 12 0 0 0 11 255 130 1 2 …

我在用go 1.9.而且我想将对象的深度复制到另一个对象中.我尝试使用encoding/gob和encoding/json来完成它.但是gob编码需要比json编码更多的时间.我看到一些像这样的其他问题,他们建议gob编码应该更快.但我看到完全相反的行为.有人能告诉我,如果我做错了吗？或者比这两个更好更快的深度复制方法？我的对象的结构是复杂和嵌套的.

测试代码:

package main

import (
    "bytes"
    "encoding/gob"
    "encoding/json"
    "log"
    "time"

    "strconv"
)

// Test ...
type Test struct {
    Prop1 int
    Prop2 string
}

// Clone deep-copies a to b
func Clone(a, b interface{}) {

    buff := new(bytes.Buffer)
    enc := gob.NewEncoder(buff)
    dec := gob.NewDecoder(buff)
    enc.Encode(a)
    dec.Decode(b)
}

// DeepCopy deepcopies a to b using json marshaling
func DeepCopy(a, b interface{}) {
    byt, _ := json.Marshal(a)
    json.Unmarshal(byt, b)
}

func main() {
    i := 0 …

我定义了这些类型：

func init() {
    gob.RegisterName("MyMessageHeader", MyMessageHeader{})
    gob.RegisterName("OtherMsg", OtherMsg{})
}

//
// Messages
//

type MyMessageHeader struct {
    MessageId InstanceIdType
    OtherId   uint64
}

type MyMessage interface {
    Id() *MyMessageHeader
}

type otherStruct struct {
    X uint8
    Y uint8
}
type OtherMsg struct {
    MyMessageHeader
    OtherField *otherStruct
}


func (m *OtherMsg) Id() *MyMessageHeader {
    return &m.MyMessageHeader
}

func MarshalMessage(m MyMessage) ([]byte, error) {
    var buff bytes.Buffer
    encoder := gob.NewEncoder(&buff)
    if err := encoder.Encode(&m); err != nil {
        return nil, errors.Newf("Could not marshal …