数据库连接为何会自动关闭？

大家好，我们又见面了啊~本文《数据库连接为何会自动关闭？》的内容中将会涉及到等等。如果你正在学习Golang相关知识，欢迎关注我，以后会给大家带来更多Golang相关文章，希望我们能一起进步！下面就开始本文的正式内容~

我在使用 gorm / psql 时遇到问题，数据库连接自动关闭。

我从来没有在 main.go 中调用 defer dbinstance.close() （现在不再调用，我已经删除了它，因为这是我的代码中唯一一个我认为连接可能被错误关闭的地方）也不是任何其他地方。

我初始化数据库的方式是使用“db”包，如下所示：

package db

import (
    "fmt"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/postgres"
)

var dbinstance *gorm.db

func init() *gorm.db {
    if dbinstance != nil {
        return dbinstance
    }
    fmt.println("opening db")
    db, err := gorm.open("postgres", "host=localhost port=5432 user=admin dbname=dbname sslmode=disable password=")
    if err != nil {
        fmt.println(err)
        panic("failed to connect database")
    }
    return db
}

然后我在 main.go 中调用 db.init() ，然后仅从程序的其余部分调用“db.dbinstance”中的数据库。

正如我之前提到的，我曾经从 main.go 调用 defer db.dbinstance.close() 但尝试将其删除以查看是否解决了问题，但没有解决。

奇怪的是，数据库连接将在许多不同的调用/函数中工作数小时，但总是在某个时刻关闭。

据我了解，它应该有效：

gorm.open() 使用 https://golang.org/pkg/database/sql/，即 线程安全并为您处理连接池。不要打电话 gorm.open() 每个请求。设置时调用一次 应用程序，并确保使用 defer db.close() 以便连接 当你的程序退出时干净地结束。

最后我需要补充一点，似乎（我不是 100% 确定）在我进行批量插入后它正在关闭，但 .close() 函数在我的程序中的任何地方都不会被调用.

我有点迷茫，不知道会发生什么？垃圾收集器（var 是全局的没有意义）？ psql 驱动程序在后台关闭？配置问题？

我添加批处理函数以供参考，以防万一：

func insertwithpostgreslimitsizev2(db *gorm.db, array []interface{}) {
    if len(array) == 0 {
        return
    }
    numberofparams := len(db.newscope(array[0]).fields())
    // postgres is limited to 65535 params.
    maxstructperbulk := int(65535 / numberofparams)
    currentindex := 0
    if len(array) > maxstructperbulk {
        for len(array) > currentindex {
            if (maxstructperbulk + currentindex) < len(array) {
                slice := array[currentindex:(currentindex + maxstructperbulk)]
                currentindex += maxstructperbulk
                _, err := db.batchinsert(slice)
                log.println(err)
            } else {

                slice := array[currentindex:len(array)]
                currentindex = len(array)
                _, err := db.batchinsert(slice)
                log.println(err)
            }
        }
    } else {
        _, err := db.batchinsert(array)
        log.println(err)
    }
}

func batchinsert(db *gorm.db,objarr []interface{}) (int64, error) {
    if len(objarr) == 0 {
        return 0, errors.new("insert a slice length of 0")
    }

    mainobj := objarr[0]
    mainscope := db.newscope(mainobj)
    mainfields := mainscope.fields()
    quoted := make([]string, 0, len(mainfields))
    for i := range mainfields {
        if (mainfields[i].isprimarykey && mainfields[i].isblank) || (mainfields[i].isignored) {
            continue
        }
        quoted = append(quoted, mainscope.quote(mainfields[i].dbname))
    }

    placeholdersarr := make([]string, 0, len(objarr))

    for _, obj := range objarr {
        scope := db.newscope(obj)
        fields := scope.fields()
        placeholders := make([]string, 0, len(fields))
        for i := range fields {
            if (fields[i].isprimarykey && fields[i].isblank) || (fields[i].isignored) {
                continue
            }
            var vars interface{}
            if (fields[i].name == "createdat" || fields[i].name == "updatedat") && fields[i].isblank {
                vars = gorm.nowfunc()
            } else {
                vars = fields[i].field.interface()
            }
            placeholders = append(placeholders, mainscope.addtovars(vars))
        }
        placeholdersstr := "(" + strings.join(placeholders, ", ") + ")"
        placeholdersarr = append(placeholdersarr, placeholdersstr)

        mainscope.sqlvars = append(mainscope.sqlvars, scope.sqlvars...)
    }
    mainscope.raw(fmt.sprintf("insert into %s (%s) values %s",
        mainscope.quotedtablename(),
        strings.join(quoted, ", "),
        strings.join(placeholdersarr, ", "),
    ))
    if err := mainscope.exec().db().error; err != nil {
        return 0, err
    }
    return mainscope.db().rowsaffected, nil
}

最后一件事是，我正在考虑通过调用我的数据库来“修复”问题，但 ping 会减慢我的每个调用：

func getDb() *gorm.DB {
    err := DbInstance.DB().Ping()
    if err != nil {
        fmt.Println("Connection to db closed opening a new one")
        return Init()
    }
    return DbInstance
}

解决方案

您可以全局搜索 dbinstance.close() 以确保永远不会调用它来自行关闭它。 如果没有，您可以将数据库超时设置得更长并增加空闲数据库连接数。

最后，最重要的是支持自动重连数据库数据源。

这是我的自动重新连接部分，您可以参考：

var db *gorm.db
func init() {
    dbconfig = fmt.sprintf("host=%s user=%s dbname=%s sslmode=%s password=%s",
        "localhost",
        "postgres",
        "dbname",
        "disable",
        "password",
    )
    db, err := gorm.open("postgres",
        dbconfig,
    )
    db.singulartable(true)
    db.logmode(true)
    db.db().setconnmaxlifetime(10 * time.second)
    db.db().setmaxidleconns(30)
    db = db
    // auto-connect，ping per 60s, re-connect on fail or error with intervels 3s, 3s, 15s, 30s, 60s, 60s ...
    go func(dbconfig string) {
        var intervals = []time.duration{3 * time.second, 3 * time.second, 15 * time.second, 30 * time.second, 60 * time.second,
        }
        for {
            time.sleep(60 * time.second)
            if e := db.db().ping(); e != nil {
            l:
                for i := 0; i < len(intervals); i++ {
                    e2 := retryhandler(3, func() (bool, error) {
                        var e error
                        db, e = gorm.open("postgres", dbconfig)
                        if e != nil {
                            return false, errorx.wrap(e)
                        }
                        return true, nil
                    })
                    if e2 != nil {
                        fmt.println(e.error())
                        time.sleep(intervals[i])
                        if i == len(intervals)-1 {
                            i--
                        }
                        continue
                    }
                    break l
                }

            }
        }
    }(dbconfig)
}

顺便说一下：

// Try f() n times on fail and one time on success 
func RetryHandler(n int, f func() (bool, error)) error {
    ok, er := f()
    if ok && er == nil {
        return nil
    }
    if n-1 > 0 {
        return RetryHandler(n-1, f)
    }
    return er
}

终于介绍完啦！小伙伴们，这篇关于《数据库连接为何会自动关闭？》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！