Go应用中使用MongoDB客户端库mongo-driver

MongoDB 是一个面向文档的 NoSQL 数据库，因其灵活的数据存储模型和高性能，被广泛应用于各种场景，尤其是在大规模数据存储和高并发读写需求的应用程序中。它适用于 Web 应用、物联网、日志记录、实时分析等场景，受到了开发者和企业的广泛认可。

对于使用 Go 语言的开发者，go.mongodb.org/mongo-driver 提供了一个功能强大且灵活的 MongoDB 客户端库，能够与 MongoDB 进行高效的交互。本文将介绍如何使用 mongo-driver，通过代码示例展示其所有特性，帮助你在 Go 应用中轻松集成 MongoDB。

1. 安装 mongo-driver

使用以下命令安装 mongo-driver：

go get go.mongodb.org/mongo-driver/mongo

2. 基本连接与配置

通过 mongo.Connect 函数可以创建与 MongoDB 数据库的连接：

package main

import (
    "context"
    "fmt"
    "log"
    "time"

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

func main() {
    // 设置连接选项
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

    // 创建 MongoDB 客户端
    client, err := mongo.Connect(context.TODO(), clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // 检查连接状态
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal("无法连接到 MongoDB:", err)
    }
    fmt.Println("成功连接到 MongoDB!")

    // 关闭连接
    defer func() {
        if err := client.Disconnect(context.TODO()); err != nil {
            log.Fatal(err)
        }
    }()
}

3. 数据库与集合操作

MongoDB 的基本单元是数据库和集合。在 MongoDB 中，集合用于存储文档。你可以通过以下方式操作集合：

db := client.Database("testdb")        // 获取数据库
collection := db.Collection("users")   // 获取集合

4. 插入文档

MongoDB 使用 BSON（Binary JSON）格式存储文档。mongo-driver 提供了 InsertOne 和 InsertMany 方法来插入文档。

插入单个文档：

doc := bson.D{{"name", "John"}, {"age", 30}}
result, err := collection.InsertOne(context.TODO(), doc)
if err != nil {
    log.Fatal(err)
}
fmt.Println("插入文档的ID:", result.InsertedID)

插入多个文档：

docs := []interface{}{
    bson.D{{"name", "Alice"}, {"age", 25}},
    bson.D{{"name", "Bob"}, {"age", 35}},
}

result, err := collection.InsertMany(context.TODO(), docs)
if err != nil {
    log.Fatal(err)
}
fmt.Println("插入的文档ID:", result.InsertedIDs)

5. 查询文档

提供了多种查询方法，包括查找单个文档（FindOne）和多个文档（Find）。

查询单个文档：

var result bson.D
err := collection.FindOne(context.TODO(), bson.D{{"name", "John"}}).Decode(&result)
if err != nil {
    log.Fatal(err)
}
fmt.Println("查询结果:", result)

查询多个文档：

cursor, err := collection.Find(context.TODO(), bson.D{})
if err != nil {
    log.Fatal(err)
}
defer cursor.Close(context.TODO())

for cursor.Next(context.TODO()) {
    var result bson.D
    err := cursor.Decode(&result)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("查询到的文档:", result)
}

6. 更新文档

MongoDB 支持使用 UpdateOne 和 UpdateMany 方法来更新单个或多个文档。

更新单个文档：

filter := bson.D{{"name", "John"}}
update := bson.D{{"$set", bson.D{{"age", 31}}}}

result, err := collection.UpdateOne(context.TODO(), filter, update)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("匹配到 %v 个文档，修改了 %v 个文档\n", result.MatchedCount, result.ModifiedCount)

更新多个文档：

filter := bson.D{{"age", bson.D{{"$gt", 25}}}}
update := bson.D{{"$inc", bson.D{{"age", 1}}}}

result, err := collection.UpdateMany(context.TODO(), filter, update)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("修改了 %v 个文档\n", result.ModifiedCount)

7. 删除文档

可以使用 DeleteOne 和 DeleteMany 方法删除文档。

删除单个文档：

filter := bson.D{{"name", "John"}}
result, err := collection.DeleteOne(context.TODO(), filter)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("删除了 %v 个文档\n", result.DeletedCount)

删除多个文档：

filter := bson.D{{"age", bson.D{{"$gt", 30}}}}
result, err := collection.DeleteMany(context.TODO(), filter)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("删除了 %v 个文档\n", result.DeletedCount)

8. 索引管理

索引可以显著提高查询效率，mongo-driver 提供了索引管理的功能。

创建索引：

indexModel := mongo.IndexModel{
    Keys:    bson.D{{"name", 1}},  // 1 表示升序，-1 表示降序
    Options: options.Index().SetUnique(true),
}

indexName, err := collection.Indexes().CreateOne(context.TODO(), indexModel)
if err != nil {
    log.Fatal(err)
}
fmt.Println("创建的索引名称:", indexName)

删除索引：

_, err := collection.Indexes().DropOne(context.TODO(), "name_1")
if err != nil {
    log.Fatal(err)
}
fmt.Println("索引已删除")

9. 聚合操作

mongo-driver 提供了强大的 Aggregate 方法用于复杂的数据处理任务。

pipeline := mongo.Pipeline{
    {{"$match", bson.D{{"age", bson.D{{"$gt", 25}}}}}},
    {{"$group", bson.D{{"_id", "$age"}, {"count", bson.D{{"$sum", 1}}}}}},
}

cursor, err := collection.Aggregate(context.TODO(), pipeline)
if err != nil {
    log.Fatal(err)
}
defer cursor.Close(context.TODO())

for cursor.Next(context.TODO()) {
    var result bson.M
    err := cursor.Decode(&result)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("聚合结果:", result)
}

10. 事务支持

MongoDB 支持多文档事务操作。通过 mongo-driver 的 Session 实现事务管理：

func runTransaction(sessionContext mongo.SessionContext) (interface{}, error) {
    _, err := collection.InsertOne(sessionContext, bson.D{{"name", "Alice"}})
    if err != nil {
        return nil, err
    }
    _, err = collection.UpdateOne(sessionContext, bson.D{{"name", "Alice"}}, bson.D{{"$set", bson.D{{"age", 25}}}})
    return nil, err
}

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

result, err := session.WithTransaction(context.TODO(), runTransaction)
if err != nil {
    log.Fatal(err)
}
fmt.Println("事务完成:", result)

总结

mongo-driver 几乎覆盖了 MongoDB 所有的功能，从基本的 CRUD 操作到高级的事务、聚合、索引等特性都支持得非常完善。无论是简单的数据操作，还是复杂的分布式应用，mongo-driver 都能提供强大、灵活且高效的 MongoDB 访问支持。

如果你的 Go 应用需要高效访问 MongoDB 数据库，mongo-driver 无疑是一个非常不错的选择！