Golang如何实现类似Java Gson的JSON继承处理？

好问题！在Go里确实没有像Gson那样开箱即用的RuntimeTypeAdapterFactory来直接处理多态JSON，但我们可以通过自定义JSON反序列化逻辑来实现类似效果，核心是利用Go的接口和json.Unmarshaler接口，根据类型字段分发解析对应的结构体。

第一步：定义对应的结构体 #

首先我们把你Java里的类转换成Go的结构体，用嵌入结构体的方式模拟继承关系：

import (
    "encoding/json"
    "fmt"
    "log"
)

// 模拟Java的MessageType枚举
type MessageType int

const (
    TextMessageType MessageType = iota + 1
    SystemTextMessageType
)

// 基础消息结构体，对应BaseMessage
type BaseMessage struct {
    MessageID string      `json:"messageId"`
    Type      MessageType `json:"type"`
}

// 文本消息，对应TextMessage
type TextMessage struct {
    BaseMessage // 嵌入基础结构体，模拟继承
    Recipient string `json:"recipient"`
    Sender    string `json:"sender"`
}

// 系统文本消息，对应SystemTextMessage
type SystemTextMessage struct {
    BaseMessage // 嵌入基础结构体，模拟继承
    Field1 string `json:"field1"`
    Field2 string `json:"field2"`
}

如果你的类型字段是字符串类型（比如Java里用String.valueOf(MessageType.TEXT_MESSAGE)），只需要把MessageType改成string类型，常量定义成对应字符串即可：

type MessageType string

const (
    TextMessageType      MessageType = "TEXT_MESSAGE"
    SystemTextMessageType MessageType = "SYSTEM_MESSAGE"
)

第二步：实现自定义反序列化逻辑 #

我们定义一个Message接口作为所有消息类型的父类型，然后给它实现json.Unmarshaler接口，在方法里先解析出类型字段，再根据类型解析对应的子结构体：

// Message 作为所有消息类型的统一接口
type Message interface{}

// UnmarshalJSON 自定义反序列化逻辑
func (m *Message) UnmarshalJSON(data []byte) error {
    // 先解析基础消息，获取type字段
    var base BaseMessage
    if err := json.Unmarshal(data, &base); err != nil {
        return err
    }

    // 根据type字段创建对应的子类型实例并完成解析
    switch base.Type {
    case TextMessageType:
        var tm TextMessage
        if err := json.Unmarshal(data, &tm); err != nil {
            return err
        }
        *m = tm
    case SystemTextMessageType:
        var stm SystemTextMessage
        if err := json.Unmarshal(data, &stm); err != nil {
            return err
        }
        *m = stm
    default:
        return fmt.Errorf("unknown message type: %v", base.Type)
    }
    return nil
}

第三步：反序列化并遍历判断类型 #

现在就可以像你在Java里那样反序列化消息列表，然后通过类型断言（类似Java的instanceof）来判断具体类型：

func main() {
    // 模拟你的JSON输入
    jsonStr := `[
        {"messageId": "msg_001", "type": 1, "recipient": "alice@example.com", "sender": "bob@example.com"},
        {"messageId": "msg_002", "type": 2, "field1": "system_notice", "field2": "service_maintenance"}
    ]`

    // 反序列化到Message切片（对应Java的List<BaseMessage>）
    var messages []Message
    if err := json.Unmarshal([]byte(jsonStr), &messages); err != nil {
        log.Fatalf("Failed to unmarshal JSON: %v", err)
    }

    // 遍历并判断具体类型
    for _, msg := range messages {
        switch v := msg.(type) {
        case TextMessage:
            fmt.Printf("Found TextMessage: ID=%s, Sender=%s\n", v.MessageID, v.Sender)
        case SystemTextMessage:
            fmt.Printf("Found SystemTextMessage: ID=%s, Field1=%s\n", v.MessageID, v.Field1)
        default:
            fmt.Printf("Unknown message type: %T\n", msg)
        }
    }
}

额外说明 #

• 序列化时，因为我们使用了嵌入结构体，Go会自动扁平化字段，所以直接序列化子结构体就能输出包含所有字段的JSON，无需额外处理。
• 如果需要更灵活的扩展，可以把类型判断的逻辑抽成一个注册函数，类似Gson的registerSubtype，这样新增消息类型时只需要注册而不需要修改Unmarshal方法。

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