149.Go实现个性化配置限频操作

一、需求描述

有时候我们在做某个功能的时候，是需要个性化限频的。比如某个活动，时间为一年，但是需要限制用户每周，每月，或者动态周期内能获得的权益次数。如下

二、代码实现

下面是一个使用Go实现的个性化配置限频系统，支持每自然周、每自然月、固定时间周期和动态周期的限频功能。我们将使用Redis来存储计数器和配置。

注：代码中注释会提到，这里提示一下。

1. 实际工作中应该是用户在前端页面配置个性化限频信息，然后后端使用JSON（结构体）存到DB中，在执行的时候，按照限频信息严格控制限频，这里为了演示简单，直接用Redis写死了限频的次数信息
2. 增加计数器和过期时间，为了保证原子性，使用lua脚本会更好一些。

package main

import (
	"context"
	"fmt"
	"strconv"
	"time"

	"github.com/go-redis/redis/v8"
)

// Redis客户端
var redisClient *redis.Client

// 初始化Redis客户端
func initRedisClient() {
	redisClient = redis.NewClient(&redis.Options{
		Addr:     "localhost:6379", // Redis服务器地址
		Password: "",               // 密码
		DB:       0,                // 数据库编号
	})
}

// 从Redis获取配置
// 实际工作中应该是用户在前端页面配置，然后后端使用JSON（结构体）存到DB中的限频元信息
// 这里为了演示简单，直接用Redis写死了限频的次数信息
func getConfigFromRedis(key string) (int, error) {
	ctx := context.Background()
	val, err := redisClient.Get(ctx, key).Result()
	if err == redis.Nil {
		return 0, fmt.Errorf("key does not exist")
	} else if err != nil {
		return 0, err
	}
	return strconv.Atoi(val)
}

// 增加计数器
// 使用lua脚本更合适一些，保证原子性
func incrementCounter(key string) (int, error) {
	ctx := context.Background()
	return redisClient.Incr(ctx, key).Result()
}

// 检查是否超过限制
func isWithinLimit(key string, limit int) (bool, error) {
	ctx := context.Background()
	count, err := redisClient.Get(ctx, key).Int()
	if err == redis.Nil {
		return true, nil
	} else if err != nil {
		return false, err
	}
	return count < limit, nil
}

// 获取当前周期的Redis键
func getRedisKey(period string) string {
	switch period {
	case "weekly":
		year, week := time.Now().ISOWeek()
		return fmt.Sprintf("weekly_limit_%d_%d", year, week)
	case "monthly":
		return fmt.Sprintf("monthly_limit_%d_%d", time.Now().Year(), time.Now().Month())
	case "fixed":
		// 这里key应该拼上开始和结束时间戳,时间参数需要修改
		return fmt.Sprintf("fixed_limit_%d_%d", time.Now().Unix(), time.Now().Unix())
	case "dynamic":
			// zset,如近30天，应该按分数保留最近30天的元素，分数就是时间戳
		return fmt.Sprintf("dynamic_limit_%d", 30)
	default:
		return ""
	}
}

// 检查并增加计数器
func checkAndIncrementCounter(key string, limit int) (bool, error) {
	if withinLimit, err := isWithinLimit(key, limit); err != nil {
		return false, err
	} else if withinLimit {
		if count, err := incrementCounter(key); err != nil {
			return false, err
		} else {
			fmt.Printf("计数器增加成功，当前计数: %d\n", count)
			return true, nil
		}
	} else {
		fmt.Println("限制已达到")
		return false, nil
	}
}

func main() {
	// 初始化Redis客户端
	initRedisClient()

	// 从Redis获取配置值
	weeklyLimit, err := getConfigFromRedis("weekly_limit")
	if err != nil {
		fmt.Println("获取每周配置失败:", err)
		return
	}
	monthlyLimit, err := getConfigFromRedis("monthly_limit")
	if err != nil {
		fmt.Println("获取每月配置失败:", err)
		return
	}
	fixedLimit, err := getConfigFromRedis("fixed_limit")
	if err != nil {
		fmt.Println("获取固定周期配置失败:", err)
		return
	}
	dynamicLimit, err := getConfigFromRedis("dynamic_limit")
	if err != nil {
		fmt.Println("获取动态周期配置失败:", err)
		return
	}

	// 示例：检查并增加每周的计数器
	weeklyKey := getRedisKey("weekly")
	if ok, err := checkAndIncrementCounter(weeklyKey, weeklyLimit); err != nil {
		fmt.Println("检查并增加每周计数器失败:", err)
	} else if !ok {
		fmt.Println("每周限制已达到")
	}

	// 示例：检查并增加每月的计数器
	monthlyKey := getRedisKey("monthly")
	if ok, err := checkAndIncrementCounter(monthlyKey, monthlyLimit); err != nil {
		fmt.Println("检查并增加每月计数器失败:", err)
	} else if !ok {
		fmt.Println("每月限制已达到")
	}

	// 示例：检查并增加固定周期的计数器
	fixedKey := getRedisKey("fixed")
	if ok, err := checkAndIncrementCounter(fixedKey, fixedLimit); err != nil {
		fmt.Println("检查并增加固定周期计数器失败:", err)
	} else if !ok {
		fmt.Println("固定周期限制已达到")
	}

	// 示例：检查并增加动态周期的计数器
	dynamicKey := getRedisKey("dynamic")
	if ok, err := checkAndIncrementCounter(dynamicKey, dynamicLimit); err != nil {
		fmt.Println("检查并增加动态周期计数器失败:", err)
	} else if !ok {
		fmt.Println("动态周期限制已达到")
	}
}

代码解释：

1. Redis客户端初始化：
   • initRedisClient函数用于初始化Redis客户端。
   • redisClient是一个全局变量，用于与Redis服务器进行交互。
2. 从Redis获取配置：
   • getConfigFromRedis函数用于从Redis中获取配置值，并将其转换为整数。
   • 使用redisClient.Get方法从Redis中获取指定键的值。
3. 增加计数器：
   • incrementCounter函数用于增加指定键的计数器。
   • 使用redisClient.Incr方法增加计数器的值。
4. 检查是否超过限制：
   • isWithinLimit函数用于检查指定键的计数器是否超过限制。
   • 使用redisClient.Get方法获取当前计数器的值，并与限制值进行比较。
5. 获取当前周期的Redis键：
   • getRedisKey函数根据不同的周期生成对应的Redis键。
   • 每周的键格式为weekly_limit__。
   • 每月的键格式为monthly_limit__。
   • 固定周期的键为fixed_limit_startTime_endTime。
   • 动态周期的键格式为dynamic_limit_Xdays。
6. 检查并增加计数器：
   • checkAndIncrementCounter函数用于检查指定键的计数器是否超过限制，并在未超过限制时增加计数器。

三、配置化能力

通过Redis，可以将任务触发条件和限制次数等配置存储在Redis中，从而实现配置化能力。例如，可以将每个周期的限制次数存储在Redis中，并在任务执行前从Redis中获取配置值。

示例配置

假设在Redis中存储以下配置：

weekly_limit: 3
monthly_limit: 3
fixed_limit: 3
dynamic_limit: 3

在任务执行前，可以从Redis中获取这些配置值，并根据配置值来决定是否执行任务。

示例代码（获取配置值）

func main() {
	// 初始化Redis客户端
	initRedisClient()

	// 从Redis获取配置值
	weeklyLimit, err := getConfigFromRedis("weekly_limit")
	if err != nil {
		fmt.Println("获取每周配置失败:", err)
		return
	}
	monthlyLimit, err := getConfigFromRedis("monthly_limit")
	if err != nil {
		fmt.Println("获取每月配置失败:", err)
		return
	}
	fixedLimit, err := getConfigFromRedis("fixed_limit")
	if err != nil {
		fmt.Println("获取固定周期配置失败:", err)
		return
	}
	dynamicLimit, err := getConfigFromRedis("dynamic_limit")
	if err != nil {
		fmt.Println("获取动态周期配置失败:", err)
		return
	}

	// 示例：检查并增加每周的计数器
	weeklyKey := getRedisKey("weekly")
	if ok, err := checkAndIncrementCounter(weeklyKey, weeklyLimit); err != nil {
		fmt.Println("检查并增加每周计数器失败:", err)
	} else if !ok {
		fmt.Println("每周限制已达到")
	}

	// 示例：检查并增加每月的计数器
	...

总结

上述代码只是给了一个大致实现的思路，还需要不断的完善才可以投入使用。