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.gofunc 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)。