当前位置：首页 > 文章列表 > Golang > Go教程 > Go JSON 多态字段怎么用 RawMessage 延迟选择结构体

Go JSON 多态字段怎么用 RawMessage 延迟选择结构体

来源：17golang原创 2026-09-08 09:34:13 0浏览收藏

接口里有一个字段可能是用户、订单或设备，最稳妥的做法不是先把它解成 map[string]any，而是先读取类型标识，再用 json.RawMessage 延迟选择目标结构体。这样既保留了标准库的类型检查，也不会为每种 payload 设计一套重复的外层解析逻辑。

要点速览

RawMessage 只负责保存原始 JSON，真正的类型选择仍由 kind 决定。
未知 kind、null 和空 payload 要单独处理，不能静默落到零值结构体。
结构体默认忽略新增字段；如果接口契约要求严格校验，再对选中的 payload 使用 Decoder。

先让外层结构知道该延迟哪一块

假设消息都有 kind 和 payload，但 payload 的字段随 kind 改变。外层只声明稳定字段，变化部分使用 json.RawMessage：

type Envelope struct {
    Kind    string          `json:"kind"`
    Payload json.RawMessage `json:"payload"` // 暂不决定 payload 的具体类型
}

它的价值在于“先拆信封，后拆内容”。json.Unmarshal 读取 Envelope 时不会把 payload 降级成浮点数、字符串和 map[string]any 的混合树；RawMessage 会保留这段 JSON，等判别字段可用后再处理。

Go encoding/json 用 kind 信封与 RawMessage payload 分离稳定字段和多态字段的结构关系 — 图1：先读取稳定的 kind，再把 RawMessage payload 交给对应结构体。

根据 kind 选择结构体，再做第二次解码

下面用两种事件演示完整分支。每个分支只负责创建目标值，真正的 JSON 解码统一放在末尾，调用方拿到的是具体类型。

package main

import (
    "encoding/json"
    "fmt"
)

type Envelope struct {
    Kind    string          `json:"kind"`
    Payload json.RawMessage `json:"payload"` // 延迟到 kind 确定后再解码
}

type UserCreated struct {
    ID    string `json:"id"`
    Email string `json:"email"`
}

type OrderPaid struct {
    OrderID string `json:"order_id"`
    Amount  int64  `json:"amount"`
}

func decodePayload(e Envelope) (any, error) {
    var target any
    switch e.Kind {
    case "user.created":
        target = new(UserCreated)
    case "order.paid":
        target = new(OrderPaid)
    default:
        return nil, fmt.Errorf("unsupported event kind %q", e.Kind) // 未知类型尽早失败
    }

    if len(e.Payload) == 0 || string(e.Payload) == "null" {
        return nil, fmt.Errorf("empty payload for %q", e.Kind) // 不把空值当合法对象
    }
    if err := json.Unmarshal(e.Payload, target); err != nil {
        return nil, fmt.Errorf("decode %s payload: %w", e.Kind, err) // 保留类型上下文
    }
    return target, nil
}

func main() {
    input := []byte(`[{"kind":"user.created","payload":{"id":"u-7","email":"a@example.com"}},
        {"kind":"order.paid","payload":{"order_id":"o-9","amount":1200}}]`)

    var events []Envelope
    if err := json.Unmarshal(input, &events); err != nil {
        panic(err) // 外层 JSON 结构错误，直接终止本次读取
    }
    for _, event := range events {
        value, err := decodePayload(event)
        if err != nil {
            fmt.Println("skip:", err) // 单条消息失败不必隐藏原因
            continue
        }
        fmt.Printf("%s -> %T\n", event.Kind, value)
    }
}

这里的关键不是写一个很长的 switch，而是让 switch 只决定“目标类型”，让解码、错误包装和空值判断保持一条路径。以后增加 device.online 时，只需新增结构体与分支，不会把外层循环改成反射代码。

三个容易漏掉的边界：null、未知字段和未知 kind

情况	默认行为	建议
payload 缺失或为 null	可能得到空 RawMessage 或 null	在二次解码前明确拒绝
payload 多了字段	结构体默认忽略未知字段	兼容型接口保留默认行为
kind 不在白名单	不会自动找到目标类型	返回带 kind 的错误并记录原消息

如果某个内部接口必须拒绝未知字段，可以只对选中的 payload 使用 json.Decoder 和 DisallowUnknownFields。不要为了严格校验而把所有消息先解成 map[string]any，那样会丢掉数字类型和结构体级别的约束。