<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>

// 1. 定義限流攔截器
public class RateLimitInterceptor implements HandlerInterceptor {
    // 每秒允許10個請求（令牌桶算法）
    private final RateLimiter rateLimiter = RateLimiter.create(10.0);
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 嘗試獲取令牌，無令牌則拒絕
        if (!rateLimiter.tryAcquire()) {
            response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
            response.getWriter().write("請求過于頻繁，請稍后再試");
            return false;
        }
        return true;
    }
}
// 2. 注冊攔截器（Spring配置）
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 對指定路徑生效（如所有接口）
        registry.addInterceptor(new RateLimitInterceptor())
                .addPathPatterns("/**");
    }
}

public class SlidingWindowLimiter {
    // 窗口大?。ê撩耄?
    private final long windowSize;
    // 窗口內最大請求數(shù)
    private final int maxRequests;
    // 記錄每個時間片的請求數(shù)（key：時間片起始時間，value：請求數(shù)）
    private final ConcurrentHashMap<Long, Integer> timeSliceCounts = new ConcurrentHashMap<>();
    public SlidingWindowLimiter(long windowSize, int maxRequests) {
        this.windowSize = windowSize;
        this.maxRequests = maxRequests;
    }
    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        // 計算當前窗口的起始時間
        long windowStart = now - windowSize;
        // 移除過期的時間片
        timeSliceCounts.keySet().removeIf(timestamp -> timestamp < windowStart);
        // 統(tǒng)計當前窗口總請求數(shù)
        int totalRequests = timeSliceCounts.values().stream().mapToInt(Integer::intValue).sum();
        if (totalRequests < maxRequests) {
            // 記錄當前時間片的請求（精確到100ms，可調整精度）
            long currentSlice = now - (now % 100);
            timeSliceCounts.put(currentSlice, timeSliceCounts.getOrDefault(currentSlice, 0) + 1);
            return true;
        }
        return false;
    }
}
// 使用示例（在Controller中）
@RestController
public class TestController {
    // 10秒內最多允許5次請求（按IP限流）
    private final Map<String, SlidingWindowLimiter> ipLimiters = new ConcurrentHashMap<>();
    @GetMapping("/test")
    public String test(HttpServletRequest request) {
        String ip = request.getRemoteAddr();
        // 為每個IP創(chuàng)建獨立的限流器
        SlidingWindowLimiter limiter = ipLimiters.computeIfAbsent(ip, 
            k -> new SlidingWindowLimiter(10000, 5));
        if (!limiter.tryAcquire()) {
            return "IP:" + ip + " 請求過于頻繁";
        }
        return "請求成功";
    }
}

-- 限流key（如：接口名:IP）
local key = KEYS[1]
-- 窗口大小（毫秒）
local windowSize = tonumber(ARGV[1])
-- 最大請求數(shù)
local maxRequests = tonumber(ARGV[2])
-- 當前時間
local now = tonumber(ARGV[3])
-- 窗口起始時間
local windowStart = now - windowSize
-- 移除窗口外的請求記錄
redis.call('ZREMRANGEBYSCORE', key, 0, windowStart)
-- 統(tǒng)計當前窗口內的請求數(shù)
local currentCount = redis.call('ZCARD', key)
if currentCount < maxRequests then
    -- 記錄當前請求時間戳
    redis.call('ZADD', key, now, now .. ':' .. math.random())
    -- 設置key過期時間（避免內存泄漏）
    redis.call('EXPIRE', key, windowSize / 1000 + 1)
    return 1  -- 允許請求
end
return 0  -- 拒絕請求

@Component
public class RedisRateLimiter {
    @Autowired
    private StringRedisTemplate redisTemplate;
    // 加載Lua腳本
    private final DefaultRedisScript<Long> limitScript;
    public RedisRateLimiter() {
        limitScript = new DefaultRedisScript<>();
        limitScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("limit.lua")));
        limitScript.setResultType(Long.class);
    }
    /**
     * 嘗試獲取請求權限
     * @param key 限流標識（如："api:test:192.168.1.1"）
     * @param windowSize 窗口大?。ê撩耄?
     * @param maxRequests 最大請求數(shù)
     * @return 是否允許
     */
    public boolean tryAcquire(String key, long windowSize, int maxRequests) {
        Long result = redisTemplate.execute(
            limitScript,
            Collections.singletonList(key),
            String.valueOf(windowSize),
            String.valueOf(maxRequests),
            String.valueOf(System.currentTimeMillis())
        );
        return result != null && result == 1;
    }
}
// 在Controller中使用
@RestController
public class TestController {
    @Autowired
    private RedisRateLimiter redisRateLimiter;
    @GetMapping("/test")
    public String test(HttpServletRequest request) {
        String ip = request.getRemoteAddr();
        String key = "api:test:" + ip;
        // 10秒內最多5次請求
        boolean allowed = redisRateLimiter.tryAcquire(key, 10000, 5);
        if (!allowed) {
            return "請求過于頻繁，請稍后再試";
        }
        return "請求成功";
    }
}