GORM 使用指南

1. 介绍

1.1 什么是 GORM？

GORM（Go Object Relational Mapper）是一个用于 Go 语言的 ORM 库，它允许开发者通过面向对象的方式操作数据库，而不必直接编写 SQL 查询语句。GORM 提供了简单易用的 API，使得在 Go 项目中进行数据库操作变得更加高效和便捷。它的设计理念是将数据库表映射为 Go 的结构体（Struct），并通过方法调用来实现对数据的增删改查等操作，从而降低了与数据库交互的复杂性。

1.2 GORM 的历史和背景

GORM 最初由 Jinzhu（原名：Liao Xingchang） 在 2013 年创建，并于同年开源发布在 GitHub 上。起初，GORM 是为了解决 Go 语言中缺乏成熟 ORM 库的问题而诞生的。随着 Go 语言的流行和生态系统的不断发展，GORM 逐渐成为了 Go 社区中最受欢迎的 ORM 库之一。

经过多年的发展，GORM 不断完善和更新，增加了许多功能和优化，同时也受到了全球范围内开发者的广泛关注和使用。截至目前，GORM 的 GitHub 仓库已经获得了数万颗星星，并且被众多知名的开源项目和商业项目所采用和推荐。

1.3 为什么选择 GORM？

选择 GORM 作为数据库操作工具的原因有以下几点：

• 简单易用：GORM 提供了简洁的 API，使得开发者能够用最少的代码完成数据库操作，降低了学习成本和开发成本。

• 功能丰富：GORM 支持丰富的数据库操作功能，包括基本的 CRUD 操作、事务管理、关联查询等，满足了大部分应用场景的需求。

• 灵活性：GORM 提供了丰富的配置选项和扩展接口，可以灵活地适应不同的项目需求和数据库类型。

• 社区支持：作为一个活跃的开源项目，GORM 拥有庞大的社区支持和活跃的开发团队，能够及时解决问题并提供技术支持。

• 性能优化：GORM 在设计和实现上对性能进行了优化，同时提供了一些性能调优的建议和工具，可以帮助开发者提升应用程序的性能表现。

• 生态完善：GORM 作为一个成熟的 ORM 库，已经在 Go 生态系统中建立了良好的地位，与其他常用的库和框架（如 Gin、Echo 等）集成良好，能够为开发者提供更加完整的解决方案。

综上所述，GORM 是一个功能强大、易于使用且受到广泛认可的 ORM 库，适用于各种规模的 Go 项目，并且能够帮助开发者提高开发效率和代码质量。

2. 安装与配置

2.1 安装 GORM

安装 GORM 可以通过 Go 的包管理工具 go get 来完成。假设你已经安装了 Go 环境，执行以下命令即可安装 GORM：

go get -u github.com/go-gorm/gorm

这条命令会将 GORM 库下载并安装到你的 $GOPATH 下的 src 目录中。

2.2 配置数据库连接

在使用 GORM 之前，你需要配置数据库连接信息，包括数据库类型、连接地址、用户名、密码等。GORM 支持多种数据库，常用的包括 MySQL、PostgreSQL、SQLite、SQL Server 等。

以下是一个示例配置 MySQL 数据库连接的代码：

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

func main() {
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    
    // 在这里使用 db 进行数据库操作
}

其中，dsn 是数据源名称，包含了数据库的连接信息，格式为 "用户名:密码@tcp(数据库地址:端口号)/数据库名称?参数"。具体的参数说明如下：

• charset=utf8mb4：设置字符集为 UTF-8。
• parseTime=True：自动解析数据库中的时间字段为 Go 的时间类型。
• loc=Local：设置时区为本地时区。

你需要将示例代码中的 user、password、dbname 替换为你自己的数据库用户名、密码和数据库名称，并根据需要修改数据库地址和端口号。

2.3 初始化 GORM

在连接数据库之后，你需要初始化 GORM 的数据库连接，以便后续进行数据库操作。通常情况下，你只需要在程序启动时进行一次初始化操作即可。

以下是初始化 GORM 的示例代码：

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

var DB *gorm.DB

func InitDB() {
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    
    DB = db
}

在这个示例中，我们将初始化操作封装在了一个名为 InitDB() 的函数中，并将初始化后的数据库连接赋值给了全局变量 DB，以便在程序的其他地方进行使用。你可以根据自己的项目需求，将初始化操作放在适当的位置，并根据需要进行调整。

3. 模型定义

在 GORM 中，模型定义是指将数据库表映射为 Go 的结构体（Struct），通过结构体的字段来表示数据库表的字段，并使用 GORM 提供的标签来指定字段的属性和约束。同时，通过在结构体之间建立关联关系，可以实现数据库表之间的关联查询和操作。

3.1 创建模型结构体

下面是一个示例，展示了如何使用 GORM 创建一个简单的模型结构体：

import "gorm.io/gorm"

type User struct {
    gorm.Model // 内置模型结构体，包含 ID、CreatedAt、UpdatedAt、DeletedAt 字段

    Name     string
    Age      int
    Email    string `gorm:"unique"` // 使用标签指定字段属性，这里表示 Email 字段在数据库中是唯一的
    Address  string
}

在这个示例中，我们创建了一个名为 User 的结构体，用于表示数据库中的用户表。User 结构体包含了 gorm.Model 结构体，这是 GORM 提供的一个内置模型结构体，包含了一些常用的字段，如 ID、CreatedAt、UpdatedAt、DeletedAt，用于记录记录的主键、创建时间、更新时间和软删除状态。

除了内置模型字段外，我们还定义了 Name、Age、Email 和 Address 字段，分别表示用户的姓名、年龄、邮箱和地址。这些字段与数据库表的字段一一对应，用于存储用户的信息。

3.2 模型字段标签解析

在模型定义中，我们可以通过在字段上添加标签来指定字段的属性和约束。常用的标签包括：

• gorm:"column:column_name"：指定字段在数据库中的列名。
• gorm:"primaryKey"：指定字段为主键。
• gorm:"autoIncrement"：指定字段为自增长。
• gorm:"unique"：指定字段在数据库中唯一。
• gorm:"not null"：指定字段不能为空。
• gorm:"default:value"：指定字段的默认值。
• gorm:"size:length"：指定字段的长度。
• gorm:"index"：指定字段创建索引。

下面是一个示例，展示了如何在模型字段上添加标签：

type Product struct {
    ID       uint   `gorm:"primaryKey;autoIncrement"`
    Name     string `gorm:"size:255;not null"`
    Price    float64
    Category string `gorm:"index"`
}

在这个示例中，我们定义了一个名为 Product 的结构体，用于表示数据库中的产品表。Product 结构体包含了 ID、Name、Price 和 Category 字段，分别表示产品的编号、名称、价格和类别。其中，ID 字段通过 primaryKey 和 autoIncrement 标签指定为主键并自增长，Name 字段通过 size 和 not null 标签指定了字段的长度和不能为空，Category 字段通过 index 标签为字段创建了索引。

3.3 模型关联关系

在 GORM 中，可以通过在模型结构体中建立字段关联来表示数据库表之间的关联关系，常见的关联关系包括一对一、一对多和多对多。以下是一个示例，展示了如何在模型中定义关联关系：

type Order struct {
    ID          uint
    OrderNumber string
    TotalAmount float64
    UserID      uint // 外键

    User User `gorm:"foreignKey:UserID"` // 一对一关联，通过 UserID 外键关联到 User 结构体
}

type User struct {
    ID    uint
    Name  string
    Email string
    Order Order // 一对一关联，一个用户对应一个订单
}

在这个示例中，我们定义了两个结构体 Order 和 User，分别表示数据库中的订单表和用户表。在 Order 结构体中，我们使用了 UserID 字段作为外键，关联到了 User 结构体，通过 gorm:"foreignKey:UserID" 标签指定了外键关联的字段。在 User 结构体中，我们定义了一个名为 Order 的字段，用于表示与用户关联的订单信息。这样，我们就建立了订单表和用户表之间的一对一关联关系。

除了一对一关联关系外，GORM 还支持一对多和多对多等其他类型的关联关系，开发者可以根据实际需求选择合适的关联关系来设计模型。

4. 基本 CRUD 操作

CRUD 是指在数据库中对数据进行创建（Create）、读取（Read）、更新（Update）和删除（Delete）等操作。在 GORM 中，可以通过提供的方法来实现这些基本的 CRUD 操作。

4.1 创建记录

在 GORM 中，创建记录可以使用 Create() 方法。下面是一个示例，展示了如何使用 GORM 创建记录：

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

type Product struct {
    ID    uint
    Name  string
    Price float64
}

func main() {
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    defer db.Close()

    // 创建记录
    product := Product{Name: "Laptop", Price: 999.99}
    result := db.Create(&product)
    if result.Error != nil {
        fmt.Println("Failed to create product:", result.Error)
    } else {
        fmt.Println("Product created successfully!")
    }
}

在这个示例中，我们首先定义了一个名为 Product 的结构体，用于表示数据库中的产品表。然后，我们创建了一个 product 变量，赋值为要插入的产品信息。接着，我们使用 Create() 方法将产品信息插入到数据库中，如果创建成功，则打印出成功的提示信息，否则打印出错误信息。

4.2 读取记录

在 GORM 中，读取记录可以使用 First()、Last()、Find()、Take() 等方法。下面是一个示例，展示了如何使用 GORM 读取记录：

func main() {
    // ...

    // 读取记录
    var product Product
    db.First(&product, 1) // 读取 ID 为 1 的产品信息
    fmt.Println("Product:", product)

    var products []Product
    db.Find(&products) // 读取所有产品信息
    fmt.Println("Products:", products)
}

在这个示例中，我们使用 First() 方法读取了 ID 为 1 的产品信息，并将结果保存到 product 变量中。然后，我们使用 Find() 方法读取了所有产品信息，并将结果保存到 products 变量中。

4.3 更新记录

在 GORM 中，更新记录可以使用 Save() 方法。下面是一个示例，展示了如何使用 GORM 更新记录：

func main() {
    // ...

    // 更新记录
    var product Product
    db.First(&product, 1) // 读取要更新的产品信息
    product.Price = 1099.99 // 更新产品价格
    db.Save(&product) // 保存更新后的产品信息
    fmt.Println("Product updated successfully!")
}

在这个示例中，我们首先使用 First() 方法读取了 ID 为 1 的产品信息，并将结果保存到 product 变量中。然后，我们更新了产品的价格，并使用 Save() 方法保存更新后的产品信息。

4.4 删除记录

在 GORM 中，删除记录可以使用 Delete() 方法。下面是一个示例，展示了如何使用 GORM 删除记录：

func main() {
    // ...

    // 删除记录
    var product Product
    db.First(&product, 1) // 读取要删除的产品信息
    db.Delete(&product) // 删除产品信息
    fmt.Println("Product deleted successfully!")
}

在这个示例中，我们首先使用 First() 方法读取了 ID 为 1 的产品信息，并将结果保存到 product 变量中。然后，我们使用 Delete() 方法删除了产品信息。

5. 高级查询

在 GORM 中，除了基本的 CRUD 操作外，还提供了丰富的高级查询功能，包括查询单条记录、查询多条记录、条件查询、排序与分页、原生 SQL 查询等。

5.1 查询单条记录

在 GORM 中，查询单条记录可以使用 First() 或 Last() 方法。下面是一个示例，展示了如何使用 GORM 查询单条记录：

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

type Product struct {
    ID    uint
    Name  string
    Price float64
}

func main() {
    // ...

    // 查询单条记录
    var product Product
    db.First(&product, 1) // 查询 ID 为 1 的产品信息
    fmt.Println("Product:", product)
}

在这个示例中，我们使用 First() 方法查询了 ID 为 1 的产品信息，并将结果保存到 product 变量中。

5.2 查询多条记录

在 GORM 中，查询多条记录可以使用 Find() 方法。下面是一个示例，展示了如何使用 GORM 查询多条记录：

func main() {
    // ...

    // 查询多条记录
    var products []Product
    db.Find(&products) // 查询所有产品信息
    fmt.Println("Products:", products)
}

在这个示例中，我们使用 Find() 方法查询了所有产品信息，并将结果保存到 products 变量中。

5.3 条件查询

在 GORM 中，条件查询可以使用 Where() 方法。下面是一个示例，展示了如何使用 GORM 进行条件查询：

func main() {
    // ...

    // 条件查询
    var product Product
    db.Where("name = ?", "Laptop").First(&product) // 查询名称为 "Laptop" 的产品信息
    fmt.Println("Product:", product)
}

在这个示例中，我们使用 Where() 方法查询了名称为 “Laptop” 的产品信息，并将结果保存到 product 变量中。

5.4 排序与分页

在 GORM 中，排序与分页可以使用 Order() 和 Limit()、Offset() 方法。下面是一个示例，展示了如何使用 GORM 进行排序与分页：

func main() {
    // ...

    // 排序与分页
    var products []Product
    db.Order("price desc").Limit(10).Offset(0).Find(&products) // 按价格降序排序，取前 10 条记录
    fmt.Println("Products:", products)
}

在这个示例中，我们使用 Order() 方法按价格降序排序，然后使用 Limit() 方法限制返回的记录数为 10 条，最后使用 Offset() 方法设置偏移量为 0，即从第一条记录开始查询。

5.5 原生 SQL 查询

在 GORM 中，原生 SQL 查询可以使用 Raw() 方法。下面是一个示例，展示了如何使用 GORM 进行原生 SQL 查询：

func main() {
    // ...

    // 原生 SQL 查询
    var products []Product
    db.Raw("SELECT * FROM products WHERE price > ?", 1000).Scan(&products) // 查询价格大于 1000 的产品信息
    fmt.Println("Products:", products)
}

在这个示例中，我们使用 Raw() 方法执行了一条原生 SQL 查询，并将结果保存到 products 变量中。

6. 事务管理

在数据库操作中，事务是一组原子性操作，要么全部成功，要么全部失败。在 GORM 中，可以使用事务来确保数据库操作的一致性和完整性。

6.1 开启事务

在 GORM 中，开启事务可以使用 Begin() 方法。下面是一个示例，展示了如何使用 GORM 开启事务：

import "gorm.io/gorm"

func main() {
    // ...

    // 开启事务
    tx := db.Begin()
    if tx.Error != nil {
        panic("failed to begin transaction")
    }

    // 在事务中执行数据库操作
    // ...

    // 提交事务
    tx.Commit()
}

在这个示例中，我们使用 Begin() 方法开启了一个事务，并将返回的事务对象保存到 tx 变量中。

6.2 提交事务

在 GORM 中，提交事务可以使用 Commit() 方法。下面是一个示例，展示了如何使用 GORM 提交事务：

func main() {
    // ...

    // 提交事务
    if err := tx.Commit().Error; err != nil {
        tx.Rollback() // 回滚事务
        panic("failed to commit transaction")
    }
}

在这个示例中，我们使用 Commit() 方法提交了之前开启的事务，并检查了提交事务时是否发生了错误，如果发生了错误，则使用 Rollback() 方法回滚事务。

6.3 回滚事务

在 GORM 中，回滚事务可以使用 Rollback() 方法。下面是一个示例，展示了如何使用 GORM 回滚事务：

func main() {
    // ...

    // 回滚事务
    tx.Rollback()
}

在这个示例中，我们使用 Rollback() 方法回滚了之前开启的事务。

6.4 事务嵌套与保存点

在 GORM 中，可以使用嵌套事务和保存点来处理复杂的事务逻辑。下面是一个示例，展示了如何在 GORM 中使用事务嵌套和保存点：

func main() {
    // ...

    // 开启事务
    tx := db.Begin()
    if tx.Error != nil {
        panic("failed to begin transaction")
    }

    // 在事务中执行数据库操作
    // ...

    // 嵌套事务
    subTx := tx.Begin()
    if subTx.Error != nil {
        tx.Rollback()
        panic("failed to begin nested transaction")
    }

    // 在嵌套事务中执行数据库操作
    // ...

    // 提交嵌套事务
    if err := subTx.Commit().Error; err != nil {
        tx.Rollback()
        panic("failed to commit nested transaction")
    }

    // 提交主事务
    if err := tx.Commit().Error; err != nil {
        panic("failed to commit transaction")
    }
}

在这个示例中，我们首先开启了一个主事务 tx，然后在主事务中开启了一个嵌套事务 subTx，并在嵌套事务中执行了数据库操作。最后，我们分别提交了嵌套事务和主事务，如果在提交事务时发生了错误，则使用 Rollback() 方法回滚事务。

7. 关联与预加载

在 GORM 中，关联关系是指数据库表之间的关系，包括一对一、一对多和多对多等类型。预加载是指在查询数据库记录时，同时将关联的数据也加载到内存中，以提高查询效率。

7.1 一对一关联

在 GORM 中，一对一关联可以通过在模型结构体中定义字段来表示。下面是一个示例，展示了如何在 GORM 中定义一对一关联：

type User struct {
    ID   uint
    Name string
    Age  int
    Profile Profile // 一对一关联，一个用户对应一个个人资料
}

type Profile struct {
    ID     uint
    UserID uint // 外键
    Bio    string
}

在这个示例中，我们定义了两个结构体 User 和 Profile，分别表示数据库中的用户表和个人资料表。在 User 结构体中，我们定义了一个名为 Profile 的字段，用于表示用户与个人资料的关联关系。这样，我们就建立了用户表和个人资料表之间的一对一关联关系。

7.2 一对多关联

在 GORM 中，一对多关联可以通过在模型结构体中定义切片字段来表示。下面是一个示例，展示了如何在 GORM 中定义一对多关联：

type User struct {
    ID      uint
    Name    string
    Age     int
    Address string
    Orders  []Order // 一对多关联，一个用户对应多个订单
}

type Order struct {
    ID     uint
    UserID uint // 外键
    Amount float64
}

在这个示例中，我们定义了两个结构体 User 和 Order，分别表示数据库中的用户表和订单表。在 User 结构体中，我们定义了一个名为 Orders 的切片字段，用于表示用户与订单的一对多关联关系。这样，我们就建立了用户表和订单表之间的一对多关联关系。

7.3 多对多关联

在 GORM 中，多对多关联可以通过在模型结构体中定义切片字段来表示。下面是一个示例，展示了如何在 GORM 中定义多对多关联：

type User struct {
    ID      uint
    Name    string
    Age     int
    Address string
    Roles   []Role `gorm:"many2many:user_roles"` // 多对多关联，一个用户对应多个角色
}

type Role struct {
    ID   uint
    Name string
}

在这个示例中，我们定义了两个结构体 User 和 Role，分别表示数据库中的用户表和角色表。在 User 结构体中，我们定义了一个名为 Roles 的切片字段，并通过 gorm:"many2many:user_roles" 标签指定了中间表的名称，用于表示用户与角色的多对多关联关系。这样，我们就建立了用户表和角色表之间的多对多关联关系。

7.4 预加载关联数据

在 GORM 中，预加载关联数据可以使用 Preload() 方法。下面是一个示例，展示了如何在 GORM 中预加载关联数据：

func main() {
    // ...

    // 预加载关联数据
    var users []User
    db.Preload("Orders").Find(&users) // 预加载用户的订单数据
    fmt.Println("Users:", users)
}

在这个示例中，我们使用 Preload("Orders") 方法预加载了用户的订单数据，并将结果保存到 users 变量中。这样，当查询用户数据时，相关的订单数据也会一并加载到内存中，以提高查询效率。

8. 钩子函数

在 GORM 中，钩子函数可以在数据库操作的不同阶段执行自定义的逻辑，常见的钩子函数包括创建前钩子、更新前钩子、删除前钩子和查询后钩子。

8.1 创建前钩子

在 GORM 中，创建前钩子可以使用 BeforeCreate() 方法。下面是一个示例，展示了如何在 GORM 中使用创建前钩子：

import "gorm.io/gorm"

type Product struct {
    gorm.Model
    Name  string
    Price float64
}

func (p *Product) BeforeCreate(tx *gorm.DB) (err error) {
    // 在创建记录之前执行的逻辑
    return nil
}

在这个示例中，我们定义了一个名为 BeforeCreate() 的方法，接收一个 *gorm.DB 类型的参数 tx，用于在创建记录之前执行自定义的逻辑。在方法中，我们可以对要创建的记录进行一些处理，例如设置默认值、生成唯一标识等。

8.2 更新前钩子

在 GORM 中，更新前钩子可以使用 BeforeUpdate() 方法。下面是一个示例，展示了如何在 GORM 中使用更新前钩子：

func (p *Product) BeforeUpdate(tx *gorm.DB) (err error) {
    // 在更新记录之前执行的逻辑
    return nil
}

在这个示例中，我们定义了一个名为 BeforeUpdate() 的方法，接收一个 *gorm.DB 类型的参数 tx，用于在更新记录之前执行自定义的逻辑。在方法中，我们可以对要更新的记录进行一些处理，例如记录修改时间、记录修改者等。

8.3 删除前钩子

在 GORM 中，删除前钩子可以使用 BeforeDelete() 方法。下面是一个示例，展示了如何在 GORM 中使用删除前钩子：

func (p *Product) BeforeDelete(tx *gorm.DB) (err error) {
    // 在删除记录之前执行的逻辑
    return nil
}

在这个示例中，我们定义了一个名为 BeforeDelete() 的方法，接收一个 *gorm.DB 类型的参数 tx，用于在删除记录之前执行自定义的逻辑。在方法中，我们可以对要删除的记录进行一些处理，例如级联删除相关联的记录等。

8.4 查询后钩子

在 GORM 中，查询后钩子可以使用 AfterFind() 方法。下面是一个示例，展示了如何在 GORM 中使用查询后钩子：

func (p *Product) AfterFind(tx *gorm.DB) (err error) {
    // 在查询记录之后执行的逻辑
    return nil
}

在这个示例中，我们定义了一个名为 AfterFind() 的方法，接收一个 *gorm.DB 类型的参数 tx，用于在查询记录之后执行自定义的逻辑。在方法中，我们可以对查询结果进行一些处理，例如格式化数据、计算额外字段等。

9. 数据库迁移

数据库迁移是指在应用程序的开发过程中，对数据库结构进行版本控制和管理的过程。在 GORM 中，可以使用迁移工具来创建、执行和回滚数据库迁移。

9.1 创建迁移

在 GORM 中，创建迁移可以使用 AutoMigrate() 方法。下面是一个示例，展示了如何在 GORM 中创建迁移：

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

type Product struct {
    gorm.Model
    Name  string
    Price float64
}

func main() {
    // 连接数据库
    dsn := "user:password@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }
    
    // 创建迁移
    db.AutoMigrate(&Product{})
}

在这个示例中，我们首先定义了一个名为 Product 的模型结构体，用于表示数据库中的产品表。然后，我们使用 AutoMigrate() 方法创建了一个迁移，它会根据模型结构体自动创建对应的数据库表。

9.2 执行迁移

在 GORM 中，执行迁移可以使用 Migrator().AutoMigrate() 方法。下面是一个示例，展示了如何在 GORM 中执行迁移：

func main() {
    // ...

    // 执行迁移
    migrator := db.Migrator()
    migrator.AutoMigrate(&Product{})
}

在这个示例中，我们首先获取了一个 Migrator 对象，然后使用 AutoMigrate() 方法执行了迁移，它会根据模型结构体自动创建对应的数据库表。

9.3 回滚迁移

在 GORM 中，回滚迁移可以使用 Migrator().Rollback() 方法。下面是一个示例，展示了如何在 GORM 中回滚迁移：

func main() {
    // ...

    // 回滚迁移
    migrator := db.Migrator()
    migrator.Rollback()
}

在这个示例中，我们首先获取了一个 Migrator 对象，然后使用 Rollback() 方法回滚了最近的一个迁移操作。

10. 总结

总的来说，GORM 是一个功能强大、易于使用的数据库 ORM 框架，能够有效地提高开发效率，减少重复劳动，是开发 Web 应用程序的理想选择。