Go_study5：go连接mongoDB，并进行相关操作

1.mongo常用命令

启动mongo服务

net start mongodb

进入mongo

mongo

（注：安装好的mongoDB无法启动，参考：https://blog.csdn.net/LZW15082682930/article/details/116431807）
查看数据库

show dbs;

切换到指定数据库test，如果不存在则创建

use test

查看该数据库下所有集合

show collections

创建集合test_coll

db.createCollection(“test_coll”)

删除指定集合test_drop

db.test_coll.drop()

2.增删改查命令

详细指令可参考：https://mongodb.net.cn/manual/reference/method/db.collection.insertOne/

//插入数据：db.comment.insert({bson数据})
// 查询所有数据：db.comment.find();
// 条件查询数据：db.comment.find({条件})
// 查询符合条件的第一条记录：db.comment.findOne({条件})
// 查询符合条件的前几条记录：db.comment.find({条件}).limit(条数)
// 查询符合条件的跳过的记录：db.comment.find({条件}).skip(条数)
// 修改数据：db.comment.update({条件},{修改后的数据}) 或db.comment.update({条件},{$set:{要修改部分的字段:数据})
// 修改数据并自增某字段值：db.comment.update({条件},{$inc:{自增的字段:步进值}})
// 删除数据：db.comment.remove({条件})
// 统计查询：db.comment.count({条件})
// 模糊查询：db.comment.find({字段名:/正则表达式/})
// 条件比较运算：db.comment.find({字段名:{$gt:值}})
// 包含查询：db.comment.find({字段名:{$in:[值1，值2]}})或db.comment.find({字段名:{$nin:[值1，值2]}})
// 条件连接查询：db.comment.find({$and:[{条件1},{条件2}]})或db.comment.find({$or:[{条件1},{条件2}]})

//$or 或关系
// $nor 或关系取反
// $gt 大于
// $gte 大于等于
// $lt 小于
// $lte 小于等于
// $ne 不等于
// $in 在多个值范围内
// $nin 不在多个值范围内
// $all 匹配数组中多个值
// $regex 正则，用于模糊查询
// $size 匹配数组大小
// $maxDistance 范围查询，距离（基于LBS）
// $mod 取模运算
// $near 邻域查询，查询附近的位置（基于LBS）
// $exists 字段是否存在
// $elemMatch 匹配内数组内的元素
// $within 范围查询（基于LBS）
// $box 范围查询，矩形范围
// $center 范围查询，圆形范围
// $centerSphere 范围查询，球形范围
// $slice 查询字段集合中的元素（比如从第几个之后，第N到第M个元素）
// $inc：递加
// $mul：相乘
// $rename：重命名
//$set：新增 or 修改
// $unset：字段删除

3.Go语言操作mongoDB

3.1使用驱动go.mongodb.org/mongo-driver/mongo

通过go代码连接mongoDB，在utils/mgodb.go中
(其中dataEngineService为数据库，factoryInfo、factoryData、factoryDataCount为集合)

const (
	DATA_BASE               string = "dataEngineService"
	FACTORY_INFO_COLL       string = "factoryInfo"
	FACTORY_DATA_COLL       string = "factoryData"
	FACTORY_DATA_COUNT_COLL string = "factoryDataCount"
)

var mgo *mongo.Client
var FactoryInfoColl *mongo.Collection
var FactoryDataColl *mongo.Collection
var FactoryDataCountColl *mongo.Collection

func init() {
	// 设置客户端连接配置
	clientOptions := options.Client().ApplyURI("mongodb://192.168.1.163:27017")

	// 连接到MongoDB
	var err error
	mgo, err = mongo.Connect(context.Background(), clientOptions)
	if err != nil {
		panic(err.Error())
	}

	// 检查连接
	if err := mgo.Ping(context.Background(), nil); err != nil {
		panic(err.Error())
	}

	FactoryInfoColl = mgo.Database(DATA_BASE).Collection(FACTORY_INFO_COLL)
	FactoryDataColl = mgo.Database(DATA_BASE).Collection(FACTORY_DATA_COLL)
	FactoryDataCountColl = mgo.Database(DATA_BASE).Collection(FACTORY_DATA_COUNT_COLL)
}

插入代码：

if _,err := utils.FactoryInfoColl.InsertOne(context.Background(), bson.M{"filed1":"value1", "filed2":"value2"});err!=nil{
	panic(err)
}

模糊查询代码：

opts := options.Find()
opts.SetSkip((req.PageNum - 1) * req.PageSize)
opts.SetLimit(req.PageSize)

filter := bson.M{}
_filter := []bson.M{}
if req.FactoryID != "" {
	_filter = append(_filter, bson.M{"factoryID": bson.M{"$regex": req.FactoryID}})
}
if req.RoadNumber != "" {
	_filter = append(_filter, bson.M{"roadNumber": bson.M{"$regex": req.RoadNumber}})
}
if req.FactoryName != "" {
	_filter = append(_filter, bson.M{"factoryName": bson.M{"$regex": req.FactoryName}})
}

filter["$and"] = _filter

cursor, err := utils.FactoryInfoColl.Find(context.Background(), filter, opts)
if err != nil {
	c.JSON(500, gin.H{"errCode": err.Error()})
	return
}

if err = cursor.All(context.TODO(), &rsp.FactoryInfoList); err != nil {
	c.JSON(500, gin.H{"errCode": err.Error()})
	return
}

统计条数代码：

if rsp.Total, err = utils.FactoryInfoColl.CountDocuments(context.Background(), bson.M{"filed1":"value1", "filed2":"value2"}); err != nil {
	c.JSON(500, gin.H{"errCode": err.Error()})
	return
}

3.2使用驱动gopkg.in/mgo.v2

（数据库为edge_agent，account_info为其中集合）
在utils/mgodb/mgodb.go中

func NewMgoSess() *mgo.Session {
	//返回一个用于连接数据库的会话  即IP和端口号
	sess, err := mgo.Dial(“mongodb://127.0.0.1:27017/edge_agent”)
	if err != nil {
		panic(err)
	}

	sess.SetMode(mgo.Monotonic, true) 
	sess.SetPoolLimit(10)

	go func() {
		for {
			time.Sleep(10 * time.Second)
			sess.Refresh()
		}
	}()

	return sess
}

在module/mongodb.go中

const (
	ACCOUNT_INFO_COLL string = "account_info"
)
var DBIns *_db
type _db struct { //存储mongodb collection以及集合中的字段
	sess            *mgo.Session
	Account
	accountInfoColl *mgo.Collection
	EdgeNode
	edgeNodeInfoColl *mgo.Collection
}
func init() {
	sess := mgodb.NewMgoSess()
	DBIns = &_db{
		sess:                    sess,
		accountInfoColl:         sess.DB("").C(ACCOUNT_INFO_COLL),
		edgeNodeInfoColl:        sess.DB("").C(EDGE_NODE_INFO_COLL),
	}
}
func dbIns() *_db {
	return DBIns
}

在module/account.go中写操作数据库函数

type Account struct{}

//根据用户名查找数据库用户是否存在
func (Account) FetchAccountInfo(name string) (*orm.LoginRequest1, error) {
	info := &orm.LoginRequest1{}
	err := dbIns().accountInfoColl.With(DBIns.sess).FindId(name).One(info)
	if err != nil {
		return nil, err
	}
	return info, nil
}

在impl/http/account/login.go中调用上述方法

//根据用户名查找数据库用户是否存在
	if rsp, err := module.DBIns.FetchAccountInfo(req.Username); err != nil {
		result.Failure(ctx, constant.LoginErrorCode, constant.LoginErrorMsg)
		return
	}