Go语言如何将JSON反序列化至interface类型？

我需要根据变量x的不同取值灵活处理JSON反序列化，写了如下示例代码：

type Service interface {
    Transform()
}

type XYZ struct {
    ID string `json:"id"`
}

func (s XYZ) Transform() {}

func main() {
    x := "could be anything"
    msg := []byte(`{"id": "123"}`)

    var msgS Service

    switch x {
    case "could be anything":
        msgS = XYZ{}
        break
    case "could be something else":
        // 另一个实现Transform()的类型
        break
    }

    err := json.Unmarshal(msg, &msgS)

    if err != nil {
        fmt.Println(err)
    }

    // msgS.Transform()
}

运行后返回错误：

json: cannot unmarshal object into Go value of type main.Service

问题原因 #

Go的json.Unmarshal无法直接反序列化到*Service类型的指针——接口本身没有具体字段结构，反序列化器无法确定要创建的具体类型实例。即便你在switch中给msgS赋值了具体类型，传递给Unmarshal的依然是接口类型的指针，底层逻辑无法处理这种情况。

解决方案建议 #

方案一：直接初始化具体类型指针（简单场景首选）

在switch语句中创建对应具体类型的指针，将指针传给Unmarshal完成反序列化，再通过类型断言转为接口变量：

import "encoding/json"
import "fmt"

type Service interface {
    Transform()
}

type XYZ struct {
    ID string `json:"id"`
}

func (s XYZ) Transform() {
    fmt.Println("XYZ Transform called, ID:", s.ID)
}

// 另一个实现Service的类型
type ABC struct {
    Name string `json:"name"`
}

func (s ABC) Transform() {
    fmt.Println("ABC Transform called, Name:", s.Name)
}

func main() {
    x := "could be anything"
    msg := []byte(`{"id": "123"}`)

    var msgS Service
    var target interface{}

    switch x {
    case "could be anything":
        target = &XYZ{}
    case "could be something else":
        target = &ABC{}
    default:
        fmt.Println("unsupported type")
        return
    }

    err := json.Unmarshal(msg, target)
    if err != nil {
        fmt.Println(err)
        return
    }

    msgS = target.(Service)
    msgS.Transform()
}

方案二：类型注册表+反射（复杂/动态场景适用）

如果需要支持大量类型或动态扩展，可以维护一个类型注册表，根据x的值获取对应类型，通过反射创建实例后反序列化：

import "encoding/json"
import "fmt"
import "reflect"

type Service interface {
    Transform()
}

type XYZ struct {
    ID string `json:"id"`
}

func (s XYZ) Transform() {
    fmt.Println("XYZ Transform called, ID:", s.ID)
}

type ABC struct {
    Name string `json:"name"`
}

func (s ABC) Transform() {
    fmt.Println("ABC Transform called, Name:", s.Name)
}

// 类型注册表，映射字符串到具体类型
var serviceTypeMap = map[string]reflect.Type{
    "could be anything":        reflect.TypeOf(XYZ{}),
    "could be something else": reflect.TypeOf(ABC{}),
}

func main() {
    x := "could be anything"
    msg := []byte(`{"id": "123"}`)

    // 获取对应类型
    t, exists := serviceTypeMap[x]
    if !exists {
        fmt.Println("unknown service type")
        return
    }

    // 创建类型的指针实例
    target := reflect.New(t).Interface()
    err := json.Unmarshal(msg, target)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 类型断言转为Service接口
    msgS := target.(Service)
    msgS.Transform()
}

内容的提问来源于stack exchange，提问作者joe