Go语言JSON解组进阶：灵活处理多态数据结构

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

type ServerItem struct {
  // 基础字段，或作为接口的占位符
}

type User struct {
  ServerItem // 嵌入基础结构体
  Name  string
  Age   int
}

type Book struct {
  ServerItem // 嵌入基础结构体
  Name      string
  Author    string
}

package main

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

// ServerResponse 包含一个总数和原始JSON消息的数据切片
type ServerResponse struct {
    Total int               `json:"total"`
    Data  []json.RawMessage `json:"data"` // 使用 json.RawMessage 存储原始JSON数据
}

// User 定义用户结构体
type User struct {
    Type string `json:"type"` // 用于区分类型的字段
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// Book 定义书籍结构体
type Book struct {
    Type   string `json:"type"` // 用于区分类型的字段
    Name   string `json:"name"`
    Author string `json:"author"`
}

// ItemType 辅助结构体，用于仅获取类型字段
type ItemType struct {
    Type string `json:"type"`
}

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

func main() {
    jsonResponse := `
{
  "total": 2,
  "data": [
    {
      "type": "user",
      "name": "Alice",
      "age": 30
    },
    {
      "type": "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 {
        log.Fatalf("Failed to unmarshal server response: %v", err)
    }

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

    // 用于存储所有解析后的具体对象
    var parsedItems []interface{}

    for i, rawItem := range response.Data {
        var itemType ItemType
        // 第一次解组：只获取类型字段
        if err := json.Unmarshal(rawItem, &itemType); err != nil {
            log.Printf("Failed to unmarshal item %d type: %v", i, err)
            continue
        }

        switch itemType.Type {
        case "user":
            var user User
            if err := json.Unmarshal(rawItem, &user); err != nil {
                log.Printf("Failed to unmarshal item %d as User: %v", i, err)
                continue
            }
            fmt.Printf("Parsed User: %+v\n", user)
            parsedItems = append(parsedItems, user)
        case "book":
            var book Book
            if err := json.Unmarshal(rawItem, &book); err != nil {
                log.Printf("Failed to unmarshal item %d as Book: %v", i, err)
                continue
            }
            fmt.Printf("Parsed Book: %+v\n", book)
            parsedItems = append(parsedItems, book)
        default:
            fmt.Printf("Unknown item type for item %d: %s\n", i, itemType.Type)
        }
    }

    fmt.Println("\n--- All Parsed Items ---")
    for _, item := range parsedItems {
        // 这里可以根据类型断言来进一步处理
        switch v := item.(type) {
        case User:
            fmt.Printf("User object: Name=%s, Age=%d\n", v.Name, v.Age)
        case Book:
            fmt.Printf("Book object: Name=%s, Author=%s\n", v.Name, v.Author)
        default:
            fmt.Printf("Unknown object type: %T\n", v)
        }
    }
}

Total items: 2
Parsed User: {Type:user Name:Alice Age:30}
Parsed Book: {Type:book Name:The Go Programming Language Author:Alan A. A. Donovan & Brian W. Kernighan}

--- All Parsed Items ---
User object: Name=Alice, Age=30
Book object: Name=The Go Programming Language, Author=Alan A. A. Donovan & Brian W. Kernighan