多级泛型接口嵌套
多级泛型接口嵌套的设计模式，从基础到业务逐层扩展：
---
层级设计
IBaseDao[T] // 最基础：单实体 CRUD
↑
IGeneralDao[T, R] // 通用层：实体 + 返回类型分离
↑
IBusinessDao[T, Q, R] // 业务层：实体 + 查询条件 + 返回
↑
UserDao // 具体实现
---
第一层：IBaseDao[T]
// 基础 CRUD，T = 实体类型
type IBaseDao[T any] interface {
Insert(entity T) error
UpdateById(id int64, entity T) error
DeleteById(id int64) error
FindById(id int64) (T, error)
FindAll() ([]T, error)
}
---
第二层：IGeneralDao[T, R]
// 通用查询，T = 实体，R = 返回类型（DTO/VO）
type IGeneralDao[T any, R any] interface {
IBaseDao[T] // 嵌入基础接口
// 分页查询
QueryPage(req *pagemodel.PageRequest[T]) *pagemodel.PageResult[R]
QueryOne(req T) (*R, error)
// 转换器（可选）
SetConverter(conv pagemodel.Converter[T, R])
}
---
第三层：IBusinessDao[T, Q, R]
// 业务层，T = 实体，Q = 查询条件，R = 返回
type IBusinessDao[T any, Q any, R any] interface {
IGeneralDao[T, R] // 嵌入通用接口
// 复杂业务查询
QueryByCondition(req Q) *pagemodel.PageResult[R]
QueryByConditionOne(req Q) (*R, error)
// 统计
CountByCondition(req Q) (int64, error)
// 批量操作
BatchInsert(entities []T) error
BatchUpdate(entities []T) error
}
---
具体实现
// 实体
type User struct {
ID int64
Name string
Age int
}
// 查询条件
type UserQuery struct {
NameLike string
AgeMin int
AgeMax int
}
// 返回 DTO
type UserDTO struct {
ID string `json:"id"`
Name string `json:"name"`
Age int `json:"age"`
}
// ========== 基础 DAO 实现 ==========
type BaseDao[T any] struct {
DB *gorm.DB
}
func (d *BaseDao[T]) Insert(entity T) error {
return d.DB.Create(&entity).Error
}
func (d *BaseDao[T]) FindById(id int64) (T, error) {
var t T
err := d.DB.First(&t, id).Error
return t, err
}
// ... 其他基础方法
// ========== 通用 DAO 实现 ==========
type GeneralDao[T any, R any] struct {
BaseDao[T]
conv pagemodel.Converter[T, R]
}
func (d *GeneralDao[T, R]) QueryPage(req *pagemodel.PageRequest[T]) *pagemodel.PageResult[R] {
var list []T
var total int64
db := d.DB.Model(new(T))
// ... 构建查询
db.Count(&total)
db.Offset((req.PageCurrent - 1) * req.PageSize).Limit(req.PageSize).Find(&list)
// 转换
result := &pagemodel.PageResult[T]{
PageResult: &page.PageResult{
Total: total,
PageCurrent: req.PageCurrent,
PageSize: req.PageSize,
},
Data: list,
}
return pagemodel.PageTo(result, d.conv)
}
func (d *GeneralDao[T, R]) SetConverter(conv pagemodel.Converter[T, R]) {
d.conv = conv
}
// ========== 业务 DAO 实现 ==========
type UserDao struct {
GeneralDao[User, UserDTO] // 嵌入通用实现
}
// 实现业务层特有方法
func (d *UserDao) QueryByCondition(req UserQuery) *pagemodel.PageResult[UserDTO] {
db := d.DB.Model(&User{})
if req.NameLike != "" {
db = db.Where("name LIKE ?", "%"+req.NameLike+"%")
}
if req.AgeMin > 0 {
db = db.Where("age >= ?", req.AgeMin)
}
if req.AgeMax > 0 {
db = db.Where("age <= ?", req.AgeMax)
}
var list []User
var total int64
db.Count(&total).Find(&list)
result := &pagemodel.PageResult[User]{
PageResult: &page.PageResult{Total: total},
Data: list,
}
return pagemodel.PageTo(result, d.conv)
}
func (d *UserDao) CountByCondition(req UserQuery) (int64, error) {
var count int64
db := d.DB.Model(&User{})
// ... 条件构建
err := db.Count(&count).Error
return count, err
}
---
使用方式
// 创建 DAO
userDao := &UserDao{
GeneralDao: GeneralDao[User, UserDTO]{
BaseDao: BaseDao[User]{DB: db},
conv: pagemodel.Converter[User, UserDTO]{},
},
}
// 基础 CRUD（来自 IBaseDao）
user, err := userDao.FindById(1)
// 通用查询（来自 IGeneralDao）
result := userDao.QueryPage(&pagemodel.PageRequest[User]{
PageCurrent: 1,
PageSize: 10,
})
// 业务查询（来自 IBusinessDao）
dtoResult := userDao.QueryByCondition(UserQuery{
NameLike: "张",
AgeMin: 18,
AgeMax: 30,
})
---
接口断言与多态
// 按层级使用接口
var base IBaseDao[User] = userDao
var general IGeneralDao[User, UserDTO] = userDao
var business IBusinessDao[User, UserQuery, UserDTO] = userDao
// 函数接受不同层级接口
func UseBase[T any](dao IBaseDao[T]) { ... }
func UseGeneral[T, R any](dao IGeneralDao[T, R]) { ... }
func UseBusiness[T, Q, R any](dao IBusinessDao[T, Q, R]) { ... }
// 调用
UseBase(userDao)
UseGeneral(userDao)
UseBusiness(userDao)
---
依赖注入（godi 风格）
// 注册到容器
godi.Register(IBusinessDao[User, UserQuery, UserDTO], func() any {
return &UserDao{
GeneralDao: GeneralDao[User, UserDTO]{
BaseDao: BaseDao[User]{DB: godi.Get(*gorm.DB)},
conv: pagemodel.Converter[User, UserDTO]{},
},
}
})
// 使用
var userDao = godi.Get(IBusinessDao[User, UserQuery, UserDTO])
result := userDao.QueryByCondition(query)
---
设计要点总结
层级 泛型参数 职责 复用方式
IBaseDao[T] 1个 基础 CRUD 嵌入
IGeneralDao[T, R] 2个 分页 + 转换 嵌入 + Converter
IBusinessDao[T, Q, R] 3个 复杂业务查询 业务实现
关键技巧：
- 上层接口嵌入下层接口
- 实现结构体嵌入上层实现
- Converter[T, R] 解耦实体与 DTO
- 泛型参数逐层增加，不破坏已有代码