中小型项目请求限流设计

何为请求限流？

请求限流是一种控制API或其他Web服务的流量的技术。它的目的是限制客户端对服务器发出的请求的数量或速率，以防止服务器过载或响应时间变慢，从而提高系统的可用性和稳定性。
中小型项目请求限流的需求

• 按IP、用户、全局限流
  
• 基于不同实现的限流设计（基于Redis或者LRU缓存）
  
• 基于注解标注哪些接口限流
  

完整限流设计实现在开源项目中：https://github.com/valarchie/AgileBoot-Back-End
注解设计

声明一个注解类，主要有以下几个属性

• key(缓存的key)
  
• time(时间范围)
  
• maxCount(时间范围内最大的请求次数)
  
• limitType(按IP/用户/全局进行限流)
  
• cacheType(基于Redis或者Map来实现限流)
  

1. /**
2. * 限流注解
3. *
4. * @author valarchie
5. */
6. @Target(ElementType.METHOD)
7. @Retention(RetentionPolicy.RUNTIME)
8. @Documented
9. public @interface RateLimit {
11.     /**
12.      * 限流key
13.      */
14.     String key() default "None";
16.     /**
17.      * 限流时间,单位秒
18.      */
19.     int time() default 60;
21.     /**
22.      * 限流次数
23.      */
24.     int maxCount() default 100;
26.     /**
27.      * 限流条件类型
28.      */
29.     LimitType limitType() default LimitType.GLOBAL;
31.     /**
32.      * 限流使用的缓存类型
33.      */
34.     CacheType cacheType() default CacheType.REDIS;
36. }

复制代码

LimitType枚举，我们可以将不同限制类型的逻辑直接放在枚举类当中。推荐将逻辑直接放置在枚举类中，代码的组织形式会更好。

1. enum LimitType {
2.         /**
3.          * 默认策略全局限流  不区分IP和用户
4.          */
5.         GLOBAL{
6.             @Override
7.             public String generateCombinedKey(RateLimit rateLimiter) {
8.                 return rateLimiter.key() + this.name();
9.             }
10.         },
12.         /**
13.          * 根据请求者IP进行限流
14.          */
15.         IP {
16.             @Override
17.             public String generateCombinedKey(RateLimit rateLimiter) {
18.                 String clientIP = ServletUtil.getClientIP(ServletHolderUtil.getRequest());
19.                 return rateLimiter.key() + clientIP;
20.             }
21.         },
23.         /**
24.          * 按用户限流
25.          */
26.         USER {
27.             @Override
28.             public String generateCombinedKey(RateLimit rateLimiter) {
29.                 LoginUser loginUser = AuthenticationUtils.getLoginUser();
30.                 if (loginUser == null) {
31.                     throw new ApiException(ErrorCode.Client.COMMON_NO_AUTHORIZATION);
32.                 }
33.                 return rateLimiter.key() + loginUser.getUsername();
34.             }
35.         };
37.         public abstract String generateCombinedKey(RateLimit rateLimiter);
39.     }
40.    

复制代码

CacheType, 主要分为Redis和Map, 后续有新的类型可以新增。

1.   enum CacheType {
3.       /**
4.        * 使用redis做缓存
5.        */
6.       REDIS,
8.       /**
9.        * 使用map做缓存
10.        */
11.       Map
13.   }

复制代码

RateLimitChecker设计

声明一个抽象类，然后将具体实现放在实现类中，便于扩展

1. /**
2. * @author valarchie
3. */
4. public abstract class AbstractRateLimitChecker {
6.     /**
7.      * 检查是否超出限流
8.      * @param rateLimiter
9.      */
10.     public abstract void check(RateLimit rateLimiter);
12. }

复制代码

Redis限流实现

1. /**
2. * @author valarchie
3. */
4. @Component
5. @RequiredArgsConstructor
6. @Slf4j
7. public class RedisRateLimitChecker extends AbstractRateLimitChecker{
9.     @NonNull
10.     private RedisTemplate<Object, Object> redisTemplate;
12.     private final RedisScript<Long> limitScript = new DefaultRedisScript<>(limitScriptText(), Long.class);
14.     @Override
15.     public void check(RateLimit rateLimiter) {
16.         int maxCount = rateLimiter.maxCount();
17.         String combineKey = rateLimiter.limitType().generateCombinedKey(rateLimiter);
19.         Long currentCount;
20.         try {
21.             currentCount = redisTemplate.execute(limitScript, ListUtil.of(combineKey), maxCount, rateLimiter.time());
22.             log.info("限制请求:{}, 当前请求次数:{}, 缓存key:{}", combineKey, currentCount, rateLimiter.key());
23.         } catch (Exception e) {
24.             throw new RuntimeException("redis限流器异常，请确保redis启动正常");
25.         }
27.         if (currentCount == null) {
28.             throw new RuntimeException("redis限流器异常，请稍后再试");
29.         }
31.         if (currentCount.intValue() > maxCount) {
32.             throw new ApiException(ErrorCode.Client.COMMON_REQUEST_TOO_OFTEN);
33.         }
35.     }
37.     /**
38.      * 限流脚本
39.      */
40.     private static String limitScriptText() {
41.         return "local key = KEYS[1]\n" +
42.             "local count = tonumber(ARGV[1])\n" +
43.             "local time = tonumber(ARGV[2])\n" +
44.             "local current = redis.call('get', key);\n" +
45.             "if current and tonumber(current) > count then\n" +
46.             "    return tonumber(current);\n" +
47.             "end\n" +
48.             "current = redis.call('incr', key)\n" +
49.             "if tonumber(current) == 1 then\n" +
50.             "    redis.call('expire', key, time)\n" +
51.             "end\n" +
52.             "return tonumber(current);";
53.     }
55. }

复制代码

Map + Guava RateLimiter实现

1. /**
2. * @author valarchie
3. */
4. @SuppressWarnings("UnstableApiUsage")
5. @Component
6. @RequiredArgsConstructor
7. @Slf4j
8. public class MapRateLimitChecker extends AbstractRateLimitChecker{
10.     /**
11.      * 最大仅支持4096个key   超出这个key  限流将可能失效
12.      */
13.     private final LRUCache<String, RateLimiter> cache = new LRUCache<>(4096);
16.     @Override
17.     public void check(RateLimit rateLimit) {
18.         String combinedKey = rateLimit.limitType().generateCombinedKey(rateLimit);
20.         RateLimiter rateLimiter = cache.get(combinedKey,
21.             () -> RateLimiter.create((double) rateLimit.maxCount() / rateLimit.time())
22.         );
24.         if (!rateLimiter.tryAcquire()) {
25.             throw new ApiException(ErrorCode.Client.COMMON_REQUEST_TOO_OFTEN);
26.         }
28.         log.info("限制请求key:{}, combined key:{}", rateLimit.key(), combinedKey);
29.     }
31. }

复制代码

限流切面

我们需要在切面中，读取限流注解标注的信息，然后选择不同的限流实现来进行限流。

1. /**
2. * 限流切面处理
3. *
4. * @author valarchie
5. */
6. @Aspect
7. @Component
8. @Slf4j
9. @ConditionalOnExpression("'${agileboot.embedded.redis}' != 'true'")
10. @RequiredArgsConstructor
11. public class RateLimiterAspect {
13.     @NonNull
14.     private RedisRateLimitChecker redisRateLimitChecker;
16.     @NonNull
17.     private MapRateLimitChecker mapRateLimitChecker;
20.     @Before("@annotation(rateLimiter)")
21.     public void doBefore(JoinPoint point, RateLimit rateLimiter) {
22.         MethodSignature signature = (MethodSignature) point.getSignature();
23.         Method method = signature.getMethod();
24.         log.info("当前限流方法:" + method.toGenericString());
26.         switch (rateLimiter.cacheType()) {
27.             case REDIS:
28.                 redisRateLimitChecker.check(rateLimiter);
29.                 break;
30.             case Map:
31.                 mapRateLimitChecker.check(rateLimiter);
32.                 return;
33.             default:
34.                 redisRateLimitChecker.check(rateLimiter);
35.         }
37.     }
39. }

复制代码

注解使用

以下是我们标注的注解例子。
time=10,maxCount=10表明10秒内最多10次请求。
cacheType=Redis表明使用Redis来实现。
limitType=IP表明基于IP来限流。

1. /**
2. * 生成验证码
3. */
4. @Operation(summary = "验证码")
5. @RateLimit(key = RateLimitKey.LOGIN_CAPTCHA_KEY, time = 10, maxCount = 10, cacheType = CacheType.REDIS,
6.     limitType = LimitType.IP)
7. @GetMapping("/captchaImage")
8. public ResponseDTO<CaptchaDTO> getCaptchaImg() {
9.     CaptchaDTO captchaImg = loginService.generateCaptchaImg();
10.     return ResponseDTO.ok(captchaImg);
11. }

复制代码

这是笔者关于中小型项目关于请求限流的实现，如有不足欢迎大家评论指正。
全栈技术交流群：1398880


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！