网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

一日一学_Go语言mgo（mongo场景应用）

2020-06-10 11:41:32 admin 615

本文重点介绍mgo使用,仅简单介绍mongodb。

## mongodb特性

mongdb简单介绍

`注意: 上图已经告知我们mongo不支持事务，在开发项目应用时，想要保证数据的完整性请考虑关系型数据库（经典例子银行转账）。
mongo提供了许多原子操作，比如文档的保存，修改，删除等，都是原子操作。所谓原子操作就是要么这个文档保存到mongodb，要么没有保存到mongodb，不会出现查询到的文档不完整的情况。`

# mgo简介

mgo 是 mongodb 的 GO 语言驱动包。  
mgo官网：[http://labix.org/mgo](https://link.jianshu.com?t=http://labix.org/mgo)

# mgo使用

##### mgo方案一

package mgo
    
    import (
        "flag"
        "gopkg.in/mgo.v2"
        "log"
        "study/conf"
    )
    
    var session *mgo.Session
    var database *mgo.Database
    
    func init() {
         /*配置mongodb的josn文件,配置内容如下: 
          {
            "hosts": "localhost",
            "database": "user"
           }*/
        filename := flag.String("config", "./conf/config.json", "Path to configuration file")
        flag.Parse()
        config := &conf.ConfigurationDatabase{}
        config.Load(*filename)
        var err error
         
        dialInfo := &mgo.DialInfo{
            Addrs:     []string{config.Hosts},
            Direct:    false,
            Timeout:   time.Second * 1,
            PoolLimit: 4096, // Session.SetPoolLimit    }
        //创建一个维护套接字池的session
        session, err = mgo.DialWithInfo(dialInfo)
    
        if err != nil {
            log.Println(err.Error())
        }
        session.SetMode(mgo.Monotonic, true)
        //使用指定数据库
        database = session.DB(config.Database)
    
    }
    
    func GetMgo() *mgo.Session {
        return session
    }
    
    func GetDataBase() *mgo.Database {
        return database
    }
    
    func GetErrNotFound() error {
        return mgo.ErrNotFound
    }

这里的 session 能够和 mongodb 集群中的所有Server通讯。

###### session设置的模式分别为:

* Strong  
session 的读写一直向主服务器发起并使用一个唯一的连接，因此所有的读写操作完全的一致。

* Monotonic  
session 的读操作开始是向其他服务器发起（且通过一个唯一的连接），只要出现了一次写操作，session
的连接就会切换至主服务器。由此可见此模式下，能够分散一些读操作到其他服务器，但是读操作不一定能够获得最新的数据。

* Eventual  
session 的读操作会向任意的其他服务器发起，多次读操作并不一定使用相同的连接，也就是读操作不一定有序。session
的写操作总是向主服务器发起，但是可能使用不同的连接，也就是写操作也不一定有序。

//个人项目部分代码
    type User struct {
        ID       bson.ObjectId `bson:"_id"`
        UserName string        `bson:"username"`
        Summary  string        `bson:"summary"`
        Age      int           `bson:"age"`
        Phone    int           `bson:"phone"`
        PassWord string        `bson:"password"`
        Sex      int           `bson:"sex"`
        Name     string        `bson:"name"`
        Email    string        `bson:"email"`
    }
    
    func Register(password string, username string) (err error) {
        con := mgo.GetDataBase().C("user")
        //可以添加一个或多个文档
        /* 对应mongo命令行
           db.user.insert({username:"13888888888",summary:"code",
           age:20,phone:"13888888888"})*/
        err = con.Insert(&User{ID: bson.NewObjectId(), UserName: username, PassWord: password})
        return
    }
    
    func FindUser(username string) (User, error) {
        var user User
        con := mgo.GetDataBase().C("user")
        //通过bson.M(是一个map[string]interface{}类型)进行
        //条件筛选，达到文档查询的目的
        /* 对应mongo命令行
          db.user.find({username:"13888888888"})*/
        if err := con.Find(bson.M{"username": username}).One(&user); err != nil {
            if err.Error() != mgo.GetErrNotFound().Error() {
                return user, err
            }
    
        }
        return user, nil
    }

通过find()可以进行单个或者全部的查询，并且可以进行分页处理。下面为简单代码展示:  
`con.Find(nil).Limit(5).Skip(0).All(&user)`

package models
    
    import (
        "gopkg.in/mgo.v2/bson"
        "study/library/mgo"
        "time"
    )
    
    type Diary struct {
        Uid        bson.ObjectId `bson:"uid"`
        ID         bson.ObjectId `bson:"_id"`
        CreatTime  time.Time     `bson:"creattime"`
        UpdateTime time.Time     `bson:"updatetime"`
        Title      string        `bson:"title"`
        Content    string        `bson:"content"`
        Mood       int           `bson:'Mood"`
        Pic        []string      `bson:'pic'`
    }
    
    //通过uid查找本作者文章，并且显示文章作者名字
    func FindDiary(uid string) ([]interface{}, error) {
        con := mgo.GetDataBase().C("diary")
           // 其中的lookup功能可以实现类似于mysql中的join操作，方便于关联查询。
           /*对应mongo命令行
            db.diary.aggregate([{$match:{uid: ObjectId("58e7a1b89b5099fdc585d370")}},
            {$lookup{from:"user",localField:"uid",foreignField:"_id",as:"user"}},
            {$project:{"user.name":1,title:1,content:1,mood:1}}]).pretty() 
           */
        pipeline := []bson.M{
            bson.M{"$match": bson.M{"uid": bson.ObjectIdHex(uid)}},
            bson.M{"$lookup": bson.M{"from": "user", "localField": "uid", "foreignField": "_id", "as": "user"}},
            bson.M{"$project": bson.M{"user.name": 1, "title": 1, "content": 1, "mood": 1, "creattime": 1}},
        }
        pipe := con.Pipe(pipeline)
        var data []interface{}
        err := pipe.All(&data)
        if err != nil {
            return nil, err
        }
        return data, nil
    
    }
    
    func ModifyDiary(id, title, content string) (err error) {
            con := mgo.GetDataBase().C("diary")
             //更新
            /*对应mongo命令行
              db.diary.update({_id:ObjectId("58e7a1b89b5099fdc585d370")},
               {$set:{title:"modify title",content:"modify content",
               updatetime:new Date()})*/
            err = con.Update(bson.M{"_id": id}, bson.M{"$set": bson.M{"title": title, "content": content, "updatetime": time.Now().Add(8 * time.Hour)}})
            return
    
    }

mgo更新方法很多，如批量更新`con.UpdateAll(selector, update)`,更新或插入数据`con.Upsert(selector,
update)` 。

思路一会儿

##### mgo方案二

思考: session 会被全局使用，当在实际的程序中，我们可以开启goroutine 来处理每个连接，多个goroutine 可以通过
session.Clone() 来创建或复用连接，使用完成之后通过 session.Close() 来关闭这个连接。当并发很高时，看起来可以提高效率。

下面部分代码修改 :

import (
        "flag"
        "gopkg.in/mgo.v2"
        "log"
        "study/conf"
    )
    
    var session *mgo.Session
    var config *conf.ConfigurationDatabase
    
    func init() {
         filename := flag.String("config", "./conf/config.json", "Path to configuration file")
        flag.Parse()
         
        config = &conf.ConfigurationDatabase{}
        config.Load(*filename)
        var err error
         
        dialInfo := &mgo.DialInfo{
            Addrs:     []string{config.Hosts},
            Direct:    false,
            Timeout:   time.Second * 1,
            PoolLimit: 4096, // Session.SetPoolLimit
        }
        session, err = mgo.DialWithInfo(dialInfo)
    
        if err != nil {
            log.Println(err.Error())
        }
        session.SetMode(mgo.Monotonic, true)
    
        
    
    }
    
    type SessionStore struct {
        session *mgo.Session
    }
    
    //获取数据库的collection
    func (d * SessionStore) C(name string) *mgo.Collection {
        return d.session.DB(config.Database).C(name)
    }
    
    //为每一HTTP请求创建新的DataStore对象
    func New SessionStore() * SessionStore {
        ds := & SessionStore{
            session: session.Copy(),
        }
        return ds
    }
    
    func (d * SessionStore) Close() {
        d.session.Close()
    }
    
    func GetErrNotFound() error {
        return mgo.ErrNotFound
    }

对查找进行了修改

func FindUser(username string) (User, error) {
        var user User
        ds := mgo.NewSessionStore()
        defer ds.Close()
        con := ds.C("user")
        if err := con.Find(bson.M{"username": username}).One(&user); err != nil {
            if err.Error() != mgo.GetErrNotFound().Error() {
                return user, err
            }
    
        }
        return user, nil
    }

mgo方案一和二测试:  
使用boom进行并发测试,并在每个 goroutine 里面sleep 5秒，这样是让连接暂时不释放，就可以看到 mgo 方案二
会不断创建新连接，方案一不会创建新连接。可以使用mongo shell 的db.serverStatus().connections来查看连接数。

`mgo方案一测试连接数: 1000 并发：mongo 3个连接 5000 并发：mongo 3个连接。`

`mgo方案二测试连接数: 1000 并发：mongo 500多个连接 5000 并发：mongo 1400多个连接。`

提示: mgo 默认连接池是 4096，在高并发下，如果每个 session都不调用 close()，会导致连接数会很快就达到
4096，并堵死其他请求，所以在使用clone() 或 copy()时 session 时一定要使用 defer close() 把连接关闭。启用
maxPoolLimit 参数会限制总连接大小，当连接超过限制总数当前协程 等待，直到可以创建连接。

`测试结果:mgo方案一和方案二在并发下，效率差不多。`

为什么

[http://goinbigdata.com/how-to-build-microservice-with-mongodb-in-
golang/](https://link.jianshu.com?t=http://goinbigdata.com/how-to-build-
microservice-with-mongodb-in-golang/)  
  
[https://www.mongodb.com/blog/post/running-mongodb-queries-concurrently-with-
go](https://link.jianshu.com?t=https://www.mongodb.com/blog/post/running-
mongodb-queries-concurrently-with-go)

转载文章，原文链接：一日一学_Go语言mgo（mongo场景应用）

关键字词go 一学

分享到：

上一篇：一日一学_Go从错误中学习基础一

下一篇：在 Golang 开发中使用 Makefile

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

一日一学_Go语言mgo（mongo场景应用）

admin 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

一日一学_Go语言mgo（mongo场景应用）

admin 官方 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

admin 1年前