本文采用mongo-driver/mongo驅動操作資料庫

設計mongo外掛結構

將程式碼分為如下結構
model : odm模型，主要是對映為資料庫儲存的表結構
constants : 儲存一些常量
config : mongo的配置資訊，比如空閒時長，連線數，超時時間等
mongodb : 實現了mongo的連線和關閉等功能。

目錄結構如下

mongo的連線和斷開

在mongodb.go中實現了連線和斷開操作
初始化

var (
	DB *Database
)

type Database struct {
	Mongo *mongo.Client
}

//初始化
func Init() {
	DB = &Database{
		Mongo: SetConnect(),
	}
}

連線資料庫

func SetConnect() *mongo.Client {

	var retryWrites bool = false

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	clientOptions := options.Client().SetHosts(config.GetConf().MongoConf.Hosts).
		SetMaxPoolSize(config.GetConf().MongoConf.MaxPoolSize).
		SetHeartbeatInterval(constants.HEART_BEAT_INTERVAL).
		SetConnectTimeout(constants.CONNECT_TIMEOUT).
		SetMaxConnIdleTime(constants.MAX_CONNIDLE_TIME).
		SetRetryWrites(retryWrites)

	//設定使用者名稱和密碼
	username := config.GetConf().MongoConf.Username
	password := config.GetConf().MongoConf.Password

	if len(username) > 0 && len(password) > 0 {
		clientOptions.SetAuth(options.Credential{Username: username, Password: password})
	}

	client, err := mongo.Connect(ctx, clientOptions)
	if err != nil {
		fmt.Println(err)
	}

	// Check the connection
	err = client.Ping(context.TODO(), nil)

	if err != nil {
		fmt.Println(err)
	}

	fmt.Println("Connected to MongoDB!")

	return client
}

關閉資料庫

func Close() {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	DB.Mongo.Disconnect(ctx)
}

在model中定義模型

定義的模型加上bson標籤，這樣可以對映到資料庫裡了

type UserData struct {
	Id         string `bson:"_id,omitempty" json:"id"`
	Name       string `bson:"name" json:"name"`
	Number     int    `bson:"number" json:"number"`
	Age        int    `bson:"age" json:"age"`
	BirthMonth int    `bson:"birthMonth" json:"birthMonth"`
}

在main函式中實現一些demo

在main函式中實現一些demo，包括單條插入，多條插入，單條更新，多條更新，分組查詢，分頁查詢
1 單條插入

//單條插入
func insertOne() {
	client := mongodb.DB.Mongo
	// 獲取資料庫和集合
	collection := client.Database(constants.DB_DATABASES).Collection(constants.DB_COLLECTION)
	userdata := model.UserData{}
	userdata.Age = 13
	userdata.BirthMonth = 11
	userdata.Number = 3
	userdata.Name = "zack"
	ctx, cancel := context.WithTimeout(context.Background(), constants.QUERY_TIME_OUT)
	defer cancel()
	// 插入一條資料
	insertOneResult, err := collection.InsertOne(ctx, &userdata)
	if err != nil {
		fmt.Println("insert one error is ", err)
		return
	}
	log.Println("collection.InsertOne: ", insertOneResult.InsertedID)
	//將objectid轉換為string
	docId := insertOneResult.InsertedID.(primitive.ObjectID)
	recordId := docId.Hex()
	fmt.Println("insert one ID str is :", recordId)
}

2 多條插入

//多條插入
func insertMany() {
	ctx, cancel := context.WithTimeout(context.Background(), constants.QUERY_TIME_OUT)
	defer cancel()
	client := mongodb.DB.Mongo
	// 獲取資料庫和集合
	collection := client.Database(constants.DB_DATABASES).Collection(constants.DB_COLLECTION)
	userdata1 := model.UserData{}
	userdata1.Age = 20
	userdata1.BirthMonth = 11
	userdata1.Number = 4
	userdata1.Name = "Lilei"

	userdata2 := model.UserData{}
	userdata2.Age = 20
	userdata2.BirthMonth = 12
	userdata2.Number = 5
	userdata2.Name = "HanMeiMei"

	var list []interface{}
	list = append(list, &userdata1)
	list = append(list, &userdata2)
	result, err := collection.InsertMany(ctx, list)
	if err != nil {
		fmt.Println("insert many error is ", err)
	}
	fmt.Println("insert many success, res is ", result.InsertedIDs)
}

3 查詢單條

//查詢單個
func findOne() {

	client := mongodb.DB.Mongo
	// 獲取資料庫和集合
	collection := client.Database(constants.DB_DATABASES).Collection(constants.DB_COLLECTION)
	filter := bson.M{"name": "HanMeiMei"}

	ctx, cancel := context.WithTimeout(context.Background(), constants.QUERY_TIME_OUT)
	defer cancel()
	singleResult := collection.FindOne(ctx, filter)
	if singleResult == nil || singleResult.Err() != nil {
		fmt.Println("find one error is ", singleResult.Err().Error())
		return
	}

	userData := &model.UserData{}
	err := singleResult.Decode(userData)
	if err != nil {
		fmt.Println("find one failed error is ", err)
		return
	}

	fmt.Println("find one success, res is ", userData)
}

4 查詢多條

//查詢多個結果集，用cursor
func findMany() {
	client := mongodb.DB.Mongo
	collection := client.Database(constants.DB_DATABASES).Collection(constants.DB_COLLECTION)

	ctx, cancel := context.WithTimeout(context.Background(), constants.QUERY_TIME_OUT)
	defer cancel()
	filter := bson.M{"birthMonth": bson.M{"$lte": 12}}

	cursor, err := collection.Find(ctx, filter)
	if err != nil {
		fmt.Println("find res failed , error is ", err)
		return
	}
	defer cursor.Close(context.Background())

	result := make(map[string]*model.UserData)
	for cursor.Next(context.Background()) {
		ud := &model.UserData{}
		err := cursor.Decode(ud)
		if err != nil {
			fmt.Println("decode error is ", err)
			continue
		}
		result[ud.Name] = ud
	}

	fmt.Println("success is ", result)
	return
}

5 更新一條

//更新
func updateOne() {
	client := mongodb.DB.Mongo
	collection, _ := client.Database(constants.DB_DATABASES).Collection(constants.DB_COLLECTION).Clone()
	ctx, cancel := context.WithTimeout(context.Background(), constants.QUERY_TIME_OUT)
	defer cancel()
	/*
		oid, err := primitive.ObjectIDFromHex(obj.RecordId)
		if err != nil {
			logging.Logger.Info("convert string from object failed")
			return err
		}
		filter := bson.M{"_id": oid}
	*/
	filter := bson.M{"name": "zack"}
	value := bson.M{"$set": bson.M{
		"number": 1024}}

	_, err := collection.UpdateOne(ctx, filter, value)
	if err != nil {
		fmt.Println("update user data failed, err is ", err)
		return
	}
	fmt.Println("update success !")
	return
}

6 更新多條

//更新多條記錄
func updateMany() {
	client := mongodb.DB.Mongo
	collection := client.Database(constants.DB_DATABASES).Collection(constants.DB_COLLECTION)

	ctx, cancel := context.WithTimeout(context.Background(), constants.QUERY_TIME_OUT)
	defer cancel()
	var names = []string{"zack", "HanMeiMei"}
	filter := bson.M{"name": bson.M{"$in": names}}

	value := bson.M{"$set": bson.M{"birthMonth": 3}}
	result, err := collection.UpdateMany(ctx, filter, value)
	if err != nil {
		fmt.Println("update many failed error is ", err)
		return
	}
	fmt.Println("update many success !, result is ", result)
	return
}

7 分組查詢

//分組查詢
func findGroup() {
	client := mongodb.DB.Mongo
	collection := client.Database(constants.DB_DATABASES).Collection(constants.DB_COLLECTION)

	ctx, cancel := context.WithTimeout(context.Background(), constants.QUERY_TIME_OUT)
	defer cancel()
	//複雜查詢，先匹配後分組
	pipeline := bson.A{
		bson.M{
			"$match": bson.M{"birthMonth": 3},
		},
		bson.M{"$group": bson.M{
			"_id":        bson.M{"birthMonthUid": "$birthMonth"},
			"totalCount": bson.M{"$sum": 1},
			"nameG":      bson.M{"$min": "$name"},
			"ageG":       bson.M{"$min": "$age"},
		},
		},

		//bson.M{"$sort": bson.M{"time": 1}},
	}
	fmt.Println("pipeline is ", pipeline)

	cursor, err := collection.Aggregate(ctx, pipeline)
	fmt.Println("findGroup cursor is ", cursor)
	if err != nil {
		fmt.Printf("dao.findGroup collection.Aggregate() error=[%s]\n", err)
		return
	}

	for cursor.Next(context.Background()) {
		doc := cursor.Current

		totalCount, err_2 := doc.LookupErr("totalCount")
		if err_2 != nil {
			fmt.Printf("dao.findGroup totalCount err_2=[%s]\n", err_2)
			return
		}

		nameData, err_4 := doc.LookupErr("nameG")
		if err_4 != nil {
			fmt.Printf("dao.findGroup insertDateG err_4=[%s]\n", err_4)
			return
		}

		ageData, err_5 := doc.LookupErr("ageG")
		if err_5 != nil {
			fmt.Printf("dao.findGroup ageG err_5=[%s]\n", err_5)
			continue
		}
		fmt.Println("totalCount is ", totalCount)
		fmt.Println("nameData is ", nameData)
		fmt.Println("ageData is ", ageData)
	}
}

8 分頁查詢

//分頁查詢
func limitPage() {
	client := mongodb.DB.Mongo
	collection := client.Database(constants.DB_DATABASES).Collection(constants.DB_COLLECTION)

	ctx, cancel := context.WithTimeout(context.Background(), constants.QUERY_TIME_OUT)
	defer cancel()

	filter := bson.M{"age": bson.M{"$gte": 0}}

	SORT := bson.D{{"number", -1}}
	findOptions := options.Find().SetSort(SORT)
	//從第1頁獲取，每次獲取10條
	skipTmp := int64((1 - 1) * 10)
	limitTmp := int64(10)
	findOptions.Skip = &skipTmp
	findOptions.Limit = &limitTmp
	cursor, err := collection.Find(ctx, filter, findOptions)
	defer cursor.Close(context.Background())
	if err != nil {
		fmt.Println("limit page error is ", err)
		return
	}

	for cursor.Next(context.Background()) {
		ud := &model.UserData{}
		err := cursor.Decode(ud)
		if err != nil {
			fmt.Println("user data decode error is ", err)
			continue
		}

		fmt.Println("user data is ", ud)

	}
}

原始碼地址

可以下載原始碼，二次封裝放到專案中直接使用
https://github.com/secondtonone1/golang-/tree/master/gomongo

感謝關注公眾號