160 lines
3.9 KiB
Go
160 lines
3.9 KiB
Go
package model
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"game/common/proto/pb"
|
||
"game/common/serialization"
|
||
"game/common/utils"
|
||
"github.com/fox/fox/log"
|
||
"github.com/go-redis/redis/v8"
|
||
"gorm.io/gorm"
|
||
"time"
|
||
)
|
||
|
||
const (
|
||
TableExpire = 7 * 24 * time.Hour // 七天后过期
|
||
)
|
||
|
||
type resultT[T any] struct {
|
||
ret T
|
||
//err error
|
||
}
|
||
|
||
type iTable interface {
|
||
GetId() uint
|
||
TableName() string
|
||
}
|
||
|
||
/*
|
||
T:Table，如果不想操作redis则将rds设置为nil
|
||
*/
|
||
type TableOp[T iTable] struct {
|
||
db *gorm.DB
|
||
rds *redis.Client
|
||
}
|
||
|
||
func NewTableOp[T iTable](db *gorm.DB, rds *redis.Client) *TableOp[T] {
|
||
return &TableOp[T]{db: db, rds: rds}
|
||
}
|
||
|
||
func (s *TableOp[T]) tableName() string {
|
||
var result resultT[T]
|
||
return result.ret.TableName()
|
||
}
|
||
|
||
func (s *TableOp[T]) redisKey(id uint) string {
|
||
return fmt.Sprintf("%s:%d", s.tableName(), id)
|
||
}
|
||
|
||
func (s *TableOp[T]) findByRedis(id uint) *T {
|
||
if s.rds == nil {
|
||
return nil
|
||
}
|
||
maps, err := s.rds.HGetAll(context.Background(), s.redisKey(id)).Result()
|
||
if err != nil {
|
||
log.ErrorF("redis-key:%v HGetAll err: %v", s.redisKey(id), err)
|
||
return nil
|
||
}
|
||
if len(maps) == 0 {
|
||
return nil
|
||
}
|
||
var result resultT[T]
|
||
us, err := serialization.MapStringToStruct[T](maps)
|
||
if err != nil {
|
||
log.ErrorF("serialization map to struct err: %v", err)
|
||
return nil
|
||
}
|
||
log.DebugF("findByRedis redis-key:%v result:%v", s.redisKey(id), us)
|
||
return &result.ret
|
||
}
|
||
|
||
func (s *TableOp[T]) writeRedis(id uint, t *T) {
|
||
if s.rds == nil {
|
||
return
|
||
}
|
||
maps := serialization.StructToMap(t)
|
||
if len(maps) == 0 {
|
||
log.ErrorF("table struct is empty:%v", s.tableName())
|
||
}
|
||
s.updateRedis(id, maps)
|
||
}
|
||
|
||
func (s *TableOp[T]) updateRedis(id uint, maps map[string]any) {
|
||
if s.rds == nil {
|
||
return
|
||
}
|
||
if err := s.rds.HMSet(context.Background(), s.redisKey(id), maps).Err(); err != nil {
|
||
log.ErrorF("redis-key:%v HMSet err: %v", s.redisKey(id), err)
|
||
}
|
||
_ = s.rds.Expire(context.Background(), s.redisKey(id), TableExpire).Err()
|
||
}
|
||
|
||
func (s *TableOp[T]) deleteRedis(id uint) {
|
||
if s.rds == nil {
|
||
return
|
||
}
|
||
_ = s.rds.Del(context.Background(), s.redisKey(id)).Err()
|
||
}
|
||
|
||
func (s *TableOp[T]) Create(t *T) (*T, pb.ErrCode) {
|
||
if err := s.db.Create(t).Error; err != nil {
|
||
log.ErrorF("create table:%v err:%v", s.tableName(), err)
|
||
return nil, pb.ErrCode_SystemErr
|
||
}
|
||
s.writeRedis((*t).GetId(), t)
|
||
return t, pb.ErrCode_OK
|
||
}
|
||
|
||
func (s *TableOp[T]) Find(id uint) (*T, pb.ErrCode) {
|
||
// 先从redis中查询，redis中没有则从mysql中查询
|
||
if table := s.findByRedis(id); table != nil {
|
||
return table, pb.ErrCode_OK
|
||
}
|
||
var result resultT[T]
|
||
err := s.db.Where("id = ?", id).First(&result.ret).Error
|
||
if err != nil {
|
||
log.DebugF("find table:%v id:%v err:%v", s.tableName(), id, err)
|
||
return nil, pb.ErrCode_SystemErr
|
||
}
|
||
return &result.ret, pb.ErrCode_OK
|
||
}
|
||
|
||
// 根据条件查询，只在mysql中查询，无法在redis中查询
|
||
func (s *TableOp[T]) FindCondition(condition map[string]any) (*T, error) {
|
||
var result resultT[T]
|
||
err := s.db.Where(condition).First(&result.ret).Error
|
||
if err != nil {
|
||
log.ErrorF("find table:%v condition:%v err:%v", s.tableName(), utils.JsonMarshal(condition), err)
|
||
return nil, err
|
||
}
|
||
// 查看redis中是否存在该键，不存在则写入数据
|
||
exist, _ := s.rds.Exists(context.Background(), s.redisKey(result.ret.GetId())).Result()
|
||
if exist != 1 {
|
||
s.writeRedis(result.ret.GetId(), &result.ret)
|
||
}
|
||
return &result.ret, nil
|
||
}
|
||
|
||
func (s *TableOp[T]) Update(id uint, updates map[string]any) (*T, pb.ErrCode) {
|
||
var result resultT[T]
|
||
err := s.db.Model(&result.ret).Where("id = ?", id).Updates(updates).Error
|
||
if err != nil {
|
||
log.ErrorF("update table:%v id:%v err:%v", s.tableName(), id, err)
|
||
return nil, pb.ErrCode_SystemErr
|
||
}
|
||
s.updateRedis(id, updates)
|
||
return &result.ret, pb.ErrCode_OK
|
||
}
|
||
|
||
func (s *TableOp[T]) Delete(id uint) (*T, pb.ErrCode) {
|
||
var result resultT[T]
|
||
err := s.db.Delete(&result.ret, id).Error
|
||
if err != nil {
|
||
log.ErrorF("delete table:%v err:%v", s.tableName(), err)
|
||
return nil, pb.ErrCode_SystemErr
|
||
}
|
||
s.deleteRedis(id)
|
||
return &result.ret, pb.ErrCode_OK
|
||
}
|