Go 解析动态 JSON的三种姿势

🎯 场景：为什么需要解析"动态"JSON？

假设你在写一个用户行为埋点系统，前端上报的数据结构经常变：

// 今天上报点击事件
{"event": "click", "page": "home", "x": 100, "y": 200}

// 明天上报表单提交
{"event": "submit", "formId": "login", "fields": {"username": "alice", "password": "***"}}

// 后天又加了个新事件
{"event": "video_play", "videoId": "v123", "duration": 45.5, "quality": "1080p"}

问题：Go 是静态类型语言，struct 要提前定义字段，但上游数据天天变，怎么办？

答案：用动态解析方案。下面介绍三种，从简单到灵活。

方案 1：map[string]interface{} —— 万能钥匙

适用场景

• 完全不知道 JSON 有哪些字段
• 字段类型可能变化
• 快速原型开发、调试、对接不稳定的第三方接口

代码示例：解析用户信息（字段可能变）

package main

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

func main() {
    // 模拟前端上报的用户数据，字段不固定
    jsonData := []byte(`{
        "name": "Alice",
        "age": 30,
        "isVip": true,
        "tags": ["admin", "early_user"],
        "extra": {
            "lastLogin": "2024-01-15",
            "device": "iOS"
        }
    }`)

    // 1️⃣ 解析到通用 map
    var data map[string]interface{}
    if err := json.Unmarshal(jsonData, &data); err != nil {
        log.Fatal(err)
    }

    // 2️⃣ 安全取值（关键！）
    name, _ := data["name"].(string)
    age, _ := data["age"].(float64)  // ⚠️ JSON 数字默认是 float64
    isVip, _ := data["isVip"].(bool)

    fmt.Printf("用户: %s, 年龄: %.0f, VIP: %v\n", name, age, isVip)

    // 3️⃣ 处理嵌套对象
    if extra, ok := data["extra"].(map[string]interface{}); ok {
        device, _ := extra["device"].(string)
        fmt.Printf("设备: %s\n", device)
    }
}

🔑 关键知识点

✅ 安全取值的正确姿势

// ❌ 危险：类型不对直接 panic
// name := data["name"].(string)  // 如果 name 是 number，程序崩溃

// ✅ 安全：用逗号接收第二个返回值
if name, ok := data["name"].(string); ok {
    fmt.Println("名字:", name)
} else {
    fmt.Println("name 字段缺失或类型不对")
}

// ✅ 更简洁：用辅助函数
func getString(m map[string]interface{}, key string) string {
    if v, ok := m[key].(string); ok {
        return v
    }
    return ""  // 或返回默认值
}

方案 2：json.RawMessage —— 延迟解析，按需加载

适用场景

• JSON 中某些字段结构已知，某些未知
• 根据某个字段的值，决定如何解析另一个字段（比如事件类型决定 payload 结构）
• 性能敏感：只解析需要的部分

代码示例：事件系统（不同事件，不同结构）

package main

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

// 外层结构固定：每个事件都有 type 和 payload
type Event struct {
    Type    string          `json:"type"`
    Payload json.RawMessage `json:"payload"` // 先不解析，留着后面用
}

// 用户创建事件的结构
type UserCreated struct {
    UserID string `json:"userId"`
    Email  string `json:"email"`
}

// 订单创建事件的结构
type OrderPlaced struct {
    OrderID string  `json:"orderId"`
    Total   float64 `json:"total"`
}

func main() {
    eventsJSON := []byte(`[
        {"type": "user.created", "payload": {"userId": "u1", "email": "a@example.com"}},
        {"type": "order.placed", "payload": {"orderId": "o1", "total": 199.99}},
        {"type": "unknown.event", "payload": {"some": "data"}}
    ]`)

    var events []Event
    if err := json.Unmarshal(eventsJSON, &events); err != nil {
        log.Fatal(err)
    }

    for _, e := range events {
        switch e.Type {
        case "user.created":
            var user UserCreated
            json.Unmarshal(e.Payload, &user)  // 只解析需要的部分
            fmt.Printf("👤 新用户: %s (%s)\n", user.UserID, user.Email)

        case "order.placed":
            var order OrderPlaced
            json.Unmarshal(e.Payload, &order)
            fmt.Printf("📦 新订单: %s, 金额: ¥%.2f\n", order.OrderID, order.Total)

        default:
            // 未知事件，用 map 兜底
            var raw map[string]interface{}
            json.Unmarshal(e.Payload, &raw)
            fmt.Printf("❓ 未知事件 %s, 原始数据: %v\n", e.Type, raw)
        }
    }
}

💡 为什么用 RawMessage？

• 避免为所有可能的 payload 定义一个大 struct
• 避免解析不需要的字段，提升性能
• 逻辑清晰：先按 type 分发，再按类型解析

方案 3：any（或 interface{}）+ 递归 —— 完全未知，深度遍历

适用场景

• JSON 结构完全不可预测（比如配置中心、插件系统）
• 需要打印、转换、透传原始数据
• 写通用工具函数

代码示例：递归打印任意 JSON

package main

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

func main() {
    // 混合类型的数组，完全不知道里面是啥
    jsonData := []byte(`[
        42,
        "hello",
        true,
        null,
        {"nested": [1, 2, 3]},
        [{"a": 1}, {"b": 2}]
    ]`)

    var data any  // any 是 interface{} 的别名，Go 1.18+
    if err := json.Unmarshal(jsonData, &data); err != nil {
        log.Fatal(err)
    }

    // 递归处理任意结构
    printValue(data, 0)
}

// 递归打印：根据实际类型做不同处理
func printValue(v any, depth int) {
    indent := ""
    for i := 0; i < depth; i++ {
        indent += "  "
    }

    switch val := v.(type) {
    case nil:
        fmt.Printf("%snull\n", indent)

    case bool:
        fmt.Printf("%sbool: %v\n", indent, val)

    case float64:  // ⚠️ 所有数字都是 float64
        fmt.Printf("%snumber: %.0f\n", indent, val)

    case string:
        fmt.Printf("%sstring: %q\n", indent, val)

    case []interface{}:
        fmt.Printf("%sarray (len=%d):\n", indent, len(val))
        for _, item := range val {
            printValue(item, depth+1)
        }

    case map[string]interface{}:
        fmt.Printf("%sobject (keys=%d):\n", indent, len(val))
        for k, v := range val {
            fmt.Printf("%s  %s:\n", indent, k)
            printValue(v, depth+2)
        }

    default:
        fmt.Printf("%sunknown type: %T\n", indent, val)
    }
}

🔧 实用技巧：写个辅助函数，复用更香

// 辅助函数：安全获取嵌套字符串值
func getNestedString(data map[string]interface{}, keys ...string) string {
    var current interface{} = data
    for i, key := range keys {
        m, ok := current.(map[string]interface{})
        if !ok {
            return ""
        }
        current = m[key]
        // 最后一个 key，尝试转 string
        if i == len(keys)-1 {
            if s, ok := current.(string); ok {
                return s
            }
            return ""
        }
    }
    return ""
}

// 使用示例
// name := getNestedString(data, "extra", "profile", "name")

📊 三种方案怎么选？

⚠️ 避坑指南

坑 1：数字全是 float64

// JSON: {"age": 30}
age := data["age"].(int)  // ❌ panic! 实际类型是 float64

// ✅ 正确
age := int(data["age"].(float64))
// 或用辅助函数
func getInt(m map[string]interface{}, key string) int {
    if v, ok := m[key].(float64); ok {
        return int(v)
    }
    return 0
}

坑 2：忘记检查类型断言结果

// ❌ 危险
email := data["email"].(string)  // 如果 email 是 null，直接 panic

// ✅ 安全
if email, ok := data["email"].(string); ok && email != "" {
    sendEmail(email)
}

坑 3：嵌套解析忘了判空

// ❌ 可能 panic
device := data["extra"].(map[string]interface{})["device"].(string)

// ✅ 层层检查
if extra, ok := data["extra"].(map[string]interface{}); ok {
    if device, ok := extra["device"].(string); ok {
        fmt.Println(device)
    }
}

🚀 进阶：第三方库推荐（可选）

如果动态 JSON 解析需求很复杂，可以考虑：

• gjson：用路径表达式快速取值，语法像 json.Get(data, "user.name")
• mapstructure：把 map[string]interface{} 转成 struct，适合"半动态"场景

// gjson 示例
import "github.com/tidwall/gjson"

value := gjson.Get(jsonString, "extra.device")
fmt.Println(value.String())  // 一行搞定，不用层层断言

💡 建议：先用标准库，遇到痛点再引入第三方库，避免过度设计。

🔚 总结

💡 最后一句忠告：
“能提前定义 struct，就别用动态解析；不得不用时，写好辅助函数，把复杂度封装起来。”

代码写得爽，维护不火葬场 🔥➡️✨