Go语言encoding/json对应.NET TypeNameHandling的等效实现方案是什么

解决方案 #

Go标准库encoding/json没有内置类似.NET Newtonsoft的TypeNameHandling特性，该场景需要通过自定义实现json.Unmarshaler接口来完成多态反序列化，核心逻辑是先读取鉴别器字段判断具体类型，再实例化对应结构体完成解析。

报错原因 #

反序列化失败的根本原因是Go的接口类型本身无法被实例化，encoding/json默认没有能力根据字段内容自动匹配接口的实现类型，因此直接向[]MyInterface反序列化时会抛出类型不匹配错误。

实现代码 #

对接口切片自定义包装类型并实现json.Unmarshaler接口即可，修改后的可运行代码如下：

package main

import (
	"encoding/json"
	"fmt"
)

type MyInterface interface {
	GetDiscriminator() string
}

type BaseStruct struct {
	Discriminator string
}

type Foo struct {
	BaseStruct
	FooField string
}

func (foo *Foo) GetDiscriminator() string {
	return foo.Discriminator
}

type Bar struct {
	BaseStruct
	BarField int
}

func (bar *Bar) GetDiscriminator() string {
	return bar.Discriminator
}

// 自定义接口切片类型，实现UnmarshalJSON接口
type MyInterfaceList []MyInterface

func (l *MyInterfaceList) UnmarshalJSON(data []byte) error {
	// 第一步：先把数组解析为原始json消息切片，保留每个元素的原始内容
	var rawList []json.RawMessage
	if err := json.Unmarshal(data, &rawList); err != nil {
		return err
	}

	// 第二步：遍历每个原始元素，鉴别类型后分别解析
	result := make(MyInterfaceList, 0, len(rawList))
	for _, raw := range rawList {
		// 先解析出鉴别器字段
		var base BaseStruct
		if err := json.Unmarshal(raw, &base); err != nil {
			return err
		}

		// 根据鉴别器实例化对应结构体
		var item MyInterface
		switch base.Discriminator {
		case "Foo":
			item = &Foo{}
		case "Bar":
			item = &Bar{}
		default:
			return fmt.Errorf("unknown discriminator: %s", base.Discriminator)
		}

		// 把原始json解析到实例化的结构体中
		if err := json.Unmarshal(raw, item); err != nil {
			return err
		}
		result = append(result, item)
	}

	*l = result
	return nil
}

func main() {
	list := []MyInterface{
		&Bar{
			BaseStruct: BaseStruct{Discriminator: "Bar"},
			BarField:   42,
		},
		&Foo{
			BaseStruct: BaseStruct{Discriminator: "Foo"},
			FooField:   "hello",
		},
	}
	jsonBytes, _ := json.Marshal(list)
	jsonString := string(jsonBytes)
	fmt.Println(jsonString)

	// 使用自定义的切片类型接收反序列化结果
	var unmarshaledList MyInterfaceList
	err := json.Unmarshal(jsonBytes, &unmarshaledList)
	if err != nil {
		fmt.Printf("Unmarshaling failed: %v", err)
		return
	}

	// 验证结果
	for _, item := range unmarshaledList {
		switch v := item.(type) {
		case *Foo:
			fmt.Printf("Foo type, FooField: %s\n", v.FooField)
		case *Bar:
			fmt.Printf("Bar type, BarField: %d\n", v.BarField)
		}
	}
}

扩展说明 #

如果需要更通用的多态反序列化能力，也可以通过注册类型工厂的方式优化上述代码，不需要每次新增实现类型都修改switch分支：

• 提前用map维护Discriminator取值到对应类型构造函数的映射
• 反序列化时直接从map中取出构造函数创建实例即可

内容的提问来源于stack exchange，提问作者koks der drache