Go操作MongoDB：仅更新非零值字段的简洁实现方案

问题分析 #

当前代码直接将结构体所有字段传入$set操作，导致未传入值的字段（如Status默认值0）会覆盖数据库中的原有值。需要一种通用方法，自动过滤结构体中的零值/空值字段，仅更新有实际传入值的字段，且无需大量if判断适配不同结构体。

解决方案 #

方法一：基于反射的通用零值过滤函数 #

通过反射遍历结构体字段，仅收集非零值字段生成$set所需的bson.M，实现任意结构体的通用更新逻辑。

通用工具函数实现

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

// BuildUpdateSet 从结构体中提取非零值字段，生成MongoDB $set操作的内容
func BuildUpdateSet(obj interface{}) bson.M {
    updateSet := bson.M{}
    val := reflect.ValueOf(obj).Elem() // 要求传入结构体指针
    typ := val.Type()

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

        // 跳过ID字段（作为过滤条件，无需更新）
        if fieldType.Name == "ID" {
            continue
        }

        // 获取bson标签，跳过无标签或标记为"-"的字段
        bsonTag := fieldType.Tag.Get("bson")
        if bsonTag == "" || bsonTag == "-" {
            continue
        }

        // 仅保留非零值字段
        if !isZero(field) {
            updateSet[bsonTag] = field.Interface()
        }
    }
    return updateSet
}

// isZero 判断字段是否为零值
func isZero(v reflect.Value) bool {
    switch v.Kind() {
    case reflect.String:
        return v.Len() == 0
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        return v.Int() == 0
    case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
        return v.Uint() == 0
    case reflect.Float32, reflect.Float64:
        return v.Float() == 0
    case reflect.Bool:
        return !v.Bool()
    case reflect.Ptr, reflect.Interface:
        return v.IsNil()
    case reflect.Slice, reflect.Map:
        return v.Len() == 0 || v.IsNil()
    case reflect.Struct:
        // 处理primitive.ObjectID的零值判断
        if v.Type() == reflect.TypeOf(primitive.ObjectID{}) {
            return v.Interface() == primitive.NilObjectID
        }
        return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface())
    default:
        return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface())
    }
}

使用示例

// 假设从请求中绑定的Product实例，仅传入了DisplayName和Text
product := &Product{
    ID:          primitive.ObjectIDFromHex("60d21b4667d0d8992e610c85"),
    DisplayName: "更新后的商品名称",
    Text:        "更新后的商品描述",
    // Status未传入，保持默认值0
}

opts := options.Update().SetUpsert(false)
filter := bson.D{{Key: "_id", Value: product.ID}}

// 生成仅包含非零值字段的$set内容
updateSet := BuildUpdateSet(product)
if len(updateSet) == 0 {
    // 无更新字段，直接返回
    return nil, nil
}

update := bson.D{{"$set", updateSet}}
_, err := db.Collection("product").UpdateOne(context.TODO(), filter, update, opts)
if err != nil {
    // 处理错误
    return err
}

方法二：基于BSON编解码的零值过滤 #

利用MongoDB驱动的BSON编解码能力，将结构体转为bson.M后过滤零值字段，无需手动处理反射逻辑。

实现代码

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

// BuildUpdateSetWithBSON 通过BSON编解码生成$set内容
func BuildUpdateSetWithBSON(obj interface{}) (bson.M, error) {
    // 将结构体序列化为BSON字节
    bsonData, err := bson.Marshal(obj)
    if err != nil {
        return nil, err
    }

    // 反序列化为bson.M
    var dataMap bson.M
    if err := bson.Unmarshal(bsonData, &dataMap); err != nil {
        return nil, err
    }

    // 删除_id字段和零值字段
    delete(dataMap, "_id")
    for key, value := range dataMap {
        if reflect.DeepEqual(value, reflect.Zero(reflect.TypeOf(value)).Interface()) {
            delete(dataMap, key)
        }
    }

    return dataMap, nil
}

使用示例

updateSet, err := BuildUpdateSetWithBSON(product)
if err != nil {
    return err
}
if len(updateSet) == 0 {
    return nil, nil
}
update := bson.D{{"$set", updateSet}}
_, err = db.Collection("product").UpdateOne(context.TODO(), filter, update, opts)

方案对比 #

• 反射方法：性能更优，可自定义过滤规则（如跳过特定字段），适合对性能有要求的场景，完全原生实现无依赖。
• BSON编解码方法：代码更简洁，无需手动处理反射细节，但需额外的编解码开销，适合快速开发场景。

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