Go语言中处理多态JSON数据：灵活的Unmarshal策略

{
  "total": 2,
  "data": [
    {
      "name": "Alice",
      "age": 30
    },
    {
      "name": "Bob",
      "age": 25
    }
  ]
}

package main

import (
    "encoding/json"
    "fmt"
)

type ServerResponse struct {
    Total int    `json:"total"`
    Data  []User `json:"data"`
}

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    jsonData := `{"total": 2, "data": [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]}`

    var response ServerResponse
    err := json.Unmarshal([]byte(jsonData), &response)
    if err != nil {
        fmt.Println("Error unmarshalling:", err)
        return
    }

    fmt.Printf("Total users: %d\n", response.Total)
    for _, user := range response.Data {
        fmt.Printf("User: %s, Age: %d\n", user.Name, user.Age)
    }
}

type ServerItem struct {
    // 可能包含所有数据类型共有的字段，或者只是一个标记
}

type User struct {
    ServerItem
    Name string `json:"name"`
    Age  int    `json:"age"`
}

type Book struct {
    ServerItem
    Name   string `json:"name"`
    Author string `json:"author"`
}

type PolymorphicServerResponse struct {
    Total int          `json:"total"`
    Data  []ServerItem `json:"data"` // 这里的 ServerItem 是一个结构体，不是接口
}

{
  "total": 2,
  "data": [
    {
      "type": "user",
      "name": "Alice",
      "age": 30
    },
    {
      "type": "book",
      "name": "The Go Programming Language",
      "author": "Alan A. A. Donovan, Brian W. Kernighan"
    }
  ]
}

package main

import (
    "encoding/json"
    "fmt"
)

// ServerItem 结构体作为嵌入字段，如果它没有自己的JSON字段，可以为空
type ServerItem struct{} 

type User struct {
    ServerItem // 嵌入 ServerItem
    Name       string `json:"name"`
    Age        int    `json:"age"`
}

type Book struct {
    ServerItem // 嵌入 ServerItem
    Name       string `json:"name"`
    Author     string `json:"author"`
}

// 定义一个接口来统一处理不同类型的ServerItem
type Item interface {
    IsServerItem() // 标记接口，实际不实现任何功能
}

// 让 User 和 Book 实现 Item 接口
func (u User) IsServerItem() {}
func (b Book) IsServerItem() {}

func main() {
    jsonData := `
    {
      "total": 2,
      "data": [
        {
          "type": "user",
          "name": "Alice",
          "age": 30
        },
        {
          "type": "book",
          "name": "The Go Programming Language",
          "author": "Alan A. A. Donovan, Brian W. Kernighan"
        }
      ]
    }`

    // 第一步：将整个JSON解码到 map[string]interface{}
    var rawResponse map[string]interface{}
    err := json.Unmarshal([]byte(jsonData), &rawResponse)
    if err != nil {
        fmt.Println("Error unmarshalling raw response:", err)
        return
    }

    total := int(rawResponse["total"].(float64)) // JSON数字默认解析为 float64
    fmt.Printf("Total items: %d\n", total)

    // 第二步：访问 'data' 字段，它将是一个 []interface{}
    rawData, ok := rawResponse["data"].([]interface{})
    if !ok {
        fmt.Println("Error: 'data' field is not a slice")
        return
    }

    var items []Item // 创建一个 Item 接口切片来存储解析后的具体类型
    for _, itemData := range rawData {
        // 每个 itemData 都是一个 map[string]interface{}
        itemMap, ok := itemData.(map[string]interface{})
        if !ok {
            fmt.Println("Error: item in data is not a map")
            continue
        }

        // 第三步：根据 'type' 字段识别具体类型并进行转换
        itemType, ok := itemMap["type"].(string)
        if !ok {
            fmt.Println("Error: 'type' field not found or not a string")
            continue
        }

        // 将当前 itemMap 重新编码为JSON字符串，然后解码到具体结构体
        // 这种方法简洁，但涉及两次编解码，可能略有性能开销
        itemJSON, err := json.Marshal(itemMap)
        if err != nil {
            fmt.Println("Error marshalling item map:", err)
            continue
        }

        switch itemType {
        case "user":
            var user User
            err := json.Unmarshal(itemJSON, &user)
            if err != nil {
                fmt.Println("Error unmarshalling user:", err)
                continue
            }
            items = append(items, user)
        case "book":
            var book Book
            err := json.Unmarshal(itemJSON, &book)
            if err != nil {
                fmt.Println("Error unmarshalling book:", err)
                continue
            }
            items = append(items, book)
        default:
            fmt.Printf("Unknown item type: %s\n", itemType)
        }
    }

    // 遍历并处理解析后的 Item 接口切片
    fmt.Println("\nParsed Items:")
    for _, item := range items {
        switch v := item.(type) {
        case User:
            fmt.Printf("  User: %s, Age: %d\n", v.Name, v.Age)
        case Book:
            fmt.Printf("  Book: %s, Author: %s\n", v.Name, v.Author)
        default:
            fmt.Println("  Unknown item type in final slice.")
        }
    }
}