Go 结构体设计解析嵌套 JSON 陷阱

本文详解 Go 中 json.Unmarshal 的常见陷阱：当 JSON 数组元素被错误地序列化为字符串（如 ["{\"name\":\"x\"}"]）时，如何通过结构体设计和预处理双策略实现健壮解析。

本文详解 Go 中 `json.Unmarshal` 的常见陷阱：当 JSON 数组元素被错误地序列化为字符串（如 `["{\"name\":\"x\"}"]`）时，如何通过结构体设计和预处理双策略实现健壮解析。

在 Go 中使用 json.Unmarshal 解析嵌套 JSON 时，结构体字段标签（如 `json:"spec"`）必须与 JSON 键名严格匹配，且数据类型需与实际 JSON 值类型一致。你遇到的问题本质并非结构体定义错误，而是上游数据格式异常："spec" 字段实际是一个字符串数组（如 ["{\"name\":\"bla_bla\",...}"]），而非预期的对象数组（[{"name":"bla_bla",...}]）。这导致 Go 尝试将字符串直接解码为 []Spec 时失败，Specs 为空切片。

✅ 正确的结构体定义（前提：JSON 格式规范）

你的原始结构体设计完全合理，适用于标准 JSON：

type Products struct {
    Product string `json:"product"`
    Specs   []Spec `json:"spec"` // 注意字段名大小写与标签一致性
}

type Spec struct {
    Name string `json:"name"`
    Info Inf    `json:"info"`
}

type Inf struct {
    Color string `json:"color"`
    Year  int    `json:"year"`
}

✅ 若原始 JSON 为：

{"product":"car","spec":[{"name":"bla_bla","info":{"color":"black","year":1991}}]}

则可直接安全解码：

var p Products
err := json.Unmarshal(data, &p)
if err != nil {
    log.Fatal(err)
}
fmt.Println(p.Specs[0].Name) // 输出: bla_bla

⚠️ 问题根源：JSON 数据被双重序列化

你观察到的 c := "{\"product\":\"car\",\"spec\":[\"{\\\"name\\\":\\\"bla_bla\\\",...}\"]}" 是典型“字符串化 JSON”问题——上游（如 JavaScript）误将对象先 JSON.stringify() 成字符串，再放入数组。结果 spec 变成 []string，而非 []map[string]interface{} 或 []Spec。

? 推荐解决方案（优于字符串替换）

方案一：自定义 UnmarshalJSON（推荐，类型安全）

为 Products 实现自定义解码逻辑，自动处理字符串化对象：

func (p *Products) UnmarshalJSON(data []byte) error {
    // 临时结构体，用于解析 spec 字段的原始值
    var raw struct {
        Product string          `json:"product"`
        SpecRaw json.RawMessage `json:"spec"`
    }
    if err := json.Unmarshal(data, &raw); err != nil {
        return err
    }
    p.Product = raw.Product

    // 判断 spec 是对象数组还是字符串数组
    var specs []Spec
    if err := json.Unmarshal(raw.SpecRaw, &specs); err == nil {
        // 正常情况：直接解码为 []Spec
        p.Specs = specs
        return nil
    }

    // 备用路径：尝试解码为字符串数组，再逐个解析
    var strSpecs []string
    if err := json.Unmarshal(raw.SpecRaw, &strSpecs); err != nil {
        return fmt.Errorf("failed to parse spec as []string or []Spec: %w", err)
    }

    for _, s := range strSpecs {
        var spec Spec
        if err := json.Unmarshal([]byte(s), &spec); err != nil {
            return fmt.Errorf("failed to unmarshal spec string %q: %w", s, err)
        }
        p.Specs = append(p.Specs, spec)
    }
    return nil
}

使用方式不变：

var p Products
err := json.Unmarshal([]byte(c), &p) // 自动适配两种格式

方案二：预处理（简洁但需谨慎）

若无法修改上游，可优化你的字符串替换逻辑，避免正则误伤：

// 更安全的预处理：仅解包 spec 数组中的字符串
replacer := strings.NewReplacer(
    `"spec\":[`, `"spec\":[`, // 保留外层结构
    `"{`, `{`, // 替换字符串内的起始引号
    `}"`, `}`, // 替换字符串内的结束引号
    `\\"`, `"`, // 还原转义引号
)
cleaned := replacer.Replace(c)
// 再用 json.Unmarshal 解析 cleaned

? 关键注意事项

• 永远检查 json.Unmarshal 返回的 error：空切片常是解码失败的信号，而非数据为空。
• 避免过度依赖字符串操作：strings.ReplaceAll 易破坏合法 JSON（如字段值含 "{）。
• 上游数据质量优先：根本解决方法是修正生成 JSON 的服务端代码，确保 spec 直接输出对象数组。
• 使用 json.RawMessage 延迟解析：对不确定结构的字段，先存为 json.RawMessage，按需再解码。

通过结构体设计 + 智能解码逻辑，你不仅能解决当前问题，还能构建出适应多种数据变体的健壮 JSON 解析器。