Go语言中如何根据查询参数返回部分结构体？

问题背景 #

需要实现REST API的属性选择功能：客户端通过fields查询参数指定返回的资源属性（支持嵌套字段，如address.city），服务端返回对应部分资源。

现有方案的不足 #

原PartialStruct仅支持顶层字段，无法处理嵌套字段；且通过Marshal/Unmarshal转换效率低，还可能引入类型匹配问题。

改进方案：递归反射构建部分结构体 #

通过解析字段路径为层级结构，递归处理嵌套字段，直接用反射构建目标结构体，避免序列化开销。

步骤1：解析字段路径为层级树 #

将fields数组转换为嵌套Map，方便递归处理：

import (
    "strings"
)

func parseFields(fields []string) map[string]any {
    fieldTree := make(map[string]any)
    for _, field := range fields {
        parts := strings.Split(field, ".")
        current := fieldTree
        for i, part := range parts {
            if _, exists := current[part]; !exists {
                if i == len(parts)-1 {
                    current[part] = nil // 标记为叶子节点
                } else {
                    current[part] = make(map[string]any)
                }
            }
            // 进入下一层级
            if nextLayer, ok := current[part].(map[string]any); ok {
                current = nextLayer
            }
        }
    }
    return fieldTree
}

步骤2：递归构建部分结构体 #

通过反射遍历原结构体，根据字段树递归生成嵌套的部分结构体：

import "reflect"

func buildPartial(original reflect.Value, fieldTree map[string]any) any {
    // 处理非结构体类型（如基本类型、指针）
    if original.Kind() != reflect.Struct {
        return original.Interface()
    }

    var partialFields []reflect.StructField
    var partialValues []reflect.Value

    for fieldName, subTree := range fieldTree {
        // 根据JSON标签匹配结构体字段
        var targetField reflect.StructField
        found := false
        for i := 0; i < original.NumField(); i++ {
            f := original.Type().Field(i)
            jsonTag := strings.Split(f.Tag.Get("json"), ",")[0]
            if jsonTag == fieldName {
                targetField = f
                found = true
                break
            }
        }
        if !found {
            continue
        }

        fieldValue := original.FieldByName(targetField.Name)
        var partialValue reflect.Value

        if subTree == nil {
            // 叶子字段，直接取值
            partialValue = fieldValue
        } else {
            // 嵌套字段，递归处理
            nestedPartial := buildPartial(fieldValue, subTree.(map[string]any))
            partialValue = reflect.ValueOf(nestedPartial)
        }

        // 构造动态结构体字段
        partialField := reflect.StructField{
            Name: targetField.Name,
            Type: partialValue.Type(),
            Tag:  targetField.Tag, // 保留原JSON标签
        }
        partialFields = append(partialFields, partialField)
        partialValues = append(partialValues, partialValue)
    }

    // 创建并赋值动态结构体
    partialType := reflect.StructOf(partialFields)
    partialStruct := reflect.New(partialType).Elem()
    for i, val := range partialValues {
        partialStruct.Field(i).Set(val)
    }

    return partialStruct.Interface()
}

步骤3：重构PartialStruct函数 #

整合解析和构建逻辑：

func PartialStruct(original any, fields []string) any {
    fieldTree := parseFields(fields)
    originalVal := reflect.ValueOf(original)
    // 处理指针类型的原结构体
    if originalVal.Kind() == reflect.Ptr {
        originalVal = originalVal.Elem()
    }
    return buildPartial(originalVal, fieldTree)
}

更优方案：MongoDB投影查询 #

由于你使用MongoDB，直接在数据库层面做投影查询是最高效的方案，避免服务端反射处理的开销：

实现代码 #

将fields参数转换为MongoDB投影文档，查询时只返回指定字段：

import (
    "context"
    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo/options"
)

func getPersonWithFields(id string, fields []string) (any, error) {
    projection := bson.M{}
    for _, field := range fields {
        projection[field] = 1
    }

    // 执行带投影的查询
    var result bson.M
    err := collection.FindOne(
        context.TODO(),
        bson.M{"_id": id},
        options.FindOne().SetProjection(projection),
    ).Decode(&result)
    if err != nil {
        return nil, err
    }
    return result, nil
}

优势 #

• 数据库仅返回需要的字段，减少网络传输和内存占用
• 避免反射带来的复杂度和性能损耗
• 逻辑更简洁，减少服务端代码维护成本

内容的提问来源于stack exchange，提问作者moth