使用 Go 反射机制封装 Gorm 分页功能

2022年4月9日 469点热度 0人点赞 0条评论

【导读】本文介绍了作者封装 gorm 分页功能的实现。

1 需求

在前后端分离项目中分页是非常常见的需求，最近在使用Gin重构SpringBoot项目，整合的orm框架是Gorm。然而Golang生态相对来Java说比较灵活（低情商：简陋），很多东西都需要自己封装。网上查了一圈Gorm的分页方案感觉都不是自己需要的，因此打算使用Gorm封装一个类似Mybatis-Plus的分页方案，可以对实现类似“泛型”查询的效果。由于用到了Golang的反射机制，映像比较深刻所以在这里记录一下。

第4小节提出的方法已经能正常实现分页功能，只不过存在一点冗余代码。第6小节提出的方法使用到了反射来解决冗余，但是反射存在性能问题，不在乎冗余的话使用第4小节的封装方法就行了

2 项目结构

本次的Demo结构如下，搭建了一个小型的Gin项目，打算对MySQL 8中内置world数据库中的国家和城市表进行分页查询。database中是数据库的初始化，通用分页查询逻辑的底层封装；model中记录了city、country表对应的结构体及条件查询结构体；service中是具体的业务查询逻辑；main.go中只有两个路由，一个是分页查询城市的路由，一个是分页查询国家的路由。完整代码见GitHub （https://github.com/yafeng-Soong/blog-example）

|——gorm_page
|    |——database
|        |——mysql.go   // 初始化及分页底层封装
|        |——model.go  // pageResponse结构体
|    |——model
|        |——city.go  // city表对应结构体
|        |——country.go  // country表对应结构体
|        |——page.go  // 分页条件 
|    |——service
|        |——city.go
|        |——country.go
|    |——go.mod
|    |——go.sum
|    |——main.go

3 结构体

city结构体包含城市名、国家代码、地区省份和人口数，country结构体包含代码、国家名、所属大陆和地区、建国时间。pageInfo结构体指明了查询的当前分页与分页大小，会嵌套进city和country对应的结构体中。city可以使用国家代码、地区省份作为查询条件，country可以使用所属大陆、区域、建国时间作为查询条件。Page结构体返回给前端，记录了总记录数、总页数等信息。

type PageInfo struct {
    CurrentPage int64 `json:"currentPage"`
    PageSize    int64 `json:"pageSize"`
} // 分页条件

type City struct {
    ID          int    `json:"id"`
    Name        string `json:"name"`
    CountryCode string `json:"countryCode"`
    District    string `json:"district"`
    Population  int    `json:"population"`
} // city表结构体

type CityQueryInfo struct {
    PageInfo
    CountryCode string `json:"countryCode"`
    District    string `json:"district"`
} // city查询条件

type Country struct {
    Code      string `json:"code"`
    Name      string `json:"name"`
    Continent string `json:"continent"`
    Region    string `json:"region"`
    IndepYear int    `json:"indepYear"`
} // country表结构体

type CountryQueryInfo struct {
    PageInfo
    Continent string `json:"continent"`
    Region    string `json:"region"`
    IndepYear int    `json:"indepYear"`
} // country查询条件

type Page struct {
    CurrentPage int64       `json:"currentPage"`
    PageSize    int64       `json:"pageSize"`
    Total       int64       `json:"total"` // 总记录数
    Pages       int64       `json:"pages"` // 总页数
    Data        interface{} `json:"data"` // 实际的list数据
} // 分页response返回给前端

4 存在冗余的Gorm分页封装

4.1 Gorm官方的分页示例

Gorm官方提供了简单的分页分装，如下所示。但实际使用过程中我们的业务是比较复杂的，比如我们希望得到总页数pages、记录总数total，这么简单的封装不能满足我们的需求。

// gorm官方的分页实例
func Paginate(r *http.Request) func(db *gorm.DB) *gorm.DB {
    return func (db *gorm.DB) *gorm.DB {
        page, _ := strconv.Atoi(r.Query("page"))
        if page == 0 {
            page = 1
        }    
        pageSize, _ := strconv.Atoi(r.Query("page_size"))
        switch {
        case pageSize > 100:
            pageSize = 100
        case pageSize <= 0:
            pageSize = 10
        }

        offset := (page - 1) * pageSize
        return db.Offset(offset).Limit(pageSize)
        }
}
db.Scopes(Paginate(r)).Find(&users)
db.Scopes(Paginate(r)).Find(&articles)

4.2 封装额外的分页信息

尝试自己封装一下额外的分页信息，首先在cityModel中编写CountAll和SelectList函数，用以查询总记录数和list数据。并扩展Paginate，可以获取到pages、total等信息，并对边界进行限制。

package model

import (
    "gorm_page/database"

    "gorm.io/gorm"
)

type City struct {
    ID          int    `json:"id"`
    Name        string `json:"name"`
    CountryCode string `json:"countryCode"`
    District    string `json:"district"`
    Population  int    `json:"population"`
}
// wrapper中包含查询条件，service传过来
func (c *City) CountAll(wrapper map[string]interface{}) int64 {
    var total int64
    database.DB.Model(&City{}).Where(wrapper).Count(&total)
    return total
}

func (c *City) SelectList(p *database.Page, wrapper map[string]interface{}) error {
    list := []City{}
    if err := database.DB.Model(&City{}).Scopes(Paginate(p)).Where(wrapper).Find(&list).Error; err != nil {
        return err
    }
    p.Data = list
    return nil
}

func Paginate(page *database.Page) func(db *gorm.DB) *gorm.DB {
    return func(db *gorm.DB) *gorm.DB {
        if page.CurrentPage <= 0 {
            page.CurrentPage = 0
        } // 当前页小于0则置为0
        switch {
        case page.PageSize > 100:
            page.PageSize = 100
        case page.PageSize <= 0:
            page.PageSize = 10
        } // 限制size大小
        page.Pages = page.Total / page.PageSize
        if page.Total%page.PageSize != 0 {
            page.Pages++
        } // 计算总页数
        p := page.CurrentPage
        if page.CurrentPage > page.Pages {
            p = page.Pages
        } // 若当前页大于总页数则使用总页数
        size := page.PageSize
        offset := int((p - 1) * size)
        return db.Offset(offset).Limit(int(size)) // 设置limit和offset
    }
}

4.3 Service中调用分页

首先从CityQueryInfo中取出查询条件设置到wrapper中，再调用cityModel的CountAll得到记录总数，如果为0直接返回（节约时间）。然后再调用SelelctList将实际的list数据保存到Page的Data字段中。

package service

import (
    "gorm_page/database"
    "gorm_page/model"
)

type CityService struct{}

var cityModel model.City

func (c *CityService) SelectPageList(p *database.Page, queryVo model.CityQueryInfo) error {
    p.CurrentPage = queryVo.CurrentPage
    p.PageSize = queryVo.PageSize
    wrapper := make(map[string]interface{}, 0)
    if queryVo.CountryCode != "" {
        wrapper["CountryCode"] = queryVo.CountryCode
    }
    if queryVo.District != "" {
        wrapper["District"] = queryVo.District
    }
    p.Total = cityModel.CountAll(wrapper)
    if p.Total == 0 {
        return nil // 若记录总数为0直接返回，不再执行Limit查询
    }
    return cityModel.SelectList(p, wrapper)
}

4.4 冗余代码

以上封装方法虽然能运行，但是并不完美，当需要分页查询的对象很多时，会存在许多冗余代码。比如我再按照上面的方法对country的分页查询进行封装，就会得到以下的冗余代码。可以看到CountAll、SelectList这些函数中不同的部分只有类型而已，若有10个对象需要分页查询，那么这两个函数就要重复10次。那么有没有什么办法简化一下，只写一次CountAll和SelectList呢？

// model/city.go中的冗余代码
func (c *City) CountAll(wrapper map[string]interface{}) int64 {
    var total int64
    database.DB.Model(&City{}).Where(wrapper).Count(&total)
    return total
}
func (c *City) SelectList(p *database.Page, wrapper map[string]interface{}) error {
    list := []City{}
    if err := database.DB.Model(&City{}).Scopes(Paginate(p)).Where(wrapper).Find(&list).Error; err != nil {
        return err
    }
    p.Data = list
    return nil
}

// model/country.go中的冗余代码
func (c *Country) CountAll(wrapper map[string]interface{}) int64 {
    var total int64
    database.DB.Model(&Country{}).Where(wrapper).Count(&total)
    return total
}
func (c *Country) SelectList(p *database.Page, wrapper map[string]interface{}) error {
    list := []Country{}
    if err := database.DB.Model(&Country{}).Scopes(Paginate(p)).Where(wrapper).Find(&list).Error; err != nil {
        return err
    }
    p.Data = list
    return nil
}

5 Mybatis-Plus中的分页

在简化Gorm的分页封装前，我们先来看看Spring中的分页。Spring中用得最多的ORM框架是Mybatis，其分页功能需要使用额外的分页插件，基本原理是使用拦截器拦截SQL语句并加上Limit、Offset条件。Mybatis-Plus则整合了分页插件，使用起来非常简单，只需要新建对应的Page对象和QueryWrapper对象，传给mapper层的selectPage方法即可。selectPage是BaseMapper中继承而来的，对UserMapper和CityMapper是透明的。selectPage执行完毕后当前页currentPage、记录总数total、总页数pages以及记录列表list都保存在了Page对象中。

// 查询用户分页
public Page<User> selectPageList(UserQueryVo queryVo) {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("career", queryVo.getCareer());
    queryWrapper.orderByDesc("update_time");
    Page<User> page = new Page<>(queryVo.getCurrentPage(), queryVo.getPageSize());
    return userMapper.selectPage(page, queryWrapper);
}
// 查询城市分页
public Page<City> selectPageList(CityQueryVo queryVo) {
    QueryWrapper<City> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("country", queryVo.getCountry()); // 按国家查找城市
    queryWrapper.orderByDesc("update_time");
    Page<User> page = new Page<>(queryVo.getCurrentPage(), queryVo.getPageSize());
    return cityMapper.selectPage(page, queryWrapper);
}

从上面得代码中我们可以看到 Mybatis-Plus中对分页代码的复用使用到了Java的泛型机制，然而Golang要等到1.18版本发布后才能支持泛型。那么现阶段有没有什么办法再golang中实现类似泛型的效果呢？答案是反射机制

6 使用反射来简化分页封装

仔细观察4.4中的冗余代码可以发现DB.Model()和DB.Find()中的参数与具体的类型相关，当时想到的第一个方案是使用interface{}抽象成一下代码。但实际运行时会报错，因为Find函数内部其实还是使用了反射，它需要确定list数组元素的类型，所以不能将interface{}数组传给Find函数。

func SelectPage(p *database.Page, wrapper map[string]interface{}, model interface{}) error {
    database.DB.Model(&model).Where(wrapper).Count(&p.Total)
    if p.Total == 0 {
        p.Data = []interface{}{}
        return nil
    }
    list := []interface{}{}
    err := database.DB.Model(&model).Scopes(Paginate(p)).Where(wrapper).Find(&list).Error
        if err != nil {
        return err
    }
    p.Data = list
    return nil
}

既然Find函数要使用反射获取数组元素的类型，那么我们就在传参之前将通过反射从model参数中获取具体的参数类型，再通过反射创建出对应类型的数组，代码如下：

func SelectPage(page *Page, wrapper map[string]interface{}, model interface{}) (e error) {
    e = nil
    DB.Model(&model).Where(wrapper).Count(&page.Total)
    if page.Total == 0 {
        page.Data = []interface{}{}
        return
    }
    // 反射获得类型
    t := reflect.TypeOf(model)
    // 再通过反射创建创建对应类型的数组
    list := reflect.Zero(reflect.SliceOf(t)).Interface()
    e = DB.Model(&model).Where(wrapper).Scopes(Paginate(page)).Find(&list).Error
    if e != nil {
        return
    }
    page.Data = list
    return
}

通过反射创建对应类型的数组还可以写成这样：

list := reflect.MakeSlice(reflect.SliceOf(t), 0, 0).Interface()

调用分页封装函数，可以看到在City和Country的结构体方法中只剩下了调用SelelctPage这一行相同代码，通过第三个参数指明了具体的查询结构体。

// model/city.go中调用分页
func (c *City) SelectPageList(p *database.Page, wrapper map[string]interface{}) error {
    err := database.SelectPage(p, wrapper, City{}) // 指明查询City
    return err
}

// model/country.go中调用分页
func (c *Country) SelectPageList(p *database.Page, wrapper map[string]interface{}) error {
    err := database.SelectPage(p, wrapper, Country{}) // 指明查询Country
    return err
}

7 测试运行

完整项目代码见我的Github示例（https://github.com/yafeng-Soong/blog-example），输入go run main.go运行Demo程序，这里使用Postman进行分别对city、country两个接口发起分页查询，得到如下结果。可以看到response中的有pages、total等信息，且data中的list数据正常，表明底层封装的SelectPage函数可以通过反射查询到不同的对象。

8 总结

Golang相对于Java体系来说更灵活，许多东西都要动手自己封装，这里只是简单示范了一下使用反射来做分页，但是反射存在一定的性能问题。并且Demo中的查询条件使用的是map传递，这样只能传递相等的查询条件，对于有like、大于小于条件的情况可以使用DB来传递：

query := database.DB.Model(&Country{}).Where(wrapper)
query = query.Where("IndepYear > ?", 1949) // 设置大于条件
database.SelectPage(p, query, Country{})
// SelectPage函数修改为如下
func SelectPage(page *Page, query *gorm.DB, model interface{}) (e error) {
        e = nil
    query.Model(&model).Count(&page.Total)
    if page.Total == 0 {
        page.Data = []interface{}{}
        return
    }
    // 反射获得类型
    t := reflect.TypeOf(model)
    // 再通过反射创建创建对应类型的数组
    list := reflect.Zero(reflect.SliceOf(t)).Interface()
    e = query.Model(&model).Scopes(Paginate(page)).Find(&list).Error
    if e != nil {
        return
    }
    page.Data = list
    return
}