How to tell json.Unmarshal to use struct instead of interface

I want to write a function that receives several types of structs and unmarshals them from JSON. To this end, I have another set of functions with a pre-defined signature that return the struct instances but since each function returns a different type of struct the function signature has interface{} as the return type.

When I send json.Unmarshal a concrete struct it works as I expected but when I send the same struct as interface{} it converts it to a map.

Here is a simplified example code that depicts the problem:

package main

import (
"encoding/json"
	"fmt"
)

type Foo struct {
	Bar string `json:"bar"`
}  

func getFoo() interface{} {
	return Foo{"bar"}
}

func main() {

    fooInterface := getFoo() 
	fooStruct := Foo{"bar"}
    fmt.Println(fooInterface) //{bar}
	fmt.Println(fooStruct)    //{bar}

	myJSON := `{"bar":"This is the new value of bar"}`
	jsonBytes := []byte(myJSON)

    err := json.Unmarshal(jsonBytes, &fooInterface )
	if err != nil {
    	fmt.Println(err)
	}
    fmt.Println(fooInterface) //map[bar:This is the new value of bar]

	err = json.Unmarshal(jsonBytes, &fooStruct)
	if err != nil {
    	fmt.Println(err)
	}
    fmt.Println(fooStruct) //{This is the new value of bar}
}

https://play.golang.org/p/tOO7Ki_i4c

I expected json.Unmarshal to use the concrete struct behind the interface for unmarshaling but it doesn't and just assigns the map of values to the passed interface.

Why doesn't it use the concrete struct and is there a way to tell it to use the concrete struct type without explicit casting (I don't know the explicit type at design time)?

The encoding/json package can't magically guess what type you want the result unmarshaled into, unless you tell it to.

One way of telling what to unmarsal into is to pass value of that type to the json.Unmarshal() function.

And unfortunately there is no other way. If you pass a value of interface{} type, the json package implementation is free to choose a type of its choice, and it will choose map[string]interface{} for JSON objects, and []interface{} for JSON arrays. This is documented at json.Unmarshal():

> To unmarshal JSON into an interface value, Unmarshal stores one of these in the interface value:
>
> 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

If you know the type beforehand, create a value of that type, and pass that for unmarshaling. Whether your store this in an interface{} variable beforehand does not matter; if the passed value is suitable for unmarshaling, it will be used. Note that the passed value will be wrapped in an interface{} if not already of that type, as that is the parameter type of json.Unmarshal().

The problem why your code fails is because you pass a value of type *interface{} which wraps a non-pointer Foo value. Since the json package can't use this, it creates a new value of its choice (a map).

Instead you should wrap a *Foo value in an interface{}, and pass that:

func getFoo() interface{} {
    return &Foo{"bar"}
}

func main() {
    fooInterface := getFoo()

    myJSON := `{"bar":"This is the new value of bar"}`
    jsonBytes := []byte(myJSON)

    err := json.Unmarshal(jsonBytes, fooInterface)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Printf("%T %+v", fooInterface, fooInterface)
}

This results in (try it on the Go Playground):

*main.Foo &{Bar:This is the new value of bar}