Go语言数据存储：将复杂结构体或JSON对象高效持久化

package main

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

// Complex 嵌套结构体，包含多种数据类型
type Complex struct {
    ID        string         `json:"id"`
    Data1     map[string]int `json:"data1"`
    Data2     []byte         `json:"data2"`
    Timestamp time.Time      `json:"timestamp"`
}

// DatastoreObject 待存储到数据存储的顶级结构体
type DatastoreObject struct {
    Name           string            `json:"name"`
    Phones         []string          `json:"phones"`
    Address        map[string]string `json:"address"`
    notExported    string            // 私有字段，不会被json.Marshal序列化
    SomethingComplex map[string]Complex `json:"something_complex"`
}

func main() {
    // 示例数据
    complexData := Complex{
        ID:        "comp-123",
        Data1:     map[string]int{"keyA": 100, "keyB": 200},
        Data2:     []byte("some binary data"),
        Timestamp: time.Now(),
    }

    datastoreObj := DatastoreObject{
        Name:    "Example Entity",
        Phones:  []string{"123-456-7890", "987-654-3210"},
        Address: map[string]string{"street": "123 Main St", "city": "Anytown"},
        notExported: "this field is private", // 不会被序列化
        SomethingComplex: map[string]Complex{
            "first_complex": complexData,
            "second_complex": {
                ID:        "comp-456",
                Data1:     map[string]int{"keyC": 300},
                Timestamp: time.Now().Add(time.Hour),
            },
        },
    }

    // 将结构体序列化为JSON字节数组
    jsonData, err := json.Marshal(datastoreObj)
    if err != nil {
        fmt.Printf("JSON Marshal error: %v\n", err)
        return
    }

    fmt.Println("Serialized JSON data:")
    fmt.Println(string(jsonData))

    // 假设这里将 jsonData 存储到数据存储的某个字节数组或字符串字段中
    fmt.Println("\n--- Storing jsonData to Datastore ---")
    // 例如：
    // datastoreClient.Put(ctx, key, &struct{
    //     JSONPayload []byte `datastore:"jsonPayload"`
    // }{
    //     JSONPayload: jsonData,
    // })

    // 从数据存储中检索后，反序列化回Go结构体
    fmt.Println("\n--- Retrieving from Datastore and Unmarshalling ---")
    var retrievedObj DatastoreObject
    err = json.Unmarshal(jsonData, &retrievedObj) // 假设 jsonData 是从数据存储中取回的
    if err != nil {
        fmt.Printf("JSON Unmarshal error: %v\n", err)
        return
    }

    fmt.Printf("Retrieved Object Name: %s\n", retrievedObj.Name)
    fmt.Printf("Retrieved Object Phones: %v\n", retrievedObj.Phones)
    fmt.Printf("Retrieved Object SomethingComplex ID: %s\n", retrievedObj.SomethingComplex["first_complex"].ID)
    // 私有字段 notExported 不会被反序列化，保持其默认零值
    fmt.Printf("Retrieved Object notExported (should be empty): '%s'\n", retrievedObj.notExported)
}

jsonData, err := json.Marshal(yourComplexStruct)
if err != nil {
    // 处理错误
    log.Fatalf("Failed to marshal struct to JSON: %v", err)
}
// jsonData 现在是 []byte 类型，可以直接存储到数据存储中
// 例如，将其存储为数据存储实体的一个字节数组字段或字符串字段。

var retrievedStruct YourComplexStruct
err := json.Unmarshal(retrievedJSONData, &retrievedStruct)
if err != nil {
    // 处理错误
    log.Fatalf("Failed to unmarshal JSON to struct: %v", err)
}
// retrievedStruct 现在包含了原始的数据