维持mgo会议的最佳实践

Question

我目前正在使用带有mgo lib的mongoDB作为Web应用程序，但我不确定我使用它的方式是否是好的。

package db

import (
    "gopkg.in/mgo.v2"
)

const (
    MongoServerAddr = "192.168.0.104"
    RedisServerAddr = "192.168.0.104"
)

var (
    MongoSession, err = mgo.Dial(MongoServerAddr)

    MDB  = MongoSession.DB("message")
    MCol = MDB.C("new")
    MSav = MDB.C("save")

    UDB  = MongoSession.DB("account")
    UCol = UDB.C("user")
)

我初始化db会话并创建获取集合和文档值的变量，因此当我需要查询集合时，我使用该变量进行查询。

像这样：

func UserExist(username string) bool {
    user := Users{}
    err := db.UCol.Find(bson.M{"username": username}).One(&user)
    if err != nil {
        return false
    } else {
        return true
    }
}

那么，有没有一个最佳实践，或者这一个很好。。？谢谢

Answer 1

使用go 1.7，在Web服务器上处理mongo会话的最惯用方法是使用新的标准库包context编写一个中间件，可以附加延迟会话。每当调用请求上下文Done（）时关闭（）。所以你不需要记住关闭

AttachDeviceCollection = func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            db, err := infra.Cloner()
            if err != nil {
                http.Error(w, err.Error(), http.StatusInternalServerError)
                return
            }
            collection, err := NewDeviceCollection(db)

            if err != nil {
                db.Session.Close()
                http.Error(w, err.Error(), http.StatusInternalServerError)
                return
            }
            ctx := context.WithValue(r.Context(), DeviceRepoKey, collection)
            go func() {
                select {
                case <-ctx.Done():
                    collection.Session.Close()
                }
            }()

            next.ServeHTTP(w, r.WithContext(ctx))
        })
    }

Answer 2

虽然没有直接回答您的问题，但关于mgo会话检查，您必须使用延迟/恢复，因为mgo调用（甚至mgo.session.ping）恐慌。据我所知，没有其他方法可以检查mgo会话状态（mgo godocs）。您可以使用Gustavo Niemeyer的建议并在您的DataStore类型上添加一个方法。

func (d *DataStore) EnsureConnected() {
    defer func() {
        if r := recover(); r != nil {
            //Your reconnect logic here.
        }
    }()

    //Ping panics if session is closed. (see mgo.Session.Panic())  
    d.Ping()
}

Answer 3

我建议不要使用这样的全球会议。相反，您可以创建一个负责所有数据库交互的类型。例如：

type DataStore struct {
    session *mgo.Session
}

func (ds *DataStore) ucol() *mgo.Collection { ... }

func (ds *DataStore) UserExist(user string) bool { ... }

这种设计有很多好处。重要的一点是，它允许您同时运行多个会话，因此，例如，如果您有一个http处理程序，您可以创建一个本地会话，该会话由一个独立的会话支持，仅用于该请求：

func (s *WebSite) dataStore() *DataStore {
    return &DataStore{s.session.Copy()}
}    

func (s *WebSite) HandleRequest(...) {
    ds := s.dataStore()
    defer ds.Close()
    ...
}

在这种情况下，mgo驱动程序表现良好，因为会话是在内部缓存和重用/维护的。在使用过程中，每个会话还将由一个独立的套接字支持，可以配置独立的设置，也可以进行独立的错误处理。如果使用单个全局会话，这些问题最终将不得不解决。