golang基于官方驱动的MongoDB高效操作插件库go-mongox的使用

golang基于官方驱动的MongoDB高效操作插件库go-mongox的使用

go-mongox-logo

go mongox 是一个基于泛型的库，扩展了官方 MongoDB 驱动。通过使用泛型，它将结构体与 MongoDB 集合绑定，旨在提供类型安全和简化的数据操作。go mongox 还引入了方法链式调用以实现更流畅的文档操作，并提供丰富的 BSON 构建器和内置函数来简化 BSON 数据的构建。此外，它支持基于插件的编程，并提供各种内置钩子函数，为数据库操作前后提供自定义逻辑的灵活性，从而增强应用程序的可扩展性和可维护性。

功能亮点

  • 泛型 MongoDB 集合
  • 文档的 CRUD 操作
  • 聚合操作
  • 内置基础 Model 结构体，自动更新默认 field 值
  • BSON 数据构建支持
  • 内置钩子
  • 支持基于插件的编程

安装

go get github.com/chenmingyong0423/go-mongox/v2

快速开始

以下是一个完整的示例 demo，展示如何使用 go-mongox 进行基本的 MongoDB 操作：

package main

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

	"github.com/chenmingyong0423/go-mongox"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

// 定义用户结构体
type User struct {
	ID        string    `bson:"_id"`
	Name      string    `bson:"name"`
	Age       int       `bson:"age"`
	CreatedAt time.Time `bson:"created_at"`
	UpdatedAt time.Time `bson:"updated_at"`
}

func main() {
	// 1. 创建 MongoDB 客户端
	client, err := mongo.Connect(context.Background(), options.Client().ApplyURI("mongodb://localhost:27017"))
	if err != nil {
		log.Fatal(err)
	}
	defer client.Disconnect(context.Background())

	// 2. 获取数据库和集合
	db := client.Database("testdb")
	collection := mongox.NewCollection[User](db.Collection("users"))

	// 3. 插入文档
	newUser := User{
		ID:        "123",
		Name:      "John Doe",
		Age:       30,
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}
	insertResult, err := collection.Creator().InsertOne(context.Background(), newUser)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Inserted document with ID: %v\n", insertResult.InsertedID)

	// 4. 查询文档
	foundUser, err := collection.Finder().Filter(mongox.Eq("_id", "123")).FindOne(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Found user: %+v\n", foundUser)

	// 5. 更新文档
	updateResult, err := collection.Updater().Filter(mongox.Eq("_id", "123")).Updates(mongox.Set("age", 31)).UpdateOne(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Updated %v documents\n", updateResult.ModifiedCount)

	// 6. 删除文档
	deleteResult, err := collection.Deleter().Filter(mongox.Eq("_id", "123")).DeleteOne(context.Background())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Deleted %v documents\n", deleteResult.DeletedCount)
}

代码说明

  1. 首先创建 MongoDB 客户端连接
  2. 使用 mongox.NewCollection 创建一个类型安全的集合操作对象
  3. 使用 Creator() 方法进行文档插入
  4. 使用 Finder() 方法进行文档查询
  5. 使用 Updater() 方法进行文档更新
  6. 使用 Deleter() 方法进行文档删除

特性说明

  • 类型安全：通过泛型确保操作的对象类型正确
  • 链式调用：提供流畅的 API 设计
  • BSON 构建：内置丰富的 BSON 构建方法如 Eq, Set 等
  • 钩子支持：可以在操作前后添加自定义逻辑

这个示例展示了 go-mongox 的基本用法，更多高级功能可以参考官方文档。


更多关于golang基于官方驱动的MongoDB高效操作插件库go-mongox的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang基于官方驱动的MongoDB高效操作插件库go-mongox的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


go-mongox: 基于官方驱动的MongoDB高效操作插件库

go-mongox 是一个基于官方 MongoDB Go 驱动 (go.mongodb.org/mongo-driver) 构建的高效操作库，它提供了更简洁、更符合 Go 风格的 API 封装，同时保留了官方驱动的所有功能。

主要特性

  1. 简化 CRUD 操作
  2. 提供流畅的链式调用
  3. 支持结构体标签映射
  4. 内置常用查询条件构建
  5. 支持事务操作
  6. 提供聚合管道简化

安装

go get github.com/qiniu/qmgo

基本使用示例

1. 连接 MongoDB

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/qiniu/qmgo"
)

type User struct {
	Name     string `bson:"name"`
	Age      int    `bson:"age"`
	CreateAt time.Time `bson:"create_at"`
}

func main() {
	ctx := context.Background()
	
	// 连接MongoDB
	client, err := qmgo.NewClient(ctx, &qmgo.Config{
		Uri: "mongodb://localhost:27017",
	})
	if err != nil {
		panic(err)
	}
	
	// 选择数据库和集合
	db := client.Database("test")
	coll := db.Collection("users")
	
	// 插入文档
	user := User{
		Name:     "张三",
		Age:      25,
		CreateAt: time.Now(),
	}
	
	_, err = coll.InsertOne(ctx, user)
	if err != nil {
		panic(err)
	}
	
	// 查询文档
	var result User
	err = coll.Find(ctx, qmgo.M{"name": "张三"}).One(&result)
	if err != nil {
		panic(err)
	}
	
	fmt.Printf("查询结果: %+v\n", result)
}

2. CRUD 操作

// 插入多个文档
users := []interface{}{
    User{Name: "李四", Age: 30, CreateAt: time.Now()},
    User{Name: "王五", Age: 28, CreateAt: time.Now()},
}

_, err = coll.InsertMany(ctx, users)
if err != nil {
    panic(err)
}

// 更新文档
filter := qmgo.M{"name": "张三"}
update := qmgo.M{"$set": qmgo.M{"age": 26}}

_, err = coll.UpdateOne(ctx, filter, update)
if err != nil {
    panic(err)
}

// 删除文档
_, err = coll.DeleteOne(ctx, qmgo.M{"name": "王五"})
if err != nil {
    panic(err)
}

// 查询多个文档
var results []User
err = coll.Find(ctx, qmgo.M{"age": qmgo.M{"$gt": 25}}).All(&results)
if err != nil {
    panic(err)
}

fmt.Println("年龄大于25的用户:")
for _, u := range results {
    fmt.Printf("%+v\n", u)
}

3. 高级查询

// 分页查询
var pageResults []User
err = coll.Find(ctx, qmgo.M{}).
    Sort("age").
    Skip(1).
    Limit(2).
    All(&pageResults)
if err != nil {
    panic(err)
}

// 聚合查询
pipeline := []qmgo.M{
    {"$match": qmgo.M{"age": qmgo.M{"$gt": 25}}},
    {"$group": qmgo.M{
        "_id":   "$name",
        "count": qmgo.M{"$sum": 1},
    }},
}

var aggResults []bson.M
err = coll.Aggregate(ctx, pipeline).All(&aggResults)
if err != nil {
    panic(err)
}

4. 事务操作

// 开启事务
session, err := client.StartSession()
if err != nil {
    panic(err)
}
defer session.EndSession(ctx)

err = session.StartTransaction()
if err != nil {
    panic(err)
}

// 在事务中执行操作
err = mongo.WithSession(ctx, session, func(sc mongo.SessionContext) error {
    // 插入文档
    _, err := coll.InsertOne(sc, User{Name: "事务用户", Age: 40})
    if err != nil {
        return err
    }
    
    // 更新文档
    _, err = coll.UpdateOne(sc, 
        qmgo.M{"name": "张三"},
        qmgo.M{"$set": qmgo.M{"age": 27}})
    if err != nil {
        return err
    }
    
    return nil
})

if err != nil {
    session.AbortTransaction(ctx)
    panic(err)
} else {
    session.CommitTransaction(ctx)
}

性能优化建议

  1. 批量操作：尽量使用 InsertMany、BulkWrite 等批量操作方法
  2. 合理使用索引：为常用查询字段创建索引
  3. 投影优化：只查询需要的字段
  4. 连接池配置：合理设置连接池大小
  5. 上下文超时：为所有操作设置合理的超时时间

总结

go-mongox 在官方驱动的基础上提供了更简洁易用的 API，特别适合需要快速开发 MongoDB 应用的场景。它保留了官方驱动的所有功能，同时通过更符合 Go 习惯的封装，提高了开发效率。

对于复杂的查询和操作，仍然可以回退到使用原生驱动的方式，这使得 go-mongox 既灵活又强大。

回到顶部