基于Redis有序聚集实现滑动窗口限流

滑动窗口算法是一种基于时间窗口的限流算法，它将时间划分为若干个固定巨细的窗口，每个窗口内记录了该时间段内的请求次数。通过动态地滑动窗口，可以动态调整限流的速率，以应对差别的流量变化。
整个限流可以概括为两个主要步骤：

• 统计窗口内的请求数量
  
• 应用限流规则
  

Redis有序聚集每个value有一个score（分数），基于score我们可以界说一个时间窗口，然后每次一个请求进来就设置一个value，这样就可以统计窗口内的请求数量。key可以是资源名，比如一个url，或者ip+url，用户标识+url等。value在这里不那么重要，因为我们只需要统计数量，因此value可以就设置成时间戳，但是如果value类似的话就会被覆盖，所以我们可以把请求的数据做一个hash，将这个hash值当value，或者如果每个请求有流水号的话，可以用请求流水号当value，总之就是要能唯一标识一次请求的。
所以，简化后的命令就变成了：

1. ZADD  资源标识   时间戳   请求标识

复制代码

 Java代码

1. public boolean isAllow(String key) {
2.     ZSetOperations<String, String> zSetOperations = stringRedisTemplate.opsForZSet();
3.     //  获取当前时间戳
4.     long currentTime = System.currentTimeMillis();
5.     //  当前时间 - 窗口大小 = 窗口开始时间
6.     long windowStart = currentTime - period;
7.     //  删除窗口开始时间之前的所有数据
8.     zSetOperations.removeRangeByScore(key, 0, windowStart);
9.     //  统计窗口中请求数量
10.     Long count = zSetOperations.zCard(key);
11.     //  如果窗口中已经请求的数量超过阈值，则直接拒绝
12.     if (count >= threshold) {
13.         return false;
14.     }
15.     //  没有超过阈值，则加入集合
16.     String value = "请求唯一标识（比如：请求流水号、哈希值、MD5值等）";
17.     zSetOperations.add(key, String.valueOf(currentTime), currentTime);
18.     //  设置一个过期时间，及时清理冷数据
19.     stringRedisTemplate.expire(key, period, TimeUnit.MILLISECONDS);
20.     //  通过
21.     return true;
22. }

复制代码

上面代码中涉及到三条Redis命令，并发请求下可能存在问题，所以我们把它们写成Lua脚本

1. local key = KEYS[1]
2. local current_time = tonumber(ARGV[1])
3. local window_size = tonumber(ARGV[2])
4. local threshold = tonumber(ARGV[3])
5. redis.call('ZREMRANGEBYSCORE', key, 0, current_time - window_size)
6. local count = redis.call('ZCARD', key)
7. if count >= threshold then
8.     return tostring(0)
9. else
10.     redis.call('ZADD', key, tostring(current_time), current_time)
11.     return tostring(1)
12. end

复制代码

完整的代码如下：

1. package com.example.demo.controller;
3. import org.springframework.beans.factory.annotation.Autowired;
4. import org.springframework.data.redis.core.StringRedisTemplate;
5. import org.springframework.data.redis.core.ZSetOperations;
6. import org.springframework.data.redis.core.script.DefaultRedisScript;
7. import org.springframework.stereotype.Service;
9. import java.util.Collections;
10. import java.util.concurrent.TimeUnit;
12. /**
13. * 基于Redis有序集合实现滑动窗口限流
14. * @Author: ChengJianSheng
15. * @Date: 2024/12/26
16. */
17. @Service
18. public class SlidingWindowRatelimiter {
20.     private long period = 60*1000;  //  1分钟
21.     private int threshold = 3;      //  3次
23.     @Autowired
24.     private StringRedisTemplate stringRedisTemplate;
26.     /**
27.      * RedisTemplate
28.      */
29.     public boolean isAllow(String key) {
30.         ZSetOperations<String, String> zSetOperations = stringRedisTemplate.opsForZSet();
31.         //  获取当前时间戳
32.         long currentTime = System.currentTimeMillis();
33.         //  当前时间 - 窗口大小 = 窗口开始时间
34.         long windowStart = currentTime - period;
35.         //  删除窗口开始时间之前的所有数据
36.         zSetOperations.removeRangeByScore(key, 0, windowStart);
37.         //  统计窗口中请求数量
38.         Long count = zSetOperations.zCard(key);
39.         //  如果窗口中已经请求的数量超过阈值，则直接拒绝
40.         if (count >= threshold) {
41.             return false;
42.         }
43.         //  没有超过阈值，则加入集合
44.         String value = "请求唯一标识（比如：请求流水号、哈希值、MD5值等）";
45.         zSetOperations.add(key, String.valueOf(currentTime), currentTime);
46.         //  设置一个过期时间，及时清理冷数据
47.         stringRedisTemplate.expire(key, period, TimeUnit.MILLISECONDS);
48.         //  通过
49.         return true;
50.     }
52.     /**
53.      * Lua脚本
54.      */
55.     public boolean isAllow2(String key) {
56.         String luaScript = "local key = KEYS[1]\n" +
57.                 "local current_time = tonumber(ARGV[1])\n" +
58.                 "local window_size = tonumber(ARGV[2])\n" +
59.                 "local threshold = tonumber(ARGV[3])\n" +
60.                 "redis.call('ZREMRANGEBYSCORE', key, 0, current_time - window_size)\n" +
61.                 "local count = redis.call('ZCARD', key)\n" +
62.                 "if count >= threshold then\n" +
63.                 "    return tostring(0)\n" +
64.                 "else\n" +
65.                 "    redis.call('ZADD', key, tostring(current_time), current_time)\n" +
66.                 "    return tostring(1)\n" +
67.                 "end";
69.         long currentTime = System.currentTimeMillis();
71.         DefaultRedisScript<String> redisScript = new DefaultRedisScript<>(luaScript, String.class);
73.         String result = stringRedisTemplate.execute(redisScript, Collections.singletonList(key), String.valueOf(currentTime), String.valueOf(period), String.valueOf(threshold));
74.         //  返回1表示通过，返回0表示拒绝
75.         return "1".equals(result);
76.     }
77. }

复制代码

这里用StringRedisTemplate执行Lua脚本，先把Lua脚本封装成DefaultRedisScript对象。留意，万万留意，Lua脚本的返回值必须是字符串，参数也最好都是字符串，用整型的话可能类型转换错误。

1. String requestId = UUID.randomUUID().toString();
3. DefaultRedisScript<String> redisScript = new DefaultRedisScript<>(luaScript, String.class);
5. String result = stringRedisTemplate.execute(redisScript,
6.         Collections.singletonList(key),
7.         requestId,
8.         String.valueOf(period),
9.         String.valueOf(threshold));

复制代码

好了，上面就是基于Redis有序聚集实现的滑动窗口限流。顺带提一句，Redis List类型也可以用来实现滑动窗口。
接下来，我们来完善一下上面的代码，通过AOP来拦截请求达到限流的目的
为此，我们必须自界说注解，然后根据注解参数，来个性化的控制限流。那么，问题来了，如果获取注解参数呢？
举例说明：

1. @Retention(RetentionPolicy.RUNTIME)
2. @Target(ElementType.METHOD)
3. public @interface MyAnnotation {
4.     String value();
5. }
8. @Aspect
9. @Component
10. public class MyAspect {
12.     @Before("@annotation(myAnnotation)")
13.     public void beforeMethod(JoinPoint joinPoint, MyAnnotation myAnnotation) {
14.         // 获取注解参数
15.         String value = myAnnotation.value();
16.         System.out.println("Annotation value: " + value);
18.         // 其他业务逻辑...
19.     }
20. }

复制代码

留意看，切点是怎么写的 @Before("@annotation(myAnnotation)")
是@Before("@annotation(myAnnotation)")，而不是@Before("@annotation(MyAnnotation)")
myAnnotation，是参数，而MyAnnotation则是注解类

此处参考

https://www.cnblogs.com/javaxubo/p/16556924.html
https://blog.csdn.net/qq_40977118/article/details/119488358
https://blog.51cto.com/knifeedge/5529885

言归正传，我们起首界说一个注解

1. package com.example.demo.controller;
3. import java.lang.annotation.*;
5. /**
6. * 请求速率限制
7. * @Author: ChengJianSheng
8. * @Date: 2024/12/26
9. */
10. @Documented
11. @Target(ElementType.METHOD)
12. @Retention(RetentionPolicy.RUNTIME)
13. public @interface RateLimit {
14.     /**
15.      * 窗口大小（默认：60秒）
16.      */
17.     long period() default 60;
19.     /**
20.      * 阈值（默认：3次）
21.      */
22.     long threshold() default 3;
23. }

复制代码

界说切面

1. package com.example.demo.controller;
3. import jakarta.servlet.http.HttpServletRequest;
4. import lombok.extern.slf4j.Slf4j;
5. import org.aspectj.lang.JoinPoint;
6. import org.aspectj.lang.annotation.Aspect;
7. import org.aspectj.lang.annotation.Before;
8. import org.springframework.beans.factory.annotation.Autowired;
9. import org.springframework.data.redis.core.StringRedisTemplate;
10. import org.springframework.data.redis.core.ZSetOperations;
11. import org.springframework.stereotype.Component;
12. import org.springframework.web.context.request.RequestContextHolder;
13. import org.springframework.web.context.request.ServletRequestAttributes;
14. import org.springframework.web.servlet.support.RequestContextUtils;
16. import java.util.concurrent.TimeUnit;
18. /**
19. * @Author: ChengJianSheng
20. * @Date: 2024/12/26
21. */
22. @Slf4j
23. @Aspect
24. @Component
25. public class RateLimitAspect {
27.     @Autowired
28.     private StringRedisTemplate stringRedisTemplate;
30. //    @Autowired
31. //    private SlidingWindowRatelimiter slidingWindowRatelimiter;
33.     @Before("@annotation(rateLimit)")
34.     public void doBefore(JoinPoint joinPoint, RateLimit rateLimit) {
35.         //  获取注解参数
36.         long period = rateLimit.period();
37.         long threshold = rateLimit.threshold();
39.         //  获取请求信息
40.         ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
41.         HttpServletRequest httpServletRequest = servletRequestAttributes.getRequest();
42.         String uri = httpServletRequest.getRequestURI();
43.         Long userId = 123L;     //  模拟获取用户ID
44.         String key = "limit:" + userId + ":" + uri;
45.         /*
46.         if (!slidingWindowRatelimiter.isAllow2(key)) {
47.             log.warn("请求超过速率限制！userId={}, uri={}", userId, uri);
48.             throw new RuntimeException("请求过于频繁！");
49.         }*/
51.         ZSetOperations<String, String> zSetOperations = stringRedisTemplate.opsForZSet();
52.         //  获取当前时间戳
53.         long currentTime = System.currentTimeMillis();
54.         //  当前时间 - 窗口大小 = 窗口开始时间
55.         long windowStart = currentTime - period * 1000;
56.         //  删除窗口开始时间之前的所有数据
57.         zSetOperations.removeRangeByScore(key, 0, windowStart);
58.         //  统计窗口中请求数量
59.         Long count = zSetOperations.zCard(key);
60.         //  如果窗口中已经请求的数量超过阈值，则直接拒绝
61.         if (count < threshold) {
62.             //  没有超过阈值，则加入集合
63.             zSetOperations.add(key, String.valueOf(currentTime), currentTime);
64.             //  设置一个过期时间，及时清理冷数据
65.             stringRedisTemplate.expire(key, period, TimeUnit.SECONDS);
66.         } else {
67.             throw new RuntimeException("请求过于频繁！");
68.         }
69.     }
71. }

复制代码

加注解

1. @RestController
2. @RequestMapping("/hello")
3. public class HelloController {
5.     @RateLimit(period = 30, threshold = 2)
6.     @GetMapping("/sayHi")
7.     public void sayHi() {
9.     }
10. }

复制代码

最后，看Redis中的数据结构

最后的最后，流量控制发起看看阿里巴巴 Sentinel
https://sentinelguard.io/zh-cn/
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。