golang?mysql的連接池如何使用

本文小編為大家詳細介紹“golang mysql的連接池如何使用”，內容詳細，步驟清晰，細節處理妥當，希望這篇“golang mysql的連接池如何使用”文章能幫助大家解決疑惑，下面跟著小編的思路慢慢深入，一起來學習新知識吧。

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

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

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

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

• db.Ping() 調用完畢后會馬上把連接返回給連接池。

• db.Exec() 調用完畢后會馬上把連接返回給連接池，但是它返回的Result對象還保留這連接的引用，當后面的代碼需要處理結果集的時候連接將會被重用。

• db.Query() 調用完畢后會將連接傳遞給sql.Rows類型，當然后者迭代完畢或者顯示的調用.Clonse()方法后，連接將會被釋放回到連接池。

• db.QueryRow()調用完畢后會將連接傳遞給sql.Row類型，當.Scan()方法調用之后把連接釋放回到連接池。

• db.Begin() 調用完畢后將連接傳遞給sql.Tx類型對象，當.Commit()或.Rollback()方法調用后釋放連接。

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

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

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

• db.SetMaxOpenConns(n int) 設置打開數據庫的最大連接數。包含正在使用的連接和連接池的連接。如果你的函數調用需要申請一個連接，并且連接池已經沒有了連接或者連接數達到了最大連接數。此時的函數調用將會被block，直到有可用的連接才會返回。設置這個值可以避免并發太高導致連接mysql出現too many connections的錯誤。該函數的默認設置是0，表示無限制。

• db.SetMaxIdleConns(n int) 設置連接池中的保持連接的最大連接數。默認也是0，表示連接池不會保持釋放會連接池中的連接的連接狀態：即當連接釋放回到連接池的時候，連接將會被關閉。這會導致連接再連接池中頻繁的關閉和創建。

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

• 大量的連接空閑，導致額外的工作和延遲。

• 連接數據庫的連接過多導致錯誤。

• 連接阻塞。

• 連接池有超過十個或者更多的死連接，限制就是10次重連。

數據庫標準接口里面有3個方法用于設置連接池的屬性: SetConnMaxLifetime, SetMaxIdleConns, SetMaxOpenConns

• SetConnMaxLifetime: 設置一個連接的最長生命周期，因為數據庫本身對連接有一個超時時間的設置，如果超時時間到了數據庫會單方面斷掉連接，此時再用連接池內的連接進行訪問就會出錯, 因此這個值往往要小于數據庫本身的連接超時時間

• SetMaxIdleConns: 連接池里面允許Idel的最大連接數, 這些Idel的連接 就是并發時可以同時獲取的連接,也是用完后放回池里面的互用的連接, 從而提升性能。

• SetMaxOpenConns: 設置最大打開的連接數，默認值為0表示不限制?？刂茟糜跀祿旖⑦B接的數量，避免過多連接壓垮數據庫。

項目結構

.
+--- 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") // 使用本地時間，即東八區，北京時間
	 // 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)
	//字典類型
	//構造scanArgs、values兩個數組，scanArgs的每個值指向values相應值的地址
	columns, _ := rows.Columns()
	scanArgs := make([]interface{}, len(columns))
	values := make([]interface{}, len(columns))
	for i := range values {
		scanArgs[i] = &values[i]
	}
	for rows.Next() {
		//將行數據保存到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的連接池設置，底層還是用的database/sql的設置連接池的方法，無非就是加一層gorm自身的一些設置。

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

代碼結構

.
+--- 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注意設置表前綴和單復數

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{ // 如果不用設置表前綴及復數，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內容：
{"driverId": 17,"pageNo": 1,"pageSize": 20,"status": 1}

讀到這里，這篇“golang mysql的連接池如何使用”文章已經介紹完畢，想要掌握這篇文章的知識點還需要大家自己動手實踐使用過才能領會，如果想了解更多相關內容的文章，歡迎關注億速云行業資訊頻道。