SpringBoot 项目使用 Redis 对方法进行接口限流

一、思考

1. 如何防止接口被恶意打击（短时间内大量请求）
2. 如何限制接口规定时间内访问次数

二、解决方法

1. 使用 String结构 记录固定时间段内某用户IP访问某接口的次数

• RedisKey = prefix : className : methodName
• RedisVlue = 访问次数

拦截请求:

1. 初次访问时设置 [RedisKey] [RedisValue=1] [规定的过期时间]
2. 获取 RedisValue 是否超过规定次数，超过则拦截，未超过则对 RedisKey 进行加1

分析: 规则是每分钟访问 1000 次

1. 考虑并发问题
   • 假设目前 RedisKey => RedisValue 为 999
   • 目前大量请求进行到第一步( 获取Redis请求次数 )，那么所有线程都获取到了值为999，进行判断都未超过限定次数则不拦截，导致实际次数超过 1000 次
   • 解决办法: 保证方法执行原子性（加锁、lua）
2. 考虑在临界值进行访问
   • 思考下图

代码实现: 比较简单（可参考若依代码 gitee.com/y_project/R... ）

2. 使用 Zset 进行存储，解决临界值访问问题

• RedisKey = prefix : className : methodName
• RedisScore = 时间搓
• RedisValue = 任意分布式不重复的值即可

如果开发者只能配置单个规则，可以使用

// 删除 score 在 【min ~ max】 中的 member
Zremrangebyscore [key] [min] [max]
// 统计某个key的member总数
ZCARD [key]

如果开发者需要配置多个规则，则需要可能需要的命令

// 统计在 score 在 【min ~ max】之前的个数 （用于判断多个规则）
ZCOUNT [key] [min] [max]
// 删除 score 在 【min ~ max】 中的 member （删除超过最长时间的数据）
Zremrangebyscore [key] [min] [max]

以下以 lua 代码进行编写

• KEYS[1] = prefix : ? : className : methodName
• KEYS[2] = 唯一ID
• KEYS[3] = 当前时间
• ARGV = [次数，单位时间，次数，单位时间, 次数, 单位时间 ...]

-- 1. 获取参数
local key = KEYS[1]
local uuid = KEYS[2]
local currentTime = tonumber(KEYS[3])
-- 2. 以数组最大值为 ttl 最大值
local expireTime = -1;
-- 3. 遍历数组查看是否越界
for i = 1, #ARGV, 2 do
    local rateRuleCount = tonumber(ARGV[i])
    local rateRuleTime = tonumber(ARGV[i + 1])
    -- 3.1 判断在单位时间内访问次数
    local count = redis.call('ZCOUNT', key, currentTime - rateRuleTime, currentTime)
    -- 3.2 判断是否超过规定次数
    if tonumber(count) >= rateRuleCount then
        return true
    end
    -- 3.3 判断元素最大值，设置为最终过期时间
    if rateRuleTime > expireTime then
        expireTime = rateRuleTime
    end
end
-- 4. redis 中添加当前时间
redis.call('ZADD', key, currentTime, uuid)
-- 5. 更新缓存过期时间
redis.call('PEXPIRE', key, expireTime)
-- 6. 删除最大时间限度之前的数据，防止数据过多
redis.call('ZREMRANGEBYSCORE', key, 0, currentTime - expireTime)
return false

以下为第二种lua脚本编写方式

• KEYS[1] = prefix : ? : className : methodName
• KEYS[2] = 当前时间
• ARGV = [次数，单位时间，次数，单位时间, 次数, 单位时间 ...]

以下为第二种实现方式，在并发高的情况下效率低，value是通过时间搓进行添加，但是访问量大的话会使得一直在调用 redis.call('ZADD', key, currentTime, currentTime)，但是在不冲突value的情况下，会比生成 UUID 好

-- 1. 获取参数
local key = KEYS[1]
local currentTime = KEYS[2]
-- 2. 以数组最大值为 ttl 最大值
local expireTime = -1;
-- 3. 遍历数组查看是否越界
for i = 1, #ARGV, 2 do
    local rateRuleCount = tonumber(ARGV[i])
    local rateRuleTime = tonumber(ARGV[i + 1])
    -- 3.1 判断在单位时间内访问次数
    local count = redis.call('ZCOUNT', key, currentTime - rateRuleTime, currentTime)
    -- 3.2 判断是否超过规定次数
    if tonumber(count) >= rateRuleCount then
        return true
    end
    -- 3.3 判断元素最大值，设置为最终过期时间
    if rateRuleTime > expireTime then
        expireTime = rateRuleTime
    end
end
-- 4. 更新缓存过期时间
redis.call('PEXPIRE', key, expireTime)
-- 5. 删除最大时间限度之前的数据，防止数据过多
redis.call('ZREMRANGEBYSCORE', key, 0, currentTime - expireTime)
-- 6. redis 中添加当前时间  ( 解决多个线程在同一毫秒添加相同 value 导致 Redis 漏记的问题 )
-- 6.1 maxRetries 最大重试次数 retries 重试次数
local maxRetries = 5
local retries = 0
while true do
    local result = redis.call('ZADD', key, currentTime, currentTime)
    if result == 1 then
        -- 6.2 添加成功则跳出循环
        break
    else
        -- 6.3 未添加成功则 value + 1 再次进行尝试
        retries = retries + 1
        if retries >= maxRetries then
            -- 6.4 超过最大尝试次数 采用添加随机数策略
            local random_value = math.random(1, 1000)
            currentTime = currentTime + random_value
        else
            currentTime = currentTime + 1
        end
    end
end

return false

第一次编写文章，有很多写的不好的地方请大家指出，java代码👉 RateLimiterAspect.java

转载请附带本文链接