Go语言中基于运行时条件动态控制JSON字段序列化

{
  "id": 1,
  "name": "John",
  "role": "admin",
  "email": "john@example.com"
}

{
  "id": 1,
  "name": "John"
}

package main

import (
    "encoding/json"
    "fmt"
)

// Role 定义用户角色
type Role string

const (
    Guest Role = "guest"
    Admin Role = "admin"
)

// UserResponse 表示用户数据，使用 omitempty 标签
type UserResponse struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Role  Role   `json:"role,omitempty"`  // 如果为零值，则省略
    Email string `json:"email,omitempty"` // 如果为零值，则省略
}

func main() {
    fmt.Println("--- 方案一：序列化前清空字段 ---")

    // 原始完整的用户数据
    fullUser := UserResponse{
        ID:    1,
        Name:  "John Doe",
        Role:  Admin,
        Email: "john.doe@example.com",
    }

    // 模拟访客用户场景
    // 创建一个副本，避免修改原始数据，或直接操作需要序列化的实例
    userForGuest := fullUser 
    // 对于访客，我们希望隐藏 Role 和 Email 字段。
    // 由于它们有 `omitempty` 标签，将其设置为零值即可实现省略。
    userForGuest.Role = ""  // Role (string) 的零值
    userForGuest.Email = "" // Email (string) 的零值

    guestJSON, err := json.MarshalIndent(userForGuest, "", "  ")
    if err != nil {
        fmt.Println("Error marshaling guest:", err)
        return
    }
    fmt.Println("访客视角 JSON (字段清空后):")
    fmt.Println(string(guestJSON))

    // 原始结构体字段被修改的演示
    // 注意：这种方法会直接修改用于序列化的结构体实例
    fmt.Printf("\n原始结构体字段被修改：Role='%s', Email='%s'\n", userForGuest.Role, userForGuest.Email)

    // 管理员视角（所有字段都可见）
    adminJSON, err := json.MarshalIndent(fullUser, "", "  ")
    if err != nil {
        fmt.Println("Error marshaling admin:", err)
        return
    }
    fmt.Println("\n管理员视角 JSON:")
    fmt.Println(string(adminJSON))
}

package main

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

// Role 定义用户角色
type Role string

const (
    Guest Role = "guest"
    Admin Role = "admin"
)

// UserResponse 表示需要动态序列化的用户数据结构
type UserResponse struct {
    ID          int    `json:"id"`
    Name        string `json:"name"`
    Role        Role   `json:"role,omitempty" auth_role:"admin"` // `auth_role` 用于自定义逻辑
    Email       string `json:"email,omitempty" auth_role:"admin"`
    CurrentRole Role   `json:"-"` // 内部字段，不参与序列化，用于传递上下文
}

// MarshalJSON 实现了 json.Marshaler 接口
func (ur UserResponse) MarshalJSON() ([]byte, error) {
    // 使用一个 map 来动态构建输出 JSON
    outputMap := make(map[string]interface{})

    // 使用反射遍历 UserResponse 的字段
    v := reflect.ValueOf(ur)
    t := v.Type()

    for i := 0; i < v.NumField(); i++ {
        field := t.Field(i)
        fieldValue := v.Field(i)

        // 跳过内部字段，例如 CurrentRole
        if field.Tag.Get("json") == "-" {
            continue
        }

        // 获取 JSON 标签名 (例如 "id", "name", "role")
        jsonTag := field.Tag.Get("json")
        jsonFieldName := strings.Split(jsonTag, ",")[0]
        if jsonFieldName == "" { // 如果 json 标签为空，则使用字段名
            jsonFieldName = field.Name
        }

        // 获取自定义的 `auth_role` 标签
        authRoleTag := field.Tag.Get("auth_role")

        // 检查基于角色的可见性
        // 如果 `auth_role` 被指定，并且当前用户角色与 `auth_role` 不匹配，则跳过此字段。
        if authRoleTag != "" && Role(authRoleTag) != ur.CurrentRole {
            continue
        }

        // 处理 `omitempty` 标签（如果字段没有被 `auth_role` 规则跳过）
        // 如果 `json` 标签包含 "omitempty" 并且字段值为零值，则跳过此字段。
        if strings.Contains(jsonTag, "omitempty") && fieldValue.IsZero() {
            continue
        }

        // 将字段添加到输出 map 中
        outputMap[jsonFieldName] = fieldValue.Interface()
    }

    // 将动态创建的 map 序列化为 JSON
    return json.Marshal(outputMap)
}

func main() {
    // 原始完整的用户数据
    fullUser := UserResponse{
        ID:    1,
        Name:  "John Doe",
        Role:  Admin,