Go 连接 MySQL

在实际后端开发中,像用户账号、商品信息和交易订单这类业务数据,通常都保存在关系型数据库 MySQL 中。

Go 语言在标准库中提供了统一的数据库操作包 database/sql。我们只需要在项目里安装一个第三方 MySQL 驱动包,就可以直接调用标准库提供的方法完成数据库连接、增删查改以及事务处理。

连接 MySQL 数据库

由于标准库 database/sql 只定义了操作数据库的统一接口,并没有内置具体数据库的通信协议,因此我们在写代码前需要先安装官方推荐的 MySQL 驱动包。

我们先确保本机已经启动了 MySQL 服务,并建好了一个名为 testdb 的空数据库。接着新建一个项目文件夹,在终端中通过 Go Modules 初始化项目并安装驱动包。如果下载速度较慢,小伙伴们可以先配置好 GOPROXY 镜像源,再执行下面的命令:

go mod init mysqldemo
go get -u github.com/go-sql-driver/mysql

驱动包安装完成后,在代码中连接 MySQL 数据库主要分为 2 步:① 调用 sql.Open() 初始化数据库连接池;② 调用 db.Ping() 验证网络和账号密码是否真正连通。

语法:

db, err := sql.Open("mysql", dsn)
err = db.Ping()

说明:

在使用 database/sql 时,我们需要在 import 中使用下划线匿名导入驱动包 _ "github.com/go-sql-driver/mysql",让驱动自动注册到标准库中,两者的配合关系如下图所示。

database/sql 标准库与 MySQL 驱动的配合关系

参数 dsn 是英文 “Data Source Name(数据源名称)” 的缩写,用来告诉程序如何连上数据库。它的完整格式为 "用户名:密码@tcp(IP地址:端口)/数据库名?参数配置",各部分的含义如下:

  • 用户名:密码:登录 MySQL 的账号与密码,例如 root:123456。
  • @tcp(IP地址:端口):指定 TCP 协议以及数据库地址与端口,连接本机默认写 @tcp(127.0.0.1:3306)。
  • /数据库名:斜杠后面填写要操作的数据库名称,例如 /testdb。
  • ?参数配置:charset=utf8mb4 表示采用支持中文和表情符号的 UTF-8 编码,parseTime=True&loc=Local 表示按本地时区自动解析时间字段。

对于 sql.Open("mysql", dsn) 来说,第 1 个参数固定写驱动名 "mysql",第 2 个参数传入拼接好的 dsn。调用成功后,它会返回一个 *sql.DB 数据库连接池对象。

示例 1:连接 MySQL 数据库

package main

import (
    "database/sql"
    "fmt"
    "time"

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

func main() {
    // 1. 准备数据库连接字符串 DSN
    dsn := "root:123456@tcp(127.0.0.1:3306)/testdb?charset=utf8mb4&parseTime=True&loc=Local"

    // 2. 初始化数据库连接池
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        fmt.Println("DSN 格式错误:", err)
        return
    }
    defer db.Close()

    // 3. 配置连接池参数
    db.SetMaxOpenConns(20)              // 最大连接数
    db.SetMaxIdleConns(10)              // 最大空闲连接数
    db.SetConnMaxLifetime(time.Hour)    // 单条连接最长存活时间

    // 4. 验证数据库是否真正连通
    if err := db.Ping(); err != nil {
        fmt.Println("连接数据库失败:", err)
        return
    }
    fmt.Println("MySQL 数据库连接成功!")
}

运行结果如下。

MySQL 数据库连接成功!

分析:

在这个例子中,我们先准备好连接字符串 dsn,小伙伴们在本地运行时记得把里面的 123456 改成自己设置的 MySQL 密码。通过 sql.Open() 拿到连接池对象 db 后,我们再调用 db.Ping() 测试网络与密码是否正确,全部通过后就会打印连接成功的提示。

中间的三行连接池配置在真实后端项目中非常实用。默认情况下,database/sql 不限制最大连接数,高并发时容易把 MySQL 服务器撑爆。

我们通过 SetMaxOpenConns() 限制最大连接数,通过 SetMaxIdleConns() 保留适量的空闲连接复用,再配合 SetConnMaxLifetime() 定期更换旧连接,服务运行起来就会稳定很多。

注意: 调用 sql.Open() 时,程序并不会立即连接 MySQL 服务器,也不会校验账号密码是否正确,只是先在内存里初始化连接配置。因此调用完 sql.Open() 后记得紧接着执行一次 db.Ping(),只有返回 nil 才代表真正连上了数据库。

插入、修改与删除数据

为了方便演示后面的增删查改操作,我们先在本地 MySQL 的 testdb 数据库中执行下面这条 SQL 语句,创建一张名为 users 的测试表:

create table users (
    id int primary key auto_increment,
    name varchar(50) not null,
    age int not null,
    bio varchar(100) null
);

在 database/sql 包中,凡是不需要返回表格数据行的操作,包括插入(insert)、修改(update)和删除(delete),统一都调用 db.Exec() 方法。

语法:

res, err := db.Exec(sql语句, 参数1, 参数2, ...)
lastID, err := res.LastInsertId()
affected, err := res.RowsAffected()

说明:

db.Exec() 的第 1 个参数是 SQL 语句,里面需要动态传入的数据统一使用英文问号(?)作为占位符,随后我们把实际的变量按顺序跟在后面即可。

执行成功后返回的 res 对象提供了两个常用方法:res.LastInsertId() 用于获取插入记录后自动生成的自增主键 ID,res.RowsAffected() 用于获取本次操作一共影响了多少行记录。

示例 2:插入与修改数据

package main

import (
    "database/sql"
    "fmt"

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

func main() {
    dsn := "root:123456@tcp(127.0.0.1:3306)/testdb?charset=utf8mb4"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        fmt.Println("DSN 格式错误:", err)
        return
    }
    defer db.Close()

    if err := db.Ping(); err != nil {
        fmt.Println("连接数据库失败:", err)
        return
    }

    // 1. 使用 ? 占位符插入新记录
    insertSQL := "insert into users (name, age, bio) values (?, ?, ?)"
    res, err := db.Exec(insertSQL, "Tom", 22, "Go 后端开发者")
    if err != nil {
        fmt.Println("插入失败:", err)
        return
    }
    newID, err := res.LastInsertId()        // 获取刚插入的自增 ID
    if err != nil {
        fmt.Println("获取 ID 失败:", err)
        return
    }
    fmt.Println("Tom 的用户 ID =", newID)

    // 再插入一条简介为空的记录
    if _, err := db.Exec(insertSQL, "Lily", 20, nil); err != nil {
        fmt.Println("插入失败:", err)
        return
    }

    // 2. 根据 ID 修改记录
    updateSQL := "update users set age = ? where id = ?"
    res2, err := db.Exec(updateSQL, 23, newID)
    if err != nil {
        fmt.Println("修改失败:", err)
        return
    }
    affected, err := res2.RowsAffected()    // 获取受影响的行数
    if err != nil {
        fmt.Println("获取行数失败:", err)
        return
    }
    fmt.Println("修改受影响行数 =", affected)
}

运行结果如下。

Tom 的用户 ID = 1
修改受影响行数 = 1

分析:

执行 db.Exec(insertSQL, "Tom", 22, "Go 后端开发者") 时,SQL 语句里的三个问号 ? 会按顺序被后面的参数替换。接着程序又插入了一条 "Lily" 的记录,并在第 3 个参数位置传入 nil(写入数据库后即为 NULL),同时把 Tom 的年龄更新成了 23。

如果小伙伴们在本地重复运行多次这段代码,表中会继续新增记录,返回的自增 ID 也会依次往后递增。想要根据 ID 删除一条记录时,写法也是完全一样的,代码如下:

deleteSQL := "delete from users where id = ?"
res, err := db.Exec(deleteSQL, 1)

注意: 编写包含动态变量的 SQL 语句时,一定要使用问号(?)占位符传参,千万不要使用 + 号或 fmt.Sprintf() 直接拼接字符串。如果直接拼接,恶意传入 "1 or 1=1" 就会把条件改成 where id = 1 or 1=1,导致整张表被泄露或删光。使用 ? 占位符能将 SQL 语法与参数值隔离,从根源上防止 “SQL 注入” 攻击。

查询数据库记录

在运行下面的查询示例前,小伙伴们先确保已经执行过示例 2,往 users 表中插入了测试记录。使用 select 语句读取数据时,我们通常会先定义一个与数据表列对应的结构体(如 User)来接收结果。

根据查询结果的行数,database/sql 包提供了 2 个方法:查询单行使用 db.QueryRow(),查询多行则使用 db.Query()。

1. 查询单行数据

当我们按主键 ID 或唯一账号查询最多只有一行的记录时,使用 db.QueryRow() 最省事。

语法:

err := db.QueryRow(sql语句, 参数...).Scan(&字段1, &字段2, ...)

说明:

调用 db.QueryRow() 后,我们直接在后面链式调用 .Scan(&字段1, &字段2, ...),就能把查询出来的各列数据按顺序写入结构体字段或普通变量中。如果表中没有查到符合条件的记录,Scan() 会返回 sql.ErrNoRows 错误。

示例 3:查询单条记录到结构体

package main

import (
    "database/sql"
    "fmt"

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

type User struct {
    ID   int
    Name string
    Age  int
}

func main() {
    dsn := "root:123456@tcp(127.0.0.1:3306)/testdb?charset=utf8mb4"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        fmt.Println("DSN 格式错误:", err)
        return
    }
    defer db.Close()

    if err := db.Ping(); err != nil {
        fmt.Println("连接数据库失败:", err)
        return
    }

    var u User
    querySQL := "select id, name, age from users where id = ?"
    err = db.QueryRow(querySQL, 1).Scan(&u.ID, &u.Name, &u.Age)
    if err == sql.ErrNoRows {
        fmt.Println("未找到该用户记录")
        return
    }
    if err != nil {
        fmt.Println("查询失败:", err)
        return
    }
    fmt.Printf("id=%d, name=%s, age=%d\n", u.ID, u.Name, u.Age)
}

运行结果如下。

id=1, name=Tom, age=23

分析:

在 select id, name, age 中,我们明确写出了要查询的 3 个列名,因此后面 .Scan(&u.ID, &u.Name, &u.Age) 传入的字段顺序也必须严格对应。在实际开发中,大家不要偷懒写成 select *,以免日后数据表增减列时导致字段扫描错位。

同时,每个字段前面都必须加上取地址符 & 传入指针,这样 Scan() 内部才能把读出来的数据写入变量 u 中。当我们需要区分 “查无此人” 与 “数据库故障” 时,像上面那样先单独判断 err == sql.ErrNoRows 即可。

2. 查询多行数据与处理 NULL 值

如果查询条件可能会返回多条记录,我们就需要使用 db.Query() 方法获取结果集,再配合 for 循环逐行扫描并装入结构体切片中。

语法:

rows, err := db.Query(sql语句, 参数...)
if err != nil {
    // 处理查询错误
}
defer rows.Close()

for rows.Next() {
    err := rows.Scan(&字段1, &字段2, ...)
}
err = rows.Err()

说明:

调用 db.Query() 会返回一个 *sql.Rows 结果集对象 rows。确认 err == nil 后,我们需要第一时间使用 defer 语句写上 defer rows.Close()。

随后通过 for rows.Next() 循环逐行往下移动。每当 rows.Next() 返回 true 时,就代表成功定位到了下一行,在循环内调用 rows.Scan() 即可取出当前行的列数据。循环结束后,我们再调用 rows.Err() 检查遍历中途有没有发生异常。

这里还有一个新手最容易栽跟头的细节:前面 users 表里的 bio 列允许为空,Lily 的简介存的就是 NULL。如果直接把 NULL 值 Scan() 到普通 string 字段里,程序会直接报错。

遇到可能为空的列,我们需要使用标准库提供的 sql.NullString 类型来接收。类似的还有 sql.NullInt64 和 sql.NullTime,分别对应可能为空的整数和时间字段。

示例 4:查询多条记录并处理 NULL 字段

package main

import (
    "database/sql"
    "fmt"

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

type User struct {
    ID   int
    Name string
    Age  int
    Bio  sql.NullString    // 兼容数据库 NULL 值
}

func main() {
    dsn := "root:123456@tcp(127.0.0.1:3306)/testdb?charset=utf8mb4"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        fmt.Println("DSN 格式错误:", err)
        return
    }
    defer db.Close()

    if err := db.Ping(); err != nil {
        fmt.Println("连接数据库失败:", err)
        return
    }

    querySQL := "select id, name, age, bio from users where age >= ?"
    rows, err := db.Query(querySQL, 18)
    if err != nil {
        fmt.Println("查询出错:", err)
        return
    }
    defer rows.Close()

    var users []User
    for rows.Next() {
        var u User
        if err := rows.Scan(&u.ID, &u.Name, &u.Age, &u.Bio); err != nil {
            fmt.Println("读取行数据失败:", err)
            return
        }
        users = append(users, u)
    }
    if err := rows.Err(); err != nil {
        fmt.Println("遍历结果集出错:", err)
        return
    }

    for _, u := range users {
        bioText := "暂无简介"
        if u.Bio.Valid {
            bioText = u.Bio.String
        }
        fmt.Printf("id=%d, name=%s, age=%d, bio=%s\n", u.ID, u.Name, u.Age, bioText)
    }
}

运行结果如下。

id=1, name=Tom, age=23, bio=Go 后端开发者
id=2, name=Lily, age=20, bio=暂无简介

分析:

在这个例子中,sql.NullString 内部包含两个字段:Valid(布尔值,表示该列是否不为空)和 String(实际的文本内容)。读取到 Lily 的记录时,u.Bio.Valid 为 false,程序就会自然显示默认文案 "暂无简介",不会因为 NULL 值导致扫描报错。

除了 sql.NullString 之外,我们也可以把结构体字段类型改成字符串指针 *string 来接收可能为 NULL 的列(为空时指针自动为 nil),小伙伴们按项目习惯选用即可。

我们可别忘了,使用 db.Query() 查询多行数据后千万不能漏写 defer rows.Close()。只要 rows 结果集没有关闭,它占用的那条数据库连接就不会归还给连接池。一旦多漏写几次把连接池占满,后续的数据库操作就会全部卡住。

使用数据库事务

在实际业务开发中,很多操作并不是单条 SQL 就能完成的。比如银行转账:我们需要先从 Tom 的账户扣除 100 元,再给 Lily 的账户增加 100 元。如果扣完款后程序突然断电或报错,第 2 条 SQL 没执行成功,钱就会凭空消失。

为了保证多条 SQL 语句 “要么全部成功,要么全部撤销恢复原状”,数据库提供了 “事务(Transaction)” 机制。在 database/sql 包中,我们可以通过 db.Begin() 开启事务。

语法:

tx, err := db.Begin()
defer tx.Rollback()

// 使用 tx.Exec() 或 tx.Query() 执行多条 SQL

err = tx.Commit()

说明:

db.Begin() 会开启一个新事务并返回一个 *sql.Tx 对象 tx。开启事务后,我们紧接着写上 defer tx.Rollback() 作为保护。

如果中途任意一条 SQL 出错提前返回,defer 会自动触发回滚,把之前改过的数据全部撤销。而一旦最后的 tx.Commit() 提交成功,再执行的 tx.Rollback() 会被自动忽略,没有任何副作用。

为了演示转账事务,我们先在 testdb 数据库中建一张极简的 accounts 账户表并初始化两条测试数据:

create table accounts (
    id int primary key auto_increment,
    name varchar(50) not null,
    balance int not null
);
insert into accounts (name, balance) values ('Tom', 1000), ('Lily', 500);

示例 5:使用事务完成账户转账

package main

import (
    "database/sql"
    "fmt"

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

func transfer(db *sql.DB, fromName, toName string, amount int) error {
    // 1. 开启事务并登记自动回滚
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    defer tx.Rollback()

    // 2. 转出方扣减余额
    subSQL := "update accounts set balance = balance - ? where name = ?"
    if _, err := tx.Exec(subSQL, amount, fromName); err != nil {
        return err
    }

    // 3. 转入方增加余额
    addSQL := "update accounts set balance = balance + ? where name = ?"
    if _, err := tx.Exec(addSQL, amount, toName); err != nil {
        return err
    }

    // 4. 全部成功,提交事务
    return tx.Commit()
}

func main() {
    dsn := "root:123456@tcp(127.0.0.1:3306)/testdb?charset=utf8mb4"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        fmt.Println("DSN 格式错误:", err)
        return
    }
    defer db.Close()

    if err := db.Ping(); err != nil {
        fmt.Println("连接数据库失败:", err)
        return
    }

    if err := transfer(db, "Tom", "Lily", 100); err != nil {
        fmt.Println("转账失败,已回滚:", err)
        return
    }
    fmt.Println("转账成功!Tom 向 Lily 转出 100 元。")
}

运行结果如下。

转账成功!Tom 向 Lily 转出 100 元。

分析:

在这个例子中,扣款和入账两条 update 语句都是在事务对象 tx 上调用 tx.Exec() 执行的。只有当两条语句全部没有报错,并且最后的 tx.Commit() 成功返回 nil 时,Tom 的余额变成 900、Lily 的余额变成 600 这两笔改动才会真正写入数据库。

这里要特别留意一点:开启事务后,事务内的所有 SQL 都必须通过 tx.Exec() 或 tx.Query() 来执行,千万不要误写成 db.Exec()。否则那条语句会绕过当前事务直接生效,出错时根本没法跟着一起回滚。

常见问题

1. 为什么导入 MySQL 驱动包时,前面要加一个下划线写成 _ "github.com/go-sql-driver/mysql"?

这其实就是我们在前面学习 init() 函数时介绍过的 “匿名导入”。

在业务代码中,我们直接调用的全都是标准库 database/sql 里的 sql.Open()、db.Exec() 和 db.Query() 等方法,并没有直接调用过驱动包里的公开函数。

如果不加下划线 _,Go 编译器会因为 “导入了包却未使用” 而报错。加上 _ 匿名导入后,既能通过编译检查,又能让程序在启动时自动执行该驱动包内部的 init() 函数,把 "mysql" 驱动注册到 database/sql 中。

2. 在实际项目中,每次执行完 SQL 语句都需要调用 db.Close() 关闭数据库吗?

不需要,而且在实际后端服务中千万不要每次操作完都关闭 db。

因为 sql.Open() 返回的 db 并不是一条单独的连接,而是一个自带并发管理的 “数据库连接池”。在真实项目中,我们通常只在程序启动时调用一次 sql.Open() 创建好 db 并配置连接池参数后长期复用,真正需要在每次多行查询后及时关闭的是 rows 结果集。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号