在Go语言中处理JSON数据时，我们经常会遇到需要反序列化一个包含多种不同结构体类型的数组。例如，一个JSON数组中的每个对象都包含一个“type”字段来标识其具体类型，而不同类型具有不同的字段。直接将这样的数组反序列化到一个[]interface{}或[]MyInterface切片中是无法正确填充具体字段的。本文将详细介绍两种主流且有效的解决方案。
1. 使用 json.RawMessage 和自定义 UnmarshalJSON
这种方法是最灵活也是最常用的，它允许我们完全控制反序列化的过程。其核心思想是：首先将异构数组的每个元素作为原始JSON消息（json.RawMessage）进行捕获，然后根据每个原始消息中的类型标识字段，动态地创建相应的Go结构体实例，并再次对该原始消息进行反序列化。
1.1 定义接口和具体实现
首先，我们需要定义一个接口来表示数组中的异构实体，以及实现该接口的具体结构体。这些结构体通常会包含一个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"`
}1.2 实现 UnmarshalJSON 方法
接下来，为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
}1.3 示例用法
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 11.4 注意事项
- 性能开销： 这种方法涉及多次对同一部分JSON数据进行反序列化（一次获取type，一次获取具体字段），对于性能敏感的场景可能需要优化。
- 错误处理： 需要仔细处理每一步的反序列化错误，尤其是在类型识别和具体类型转换时。
- 代码维护： 每增加一种新的实体类型，都需要修改UnmarshalJSON中的switch语句。
2. 使用“联合体”结构
第二种方法是创建一个“联合体”结构，它包含了所有可能异构类型的所有字段，以及一个类型标识字段。然后将JSON数组反序列化为这种联合体结构的切片。这种方法的优点是避免了自定义UnmarshalJSON的复杂性，但可能导致结构体臃肿。
2.1 定义联合体结构
联合体结构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"`
}2.2 反序列化和类型转换
反序列化过程将直接使用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}2.3 注意事项
- 结构体臃肿： 联合体结构会包含所有可能的字段，即使某个字段只属于特定类型。这可能导致内存浪费，尤其是在字段数量很多时。
- 字段命名冲突： 如果不同类型有同名字段但含义不同，则此方法不适用。
- omitempty标签： 使用omitempty标签可以避免在序列化时输出空值字段，但在反序列化时，JSON解析器会尝试填充所有匹配的字段。
- 易于实现： 这种方法不需要自定义UnmarshalJSON，使得反序列化代码更简洁。后续的类型转换逻辑也相对简单。
总结
在Go语言中反序列化异构JSON数组，主要有两种策略：
- 自定义 UnmarshalJSON 结合 json.RawMessage： 这种方法提供了最大的灵活性和精确性，能够完全控制每个异构元素的类型识别和具体字段填充。它适用于字段结构差异大、类型数量多、或对性能有较高要求的场景。缺点是代码量相对较大，且需要手动维护类型映射。
- 使用“联合体”结构： 这种方法通过创建一个包含所有可能字段的通用结构体来简化反序列化过程。它适用于异构类型数量不多、字段重叠较少、且对内存占用不那么敏感的场景。优点是实现简单，但可能导致结构体臃肿和字段语义不清。
选择哪种方法取决于具体的业务需求、数据结构复杂性以及对代码可维护性和性能的要求。对于大多数复杂的异构JSON数组场景，自定义UnmarshalJSON通常是更健壮和推荐的选择。
