Golang中比较两个JSON的最佳方法

你能展示一下你目前的代码吗？并且能详细说明你提到的三个问题吗？另外，env 有什么特殊含义吗（例如，你是仅通过名称来匹配服务器中的书籍和 JSON 中的书籍，还是需要名称和 env 都相同）？

在Go中比较两个JSON结构的最佳方法是使用reflect.DeepEqual配合JSON反序列化，或者使用专门的JSON比较库如github.com/google/go-cmp/cmp。对于你的具体需求，需要比较并同步两个不同结构的JSON数据，这里提供两种解决方案：

方案1：使用反射和自定义比较逻辑

package main

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

type FileBook struct {
    Name string `json:"name"`
    Read bool   `json:"read"`
}

type FileEnv struct {
    Env   string      `json:"env"`
    Books []FileBook  `json:"books"`
}

type FileData struct {
    Envs []FileEnv `json:"envs"`
}

type ServerEnv struct {
    Name    string `json:"name"`
    Enabled bool   `json:"enabled"`
}

type ServerBook struct {
    Type  string      `json:"type"`
    Name  string      `json:"name"`
    Envs  []ServerEnv `json:"envs"`
}

type ServerData struct {
    Name  string        `json:"name"`
    Envs  []string      `json:"envs"`
    Books []ServerBook  `json:"books"`
}

func compareAndUpdate(fileJSON, serverJSON []byte) ([]string, []string, []string) {
    var fileData FileData
    var serverData ServerData
    
    json.Unmarshal(fileJSON, &fileData)
    json.Unmarshal(serverJSON, &serverData)
    
    fileBooks := make(map[string]bool)
    serverBooks := make(map[string]bool)
    
    for _, env := range fileData.Envs {
        for _, book := range env.Books {
            fileBooks[book.Name] = true
        }
    }
    
    for _, book := range serverData.Books {
        serverBooks[book.Name] = true
    }
    
    var toAdd []string
    var toRemove []string
    var toKeep []string
    
    for bookName := range fileBooks {
        if !serverBooks[bookName] {
            toAdd = append(toAdd, bookName)
        } else {
            toKeep = append(toKeep, bookName)
        }
    }
    
    for bookName := range serverBooks {
        if !fileBooks[bookName] {
            toRemove = append(toRemove, bookName)
        }
    }
    
    return toAdd, toRemove, toKeep
}

func main() {
    fileJSON := []byte(`{
        "envs": [{
            "env": "test",
            "books": [
                { "name": "book1", "read": true },
                { "name": "book2", "read": true },
                { "name": "book4", "read": true }
            ]
        }]
    }`)
    
    serverJSON := []byte(`{
        "name": "Default",
        "envs": ["test", "stag"],
        "books": [
            {
                "type": "release",
                "name": "book3",
                "envs": [
                    { "name": "test", "enabled": true },
                    { "name": "stag", "enabled": false }
                ]
            },
            {
                "type": "release",
                "name": "book2",
                "envs": [
                    { "name": "test", "enabled": true },
                    { "name": "stag", "enabled": false }
                ]
            }
        ]
    }`)
    
    toAdd, toRemove, toKeep := compareAndUpdate(fileJSON, serverJSON)
    
    fmt.Printf("需要添加的书籍: %v\n", toAdd)
    fmt.Printf("需要删除的书籍: %v\n", toRemove)
    fmt.Printf("需要保留的书籍: %v\n", toKeep)
}

方案2：使用go-cmp进行深度比较

package main

import (
    "encoding/json"
    "fmt"
    
    "github.com/google/go-cmp/cmp"
)

func compareJSONStructures(fileJSON, serverJSON []byte) (bool, string) {
    var fileData interface{}
    var serverData interface{}
    
    json.Unmarshal(fileJSON, &fileData)
    json.Unmarshal(serverJSON, &serverData)
    
    diff := cmp.Diff(fileData, serverData)
    if diff != "" {
        return false, diff
    }
    return true, ""
}

func extractBookNames(data interface{}) map[string]bool {
    books := make(map[string]bool)
    
    switch v := data.(type) {
    case map[string]interface{}:
        if envs, ok := v["envs"].([]interface{}); ok {
            for _, env := range envs {
                if envMap, ok := env.(map[string]interface{}); ok {
                    if bookList, ok := envMap["books"].([]interface{}); ok {
                        for _, book := range bookList {
                            if bookMap, ok := book.(map[string]interface{}); ok {
                                if name, ok := bookMap["name"].(string); ok {
                                    books[name] = true
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    return books
}

func main() {
    fileJSON := []byte(`{
        "envs": [{
            "env": "test",
            "books": [
                { "name": "book1", "read": true },
                { "name": "book2", "read": true },
                { "name": "book3", "read": true }
            ]
        }]
    }`)
    
    serverJSON := []byte(`{
        "name": "Default",
        "envs": ["test", "stag"],
        "books": [
            {
                "type": "release",
                "name": "book3",
                "envs": [
                    { "name": "test", "enabled": true },
                    { "name": "stag", "enabled": false }
                ]
            }
        ]
    }`)
    
    // 比较整体结构
    equal, diff := compareJSONStructures(fileJSON, serverJSON)
    fmt.Printf("结构是否相等: %v\n", equal)
    if !equal {
        fmt.Printf("差异: %s\n", diff)
    }
    
    // 提取并比较书籍名称
    var fileData, serverData interface{}
    json.Unmarshal(fileJSON, &fileData)
    json.Unmarshal(serverJSON, &serverData)
    
    fileBooks := extractBookNames(fileData)
    
    var serverBooks = make(map[string]bool)
    if serverMap, ok := serverData.(map[string]interface{}); ok {
        if books, ok := serverMap["books"].([]interface{}); ok {
            for _, book := range books {
                if bookMap, ok := book.(map[string]interface{}); ok {
                    if name, ok := bookMap["name"].(string); ok {
                        serverBooks[name] = true
                    }
                }
            }
        }
    }
    
    fmt.Printf("\n文件中的书籍: %v\n", fileBooks)
    fmt.Printf("服务器中的书籍: %v\n", serverBooks)
}

方案3：通用JSON比较函数

package main

import (
    "encoding/json"
    "fmt"
)

func compareJSON(a, b []byte) (bool, error) {
    var j1, j2 interface{}
    
    if err := json.Unmarshal(a, &j1); err != nil {
        return false, err
    }
    if err := json.Unmarshal(b, &j2); err != nil {
        return false, err
    }
    
    return deepEqual(j1, j2), nil
}

func deepEqual(a, b interface{}) bool {
    switch aVal := a.(type) {
    case map[string]interface{}:
        bVal, ok := b.(map[string]interface{})
        if !ok {
            return false
        }
        if len(aVal) != len(bVal) {
            return false
        }
        for key, aItem := range aVal {
            bItem, exists := bVal[key]
            if !exists || !deepEqual(aItem, bItem) {
                return false
            }
        }
        return true
        
    case []interface{}:
        bVal, ok := b.([]interface{})
        if !ok {
            return false
        }
        if len(aVal) != len(bVal) {
            return false
        }
        for i := range aVal {
            if !deepEqual(aVal[i], bVal[i]) {
                return false
            }
        }
        return true
        
    default:
        return a == b
    }
}

func getUpdateOperations(fileJSON, serverJSON []byte) (add, remove []string) {
    var fileData map[string]interface{}
    var serverData map[string]interface{}
    
    json.Unmarshal(fileJSON, &fileData)
    json.Unmarshal(serverJSON, &serverData)
    
    fileBooks := extractBooks(fileData)
    serverBooks := extractServerBooks(serverData)
    
    for book := range fileBooks {
        if !serverBooks[book] {
            add = append(add, book)
        }
    }
    
    for book := range serverBooks {
        if !fileBooks[book] {
            remove = append(remove, book)
        }
    }
    
    return add, remove
}

func extractBooks(data map[string]interface{}) map[string]bool {
    books := make(map[string]bool)
    
    if envs, ok := data["envs"].([]interface{}); ok {
        for _, env := range envs {
            if envMap, ok := env.(map[string]interface{}); ok {
                if bookList, ok := envMap["books"].([]interface{}); ok {
                    for _, book := range bookList {
                        if bookMap, ok := book.(map[string]interface{}); ok {
                            if name, ok := bookMap["name"].(string); ok {
                                books[name] = true
                            }
                        }
                    }
                }
            }
        }
    }
    
    return books
}

func extractServerBooks(data map[string]interface{}) map[string]bool {
    books := make(map[string]bool)
    
    if bookList, ok := data["books"].([]interface{}); ok {
        for _, book := range bookList {
            if bookMap, ok := book.(map[string]interface{}); ok {
                if name, ok := bookMap["name"].(string); ok {
                    books[name] = true
                }
            }
        }
    }
    
    return books
}

func main() {
    fileJSON := []byte(`{
        "envs": [{
            "env": "test",
            "books": [
                { "name": "book1", "read": true },
                { "name": "book2", "read": true },
                { "name": "book4", "read": true }
            ]
        }]
    }`)
    
    serverJSON := []byte(`{
        "name": "Default",
        "envs": ["test", "stag"],
        "books": [
            { "type": "release", "name": "book3" },
            { "type": "release", "name": "book2" }
        ]
    }`)
    
    add, remove := getUpdateOperations(fileJSON, serverJSON)
    
    fmt.Printf("需要添加: %v\n", add)
    fmt.Printf("需要删除: %v\n", remove)
    
    // 处理边界情况
    emptyServerJSON := []byte(`{"books": []}`)
    add2, remove2 := getUpdateOperations(fileJSON, emptyServerJSON)
    fmt.Printf("\n服务器为空时需要添加: %v\n", add2)
    fmt.Printf("服务器为空时需要删除: %v\n", remove2)
}

这些方案可以处理你提到的所有边界情况：

1. 服务器中的书籍数量为空时
2. 服务器中的书籍数量多于JSON文件时
3. JSON文件中的书籍数量多于服务器时

第一种方案使用结构体映射，适合结构固定的JSON；第二种方案使用go-cmp库，适合需要详细差异信息的场景；第三种方案使用通用接口，适合动态JSON结构。