mongoDB分布式存储（二）
go客户端实现mongoDB的增删改查
所有api的使用和说明都在官方文档： https://pkg.go.dev/go.mongodb.org/mongo-driver/mongo#pkg-index
下面只记录一下项目中用到的简单的增删改查操作
可能用过mysql和redis客户端的不太习惯mongo客户端的操作，它获取一个表操作对象分成了几个部分：获取客户端连接、选择数据库、选择表
// 建立连接
client, err := mongo.Connect(context.TODO(),
options.Client().ApplyURI("mongodb://xxx.xxx.xxx.xxx:27017"),
options.Client().SetConnectTimeout(5*time.Second))
if err != nil {
fmt.Println(err)
return
}
// 选择数据库
database := client.Database("cron")
// 选择表log
collection := database.Collection("log")
因为mongo中数据是使用bson格式存储的，所以在定义插入数据结构体时，需要使用bson标签进行反射
// 任务的执行时间点
type TimePoint struct {
StartTime int64 `bson:"startTime"`
EndTime int64 `bson:"endTime"`
}
// 日志结构
type logRecord struct {
JobName string `bson:"jon_name"` //任务名
Command string `bson:"commond"` // shell命令
Err string `bson:"err"` // 脚本错误
Content string `bson:"content"` //脚本输出
TimePoint TimePoint `bson:"timePoint"` //执行时间
}
1. 向mongoDB中插入数据
插入数据是对我们获取到的表操作对象进行的，具体的插入函数签名有如下几个：
func (coll *Collection) InsertMany(ctx context.Context, documents []interface{}, ...) (*InsertManyResult, error)
func (coll *Collection) InsertOne(ctx context.Context, document interface{}, opts ...*options.InsertOneOptions) (*InsertOneResult, error)
根据函数名可以看出可以选择插入一个和多个，opt是options.InsertOneOptions结构体指针，里面有可选择的参数
向mongo中插入一个任务日志：
// 定义数据结构体
record := &logRecord{
JobName: "job10",
Command: "ceho hello",
Err: "",
Content: "hello",
TimePoint: TimePoint{
StartTime: time.Now().Unix(),
EndTime: time.Now().Unix() + 10,
},
}
// 插入数据
insertOneResult, err := collection.InsertOne(context.TODO(), record)
if err != nil {
fmt.Println(err)
return
}
// 默认生成一个全局唯一的id，12字节的二进制
docID := insertOneResult.InsertedID.(primitive.ObjectID)
fmt.Println("自增ID：", docID.Hex())
注意insertOneResult只有InsertID这一个属性，是一个12字节的二进制，如果想要变成易读数据格式需要进行类型断言，并且使用.Hex()方法来转换
插入多条数据也是一样的操作，需要先声明一个插入数据的切片
// 批量插入多条数据
logArr := []interface{}{record, record, record}
insertManyResult, err := collection.InsertMany(context.TODO(), logArr)
if err != nil {
fmt.Println(err)
return
}
for _, id := range insertManyResult.InsertedIDs {
docID := id.(primitive.ObjectID)
fmt.Println("自增ID:", docID.Hex())
}
2. 从mongoDB中读取数据
首先来看一下查找数据的函数签名，有很多，大抵就是查找和更新删除等操作的组合，其参数列表里有一个 filter过滤器，这个需要自己定义过滤器，来指明我们需要针对什么条件来查询，opts仍然是可选参数，findopt就有很多，分页limit排序等等，如果需要的话可以看看各个参数的释义。
func (coll *Collection) Find(ctx context.Context, filter interface{}, opts ...*options.FindOptions) (*Cursor, error)
func (coll *Collection) FindOne(ctx context.Context, filter interface{}, opts ...*options.FindOneOptions) *SingleResult
func (coll *Collection) FindOneAndDelete(ctx context.Context, filter interface{}, ...) *SingleResult
func (coll *Collection) FindOneAndReplace(ctx context.Context, filter interface{}, replacement interface{}, ...) *SingleResult
func (coll *Collection) FindOneAndUpdate(ctx context.Context, filter interface{}, update interface{}, ...) *SingleResult
首先定义一个简单的过滤器：
// jobname过滤条件
type FindByJobName struct {
JobName string `bson:"jon_name"`
}
// 按照jobname过滤，找出jobname=job10
cond := &FindByJobName{
JobName: "job10",
}
执行find，返回的是一个*mongo.Cursor类型的值，就是一个游标，类似于mysql中的游标，之后我们可以使用这个游标遍历结果集
skip := int64(0)
limit := int64(2)
// 查询
//cursor, err := collection.Find(context.TODO(), bson.D{{"jon_name", "job10"}}) // 这是官方案例中的写法，显得不像在写客户端
cursor, err := collection.Find(context.TODO(), cond, &options.FindOptions{
Skip: &skip,
Limit: &limit,
})
defer cursor.Close(context.TODO())
if err != nil {
fmt.Println(err)
return
}
遍历结果集，得到查询到的数据
// 遍历结果集
for cursor.Next(context.TODO()) {
record := &logRecord{}
// 反序列化bson到结构体对象
err := cursor.Decode(record)
if err != nil {
fmt.Println(err)
return
}
// 打印结构体
fmt.Println(*record)
}
3. 删除mongoDB中的数据
首先定义一个删除规则：我们要删除创建时间小于当前时间的日志，等同于清空数据库了。
先来看看删除的函数签名，其实和find是类似的，需要一个过滤器
func (coll *Collection) DeleteMany(ctx context.Context, filter interface{}, opts ...*options.DeleteOptions) (*DeleteResult, error)
func (coll *Collection) DeleteOne(ctx context.Context, filter interface{}, opts ...*options.DeleteOptions) (*DeleteResult, error)
根据删除规则我们定义一个过滤器，我们要删除的是创建时间小于当前时间的，那么在mongo ctl中就应该写成json表达式
delete({"timePoint.startPoint":{"$lt":当前时间}})
我们可以利用go的bson反射来做到这个表达式的定义，记住反射是怎么序列化的就行，后面的bson标签是key
// startTime小于某时间
// {"$lt":timestamp}
type TimeBeforeCond struct {
Before int64 `bson:"$lt"`
}
// 定义删除条件
// {"timePoint.startPoint":{"$lt":timestamp}}
type DelCond struct {
beforeCond TimeBeforeCond `bson:"timePoint.startTime"`
}
现在让我们执行deletemany操作，返回的*mongo.DeleteResult只有一个属性就是被删除了多少行
// 定义删除条件
delCond := &DelCond{
beforeCond: TimeBeforeCond{
Before: time.Now().Unix(),
},
}
deleteResult, err := collection.DeleteMany(context.TODO(), delCond)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("删除了多少行：", deleteResult.DeletedCount)
以上只是一些go-mongo客户端的简单操作，如果有更复杂的需求建议去阅读官方文档，里面有每个方法的详细释义及example
