在Go语言中处理JSON数据时，我们经常会遇到需要反序列化一个包含多种不同结构体类型的数组。例如，一个JSON数组中的每个对象都包含一个“type”字段来标识其具体类型，而不同类型具有不同的字段。直接将这样的数组反序列化到一个[]interface{}或[]MyInterface切片中是无法正确填充具体字段的。本文将详细介绍两种主流且有效的解决方案。
这种方法是最灵活也是最常用的，它允许我们完全控制反序列化的过程。其核心思想是：首先将异构数组的每个元素作为原始JSON消息（json.RawMessage）进行捕获，然后根据每个原始消息中的类型标识字段，动态地创建相应的Go结构体实例，并再次对该原始消息进行反序列化。
首先，我们需要定义一个接口来表示数组中的异构实体，以及实现该接口的具体结构体。这些结构体通常会包含一个Type字段，用于JSON中的类型标识。
package main
import (
"encoding/json"
"fmt"
)
// Entity 是所有异构结构体需要实现的接口
type Entity interface {
GetType() string
}
// T1 是一个具体的实体类型
type T1 struct {
Type string `json:"type"`
Field1 int `json:"field1"`
}
func (t T1) GetType() string {
return t.Type
}
// T2 是另一个具体的实体类型
type T2 struct {
Type string `json:"type"`
Field2 string `json:"field2"`
Field3 bool `json:"field3"`
}
func (t T2) GetType() string {
return t.Type
}
// Result 包含一个异构实体数组
type Result struct {
Foo int `json:"foo"`
Bar []Entity `json:"bar"`
}接下来，为Result类型实现UnmarshalJSON方法。这是关键步骤，它将处理Bar字段的异构反序列化逻辑。
立即学习“go语言免费学习笔记（深入）”；
// Helper struct for unmarshaling the outer Result structure initially
type resultAlias Result
// unmarshalHelper is used to temporarily unmarshal the "type" field
type unmarshalHelper struct {
Type string `json:"type"`
}
// UnmarshalJSON 为 Result 类型实现自定义 JSON 反序列化
func (r *Result) UnmarshalJSON(data []byte) error {
// 1. 先将 Result 的其他字段（如 Foo）反序列化
// 使用别名类型避免无限循环调用 UnmarshalJSON
var temp resultAlias
if err := json.Unmarshal(data, &temp); err != nil {
return err
}
r.Foo = temp.Foo
// 2. 将 Bar 字段反序列化为 []json.RawMessage
// 这样可以保留每个元素的原始 JSON 形式
var rawEntities []json.RawMessage
// 从原始数据中提取 "bar" 字段
var rawMap map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMap); err != nil {
return err
}
if barData, ok := rawMap["bar"]; ok {
if err := json.Unmarshal(barData, &rawEntities); err != nil {
return err
}
}
// 3. 遍历每个原始消息，根据 "type" 字段进行具体反序列化
r.Bar = make([]Entity, len(rawEntities))
for i, rawMsg := range rawEntities {
var helper unmarshalHelper
if err := json.Unmarshal(rawMsg, &helper); err != nil {
return fmt.Errorf("failed to unmarshal type helper for entity %d: %w", i, err)
}
switch helper.Type {
case "t1":
var t1 T1
if err := json.Unmarshal(rawMsg, &t1); err != nil {
return fmt.Errorf("failed to unmarshal T1 for entity %d: %w", i, err)
}
r.Bar[i] = t1
case "t2":
var t2 T2
if err := json.Unmarshal(rawMsg, &t2); err != nil {
return fmt.Errorf("failed to unmarshal T2 for entity %d: %w", i, err)
}
r.Bar[i] = t2
default:
return fmt.Errorf("unknown entity type '%s' for entity %d", helper.Type, i)
}
}
return nil
}func main() {
jsonData := `{
"foo": 123,
"bar": [
{"type": "t1", "field1": 10},
{"type": "t2", "field2": "hello", "field3": true},
{"type": "t1", "field1": 20}
]
}`
var result Result
err := json.Unmarshal([]byte(jsonData), &result)
if err != nil {
fmt.Printf("Error unmarshaling: %v\n", err)
return
}
fmt.Printf("Foo: %d\n", result.Foo)
for i, entity := range result.Bar {
fmt.Printf(" Entity %d (Type: %s): ", i, entity.GetType())
switch v := entity.(type) {
case T1:
fmt.Printf("T1{Field1: %d}\n", v.Field1)
case T2:
fmt.Printf("T2{Field2: %s, Field3: %t}\n", v.Field2, v.Field3)
}
}
// 尝试反序列化一个未知类型
jsonDataUnknown := `{
"foo": 456,
"bar": [
{"type": "t1", "field1": 10},
{"type": "unknown_type", "fieldA": "xyz"}
]
}`
var resultUnknown Result
err = json.Unmarshal([]byte(jsonDataUnknown), &resultUnknown)
if err != nil {
fmt.Printf("\nError unmarshaling unknown type: %v\n", err)
}
}输出示例:
Foo: 123
Entity 0 (Type: t1): T1{Field1: 10}
Entity 1 (Type: t2): T2{Field2: hello, Field3: true}
Entity 2 (Type: t1): T1{Field1: 20}
Error unmarshaling unknown type: unknown entity type 'unknown_type' for entity 1第二种方法是创建一个“联合体”结构，它包含了所有可能异构类型的所有字段，以及一个类型标识字段。然后将JSON数组反序列化为这种联合体结构的切片。这种方法的优点是避免了自定义UnmarshalJSON的复杂性，但可能导致结构体臃肿。
联合体结构EntityUnion会包含Type字段和所有T1、T2等可能类型的字段。
// EntityUnion 包含所有可能类型的字段
type EntityUnion struct {
Type string `json:"type"`
Field1 int `json:"field1,omitempty"` // T1 的字段
Field2 string `json:"field2,omitempty"` // T2 的字段
Field3 bool `json:"field3,omitempty"` // T2 的字段
}
// ResultUnion 包含一个 EntityUnion 数组
type ResultUnion struct {
Foo int `json:"foo"`
Bar []EntityUnion `json:"bar"`
}反序列化过程将直接使用json.Unmarshal，然后需要一个辅助函数来将EntityUnion转换为具体的Entity接口类型。
// ToEntity 将 EntityUnion 转换为具体的 Entity 接口类型
func (eu EntityUnion) ToEntity() (Entity, error) {
switch eu.Type {
case "t1":
return T1{Type: eu.Type, Field1: eu.Field1}, nil
case "t2":
return T2{Type: eu.Type, Field2: eu.Field2, Field3: eu.Field3}, nil
default:
return nil, fmt.Errorf("unknown entity type '%s'", eu.Type)
}
}
func main() {
// ... (前面的 main 函数内容) ...
fmt.Println("\n--- Using Union Struct Approach ---")
jsonData := `{
"foo": 123,
"bar": [
{"type": "t1", "field1": 10},
{"type": "t2", "field2": "hello", "field3": true},
{"type": "t1", "field1": 20}
]
}`
var resultUnion ResultUnion
err := json.Unmarshal([]byte(jsonData), &resultUnion)
if err != nil {
fmt.Printf("Error unmarshaling union: %v\n", err)
return
}
fmt.Printf("Foo: %d\n", resultUnion.Foo)
var concreteEntities []Entity
for i, eu := range resultUnion.Bar {
entity, err := eu.ToEntity()
if err != nil {
fmt.Printf("Error converting union entity %d: %v\n", i, err)
continue
}
concreteEntities = append(concreteEntities, entity)
fmt.Printf(" Entity %d (Type: %s): ", i, entity.GetType())
switch v := entity.(type) {
case T1:
fmt.Printf("T1{Field1: %d}\n", v.Field1)
case T2:
fmt.Printf("T2{Field2: %s, Field3: %t}\n", v.Field2, v.Field3)
}
}
}输出示例:
--- Using Union Struct Approach ---
Foo: 123
Entity 0 (Type: t1): T1{Field1: 10}
Entity 1 (Type: t2): T2{Field2: hello, Field3: true}
Entity 2 (Type: t1): T1{Field1: 20}在Go语言中反序列化异构JSON数组，主要有两种策略：
选择哪种方法取决于具体的业务需求、数据结构复杂性以及对代码可维护性和性能的要求。对于大多数复杂的异构JSON数组场景，自定义UnmarshalJSON通常是更健壮和推荐的选择。
以上就是Go语言中异构JSON数组的反序列化技巧的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
929
