import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
/**
 * 固定窗口計(jì)數(shù)器限流算法
 * 優(yōu)點(diǎn)：實(shí)現(xiàn)簡單、性能極高
 * 缺點(diǎn)：存在"臨界問題"（窗口交界處可能出現(xiàn)2倍閾值的突發(fā)流量）
 */
public class FixedWindowRateLimiter {
    // 時(shí)間窗口大?。ê撩耄?
    private final long windowSizeMs;
    // 窗口內(nèi)允許的最大請求數(shù)
    private final int maxRequests;
    // 當(dāng)前窗口的請求計(jì)數(shù)器（原子類保證線程安全）
    private final AtomicInteger counter = new AtomicInteger(0);
    // 窗口開始時(shí)間（原子類保證線程安全）
    private final AtomicLong windowStartTime = new AtomicLong(System.currentTimeMillis());
    public FixedWindowRateLimiter(long windowSizeMs, int maxRequests) {
        this.windowSizeMs = windowSizeMs;
        this.maxRequests = maxRequests;
    }
    /**
     * 嘗試獲取令牌
     * @return true-獲取成功（允許請求），false-獲取失?。ㄏ蘖鳎?
     */
    public boolean tryAcquire() {
        long currentTime = System.currentTimeMillis();
        // 1. 判斷是否進(jìn)入新窗口
        if (currentTime - windowStartTime.get() > windowSizeMs) {
            // 重置窗口：CAS操作保證只有一個(gè)線程能重置成功
            if (windowStartTime.compareAndSet(windowStartTime.get(), currentTime)) {
                counter.set(0);
            }
        }
        // 2. 原子性增加計(jì)數(shù)并判斷是否超過閾值
        return counter.incrementAndGet() <= maxRequests;
    }
    // 測試用例
    public static void main(String[] args) throws InterruptedException {
        // 1秒內(nèi)最多允許5個(gè)請求
        FixedWindowRateLimiter limiter = new FixedWindowRateLimiter(1000, 5);
        // 模擬10個(gè)并發(fā)請求
        for (int i = 0; i < 10; i++) {
            final int requestId = i;
            new Thread(() -> {
                if (limiter.tryAcquire()) {
                    System.out.println("請求" + requestId + "：成功");
                } else {
                    System.out.println("請求" + requestId + "：被限流");
                }
            }).start();
        }
        // 等待1秒后，窗口重置，再發(fā)5個(gè)請求
        Thread.sleep(1000);
        System.out.println("===== 窗口重置 =====");
        for (int i = 10; i < 15; i++) {
            final int requestId = i;
            new Thread(() -> {
                if (limiter.tryAcquire()) {
                    System.out.println("請求" + requestId + "：成功");
                } else {
                    System.out.println("請求" + requestId + "：被限流");
                }
            }).start();
        }
    }
}

import java.util.concurrent.atomic.AtomicIntegerArray;
/**
 * 滑動(dòng)窗口計(jì)數(shù)器限流算法
 * 優(yōu)點(diǎn)：解決了固定窗口的"臨界問題"，限流精度更高
 * 缺點(diǎn)：實(shí)現(xiàn)稍復(fù)雜，需要維護(hù)多個(gè)時(shí)間片的計(jì)數(shù)器
 */
public class SlidingWindowRateLimiter {
    // 總窗口大?。ê撩耄?
    private final long windowSizeMs;
    // 每個(gè)小時(shí)間片的大小（毫秒）
    private final long sliceSizeMs;
    // 時(shí)間片數(shù)量
    private final int sliceCount;
    // 每個(gè)時(shí)間片的請求計(jì)數(shù)器（原子數(shù)組保證線程安全）
    private final AtomicIntegerArray counters;
    // 上一次請求的時(shí)間戳
    private volatile long lastRequestTime;
    // 上一次請求所在的時(shí)間片索引
    private volatile int lastSliceIndex;
    public SlidingWindowRateLimiter(long windowSizeMs, int sliceCount, int maxRequests) {
        this.windowSizeMs = windowSizeMs;
        this.sliceCount = sliceCount;
        this.sliceSizeMs = windowSizeMs / sliceCount;
        this.counters = new AtomicIntegerArray(sliceCount);
        this.lastRequestTime = System.currentTimeMillis();
        this.lastSliceIndex = getCurrentSliceIndex();
    }
    /**
     * 獲取當(dāng)前時(shí)間對應(yīng)的時(shí)間片索引
     */
    private int getCurrentSliceIndex() {
        return (int) ((System.currentTimeMillis() / sliceSizeMs) % sliceCount);
    }
    /**
     * 嘗試獲取令牌
     * @return true-獲取成功，false-被限流
     */
    public synchronized boolean tryAcquire() {
        long currentTime = System.currentTimeMillis();
        int currentSliceIndex = getCurrentSliceIndex();
        // 1. 清除所有過期的時(shí)間片（滑動(dòng)窗口）
        long timePassed = currentTime - lastRequestTime;
        if (timePassed > windowSizeMs) {
            // 超過整個(gè)窗口大小，全部清零
            for (int i = 0; i < sliceCount; i++) {
                counters.set(i, 0);
            }
        } else {
            // 清除從上次請求到現(xiàn)在之間過期的時(shí)間片
            int slicesToClear = (int) (timePassed / sliceSizeMs);
            for (int i = 1; i <= slicesToClear; i++) {
                int index = (lastSliceIndex + i) % sliceCount;
                counters.set(index, 0);
            }
        }
        // 2. 計(jì)算當(dāng)前窗口內(nèi)的總請求數(shù)
        int totalRequests = 0;
        for (int i = 0; i < sliceCount; i++) {
            totalRequests += counters.get(i);
        }
        // 3. 判斷是否超過閾值
        if (totalRequests >= maxRequests) {
            return false;
        }
        // 4. 當(dāng)前時(shí)間片計(jì)數(shù)加1
        counters.incrementAndGet(currentSliceIndex);
        lastRequestTime = currentTime;
        lastSliceIndex = currentSliceIndex;
        return true;
    }
    // 測試用例
    public static void main(String[] args) throws InterruptedException {
        // 1秒窗口，劃分為10個(gè)100毫秒的時(shí)間片，最多允許5個(gè)請求
        SlidingWindowRateLimiter limiter = new SlidingWindowRateLimiter(1000, 10, 5);
        // 模擬10個(gè)請求，間隔100毫秒
        for (int i = 0; i < 10; i++) {
            final int requestId = i;
            new Thread(() -> {
                if (limiter.tryAcquire()) {
                    System.out.println("請求" + requestId + "：成功");
                } else {
                    System.out.println("請求" + requestId + "：被限流");
                }
            }).start();
            Thread.sleep(100);
        }
    }
}

/**
 * 漏桶限流算法
 * 優(yōu)點(diǎn)：可以強(qiáng)制限制請求的處理速度，輸出流量非常平穩(wěn)
 * 缺點(diǎn)：不允許突發(fā)流量，即使系統(tǒng)資源空閑也只能以固定速度處理
 */
public class LeakyBucketRateLimiter {
    // 桶的容量（最大排隊(duì)請求數(shù)）
    private final int capacity;
    // 漏水速度（每秒處理的請求數(shù)）
    private final double leakRate;
    // 當(dāng)前桶中的水量（排隊(duì)的請求數(shù)）
    private double currentWater;
    // 上次漏水的時(shí)間戳
    private long lastLeakTime;
    public LeakyBucketRateLimiter(int capacity, double leakRate) {
        this.capacity = capacity;
        this.leakRate = leakRate;
        this.currentWater = 0;
        this.lastLeakTime = System.currentTimeMillis();
    }
    /**
     * 嘗試獲取令牌
     * @return true-獲取成功（請求進(jìn)入桶中等待處理），false-被限流（桶滿）
     */
    public synchronized boolean tryAcquire() {
        long currentTime = System.currentTimeMillis();
        // 1. 計(jì)算從上次漏水到現(xiàn)在應(yīng)該漏出的水量
        double leakedWater = (currentTime - lastLeakTime) / 1000.0 * leakRate;
        // 2. 更新當(dāng)前水量（不能小于0）
        currentWater = Math.max(0, currentWater - leakedWater);
        lastLeakTime = currentTime;
        // 3. 判斷桶是否已滿
        if (currentWater < capacity) {
            currentWater += 1;
            return true;
        }
        return false;
    }
    // 測試用例
    public static void main(String[] args) throws InterruptedException {
        // 桶容量10，每秒漏水5個(gè)（即每秒處理5個(gè)請求）
        LeakyBucketRateLimiter limiter = new LeakyBucketRateLimiter(10, 5);
        // 模擬15個(gè)突發(fā)請求
        for (int i = 0; i < 15; i++) {
            final int requestId = i;
            new Thread(() -> {
                if (limiter.tryAcquire()) {
                    System.out.println("請求" + requestId + "：進(jìn)入桶中");
                } else {
                    System.out.println("請求" + requestId + "：被限流（桶滿）");
                }
            }).start();
        }
        // 等待2秒，觀察漏水效果
        Thread.sleep(2000);
        System.out.println("===== 2秒后 =====");
        // 再發(fā)5個(gè)請求
        for (int i = 15; i < 20; i++) {
            final int requestId = i;
            new Thread(() -> {
                if (limiter.tryAcquire()) {
                    System.out.println("請求" + requestId + "：進(jìn)入桶中");
                } else {
                    System.out.println("請求" + requestId + "：被限流（桶滿）");
                }
            }).start();
        }
    }
}

/**
 * 令牌桶限流算法（工業(yè)界標(biāo)準(zhǔn)）
 * 優(yōu)點(diǎn)：允許突發(fā)流量，同時(shí)能平滑限流，兼顧性能和靈活性
 * 缺點(diǎn)：實(shí)現(xiàn)稍復(fù)雜
 */
public class TokenBucketRateLimiter {
    // 令牌桶容量（最大突發(fā)請求數(shù)）
    private final int capacity;
    // 令牌生成速度（每秒生成的令牌數(shù)，即限流QPS）
    private final double tokenRate;
    // 當(dāng)前令牌數(shù)
    private double currentTokens;
    // 上次生成令牌的時(shí)間戳
    private long lastTokenTime;
    public TokenBucketRateLimiter(int capacity, double tokenRate) {
        this.capacity = capacity;
        this.tokenRate = tokenRate;
        // 初始時(shí)桶是滿的
        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. 計(jì)算從上次生成令牌到現(xiàn)在應(yīng)該生成的令牌數(shù)
        double generatedTokens = (currentTime - lastTokenTime) / 1000.0 * tokenRate;
        // 2. 更新當(dāng)前令牌數(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個(gè)令牌（即限流QPS=5，最大突發(fā)10個(gè)請求）
        TokenBucketRateLimiter limiter = new TokenBucketRateLimiter(10, 5);
        // 模擬15個(gè)突發(fā)請求
        System.out.println("===== 突發(fā)15個(gè)請求 =====");
        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秒，令牌桶會(huì)補(bǔ)充5個(gè)令牌
        Thread.sleep(1000);
        System.out.println("===== 1秒后 =====");
        // 再發(fā)10個(gè)請求
        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();
        }
    }
}

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimit {
    /**
     * 限流維度枚舉
     */
    enum Dimension {
        GLOBAL,  // 全局限流（所有請求共享一個(gè)令牌桶）
        IP,      // IP維度限流（每個(gè)IP一個(gè)令牌桶）
        USER     // 用戶維度限流（每個(gè)用戶一個(gè)令牌桶）
    }
    /**
     * 限流維度（支持組合，如同時(shí)限制全局和用戶）
     */
    Dimension[] dimensions() default {
        Dimension.GLOBAL
};
    /**
     * 時(shí)間窗口內(nèi)允許的最大請求數(shù)（即令牌桶容量）
     */
    double count();
    /**
     * 時(shí)間窗口大小
     */
    long interval() default 1;
    /**
     * 時(shí)間單位
     */
    TimeUnit timeUnit() default TimeUnit.SECONDS;
    /**
     * 降級方法名（限流時(shí)調(diào)用該方法返回結(jié)果）
     */
    String fallback() default "";
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RScript;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.annotation.PostConstruct;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
@Aspect
@Component
public class RateLimitAspect {
    @Autowired
    private RedissonClient redissonClient;
    private String luaScriptSha;
    // Lua腳本內(nèi)容（見下文）
    private static final String LUA_SCRIPT = "..."
    @PostConstruct
    public void init() {
        // 預(yù)加載 Lua 腳本到 Redis，獲取 SHA 1值，減少網(wǎng)絡(luò)傳輸開銷
        this.luaScriptSha = 
  redissonClient.getScript(StringCodec.INSTANCE).scriptLoad(LUA_SCRIPT);
    }
    @Around("@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
        // 1. 計(jì)算時(shí)間窗口（轉(zhuǎn)換為毫秒）
        long intervalMs = rateLimit.timeUnit().toMillis(rateLimit.interval());
        // 2. 獲取目標(biāo)類和方法名
        String className = joinPoint.getTarget().getClass().getName();
        String methodName = joinPoint.getSignature().getName();
        // 3. 生成限流Key（使用Hash Tag適配Redis集群）
        List<String> keys = generateKeys(className, methodName, rateLimit.dimensions());
        // 4. 構(gòu)造Lua腳本參數(shù)
        List<Object> args = new ArrayList<>();
        args.add(rateLimit.count()); // 最大令牌數(shù)
        args.add(intervalMs); // 時(shí)間窗口（毫秒）
        args.add(System.currentTimeMillis()); // 當(dāng)前時(shí)間戳
        args.add(1); // 每次請求消耗的令牌數(shù)
        args.add(intervalMs * 2 / 1000); // Key過期時(shí)間（窗口的2倍）
        // 5. 執(zhí)行Lua腳本
        RScript script = redissonClient.getScript(StringCodec.INSTANCE);
        Long result = script.evalSha(RScript.Mode.READ_WRITE, luaScriptSha,
                RScript.ReturnType.VALUE, keys, args.toArray());
        // 6. 處理限流結(jié)果
        if (result == null || result == 0) {
            // 觸發(fā)限流，執(zhí)行降級方法
            return handleFallback(joinPoint, rateLimit);
        }
        // 7. 執(zhí)行業(yè)務(wù)方法
        return joinPoint.proceed();
    }
    /**
     * 生成限流Key，使用Hash Tag確保同一方法的所有Key落在同一個(gè)Redis Slot
     */
    private List<String> generateKeys(String className, String methodName, RateLimit.Dimension[] dimensions) {
        List<String> keys = new ArrayList<>();
        // Hash Tag：用{}包裹類名和方法名，確保所有Key落在同一個(gè)Slot
        String hashTag = "{" + className + ":" + methodName + "}";
        String keyPrefix = "ratelimit:" + hashTag;
        for (RateLimit.Dimension dimension : dimensions) {
            switch (dimension) {
                case GLOBAL:
                    keys.add(keyPrefix + ":global");
                    break;
                case IP:
                    String ip = getClientIp();
                    keys.add(keyPrefix + ":ip:" + ip);
                    break;
                case USER:
                    // 從請求上下文獲取當(dāng)前用戶ID（需根據(jù)實(shí)際項(xiàng)目調(diào)整）
                    String userId = getCurrentUserId();
                    keys.add(keyPrefix + ":user:" + userId);
                    break;
            }
        }
        return keys;
    }
    /**
     * 執(zhí)行降級方法
     */
    private Object handleFallback(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
        String fallbackName = rateLimit.fallback();
        if (fallbackName.isEmpty()) {
            // 未配置降級方法，拋出默認(rèn)異常
            throw new RuntimeException("請求過于頻繁，請稍后再試");
        }
        // 查找降級方法（優(yōu)先匹配同參數(shù)列表，其次匹配無參方法）
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Class<?> targetClass = joinPoint.getTarget().getClass();
        Class<?>[] parameterTypes = signature.getParameterTypes();
        Method fallbackMethod;
        try {
            fallbackMethod = targetClass.getDeclaredMethod(fallbackName, parameterTypes);
        } catch (NoSuchMethodException e) {
            fallbackMethod = targetClass.getDeclaredMethod(fallbackName);
        }
        fallbackMethod.setAccessible(true);
        // 調(diào)用降級方法
        return fallbackMethod.invoke(joinPoint.getTarget(), joinPoint.getArgs());
    }
    // 輔助方法：獲取客戶端IP
    private String getClientIp() {
        HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
        String ip = request.getHeader("X-Forwarded-For");
        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();
        }
        return ip;
    }
    // 輔助方法：獲取當(dāng)前用戶ID（需根據(jù)實(shí)際項(xiàng)目實(shí)現(xiàn)）
    private String getCurrentUserId() {
        // 示例：從Token中解析用戶ID
        return "123456";
    }
}

-- 令牌桶限流Lua腳本
-- KEYS: 限流Key列表（每個(gè)維度一個(gè)Key）
-- ARGV: [1]max_tokens（最大令牌數(shù)）, [2]interval_ms（時(shí)間窗口毫秒）, [3]now_ms（當(dāng)前時(shí)間戳）, [4]permits（每次請求消耗的令牌數(shù)）, [5]expire_time（Key過期時(shí)間秒）
local max_tokens = tonumber(ARGV[1])
local interval_ms = tonumber(ARGV[2])
local now_ms = tonumber(ARGV[3])
local permits = tonumber(ARGV[4])
local expire_time = tonumber(ARGV[5])
-- 第一階段：預(yù)檢查所有維度的令牌是否充足
for i, key in ipairs(KEYS) do
    local value_key = key .. ":value"  -- 存儲(chǔ)當(dāng)前令牌數(shù)的Key
    local permits_key = key .. ":permits"  -- 存儲(chǔ)請求記錄的ZSet Key
    -- 初始化令牌桶（如果不存在）
    if redis.call("exists", value_key) == 0 then
        redis.call("set", value_key, max_tokens)
    end
    -- 回收過期令牌：刪除interval_ms之前的請求記錄，并將對應(yīng)的令牌放回桶中
    local expired_values = redis.call("zrangebyscore", permits_key, 0, now_ms - interval_ms)
    if #expired_values > 0 then
        local expired_count = 0
        for _, v in ipairs(expired_values) do
            -- 解析請求記錄中的令牌數(shù)（格式：request_id:permits）
            local _, p = string.match(v, "(.*):(.*)")
            expired_count = expired_count + tonumber(p)
        end
        -- 刪除過期記錄
        redis.call("zremrangebyscore", permits_key, 0, now_ms - interval_ms)
        -- 回收令牌
        local curr_v = tonumber(redis.call("get", value_key))
        redis.call("set", value_key, math.min(max_tokens, curr_v + expired_count))
    end
    -- 檢查當(dāng)前令牌是否足夠
    local current_val = tonumber(redis.call("get", value_key))
    if current_val < permits then
        return 0  -- 任一維度令牌不足，直接返回失敗
    end
end
-- 第二階段：所有維度檢查通過，統(tǒng)一扣減令牌
for i, key in ipairs(KEYS) do
    local value_key = key .. ":value"
    local permits_key = key .. ":permits"
    -- 生成唯一請求ID（時(shí)間戳+隨機(jī)數(shù)）
    local request_id = now_ms .. ":" .. math.random(1000000)
    -- 記錄本次請求到ZSet（分?jǐn)?shù)為時(shí)間戳，值為request_id:permits）
    redis.call("zadd", permits_key, now_ms, request_id .. ":" .. permits)
    -- 扣減令牌
    local current_v = tonumber(redis.call("get", value_key))
    redis.call("set", value_key, current_v - permits)
    -- 設(shè)置Key過期時(shí)間，防止內(nèi)存泄漏
    redis.call("expire", value_key, expire_time)
    redis.call("expire", permits_key, expire_time)
end
return 1  -- 限流通過