SpringBoot通过一个注解结合Redis实现接口限流就是这么简单

环境：Springboot3.0.5

---

概述

接口限流是指在系统中对接口进行限制访问，以保护系统不被过载或异常流量所影响。这通常是为了防止DDoS攻击或其他类型的恶意流量攻击，以及确保系统的稳定性和可靠性。

接口限流可以采取多种方法，包括：

1. 计数器：记录每个接口的访问次数，如果超过预设的限制，则限制对该接口的访问。
2. 速率限制：限制每个接口的访问速率，例如每秒请求数。
3. 滑动窗口算法：记录一段时间内每个接口的访问次数，并根据这些数据进行限流。
4. 漏桶算法：限制一段时间内的总访问次数或总请求数，无论接口是否被频繁访问。
5. 基于流的限流：根据网络流量进行限流，例如限制每个IP地址的流量。

接口限流可以保护系统免受异常流量攻击，但同时也可能会对正常用户造成一些影响，因此需要合理设置限流策略，以确保系统的稳定性和可靠性。

限流

实现方案

1. Guava实现接口限流

@Test
public void testWithRateLimiter() {
  long start = System.currentTimeMillis() ;
  // 每秒最多接受10个请求
  RateLimiter limiter = RateLimiter.create(10.0) ;
  for (int i = 0; i < 10; i++) {
    // 如果没有可用的将会被阻塞
    limiter.acquire() ; 
    System.out.println("execution bussiness invoke...") ;
    TimeUnit.SECONDS.sleep(1) ;
  }
  long end = System.currentTimeMillis() ;
  System.out.println((end - start) + "ms") ;
}

1. 通过Spring Cloud Gateway

在Spring Cloud Gateway中提供了
RequestRateLimiterGatewayFilterFactory过滤器，我们可以通过配置该过滤器来实现限流，该过滤默认提供了基于Redis实现的RedisRateLimiter。我们可以通过自定义RateLimiter实现自己的限流方案。

spring:
  cloud:
     gateway:
       routes:
       - id: test
         uri: http://localhost:8082
         filters:
         - name: RequestRateLimiter
            args:
              key-resolver: '#{@hostAddrKeyResolver}'
              redis-rate-limiter.replenishRate: 1
              redis-rate-limiter.burstCapacity: 3

1. Resilience4j

在该库中提供了限流的支持，我们可以通过编程的方式也可以直接通过注解的方式实现。

具体查看Resilience4j的官网都有介绍。

1. 自定义

该方案就是本文要介绍实现的方案。

自定义接口限流

接下来通过一个注解结合Redis实现简单基于计数器的方法实现接口的限流。

• 依赖配置

  org.springframework.boot
  spring-boot-starter-data-redis

配置

spring:
  data:
    redis:
      host: localhost
      port: 6379
      password: 123123
      database: 12
      lettuce:
        pool:
          maxActive: 8
          maxIdle: 100
          minIdle: 10
          maxWait: -1

• 自定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AccessLimit {

  // 单位时间：秒
  long seconds() default 1;
  // 单位时间内限制访问次数
  int count() default 10 ;
  
}

• 拦截器

这是我们实现接口限流的核心，符合条件的请求都会先进过该拦截器判断是否放行。

@Component
public class AccessLimitInterceptor implements HandlerInterceptor {

  @Resource
  private StringRedisTemplate stringRedisTemplate ;
  
  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    // 只针对@Controller(RequestMappingHandlerMapping)的接口
    if (handler instanceof HandlerMethod handlerMethod) {
      Method method = handlerMethod.getMethod() ;
      // 具备AccessLimit注解的才进行拦截
      AccessLimit accessLimit = method.getDeclaredAnnotation(AccessLimit.class) ;
      if (accessLimit != null) {
        // 获取注解配置的参数
        long seconds = accessLimit.seconds() ;
        int count = accessLimit.count() ;
        if (seconds > 0 && count >= 0) {
          String key = request.getRemoteAddr() + ":" + request.getRequestURI() ;
          String value = this.stringRedisTemplate.opsForValue().get(key) ;
          System.out.println("当前为：" + value) ;
          if (value == null) {
            this.stringRedisTemplate.opsForValue().set(key, String.valueOf(count - 1) , seconds, TimeUnit.SECONDS) ;
            return true ;
          } else {
            int c = Integer.valueOf(value) ;
            if (c <= 0) {
              response.setContentType("application/json;charset=utf-8") ;
              Map res = Map.ofEntries(
                  Map.entry("code", -1),
                  Map.entry("message", "访问太快了")
              ) ;
              response.getWriter().println(new ObjectMapper().writeValueAsString(res)) ;
              return false ;
            } else {
              this.stringRedisTemplate.opsForValue().decrement(key) ;
              return true ;
            }
          }
        }
      }
    }
    return true ;
  }
  
}

配置拦截器

@Component
public class AccessLimitConfig implements WebMvcConfigurer {

  @Resource
  private AccessLimitInterceptor accessLimitInterceptor ;
  
  @Override
  public void addInterceptors(InterceptorRegistry registry) {
    registry
      .addInterceptor(accessLimitInterceptor)
      .addPathPatterns("/**")
      // 对登录和退出接口放行
      .excludePathPatterns("/login", "/logout") ;
  }
  
}

以上就是核心类，整体还是非常简单的，主要判断都在拦截器中。接下来进行接口测试

@RestController
@RequestMapping("/acc")
public class AccessLimitController {

  @AccessLimit(seconds = 1, count = 2)
  @GetMapping("/index")
  public Object index() {
    return "success" ;
  }
  
}

测试

正常访问

如果1秒内超过2次将输出上面错误