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

package main

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

// User 定义用户结构体
type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// ServerResponse 定义服务器响应结构体，Data字段为User切片
type ServerResponse struct {
    Total int    `json:"total"`
    Data  []User `json:"data"`
}

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

    var response ServerResponse
    err := json.Unmarshal([]byte(jsonStr), &response)
    if err != nil {
        log.Fatalf("Unmarshal error: %v", err)
    }

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

// ServerItem 基础结构体，可能包含类型标识符
type ServerItem struct {
    Type string `json:"type"` // 用于区分具体类型的字段
}

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

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

// ServerResponseWithRawData 结构体，Data字段为json.RawMessage
type ServerResponseWithRawData struct {
    Total int             `json:"total"`
    Data  json.RawMessage `json:"data"` // 延迟解析Data字段
}

{
  "total": 3,
  "data": [
    {
      "type": "user",
      "name": "Alice",
      "age": 30
    },
    {
      "type": "book",
      "name": "The Go Programming Language",
      "author": "Alan A. A. Donovan"
    },
    {
      "type": "user",
      "name": "Bob",
      "age": 25
    }
  ]
}

package main

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

// ServerItem 基础结构体，包含类型标识符
type ServerItem struct {
    Type string `json:"type"`
}

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

// Book 结构体
type Book struct {
    ServerItem
    Name   string `json:"name"`
    Author string `json:"author"`
}

// ServerResponseWithRawData 初始反序列化结构
type ServerResponseWithRawData struct {
    Total int             `json:"total"`
    Data  json.RawMessage `json:"data"` // 使用json.RawMessage延迟解析
}

func main() {
    jsonStr := `{
        "total": 3,
        "data": [
            {
                "type": "user",
                "name": "Alice",
                "age": 30
            },
            {
                "type": "book",
                "name": "The Go Programming Language",
                "author": "Alan A. A. Donovan"
            },
            {
                "type": "user",
                "name": "Bob",
                "age": 25
            }
        ]
    }`

    var rawResponse ServerResponseWithRawData
    err := json.Unmarshal([]byte(jsonStr), &rawResponse)
    if err != nil {
        log.Fatalf("Unmarshal raw response error: %v", err)
    }

    fmt.Printf("Total items: %d\n", rawResponse.Total)

    // 将Data字段的原始JSON字节反序列化为[]map[string]interface{}
    var dataItems []map[string]interface{}
    err = json.Unmarshal(rawResponse.Data, &dataItems)
    if err != nil {
        log.Fatalf("Unmarshal data items error: %v", err)
    }

    var users []User
    var books []Book
    var allItems []interface{} // 用于存储所有解析出的具体对象

    for _, itemMap := range dataItems {
        // 检查"type"字段以确定具体类型
        if itemType, ok := itemMap["type"].(string); ok {
            // 将当前map[string]interface{}重新编码为JSON字节，再反序列化为具体类型
            itemBytes, err := json.Marshal(itemMap)
            if err != nil {
                log.Printf("Error marshalling item map: %v", err)
                continue
            }

            switch itemType {
            case "user":
                var user User
                if err := json.Unmarshal(itemBytes, &user); err != nil {
                    log.Printf("Error unmarshalling user: %v", err)
                    continue
                }
                users = append(users, user)
                allItems = append(allItems, user)
            case "book":
                var book Book
                if err := json.Unmarshal(itemBytes, &book); err != nil {
                    log.Printf("Error unmarshalling book: %v", err)
                    continue
                }
                books = append(books, book)
                allItems = append(allItems, book)
            default:
                log.Printf("Unknown item type: %s", itemType)
            }
        } else {
            log.Println("Item missing 'type' field or 'type' is not a string.")
        }
    }

    fmt.Println("\n--- Parsed Users ---")
    for _, user := range users {
        fmt.Printf("User (Type: %s): %s, Age: %d\n", user.Type, user.Name, user.Age)
    }

    fmt.Println("\n--- Parsed Books ---")
    for _, book := range books {
        fmt.Printf("Book (Type: %s): %s, Author: %s\n", book.Type, book.Name, book.Author)
    }

    fmt.Println("\n--- All Parsed Items (via interface{}) ---")
    for i, item := range allItems {
        switch v := item.(type) {
        case User:
            fmt.Printf("Item %d is a User: %s (Age: %d)\n", i+1, v.Name, v.Age)
        case Book:
            fmt.Printf("Item %d is a Book: %s (Author: %s)\n", i+1, v.Name, v.Author)
        default:
            fmt.Printf("Item %d is an unknown type: %T\n", i+1, v)
        }
    }
}