Go语言中实现灵活的JSON类型解码

{
  "b": [
    {"x": 9},
    {"x": 4, "y": "test"}
  ]
}

{
  "type": "structx",
  "data": {"x": 9, "xstring": "This is structX"}
}

{
  "type": "structy",
  "data": {"y": true}
}

package main

import (
    "encoding/json"
    "fmt"
)

// JsonEnvelope 定义了包含类型标识和原始数据载荷的通用结构
type JsonEnvelope struct {
    Type string          `json:"type"` // 用于标识内部数据类型的字段
    Data json.RawMessage `json:"data"` // 存储原始JSON字节，延迟解析
}

// StructX 是可能的具体数据结构之一
type StructX struct {
    X       float64 `json:"x"`
    Xstring string  `json:"xstring"`
}

// StructY 是另一种可能的具体数据结构
type StructY struct {
    Y bool `json:"y"`
}

func main() {
    // 示例JSON数据1：类型为 "structx"
    s1 := `{"type":"structx", "data":{"x":9,"xstring":"This is structX"}}`
    // 示例JSON数据2：类型为 "structy"
    s2 := `{"type":"structy", "data":{"y":true}}`
    // 示例JSON数据3：模拟原始问题中的数组场景，每个元素包含类型信息
    s3 := `{"items": [{"type":"structx", "data":{"x":1,"xstring":"Item One"}}, {"type":"structy", "data":{"y":false}}, {"type":"structx", "data":{"x":2,"xstring":"Item Two"}}]}`

    // 处理 s1
    fmt.Println("--- 处理 s1 (structx) ---")
    processDynamicJson(s1)

    // 处理 s2
    fmt.Println("\n--- 处理 s2 (structy) ---")
    processDynamicJson(s2)

    // 处理 s3 (数组场景)
    fmt.Println("\n--- 处理 s3 (数组场景) ---")
    processDynamicJsonArray(s3)
}

// processDynamicJson 函数演示如何处理单个动态JSON对象
func processDynamicJson(jsonStr string) {
    var envelope JsonEnvelope
    err := json.Unmarshal([]byte(jsonStr), &envelope)
    if err != nil {
        panic(fmt.Errorf("解析JsonEnvelope失败: %w", err))
    }

    fmt.Printf("检测到的类型: %s\n", envelope.Type)

    // 根据 Type 字段的值，将 Data (json.RawMessage) 解码到具体的结构体
    switch envelope.Type {
    case "structx":
        var sx StructX
        err := json.Unmarshal(envelope.Data, &sx)
        if err != nil {
            panic(fmt.Errorf("解析StructX失败: %w", err))
        }
        fmt.Printf("解码为 StructX: %+v\n", sx)
    case "structy":
        var sy StructY
        err := json.Unmarshal(envelope.Data, &sy)
        if err != nil {
            panic(fmt.Errorf("解析StructY失败: %w", err))
        }
        fmt.Printf("解码为 StructY: %+v\n", sy)
    default:
        fmt.Printf("未知类型: %s, 无法解码Data\n", envelope.Type)
    }
}

// ItemsWrapper 用于处理包含动态类型元素数组的JSON
type ItemsWrapper struct {
    Items []JsonEnvelope `json:"items"`
}

// processDynamicJsonArray 函数演示如何处理包含动态JSON对象数组的场景
func processDynamicJsonArray(jsonStr string) {
    var wrapper ItemsWrapper
    err := json.Unmarshal([]byte(jsonStr), &wrapper)
    if err != nil {
        panic(fmt.Errorf("解析ItemsWrapper失败: %w", err))
    }

    fmt.Printf("检测到 %d 个动态项\n", len(wrapper.Items))

    for i, itemEnvelope := range wrapper.Items {
        fmt.Printf("  --- 处理第 %d 项 (类型: %s) ---\n", i+1, itemEnvelope.Type)
        switch itemEnvelope.Type {
        case "structx":
            var sx StructX
            err := json.Unmarshal(itemEnvelope.Data, &sx)
            if err != nil {
                panic(fmt.Errorf("解析第 %d 项为 StructX 失败: %w", i+1, err))
            }
            fmt.Printf("  解码为 StructX: %+v\n", sx)
        case "structy":
            var sy StructY
            err := json.Unmarshal(itemEnvelope.Data, &sy)
            if err != nil {
                panic(fmt.Errorf("解析第 %d 项为 StructY 失败: %w", i+1, err))
            }
            fmt.Printf("  解码为 StructY: %+v\n", sy)
        default:
            fmt.Printf("  未知类型: %s, 无法解码Data\n", itemEnvelope.Type)
        }
    }
}