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

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:

type a struct {
   Id   int
   Data msgInfo
}

type b struct {
   Id   	int
   Data 	msgInfo
   Other	metaInfo
}

type c struct {
   Other	metaInfo
}

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.

type msgtype reflect.Type

.
.

nrOfBytes, err := udpConn.Read(recievedBytes)
if err != nil {...}

var msg interface{}
err = json.Unmarshal(recievedBytes[0:nrOfBytes], &msg)
if err != nil {...}

u := reflect.ValueOf(msg)
msgType := u.Type()
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

msg is of type: a

but i'm only getting

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

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):

package main
           
import (   
    "encoding/json"
    "fmt"  
)          
           
type Message struct {
    Type string
    Data json.RawMessage
}          
           
func (m Message) Struct() interface{} {
    unmarshaller, found := unmarshallers[m.Type]
    if !found {
        return nil
    }      
    return unmarshaller([]byte(m.Data))
}          
           
type Foo struct {
    ID int 
}          
           
var unmarshallers = map[string]func([]byte) interface{}{
    "foo": func(raw []byte) interface{} {
        var f Foo
        json.Unmarshal(raw, &f)
        return f
    },     
}          
           
func main() {
    var body = []byte(`{"Type":"foo","Data":{"ID":1}}`)
    var msg Message
    json.Unmarshal(body, &msg)
           
    switch s := msg.Struct().(type) {
    case Foo:
        fmt.Println(s)
    }      
}

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

Base on your comment, this maybe a solution:

type Packet {
  Type string
  Data []byte
}

Encode function:

func packageEncode(i interface{}) ([]byte, error) {
  b, err := json.Marshal(i)
  if err != nil {
    return nil, err
  }

  p := &Package{Data: b}
  switch t.(type) {
    case a:
      p.Type = "a"
    case b:
      p.Type = "b"
    case c:
      p.Type = "c"
  }
  return json.Marshal(p)
}

Then, when recieved message and decode:

p := &Package{}
err = json.Unmarshal(recievedBytes[0:nrOfBytes], p)
...
if p.Type == "a" {
  msg := &a{}
  err = json.Unmarshal(p.Data, msg)
}

if p.Type == "b" {
  ...
}