Go语言数据库：GORM框架使用

1. GORM基础介绍

GORM是Go语言中广泛使用的ORM（对象关系映射）框架，支持主流数据库（MySQL、PostgreSQL等），提供自动迁移、CRUD操作等功能，简化数据库交互代码：

自动映射结构体到数据库表
支持链式调用构建查询
提供钩子（Hook）实现业务逻辑扩展
兼容`database/sql`接口

示例：安装GORM

go get -u gorm.io/gorm
ago get -u gorm.io/driver/mysql  // MySQL驱动

2. 数据库连接与初始化

使用GORM连接数据库需要配置驱动和DSN（数据来源名称），通过`gorm.Open`初始化数据库实例：

示例：连接MySQL数据库

package main

import (
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

func main() {
    // 配置DSN
    dsn := "root:123456@tcp(localhost:3306)/testdb?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) 
    if err != nil {
        panic("连接数据库失败: " + err.Error())
    }
    fmt.Println("GORM连接成功")

    // 配置连接池
    sqlDB, _ := db.DB()
    sqlDB.SetMaxIdleConns(10)         // 最大空闲连接数
    sqlDB.SetMaxOpenConns(100)        // 最大打开连接数
    sqlDB.SetConnMaxLifetime(time.Hour) // 连接最大存活时间
}

关键点说明：

`gorm.Open`返回`*gorm.DB`实例，用于后续操作
通过`db.DB()`获取底层`*sql.DB`实例，配置连接池参数
敏感信息（如密码）应通过环境变量获取，避免硬编码

3. 模型定义与自动迁移

GORM通过结构体定义模型（Model），字段标签（Tag）控制表名、列名等属性。`AutoMigrate`方法自动迁移模型到数据库：

示例：模型定义与迁移

type User struct {
    gorm.Model          // 嵌入GORM内置模型（包含ID、CreatedAt、UpdatedAt、DeletedAt）
    Username  string    `gorm:"size:50;unique"`  // 用户名（长度50，唯一）
    Email     string    `gorm:"index"`           // 邮箱（添加索引）
    Age       uint8     // 无符号8位整数
    Profile   Profile   // 一对一关联
}

type Profile struct {
    gorm.Model
    UserID    uint      // 用户ID（外键）
    Bio       string    `gorm:"type:text"`      // 个人简介（文本类型）
}

func main() {
    // 自动迁移（创建/更新表结构）
    err := db.AutoMigrate(&User{}, &Profile{})
    if err != nil {
        panic("迁移失败: " + err.Error())
    }
}

标签说明：

`size:50`：设置字段长度为50
`unique`：添加唯一约束
`index`：添加普通索引
`type:text`：指定数据库字段类型为TEXT

4. 数据插入（Create）

使用`Create`方法插入单条或多条记录，GORM会自动填充`ID`、`CreatedAt`等内置字段：

示例：插入用户记录

func createUser(db *gorm.DB) {
    // 单条插入
    user := User{
        Username: "alice",
        Email:    "alice@example.com",
        Age:      25,
        Profile: Profile{Bio: "Go语言爱好者"},
    }
    result := db.Create(&user)
    if result.Error != nil {
        fmt.Println("插入失败:", result.Error)
        return
    }
    fmt.Printf("插入用户ID: %d\n", user.ID)

    // 批量插入（最多支持999条，取决于数据库配置）
    users := []User{
        {Username: "bob", Email: "bob@example.com", Age: 30},
        {Username: "carol", Email: "carol@example.com", Age: 28},
    }
    db.Create(&users)
    fmt.Printf("批量插入数量: %d\n", len(users))
}

注意事项：

关联模型（如Profile）需开启`gorm:association_autoupdate`等标签（默认自动插入）
`result.RowsAffected`返回影响的行数

5. 数据查询（Query）

GORM提供丰富的查询方法，支持链式调用、条件过滤、关联查询等，常用方法包括`Find`、`First`、`Where`：

示例：用户查询操作

func queryUsers(db *gorm.DB) {
    var user User
    // 查询单条记录（按ID）
    db.First(&user, 1)
    fmt.Printf("用户1: %+v\n", user)

    // 条件查询（年龄大于25）
    var users []User
    db.Where("age > ?", 25).Find(&users)
    fmt.Printf("年龄大于25的用户: %+v\n", users)

    // 模糊查询（用户名包含"li"）
    db.Where("username LIKE ?", "%li%").Find(&users)

    // 关联查询（预加载Profile）
    db.Preload("Profile").Find(&users)
    for _, u := range users {
        fmt.Printf("用户%v简介: %s\n", u.Username, u.Profile.Bio)
    }
}

高级查询：

`Order`：排序（`db.Order("age DESC")`）
`Limit/Offset`：分页（`db.Limit(10).Offset(20)`）
`Select`：指定字段（`db.Select("username, email")`）
`Joins`：手动连接表（`db.Joins("LEFT JOIN profiles ON users.id = profiles.user_id")`）

6. 数据更新（Update）

使用`Update`或`Updates`方法更新单条或多条记录，支持结构体、Map等更新方式：

示例：用户信息更新

func updateUser(db *gorm.DB) {
    // 单字段更新
    db.Model(&User{}).Where("id = ?", 1).Update("age", 26)

    // 多字段更新（结构体）
    user := User{Username: "alice-updated", Age: 26}
    db.Model(&user).Where("id = ?", 1).Updates(user)

    // 多字段更新（Map）
    db.Model(&User{}).Where("age < ?", 30).Updates(map[string]interface{}{
        "email": "new@example.com",
        "age":   gorm.Expr("age + 1"),  // 字段自增
    })
}

注意事项：

使用结构体更新时，零值字段（如空字符串）不会被更新（需使用`Select`指定字段或Map）
`gorm.Expr`用于执行SQL表达式（如自增、函数调用）

7. 数据删除（Delete）

GORM支持逻辑删除（软删除）和物理删除。逻辑删除通过`gorm.Model`中的`DeletedAt`字段实现，删除时标记为删除时间而非真删除：

示例：用户删除操作

func deleteUser(db *gorm.DB) {
    var user User
    // 逻辑删除（标记DeletedAt）
    db.Delete(&user, 1)

    // 物理删除（真删除）
    db.Unscoped().Delete(&user, 1)

    // 批量删除（年龄小于20）
    result := db.Where("age < ?", 20).Delete(&User{})
    fmt.Printf("删除数量: %d\n", result.RowsAffected)
}

逻辑删除特性：

查询时自动过滤已删除记录（需使用`Unscoped()`查询所有记录）
支持`gorm:soft_delete:flag`标签自定义软删除字段

8. 事务处理

GORM通过`Transaction`方法实现事务，确保一组操作的原子性。支持嵌套事务和保存点（Savepoint）：

示例：转账事务

func transfer(db *gorm.DB, fromID, toID uint, amount float64) error {
    return db.Transaction(func(tx *gorm.DB) error {
        // 扣减转出账户余额
        var fromAccount Account
        if err := tx.First(&fromAccount, fromID).Error;
            err != nil {
            return err
        }
        if fromAccount.Balance < amount {
            return errors.New("余额不足")
        }
        fromAccount.Balance -= amount
        if err := tx.Save(&fromAccount).Error;
            err != nil {
            return err
        }

        // 增加转入账户余额
        var toAccount Account
        if err := tx.First(&toAccount, toID).Error;
            err != nil {
            return err
        }
        toAccount.Balance += amount
        if err := tx.Save(&toAccount).Error;
            err != nil {
            return err
        }

        return nil  // 提交事务
    })
}

事务控制：

在事务函数中返回错误会自动回滚
返回`nil`自动提交
使用`tx.Commit()`和`tx.Rollback()`手动控制（需配合`db.Transaction`）