Unmarshaling Into an Interface{} and Then Performing Type Assertion

I get a string through a rabbitmq message system. Before sending,

I use json.Marshal, convert the outcome to string and send through
rabbitmq.

The structs that I convert and send can be: (changed the names and the size of the structs but it should not matter)

type Somthing1 struct{
   Thing        string    `json:"thing"`
   OtherThing   int64     `json:"other_thing"`
}

or

type Somthing2 struct{
   Croc        int       `json:"croc"`
   Odile       bool      `json:"odile"`
}

The message goes through perfectly as a string and is printed
on the other side (some server)

Up until now everything works.
Now I'm trying to convert them back into their structs and assert the types.

first attempt is by:

func typeAssert(msg string) {

 var input interface{}

 json.Unmarshal([]byte(msg), &input)

 switch input.(type){
 case Somthing1:
    job := Somthing1{}
    job = input.(Somthing1)
    queueResults(job)

  case Somthing2:
    stats := Somthing2{}
    stats = input.(Somthing2)
    queueStatsRes(stats)
 default:
}

This does not work. When Printing the type of input after Unmarshaling
it I get map[string]interface{} (?!?)

and even stranger than that, the map key is the string I got and the map value is empty.

I did some other attempts like:

 func typeAssert(msg string) {

  var input interface{}

  json.Unmarshal([]byte(msg), &input)

  switch v := input.(type){
  case Somthing1:
    v = input.(Somthing1)
    queueResults(v)

   case Somthing2:
    v = input.(Somthing2)
    queueStatsRes(v)
  default:
}

and also tried writing the switch like was explained in this answer:
Golang: cannot type switch on non-interface value

switch v := interface{}(input).(type)

still with no success...

Any ideas?

The default types that the json package Unmarshals into are shown in the Unmarshal function documentation

bool, for JSON booleans
float64, for JSON numbers
string, for JSON strings
[]interface{}, for JSON arrays
map[string]interface{}, for JSON objects
nil for JSON null

Since you're unmarshaling into an interface{}, the returned types will only be from that set. The json package doesn't know about Something1 and Something2. You either need to convert from the map[string]interface{} that the json object is being unmarshaled into, or unmarshal directly into the struct type you want.

If you don't want to do unpack the data from a generic interface, or somehow tag the data so you know what type to expect, you could iteratively take the json and try to unmarshal it into each type you want.

You can even pack those into a wrapper struct to do the unmarshaling for you:

type Something1 struct {
	Thing      string `json:"thing"`
	OtherThing int64  `json:"other_thing"`
}

type Something2 struct {
	Croc  int  `json:"croc"`
	Odile bool `json:"odile"`
}

type Unpacker struct {
	Data       interface{}
}

func (u *Unpacker) UnmarshalJSON(b []byte) error {
	smth1 := &Something1{}
	err := json.Unmarshal(b, smth1)

	// no error, but we also need to make sure we unmarshaled something
	if err == nil && smth1.Thing != "" {
		u.Data = smth1
		return nil
	}

	// abort if we have an error other than the wrong type
	if _, ok := err.(*json.UnmarshalTypeError); err != nil && !ok {
		return err
	}

	smth2 := &Something2{}
	err = json.Unmarshal(b, smth2)
	if err != nil {
		return err
	}

	u.Data = smth2
	return nil
}

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

You have encountered a typical json vs typed language problem!
Since json is untyped and schemaless, it is not possible to infer what data is "under the string" without actually decoding it.

So your only option is to unmarshal into an interface{} which always produces a map[string]interface{}. You could do some reflection magic here to build the final struct, but that's a lot of manual work and error prone.
Here are some possible solutions:

Quick 'n' dirty

Let the json package do the reflection stuff. Attempt to unmarshal into every expected type:

func typeAssert(msg string) {

 var thing1 Something1

 err := json.Unmarshal([]byte(msg), &thing1)
 if err == nil{
    // do something with thing1
    return
 }    

 var thing2 Something2

 err = json.Unmarshal([]byte(msg), &thing2)
 if err == nil{
    // do something with thing2
    return
 }    
 
 //handle unsupported type

}

Build your own "type system" on top of json

Defer the encoding until you know what's inside. Use this struct as an intermediate representation of your data:

type TypedJson struct{
  Type string 
  Data json.RawMessage
}

Marshal:

thing := Something1{"asd",123}
tempJson, _ := json.Marshal(thing)
 
typedThing := TypedJson{"something1", tempJson}
finalJson, _ := json.Marshal(typedThing)

Unmarshal:

func typeAssert(msg string) {

  var input TypedJson  
  json.Unmarshal([]byte(msg), &input)

  switch input.Type{
  case "something1":
    var thing Something1
    json.Unmarshal(input.Data, &thing)
    queueStatsRes(thing)   
   case "something2":
    var thing Something2
    json.Unmarshal(input.Data, &thing)
    queueStatsRes(thing)
  default:
    //handle unsupported type
}

Use a typed serialization format

• Go's own gob encoding
• Protocol Buffers
• and many more...

I like this style of a "Message" type which can unmarshal any expected message.

Few benefits:

• It plays nice with being a subtype in a bigger json structure because it implements UnmarshalJSON. This makes it more reusable.
• Message is always parsed to the same type so we're statically typed, but a type field tells you what type of message it is
• The Somthing1/Somthing2 fields are strongly typed, but only the correct one is populated.

I would prefer if the top level message had an explicit type. Something like {"messageType":"Somthing1", "messageData":{...}}. That would take the trial and error aspect out of parsing. But you can't always control the data source and may need to resort to it.

type Somthing1 struct{
   Thing        string    `json:"thing"`
   OtherThing   int64     `json:"other_thing"`
}

type Somthing2 struct{
   Croc        int       `json:"croc"`
   Odile       bool      `json:"odile"`
}

type Message struct{
  Type string // enum type here would be nice, but string for brevity

  // pointers, because only one of these will be populated, and the other will be nil. Can add as many as you want as you add message types.
  Somthing1 *Somthing1
  Somthing2 *Somthing2
}

func (m *Message) UnmarshalJSON(b []byte) error {
  var s1 Somthing1
  err := json.Unmarshal(b, &s1)
  if err == nil {
    // this line is some sort of check s1 is a valid Somthing1. Will depend on use case/data model
    if s1.Thing != "" {
      m.Type = "Somthing1"
      m.Somthing1 = &s1
      return nil
    }
  }

  var s2 Somthing2
  err = json.Unmarshal(b, &s2)
  if err == nil {
    // this line is some sort of check s2 is a valid Somthing2. Will depend on use case/data model
    if s2.Croc > 0 {
      m.Type = "Somthing2"
      m.Somthing2 = &s2
      return nil
    }
  }

  return errors.New("Invalid message")
}

Example (based off of JimB's sample): https://go.dev/play/p/vQfY--lSGmh