Go 服务使用 mongo-driver 连接 MongoDB 时怎样配置连接池和优化查询？

Go 语言官方提供的 mongo-driver 是当前生产环境中使用最广的 MongoDB 驱动。它不只是封装了网络协议，还在连接池、拓扑发现、读写分离、自动重试等方面做了完整实现。要在 Go 服务中稳定使用 MongoDB，必须理解驱动如何建立和管理连接、如何构造 BSON 文档，以及如何通过 context 控制操作耗时。本文从连接管理、CRUD 编写、聚合和事务几个方面展开，帮助减少线上偶发延迟和连接泄漏。

一、连接初始化与连接池配置

mongo-driver 的连接并不是在调用 mongo.Connect 时立即建立全部连接，而是采用惰性创建的方式。首次执行数据库操作时，驱动才会从连接池中取用或创建连接。连接池的默认最大连接数是 100，这个值对大多数中小型服务足够，但如果有大量并发请求，默认值可能成为瓶颈。最大连接数设置过低会导致请求排队等待连接，设置过高则可能让 MongoDB 服务端承受过多连接压力。需要根据业务并发量和实例规格调整。

三个核心参数中，MaxPoolSize 控制单个服务实例到单个 MongoDB 节点的最大连接数；MinPoolSize 指定连接池维持的最小空闲连接数，适合预热场景，避免突发流量下建立连接的开销；MaxConnIdleTime 决定空闲连接被回收前的保留时间。如果连接长时间空闲，MongoDB 服务端可能主动关闭，驱动会在下次使用时检测并重建。合理设置这些参数，可以降低连接建立延迟，也能避免连接数无限膨胀。

连接初始化和关闭都应当带上下文超时。示例中给 mongo.Connect 设置了 10 秒超时，防止网络异常时长时间阻塞。程序退出前要调用 Disconnect 主动归还连接，否则可能出现短暂的服务不可用。下面是一个基础初始化示例。

package main

import (
    "context"
    "time"

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

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

    clientOpts := options.Client().
        ApplyURI("mongodb://localhost:27017").
        SetMaxPoolSize(100).
        SetMinPoolSize(10).
        SetMaxConnIdleTime(30 * time.Second)

    client, err := mongo.Connect(ctx, clientOpts)
    if err != nil {
        panic(err)
    }
    defer client.Disconnect(context.Background())
}

二、CRUD 操作与 BSON 文档构造

mongo-driver 提供多种构造 BSON 文档的方式，常用的有 bson.D、bson.M 和结构体标签。bson.D 是一个有序文档，底层是切片，会严格保持字段顺序。这在排序条件、索引键和部分命令中很重要，因为字段顺序会影响 MongoDB 的查询计划选择。bson.M 是 map 类型，书写简洁，但字段顺序不确定。普通等值过滤条件用 bson.M 完全够用，而构造复合索引、排序条件时建议使用 bson.D。

结构体标签方式适合将 Go 结构体直接映射为 MongoDB 文档。通过在字段上添加 bson:"field_name,omitempty" 标签，可以控制序列化后的字段名和空值行为。不过结构体在构造动态查询条件时不够灵活，通常适合写入和读取固定模型，不适合拼接复杂过滤条件。

coll := client.Database("shop").Collection("orders")

doc := bson.D{
    {Key: "order_no", Value: "ORD20240501"},
    {Key: "amount", Value: 89.9},
    {Key: "items", Value: bson.A{"book", "pen"}},
    {Key: "created_at", Value: time.Now()},
}

result, err := coll.InsertOne(ctx, doc)
if err != nil {
    log.Fatal(err)
}
fmt.Println(result.InsertedID)

查询时通常先构造 filter 参数，再通过 options.Find 设置排序、限制和投影。单个查询使用 FindOne，多条查询使用 Find 返回 cursor。cursor 必须及时关闭，否则会占用连接和内存。cursor.All 可以将结果一次性解码到切片，适合数据量较小的场景；如果结果集很大，应使用 cursor.Next 逐条读取，避免内存峰值过高。

filter := bson.M{"amount": bson.M{"$gte": 50, "$lte": 200}}
opts := options.Find().SetSort(bson.D{{Key: "created_at", Value: -1}}).SetLimit(20)

cursor, err := coll.Find(ctx, filter, opts)
if err != nil {
    log.Fatal(err)
}
defer cursor.Close(ctx)

var orders []bson.M
if err := cursor.All(ctx, &orders); err != nil {
    log.Fatal(err)
}

更新操作可以使用 UpdateOne、UpdateMany 和 ReplaceOne。更新文档中常用 $set、$inc、$push 等操作符。删除操作使用 DeleteOne 和 DeleteMany。如果希望更新不存在时自动插入，可以在 options.Update 中设置 SetUpsert(true)。批量写入建议使用 BulkWrite，一次提交多个操作，减少网络往返。

updateFilter := bson.M{"order_no": "ORD20240501"}
updateDoc := bson.M{"$set": bson.M{"status": "paid", "updated_at": time.Now()}}

_, err := coll.UpdateOne(ctx, updateFilter, updateDoc)
if err != nil {
    log.Fatal(err)
}

deleteResult, err := coll.DeleteMany(ctx, bson.M{"status": "expired"})
if err != nil {
    log.Fatal(err)
}
fmt.Println(deleteResult.DeletedCount)

三、聚合管道与索引配合

聚合查询是 MongoDB 强大的分析能力，mongo-driver 通过 mongo.Pipeline 类型支持。管道本质上是一组阶段文档，常见阶段包括 $match、$group、$sort、$project 和 $lookup。在驱动里构造管道时，可以使用 bson.D 保证阶段内字段顺序，也可以混合 bson.M 提高可读性。

聚合查询同样返回 cursor，需要遍历或一次性解码。聚合操作对资源消耗通常高于普通查询，尤其是 $group 和 $lookup 可能触发内存排序。如果数据量较大，应提前用 $match 过滤，减少后续阶段处理的数据量。还可以设置 AllowDiskUse 允许使用磁盘临时空间，但要注意性能下降。

pipeline := mongo.Pipeline{
    {{Key: "$match", Value: bson.M{"status": "paid"}}},
    {{Key: "$group", Value: bson.M{"_id": "$customer_id", "total": bson.M{"$sum": "$amount"}}}},
    {{Key: "$sort", Value: bson.D{{Key: "total", Value: -1}}}},
}

cursor, err := coll.Aggregate(ctx, pipeline)
if err != nil {
    log.Fatal(err)
}
defer cursor.Close(ctx)

var results []bson.M
if err := cursor.All(ctx, &results); err != nil {
    log.Fatal(err)
}

聚合性能高度依赖索引。在 $match 阶段，如果过滤字段有合适索引，MongoDB 可以快速定位数据。没有索引时，聚合会扫描整个集合。可以通过 coll.Indexes().CreateOne 创建索引，也可以在 options.Index() 中指定唯一索引、稀疏索引和过期索引。上线前建议使用 explain 查看执行计划，确认是否走了 IXSCAN 而不是 COLLSCAN。

indexModel := mongo.IndexModel{
    Keys:    bson.D{{Key: "status", Value: 1}, {Key: "created_at", Value: -1}},
    Options: options.Index().SetName("idx_status_created"),
}

_, err := coll.Indexes().CreateOne(ctx, indexModel)
if err != nil {
    log.Fatal(err)
}

四、事务处理与错误排查

MongoDB 从 4.0 开始支持副本集上的多文档事务，4.2 开始支持分片集群事务。Go 驱动的事务依赖 session。调用 StartSession 后，通过 WithTransaction 执行事务回调。回调内部的所有操作必须使用传入的 sessCtx，这样才能保证操作在事务上下文中执行。若回调返回错误，事务会自动回滚；若正常返回，事务提交。

事务适合需要多文档原子更新的场景，比如订单创建和库存扣减。但不建议在事务中执行耗时操作，因为事务会持有锁，增加冲突概率。单节点部署并不支持事务，需要先确认 MongoDB 至少是副本集架构。事务超时默认 60 秒，可以通过 WithTransaction 的选项或在 MongoDB 服务器端参数调整。

session, err := client.StartSession()
if err != nil {
    log.Fatal(err)
}
defer session.EndSession(context.Background())

_, err = session.WithTransaction(ctx, func(sessCtx mongo.SessionContext) (interface{}, error) {
    coll := client.Database("shop").Collection("orders")
    _, err := coll.InsertOne(sessCtx, bson.M{"order_no": "TX-001", "amount": 120})
    if err != nil {
        return nil, err
    }
    _, err = coll.UpdateOne(sessCtx, bson.M{"order_no": "TX-001"}, bson.M{"$set": bson.M{"status": "confirmed"}})
    if err != nil {
        return nil, err
    }
    return nil, nil
})
if err != nil {
    log.Fatal(err)
}

错误排查方面，驱动返回的错误可以分为网络错误、服务器错误和逻辑错误。网络超时经常表现为 context.DeadlineExceeded 或 mongo.ErrClientDisconnected。服务器错误可以通过 mongo.IsDuplicateKeyError 判断唯一索引冲突，通过 mongo.IsTimeout 判断服务器侧超时，通过 mongo.IsNetworkError 判断网络异常。不要把所有错误都当作连接失败处理，否则会造成不必要的重试或告警噪音。

重试机制上，mongo-driver 默认会重试一次可重试的写操作和读操作，但重试前提是操作不会产生副作用或已经明确可重试。对于幂等写入，可以放心使用默认重试；对于非幂等写入，需要谨慎设置 retryWrites=false。同时，给每个操作设置合理的 context 超时，能避免某个慢操作用尽连接池，影响整个服务。

Go mongo-driverMongoDB连接池修改时间：2026-09-19 17:38:51