如何在Golang后端更新来自React客户端的MongoDB文档？

问题原因 #

报错的核心是**_id类型不匹配**：

• 后端返回文档时，MongoDB的primitive.ObjectID类型会被序列化为字符串格式的ID
• 客户端编辑后回传，后端用json.Unmarshal解析时，这个ID会被当成字符串存入bson.M
• 执行ReplaceOne时，你试图把原文档的ObjectID类型_id替换成字符串类型，触发MongoDB的不可变字段限制

解决方法1：修正现有bson.M写法的更新逻辑 #

修改putSequence函数，做两个关键处理：

1. 将客户端传来的字符串ID转为primitive.ObjectID作为过滤条件
2. 从要替换的文档中移除_id字段（避免修改这个不可变字段）

修改后的代码：

func putSequence(c *gin.Context) {
    jsonData, err := io.ReadAll(c.Request.Body)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("jsonData: %s\n", jsonData)

    var document bson.M
    err = json.Unmarshal(jsonData, &document)
    if err != nil {
        log.Fatal(err)
    }

    // 提取_id字符串并转为primitive.ObjectID
    idStr, ok := document["_id"].(string)
    if !ok {
        c.JSON(http.StatusBadRequest, "invalid _id format")
        return
    }
    _id, err := primitive.ObjectIDFromHex(idStr)
    if err != nil {
        c.JSON(http.StatusBadRequest, "invalid _id")
        return
    }

    // 从要替换的文档中移除_id字段
    delete(document, "_id")

    // 执行替换操作
    filter := bson.D{{Key: "_id", Value: _id}}
    result, err := sequencesCollection.ReplaceOne(c, filter, document)
    if err != nil {
        log.Fatal(err)
    }

    c.JSON(http.StatusOK, result.UpsertedCount)
}

解决方法2：使用结构体替代bson.M（长期更健壮方案） #

定义对应文档的结构体，通过标签控制JSON和BSON的序列化/反序列化，确保_id类型在往返过程中正确转换：

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

type Sequence struct {
    ID                  primitive.ObjectID `bson:"_id,omitempty" json:"_id"`
    CurrentEnvelopeId   string             `bson:"currentEnvelopeId,omitempty" json:"currentEnvelopeId"`
    CurrentPanelId      string             `bson:"currentPanelId,omitempty" json:"currentPanelId"`
    DeviceFamilyId      string             `bson:"deviceFamilyId,omitempty" json:"deviceFamilyId"`
    Division            float64            `bson:"division,omitempty" json:"division"`
    // 按你的文档结构补充剩余字段
    UserID              primitive.ObjectID `bson:"user_id,omitempty" json:"user_id"`
}

修改getSequence函数：

func getSequence(ctx *gin.Context) {
    id := ctx.Params.ByName("id")

    _id, err := primitive.ObjectIDFromHex(id)
    if err != nil {
        ctx.JSON(http.StatusBadRequest, "invalid _id")
        return
    }

    var sequence Sequence
    if err := sequencesCollection.FindOne(ctx, bson.M{"_id": _id}).Decode(&sequence); err != nil {
        ctx.JSON(http.StatusNotFound, "sequence not found")
        return
    }

    ctx.JSON(http.StatusOK, sequence)
}

修改putSequence函数：

func putSequence(c *gin.Context) {
    var sequence Sequence
    if err := c.ShouldBindJSON(&sequence); err != nil {
        c.JSON(http.StatusBadRequest, "invalid request body")
        return
    }

    // 确保_id是有效的ObjectID
    if !sequence.ID.IsValid() {
        c.JSON(http.StatusBadRequest, "invalid _id")
        return
    }

    // 构造不带_id的更新文档（避免修改不可变字段）
    updateDoc := sequence
    updateDoc.ID = primitive.NilObjectID

    filter := bson.D{{Key: "_id", Value: sequence.ID}}
    result, err := sequencesCollection.ReplaceOne(c, filter, updateDoc)
    if err != nil {
        log.Fatal(err)
    }

    c.JSON(http.StatusOK, result.UpsertedCount)
}

额外说明 #

• 结构体写法的优势是类型安全，避免bson.M带来的类型断言问题，同时更易维护文档结构
• 若坚持用bson.M，必须保证替换的文档中不包含类型不匹配的_id字段，或者将其转换为正确的primitive.ObjectID类型

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