golang通过结构体的继承、重写封装的一个高复用的公用查询

前言

在golang开发中会发现,没有泛型会写大量重复代码,例如:对数据库表分页查询时,大多情况是表名不同,查询条件与查询字段不同,正常情况下,就得写多份重叠代码。本文主要是对过结构体继承(其实是组合),模拟泛型(用interface类型),来封装业务层的公用查询逻辑。
其中会用到gorm查询时不固定定条件查询,可以看我另一篇博文go语言对gorm不固定条件查询封装

思路

1. 既然要公用,那就得定义一个baseservice.go文件,别的业务继承basebaseservice.go
2. 继承后,如何重写父结构体的方法,以及父结构体的方法如何调用子结构体的方法,来实现高复用性
3. 因为不支持泛型,在gorm查询时,所需结构体就得用interface,试想gorm本身就是一个公用查询框架,传入interface,然后用reflect反射等到数据。

代码

• 父结构体及业务逻辑:baseservice.go

package services
import (
 "encoding/json"
 "github.com/go-redis/redis/v7"
 "github.com/jinzhu/gorm"
 "math"
 "reflect"
 "strconv"
 "time"
 "weichai/app/cache"
 "weichai/app/models/entity"
 "weichai/pkg/utils"
)
type BaseService struct {
 // 要操作的model结构体[必须为指针类型的结构体*slice]
 Model interface{} //model必须是指针
 CachePrefix string //缓存的前缀
 // 不同的业务,有不同的库查询逻辑,所以抽象此方法,让子结构体来实现。默认方法 queryList
 QueryList func(wheres interface{}, columns interface{}, orderBy interface{}, page, rows int, total *int) (list interface{}, err error)
}
// model必须是指针
func NewBaseService(model interface{}, cachePrefix string) *BaseService {
 bs := &BaseService{}
 bs.Model = model
 bs.CachePrefix = cachePrefix
 // 赋值默认方法
 bs.QueryList = bs.queryList
 return bs
}
// 根据id返回数据
// 返回值 nil|*struct{} ,当err不为nil|没有找到记录时,返回值=nil
func (service *BaseService) GetById(id int) (interface{}, error) {
 db := entity.DB
 model := service.GetNewModel()
 err := db.Where("id = ?", id).First(model, id).Error
 if err != nil && err != gorm.ErrRecordNotFound {
 return nil, err
 } else if err == gorm.ErrRecordNotFound {
 return nil, nil
 }
 return model, nil
}
// 根据查询条件返回列表数据[会走缓存]
// 返回值 list:nil|*[]*struct{} ,当err不为nil时,list=nil
func (service *BaseService) List(wheres interface{}, columns interface{}, orderBy interface{}, page, rows int, total *int) (list interface{}, err error) {
 vb, err := json.Marshal([]interface{}{wheres, columns, orderBy, page, rows})
 if err != nil {
 return nil, err
 }
 pkey := utils.GetMd5String(string(vb))
 prefix := service.CachePrefix
 ckey := prefix + "_list:" + pkey
 ckey_total := prefix + "_list_total:" + pkey
 _total, err := cache.Get(ckey_total)
 if err == nil {
 _t, err := strconv.Atoi(_total)
 if err == nil {
 *total = _t
 if math.Ceil(float64(_t/rows)) < float64(page) {
 list = service.GetNewModelSlice()
 return list, nil
 }
 }
 }
 data, err := cache.Get(ckey)
 is_cache_data := false
 if err == redis.Nil || err != nil {
 // 防止缓存穿透,需要加锁 【只有ckey相同时,才会互斥锁】
 lock := utils.MultipleMutex.Lock(ckey)
 data, err = cache.Get(ckey)
 if err == redis.Nil || err != nil {
 if service.QueryList == nil {
 service.QueryList = service.queryList
 }
 list, err = service.QueryList(wheres, columns, orderBy, page, rows, total)
 if err == nil {
 exp := time.Second * 30 //在实际开发中,可以把过期时间放到结构体中,让子结构体赋值
 _, _ = cache.Set(ckey, list, exp)
 _, _ = cache.Set(ckey_total, total, exp)
 //set出错,上报
 } else {
 utils.MultipleMutex.Unlock(lock)
 return nil, err
 }
 } else {
 is_cache_data = true
 }
 utils.MultipleMutex.Unlock(lock)
 } else {
 is_cache_data = true
 }
 if is_cache_data {
 list = service.GetNewModelSlice()
 err := json.Unmarshal(([]byte)(data), list)
 if err != nil {
 return nil, err
 }
 }
 return list, err
}
// 根据查询条件返回列表数据[直接查库]
// 返回值 list:nil|*[]*struct{} ,当err不为nil时,list=nil
func (service *BaseService) queryList(wheres interface{}, columns interface{}, orderBy interface{}, page, rows int, total *int) (list interface{}, err error) {
 db := entity.DB
 list = service.GetNewModelSlice()
 db, err = entity.BuildQueryList(db, wheres, columns, orderBy, page, rows)
 if err != nil {
 return nil, err
 }
 err = db.Find(list).Error
 if err != nil {
 return nil, err
 }
 db = entity.DB
 db, err = entity.BuildWhere(db, wheres)
 if err != nil {
 return nil, err
 }
 db.Model(service.GetNewModel()).Count(total)
 return list, nil
}
// 获取新的struct,返回值 *struct{}
func (service *BaseService) GetNewModel() interface{} {
 t := reflect.TypeOf(service.Model)
 m := t.Elem()
 return reflect.Indirect(reflect.New(m)).Addr().Interface()
}
// 获取新的struct切片,返回值 *[]*struct{}
func (service *BaseService) GetNewModelSlice() interface{} {
 t := reflect.TypeOf(service.Model)
 // return reflect.Indirect(reflect.New(reflect.SliceOf(t))).Addr().Interface()
 list := reflect.New(reflect.SliceOf(t)).Elem()
 list.Set(reflect.MakeSlice(list.Type(), 0, 0))
 return reflect.Indirect(list).Addr().Interface()
}

代码说明:

主要实现功能:定义BaseService结构体,抽象出QueryList方法[子结构体实现抽象方法],List分页查询方法[包含redis缓存],反射出gorm查询数据时所需结构体

1. BaseService 结构体:创建一个BaseService结构体系,Model属性是 在gorm查询时所用到的结构体,这里必须为指针类型的结构体*slice,因应后面反射结构体时用到。
   (1). QueryList方法:此方法是对外提供的一个方法,方便子结构实现不同业务查询。queryList方法是一个公用库查询方法,只是简单的做单表查询,并不包含关联查询,如果有关联查询、预加载或特殊业务逻辑,子结构体就要单独实现
2. List 方法:公用分页查询方法,这个方法会走缓存。
   (1). cache:基于go-redis封装的缓存包,后面会贴出代码
   (2). utils.MultipleMutex:封装的多个互斥锁,只有key相同时,才会互斥锁,后面会贴出代码
3. queryList 方法:数据库查询逻辑。方法的参数,entity.DB,与entity.BuildQueryList方法,具体请看go语言对gorm不固定条件查询封装这篇博文。
4. GetNewModel 方法:根据BaseService里的Model属性,反射生成一个新的结构体,返回的是个指针
5. GetNewModelSlice 方法:根据BaseService里的Model属性,反射生成一个新的切片结构体,返回的是切片指针
   说明:baseservice.go只实现了部分公用方法,在实际开发中,公用逻辑远比这多,可以根据自己业务需求来做相应的封装

• 子结构体:user.go

package user
import (
 "github.com/jinzhu/gorm"
 "weichai/app/models/entity"
 userModel "weichai/app/models/user"
 "weichai/app/services"
)
type userService struct {
 *services.BaseService // 组合BaseService结构体,实现继承
}
// 必须是指针 &userModel.User{}
var _bs = services.NewBaseService(&userModel.User{}, "user")
var _us = &userService{BaseService: _bs}
func NewUserService() *userService {
 // 给父结构体的QueryList方法赋值,来达到重写需求【由于golang不是OOP,所以'重写'也不能达到重写,父结构体是没有办法直接调用重写的方法的,所以要通过在结构体中定义方法,子结构体给它赋值】
 _bs.QueryList = _us.QueryList
 return _us
}
/*// 重写(覆盖)父结构体的List方法,来实现特殊需求
func (service *userService) List(wheres interface{}, columns interface{}, orderBy interface{}, page, rows int, total *int) (list interface{}, err error) {
 // 调用父的List: service.BaseService.List()
 return nil, nil
}*/
// 实现抽象方法,来实现特殊业务,此方法包含了 关联查询的预加载逻辑
func (service *userService) QueryList(wheres interface{}, columns interface{}, orderBy interface{}, page, rows int, total *int) (list interface{}, err error) {
 db := entity.DB
 var model []*userModel.User
 var mod userModel.User
 db, err = entity.BuildQueryList(db, wheres, columns, orderBy, page, rows)
 if err != nil {
 return nil, err
 }
 err = db.Preload("UserCard", func(db *gorm.DB) *gorm.DB {
 return db.Order("created_at asc")
 }).Find(&model).Error
 db = entity.DB
 db, err = entity.BuildWhere(db, wheres)
 if err != nil {
 return nil, err
 }
 db.Model(&mod).Count(total)
 return &model, nil
}

• 在controller里查询用户列表

func List(ctx *gin.Context) {
 total := 0
 where := []interface{}{
 []interface{}{"id", "in", []int{1, 2}},
 }
 //var wg sync.WaitGroup
 //wg.Add(2)
 //测试多协程查询时加锁
 /*go func() {
 bll := userService.NewUserService()
 list, _ := bll.BaseService.List(where, []string{"*"}, "id desc", 1, 1, &total)
 list = list.(*[]*user.User)
 wg.Done()
 }()
 go func() {
 bll := userService.NewUserService()
 _, _ = bll.BaseService.List(where, []string{"*"}, "id desc", 1, 1, &total)
 wg.Done()
 }()*/
 bll := userService.NewUserService()
 res, _ := bll.List(where, []string{"*"}, "id desc", 1, 1, &total)
 list := res.(*[]*user.User)
 //wg.Wait()
 ctx.JSON(http.StatusOK, utils.Result(result.OK, map[string]interface{}{
 "list": list, "total": total,
 }, ""))
}

其它代码

• utils.MultipleMutex所用到代码文件

逻辑也比较简单,根据相同的key返回sync.Mutex的指针,并存储在map里;在Unlock时,删除map的值
不同的key会返回不同的sync.Mutex,所以在应用时不会锁住资源,达到并发需求

package utils
import (
 "sync"
)
var MultipleMutex = &multipleMutex{
 keys: map[string]*lock{},
 keyMutex: &sync.Mutex{},
}
type multipleMutex struct {
 keys map[string]*lock
 keyMutex *sync.Mutex
}
type lock struct {
 key *string
 mutex *sync.Mutex
}
func (mm *multipleMutex) Lock(key string) *lock {
 mm.keyMutex.Lock()
 mutex, ok := mm.keys[key]
 if !ok {
 mutex = &lock{
 key: &key,
 mutex: new(sync.Mutex),
 }
 mm.keys[key] = mutex
 }
 mm.keyMutex.Unlock()
 mutex.mutex.Lock()
 return mutex
}
func (mm *multipleMutex) Unlock(lock *lock) {
 key := lock.key
 mm.keyMutex.Lock()
 mutex, ok := mm.keys[*key]
 if ok && mutex == lock {
 // 删除map的key,如果有引用lock,是不会触发GC的,所以别的协程执行后面的lock.mutex.Unlock()不会有问题
 delete(mm.keys, *key)
 }
 mm.keyMutex.Unlock()
 lock.mutex.Unlock()
}

• cache用到的代码文件

package cache
import (
 "encoding/json"
 "reflect"
 "time"
 "weichai/pkg/redis"
)
func Set(key string, val interface{}, expire time.Duration) (ok bool, err error) {
 kind := reflect.TypeOf(val).Kind()
 var v interface{}
 switch kind {
 case reflect.Interface, reflect.Map, reflect.Slice, reflect.Struct, reflect.Array, reflect.Ptr:
 vb, err := json.Marshal(val)
 if err != nil {
 return false, err
 }
 v = string(vb)
 default:
 v = val
 }
 res, err := redis.RedisClient.Set(redis.CreateKey(key), v, expire).Result()
 return res == "OK", err
}
func Get(key string) (val string, err error) {
 return redis.RedisClient.Get(redis.CreateKey(key)).Result()
}
// redis用的是 github.com/go-redis/redis/v7,redis.CreateKey(key)返回一个加了前缀的key。这些代码就不贴了

总结

代码模拟了结构体的继承,重写,抽象方法来实现一个高复用的公用查询逻辑,在开发过程中能节省不少的代码量,使代码更整洁

本文来自:简书

感谢作者:_老七

查看原文:golang通过结构体的继承、重写封装的一个高复用的公用查询

• 编辑
• 预览