使用mongo-go-driver操作MongoDB

mongo-go-driver是MongoDB官方提供的Go语言驱动程序，提供了全面的MongoDB操作功能。下面我将介绍其基本用法和常见操作示例。

安装

首先安装mongo-go-driver：

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

基本连接

package main

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

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

func main() {
	// 设置连接选项
	clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")
	
	// 连接到MongoDB
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	
	client, err := mongo.Connect(ctx, clientOptions)
	if err != nil {
		log.Fatal(err)
	}
	
	// 检查连接
	err = client.Ping(ctx, readpref.Primary())
	if err != nil {
		log.Fatal(err)
	}
	
	fmt.Println("Connected to MongoDB!")
	
	// 断开连接
	defer func() {
		if err = client.Disconnect(ctx); err != nil {
			log.Fatal(err)
		}
	}()
}

CRUD操作

1. 插入文档

type Person struct {
	Name    string
	Age     int
	City    string
	Hobbies []string
}

// 获取集合
collection := client.Database("testdb").Collection("people")

// 插入单个文档
person := Person{"张三", 30, "北京", []string{"游泳", "读书"}}
insertResult, err := collection.InsertOne(ctx, person)
if err != nil {
	log.Fatal(err)
}
fmt.Println("Inserted a single document: ", insertResult.InsertedID)

// 插入多个文档
persons := []interface{}{
	Person{"李四", 25, "上海", []string{"跑步", "音乐"}},
	Person{"王五", 28, "广州", []string{"旅游", "摄影"}},
}
insertManyResult, err := collection.InsertMany(ctx, persons)
if err != nil {
	log.Fatal(err)
}
fmt.Println("Inserted multiple documents: ", insertManyResult.InsertedIDs)

2. 查询文档

// 查询单个文档
var result Person
err = collection.FindOne(ctx, bson.M{"name": "张三"}).Decode(&result)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Found a single document: %+v\n", result)

// 查询多个文档
cursor, err := collection.Find(ctx, bson.M{"age": bson.M{"$gt": 25}})
if err != nil {
	log.Fatal(err)
}
defer cursor.Close(ctx)

var people []Person
if err = cursor.All(ctx, &people); err != nil {
	log.Fatal(err)
}
fmt.Println("Found multiple documents:")
for _, p := range people {
	fmt.Printf("%+v\n", p)
}

3. 更新文档

// 更新单个文档
filter := bson.M{"name": "张三"}
update := bson.M{
	"$set": bson.M{
		"age": 31,
		"city": "深圳",
	},
}
updateResult, err := collection.UpdateOne(ctx, filter, update)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Matched %v documents and updated %v documents.\n", 
	updateResult.MatchedCount, updateResult.ModifiedCount)

// 更新多个文档
updateManyResult, err := collection.UpdateMany(
	ctx,
	bson.M{"age": bson.M{"$gt": 25}},
	bson.M{"$inc": bson.M{"age": 1}},
)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Matched %v documents and updated %v documents.\n", 
	updateManyResult.MatchedCount, updateManyResult.ModifiedCount)

4. 删除文档

// 删除单个文档
deleteResult, err := collection.DeleteOne(ctx, bson.M{"name": "王五"})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Deleted %v documents\n", deleteResult.DeletedCount)

// 删除多个文档
deleteManyResult, err := collection.DeleteMany(ctx, bson.M{"age": bson.M{"$gt": 30}})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Deleted %v documents\n", deleteManyResult.DeletedCount)

高级操作

事务

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

err = mongo.WithSession(ctx, session, func(sc mongo.SessionContext) error {
	if err = session.StartTransaction(); err != nil {
		return err
	}
	
	// 执行事务操作
	if _, err = collection.InsertOne(sc, Person{"赵六", 35, "杭州", nil}); err != nil {
		session.AbortTransaction(sc)
		return err
	}
	
	if _, err = collection.UpdateOne(
		sc,
		bson.M{"name": "张三"},
		bson.M{"$set": bson.M{"age": 32}},
	); err != nil {
		session.AbortTransaction(sc)
		return err
	}
	
	return session.CommitTransaction(sc)
})

if err != nil {
	log.Fatal(err)
}

聚合查询

matchStage := bson.D{{"$match", bson.D{{"age", bson.D{{"$gt", 25}}}}}}
groupStage := bson.D{
	{"$group", bson.D{
		{"_id", "$city"},
		{"total", bson.D{{"$sum", 1}}},
		{"averageAge", bson.D{{"$avg", "$age"}}},
	}},
}

cursor, err := collection.Aggregate(ctx, mongo.Pipeline{matchStage, groupStage})
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)
}
for _, result := range results {
	fmt.Printf("City: %v, Count: %v, Avg Age: %v\n", 
		result["_id"], result["total"], result["averageAge"])
}

最佳实践

1. 连接池管理：客户端会自动管理连接池，通常一个应用只需要一个客户端实例
2. 上下文使用：所有操作都应使用context来控制超时和取消
3. BSON处理：使用bson标签定义结构体字段与MongoDB字段的映射关系
4. 错误处理：检查所有操作返回的错误
5. 资源释放：确保关闭游标和会话等资源

mongo-go-driver提供了丰富的功能，可以满足大多数MongoDB操作需求。更多高级用法可以参考官方文档。