如何在Go语言中将复杂结构体以JSON形式存储到数据存储（Datastore）

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"`
}

// DatastoreEntity 代表我们希望存储到Datastore的顶级实体
type DatastoreEntity struct {
    Name           string            `json:"name"`
    Phones         []string          `json:"phones"`
    Address        map[string]string `json:"address"`
    noJsonField    string            // 私有字段，不会被JSON编码
    SomethingComplex map[string]Complex `json:"somethingComplex"`
}

func main() {
    // 创建一个Complex实例
    complexData := Complex{
        ID: "comp-001",
        Data1: map[string]int{
            "keyA": 100,
            "keyB": 200,
        },
        Data2:     []byte("some raw bytes"),
        TimeStamp: time.Now(),
    }

    // 创建一个DatastoreEntity实例
    entity := DatastoreEntity{
        Name: "示例公司",
        Phones: []string{
            "123-456-7890",
            "987-654-3210",
        },
        Address: map[string]string{
            "street": "主街123号",
            "city":   "示例市",
            "zip":    "12345",
        },
        noJsonField: "这是一个不应被编码的内部字段", // 这个字段不会出现在JSON中
        SomethingComplex: map[string]Complex{
            "primary": complexData,
            "secondary": {
                ID: "comp-002",
                Data1: map[string]int{"val": 50},
                TimeStamp: time.Now().Add(-24 * time.Hour),
            },
        },
    }

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

    // 打印JSON字符串
    fmt.Println("序列化后的JSON数据：")
    fmt.Println(string(jsonData))

    // 这个 jsonData ([]byte) 就是可以存储到Datastore的“原样”数据
    // 假设Datastore中有一个字段类型为 []byte 或 string
    // 例如: type MyDatastoreRecord struct { ID string; Data []byte }
    // record := MyDatastoreRecord{ID: "some-id", Data: jsonData}
    // datastoreClient.Put(ctx, record)

    // --- 反序列化示例（从Datastore取回数据后） ---
    var retrievedEntity DatastoreEntity
    err = json.Unmarshal(jsonData, &retrievedEntity) // 从 []byte 反序列化回结构体
    if err != nil {
        fmt.Printf("JSON反序列化失败: %v\n", err)
        return
    }

    fmt.Println("\n反序列化后的实体名称:", retrievedEntity.Name)
    fmt.Println("反序列化后的实体电话:", retrievedEntity.Phones)
    fmt.Println("反序列化后的复杂数据ID (primary):", retrievedEntity.SomethingComplex["primary"].ID)
    // 注意：noJsonField 不会被反序列化，因为它不在JSON数据中
    fmt.Println("反序列化后的内部字段 (noJsonField):", retrievedEntity.noJsonField) // 将为空字符串
}

// 假设这是您的Datastore实体定义
type MyDatastoreRecord struct {
    ID   string
    JsonData []byte // 存储JSON字节数组
}

// 在您的Datastore操作中
// ...
// jsonData, err := json.Marshal(entity)
// if err != nil { /* handle error */ }
//
// record := MyDatastoreRecord{
//     ID:       "unique-entity-id",
//     JsonData: jsonData,
// }
//
// _, err = datastoreClient.Put(ctx, datastore.NameKey("MyRecord", record.ID, nil), &record)
// if err != nil { /* handle error */ }
// ...