• 《Go 简易速速上手小册》第9章：数据库交互（2024 最新版）

    在这里插入图片描述

    文章目录

    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

    • 1

    对于PostgreSQL，则可能是github.com/lib/pq：

    go get -u github.com/lib/pq

    • 1

    数据库连接

    连接数据库通常涉及创建一个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()

    • 1
    • 2
    • 3
    • 4
    • 5

    确保在不再需要数据库连接时调用db.Close()来关闭连接。

    9.1.2 重点案例：用户信息管理系统

    在这个扩展案例中，我们将构建一个用户信息管理系统，该系统将演示如何在Go语言中连接MySQL数据库、添加新用户以及查询现有用户信息。此外，我们还将实现一个简单的用户登录验证功能。

    准备数据库

    首先，确保你的MySQL数据库服务正在运行，并执行以下SQL脚本来创建数据库和表：

    CREATE DATABASE IF NOT EXISTS userdb;
USE userdb;
CREATE TABLE IF NOT EXISTS users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL,
    password VARCHAR(255) NOT NULL
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    Go 代码实现

    在Go项目中，使用database/sql包和github.com/go-sql-driver/mysql驱动来实现与数据库的连接和操作。

    连接数据库

    首先，实现一个函数来创建数据库连接：

    // db.go

package main

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

func connectDB() *sql.DB {
    db, err := sql.Open("mysql", "user:password@/userdb?parseTime=true")
    if err != nil {
        log.Fatal(err)
    }
    return db
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    添加新用户

    实现一个函数，用于添加新用户到数据库：

    // user.go

package main

import (
    "log"
)

func addUser(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    查询用户信息

    实现一个函数，用于根据邮箱查询用户信息：

    func getUserByEmail(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    用户登录验证

    实现一个简单的用户登录验证功能：

    func verifyUserLogin(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")
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    主函数

    在main函数中，调用上述函数演示添加新用户和查询用户信息的功能：

    // main.go

package main

func main() {
    db := connectDB()
    defer db.Close()

    addUser(db, "Jack Sparrow", "jack@sparrow.com", "pirate")
    getUserByEmail(db, "jack@sparrow.com")
    verifyUserLogin(db, "jack@sparrow.com", "pirate")
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    通过运行main.go文件，你可以看到添加新用户、查询用户信息和用户登录验证的过程。

    通过这个扩展案例，你已经学会了如何在Go语言中连接MySQL数据库、执行基本的数据操作以及实现简单的用户登录验证功能。这为构建更复杂的Web应用和服务提供了坚实的基础。随着你对数据库操作的深入，你将能够更有效地管理和利用数据，为用户提供丰富和安全的服务。

    9.1.3 拓展案例 1：批量添加用户

    在这个案例中，我们将扩展之前的用户信息管理系统，实现一个功能以批量添加用户到数据库中。这项功能非常适合于需要一次性导入大量用户数据的场景，比如从CSV文件导入或者在系统初始化时预填充用户数据。为了保证数据的一致性和完整性，我们将使用事务来处理批量添加操作。

    准备数据库

    确保你已经按照之前的指示创建了userdb数据库和users表。

    Go 代码实现

    实现批量添加用户功能

    我们将实现一个addUsers函数，接收一个用户信息列表，并使用事务批量添加用户到数据库中：

    // user.go

package main

import (
    "database/sql"
    "log"
)

type User struct {
    Name     string
    Email    string
    Password string
}

func addUsers(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")
}

    • 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

    在这个函数中，我们首先开始一个新的事务。对于传入的每个用户，我们使用预编译的SQL语句和事务执行插入操作。最后，如果所有插入操作都成功执行，我们提交事务；如果在过程中遇到任何错误，事务将被回滚，保证数据库状态的一致性。

    主函数

    在main函数中，调用addUsers函数演示批量添加用户的功能：

    // main.go

package main

func main() {
    db := connectDB()
    defer db.Close()

    users := []User{
        {"Will Turner", "will@turner.com", "Bootstrap"},
        {"Elizabeth Swann", "elizabeth@swann.com", "PirateKing"},
        {"Hector Barbossa", "hector@barbossa.com", "BlackPearl"},
    }

    addUsers(db, users)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    通过运行main.go文件，你可以看到批量添加用户的过程。使用事务可以确保批量添加操作的原子性，即要么所有用户都成功添加，要么一个都不添加，避免了可能出现的数据不一致问题。

    通过这个拓展案例，你已经学会了如何在Go语言中实现批量添加用户的功能，并了解了事务在保证数据库操作一致性中的重要作用。掌握这些技能后，你将能够更高效地管理和操作数据库中的数据。

    9.1.4 拓展案例 2：用户登录验证

    在这个案例中，我们将为用户信息管理系统添加用户登录验证功能。这个功能允许用户通过提供邮箱和密码来验证其身份。为了保证安全性，我们将存储密码的哈希值，而不是明文密码。

    准备数据库

    首先，确保你的users表已经准备好，并且有一个用于存储密码哈希值的字段：

    ALTER TABLE users ADD COLUMN password_hash VARCHAR(255) NOT NULL;

    • 1

    Go 代码实现

    为了处理密码，我们将使用golang.org/x/crypto/bcrypt包来生成和验证密码哈希。首先，安装bcrypt包：

    go get -u golang.org/x/crypto/bcrypt

    • 1
    生成和验证密码哈希

    我们将实现两个函数：一个用于生成密码的哈希值，另一个用于验证提供的密码是否与存储的哈希值匹配：

    // auth.go

package main

import (
    "golang.org/x/crypto/bcrypt"
)

// GeneratePasswordHash 生成密码的哈希值
func GeneratePasswordHash(password string) (string, error) {
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), 14)
    return string(bytes), err
}

// VerifyPassword 检查密码是否与其哈希值匹配
func VerifyPassword(password, hash string) bool {
    err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
    return err == nil
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    实现用户登录验证

    接下来，我们扩展用户信息管理系统，添加用户登录验证功能：

    // user.go

package main

import (
    "database/sql"
    "fmt"
    "log"
)

// VerifyUserLogin 验证用户登录
func VerifyUserLogin(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
    }

    if VerifyPassword(password, passwordHash) {
        fmt.Println("登录成功")
    } else {
        fmt.Println("密码错误")
    }
}

    • 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
    主函数

    在main函数中，调用VerifyUserLogin函数演示用户登录验证的过程：

    // main.go

package main

func main() {
    db := connectDB()
    defer db.Close()

    // 假设用户已经被添加到数据库，并且密码哈希已经存储
    email := "jack@sparrow.com"
    password := "pirate"

    VerifyUserLogin(db, email, password)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    通过运行main.go文件，你可以测试用户登录验证的功能。这个过程首先查询用户的密码哈希值，然后使用bcrypt库来验证提供的密码是否与哈希值匹配。

    通过这个拓展案例，你已经学会了如何在Go语言中实现基本的用户登录验证功能，包括如何安全地处理和存储密码。这为构建需要用户认证的Web应用和服务提供了坚实的基础。随着你对安全性的深入理解，你将能够为你的应用实现更高级的安全特性。

    9.2 执行查询与操作数据 - Go 语言的数据潜水艇

    9.2.1 基础知识讲解

    在Go的数据海洋中，执行查询和操作数据是寻找和管理宝藏的关键步骤。database/sql包提供了一套通用的接口，允许我们执行SQL查询、插入、更新和删除操作，以及处理结果集。

    执行查询

    查询数据库并处理结果集通常包括以下几个步骤：

    1. 使用Query或QueryRow执行SQL查询。Query用于返回多行结果，而QueryRow用于期望最多一行结果的查询。

    2. 遍历Rows结果集（如果是多行结果）。使用Next方法迭代结果集，并使用Scan方法将行数据扫描到变量中。

    3. 处理Row结果（如果是单行结果）。直接使用Scan方法将结果扫描到变量中。

    操作数据

    插入、更新和删除操作通常使用Exec方法执行SQL命令。这个方法返回一个Result对象，它提供了关于操作影响的行数等信息。

    9.2.2 重点案例：图书管理系统

    在这个扩展案例中，我们将构建一个简单的图书管理系统，该系统将演示如何在Go语言中连接MySQL数据库、添加新图书、查询图书列表、更新图书信息以及删除图书记录。

    准备数据库

    首先，确保你的MySQL数据库服务正在运行，并执行以下SQL脚本来创建数据库和books表：

    CREATE DATABASE IF NOT EXISTS library;
USE library;
CREATE TABLE IF NOT EXISTS books (
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    author VARCHAR(255) NOT NULL,
    published_date DATE
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    Go 代码实现

    连接数据库

    首先，实现一个函数来创建数据库连接：

    // db.go

package main

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

func connectDB() *sql.DB {
    db, err := sql.Open("mysql", "user:password@/library")
    if err != nil {
        log.Fatal(err)
    }
    return db
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    确保替换user:password@/library中的user和password为你的数据库用户名和密码。

    添加新图书
    // book.go

package main

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

func addBook(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    查询图书列表
    func listBooks(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 int
        var title, author string
        var 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"))
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    更新图书信息
    func updateBook(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    删除图书记录
    func deleteBook(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    主函数

    在main.go中，整合上述功能，并运行演示：

    // main.go

package main

import "time"

func main() {
    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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    通过运行main.go文件，你可以测试图书管理系统的各项功能。这个简单的应用展示了在Go中如何执行常见的数据库操作，包括连接数据库、执行SQL命令以及处理查询结果。

    通过这个案例，你学会了如何使用Go与数据库进行交互，实现一个基本的图书管理系统。这为进一步开发更复杂的数据库驱动应用奠定了基础。随着对数据库操作的深入掌握，你将能够构建更加强大和灵活的数据管理和分析功能。

    9.2.3 拓展案例 1：图书借阅记录

    在这个案例中，我们将扩展图书管理系统，添加功能以记录用户的图书借阅信息。这项功能涉及到创建新的数据库表来存储借阅记录，并实现相关的增、查操作。

    准备数据库

    首先，除了已有的books表之外，我们还需要创建两个新的表：users和borrow_records。

    CREATE TABLE IF NOT EXISTS users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL
);

CREATE TABLE IF NOT EXISTS borrow_records (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    book_id INT NOT NULL,
    borrow_date DATE NOT NULL,
    return_date DATE,
    FOREIGN KEY (user_id) REFERENCES users(id),
    FOREIGN KEY (book_id) REFERENCES books(id)
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    Go 代码实现

    添加用户

    首先，我们需要能够添加用户到users表中，因为借阅记录需要关联到具体的用户。

    // user.go

func addUser(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    添加借阅记录

    接下来，实现添加借阅记录的功能：

    // borrow.go

func addBorrowRecord(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    查询借阅记录

    实现一个函数，用于查询特定用户的所有借阅记录：

    func listBorrowRecords(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 int
        var title string
        var 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"))
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    主函数

    在main.go中，整合上述功能，并运行演示：

    // main.go

package main

func main() {
    db := connectDB()
    defer db.Close()

    // 添加用户示例
    addUser(db, "Elizabeth Swann", "elizabeth@swann.com")

    // 添加图书示例
    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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    通过运行main.go文件，你可以测试添加用户、图书以及借阅记录的过程，并且能够查询特定用户的所有借阅记录。

    通过这个拓展案例，你已经学会了如何在Go语言中实现与数据库相关的更复杂的操作，包括处理多表关联和实现具体的业务逻辑。随着你对数据库操作的掌握越来越深入，你将能够构建更加复杂和功能丰富的应用。

    9.2.4 拓展案例 2：图书搜索功能

    在这个案例中，我们将扩展图书管理系统，添加图书搜索功能，允许用户通过书名或作者名进行搜索。这项功能能够帮助用户快速找到感兴趣的图书，提高系统的用户体验。

    准备数据库

    假设我们已经有了一个books表，其中包含图书的标题(title)和作者(author)。

    Go 代码实现

    实现搜索图书功能

    我们将实现一个searchBooks函数，接收一个搜索关键字，并在书名和作者名中查找匹配项。

    // search.go

package main

import (
    "database/sql"
    "fmt"
    "log"
)

func searchBooks(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 int
        var title, author string
        if 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)
    }
}

    • 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

    请注意，搜索时使用LIKE操作符和通配符%来实现模糊匹配，以便匹配包含关键字的所有图书。

    主函数

    在main.go中，调用searchBooks函数演示搜索图书的功能：

    // main.go

package main

func main() {
    db := connectDB()
    defer db.Close()

    // 示例：搜索图书
    searchKeyword := "Caribbean"
    searchBooks(db, searchKeyword)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    通过运行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

    • 1
    • 2
    • 3
    • 4

    连接数据库

    使用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")
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    9.3.2 重点案例：员工管理系统

    在这个扩展案例中，我们将构建一个简单的员工管理系统，使用GORM实现对员工数据的增删改查操作。该系统将演示如何在Go语言中使用ORM框架来简化数据库操作，提高开发效率。

    定义模型

    首先，我们定义Employee模型来映射数据库中的employees表：

    // models.go

package 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
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    初始化数据库并自动迁移模型

    接下来，初始化数据库连接并自动迁移模型，确保数据库表结构与Go中的模型结构一致：

    // db.go

package main

import (
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
    "log"
)

func InitDB() *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
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    实现员工的增删改查操作

    在员工管理系统中，我们需要实现以下功能：

    • 添加新员工
    func AddEmployee(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 查询所有员工
    func ListEmployees(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)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 更新员工信息
    func UpdateEmployee(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 删除员工
    func DeleteEmployee(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    主函数

    在main.go中，我们整合上述功能，并运行演示：

    // main.go

package main

func main() {
    db := InitDB()

    // 添加新员工
    newEmployee := Employee{Name: "Jack Sparrow", Email: "jack@sparrow.com", Position: "Captain"}
    AddEmployee(db, &newEmployee)

    // 查询所有员工
    ListEmployees(db)

    // 更新员工信息
    UpdateEmployee(db, newEmployee.ID, map[string]interface{}{"Position": "Pirate Lord"})

    // 删除员工
    DeleteEmployee(db, newEmployee.ID)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    通过运行main.go文件，你可以测试员工管理系统的各项功能。这个简单的应用展示了如何使用GORM与SQLite数据库进行交互，实现对员工数据的操作。

    通过这个案例，你已经学会了如何在Go语言中使用GORM框架来简化数据库操作。随着对GORM和ORM概念的深入理解，你将能够更高效地开发出数据驱动的应用。

    9.3.3 拓展案例 1：员工请假记录

    在这个拓展案例中，我们将为员工管理系统添加员工请假记录的功能。这项功能涉及到新的数据库表leave_records的创建，并实现员工请假记录的增加和查询操作。

    扩展数据库模型

    首先，我们需要创建一个新的表leave_records来存储请假记录，并且这个表与employees表通过外键关联。

    CREATE TABLE IF NOT EXISTS leave_records (
    id INT AUTO_INCREMENT PRIMARY KEY,
    employee_id INT NOT NULL,
    leave_date DATE NOT NULL,
    return_date DATE NOT NULL,
    reason TEXT,
    FOREIGN KEY (employee_id) REFERENCES employees(id)
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    接着，在Go中定义LeaveRecord模型以映射leave_records表：

    // models.go

type LeaveRecord struct {
    gorm.Model
    EmployeeID uint
    LeaveDate  time.Time
    ReturnDate time.Time
    Reason     string
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    确保在初始化数据库时自动迁移新模型：

    db.AutoMigrate(&Employee{}, &LeaveRecord{})

    • 1

    实现请假记录操作

    添加请假记录

    我们实现一个函数来添加新的请假记录：

    func AddLeaveRecord(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.")
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    查询员工的请假记录

    实现一个函数来查询特定员工的所有请假记录：

    func ListLeaveRecords(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)
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    主函数

    在main.go中，调用上述函数演示添加和查询请假记录的功能：

    // main.go

package main

func main() {
    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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    通过运行main.go文件，你可以测试添加和查询请假记录的功能。这个拓展案例展示了如何使用GORM处理更复杂的数据模型和关联关系，为员工管理系统添加新的功能。

    通过这个案例，你进一步理解了在Go语言中使用ORM框架进行数据库操作的便利性，以及如何为应用添加实际业务逻辑。随着你对GORM和数据库操作的深入掌握，你将能够构建更加复杂和功能丰富的应用。

    9.3.4 拓展案例 2：部门管理

    在这个案例中，我们将为员工管理系统添加部门管理功能，允许创建部门、查询部门列表、将员工分配到部门等。这涉及到处理多对多的关联关系，并展示如何使用GORM进行复杂的查询和更新操作。

    扩展数据库模型

    首先，我们需要定义Department模型并创建一个新表departments来存储部门信息。同时，因为一个员工可以属于多个部门，一个部门也可以有多个员工，我们还需要一个关联表employee_departments来实现多对多的关系。

    CREATE TABLE IF NOT EXISTS departments (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    description TEXT
);

CREATE TABLE IF NOT EXISTS employee_departments (
    employee_id INT,
    department_id INT,
    FOREIGN KEY (employee_id) REFERENCES employees(id),
    FOREIGN KEY (department_id) REFERENCES departments(id),
    PRIMARY KEY (employee_id, department_id)
);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    接着，在Go中定义Department模型并更新Employee模型以映射新的关系：

    // models.go

type 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;"`
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    确保在初始化数据库时自动迁移新模型：

    db.AutoMigrate(&Employee{}, &Department{})

    • 1

    实现部门管理操作

    添加部门
    func AddDepartment(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)
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    查询部门列表
    func ListDepartments(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)
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    将员工分配到部门
    func AssignEmployeeToDepartment(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)
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    主函数

    在main.go中，整合上述功能，并运行演示：

    // main.go

package main

func main() {
    db := InitDB()

    // 添加部门
    dept := Department{Name: "IT", Description: "Information Technology"}
    AddDepartment(db, &dept)

    // 查询部门列表
    ListDepartments(db)

    // 将员工分配到部门
    AssignEmployeeToDepartment(db, 1, 1) // 假设员工ID和部门ID都为1
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    通过运行main.go文件，你可以测试部门管理的各项功能。这个拓展案例展示了如何使用GORM处理多对多的关系，并在应用中实现复杂的业务逻辑。

    通过这个案例，你已经学会了如何在Go语言中使用GORM框架来管理多对多的关系，并实现了一个部门管理功能。随着你对GORM和数据库操作的深入掌握，你将能够构建更加复杂和功能丰富的应用。

  • 相关阅读:
    山西电力市场日前价格预测【2023-10-13】
    C#使用winform做一个开关小游戏
    【JAVA】：万字长篇带你了解JAVA并发编程【一】
    HTTPS的链接建立、通信过程
    进程的控制
    【期末大作业】基于HTML+CSS+JavaScript南京大学网页校园教育网站html模板(3页)
    [Android] 隧道音画同步模式
    金融机构系统性风险分析(Domestic+MES模型)200701-202012
    k8s基础：kubectl delete --ignore-not-found参数选项作用
    Rust 枚举与模式匹配：探索类型安全与表达力的完美结合
  • 原文地址：https://blog.csdn.net/qq_41340258/article/details/136142804