文章目录
9.1 连接数据库 - Go 语言的海底宝藏之门
9.1.1 基础知识讲解
在Go语言的海洋中，连接数据库是获取深海宝藏的第一步。Go通过
database/sql
包提供了一个通用的接口来与SQL数据库进行交云，但实际上你还需要一个具体数据库的驱动来完成这个任务。
安装数据库驱动
首先，选择并安装你需要的数据库驱动。对于MySQL，你可能会选择
github.com/go-sql-driver/mysql
：
go get -u github.com/go-sql-driver/mysql
对于PostgreSQL，则可能是
github.com/lib/pq
：
go get -u github.com/lib/pq
数据库连接
连接数据库通常涉及创建一个
sql.DB
对象，它代表一个数据库的长连接。使用
sql.Open
函数并传入相应的驱动名和数据库的DSN（数据源名称）即可：
db, err := sql.Open("mysql","user:password@tcp(localhost:3306)/dbname")if err !=nil{
log.Fatal(err)}defer db.Close()
确保在不再需要数据库连接时调用
db.Close()
来关闭连接。
9.1.2 重点案例：用户信息管理系统
在这个扩展案例中，我们将构建一个用户信息管理系统，该系统将演示如何在Go语言中连接MySQL数据库、添加新用户以及查询现有用户信息。此外，我们还将实现一个简单的用户登录验证功能。
准备数据库
首先，确保你的MySQL数据库服务正在运行，并执行以下SQL脚本来创建数据库和表：
CREATEDATABASEIFNOTEXISTS userdb;USE userdb;CREATETABLEIFNOTEXISTS users (
id INTAUTO_INCREMENTPRIMARYKEY,
name VARCHAR(255)NOTNULL,
email VARCHAR(255)NOTNULL,
password VARCHAR(255)NOTNULL);
Go 代码实现
在Go项目中，使用
database/sql
包和
github.com/go-sql-driver/mysql
驱动来实现与数据库的连接和操作。
连接数据库
首先，实现一个函数来创建数据库连接：
// db.gopackage main
import("database/sql"_"github.com/go-sql-driver/mysql""log")funcconnectDB()*sql.DB {
db, err := sql.Open("mysql","user:password@/userdb?parseTime=true")if err !=nil{
log.Fatal(err)}return db
}
添加新用户
实现一个函数，用于添加新用户到数据库：
// user.gopackage main
import("log")funcaddUser(db *sql.DB, name, email, password string){_, err := db.Exec("INSERT INTO users (name, email, password) VALUES (?, ?, ?)", name, email, password)if err !=nil{
log.Fatal(err)}
log.Println("New user added successfully:", name)}
查询用户信息
实现一个函数，用于根据邮箱查询用户信息：
funcgetUserByEmail(db *sql.DB, email string){var name, userEmail string
err := db.QueryRow("SELECT name, email FROM users WHERE email = ?", email).Scan(&name,&userEmail)if err !=nil{
log.Println("User not found:", err)return}
log.Printf("User found: Name: %s, Email: %s\n", name, userEmail)}
用户登录验证
实现一个简单的用户登录验证功能：
funcverifyUserLogin(db *sql.DB, email, password string){var dbPassword string
err := db.QueryRow("SELECT password FROM users WHERE email = ?", email).Scan(&dbPassword)if err !=nil{
log.Println("Authentication failed:", err)return}if dbPassword == password {
log.Println("User authenticated successfully")}else{
log.Println("Invalid password")}}
主函数
在
main
函数中，调用上述函数演示添加新用户和查询用户信息的功能：
// main.gopackage main
funcmain(){
db :=connectDB()defer db.Close()addUser(db,"Jack Sparrow","[email protected]","pirate")getUserByEmail(db,"[email protected]")verifyUserLogin(db,"[email protected]","pirate")}
通过运行
main.go
文件，你可以看到添加新用户、查询用户信息和用户登录验证的过程。
通过这个扩展案例，你已经学会了如何在Go语言中连接MySQL数据库、执行基本的数据操作以及实现简单的用户登录验证功能。这为构建更复杂的Web应用和服务提供了坚实的基础。随着你对数据库操作的深入，你将能够更有效地管理和利用数据，为用户提供丰富和安全的服务。
9.1.3 拓展案例 1：批量添加用户
在这个案例中，我们将扩展之前的用户信息管理系统，实现一个功能以批量添加用户到数据库中。这项功能非常适合于需要一次性导入大量用户数据的场景，比如从CSV文件导入或者在系统初始化时预填充用户数据。为了保证数据的一致性和完整性，我们将使用事务来处理批量添加操作。
准备数据库
确保你已经按照之前的指示创建了
userdb
数据库和
users
表。
Go 代码实现
实现批量添加用户功能
我们将实现一个
addUsers
函数，接收一个用户信息列表，并使用事务批量添加用户到数据库中：
// user.gopackage main
import("database/sql""log")type User struct{
Name string
Email string
Password string}funcaddUsers(db *sql.DB, users []User){
tx, err := db.Begin()if err !=nil{
log.Fatal("Failed to begin transaction:", err)}
stmt, err := tx.Prepare("INSERT INTO users (name, email, password) VALUES (?, ?, ?)")if err !=nil{
log.Fatal("Failed to prepare statement:", err)}defer stmt.Close()for_, user :=range users {_, err = stmt.Exec(user.Name, user.Email, user.Password)if err !=nil{
log.Fatal("Failed to execute statement:", err)}}
err = tx.Commit()if err !=nil{
log.Fatal("Failed to commit transaction:", err)}
log.Println("Users added successfully")}
在这个函数中，我们首先开始一个新的事务。对于传入的每个用户，我们使用预编译的SQL语句和事务执行插入操作。最后，如果所有插入操作都成功执行，我们提交事务；如果在过程中遇到任何错误，事务将被回滚，保证数据库状态的一致性。
主函数
在
main
函数中，调用
addUsers
函数演示批量添加用户的功能：
// main.gopackage main
funcmain(){
db :=connectDB()defer db.Close()
users :=[]User{{"Will Turner","[email protected]","Bootstrap"},{"Elizabeth Swann","[email protected]","PirateKing"},{"Hector Barbossa","[email protected]","BlackPearl"},}addUsers(db, users)}
通过运行
main.go
文件，你可以看到批量添加用户的过程。使用事务可以确保批量添加操作的原子性，即要么所有用户都成功添加，要么一个都不添加，避免了可能出现的数据不一致问题。
通过这个拓展案例，你已经学会了如何在Go语言中实现批量添加用户的功能，并了解了事务在保证数据库操作一致性中的重要作用。掌握这些技能后，你将能够更高效地管理和操作数据库中的数据。
9.1.4 拓展案例 2：用户登录验证
在这个案例中，我们将为用户信息管理系统添加用户登录验证功能。这个功能允许用户通过提供邮箱和密码来验证其身份。为了保证安全性，我们将存储密码的哈希值，而不是明文密码。
准备数据库
首先，确保你的
users
表已经准备好，并且有一个用于存储密码哈希值的字段：
ALTERTABLE users ADDCOLUMN password_hash VARCHAR(255)NOTNULL;
Go 代码实现
为了处理密码，我们将使用
golang.org/x/crypto/bcrypt
包来生成和验证密码哈希。首先，安装bcrypt包：
go get -u golang.org/x/crypto/bcrypt
生成和验证密码哈希
我们将实现两个函数：一个用于生成密码的哈希值，另一个用于验证提供的密码是否与存储的哈希值匹配：
// auth.gopackage main
import("golang.org/x/crypto/bcrypt")// GeneratePasswordHash 生成密码的哈希值funcGeneratePasswordHash(password string)(string,error){
bytes, err := bcrypt.GenerateFromPassword([]byte(password),14)returnstring(bytes), err
}// VerifyPassword 检查密码是否与其哈希值匹配funcVerifyPassword(password, hash string)bool{
err := bcrypt.CompareHashAndPassword([]byte(hash),[]byte(password))return err ==nil}
实现用户登录验证
接下来，我们扩展用户信息管理系统，添加用户登录验证功能：
// user.gopackage main
import("database/sql""fmt""log")// VerifyUserLogin 验证用户登录funcVerifyUserLogin(db *sql.DB, email, password string){var passwordHash string
err := db.QueryRow("SELECT password_hash FROM users WHERE email = ?", email).Scan(&passwordHash)if err !=nil{if err == sql.ErrNoRows {
fmt.Println("用户不存在")}else{
log.Fatal("查询错误:", err)}return}ifVerifyPassword(password, passwordHash){
fmt.Println("登录成功")}else{
fmt.Println("密码错误")}}
主函数
在
main
函数中，调用
VerifyUserLogin
函数演示用户登录验证的过程：
// main.gopackage main
funcmain(){
db :=connectDB()defer db.Close()// 假设用户已经被添加到数据库，并且密码哈希已经存储
email :="[email protected]"
password :="pirate"VerifyUserLogin(db, email, password)}
通过运行
main.go
文件，你可以测试用户登录验证的功能。这个过程首先查询用户的密码哈希值，然后使用bcrypt库来验证提供的密码是否与哈希值匹配。
通过这个拓展案例，你已经学会了如何在Go语言中实现基本的用户登录验证功能，包括如何安全地处理和存储密码。这为构建需要用户认证的Web应用和服务提供了坚实的基础。随着你对安全性的深入理解，你将能够为你的应用实现更高级的安全特性。
9.2 执行查询与操作数据 - Go 语言的数据潜水艇
9.2.1 基础知识讲解
在Go的数据海洋中，执行查询和操作数据是寻找和管理宝藏的关键步骤。
database/sql
包提供了一套通用的接口，允许我们执行SQL查询、插入、更新和删除操作，以及处理结果集。
执行查询
查询数据库并处理结果集通常包括以下几个步骤：
- 使用
Query或QueryRow执行SQL查询。Query用于返回多行结果，而QueryRow用于期望最多一行结果的查询。 - 遍历
Rows结果集（如果是多行结果）。使用Next方法迭代结果集，并使用Scan方法将行数据扫描到变量中。 - 处理
Row结果（如果是单行结果）。直接使用Scan方法将结果扫描到变量中。
操作数据
插入、更新和删除操作通常使用
Exec
方法执行SQL命令。这个方法返回一个
Result
对象，它提供了关于操作影响的行数等信息。
9.2.2 重点案例：图书管理系统
在这个扩展案例中，我们将构建一个简单的图书管理系统，该系统将演示如何在Go语言中连接MySQL数据库、添加新图书、查询图书列表、更新图书信息以及删除图书记录。
准备数据库
首先，确保你的MySQL数据库服务正在运行，并执行以下SQL脚本来创建数据库和
books
表：
CREATEDATABASEIFNOTEXISTS library;USE library;CREATETABLEIFNOTEXISTS books (
id INTAUTO_INCREMENTPRIMARYKEY,
title VARCHAR(255)NOTNULL,
author VARCHAR(255)NOTNULL,
published_date DATE);
Go 代码实现
连接数据库
首先，实现一个函数来创建数据库连接：
// db.gopackage main
import("database/sql"_"github.com/go-sql-driver/mysql""log")funcconnectDB()*sql.DB {
db, err := sql.Open("mysql","user:password@/library")if err !=nil{
log.Fatal(err)}return db
}
确保替换
user:password@/library
中的
user
和
password
为你的数据库用户名和密码。
添加新图书
// book.gopackage main
import("database/sql""fmt""log""time")funcaddBook(db *sql.DB, title, author string, publishedDate time.Time){_, err := db.Exec("INSERT INTO books (title, author, published_date) VALUES (?, ?, ?)", title, author, publishedDate)if err !=nil{
log.Fatal("Failed to add book:", err)}
fmt.Println("Successfully added new book:", title)}
查询图书列表
funclistBooks(db *sql.DB){
rows, err := db.Query("SELECT id, title, author, published_date FROM books")if err !=nil{
log.Fatal("Failed to list books:", err)}defer rows.Close()for rows.Next(){var id intvar title, author stringvar publishedDate time.Time
if err := rows.Scan(&id,&title,&author,&publishedDate); err !=nil{
log.Fatal("Failed to scan book:", err)}
fmt.Printf("%d: %s by %s, published on %s\n", id, title, author, publishedDate.Format("2006-01-02"))}}
更新图书信息
funcupdateBook(db *sql.DB, id int, title, author string){_, err := db.Exec("UPDATE books SET title = ?, author = ? WHERE id = ?", title, author, id)if err !=nil{
log.Fatal("Failed to update book:", err)}
fmt.Println("Successfully updated book with ID:", id)}
删除图书记录
funcdeleteBook(db *sql.DB, id int){_, err := db.Exec("DELETE FROM books WHERE id = ?", id)if err !=nil{
log.Fatal("Failed to delete book:", err)}
fmt.Println("Successfully deleted book with ID:", id)}
主函数
在
main.go
中，整合上述功能，并运行演示：
// main.gopackage main
import"time"funcmain(){
db :=connectDB()defer db.Close()// 添加图书示例addBook(db,"Go Programming Language","Alan A. A. Donovan & Brian W. Kernighan", time.Date(2015,11,17,0,0,0,0, time.UTC))// 查询图书列表listBooks(db)// 更新图书信息updateBook(db,1,"The Go Programming Language","Alan A. A. Donovan & Brian W. Kernighan")// 删除图书记录deleteBook(db,1)}
通过运行
main.go
文件，你可以测试图书管理系统的各项功能。这个简单的应用展示了在Go中如何执行常见的数据库操作，包括连接数据库、执行SQL命令以及处理查询结果。
通过这个案例，你学会了如何使用Go与数据库进行交互，实现一个基本的图书管理系统。这为进一步开发更复杂的数据库驱动应用奠定了基础。随着对数据库操作的深入掌握，你将能够构建更加强大和灵活的数据管理和分析功能。
9.2.3 拓展案例 1：图书借阅记录
在这个案例中，我们将扩展图书管理系统，添加功能以记录用户的图书借阅信息。这项功能涉及到创建新的数据库表来存储借阅记录，并实现相关的增、查操作。
准备数据库
首先，除了已有的
books
表之外，我们还需要创建两个新的表：
users
和
borrow_records
。
CREATETABLEIFNOTEXISTS users (
id INTAUTO_INCREMENTPRIMARYKEY,
name VARCHAR(255)NOTNULL,
email VARCHAR(255)UNIQUENOTNULL);CREATETABLEIFNOTEXISTS borrow_records (
id INTAUTO_INCREMENTPRIMARYKEY,
user_id INTNOTNULL,
book_id INTNOTNULL,
borrow_date DATENOTNULL,
return_date DATE,FOREIGNKEY(user_id)REFERENCES users(id),FOREIGNKEY(book_id)REFERENCES books(id));
Go 代码实现
添加用户
首先，我们需要能够添加用户到
users
表中，因为借阅记录需要关联到具体的用户。
// user.gofuncaddUser(db *sql.DB, name, email string){_, err := db.Exec("INSERT INTO users (name, email) VALUES (?, ?)", name, email)if err !=nil{
log.Fatal("Failed to add user:", err)}
fmt.Println("User added successfully:", name)}
添加借阅记录
接下来，实现添加借阅记录的功能：
// borrow.gofuncaddBorrowRecord(db *sql.DB, userID, bookID int, borrowDate time.Time){_, err := db.Exec("INSERT INTO borrow_records (user_id, book_id, borrow_date) VALUES (?, ?, ?)", userID, bookID, borrowDate)if err !=nil{
log.Fatal("Failed to add borrow record:", err)}
fmt.Println("Borrow record added successfully for user ID:", userID)}
查询借阅记录
实现一个函数，用于查询特定用户的所有借阅记录：
funclistBorrowRecords(db *sql.DB, userID int){
rows, err := db.Query("SELECT b.id, bk.title, b.borrow_date, b.return_date FROM borrow_records b JOIN books bk ON b.book_id = bk.id WHERE b.user_id = ?", userID)if err !=nil{
log.Fatal("Failed to list borrow records:", err)}defer rows.Close()for rows.Next(){var id intvar title stringvar borrowDate, returnDate sql.NullTime
if err := rows.Scan(&id,&title,&borrowDate,&returnDate); err !=nil{
log.Fatal("Failed to scan borrow record:", err)}
fmt.Printf("Record %d: %s, Borrowed on %s, Returned on %v\n", id, title, borrowDate.Time.Format("2006-01-02"), returnDate.Time.Format("2006-01-02"))}}
主函数
在
main.go
中，整合上述功能，并运行演示：
// main.gopackage main
funcmain(){
db :=connectDB()defer db.Close()// 添加用户示例addUser(db,"Elizabeth Swann","[email protected]")// 添加图书示例addBook(db,"Pirates of the Caribbean","Ted Elliott & Terry Rossio", time.Date(2003,7,9,0,0,0,0, time.UTC))// 添加借阅记录addBorrowRecord(db,1,1, time.Now())// 查询借阅记录listBorrowRecords(db,1)}
通过运行
main.go
文件，你可以测试添加用户、图书以及借阅记录的过程，并且能够查询特定用户的所有借阅记录。
通过这个拓展案例，你已经学会了如何在Go语言中实现与数据库相关的更复杂的操作，包括处理多表关联和实现具体的业务逻辑。随着你对数据库操作的掌握越来越深入，你将能够构建更加复杂和功能丰富的应用。
9.2.4 拓展案例 2：图书搜索功能
在这个案例中，我们将扩展图书管理系统，添加图书搜索功能，允许用户通过书名或作者名进行搜索。这项功能能够帮助用户快速找到感兴趣的图书，提高系统的用户体验。
准备数据库
假设我们已经有了一个
books
表，其中包含图书的标题(
title
)和作者(
author
)。
Go 代码实现
实现搜索图书功能
我们将实现一个
searchBooks
函数，接收一个搜索关键字，并在书名和作者名中查找匹配项。
// search.gopackage main
import("database/sql""fmt""log")funcsearchBooks(db *sql.DB, keyword string){// 使用LIKE操作符进行模糊匹配，同时搜索书名和作者名
query := fmt.Sprintf("%%s%", keyword)// 构建一个包含通配符的查询字符串
rows, err := db.Query("SELECT id, title, author FROM books WHERE title LIKE ? OR author LIKE ?", query, query)if err !=nil{
log.Fatal("Failed to search books:", err)}defer rows.Close()
fmt.Println("Search results:")for rows.Next(){var id intvar title, author stringif err := rows.Scan(&id,&title,&author); err !=nil{
log.Fatal("Failed to scan book:", err)}
fmt.Printf("ID: %d, Title: %s, Author: %s\n", id, title, author)}// 检查是否有错误发生在迭代结果集中if err := rows.Err(); err !=nil{
log.Fatal(err)}}
请注意，搜索时使用
LIKE
操作符和通配符
%
来实现模糊匹配，以便匹配包含关键字的所有图书。
主函数
在
main.go
中，调用
searchBooks
函数演示搜索图书的功能：
// main.gopackage main
funcmain(){
db :=connectDB()defer db.Close()// 示例：搜索图书
searchKeyword :="Caribbean"searchBooks(db, searchKeyword)}
通过运行
main.go
文件，你可以测试图书搜索功能。输入一个关键字，程序将列出所有在书名或作者名中包含该关键字的图书。
通过这个拓展案例，你已经学会了如何在Go语言中为图书管理系统实现一个基本的搜索功能。这种功能在现实世界的应用中非常有用，尤其是在数据量大的情况下，能够帮助用户快速定位到他们感兴趣的信息。随着你对数据库操作和查询优化的进一步学习和实践，你将能够构建出更加强大和高效的搜索功能。
9.3 使用ORM框架 - Go 语言的数据航海术
9.3.1 基础知识讲解
在Go的数据探险旅程中，使用ORM（Object-Relational Mapping）框架可以让我们以更直观和对象化的方式与数据库进行交互，而无需编写繁琐的SQL语句。ORM框架提供了一种机制，将数据库表映射为Go中的结构体，数据库表中的行（记录）映射为结构体的实例，这样我们就可以使用Go代码来操作数据库了。
GORM 介绍
GORM是Go语言中最受欢迎的ORM库之一，它具有全功能的ORM功能，支持关联（包括一对一、一对多、多对多）、钩子（回调）、事务、迁移、SQL构建器、自动加载和预加载等特性。
要使用GORM，首先需要安装：
go get -u gorm.io/gorm
go get -u gorm.io/driver/sqlite // 对于SQLite
go get -u gorm.io/driver/mysql // 对于MySQL
go get -u gorm.io/driver/postgres // 对于PostgreSQL
连接数据库
使用GORM连接数据库非常简单，以下是一个连接SQLite数据库的示例：
import("gorm.io/driver/sqlite""gorm.io/gorm")
db, err := gorm.Open(sqlite.Open("test.db"),&gorm.Config{})if err !=nil{panic("failed to connect database")}
9.3.2 重点案例：员工管理系统
在这个扩展案例中，我们将构建一个简单的员工管理系统，使用GORM实现对员工数据的增删改查操作。该系统将演示如何在Go语言中使用ORM框架来简化数据库操作，提高开发效率。
定义模型
首先，我们定义
Employee
模型来映射数据库中的
employees
表：
// models.gopackage main
import("gorm.io/gorm""time")type Employee struct{
ID uint`gorm:"primaryKey"`
CreatedAt time.Time
UpdatedAt time.Time
DeletedAt gorm.DeletedAt `gorm:"index"`
Name string
Email string`gorm:"uniqueIndex"`
Position string}
初始化数据库并自动迁移模型
接下来，初始化数据库连接并自动迁移模型，确保数据库表结构与Go中的模型结构一致：
// db.gopackage main
import("gorm.io/driver/sqlite""gorm.io/gorm""log")funcInitDB()*gorm.DB {
db, err := gorm.Open(sqlite.Open("employees.db"),&gorm.Config{})if err !=nil{
log.Fatalf("Failed to connect to database: %v", err)}// 自动迁移模式
db.AutoMigrate(&Employee{})return db
}
实现员工的增删改查操作
在员工管理系统中，我们需要实现以下功能：
- 添加新员工
funcAddEmployee(db *gorm.DB, employee *Employee){
result := db.Create(employee)if result.Error !=nil{
log.Fatalf("Failed to add employee: %v", result.Error)}
log.Printf("Added new employee: %s", employee.Name)}
- 查询所有员工
funcListEmployees(db *gorm.DB){var employees []Employee
result := db.Find(&employees)if result.Error !=nil{
log.Fatalf("Failed to list employees: %v", result.Error)}for_, employee :=range employees {
log.Printf("ID: %d, Name: %s, Email: %s, Position: %s", employee.ID, employee.Name, employee.Email, employee.Position)}}
- 更新员工信息
funcUpdateEmployee(db *gorm.DB, id uint, updateData map[string]interface{}){
result := db.Model(&Employee{}).Where("id = ?", id).Updates(updateData)if result.Error !=nil{
log.Fatalf("Failed to update employee: %v", result.Error)}
log.Printf("Updated employee with ID: %d", id)}
- 删除员工
funcDeleteEmployee(db *gorm.DB, id uint){
result := db.Delete(&Employee{}, id)if result.Error !=nil{
log.Fatalf("Failed to delete employee: %v", result.Error)}
log.Printf("Deleted employee with ID: %d", id)}
主函数
在
main.go
中，我们整合上述功能，并运行演示：
// main.gopackage main
funcmain(){
db :=InitDB()// 添加新员工
newEmployee := Employee{Name:"Jack Sparrow", Email:"[email protected]", Position:"Captain"}AddEmployee(db,&newEmployee)// 查询所有员工ListEmployees(db)// 更新员工信息UpdateEmployee(db, newEmployee.ID,map[string]interface{}{"Position":"Pirate Lord"})// 删除员工DeleteEmployee(db, newEmployee.ID)}
通过运行
main.go
文件，你可以测试员工管理系统的各项功能。这个简单的应用展示了如何使用GORM与SQLite数据库进行交互，实现对员工数据的操作。
通过这个案例，你已经学会了如何在Go语言中使用GORM框架来简化数据库操作。随着对GORM和ORM概念的深入理解，你将能够更高效地开发出数据驱动的应用。
9.3.3 拓展案例 1：员工请假记录
在这个拓展案例中，我们将为员工管理系统添加员工请假记录的功能。这项功能涉及到新的数据库表
leave_records
的创建，并实现员工请假记录的增加和查询操作。
扩展数据库模型
首先，我们需要创建一个新的表
leave_records
来存储请假记录，并且这个表与
employees
表通过外键关联。
CREATETABLEIFNOTEXISTS leave_records (
id INTAUTO_INCREMENTPRIMARYKEY,
employee_id INTNOTNULL,
leave_date DATENOTNULL,
return_date DATENOTNULL,
reason TEXT,FOREIGNKEY(employee_id)REFERENCES employees(id));
接着，在Go中定义
LeaveRecord
模型以映射
leave_records
表：
// models.gotype LeaveRecord struct{
gorm.Model
EmployeeID uint
LeaveDate time.Time
ReturnDate time.Time
Reason string}
确保在初始化数据库时自动迁移新模型：
db.AutoMigrate(&Employee{},&LeaveRecord{})
实现请假记录操作
添加请假记录
我们实现一个函数来添加新的请假记录：
funcAddLeaveRecord(db *gorm.DB, record *LeaveRecord){if err := db.Create(record).Error; err !=nil{
log.Fatalf("Failed to add leave record: %v", err)}else{
fmt.Println("Leave record added successfully.")}}
查询员工的请假记录
实现一个函数来查询特定员工的所有请假记录：
funcListLeaveRecords(db *gorm.DB, employeeID uint){var records []LeaveRecord
if err := db.Where("employee_id = ?", employeeID).Find(&records).Error; err !=nil{
log.Fatalf("Failed to list leave records: %v", err)}else{for_, record :=range records {
fmt.Printf("Leave from %s to %s, Reason: %s\n", record.LeaveDate.Format("2006-01-02"), record.ReturnDate.Format("2006-01-02"), record.Reason)}}}
主函数
在
main.go
中，调用上述函数演示添加和查询请假记录的功能：
// main.gopackage main
funcmain(){
db :=InitDB()// 假设已存在员工Jack Sparrow，其ID为1
employeeID :=uint(1)// 添加请假记录
record := LeaveRecord{
EmployeeID: employeeID,
LeaveDate: time.Date(2023,1,10,0,0,0,0, time.UTC),
ReturnDate: time.Date(2023,1,20,0,0,0,0, time.UTC),
Reason:"Sailing the seven seas",}AddLeaveRecord(db,&record)// 查询员工的请假记录ListLeaveRecords(db, employeeID)}
通过运行
main.go
文件，你可以测试添加和查询请假记录的功能。这个拓展案例展示了如何使用GORM处理更复杂的数据模型和关联关系，为员工管理系统添加新的功能。
通过这个案例，你进一步理解了在Go语言中使用ORM框架进行数据库操作的便利性，以及如何为应用添加实际业务逻辑。随着你对GORM和数据库操作的深入掌握，你将能够构建更加复杂和功能丰富的应用。
9.3.4 拓展案例 2：部门管理
在这个案例中，我们将为员工管理系统添加部门管理功能，允许创建部门、查询部门列表、将员工分配到部门等。这涉及到处理多对多的关联关系，并展示如何使用GORM进行复杂的查询和更新操作。
扩展数据库模型
首先，我们需要定义
Department
模型并创建一个新表
departments
来存储部门信息。同时，因为一个员工可以属于多个部门，一个部门也可以有多个员工，我们还需要一个关联表
employee_departments
来实现多对多的关系。
CREATETABLEIFNOTEXISTS departments (
id INTAUTO_INCREMENTPRIMARYKEY,
name VARCHAR(255)NOTNULL,
description TEXT);CREATETABLEIFNOTEXISTS employee_departments (
employee_id INT,
department_id INT,FOREIGNKEY(employee_id)REFERENCES employees(id),FOREIGNKEY(department_id)REFERENCES departments(id),PRIMARYKEY(employee_id, department_id));
接着，在Go中定义
Department
模型并更新
Employee
模型以映射新的关系：
// models.gotype Department struct{
gorm.Model
Name string
Description string
Employees []Employee `gorm:"many2many:employee_departments;"`}type Employee struct{
gorm.Model
Name string
Email string`gorm:"uniqueIndex"`
Position string
Departments []Department `gorm:"many2many:employee_departments;"`}
确保在初始化数据库时自动迁移新模型：
db.AutoMigrate(&Employee{},&Department{})
实现部门管理操作
添加部门
funcAddDepartment(db *gorm.DB, department *Department){if err := db.Create(department).Error; err !=nil{
log.Fatalf("Failed to add department: %v", err)}else{
fmt.Println("Department added successfully:", department.Name)}}
查询部门列表
funcListDepartments(db *gorm.DB){var departments []Department
if err := db.Find(&departments).Error; err !=nil{
log.Fatalf("Failed to list departments: %v", err)}else{for_, department :=range departments {
fmt.Printf("ID: %d, Name: %s, Description: %s\n", department.ID, department.Name, department.Description)}}}
将员工分配到部门
funcAssignEmployeeToDepartment(db *gorm.DB, employeeID, departmentID uint){var employee Employee
var department Department
if err := db.First(&employee, employeeID).Error; err !=nil{
log.Fatalf("Employee not found: %v", err)}if err := db.First(&department, departmentID).Error; err !=nil{
log.Fatalf("Department not found: %v", err)}
db.Model(&employee).Association("Departments").Append(&department)
fmt.Printf("Employee %s assigned to department %s\n", employee.Name, department.Name)}
主函数
在
main.go
中，整合上述功能，并运行演示：
// main.gopackage main
funcmain(){
db :=InitDB()// 添加部门
dept := Department{Name:"IT", Description:"Information Technology"}AddDepartment(db,&dept)// 查询部门列表ListDepartments(db)// 将员工分配到部门AssignEmployeeToDepartment(db,1,1)// 假设员工ID和部门ID都为1}
通过运行
main.go
文件，你可以测试部门管理的各项功能。这个拓展案例展示了如何使用GORM处理多对多的关系，并在应用中实现复杂的业务逻辑。
通过这个案例，你已经学会了如何在Go语言中使用GORM框架来管理多对多的关系，并实现了一个部门管理功能。随着你对GORM和数据库操作的深入掌握，你将能够构建更加复杂和功能丰富的应用。
版权归原作者 江帅帅 所有， 如有侵权，请联系我们删除。