Golang中利用结构体嵌入和BSON标签实现字段选择性暴露

import "go.mongodb.org/mongo-driver/bson/primitive" // 推荐使用新的mongo-driver/bson/primitive

type User struct {
  Id      primitive.ObjectID `json:"id,omitempty" bson:"_id,omitempty"`
  Name    string             `json:"name,omitempty" bson:"name,omitempty"`
  Secret  string             `json:"-" bson:"secret,omitempty"` // 常规API不返回Secret
}

type AdminUser struct {
  User // 嵌入User结构体
  Secret string `json:"secret,omitempty" bson:"secret,omitempty"` // 尝试在这里重新定义Secret
}

import "go.mongodb.org/mongo-driver/bson/primitive"

// User 基础用户结构体，不包含敏感信息
type User struct {
  Id   primitive.ObjectID `json:"id,omitempty" bson:"_id,omitempty"`
  Name string             `json:"name,omitempty" bson:"name,omitempty"`
  // Secret 字段已从User中移除
}

// AdminUser 包含所有用户字段及敏感信息的管理员用户结构体
type AdminUser struct {
  User   `bson:",inline"` // 嵌入User结构体，并使用inline标签扁平化其字段
  Secret string           `json:"secret,omitempty" bson:"secret,omitempty"` // 仅在AdminUser中定义Secret
}

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "time"

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/bson/primitive"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

// 假设我们有一个全局的MongoDB客户端
var client *mongo.Client
var usersCollection *mongo.Collection

func init() {
    // 连接MongoDB (仅为示例，实际应用中应进行错误处理和配置)
    var err error
    client, err = mongo.NewClient(options.Client().ApplyURI("mongodb://localhost:27017"))
    if err != nil {
        log.Fatal(err)
    }
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    err = client.Connect(ctx)
    if err != nil {
        log.Fatal(err)
    }
    usersCollection = client.Database("testdb").Collection("users")

    // 插入一些测试数据
    insertTestData()
}

func insertTestData() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // 清空集合以便测试
    usersCollection.Drop(ctx)

    // 插入一个普通用户
    user1 := User{
        Id:   primitive.NewObjectID(),
        Name: "Alice",
    }
    usersCollection.InsertOne(ctx, bson.M{"_id": user1.Id, "name": user1.Name, "secret": "alice_secret_123"})

    // 插入一个需要管理员查看的用户
    user2 := AdminUser{
        User: User{
            Id:   primitive.NewObjectID(),
            Name: "Bob",
        },
        Secret: "bob_admin_secret_456",
    }
    usersCollection.InsertOne(ctx, bson.M{"_id": user2.User.Id, "name": user2.User.Name, "secret": user2.Secret})

    fmt.Println("Test data inserted.")
}

// getUserHandler 模拟常规API，返回不含Secret的用户信息
func getUserHandler(w http.ResponseWriter, r *http.Request) {
    // 假设从请求中获取userId
    userIdStr := r.URL.Query().Get("id")
    if userIdStr == "" {
        http.Error(w, "User ID is required", http.StatusBadRequest)
        return
    }
    userId, err := primitive.ObjectIDFromHex(userIdStr)
    if err != nil {
        http.Error(w, "Invalid User ID", http.StatusBadRequest)
        return
    }

    var user User // 使用基础User结构体
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    err = usersCollection.FindOne(ctx, bson.M{"_id": userId}).Decode(&user)
    if err != nil {
        if err == mongo.ErrNoDocuments {
            http.Error(w, "User not found", http.StatusNotFound)
            return
        }
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user) // Secret字段因不在User中，不会被编码
}

// getAdminUserHandler 模拟管理员API，返回包含Secret的用户信息
func getAdminUserHandler(w http.ResponseWriter, r *http.Request) {
    // 假设从请求中获取userId
    userIdStr := r.URL.Query().Get("id")
    if userIdStr == "" {
        http.Error(w, "User ID is required", http.StatusBadRequest)
        return
    }
    userId, err := primitive.ObjectIDFromHex(userIdStr)
    if err != nil {
        http.Error(w, "Invalid User ID", http.StatusBadRequest)
        return
    }

    var adminUser AdminUser // 使用AdminUser结构体
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    err = usersCollection.FindOne(ctx, bson.M{"_id": userId}).Decode(&adminUser)
    if err != nil {
        if err == mongo.ErrNoDocuments {
            http.Error(w, "User not found", http.StatusNotFound)
            return
        }
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(adminUser) // Secret字段会因AdminUser中定义而被编码
}

func main() {
    http.HandleFunc("/user", getUserHandler)
    http.HandleFunc("/admin/user", getAdminUserHandler)

    fmt.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}