/**
 * 令牌桶限流算法（工業(yè)界標準）
 * 優(yōu)點：允許突發(fā)流量，同時能平滑限流，兼顧性能和靈活性
 * 缺點：實現(xiàn)稍復雜
 */
public class TokenBucketRateLimiter {
    // 令牌桶容量（最大突發(fā)請求數(shù)）
    private final int capacity;
    // 令牌生成速度（每秒生成的令牌數(shù)，即限流QPS）
    private final double tokenRate;
    // 當前令牌數(shù)
    private double currentTokens;
    // 上次生成令牌的時間戳
    private long lastTokenTime;
    public TokenBucketRateLimiter(int capacity, double tokenRate) {
        this.capacity = capacity;
        this.tokenRate = tokenRate;
        // 初始時桶是滿的
        this.currentTokens = capacity;
        this.lastTokenTime = System.currentTimeMillis();
    }
    /**
     * 嘗試獲取令牌
     * @return true-獲取成功（允許請求），false-獲取失敗（限流）
     */
    public synchronized boolean tryAcquire() {
        return tryAcquire(1);
    }
    /**
     * 嘗試獲取指定數(shù)量的令牌
     * @param permits 需要獲取的令牌數(shù)
     * @return true-獲取成功，false-獲取失敗
     */
    public synchronized boolean tryAcquire(int permits) {
        if (permits <= 0 || permits > capacity) {
            return false;
        }
        long currentTime = System.currentTimeMillis();
        // 1. 計算從上次生成令牌到現(xiàn)在應(yīng)該生成的令牌數(shù)
        double generatedTokens = (currentTime - lastTokenTime) / 1000.0 * tokenRate;
        // 2. 更新當前令牌數(shù)（不能超過桶的容量）
        currentTokens = Math.min(capacity, currentTokens + generatedTokens);
        lastTokenTime = currentTime;
        // 3. 判斷是否有足夠的令牌
        if (currentTokens >= permits) {
            currentTokens -= permits;
            return true;
        }
        return false;
    }
    // 測試用例
    public static void main(String[] args) throws InterruptedException {
        // 令牌桶容量10，每秒生成5個令牌（即限流QPS=5，最大突發(fā)10個請求）
        TokenBucketRateLimiter limiter = new TokenBucketRateLimiter(10, 5);
        // 模擬15個突發(fā)請求
        System.out.println("===== 突發(fā)15個請求 =====");
        for (int i = 0; i < 15; i++) {
            final int requestId = i;
            new Thread(() -> {
                if (limiter.tryAcquire()) {
                    System.out.println("請求" + requestId + "：成功");
                } else {
                    System.out.println("請求" + requestId + "：被限流");
                }
            }).start();
        }
        // 等待1秒，令牌桶會補充5個令牌
        Thread.sleep(1000);
        System.out.println("===== 1秒后 =====");
        // 再發(fā)10個請求
        for (int i = 15; i < 25; i++) {
            final int requestId = i;
            new Thread(() -> {
                if (limiter.tryAcquire()) {
                    System.out.println("請求" + requestId + "：成功");
                } else {
                    System.out.println("請求" + requestId + "：被限流");
                }
            }).start();
        }
    }
}

用戶請求 → 進入被@RateLimit標記的方法 → AOP切面攔截 → 調(diào)用Lua腳本執(zhí)行限流判斷
→ 通過：執(zhí)行原方法
→ 不通過：執(zhí)行降級方法 / 拋出異常

/**
 * 限流注解
 * 用于方法級別的限流控制，支持多維度組合限流
 *
 * @see RateLimitAspect
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {

    /**
     * 限流維度枚舉
     */
    enum Dimension {
        /**
         * 全局限流：對所有請求統(tǒng)一限流
         */
        GLOBAL,
        /**
         * IP限流：按客戶端IP地址限流
         */
        IP,
        /**
         * 用戶限流：按用戶ID限流
         */
        USER
    }

    /**
     * 限流維度配置
     * 支持多維度組合，只有所有維度都滿足條件時才允許請求通過
     * 例如：{Dimension.GLOBAL, Dimension.USER} 表示同時進行全局限流和用戶級限流
     *
     * @return 限流維度數(shù)組
     */
    Dimension[] dimensions() default {Dimension.GLOBAL};

    /**
     * 在指定時間窗口內(nèi)允許的最大請求數(shù)
     * 例如：count = 10, interval = 1, timeUnit = MINUTES 表示每分鐘最多 10 次
     *
     * @return 令牌總數(shù)
     */
    double count();

    /**
     * 時間窗口大小
     * 默認 1
     *
     * @return 時間窗口
     */
    long interval() default 1;

    /**
     * 時間單位
     * 默認為秒，即默認“每秒 count 次”
     *
     * @return 時間單位
     */
    TimeUnit timeUnit() default TimeUnit.SECONDS;

    /**
     * 等待令牌的超時時間
     * 如果設(shè)置為0，表示不等待，直接獲取令牌，失敗則拒絕
     * 如果大于0，會嘗試等待指定時間獲取令牌
     *
     * @return 超時時間
     */
    long timeout() default 0;

    /**
     * 降級方法名
     * 當限流觸發(fā)時，調(diào)用指定方法進行降級處理
     * 降級方法支持：
     * 1. 無參方法
     * 2. 與原方法參數(shù)列表完全一致的方法
     * 降級方法必須在同一個類中，返回值類型與原方法兼容
     * 如果為空字符串，則拋出 RateLimitExceededException 異常
     *
     * @return 降級方法名
     */
    String fallback() default "";

    /**
     * 時間單位枚舉
     */
    enum TimeUnit {
        MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS
    }
}

---@diagnostic disable: undefined-global
-- 原子化多維度限流腳本
-- 基于令牌桶算法實現(xiàn)，支持多維度組合限流
-- 只有所有維度都滿足條件時才扣減令牌，確保原子性

-- 參數(shù)說明：
-- KEYS[1..N]: 限流維度鍵列表
-- ARGV[1]: 當前時間戳（毫秒）
-- ARGV[2]: 申請令牌數(shù)
-- ARGV[3]: 時間窗口（毫秒）
-- ARGV[4]: 最大令牌數(shù)（窗口內(nèi)允許的總數(shù)）
-- ARGV[5]: 請求唯一標識

local now_ms = tonumber(ARGV[1])
local permits = tonumber(ARGV[2])
local interval = tonumber(ARGV[3])
local max_tokens = tonumber(ARGV[4])
local request_id = ARGV[5]

-- 第一階段：預(yù)檢查階段 - 檢查所有維度是否有足夠令牌
for i, key in ipairs(KEYS) do
    local value_key = key .. ":value"
    local permits_key = key .. ":permits"

    -- 初始化 value_key（如果不存在）
    if redis.call("exists", value_key) == 0 then
        redis.call("set", value_key, max_tokens)
    end

    -- 回收過期令牌
    -- 清理過期的 permit 記錄，并回收配額到 value_key
    local expired_values = redis.call("zrangebyscore", permits_key, 0, now_ms - interval)
    if #expired_values > 0 then
        local expired_count = 0
        for _, v in ipairs(expired_values) do
            -- 優(yōu)化解析邏輯：使用更高效的模式匹配
            local p = tonumber(string.match(v, ":(%d+)$"))
            if p then
                expired_count = expired_count + p
            end
        end

        -- 刪除過期記錄
        redis.call("zremrangebyscore", permits_key, 0, now_ms - interval)

        -- 回收配額
        if expired_count > 0 then
            local curr_v = tonumber(redis.call("get", value_key) or max_tokens)
            local next_v = math.min(max_tokens, curr_v + expired_count)
            redis.call("set", value_key, next_v)
        end
    end

    -- 核心檢查：當前可用令牌是否足夠
    local current_val = tonumber(redis.call("get", value_key) or max_tokens)
    if current_val < permits then
        -- 任何一個維度配額不足，直接返回失敗
        return 0
    end
end

-- 第二階段：扣減階段 - 只有所有維度都通過后才執(zhí)行
for i, key in ipairs(KEYS) do
    local value_key = key .. ":value"
    local permits_key = key .. ":permits"

    -- 記錄本次令牌分配（格式：request_id:permits）
    local permit_record = request_id .. ":" .. permits
    redis.call("zadd", permits_key, now_ms, permit_record)

    -- 扣減令牌
    local current_v = tonumber(redis.call("get", value_key) or max_tokens)
    redis.call("set", value_key, current_v - permits)

    -- 設(shè)置過期時間，確保過期令牌能被正?；厥?(窗口的2倍，至少1秒)
    local expire_time = math.ceil(interval * 2 / 1000)
    if expire_time < 1 then expire_time = 1 end
    redis.call("expire", value_key, expire_time)
    redis.call("expire", permits_key, expire_time)
end

-- 成功獲取所有維度的令牌
return 1

/**
 * 限流 AOP 切面
 * 實現(xiàn)基于令牌桶算法的多維度限流
 */
@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
public class RateLimitAspect {
    private final RedissonClient redissonClient;
    //Lua 腳本緩存
    private static String LUA_SCRIPT;
    private String luaScriptSha;
    static {
        try {
            ClassPathResource resource = new ClassPathResource("rate_limit.lua");
            LUA_SCRIPT = new String(resource.getContentAsByteArray(), StandardCharsets.UTF_8);
        } catch (IOException e) {
            throw new RuntimeException("加載限流 Lua 腳本失敗", e);
        }
    }
    //初始化：預(yù)加載腳本到 Redis 提高性能
    @PostConstruct
    public void init() {
        this.luaScriptSha = redissonClient.getScript(StringCodec.INSTANCE).scriptLoad(LUA_SCRIPT);
        log.info("限流 Lua 腳本加載完成, SHA1: {}", luaScriptSha);
    }
    //環(huán)繞通知：攔截帶 @RateLimit 注解的方法
    @Around("@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        String className = method.getDeclaringClass().getSimpleName();
        String methodName = method.getName();
        // 1. 計算時間窗口（毫秒）
        long intervalMs = calculateIntervalMs(rateLimit.interval(), rateLimit.timeUnit());
        // 2. 根據(jù)配置維度動態(tài)生成 Redis Keys
        List<String> keys = generateKeys(className, methodName, rateLimit.dimensions());
        // 3. 調(diào)用 Lua 腳本執(zhí)行原子限流
        // 使用 StringCodec 確保參數(shù)正確傳遞為字符串
        RScript script = redissonClient.getScript(StringCodec.INSTANCE);
        // 準備參數(shù)
        List<Object> keysList = new ArrayList<>(keys);
        Object[] args = {
                String.valueOf(System.currentTimeMillis()), // ARGV[1]: 當前時間戳
                String.valueOf(1),                          // ARGV[2]: 申請令牌數(shù)（默認1個）
                String.valueOf(intervalMs),                 // ARGV[3]: 時間窗口
                String.valueOf(rateLimit.count()),          // ARGV[4]: 最大令牌數(shù)
                UUID.randomUUID().toString()               // ARGV[5]: 請求唯一標識
        };
        Object resultObj = script.evalSha(
                RScript.Mode.READ_WRITE,
                luaScriptSha,
                RScript.ReturnType.VALUE,
                keysList,
                args
        );
        // 將結(jié)果轉(zhuǎn)換為 Long
        Long result = convertToLong(resultObj);
        // 4. 處理限流結(jié)果
        if (result == null || result == 0) {
            return handleRateLimitExceeded(joinPoint, rateLimit, keys);
        }
        // 5. 執(zhí)行原方法
        return joinPoint.proceed();
    }
    //計算時間窗口毫秒數(shù)
    private long calculateIntervalMs(long interval, RateLimit.TimeUnit unit) {
        return switch (unit) {
            case MILLISECONDS -> interval;
            case SECONDS -> interval * 1000;
            case MINUTES -> interval * 60 * 1000;
            case HOURS -> interval * 3600 * 1000;
            case DAYS -> interval * 86400 * 1000;
        };
    }
    //將結(jié)果對象安全轉(zhuǎn)換為 Long
    private Long convertToLong(Object obj) {
        if (obj == null) {
            return null;
        }
        if (obj instanceof Long) {
            return (Long) obj;
        } else if (obj instanceof Integer) {
            return ((Integer) obj).longValue();
        } else if (obj instanceof Short) {
            return ((Short) obj).longValue();
        } else if (obj instanceof Byte) {
            return ((Byte) obj).longValue();
        } else if (obj instanceof String) {
            try {
                return Long.parseLong((String) obj);
            } catch (NumberFormatException e) {
                log.warn("無法將字符串轉(zhuǎn)換為Long: {}", obj);
                return null;
            }
        }
        log.warn("不支持的對象類型轉(zhuǎn)換為Long: {}", obj.getClass().getName());
        return null;
    }
    //生成限流鍵列表
    private List<String> generateKeys(String className, String methodName, RateLimit.Dimension[] dimensions) {
        List<String> keys = new ArrayList<>();
        // 使用 {} 包含類名和方法名作為 Hash Tag，確保該方法的所有限流 Key 落在同一個 Redis Slot
        // 從而適配 Redis Cluster 模式
        String hashTag = "{" + className + ":" + methodName + "}";
        String keyPrefix = "ratelimit:" + hashTag;
        for (RateLimit.Dimension dimension : dimensions) {
            switch (dimension) {
                case GLOBAL -> keys.add(keyPrefix + ":global");
                case IP -> keys.add(keyPrefix + ":ip:" + getClientIp());
                case USER -> keys.add(keyPrefix + ":user:" + getCurrentUserId());
            }
        }
        return keys;
    }
    //處理限流超出情況
    private Object handleRateLimitExceeded(ProceedingJoinPoint joinPoint, RateLimit rateLimit, List<String> keys)
            throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        // 如果配置了降級方法，則調(diào)用降級方法
        if (rateLimit.fallback() != null && !rateLimit.fallback().isEmpty()) {
            try {
                Method fallbackMethod = findFallbackMethod(joinPoint, rateLimit.fallback());
                if (fallbackMethod != null) {
                    log.debug("限流觸發(fā)，執(zhí)行降級方法: {}.{} -> {}",
                            joinPoint.getTarget().getClass().getSimpleName(),
                            methodName,
                            rateLimit.fallback());
                    // 如果降級方法有參數(shù)，傳入原方法的參數(shù)
                    if (fallbackMethod.getParameterCount() > 0) {
                        return fallbackMethod.invoke(joinPoint.getTarget(), joinPoint.getArgs());
                    } else {
                        return fallbackMethod.invoke(joinPoint.getTarget());
                    }
                }
            } catch (Exception e) {
                log.error("降級方法執(zhí)行失敗: {}", rateLimit.fallback(), e);
            }
        }
        // 沒有降級方法或降級失敗，拋出限流異常
        log.debug("限流觸發(fā)，拒絕請求: keys={}, count={} per {} {}",
                keys, rateLimit.count(), rateLimit.interval(), rateLimit.timeUnit());
        throw new BusinessException("請求過于頻繁，請稍后再試");
    }
    /**
     * 查找降級方法
     * 優(yōu)先查找與原方法參數(shù)列表完全一致的方法，找不到則查找無參方法
     */
    private Method findFallbackMethod(ProceedingJoinPoint joinPoint, String fallbackName) {
        Class<?> targetClass = joinPoint.getTarget().getClass();
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Class<?>[] parameterTypes = signature.getParameterTypes();
        try {
            // 1. 嘗試查找同參數(shù)列表的方法
            Method method = targetClass.getDeclaredMethod(fallbackName, parameterTypes);
            method.setAccessible(true);
            return method;
        } catch (NoSuchMethodException e) {
            // 2. 嘗試查找無參方法
            try {
                Method method = targetClass.getDeclaredMethod(fallbackName);
                method.setAccessible(true);
                return method;
            } catch (NoSuchMethodException ex) {
                log.warn("未找到降級方法: {}.{} (需無參或參數(shù)列表一致)",
                        targetClass.getSimpleName(), fallbackName);
                return null;
            }
        }
    }
    /**
     * 獲取客戶端真實 IP
     * 處理 X-Forwarded-For 頭，支持代理服務(wù)器場景
     */
    private String getClientIp() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes == null) {
            return "unknown";
        }
        HttpServletRequest request = attributes.getRequest();
        String ip = request.getHeader("X-Forwarded-For");
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
        }
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        // 處理多個 IP 的情況（X-Forwarded-For 可能包含多個 IP）
        if (ip != null && ip.contains(",")) {
            ip = ip.split(",")[0].trim();
        }
        return ip != null ? ip : "unknown";
    }
    /**
     * 獲取當前用戶 ID
     * 從請求屬性或 Session 中獲取
     */
    private String getCurrentUserId() {
        UserVO user = UserHolder.getUser();

        if (user != null) {
            return user.getId().toString();
        }
        return "anonymous";
    }
}

// 每分鐘最多5次請求，同時做用戶級限流，觸發(fā)限流時調(diào)用fallback方法
@RateLimit(
    dimensions = {RateLimit.Dimension.USER},
    count = 5,
    interval = 1,
    timeUnit = RateLimit.TimeUnit.MINUTES,
    fallback = "seckillFallback"
)
public ResponseDTO<String> seckillFosterCoupon(Long couponId) {
    //業(yè)務(wù)邏輯
}

// 降級方法（和原方法參數(shù)一致）
public ResponseDTO<String> seckillFallback(Long couponId) {
    return ResponseDTO.fail("您的請求過于頻繁，請稍后再試");
}