Go语言中优雅地解析Neo4j事务的复杂JSON结果

{
  "results": [
    {"columns":[],"data":[]},
    {"columns":["r"],"data": [ // 包含实际数据的结果集
      {"row":[{"id":"1","name":"test1"}]},
      {"row":[{"id":"2","name":"test2"}]},
      {"row":[{"id":"3","name":"test3"}]}
    ]}
  ],
  "errors": []
}

{
  "results": [
    {"columns":[],"data":[]},
    {"columns":["r"],"data": [ // 包含实际数据的结果集
      {"row":[{"id":"4","number":"555-1234"}]},
      {"row":[{"id":"5","number":"555-1232"}]}
    ]}
  ],
  "errors": []
}

// Person 结构体表示一个人
type Person struct {
    Id   string `json:"id"`
    Name string `json:"name"`
}

// Phone 结构体表示一个电话
type Phone struct {
    Id     string `json:"id"`
    Number string `json:"number"`
}

import "encoding/json"

// Neo4jDataRow 结构体用于捕获 Neo4j 响应中 data 数组内的 row 字段
// 由于 row 的内容可以是不同的业务结构，我们使用 []json.RawMessage 延迟解析
type Neo4jDataRow struct {
    Row []json.RawMessage `json:"row"`
}

// Neo4jResult 结构体用于捕获 Neo4j 响应中 results 数组内的每个元素
type Neo4jResult struct {
    Columns []string       `json:"columns"`
    Data    []Neo4jDataRow `json:"data"`
}

// Neo4jTransactionResponse 结构体表示完整的 Neo4j 事务响应
type Neo4jTransactionResponse struct {
    Results []Neo4jResult `json:"results"`
    Errors  []string      `json:"errors"` // 或者定义更详细的错误结构体
}

package main

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

// Person 结构体表示一个人
type Person struct {
    Id   string `json:"id"`
    Name string `json:"name"`
}

// Phone 结构体表示一个电话
type Phone struct {
    Id     string `json:"id"`
    Number string `json:"number"`
}

// Neo4jDataRow 结构体用于捕获 Neo4j 响应中 data 数组内的 row 字段
type Neo4jDataRow struct {
    Row []json.RawMessage `json:"row"`
}

// Neo4jResult 结构体用于捕获 Neo4j 响应中 results 数组内的每个元素
type Neo4jResult struct {
    Columns []string       `json:"columns"`
    Data    []Neo4jDataRow `json:"json.RawMessage"` // 注意这里的json tag是错误的，应为"data"
}

// Neo4jResult 结构体用于捕获 Neo4j 响应中 results 数组内的每个元素
type CorrectedNeo4jResult struct {
    Columns []string       `json:"columns"`
    Data    []Neo4jDataRow `json:"data"` // 修正后的json tag
}

// Neo4jTransactionResponse 结构体表示完整的 Neo4j 事务响应
type Neo4jTransactionResponse struct {
    Results []CorrectedNeo4jResult `json:"results"`
    Errors  []string               `json:"errors"`
}

func main() {
    // 示例 Neo4j JSON 响应数据 (Person)
    personJSON := `{
      "results": [
        {"columns":[],"data":[]},
        {"columns":["r"],"data": [
          {"row":[{"id":"1","name":"test1"}]},
          {"row":[{"id":"2","name":"test2"}]},
          {"row":[{"id":"3","name":"test3"}]}
        ]}
      ],
      "errors": []
    }`

    // 示例 Neo4j JSON 响应数据 (Phone)
    phoneJSON := `{
      "results": [
        {"columns":[],"data":[]},
        {"columns":["r"],"data": [
          {"row":[{"id":"4","number":"555-1234"}]},
          {"row":[{"id":"5","number":"555-1232"}]},
          {"row":[{"id":"6","number":"555-1235"}]}
        ]}
      ],
      "errors": []
    }`

    // 解析 Person 数据
    fmt.Println("--- 解析 Person 数据 ---")
    var personResponse Neo4jTransactionResponse
    err := json.Unmarshal([]byte(personJSON), &personResponse)
    if err != nil {
        log.Fatalf("解析 Person JSON 失败: %v", err)
    }
    extractAndProcessData(personResponse, "person")

    fmt.Println("\n--- 解析 Phone 数据 ---")
    // 解析 Phone 数据
    var phoneResponse Neo4jTransactionResponse
    err = json.Unmarshal([]byte(phoneJSON), &phoneResponse)
    if err != nil {
        log.Fatalf("解析 Phone JSON 失败: %v", err)
    }
    extractAndProcessData(phoneResponse, "phone")
}

// extractAndProcessData 负责从 Neo4jTransactionResponse 中提取并处理数据
func extractAndProcessData(response Neo4jTransactionResponse, dataType string) {
    if len(response.Errors) > 0 {
        fmt.Printf("Neo4j 事务返回错误: %v\n", response.Errors)
        return
    }

    // 遍历 results 数组，通常我们只关心最后一个有数据的 result
    for i := len(response.Results) - 1; i >= 0; i-- {
        result := response.Results[i]
        if len(result.Data) > 0 {
            fmt.Printf("找到包含数据的 result (索引 %d)\n", i)
            for _, dataEntry := range result.Data {
                for _, rawRow := range dataEntry.Row {
                    switch dataType {
                    case "person":
                        var p Person
                        if err := json.Unmarshal(rawRow, &p); err != nil {
                            fmt.Printf("反序列化 Person 失败: %v, 原始数据: %s\n", err, string(rawRow))
                            continue
                        }
                        fmt.Printf("提取到 Person: %+v\n", p)
                    case "phone":
                        var ph Phone
                        if err := json.Unmarshal(rawRow, &ph); err != nil {
                            fmt.Printf("反序列化 Phone 失败: %v, 原始数据: %s\n", err, string(rawRow))
                            continue
                        }
                        fmt.Printf("提取到 Phone: %+v\n", ph)
                    default:
                        fmt.Printf("未知数据类型 '%s'，原始数据: %s\n", dataType, string(rawRow))
                    }
                }
            }
            return // 假设我们只处理第一个找到的数据集
        }
    }
    fmt.Println("未找到任何包含数据的 result。")
}