Go遍历MongoDB多集合并动态解码到对应自定义结构体如何实现

问题根因 #

你之前的映射表存储的是结构体值实例，取出后直接取地址得到的是*interface{}类型，MongoDB的bson解码器无法识别这个指针指向的实际结构体类型，只会解析为默认的bson原生类型。

实现方案 #

核心思路是把集合映射改为存储对应结构体的指针构造函数，每次遍历文档时动态生成对应类型的空指针供Decode方法填充：

1. 先修改types包下的集合映射定义：

// types/collections.go
var Collections = map[string]func() interface{}{
    "announcements":          func() interface{} { return &Announcements{} },
    "badges":                 func() interface{} { return &Badges{} },
    "betaUser":               func() interface{} { return &BetaUser{} },
    "bonusLearningItems":     func() interface{} { return &BonusLearningItems{} },
    "books":                  func() interface{} { return &Books{} },
    // 其余集合依次添加即可
}

2. 遍历集合时的逻辑调整为：

collections, err := db.ListCollectionNames(context.TODO(), bson.M{})
if err != nil {
    log.Fatalf("Failed to get coll names: %v", err)
}

for _, collName := range collections {
    // 跳过未定义映射的集合
    newObj, ok := types.Collections[collName]
    if !ok {
        log.Printf("skip undefined collection: %s", collName)
        continue
    }
    coll := db.Collection(collName)
    cursor, err := coll.Find(context.TODO(), bson.M{})
    if err != nil {
        log.Fatalf("get cursor for %s failed: %v", collName, err)
    }

    for cursor.Next(context.TODO()) {
        // 生成对应结构体的空指针
        obj := newObj()
        // Decode会自动根据指针的实际类型匹配bson标签填充字段
        if err := cursor.Decode(obj); err != nil {
            log.Fatalf("decode %s document failed: %v", collName, err)
        }
        // 打印验证，此时obj已经是填充完成的对应结构体指针
        log.Printf("%#v\n", obj)

        // 后续需要修改结构体字段的话，可以用类型断言匹配
        switch doc := obj.(type) {
        case *types.Announcements:
            doc.ModifiedBy = "batch_update"
            doc.DateModified = time.Now()
            // 后续存库等逻辑
        case *types.Badges:
            // Badges类型的专属修改逻辑
        // 其余类型依次添加case即可
        }
    }
    if err = cursor.Err(); err != nil {
        log.Fatalf("cursor for %s error: %v", collName, err)
    }
    _ = cursor.Close(context.TODO())
}

优化建议 #

如果所有结构体的修改逻辑有共性（比如都要更新修改人、修改时间字段），可以定义统一的接口避免重复写switch分支：

// types/common.go
type DocModifier interface {
    UpdateMeta(operator string)
}

// 给每个结构体实现这个接口
func (a *Announcements) UpdateMeta(operator string) {
    a.ModifiedBy = operator
    a.DateModified = time.Now()
}

func (b *Badges) UpdateMeta(operator string) {
    b.ModifiedBy = operator
    b.DateModified = time.Now()
}

之后遍历的时候就可以直接调用接口方法，不需要写分支：

if modifier, ok := obj.(DocModifier); ok {
    modifier.UpdateMeta("system")
}

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