Go Mgo 应用中 TCP 超时与连接池的最佳实践

package main

import (
    "log"
    "time"

    "gopkg.in/mgo.v2"
)

// InitMongoDB 初始化 MongoDB 连接
func InitMongoDB(mongoURL string, timeout time.Duration) (*mgo.Session, error) {
    dialInfo, err := mgo.ParseURL(mongoURL)
    if err != nil {
        return nil, err
    }

    // 设置连接超时和操作超时
    dialInfo.Timeout = timeout // 延长超时时间
    // dialInfo.Source = "admin" // 如果需要认证

    session, err := mgo.DialWithInfo(dialInfo)
    if err != nil {
        return nil, err
    }

    // 可选：设置读写模式和一致性
    // session.SetMode(mgo.Monotonic, true)

    return session, nil
}

func main() {
    mongoURL := "mongodb://localhost:27017/mydb"
    // 将超时时间从默认的10秒延长到30秒或更长，根据实际业务需求调整
    // 注意：过长的超时时间可能掩盖潜在的性能问题
    connectionTimeout := 30 * time.Second 

    session, err := InitMongoDB(mongoURL, connectionTimeout)
    if err != nil {
        log.Fatalf("Failed to connect to MongoDB: %v", err)
    }
    defer session.Close() // 确保主会话在应用退出时关闭

    log.Println("Successfully connected to MongoDB with custom timeout.")

    // 应用程序的其他逻辑...
}

package main

import (
    "fmt"
    "log"
    "time"

    "gopkg.in/mgo.v2"
    "gopkg.in/mgo.v2/bson"
)

var globalSession *mgo.Session

// initGlobalSession 初始化全局主会话
func initGlobalSession(mongoURL string, timeout time.Duration) error {
    dialInfo, err := mgo.ParseURL(mongoURL)
    if err != nil {
        return err
    }
    dialInfo.Timeout = timeout

    session, err := mgo.DialWithInfo(dialInfo)
    if err != nil {
        return err
    }

    // 设置全局主会话的读写模式和一致性
    session.SetMode(mgo.Monotonic, true)
    globalSession = session
    return nil
}

// GetCollection 获取集合的会话副本
func GetCollection(dbName, collectionName string) (*mgo.Collection, *mgo.Session) {
    if globalSession == nil {
        log.Fatal("Global Mgo session not initialized.")
    }
    // 为每个请求创建会话副本
    sessionCopy := globalSession.Copy() 
    return sessionCopy.DB(dbName).C(collectionName), sessionCopy
}

// 模拟一个可能超时的数据库操作
func performDBSlowOperation(dbName, collectionName string) error {
    coll, session := GetCollection(dbName, collectionName)
    defer session.Close() // 确保会话副本在使用后关闭

    // 模拟一个长时间运行的查询，例如查询一个不存在的索引，或者一个非常大的集合
    // 实际应用中，这里可能是真正的查询逻辑
    var result struct {
        Name string `bson:"name"`
    }
    err := coll.Find(bson.M{"non_existent_field": "value"}).One(&result)
    if err != nil {
        if err == mgo.ErrNotFound {
            return nil // 查找不到是正常情况
        }
        // 捕获并处理可能的超时错误
        if mgo.Is ); // 检查是否是网络错误，包括超时
        // if err.Error() == "read tcp 10.168.30.100:37288: i/o timeout" { // 更具体的错误匹配
            log.Printf("Database operation timed out or network error: %v", err)
            // 这里可以进行错误重试，或者返回特定错误码给客户端
            return fmt.Errorf("database operation failed due to timeout/network: %v", err)
        }
        return fmt.Errorf("database operation failed: %v", err)
    }
    log.Printf("Query result: %v", result)
    return nil
}

func main() {
    mongoURL := "mongodb://localhost:27017/testdb"
    connectionTimeout := 5 * time.Second // 故意设置短一点，方便测试超时

    err := initGlobalSession(mongoURL, connectionTimeout)
    if err != nil {
        log.Fatalf("Failed to initialize global Mgo session: %v", err)
    }
    defer globalSession.Close() // 确保全局主会话在应用退出时关闭

    log.Println("Global Mgo session initialized.")

    // 模拟多次请求，每次请求都会获取一个新的会话副本
    for i := 0; i < 3; i++ {
        log.Printf("Performing DB operation %d...", i+1)
        err := performDBSlowOperation("testdb", "mycollection")
        if err != nil {
            log.Printf("Operation %d failed: %v", i+1, err)
        } else {
            log.Printf("Operation %d successful.", i+1)
        }
        time.Sleep(1 * time.Second) // 模拟请求间隔
    }
}