<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.43.0</version>
</dependency>

import lombok.Data;
import org.redisson.api.RateIntervalUnit;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
@ConfigurationProperties("rate-limit")
@Data
public class RateLimitProperties {
    private Config defaultConfig;
    private List<Config> configs;

    @Data
    public static class Config {
        private String keyPrefix;
        private long timeOut;
        private RateIntervalUnit rateIntervalUnit;
        private long count;
    }

    /**
     * 根據(jù)key獲取對應匹配的前綴的限流配置
     * @param key key
     * @return 限流配置
     */
    public Config getRateLimitConfig(String key) {
        return configs.stream()
                .filter(e -> key.startsWith(e.getKeyPrefix()))
                .findFirst()
                .orElse(defaultConfig);
    }

}

# 限流配置
rate-limit:
  # 默認限流配置，如果前綴沒有匹配上，則使用默認配置
  default-config:
    model-name-prefix: default
    time-out: 30
    rate-interval-unit: seconds
    count: 1
  configs:
    - key-prefix: test
      time-out: 1
      rate-interval-unit: seconds
      count: 2

import com.gzb.app.config.RateLimitProperties;
import com.gzb.app.constant.RedisConstant;
import org.redisson.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * 限流工具類
 */
@Component
public class RateLimitUtil {
    @Autowired
    private RateLimitProperties rateLimitProperties;
    @Autowired
    private RedissonClient redissonClient;
    
    /**
     * 嘗試獲取一個限流器許可，如果當前沒有足夠的令牌，調(diào)用線程將被阻塞，直到有足夠的令牌
     * @param key 限流器的唯一標識
     */
    public void acquire(String key) {
        getRedissonRateLimiter(key).acquire();
    }

    /**
     * 嘗試立即獲取一個限流器許可，如果當前沒有足夠的令牌，立即返回 false
     * @param key 限流器的唯一標識
     * @return 成功：true 失?。篺alse
     */
    public boolean tryAcquire(String key) {
        return getRedissonRateLimiter(key).tryAcquire();
    }

    /**
     * 嘗試在指定時間內(nèi)獲取一個限流器許可，如果在指定時間內(nèi)沒有足夠的令牌，立即返回 false
     * @param key 限流器的唯一標識
     * @param time 等待的時間長度
     * @param timeUnit 時間單位
     * @return 成功：true 失敗：false
     */
    public boolean tryAcquire(String key, long time, TimeUnit timeUnit) {
        return getRedissonRateLimiter(key).tryAcquire(time, timeUnit);
    }

    /**
     * 獲取限流器，如果限流器不存在，則根據(jù)配置創(chuàng)建一個新的限流器
     * @param key 限流器的唯一標識
     * @return RedissonRateLimiter 限流器實例
     */
    public RRateLimiter getRedissonRateLimiter(String key) {
        RateLimitProperties.Config config = rateLimitProperties.getRateLimitConfig(key);
        long count = config.getCount();
        long timeOut = config.getTimeOut();
        RateIntervalUnit rateIntervalUnit = config.getRateIntervalUnit();
        RRateLimiter rateLimiter = redissonClient.getRateLimiter(key);
        // 如果限流器不存在，就創(chuàng)建一個限流器
        if (!rateLimiter.isExists()) {
            rateLimiter.trySetRate(RateType.OVERALL, count, timeOut, rateIntervalUnit);
            return rateLimiter;
        }
        checkIfConfigNeedUpdate(rateLimiter, config);
        return rateLimiter;
    }

    /**
     * 檢查限流器配置是否發(fā)生修改，如果配置發(fā)生變化，則刪除舊的限流器并重新創(chuàng)建
     *
     * @param rateLimiter 限流器
     * @param rateLimitConfig 限流配置
     */
    private void checkIfConfigNeedUpdate(RRateLimiter rateLimiter, RateLimitProperties.Config rateLimitConfig) {
        long count = rateLimitConfig.getCount();
        long timeOut = rateLimitConfig.getTimeOut();
        RateIntervalUnit rateIntervalUnit = rateLimitConfig.getRateIntervalUnit();
        // 獲取之前限流器的配置信息
        RateLimiterConfig config = rateLimiter.getConfig();
        if (rateIntervalUnit.toMillis(timeOut) != config.getRateInterval() || count != config.getRate()) {
            // 如果當前限流器的配置與配置文件不一致，說明服務器重啟過
            rateLimiter.delete();
            // 配置文件為準，重新設置
            rateLimiter.trySetRate(RateType.OVERALL, count, timeOut, rateIntervalUnit);
        }
    }
}

@RestController
@Slf4j
public class RedissonController {
    @Autowired
    private RateLimitUtil rateLimitUtil;

    @GetMapping("/rateLimit/{key}")
    public void rateLimit(@PathVariable String key) {
        log.info("{} start get access token, current time = {}", Thread.currentThread().getName(), System.currentTimeMillis());
        rateLimitUtil.acquire(key);
        log.info("{} successfully start get access token, current time = {}", Thread.currentThread().getName(), System.currentTimeMillis());
    }
}

-- 獲取限流器的配置值：rate、interval 和 type
local rate = redis.call('hget', KEYS[1], 'rate');          -- 獲取限制速率（每秒允許的請求次數(shù)）
local interval = redis.call('hget', KEYS[1], 'interval');  -- 獲取限流的時間間隔（單位通常為秒）
local type = redis.call('hget', KEYS[1], 'type');          -- 獲取限流類型（如 OVERALL 或 PRE_WARMING）

-- 如果配置沒有初始化（即獲取的值為空），拋出錯誤
-- 這里對應著一開始要設置好限流配置參數(shù)，否則Lua腳本執(zhí)行過程會拋出異常
assert(rate ~= false and interval ~= false and type ~= false, 'RateLimiter is not initialized')

-- 當前請求令牌數(shù)的鍵
local valueName = KEYS[2];   
-- 請求令牌記錄的鍵
local permitsName = KEYS[4]; 

-- 如果限流類型是 PRE_WARMING，調(diào)整鍵值名
if type == '1' then
    valueName = KEYS[3];   -- 如果是 PRE_WARMING，則使用不同的令牌數(shù)鍵
    permitsName = KEYS[5];  -- 如果是 PRE_WARMING，則使用不同的令牌記錄鍵
end;

-- 檢查請求的令牌數(shù)是否超過了令牌桶的大小
-- 例如：rate設置為10，在acqure的時候大于10，Lua腳本就會報錯
assert(tonumber(rate) >= tonumber(ARGV[1]), 'Requested permits amount cannot exceed defined rate');

-- 獲取當前剩余可用的令牌數(shù)
local currentValue = redis.call('get', valueName);

-- 變量 res 用于存儲返回值，指示是否可以獲取令牌
-- 如果是nil表示令牌充足，獲取令牌成功
-- 如果是一個數(shù)字，則表示令牌不足，需要要等待的時間
local res;

-- 表明不是第一次獲取令牌
if currentValue ~= false then
    -- 獲取在過去一段時間內(nèi)過期的請求記錄
    local expiredValues = redis.call('zrangebyscore', permitsName, 0, tonumber(ARGV[2]) - interval);
    local released = 0;  -- 已釋放的令牌數(shù)

    -- 統(tǒng)計過期的請求記錄中的令牌數(shù)
    for i, v in ipairs(expiredValues) do
        local random, permits = struct.unpack('Bc0I', v);
        released = released + permits;
    end;

    -- 如果有過期的令牌，進行釋放處理
    if released > 0 then
        -- 從令牌記錄中移除過期的項
        redis.call('zremrangebyscore', permitsName, 0, tonumber(ARGV[2]) - interval);
        
        -- 以下if-else代碼用于保證可用的令牌個數(shù)和令牌訪問記錄中使用的令牌個數(shù)之和小于桶的容量rate
        if tonumber(currentValue) + released > tonumber(rate) then
            local values = redis.call('zrange', permitsName, 0, -1);  -- 獲取所有令牌記錄
            local used = 0;  -- 已使用的令牌數(shù)
            -- 統(tǒng)計所有已使用的令牌數(shù)
            for i, v in ipairs(values) do
                local random, permits = struct.unpack('Bc0I', v);
                used = used + permits;
            end;
            -- 調(diào)整當前令牌數(shù)，確保不會超過桶的大小
            currentValue = tonumber(rate) - used;
        else
            -- 否則，直接增加釋放的令牌數(shù)
            currentValue = tonumber(currentValue) + released;
        end;
        -- 更新令牌數(shù)
        redis.call('set', valueName, currentValue);
    end;

    -- 如果當前令牌數(shù)小于請求的令牌數(shù)，計算下一次可以獲取令牌的時間
    if tonumber(currentValue) < tonumber(ARGV[1]) then
        local firstValue = redis.call('zrange', permitsName, 0, 0, 'withscores');  -- 獲取最早的請求記錄
        res = 3 + interval - (tonumber(ARGV[2]) - tonumber(firstValue[2]));  -- 計算等待時間
    else
        -- 如果當前令牌數(shù)足夠，記錄請求并減少令牌數(shù)
        redis.call('zadd', permitsName, ARGV[2], struct.pack('Bc0I', string.len(ARGV[3]), ARGV[3], ARGV[1]));
        redis.call('decrby', valueName, ARGV[1]);
        res = nil;  -- 沒有錯誤，返回值為空
    end;
-- 如果是第一次獲取令牌，則設置當前可用的令牌數(shù)，添加訪問記錄，扣減可用令牌數(shù)量
else
    -- 設置當前可用的令牌數(shù)
    redis.call('set', valueName, rate);
    -- 新增領票訪問記錄
    redis.call('zadd', permitsName, ARGV[2], struct.pack('Bc0I', string.len(ARGV[3]), ARGV[3], ARGV[1]));
    -- 扣減可用令牌數(shù)量
    redis.call('decrby', valueName, ARGV[1]);
    -- 沒有錯誤，返回值為空，表示獲取令牌成功
    res = nil;  
end;

-- 返回結(jié)果，可能是等待時間或空值
-- 如果是nil表示令牌充足，獲取令牌成功
-- 如果是一個數(shù)字，則表示令牌不足，需要要等待的時間
return res;