go database/sql -- 连接的申请与释放

小伙伴们对数据库编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《go database/sql -- 连接的申请与释放》，就很适合你，本篇文章讲解的知识点主要包括MySQL、go、数据库。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

database/sql是go自带的操作sql的库，它维护了sql的连接池，包括连接的申请和释放。

连接池

datebase/sql维护了连接池，其配置：

db.SetMaxIdleConns(10)        //设置空闲连接池中的最大idle连接数
db.SetMaxOpenConns(100)       //设置数据库连接最大打开数
db.SetConnMaxLifetime(time.Hour)    //设置可重用连接的最长时间

操作MySQL的示例程序：

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)

func main() {
    db, _ := db.Open("mysql", "root:rootroot@/dqm?charset=utf8&parseTime=True&loc=Local")    
    defer db.Close()
    db.SetMaxOpenConns(10)
    if err := db.Ping(); err != nil {
        fmt.Println("connect to MySQL failed, err:", err)
        return
    }
    rows, err := db.Query("select * from test where name = 'jackie' limit 10")
    if err != nil {
        fmt.Println("query error")
    }
    defer rows.Close()
    for rows.Next() {
        fmt.Println("close")
    }
    row, _ := db.Query("select * from test")
    fmt.Println(row, rows)
}

db.Open(“mysql”, dsn)并不会真正连接MySQL，也不会校验数据库用户名/密码，仅校验了dsn格式。

只有在Ping()或者实际的Query()操作时才会建立连接。

故项目中一般在InitDB()时，除了Open()，还要Ping()以确认连接OK。

使用MySQL

database/sql用于操作数据库的CRUD，当操作mysql时使用驱动：

import (    
    _ "github.com/go-sql-driver/mysql"
) 

它会自动注册mysql的驱动：

//github.com/go-sql-driver/mysql/driver.go
func init() {
    sql.Register("mysql", &MySQLDriver{})
}

源码分析：

初始化DB

// Open may just validate its arguments without creating a connection
// to the database. To verify that the data source name is valid, call
// Ping.
func Open(driverName, dataSourceName string) (*DB, error) {
   driversMu.RLock()
   driveri, ok := drivers[driverName]
   driversMu.RUnlock()
   if !ok {
      return nil, fmt.Errorf("sql: unknown driver %q (forgotten import?)", driverName)
   }
   if driverCtx, ok := driveri.(driver.DriverContext); ok {
      connector, err := driverCtx.OpenConnector(dataSourceName)
      if err != nil {
         return nil, err
      }
      return OpenDB(connector), nil
   }
   return OpenDB(dsnConnector{dsn: dataSourceName, driver: driveri}), nil
}

初始化DB仅构造了DB的结构，并没有创建真正的连接：

func OpenDB(c driver.Connector) *DB {
   ctx, cancel := context.WithCancel(context.Background())
   db := &DB{
      connector:    c,
      openerCh:     make(chan struct{}, connectionRequestQueueSize),
      resetterCh:   make(chan *driverConn, 50),
      lastPut:      make(map[*driverConn]string),
      connRequests: make(map[uint64]chan connRequest),
      stop:         cancel,
   }
   go db.connectionOpener(ctx)      //goroutine用于创建连接
   go db.connectionResetter(ctx)    //goroutine用于重置session
   return db
}

获取连接

获取连接都是在具体的sql被执行的时候，如Query、Exec；

func (db *DB) Query(query string, args ...interface{}) (*Rows, error) {
   return db.QueryContext(context.Background(), query, args...)
}

func (db *DB) query(ctx context.Context, query string, args []interface{}, strategy connReuseStrategy) (*Rows, error) {
   dc, err := db.conn(ctx, strategy)   //在这里获取连接：创建新的 或 使用cache的
   if err != nil {
      return nil, err
   }
    //传入dc.releaseConn，query完毕后回调该函数
   return db.queryDC(ctx, nil, dc, dc.releaseConn, query, args)   
}

通过db.conn()获取连接，先尝试从freeConn中拿，拿到就返回；否则看是否超过maxConn，没超就创建，否则进队列等待：

func (db *DB) conn(ctx context.Context, strategy connReuseStrategy) (*driverConn, error) {
    ......
    // 尝试从连接池中拿
    numFree := len(db.freeConn)
    if strategy == cachedOrNewConn && numFree > 0 {
       conn := db.freeConn[0]
        ...
        return conn, nil
    }
    // 如果超过最大连接数，要阻塞等待
    if db.maxOpen > 0 && db.numOpen >= db.maxOpen {
        ......
    }
    //创建一个新的连接
    db.numOpen++ // optimistically  
    ci, err := db.connector.Connect(ctx)
    dc := &driverConn{
       db:        db,
       createdAt: nowFunc(),
       ci:        ci,
       inUse:     true,
    }
    db.addDepLocked(dc, dc)    
    return dc, nil
}

释放连接

释放连接在query的db.releaseConn进行，释放连接实际是将连接放入连接池db.freeConn：

func (dc *driverConn) releaseConn(err error) {
   dc.db.putConn(dc, err, true)
}

// putConn adds a connection to the db's free pool.
// err is optionally the last error that occurred on this connection.
func (db *DB) putConn(dc *driverConn, err error, resetSession bool) {
    ......
    added := db.putConnDBLocked(dc, nil)
    ......
}

// Satisfy a connRequest or put the driverConn in the idle pool and return true
// or return false.
func (db *DB) putConnDBLocked(dc *driverConn, err error) bool {
    ......
    db.freeConn = append(db.freeConn, dc)
    ......
}

查询时连接的释放

query的结果返回到Rows结构中，同时它把releaseConn传递给Row；

func (db *DB) queryDC(ctx, txctx context.Context, dc *driverConn, releaseConn func(error), query string, args []interface{}) (*Rows, error) {
    ......
    rows := &Rows{
       dc:          dc,
       releaseConn: releaseConn,    //传递relaseConn函数
       rowsi:       rowsi,
    }
    rows.initContextClose(ctx, txctx)
    return rows, nil
    ......
}

而在Rows.Next()函数中：

func (rs *Rows) Next() bool {
   var doClose, ok bool
   withLock(rs.closemu.RLocker(), func() {
      doClose, ok = rs.nextLocked()
   })
   if doClose {    //发现没有记录了，就释放连接
      rs.Close()
   }
   return ok
}

func (rs *Rows) Close() error {
   return rs.close(nil)
}

func (rs *Rows) close(err error) error {
    rs.closemu.Lock()
    defer rs.closemu.Unlock()

    if rs.closed {
       return nil
    }
    rs.closed = true    //置关闭标志位
    ......
    rs.releaseConn(err)   //释放连接
    return err
}

也就是说，用Rows.Next()来释放连接；但是，如果在使用时没有遍历到最后，它不会自动释放连接。

建议最好使用defer rows.Close()手动确认关闭，从代码可以看出，rows.Close()是可重入的(置closed标志位，下次调用直接return)。

以上就是《go database/sql -- 连接的申请与释放》的详细内容，更多关于mysql的资料请关注golang学习网公众号！