Go语言中处理多态JSON数据反序列化的策略与实践

type ServerResponse struct {
  Total int
  Data  []ServerItem // 期望这里能容纳User或Book
}

type ServerItem interface {
  // ... 共同方法
}

type User struct {
  // ... User特有字段
}

type Book struct {
  // ... Book特有字段
}

package main

import (
    "encoding/json"
    "fmt"
)

// ServerItem 接口，定义了所有多态项应具备的共同行为
type ServerItem interface {
    GetKind() string
}

// User 是一个具体的项目类型
type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
    Kind string `json:"kind"` // 判别字段，用于识别类型
}

func (u User) GetKind() string { return u.Kind }

// Book 是另一个具体的项目类型
type Book struct {
    Name   string `json:"name"`
    Author string `json:"author"`
    Kind   string `json:"kind"` // 判别字段
}

func (b Book) GetKind() string { return b.Kind }

// ServerResponse 包含一个总数和原始的JSON数据切片
type ServerResponse struct {
    Total int               `json:"total"`
    Data  []json.RawMessage `json:"data"` // 使用 json.RawMessage 延迟反序列化
}

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

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

    fmt.Printf("总计项目数: %d\n", response.Total)

    var processedItems []ServerItem // 用于存储反序列化后的具体类型实例

    for i, rawData := range response.Data {
        // 第一步：初步反序列化以获取判别字段 (kind)
        var temp map[string]interface{}
        err := json.Unmarshal(rawData, &temp)
        if err != nil {
            fmt.Printf("错误：无法将第 %d 个项目反序列化为临时 map: %v\n", i, err)
            continue
        }

        kind, ok := temp["kind"].(string)
        if !ok {
            fmt.Printf("错误：第 %d 个项目缺少 'kind' 字段或其类型不是字符串\n", i)
            continue
        }

        // 第二步：根据判别字段的值，将原始 rawData 反序列化到具体的结构体
        switch kind {
        case "user":
            var user User
            err := json.Unmarshal(rawData, &user) // 再次反序列化原始数据
            if err != nil {
                fmt.Printf("错误：无法将第 %d 个项目反序列化为 User 类型: %v\n", i, err)
                continue
            }
            processedItems = append(processedItems, user)
            fmt.Printf("已处理 User: %+v\n", user)
        case "book":
            var book Book
            err := json.Unmarshal(rawData, &book) // 再次反序列化原始数据
            if err != nil {
                fmt.Printf("错误：无法将第 %d 个项目反序列化为 Book 类型: %v\n", i, err)
                continue
            }
            processedItems = append(processedItems, book)
            fmt.Printf("已处理 Book: %+v\n", book)
        default:
            fmt.Printf("警告：未知项目类型 '%s'，跳过第 %d 个项目\n", kind, i)
        }
    }

    fmt.Println("\n--- 所有已处理的项目 ---")
    for _, item := range processedItems {
        fmt.Printf("项目类型: %s, 数据: %+v\n", item.GetKind(), item)
        // 现在可以安全地进行类型断言，访问具体类型的字段
        if user, ok := item.(User); ok {
            fmt.Printf("  具体 User 姓名: %s\n", user.Name)
        }
        if book, ok := item.(Book); ok {
            fmt.Printf("  具体 Book 作者: %s\n", book.Author)
        }
    }
}

总计项目数: 2
已处理 User: {Name:Alice Age:30 Kind:user}
已处理 Book: {Name:The Go Programming Language Author:Alan A. A. Donovan & Brian W. Kernighan Kind:book}

--- 所有已处理的项目 ---
项目类型: user, 数据: {Name:Alice Age:30 Kind:user}
  具体 User 姓名: Alice
项目类型: book, 数据: {Name:The Go Programming Language Author:Alan A. A. Donovan & Brian W. Kernighan Kind:book}
  具体 Book 作者: Alan A. A. Donovan & Brian W. Kernighan

// 替代的 ServerResponse 结构体
type AlternativeServerResponse struct {
    Total int                      `json:"total"`
    Data  []map[string]interface{} `json:"data"` // 直接反序列化为 map 切片
}

// ... 在 main 函数中
// var altResponse AlternativeServerResponse
// err := json.Unmarshal([]byte(jsonResponse), &altResponse)
// ...
// for i, itemMap := range altResponse.Data {
//     kind, ok := itemMap["kind"].(string)
//     // ... 根据 kind 再次将 itemMap 序列化为 JSON 字符串，再反序列化到具体结构体
//     // 或者手动从 itemMap 赋值到具体结构体字段
// }

// 示例：为 ServerItemWrapper 实现 UnmarshalJSON
type ServerItemWrapper struct {
    Item ServerItem
}

func (sw *ServerItemWrapper) UnmarshalJSON(b []byte) error {
    var temp map[string]interface{}
    if err := json.Unmarshal(b, &temp); err != nil {
        return err
    }

    kind, ok := temp["kind"].(string)
    if !ok {
        return fmt.Errorf("缺少 'kind' 字段或其类型不是字符串")
    }

    switch kind {
    case "user":
        var user User
        if err := json.Unmarshal(b, &user); err != nil {