在Go语言中根据运行时条件动态控制JSON字段输出的教程

package main

import (
    "encoding/json"
    "fmt"
)

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

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

// User 表示用户信息
type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    Role string `json:"role,omitempty"` // role字段只有在非零值时才输出
}

// PrepareUserForRole 根据角色准备User结构体
func PrepareUserForRole(user User, role UserRole) User {
    if role == Guest {
        // 对于Guest用户，清空Role字段，使其在JSON中被omitempty省略
        user.Role = ""
    }
    return user
}

func main() {
    adminUser := User{ID: 1, Name: "John", Role: "admin"}
    guestUser := User{ID: 2, Name: "Jane", Role: "guest"}

    // 为Admin用户序列化
    adminPreparedUser := PrepareUserForRole(adminUser, Admin)
    adminJSON, err := json.MarshalIndent(adminPreparedUser, "", "  ")
    if err != nil {
        fmt.Println("Error marshalling admin user:", err)
        return
    }
    fmt.Println("Admin JSON:")
    fmt.Println(string(adminJSON))
    // 预期输出:
    // {
    //   "id": 1,
    //   "name": "John",
    //   "role": "admin"
    // }

    fmt.Println("---")

    // 为Guest用户序列化
    guestPreparedUser := PrepareUserForRole(guestUser, Guest)
    guestJSON, err := json.MarshalIndent(guestPreparedUser, "", "  ")
    if err != nil {
        fmt.Println("Error marshalling guest user:", err)
        return
    }
    fmt.Println("Guest JSON:")
    fmt.Println(string(guestJSON))
    // 预期输出:
    // {
    //   "id": 2,
    //   "name": "Jane"
    // }
}

package main

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

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

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

// UserWithCustomMarshal 包含需要根据角色过滤的字段
type UserWithCustomMarshal struct {
    CurrentRole UserRole `json:"-"` // 运行时角色，不序列化
    ID          int      `json:"id"`
    Name        string   `json:"name"`
    Email       string   `json:"email,omitempty" role:"admin"` // 仅Admin可见
    Phone       string   `json:"phone,omitempty" role:"admin"` // 仅Admin可见
    Status      string   `json:"status" role:"guest,admin"`    // Guest和Admin都可见
}

// MarshalJSON 实现 json.Marshaler 接口
func (u *UserWithCustomMarshal) MarshalJSON() ([]byte, error) {
    var buf bytes.Buffer
    buf.WriteString("{")
    firstField := true

    // 使用反射遍历结构体字段
    val := reflect.ValueOf(*u)
    typ := val.Type()

    for i := 0; i < val.NumField(); i++ {
        field := typ.Field(i)
        fieldVal := val.Field(i)

        // 忽略 CurrentRole 字段本身
        if field.Name == "CurrentRole" {
            continue
        }

        // 获取json标签
        jsonTag := field.Tag.Get("json")
        if jsonTag == "-" { // 忽略不序列化的字段
            continue
        }
        jsonFieldName := strings.Split(jsonTag, ",")[0]
        if jsonFieldName == "" {
            jsonFieldName = field.Name // 如果json标签为空，使用字段名
        }

        // 获取自定义的role标签
        roleTag := field.Tag.Get("role")
        // 如果没有role标签，默认所有角色可见
        if roleTag != "" {
            // 检查当前角色是否在允许的角色列表中
            allowedRoles := strings.Split(roleTag, ",")
            found := false
            for _, r := range allowedRoles {
                if UserRole(r) == u.CurrentRole {
                    found = true
                    break
                }
            }
            if !found {
                continue // 当前角色不允许访问此字段，跳过
            }
        }

        // 处理 omitempty 逻辑
        omitempty := strings.Contains(jsonTag, "omitempty")
        if omitempty && reflect.DeepEqual(fieldVal.Interface(), reflect.Zero(fieldVal.Type()).Interface()) {
            continue // 字段为零值且有omitempty标签，跳过
        }

        if !firstField {
            buf.WriteString(",")
        }
        firstField = false

        // 序列化字段名
        fieldNameBytes, err := json.Marshal(jsonFieldName)
        if err != nil {
            return nil, err
        }
        buf.Write(fieldNameBytes)
        buf.WriteString(":")

        // 序列化字段值
        fieldValueBytes, err := json.Marshal(fieldVal.Interface())
        if err != nil {
            return nil, err
        }
        buf.Write(fieldValueBytes)
    }

    buf.WriteString("}")
    return buf.Bytes(), nil
}

func main() {
    adminUser := UserWithCustomMarshal{
        CurrentRole: Admin,
        ID:          1,
        Name:        "Alice",
        Email:       "alice@example.com",
        Phone:       "123-456-7890",
        Status:      "active",
    }

    guestUser := UserWithCustomMarshal{
        CurrentRole: Guest,
        ID:          2,
        Name:        "Bob",
        Email:       "bob@example.com", // 即使有值，Guest角色也看不到
        Phone:       "987-654-3210",    // 即使有值，Guest角色也看不到
        Status:      "inactive",
    }

    adminJSON, err := json.MarshalIndent(adminUser, "", "  ")
    if err != nil {
        fmt.Println("Error marshalling admin user:", err)
        return
    }
    fmt.Println("Admin JSON:")
    fmt.Println(string(adminJSON))
    // 预期输出:
    // {
    //   "id": 1,
    //   "name": "Alice",
    //   "email": "alice@example.com",
    //   "phone": "123-456-7890",
    //   "status": "active"
    // }

    fmt.Println("---")

    guestJSON, err := json.MarshalIndent(guestUser, "", "  ")
    if err != nil {
        fmt.Println("Error marshalling guest user:", err)
        return
    }
    fmt.Println("Guest JSON:")
    fmt.Println(string(guestJSON))
    // 预期输出:
    // {
    //   "id": 2,
    //   "name": "Bob",
    //   "status": "inactive"
    // }
}