Go语言中处理JSON序列化与非导出字段的策略

package main

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

// internalData 是一个非导出类型，用于内部存储和JSON操作。
// 它的字段是导出的，以便json包可以通过反射访问。
// 这里的字段名与JSON字段名保持一致，也可以通过json tag自定义。
type internalData struct {
    FieldOne string `json:"field_one"` // 使用json tag来定义JSON字段名
    FieldTwo int    `json:"field_two"`
    // 可以有更多需要通过JSON处理的字段
}

// ExternalData 是一个导出类型，提供外部API和封装。
// 它嵌入了internalData，以便通过接口方法控制JSON序列化/反序列化。
type ExternalData struct {
    internalData // 嵌入非导出类型，实现了数据的封装
    Metadata     string `json:"-"` // 这个字段不会被JSON处理，因为有`json:"-"` tag
    // ExternalData可以有自己的额外字段，这些字段可能不需要被JSON处理
    // 或者需要不同的处理逻辑。
}

// MarshalJSON 实现了json.Marshaler接口，用于自定义ExternalData的JSON序列化。
// 当对ExternalData实例调用json.Marshal时，会调用此方法。
func (d ExternalData) MarshalJSON() ([]byte, error) {
    // 直接序列化嵌入的internalData结构体。
    // internalData的所有字段都是导出的，因此json包可以正常处理它们。
    // 这里使用d.internalData，因为MarshalJSON的接收者是值类型。
    return json.Marshal(d.internalData)
}

// UnmarshalJSON 实现了json.Unmarshaler接口，用于自定义ExternalData的JSON反序列化。
// 当将JSON数据反序列化到ExternalData实例时，会调用此方法。
func (d *ExternalData) UnmarshalJSON(b []byte) error {
    // 将传入的JSON字节反序列化到嵌入的internalData结构体中。
    // 注意这里使用&d.internalData，因为需要修改其值。
    return json.Unmarshal(b, &d.internalData)
}

// FieldOne 是一个Getter方法，提供对内部FieldOne的受控访问。
// 遵循Go语言的Getter命名习惯。
func (d *ExternalData) FieldOne() string {
    return d.internalData.FieldOne
}

// SetFieldOne 是一个Setter方法，提供对内部FieldOne的受控修改。
func (d *ExternalData) SetFieldOne(val string) {
    d.internalData.FieldOne = val
}

// FieldTwo 是一个Getter方法。
func (d *ExternalData) FieldTwo() int {
    return d.internalData.FieldTwo
}

// SetFieldTwo 是一个Setter方法。
func (d *ExternalData) SetFieldTwo(val int) {
    d.internalData.FieldTwo = val
}

func main() {
    fmt.Println("--- 演示自定义JSON序列化与反序列化 ---")

    // 1. 创建一个ExternalData实例
    data := ExternalData{
        internalData: internalData{
            FieldOne: "Hello Go World",
            FieldTwo: 42,
        },
        Metadata: "This is some private metadata", // Metadata字段不应被JSON处理
    }
    fmt.Printf("原始数据: %+v\n", data)
    fmt.Printf("通过Getter访问FieldOne: %s\n", data.FieldOne())
    fmt.Printf("通过Getter访问FieldTwo: %d\n", data.FieldTwo())
    fmt.Printf("Metadata字段: '%s'\n", data.Metadata)

    // 2. 序列化 ExternalData 到 JSON
    fmt.Println("\n--- 序列化 ---")
    jsonData, err := json.MarshalIndent(data, "", "  ")
    if err != nil {
        log.Fatalf("序列化失败: %v\n", err)
    }
    fmt.Printf("序列化结果:\n%s\n", jsonData)
    // 预期输出: {"field_one": "Hello Go World", "field_two": 42}
    // 注意Metadata字段不会出现在JSON中

    // 3. 反序列化 JSON 到新的 ExternalData 实例
    fmt.Println("\n--- 反序列化 ---")
    var newData ExternalData
    err = json.Unmarshal(jsonData, &newData)
    if err != nil {
        log.Fatalf("反序列化失败: %v\n", err)
    }
    fmt.Printf("反序列化结果: %+v\n", newData)
    fmt.Printf("反序列化后通过Getter访问FieldOne: %s\n", newData.FieldOne())
    fmt.Printf("反序列化后通过Getter访问FieldTwo: %d\n", newData.FieldTwo())
    // 预期newData.Metadata为空字符串，因为它在反序列化时不会被填充
    fmt.Printf("反序列化后Metadata字段 (应为空): '%s'\n", newData.Metadata)

    // 4. 修改内部数据并通过JSON序列化验证
    fmt.Println("\n--- 修改数据并再次序列化 ---")
    newData.SetFieldOne("Updated Value")
    newData.SetFieldTwo(100)
    updatedJsonData, err := json.MarshalIndent(newData, "", "  ")
    if err != nil {
        log.Fatalf("再次序列化失败: %v\n", err)
    }
    fmt.Printf("修改后序列化结果:\n%s\n", updatedJsonData)
}