在实际业务场景中，随着数据量增长，使用Go语言操作大型MySQL数据库需要兼顾性能、稳定性和资源消耗，不合理的操作方式很容易导致数据库连接耗尽、查询超时甚至服务宕机。
合理配置数据库连接池
Go语言标准库的database/sql包自带连接池功能，处理大型MySQL数据库时，必须根据业务并发量和数据库承载能力调整连接池参数，避免连接数过多压垮数据库或者连接数不足导致请求阻塞。
核心配置参数有两个：
- SetMaxOpenConns：设置数据库的最大打开连接数，不能超过MySQL配置的
max_connections参数值 - SetMaxIdleConns：设置最大空闲连接数，通常设置为最大打开连接数的二分之一左右，减少频繁创建销毁连接的开销
- SetConnMaxLifetime：设置连接的最大存活时间，避免长期占用的连接失效
以下是连接池配置的示例代码：
package main
import (
"database/sql"
"fmt"
"time"
_ "github.com/go-sql-driver/mysql"
)
func main() {
// 连接MySQL数据库，格式为 用户名:密码@tcp(地址:端口)/数据库名
dsn := "root:password@tcp(127.0.0.1:3306)/large_db"
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
defer db.Close()
// 设置最大打开连接数为100，根据MySQL的max_connections调整
db.SetMaxOpenConns(100)
// 设置最大空闲连接数为50
db.SetMaxIdleConns(50)
// 设置连接最大存活时间为1小时
db.SetConnMaxLifetime(time.Hour)
// 验证数据库连接是否正常
err = db.Ping()
if err != nil {
panic(err)
}
fmt.Println("数据库连接成功，连接池配置完成")
}
优化查询语句与索引使用
大型MySQL数据库的查询性能很大程度上依赖索引设计，Go语言执行查询时需要避免全表扫描，同时合理拼接查询条件，减少不必要的数据返回。
查询优化的核心要点：
- 避免
SELECT *，只查询需要的字段，减少数据传输量 - where条件中的字段尽量添加索引，尤其是高频查询的字段
- 避免where条件中使用函数或者运算，会导致索引失效
- 分页查询时避免使用大的offset，可采用基于主键的游标分页方式
以下是优化后的分页查询示例，采用主键游标方式避免大offset性能问题：
package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
type User struct {
ID int64
Name string
Age int
}
func queryByCursor(db *sql.DB, lastID int64, pageSize int) ([]User, error) {
// 基于主键ID游标分页，避免LIMIT大offset
query := "SELECT id, name, age FROM user WHERE id > ? ORDER BY id LIMIT ?"
rows, err := db.Query(query, lastID, pageSize)
if err != nil {
return nil, err
}
defer rows.Close()
var users []User
for rows.Next() {
var u User
err := rows.Scan(&u.ID, &u.Name, &u.Age)
if err != nil {
return nil, err
}
users = append(users, u)
}
return users, nil
}
func main() {
dsn := "root:password@tcp(127.0.0.1:3306)/large_db"
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
defer db.Close()
// 查询第一页，lastID从0开始
users, err := queryByCursor(db, 0, 20)
if err != nil {
panic(err)
}
fmt.Printf("第一页数据：%vn", users)
// 如果第一页最后一条数据的ID是20，查询下一页
if len(users) > 0 {
nextUsers, err := queryByCursor(db, users[len(users)-1].ID, 20)
if err != nil {
panic(err)
}
fmt.Printf("第二页数据：%vn", nextUsers)
}
}
批量处理数据写入与更新
处理大型MySQL数据库时，单条插入或者更新数据的效率极低，尤其是在需要写入大量数据的场景，必须采用批量操作的方式减少数据库交互次数，提升整体性能。
批量操作的核心技巧：
- 使用
INSERT INTO table VALUES (),(),()的批量插入语法，单次批量插入的数据量控制在1000条以内，避免SQL语句过长 - 批量更新可结合
CASE WHEN语法，减少更新语句的执行次数 - 批量操作时搭配事务使用，要么全部成功要么全部失败，保证数据一致性
以下是批量插入和批量更新的示例代码：
package main
import (
"database/sql"
"fmt"
"strings"
_ "github.com/go-sql-driver/mysql"
)
// 批量插入数据
func batchInsert(db *sql.DB, users []User) error {
if len(users) == 0 {
return nil
}
// 开启事务
tx, err := db.Begin()
if err != nil {
return err
}
defer tx.Rollback()
// 拼接批量插入SQL
query := "INSERT INTO user (name, age) VALUES "
var valueParts []string
var args []interface{}
for _, u := range users {
valueParts = append(valueParts, "(?, ?)")
args = append(args, u.Name, u.Age)
}
query += strings.Join(valueParts, ",")
// 执行插入
_, err = tx.Exec(query, args...)
if err != nil {
return err
}
// 提交事务
return tx.Commit()
}
// 批量更新数据
func batchUpdate(db *sql.DB, users []User) error {
if len(users) == 0 {
return nil
}
tx, err := db.Begin()
if err != nil {
return err
}
defer tx.Rollback()
// 拼接批量更新SQL，根据ID更新年龄
query := "UPDATE user SET age = CASE id "
var args []interface{}
for _, u := range users {
query += "WHEN ? THEN ? "
args = append(args, u.ID, u.Age)
}
query += "END WHERE id IN ("
// 拼接IN条件的ID
var idParts []string
for _, u := range users {
idParts = append(idParts, "?")
args = append(args, u.ID)
}
query += strings.Join(idParts, ",") + ")"
_, err = tx.Exec(query, args...)
if err != nil {
return err
}
return tx.Commit()
}
func main() {
dsn := "root:password@tcp(127.0.0.1:3306)/large_db"
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
defer db.Close()
// 构造批量插入数据
var insertUsers []User
for i := 0; i < 100; i++ {
insertUsers = append(insertUsers, User{Name: fmt.Sprintf("user_%d", i), Age: 20 + i%10})
}
err = batchInsert(db, insertUsers)
if err != nil {
panic(err)
}
fmt.Println("批量插入完成")
// 构造批量更新数据
var updateUsers []User
updateUsers = append(updateUsers, User{ID: 1, Age: 25})
updateUsers = append(updateUsers, User{ID: 2, Age: 26})
err = batchUpdate(db, updateUsers)
if err != nil {
panic(err)
}
fmt.Println("批量更新完成")
}
监控与异常处理
处理大型MySQL数据库时，还需要做好数据库操作的监控和异常处理，及时发现慢查询、连接异常等问题，避免问题扩大影响业务。
可以在执行数据库操作时添加耗时统计，记录慢查询日志，同时捕获数据库操作的错误，进行重试或者告警处理。以下是添加耗时统计的示例：
package main
import (
"database/sql"
"fmt"
"time"
_ "github.com/go-sql-driver/mysql"
)
func queryWithMonitor(db *sql.DB, query string, args ...interface{}) (*sql.Rows, error) {
start := time.Now()
rows, err := db.Query(query, args...)
cost := time.Since(start)
// 耗时超过500毫秒记为慢查询
if cost > 500*time.Millisecond {
fmt.Printf("慢查询：SQL=%s, 耗时=%v, 参数=%vn", query, cost, args)
}
return rows, err
}
func main() {
dsn := "root:password@tcp(127.0.0.1:3306)/large_db"
db, err := sql.Open("mysql", dsn)
if err != nil {
panic(err)
}
defer db.Close()
rows, err := queryWithMonitor(db, "SELECT id, name FROM user WHERE age > ?", 20)
if err != nil {
panic(err)
}
defer rows.Close()
fmt.Println("查询执行完成")
}