Golang自定义JSON序列化（是否存在类似于gob.register()的功能来处理JSON？）

huangapple
go评论115阅读模式
英文:

Golang custom JSON serialization (does something equivalent to gob.register() exist for json?)

问题

在使用JSON进行编码/解码时，是否有一种方法可以序列化自定义结构体？

假设你有3个（实际代码中有10个）不同的自定义结构体，它们将通过UDP进行发送，并且你使用JSON进行编码：

  1. type a struct {
  2.    Id   int
  3.    Data msgInfo
  4. }
  6. type b struct {
  7.    Id   	int
  8.    Data 	msgInfo
  9.    Other	metaInfo
  10. }
  12. type c struct {
  13.    Other	metaInfo
  14. }

在接收端，你想知道接收到的结构体是类型a、b还是c，这样可以将其传递给特定类型的通道。

  1. type msgtype reflect.Type
  3. ...
  5. nrOfBytes, err := udpConn.Read(recievedBytes)
  6. if err != nil {...}
  8. var msg interface{}
  9. err = json.Unmarshal(recievedBytes[0:nrOfBytes], &msg)
  10. if err != nil {...}
  12. u := reflect.ValueOf(msg)
  13. msgType := u.Type()
  14. fmt.Printf("msg is of type: %s\n", msgType)

使用gob可以很容易地实现这一点，只需注册类型即可。但由于使用UDP进行通信，所以必须使用JSON，那么有没有办法序列化自定义结构体呢？我希望打印结果是：

  1. msg is of type: a

但实际上我得到的是：

  1. msg is of type: map[string]interface {}
英文:

Is there a way to serialize custom structs when encoding/decoding with json?

say you have 3 (in my actual code there are 10) different custom structs which are being sent over udp, and you use json for encoding:

  1. type a struct {
  2.    Id   int
  3.    Data msgInfo
  4. }
  6. type b struct {
  7.    Id   	int
  8.    Data 	msgInfo
  9.    Other	metaInfo
  10. }
  12. type c struct {
  13.    Other	metaInfo
  14. }

On the recieving end you want to know if the struct recieved was of type a, b or c, so it can for example be passed to a type spesific channel.

  1. type msgtype reflect.Type
  3. .
  4. .
  6. nrOfBytes, err := udpConn.Read(recievedBytes)
  7. if err != nil {...}
  9. var msg interface{}
  10. err = json.Unmarshal(recievedBytes[0:nrOfBytes], &msg)
  11. if err != nil {...}
  13. u := reflect.ValueOf(msg)
  14. msgType := u.Type()
  15. fmt.Printf("msg is of type: %s\n", msgType)

With gob this is easily done by registering the types, but i have to use json seeing as it's communication over udp, so is there anyway to serialize the custom structs? I want the print to be

  1. msg is of type: a

but i'm only getting

  1. msg is of type: map[string]interface {}

答案1

得分: 2

你可以使用json.RawMessage类型和自定义的Wrapper类型来实现。然后，在接收到消息时，你可以使用switch语句（或使用构造函数的映射）来获取正确的结构体。

例如（省略错误检查）：

  1. package main
  3. import (
  4.     "encoding/json"
  5.     "fmt"
  6. )
  8. type Message struct {
  9.     Type string
  10.     Data json.RawMessage
  11. }
  13. func (m Message) Struct() interface{} {
  14.     unmarshaller, found := unmarshallers[m.Type]
  15.     if !found {
  16.         return nil
  17.     }
  18.     return unmarshaller([]byte(m.Data))
  19. }
  21. type Foo struct {
  22.     ID int
  23. }
  25. var unmarshallers = map[string]func([]byte) interface{}{
  26.     "foo": func(raw []byte) interface{} {
  27.         var f Foo
  28.         json.Unmarshal(raw, &f)
  29.         return f
  30.     },
  31. }
  33. func main() {
  34.     var body = []byte(`{"Type":"foo","Data":{"ID":1}}`)
  35.     var msg Message
  36.     json.Unmarshal(body, &msg)
  38.     switch s := msg.Struct().(type) {
  39.     case Foo:
  40.         fmt.Println(s)
  41.     }
  42. }

你可以在这个playground示例中查看实时演示：http://play.golang.org/p/7FmQqnWPaE

英文:

One thing you can do is using the json.RawMessage type and a custom Wrapper type.
Then, upon receiving a message, you can do a switch (or use a map of constructors) to get the right struct.

For example (omitting error checking):

  1. package main
  2.            
  3. import (   
  4.     "encoding/json"
  5.     "fmt"  
  6. )          
  7.            
  8. type Message struct {
  9.     Type string
  10.     Data json.RawMessage
  11. }          
  12.            
  13. func (m Message) Struct() interface{} {
  14.     unmarshaller, found := unmarshallers[m.Type]
  15.     if !found {
  16.         return nil
  17.     }      
  18.     return unmarshaller([]byte(m.Data))
  19. }          
  20.            
  21. type Foo struct {
  22.     ID int 
  23. }          
  24.            
  25. var unmarshallers = map[string]func([]byte) interface{}{
  26.     "foo": func(raw []byte) interface{} {
  27.         var f Foo
  28.         json.Unmarshal(raw, &f)
  29.         return f
  30.     },     
  31. }          
  32.            
  33. func main() {
  34.     var body = []byte(`{"Type":"foo","Data":{"ID":1}}`)
  35.     var msg Message
  36.     json.Unmarshal(body, &msg)
  37.            
  38.     switch s := msg.Struct().(type) {
  39.     case Foo:
  40.         fmt.Println(s)
  41.     }      
  42. }

See this playground example for a live demo http://play.golang.org/p/7FmQqnWPaE

答案2

得分: 0

根据你的评论，这可能是一个解决方案：

  1. type Packet struct {
  2.   Type string
  3.   Data []byte
  4. }
  6. // 编码函数
  7. func packageEncode(i interface{}) ([]byte, error) {
  8.   b, err := json.Marshal(i)
  9.   if err != nil {
  10.     return nil, err
  11.   }
  13.   p := &Packet{Data: b}
  14.   switch t := i.(type) {
  15.     case a:
  16.       p.Type = "a"
  17.     case b:
  18.       p.Type = "b"
  19.     case c:
  20.       p.Type = "c"
  21.   }
  22.   return json.Marshal(p)
  23. }
  25. // 当接收到消息并解码时
  26. p := &Packet{}
  27. err = json.Unmarshal(recievedBytes[0:nrOfBytes], p)
  28. ...
  29. if p.Type == "a" {
  30.   msg := &a{}
  31.   err = json.Unmarshal(p.Data, msg)
  32. }
  34. if p.Type == "b" {
  35.   ...
  36. }

请注意，我已经将代码中的&替换为了正确的&符号。

英文:

Base on your comment, this maybe a solution:

  1. type Packet {
  2.   Type string
  3.   Data []byte
  4. }

Encode function:

  1. func packageEncode(i interface{}) ([]byte, error) {
  2.   b, err := json.Marshal(i)
  3.   if err != nil {
  4.     return nil, err
  5.   }
  7.   p := &Package{Data: b}
  8.   switch t.(type) {
  9.     case a:
  10.       p.Type = "a"
  11.     case b:
  12.       p.Type = "b"
  13.     case c:
  14.       p.Type = "c"
  15.   }
  16.   return json.Marshal(p)
  17. }

Then, when recieved message and decode:

  1. p := &Package{}
  2. err = json.Unmarshal(recievedBytes[0:nrOfBytes], p)
  3. ...
  4. if p.Type == "a" {
  5.   msg := &a{}
  6.   err = json.Unmarshal(p.Data, msg)
  7. }
  9. if p.Type == "b" {
  10.   ...
  11. }

huangapple
  • 本文由 发表于 2016年4月7日 22:23:36
  • 转载请务必保留本文链接：https://go.coder-hub.com/36479128.html
  • go
  • json
  • serialization
  • udp
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定