MySQL 基础

MySQL 是最流行的关系型数据库之一，本教程介绍如何在 Go 中使用 MySQL 进行数据库操作。

📋 学习目标

🎯 MySQL 简介

为什么选择 MySQL

流行度高: 使用广泛，社区活跃
性能优秀: 适合 Web 应用
易于使用: 学习曲线平缓
功能完整: 支持事务、索引等

Go MySQL 驱动

Go 标准库提供了 database/sql 接口，常用的 MySQL 驱动：

github.com/go-sql-driver/mysql - 官方推荐
github.com/go-gorm/mysql - GORM 驱动

🚀 快速开始

安装驱动

bash

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

基本连接

package main

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

func main() {
	// 数据源名称格式: username:password@tcp(host:port)/dbname?charset=utf8mb4
	dsn := "root:password@tcp(127.0.0.1:3306)/mydb?charset=utf8mb4&parseTime=True&loc=Local"
	
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		panic(err)
	}
	defer db.Close()
	
	// 测试连接
	if err := db.Ping(); err != nil {
		panic(err)
	}
	
	fmt.Println("数据库连接成功")
}

📊 数据库操作

创建表

func createTable(db *sql.DB) error {
	query := `
	CREATE TABLE IF NOT EXISTS users (
		id INT AUTO_INCREMENT PRIMARY KEY,
		name VARCHAR(100) NOT NULL,
		email VARCHAR(100) UNIQUE NOT NULL,
		age INT DEFAULT 0,
		created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
		updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
	) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
	`
	
	_, err := db.Exec(query)
	return err
}

插入数据

func insertUser(db *sql.DB, name, email string, age int) (int64, error) {
	query := "INSERT INTO users (name, email, age) VALUES (?, ?, ?)"
	
	result, err := db.Exec(query, name, email, age)
	if err != nil {
		return 0, err
	}
	
	id, err := result.LastInsertId()
	return id, err
}

// 批量插入
func insertUsers(db *sql.DB, users []User) error {
	query := "INSERT INTO users (name, email, age) VALUES (?, ?, ?)"
	
	stmt, err := db.Prepare(query)
	if err != nil {
		return err
	}
	defer stmt.Close()
	
	for _, user := range users {
		_, err := stmt.Exec(user.Name, user.Email, user.Age)
		if err != nil {
			return err
		}
	}
	
	return nil
}

查询数据

type User struct {
	ID        int
	Name      string
	Email     string
	Age       int
	CreatedAt time.Time
	UpdatedAt time.Time
}

// 查询单条记录
func getUserByID(db *sql.DB, id int) (*User, error) {
	query := "SELECT id, name, email, age, created_at, updated_at FROM users WHERE id = ?"
	
	var user User
	err := db.QueryRow(query, id).Scan(
		&user.ID,
		&user.Name,
		&user.Email,
		&user.Age,
		&user.CreatedAt,
		&user.UpdatedAt,
	)
	
	if err != nil {
		return nil, err
	}
	
	return &user, nil
}

// 查询多条记录
func getUsers(db *sql.DB, limit, offset int) ([]User, error) {
	query := "SELECT id, name, email, age, created_at, updated_at FROM users LIMIT ? OFFSET ?"
	
	rows, err := db.Query(query, limit, offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	
	var users []User
	for rows.Next() {
		var user User
		err := rows.Scan(
			&user.ID,
			&user.Name,
			&user.Email,
			&user.Age,
			&user.CreatedAt,
			&user.UpdatedAt,
		)
		if err != nil {
			return nil, err
		}
		users = append(users, user)
	}
	
	return users, rows.Err()
}

// 条件查询
func searchUsers(db *sql.DB, keyword string) ([]User, error) {
	query := `
		SELECT id, name, email, age, created_at, updated_at 
		FROM users 
		WHERE name LIKE ? OR email LIKE ?
	`
	
	keyword = "%" + keyword + "%"
	rows, err := db.Query(query, keyword, keyword)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	
	var users []User
	for rows.Next() {
		var user User
		err := rows.Scan(
			&user.ID,
			&user.Name,
			&user.Email,
			&user.Age,
			&user.CreatedAt,
			&user.UpdatedAt,
		)
		if err != nil {
			return nil, err
		}
		users = append(users, user)
	}
	
	return users, rows.Err()
}

更新数据

func updateUser(db *sql.DB, id int, name, email string, age int) error {
	query := "UPDATE users SET name = ?, email = ?, age = ? WHERE id = ?"
	
	result, err := db.Exec(query, name, email, age, id)
	if err != nil {
		return err
	}
	
	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return err
	}
	
	if rowsAffected == 0 {
		return fmt.Errorf("用户不存在")
	}
	
	return nil
}

删除数据

func deleteUser(db *sql.DB, id int) error {
	query := "DELETE FROM users WHERE id = ?"
	
	result, err := db.Exec(query, id)
	if err != nil {
		return err
	}
	
	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return err
	}
	
	if rowsAffected == 0 {
		return fmt.Errorf("用户不存在")
	}
	
	return nil
}

🔄 事务处理

func transferMoney(db *sql.DB, fromID, toID int, amount float64) error {
	tx, err := db.Begin()
	if err != nil {
		return err
	}
	
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	
	// 扣除转出账户金额
	_, err = tx.Exec("UPDATE accounts SET balance = balance - ? WHERE id = ?", amount, fromID)
	if err != nil {
		return err
	}
	
	// 增加转入账户金额
	_, err = tx.Exec("UPDATE accounts SET balance = balance + ? WHERE id = ?", amount, toID)
	if err != nil {
		return err
	}
	
	return nil
}

🔧 连接池配置

func setupDB(dsn string) (*sql.DB, error) {
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		return nil, err
	}
	
	// 设置最大打开连接数
	db.SetMaxOpenConns(25)
	
	// 设置最大空闲连接数
	db.SetMaxIdleConns(5)
	
	// 设置连接最大生存时间
	db.SetConnMaxLifetime(5 * time.Minute)
	
	// 测试连接
	if err := db.Ping(); err != nil {
		return nil, err
	}
	
	return db, nil
}

🏃‍♂️ 实践应用

完整的 CRUD 示例

package main

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

type User struct {
	ID        int       `json:"id"`
	Name      string    `json:"name"`
	Email     string    `json:"email"`
	Age       int       `json:"age"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

type UserService struct {
	db *sql.DB
}

func NewUserService(dsn string) (*UserService, error) {
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		return nil, err
	}
	
	if err := db.Ping(); err != nil {
		return nil, err
	}
	
	// 配置连接池
	db.SetMaxOpenConns(25)
	db.SetMaxIdleConns(5)
	db.SetConnMaxLifetime(5 * time.Minute)
	
	return &UserService{db: db}, nil
}

func (s *UserService) Create(name, email string, age int) (*User, error) {
	query := "INSERT INTO users (name, email, age) VALUES (?, ?, ?)"
	
	result, err := s.db.Exec(query, name, email, age)
	if err != nil {
		return nil, err
	}
	
	id, err := result.LastInsertId()
	if err != nil {
		return nil, err
	}
	
	return s.GetByID(int(id))
}

func (s *UserService) GetByID(id int) (*User, error) {
	query := "SELECT id, name, email, age, created_at, updated_at FROM users WHERE id = ?"
	
	var user User
	err := s.db.QueryRow(query, id).Scan(
		&user.ID,
		&user.Name,
		&user.Email,
		&user.Age,
		&user.CreatedAt,
		&user.UpdatedAt,
	)
	
	if err != nil {
		return nil, err
	}
	
	return &user, nil
}

func (s *UserService) List(limit, offset int) ([]User, error) {
	query := "SELECT id, name, email, age, created_at, updated_at FROM users LIMIT ? OFFSET ?"
	
	rows, err := s.db.Query(query, limit, offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	
	var users []User
	for rows.Next() {
		var user User
		err := rows.Scan(
			&user.ID,
			&user.Name,
			&user.Email,
			&user.Age,
			&user.CreatedAt,
			&user.UpdatedAt,
		)
		if err != nil {
			return nil, err
		}
		users = append(users, user)
	}
	
	return users, rows.Err()
}

func (s *UserService) Update(id int, name, email string, age int) error {
	query := "UPDATE users SET name = ?, email = ?, age = ? WHERE id = ?"
	
	result, err := s.db.Exec(query, name, email, age, id)
	if err != nil {
		return err
	}
	
	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return err
	}
	
	if rowsAffected == 0 {
		return fmt.Errorf("用户不存在")
	}
	
	return nil
}

func (s *UserService) Delete(id int) error {
	query := "DELETE FROM users WHERE id = ?"
	
	result, err := s.db.Exec(query, id)
	if err != nil {
		return err
	}
	
	rowsAffected, err := result.RowsAffected()
	if err != nil {
		return err
	}
	
	if rowsAffected == 0 {
		return fmt.Errorf("用户不存在")
	}
	
	return nil
}

func main() {
	dsn := "root:password@tcp(127.0.0.1:3306)/mydb?charset=utf8mb4&parseTime=True&loc=Local"
	
	service, err := NewUserService(dsn)
	if err != nil {
		log.Fatal(err)
	}
	
	// 创建用户
	user, err := service.Create("张三", "zhangsan@example.com", 25)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("创建用户: %+v\n", user)
	
	// 查询用户
	user, err = service.GetByID(user.ID)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("查询用户: %+v\n", user)
	
	// 更新用户
	err = service.Update(user.ID, "李四", "lisi@example.com", 30)
	if err != nil {
		log.Fatal(err)
	}
	
	// 查询列表
	users, err := service.List(10, 0)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("用户列表: %+v\n", users)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

⚠️ 注意事项

1. SQL 注入防护

// ✅ 使用参数化查询
db.Query("SELECT * FROM users WHERE id = ?", id)

// ❌ 不要拼接 SQL
db.Query(fmt.Sprintf("SELECT * FROM users WHERE id = %d", id))

2. 连接管理

// ✅ 总是关闭连接和结果集
rows, err := db.Query(...)
defer rows.Close()

// ✅ 使用连接池
db.SetMaxOpenConns(25)

3. 错误处理

// ✅ 检查所有错误
if err != nil {
	return err
}

// ✅ 检查查询结果
if rowsAffected == 0 {
	return fmt.Errorf("记录不存在")
}

📚 扩展阅读

⏭️ 下一章节

GORM 框架 → 学习更高级的 ORM 操作

💡 提示: 掌握原生 SQL 操作是理解 ORM 框架的基础，建议先熟悉 database/sql 的使用！

MySQL 基础 ​

📋 学习目标 ​

🎯 MySQL 简介 ​

为什么选择 MySQL ​

Go MySQL 驱动 ​

🚀 快速开始 ​

安装驱动 ​

基本连接 ​

📊 数据库操作 ​

创建表 ​

插入数据 ​

查询数据 ​

更新数据 ​

删除数据 ​

🔄 事务处理 ​

🔧 连接池配置 ​

🏃‍♂️ 实践应用 ​

完整的 CRUD 示例 ​

⚠️ 注意事项 ​

1. SQL 注入防护 ​

2. 连接管理 ​

3. 错误处理 ​

📚 扩展阅读 ​

⏭️ 下一章节 ​