golang mysql的連接池的具體使用

更新時間：2023年02月21日 10:11:23 作者：Marathon-Davis

本文主要介紹了golang mysql的連接池的具體使用，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

1.mysql-通過sql建立連接池

連接池用sql.Open函數(shù)創(chuàng)建連接池，可是此時只是初始化了連接池，并沒有創(chuàng)建任何連接。連接創(chuàng)建都是惰性的，只有當(dāng)你真正使用到連接的時候，連接池才會創(chuàng)建連接。連接池很重要，它直接影響著你的程序行為。

連接池的工作原來卻相當(dāng)簡單。當(dāng)你的函數(shù)(例如Exec，Query)調(diào)用需要訪問底層數(shù)據(jù)庫的時候，函數(shù)首先會向連接池請求一個連接。如果連接池有空閑的連接，則返回給函數(shù)。否則連接池將會創(chuàng)建一個新的連接給函數(shù)。一旦連接給了函數(shù)，連接則歸屬于函數(shù)。函數(shù)執(zhí)行完畢后，要不把連接所屬權(quán)歸還給連接池，要么傳遞給下一個需要連接的（Rows）對象，最后使用完連接的對象也會把連接釋放回到連接池。

請求一個連接的函數(shù)有好幾種，執(zhí)行完畢處理連接的方式稍有差別，大致如下：

db.Ping() 調(diào)用完畢后會馬上把連接返回給連接池。
db.Exec() 調(diào)用完畢后會馬上把連接返回給連接池，但是它返回的Result對象還保留這連接的引用，當(dāng)后面的代碼需要處理結(jié)果集的時候連接將會被重用。
db.Query() 調(diào)用完畢后會將連接傳遞給sql.Rows類型，當(dāng)然后者迭代完畢或者顯示的調(diào)用.Clonse()方法后，連接將會被釋放回到連接池。
db.QueryRow()調(diào)用完畢后會將連接傳遞給sql.Row類型，當(dāng).Scan()方法調(diào)用之后把連接釋放回到連接池。
db.Begin() 調(diào)用完畢后將連接傳遞給sql.Tx類型對象，當(dāng).Commit()或.Rollback()方法調(diào)用后釋放連接。

因為每一個連接都是惰性創(chuàng)建的，如何驗證sql.Open調(diào)用之后，sql.DB對象可用呢？通常使用db.Ping()方法初始化，調(diào)用了Ping之后，連接池一定會初始化一個數(shù)據(jù)庫連接。

連接失敗關(guān)于連接池另外一個知識點就是你不必檢查或者嘗試處理連接失敗的情況。當(dāng)你進(jìn)行數(shù)據(jù)庫操作的時候，如果連接失敗了，database/sql會幫你處理。實際上，當(dāng)從連接池取出的連接斷開的時候，database/sql會自動嘗試重連10次。仍然無法重連的情況下會自動從連接池再獲取一個或者新建另外一個。

連接池配置配置連接池有兩個的方法：

db.SetMaxOpenConns(n int) 設(shè)置打開數(shù)據(jù)庫的最大連接數(shù)。包含正在使用的連接和連接池的連接。如果你的函數(shù)調(diào)用需要申請一個連接，并且連接池已經(jīng)沒有了連接或者連接數(shù)達(dá)到了最大連接數(shù)。此時的函數(shù)調(diào)用將會被block，直到有可用的連接才會返回。設(shè)置這個值可以避免并發(fā)太高導(dǎo)致連接mysql出現(xiàn)too many connections的錯誤。該函數(shù)的默認(rèn)設(shè)置是0，表示無限制。
db.SetMaxIdleConns(n int) 設(shè)置連接池中的保持連接的最大連接數(shù)。默認(rèn)也是0，表示連接池不會保持釋放會連接池中的連接的連接狀態(tài)：即當(dāng)連接釋放回到連接池的時候，連接將會被關(guān)閉。這會導(dǎo)致連接再連接池中頻繁的關(guān)閉和創(chuàng)建。

對于連接池的使用依賴于你是如何配置連接池，如果使用不當(dāng)會導(dǎo)致下面問題：

大量的連接空閑，導(dǎo)致額外的工作和延遲。
連接數(shù)據(jù)庫的連接過多導(dǎo)致錯誤。
連接阻塞。
連接池有超過十個或者更多的死連接，限制就是10次重連。

數(shù)據(jù)庫標(biāo)準(zhǔn)接口里面有3個方法用于設(shè)置連接池的屬性: SetConnMaxLifetime, SetMaxIdleConns, SetMaxOpenConns

SetConnMaxLifetime: 設(shè)置一個連接的最長生命周期，因為數(shù)據(jù)庫本身對連接有一個超時時間的設(shè)置，如果超時時間到了數(shù)據(jù)庫會單方面斷掉連接，此時再用連接池內(nèi)的連接進(jìn)行訪問就會出錯, 因此這個值往往要小于數(shù)據(jù)庫本身的連接超時時間
SetMaxIdleConns: 連接池里面允許Idel的最大連接數(shù), 這些Idel的連接就是并發(fā)時可以同時獲取的連接,也是用完后放回池里面的互用的連接, 從而提升性能。
SetMaxOpenConns: 設(shè)置最大打開的連接數(shù)，默認(rèn)值為0表示不限制?？刂茟?yīng)用于數(shù)據(jù)庫建立連接的數(shù)量，避免過多連接壓垮數(shù)據(jù)庫。

項目結(jié)構(gòu)

.
+--- go.mod
+--- go.sum
+--- main.go
+--- pool
|   +--- sql-pool.go

代碼pool

package pool

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

var DB *sql.DB

func init()  {
	DB, _ = sql.Open("mysql", "root:root@tcp(localhost:3306)/test?charset=utf8&parseTime=True&loc=Local") // 使用本地時間，即東八區(qū)，北京時間
	 // set pool params
	DB.SetMaxOpenConns(2000)
	DB.SetMaxIdleConns(1000)
	DB.SetConnMaxLifetime(time.Minute * 60) // mysql default conn timeout=8h, should < mysql_timeout
	 err := DB.Ping()
	 if err != nil {
	 	log.Fatalf("database init failed, err: ", err)
	 }
	log.Println("mysql conn pool has initiated.")
}

func checkErr(err error)  {
	if err != nil {
		log.Println(err)
		panic(err)
	}
}

func createTable() {
	db := DB
	table := `CREATE TABLE IF NOT EXISTS test.user (
	 user_id INT(11) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '用戶編號',
	 user_name VARCHAR(45) NOT NULL COMMENT '用戶名稱',
	 user_age TINYINT(3) UNSIGNED NOT NULL DEFAULT 0 COMMENT '用戶年齡',
	 user_sex TINYINT(3) UNSIGNED NOT NULL DEFAULT 0 COMMENT '用戶性別',
	 PRIMARY KEY (user_id))
	 ENGINE = InnoDB
	 AUTO_INCREMENT = 1
	 DEFAULT CHARACTER SET = utf8
	 COLLATE = utf8_general_ci
	 COMMENT = '用戶表'`
	if _, err := db.Exec(table); err != nil {
		checkErr(err)
	}
}

func insert() {
	db := DB
	stmt, err := db.Prepare(`INSERT user (user, age) values (?, ?)`)
	checkErr(err)
	res, err := stmt.Exec("Elvis", 26)
	checkErr(err)
	id, err := res.LastInsertId()
	checkErr(err)
	log.Println(id)
}

func query() {
	db := DB
	rows, err := db.Query("SELECT * FROM user")
	checkErr(err)
	for rows.Next() {
		var userId int
		var userName string
		var userAge int
		var userSex int
		rows.Columns()
		err = rows.Scan(&userId, &userName, &userAge, &userSex)
		checkErr(err)
		fmt.Println(userId)
		fmt.Println(userName)
		fmt.Println(userAge)
		fmt.Println(userSex)
	}
}

func queryToMap() {
	db := DB
	rows, err := db.Query("SELECT * FROM user")
	checkErr(err)
	//字典類型
	//構(gòu)造scanArgs、values兩個數(shù)組，scanArgs的每個值指向values相應(yīng)值的地址
	columns, _ := rows.Columns()
	scanArgs := make([]interface{}, len(columns))
	values := make([]interface{}, len(columns))
	for i := range values {
		scanArgs[i] = &values[i]
	}
	for rows.Next() {
		//將行數(shù)據(jù)保存到record字典
		err = rows.Scan(scanArgs...)
		record := make(map[string]string)
		for i, col := range values {
			if col != nil {
				record[columns[i]] = string(col.([]byte))
			}
		}
		fmt.Println(record)
	}
}

func update() {
	db := DB
	stmt, err := db.Prepare(`UPDATE user SET user_age=?,user_sex=? WHERE user_id=?`)
	checkErr(err)
	res, err := stmt.Exec(21, 2, 1)
	checkErr(err)
	num, err := res.RowsAffected()
	checkErr(err)
	fmt.Println(num)
}

func remove() {
	db := DB
	stmt, err := db.Prepare(`DELETE FROM user WHERE user_id=?`)
	checkErr(err)
	res, err := stmt.Exec(1)
	checkErr(err)
	num, err := res.RowsAffected()
	checkErr(err)
	fmt.Println(num)
}

main

package main

import (
	"fmt"
	"log"
	"net/http"

	. "go-mysql-pool-v1/pool"
)

func main()  {
	http.HandleFunc("/pool", pool)
	log.Println("server is up now...")
	http.ListenAndServe(":8080", nil)
}

func pool(w http.ResponseWriter, r *http.Request)  {
	rows, err := DB.Query(`select * from user limit 1`)
	defer rows.Close()
	checkErr(err)

	columns, _ := rows.Columns()
	scanArgs := make([]interface{}, len(columns))
	values := make([]interface{}, len(columns))
	for j := range values {
		scanArgs[j] = &values[j]
	}

	record := make(map[string]string)
	for rows.Next() {
		err = rows.Scan(scanArgs...)
		for i, col := range values {
			if col != nil {
				record[columns[i]] = string(col.([]byte))
			}
		}
	}
	log.Println(record)
	fmt.Fprintf(w, "finish")
}

func checkErr(err error)  {
	if err != nil {
		log.Println(err)
		panic(err)
	}
}

可以通過工具ab測試連接池性能，用法見最下方注。

2.mysql-gorm 建立連接池

其實gorm的連接池設(shè)置，底層還是用的database/sql的設(shè)置連接池的方法，無非就是加一層gorm自身的一些設(shè)置。

以下示例為gorm v2版本，v1版本通過github.com/jinzhu/gorm，如mysql的驅(qū)動導(dǎo)入需要加_。

代碼結(jié)構(gòu)

.
+--- config
|   +--- config.go
|   +--- config.json
+--- go.mod
+--- go.sum
+--- main.go
+--- pool
|   +--- gorm-pool.go
+--- test.db

config.json

{
  "database": {
    "name": "test",
    "type": "mysql",
    "host": "localhost",
    "port": "3306",
    "user": "root",
    "password": "root",
    "table_prefix": ""
  }
}

config.go

package config

import (
	"encoding/json"
	"os"
)

type Database struct {
	Type        string `json:"type"`
	Host        string `json:"host"`
	Port        string `json:"port"`
	User        string `json:"user"`
	Password    string `json:"password"`
	Name        string `json:"name"`
	TablePrefix string `json:"table_prefix"`
}

var DatabaseSetting = &Database{}


type Config struct {
	Database *Database `json:"database"`
}

var GlobalConfigSetting = &Config{}

func init()  {
	// win path is abs-path, linux -> config.json
	filePtr, err := os.Open("D:\\demo1\\src\\demo\\demo06\\go-mysql-pool-v2\\config\\config.json")
	if err != nil {
		return
	}
	defer filePtr.Close()

	// json decode
	decoder := json.NewDecoder(filePtr)
	err = decoder.Decode(GlobalConfigSetting)
	DatabaseSetting = GlobalConfigSetting.Database
}

gorm-pool.go注意設(shè)置表前綴和單復(fù)數(shù)

package pool

import (
	"fmt"
	"go-mysql-pool-v2/config"
	"gorm.io/driver/mysql"
	"gorm.io/driver/postgres"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	"log"
	"time"
)

var db *gorm.DB

// gorm v2
func init()  {
	var dbURi string
	var dialector gorm.Dialector
	if config.DatabaseSetting.Type == "mysql" {
		dbURi = fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8&parseTime=true",
			config.DatabaseSetting.User,
			config.DatabaseSetting.Password,
			config.DatabaseSetting.Host,
			config.DatabaseSetting.Port,
			config.DatabaseSetting.Name)
		dialector = mysql.New(mysql.Config{
			DSN:                       dbURi, // data source name
			DefaultStringSize:         256,   // default size for string fields
			DisableDatetimePrecision:  true,  // disable datetime precision, which not supported before MySQL 5.6
			DontSupportRenameIndex:    true,  // drop & create when rename index, rename index not supported before MySQL 5.7, MariaDB
			DontSupportRenameColumn:   true,  // `change` when rename column, rename column not supported before MySQL 8, MariaDB
			SkipInitializeWithVersion: false, // auto configure based on currently MySQL version
		})
	} else if config.DatabaseSetting.Type == "postgres" {
		dbURi = fmt.Sprintf("host=%s port=%s user=%s dbname=%s sslmode=disable password=%s",
			config.DatabaseSetting.Host,
			config.DatabaseSetting.Port,
			config.DatabaseSetting.User,
			config.DatabaseSetting.Name,
			config.DatabaseSetting.Password)
		dialector = postgres.New(postgres.Config{
			DSN:                  "user=gorm password=gorm dbname=gorm port=9920 sslmode=disable TimeZone=Asia/Shanghai",
			PreferSimpleProtocol: true, // disables implicit prepared statement usage
		})
	} else { // sqlite3
		dbURi = fmt.Sprintf("test.db")
		dialector = sqlite.Open("test.db")
	}

	conn, err := gorm.Open(dialector, &gorm.Config{ // 如果不用設(shè)置表前綴及復(fù)數(shù)，nil
		NamingStrategy: schema.NamingStrategy{
			TablePrefix: config.DatabaseSetting.TablePrefix, // set table prefix
			SingularTable: true, // set table singular
		},
	})
	if err != nil {
		log.Println(err.Error())
	}
	sqlDB, err := conn.DB()
	if err != nil {
		log.Println("connect db server failed.")
	}
	sqlDB.SetMaxOpenConns(100)
	sqlDB.SetMaxIdleConns(10)
	sqlDB.SetConnMaxLifetime(600*time.Second)

	db = conn
}

// open api
func GetDB() *gorm.DB {
	sqlDB, err := db.DB()
	if err != nil {
		log.Println("connect db server failed.")
	}
	if err = sqlDB.Ping(); err != nil {
		sqlDB.Close()
	}

	return db
}

main

package main

import (
	"go-mysql-pool-v2/pool"
	"gorm.io/gorm"
	"log"
)

type Product struct {
	gorm.Model // default add id stats time, id as primary key
	Code string
	Price uint
}

func main()  {
	log.Println("gorm init...")
	SetupModel()
}

func SetupModel()  {
	db := pool.GetDB()
	// auto migrate
	db.AutoMigrate(&Product{})
	// create record
	db.Create(&Product{Code: "L1212", Price: 1000})
}

go.mod

module go-mysql-pool-v2

go 1.16

replace go-mysql-pool-v2 => ../go-mysql-pool-v2

require (
	gorm.io/driver/mysql v1.3.4
	gorm.io/driver/postgres v1.3.4
	gorm.io/driver/sqlite v1.3.4
	gorm.io/gorm v1.23.5
)

3.連接池相較于單個client

4.通用連接池

注

ubuntu安裝ab工具，apt-get install apache2-utils
// get 一般請求
ab -n 1000 -c 1000 http://xxx

// post json請求
ab -n 100000 -c 400 -p tempPara.txt -T application/json http://xxx

tempPara.txt內(nèi)容：
{"driverId": 17,"pageNo": 1,"pageSize": 20,"status": 1}