Golang 1.18 调用 MySQL 数据库实践

在后端开发领域，Golang 凭借其高效、简洁的特性以及强大的并发处理能力，成为众多开发者的首选语言之一。而 MySQL 作为最流行的关系型数据库之一，与 Golang 的结合能够为应用程序提供稳定、可靠的数据存储和管理支持。

本文将基于 Golang 1.18 版本，详细介绍如何使用 Golang 实现对 MySQL 数据库的各类操作，包括增删改查、事务处理以及锁操作等。

一、环境准备与依赖获取

1.1 检查 Golang 版本

在开始编写代码之前，首先需要确保开发环境中已安装 Golang 1.18 版本。可以通过在终端中执行以下命令来检查 Golang 的版本：

go version

如果版本不符合要求，请根据官方文档指引进行安装或升级。

1.2 初始化 Go 模块

使用go mod进行项目依赖管理。在项目根目录下打开终端，执行以下命令初始化 Go 模块：

go mod init your_project_name

将your_project_name替换为实际的项目名称，这将在项目根目录下生成go.mod和go.sum文件，用于记录项目的依赖信息和依赖包的哈希值。

1.3 获取数据库驱动

Golang 与 MySQL 数据库交互需要借助数据库驱动，这里我们使用go-sql-driver/mysql驱动。在终端中执行以下命令获取该驱动：

go get github.com/go-sql-driver/mysql

此命令会将go-sql-driver/mysql驱动下载到项目的依赖中，并自动更新go.mod和go.sum文件。

二、数据库连接配置

在进行数据库操作之前，首先要建立与 MySQL 数据库的连接。以下是一个简单的数据库连接示例代码：

package main
​
import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)
​
func connectDB() (*sql.DB, error) {
    // 数据库连接字符串，格式为：用户名:密码@tcp(主机地址:端口)/数据库名
    dsn := "root:password@tcp(127.0.0.1:3306)/your_database_name"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        return nil, err
    }
    // 尝试与数据库建立连接，验证连接是否有效
    if err := db.Ping(); err != nil {
        return nil, err
    }
    fmt.Println("成功连接到MySQL数据库")
    return db, nil
}

在上述代码中，sql.Open函数用于创建一个数据库连接池，第一个参数"mysql"指定使用的数据库驱动名称，第二个参数dsn是数据库连接字符串，包含了用户名、密码、主机地址、端口和数据库名称等信息。db.Ping方法用于测试与数据库的连接是否正常，如果连接失败，将返回相应的错误信息。

三、数据增删改查操作

3.1 插入数据（增）

假设我们有一个名为users的表，表结构如下：

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    age INT
);

以下是向users表中插入数据的 Golang 代码示例：

func insertData(db *sql.DB, name string, age int) error {
    sqlStatement := `INSERT INTO users (name, age) VALUES (?,?)`
    _, err := db.Exec(sqlStatement, name, age)
    if err != nil {
        return err
    }
    fmt.Println("数据插入成功")
    return nil
}

在insertData函数中，使用db.Exec方法执行 SQL 插入语句。?是占位符，用于防止 SQL 注入攻击，实际的值通过后面的参数传递。

3.2 查询数据（查）

查询users表中所有数据的示例代码如下：

func queryData(db *sql.DB) error {
    sqlStatement := `SELECT id, name, age FROM users`
    rows, err := db.Query(sqlStatement)
    if err != nil {
        return err
    }
    defer rows.Close()
    for rows.Next() {
        var id int
        var name string
        var age int
        if err := rows.Scan(&id, &name, &age); err != nil {
            return err
        }
        fmt.Printf("ID: %d, Name: %s, Age: %d\n", id, name, age)
    }
    if err := rows.Err(); err != nil {
        return err
    }
    fmt.Println("数据查询完成")
    return nil
}

db.Query方法用于执行 SQL 查询语句，返回一个*sql.Rows对象，通过rows.Next方法遍历查询结果集，使用rows.Scan方法将查询结果中的字段值赋值给相应的变量。

3.3 更新数据（改）

更新users表中指定用户年龄的示例代码如下：

func updateData(db *sql.DB, id int, newAge int) error {
    sqlStatement := `UPDATE users SET age =? WHERE id =?`
    _, err := db.Exec(sqlStatement, newAge, id)
    if err != nil {
        return err
    }
    fmt.Println("数据更新成功")
    return nil
}

同样使用db.Exec方法执行 SQL 更新语句，通过占位符传递更新的值和条件。

3.4 删除数据（删）

删除users表中指定用户的示例代码如下：

func deleteData(db *sql.DB, id int) error {
    sqlStatement := `DELETE FROM users WHERE id =?`
    _, err := db.Exec(sqlStatement, id)
    if err != nil {
        return err
    }
    fmt.Println("数据删除成功")
    return nil
}

db.Exec方法执行 SQL 删除语句，实现数据的删除操作。

四、事务处理

事务是数据库操作中非常重要的概念，它确保一系列操作要么全部成功执行，要么全部失败回滚，从而保证数据的一致性和完整性。以下是一个使用事务向users表中插入两条数据的示例代码：

func insertDataWithTransaction(db *sql.DB, name1 string, age1 int, name2 string, age2 int) error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    sqlStatement := `INSERT INTO users (name, age) VALUES (?,?)`
    _, err = tx.Exec(sqlStatement, name1, age1)
    if err != nil {
        tx.Rollback()
        return err
    }
    _, err = tx.Exec(sqlStatement, name2, age2)
    if err != nil {
        tx.Rollback()
        return err
    }
    err = tx.Commit()
    if err != nil {
        return err
    }
    fmt.Println("数据插入事务执行成功")
    return nil
}

在insertDataWithTransaction函数中，首先通过db.Begin方法开启一个事务，然后在事务中执行 SQL 插入语句。如果在执行过程中出现任何错误，通过tx.Rollback方法回滚事务；如果所有操作都成功，则通过tx.Commit方法提交事务。

五、锁操作

在多并发环境下，为了保证数据的一致性和准确性，常常需要使用锁机制。MySQL 支持多种锁类型，这里以排他锁（行锁）为例，展示如何在 Golang 中使用锁操作。

假设我们有一个account表用于存储账户余额信息：

CREATE TABLE account (
    id INT AUTO_INCREMENT PRIMARY KEY,
    balance DECIMAL(10, 2) NOT NULL
);

以下是一个模拟转账操作的示例代码，在转账过程中使用排他锁锁定相关账户记录，防止并发操作导致数据不一致：

func transfer(db *sql.DB, fromID int, toID int, amount float64) error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    // 使用排他锁锁定转出账户记录
    lockSQL := `SELECT balance FROM account WHERE id =? FOR UPDATE`
    var fromBalance float64
    err = tx.QueryRow(lockSQL, fromID).Scan(&fromBalance)
    if err != nil {
        tx.Rollback()
        return err
    }
    if fromBalance < amount {
        tx.Rollback()
        return fmt.Errorf("余额不足")
    }
    // 更新转出账户余额
    updateFromSQL := `UPDATE account SET balance = balance -? WHERE id =?`
    _, err = tx.Exec(updateFromSQL, amount, fromID)
    if err != nil {
        tx.Rollback()
        return err
    }
    // 使用排他锁锁定转入账户记录
    var toBalance float64
    err = tx.QueryRow(lockSQL, toID).Scan(&toBalance)
    if err != nil {
        tx.Rollback()
        return err
    }
    // 更新转入账户余额
    updateToSQL := `UPDATE account SET balance = balance +? WHERE id =?`
    _, err = tx.Exec(updateToSQL, amount, toID)
    if err != nil {
        tx.Rollback()
        return err
    }
    err = tx.Commit()
    if err != nil {
        return err
    }
    fmt.Println("转账操作成功")
    return nil
}

在transfer函数中，首先开启一个事务，然后使用FOR UPDATE语句在查询账户余额时获取排他锁，确保在当前事务处理期间，其他事务无法修改该记录。在完成账户余额的更新操作后，提交事务释放锁。

六、完整示例与运行

将上述各功能模块整合到一个完整的示例中：

package main
​
import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)
​
func connectDB() (*sql.DB, error) {
    dsn := "root:password@tcp(127.0.0.1:3306)/your_database_name"
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        return nil, err
    }
    if err := db.Ping(); err != nil {
        return nil, err
    }
    fmt.Println("成功连接到MySQL数据库")
    return db, nil
}
​
func insertData(db *sql.DB, name string, age int) error {
    sqlStatement := `INSERT INTO users (name, age) VALUES (?,?)`
    _, err := db.Exec(sqlStatement, name, age)
    if err != nil {
        return err
    }
    fmt.Println("数据插入成功")
    return nil
}
​
func queryData(db *sql.DB) error {
    sqlStatement := `SELECT id, name, age FROM users`
    rows, err := db.Query(sqlStatement)
    if err != nil {
        return err
    }
    defer rows.Close()
    for rows.Next() {
        var id int
        var name string
        var age int
        if err := rows.Scan(&id, &name, &age); err != nil {
            return err
        }
        fmt.Printf("ID: %d, Name: %s, Age: %d\n", id, name, age)
    }
    if err := rows.Err(); err != nil {
        return err
    }
    fmt.Println("数据查询完成")
    return nil
}
​
func updateData(db *sql.DB, id int, newAge int) error {
    sqlStatement := `UPDATE users SET age =? WHERE id =?`
    _, err := db.Exec(sqlStatement, newAge, id)
    if err != nil {
        return err
    }
    fmt.Println("数据更新成功")
    return nil
}
​
func deleteData(db *sql.DB, id int) error {
    sqlStatement := `DELETE FROM users WHERE id =?`
    _, err := db.Exec(sqlStatement, id)
    if err != nil {
        return err
    }
    fmt.Println("数据删除成功")
    return nil
}
​
func insertDataWithTransaction(db *sql.DB, name1 string, age1 int, name2 string, age2 int) error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    sqlStatement := `INSERT INTO users (name, age) VALUES (?,?)`
    _, err = tx.Exec(sqlStatement, name1, age1)
    if err != nil {
        tx.Rollback()
        return err
    }
    _, err = tx.Exec(sqlStatement, name2, age2)
    if err != nil {
        tx.Rollback()
        return err
    }
    err = tx.Commit()
    if err != nil {
        return err
    }
    fmt.Println("数据插入事务执行成功")
    return nil
}
​
func transfer(db *sql.DB, fromID int, toID int, amount float64) error {
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    lockSQL := `SELECT balance FROM account WHERE id =? FOR UPDATE`
    var fromBalance float64
    err = tx.QueryRow(lockSQL, fromID).Scan(&fromBalance)
    if err != nil {
        tx.Rollback()
        return err
    }
    if fromBalance < amount {
        tx.Rollback()
        return fmt.Errorf("余额不足")
    }
    updateFromSQL := `UPDATE account SET balance = balance -? WHERE id =?`
    _, err = tx.Exec(updateFromSQL, amount, fromID)
    if err != nil {
        tx.Rollback()
        return err
    }
    var toBalance float64
    err = tx.QueryRow(lockSQL, toID).Scan(&toBalance)
    if err != nil {
        tx.Rollback()
        return err
    }
    updateToSQL := `UPDATE account SET balance = balance +? WHERE id =?`
    _, err = tx.Exec(updateToSQL, amount, toID)
    if err != nil {
        tx.Rollback()
        return err
    }
    err = tx.Commit()
    if err != nil {
        return err
    }
    fmt.Println("转账操作成功")
    return nil
}
​
func main() {
    db, err := connectDB()
    if err != nil {
        fmt.Println("连接数据库失败:", err)
        return
    }
    defer db.Close()
​
    // 插入数据
    if err := insertData(db, "Alice", 25); err != nil {
        fmt.Println("插入数据失败:", err)
        return
    }
​
    // 查询数据
    if err := queryData(db); err != nil {
        fmt.Println("查询数据失败:", err)
        return
    }
​
    // 更新数据
    if err := updateData(db, 1, 26); err != nil {
        fmt.Println("更新数据失败:", err)
        return
    }
​
    // 删除数据
    if err := deleteData(db, 1); err != nil {
        fmt.Println("删除数据失败:", err)
        return
    }
​
    // 事务处理
    if err := insertDataWithTransaction(db, "Bob", 30, "Charlie", 35); err != nil {
        fmt.Println("事务处理失败:", err)
        return
    }
​
    // 锁操作（转账）
    if err := transfer(db, 1, 2, 50.0); err != nil {
        fmt.Println("转账操作失败:", err)
        return
    }
​
    fmt.Println("所有数据库操作完成")
}

在运行上述代码前，请确保 MySQL 数据库已启动，并且数据库中已创建相应的表结构。运行go run main.go即可执行各数据库操作。

通过以上内容，我们详细介绍了 Golang 1.18 调用 MySQL 数据库的各类操作，包括基本的增删改查、事务处理以及锁操作。掌握这些知识和技能，能够帮助我们在实际开发中高效、可靠地使用 MySQL 数据库，构建出更加健壮的后端应用程序。