GF框架中分表处理的实践与优化方案

2025-05-19 05:54:06作者：卓炯娓

引言

在大型应用系统中，随着数据量的不断增长，单表存储往往会遇到性能瓶颈。分表(Sharding)是一种常见的数据库优化手段，通过将数据分散到多个表中来提高查询效率。本文将详细介绍在GF框架中实现分表处理的几种方案，包括基于用户ID取模的分表策略和基于时间维度的分表策略。

基于用户ID取模的分表实现

分表原理

基于用户ID取模的分表策略是一种常见的水平分表方法。具体实现是将用户ID对分表数量取模，根据余数决定数据存储在哪个表中。例如，有10张分表(game_best_0到game_best_9)，用户ID为12345的记录将存储在game_best_5中(12345%10=5)。

实现步骤

DAO层改造：在GF框架中，首先通过gf gen dao命令生成基础DAO代码，然后对internal/dao/internal/game_best.go文件进行改造：

type GameBestDao struct {
    table      string          // 基础表名(不含数字后缀)
    group      string          // 数据库配置组名
    columns    GameBestColumns // 表字段定义
    tableCount int             // 分表数量
}

// 设置实际表名
func (dao *GameBestDao) setTable(uid int) string {
    remainder := uid % dao.tableCount
    return dao.table + strconv.Itoa(remainder)
}

// 带分表参数的Ctx方法
func (dao *GameBestDao) Ctx(ctx context.Context, uid int) *gdb.Model {
    return dao.DB().Model(dao.setTable(uid)).Safe().Ctx(ctx)
}

DO层改造：在internal/model/do/game_best.go中定义所有分表的结构体，并提供一个工厂方法根据用户ID返回对应的DO对象：

// 定义基础字段结构
type GameBestBase struct {
    Uid     interface{}
    Money   interface{}
    // 其他字段...
}

// 定义各分表结构
type GameBest0 struct {
    g.Meta `orm:"table:game_best_0, do:true"`
    GameBestBase
}
// 定义GameBest1到GameBest9...

// 工厂方法
func CreateAndSetGameBest(uid int, in GameBestBase) (any, error) {
    GameBestType := fmt.Sprintf("GameBest%d", uid%10)
    if GameBest, ok := GameBestMap[GameBestType]; ok {
        // 使用反射设置字段值
        val := reflect.ValueOf(GameBest).Elem()
        val.FieldByName("Uid").Set(reflect.ValueOf(in.Uid))
        // 设置其他字段...
        return GameBest, nil
    }
    return nil, fmt.Errorf("不支持的GameBest类型")
}

业务层使用：在业务逻辑中，通过传入用户ID来操作对应的分表：

func CreateGameUserInfo(ctx context.Context, in model.GameLoginInput, uid int) error {
    userinfo, err := do.CreateAndSetUserInfo(uid, do.UserInfoBase{
        Uid: uid,
        // 其他字段初始化...
    })
    if err != nil {
        return err
    }

    return dao.UserInfo.Transaction(ctx, uid, func(ctx context.Context, tx gdb.TX) error {
        _, err = dao.UserInfo.Ctx(ctx, uid).Data(userinfo).Insert()
        return err
    })
}

基于时间维度的分表实现

分表原理

基于时间的分表策略适用于有明显时间特征的数据，如订单、日志等。常见的分表粒度包括年表(order_2024)、月表(order_202404)、周表(order_202434)和日表(order_20240425)。

实现方案

DAO层通用实现：与基于用户ID的方案类似，但表名后缀为时间字符串而非数字：

func (dao *OrderDao) setTable(timeSuffix string) string {
    return dao.table + timeSuffix
}

func (dao *OrderDao) Ctx(ctx context.Context, timeSuffix string) *gdb.Model {
    return dao.DB().Model(dao.setTable(timeSuffix)).Safe().Ctx(ctx)
}

定时任务与表维护：需要实现定时任务，在适当的时候创建新表。例如，每月初创建下个月的订单表：

func init() {
    // 每月1号0点检查并创建下月表
    g.Cron().Add("0 0 1 * *", func() {
        nextMonth := gtime.Now().Add(gtime.M*1).Format("200601")
        createOrderTable(nextMonth)
    })
}

func createOrderTable(month string) {
    tableName := "order_" + month
    // 检查表是否存在，不存在则创建
    if !g.DB().Table(tableName).Schema().HasTable(tableName) {
        _, err := g.DB().Exec(fmt.Sprintf(`
            CREATE TABLE %s LIKE order_template
        `, tableName))
        if err != nil {
            glog.Errorf("创建表%s失败: %v", tableName, err)
        }
    }
}

DO层动态处理：由于时间分表的表名变化较大，可以采用更灵活的方式处理DO对象：

type OrderDynamic struct {
    g.Meta 
    OrderBase
}

func NewOrderDynamic(tableSuffix string) *OrderDynamic {
    return &OrderDynamic{
        Meta: g.Meta{orm:"table:order_" + tableSuffix},
    }
}