本篇文章的主要内容是SpringBoot怎么限制请求访问次数。
当我们的服务端程序部署到服务器上后，就要考虑很多关于安全的问题。总会有坏人来攻击你的服务，比如说会窃取你的数据或者给你的服务器上强度。关于给服务器上强度，往往就有高强度给服务器发送请求这个方法。所以我们就要限制请求的访问次数。
有以下几种方法：

1. 使用拦截器（interceptor）

• 创建一个拦截器类，实现HandlerInterceptor接口

@Component
public class RateLimitInterceptor implements HandlerInterceptor {
}

• 在拦截器中重写PreHandle方法，实现访问频率限制的逻辑

package com.game.server.interceptor;/*** @author Administrator* @date 2024/7/17 9:27* @description RateLimitInterceptor*/
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;@Component
public class RateLimitInterceptor implements HandlerInterceptor {public static final Map<String, AtomicInteger> requestCounts = new ConcurrentHashMap<>();@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {String ipAddress = request.getRemoteAddr();AtomicInteger requestCount = requestCounts.computeIfAbsent(ipAddress, k -> new AtomicInteger(0));System.out.println("当前ip:"+ipAddress+"请求次数："+requestCount.incrementAndGet());if (requestCount.incrementAndGet() > 10) { // 限制每分钟每个IP最多10次请求response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());response.getWriter().write("请求过于频繁，请稍后再试。");
//            throw new RuntimeException("请求过于频繁，请稍后再试。");return false;}return true;}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {String ipAddress = request.getRemoteAddr();AtomicInteger requestCount = requestCounts.get(ipAddress);if (requestCount != null) {requestCount.decrementAndGet();}}
}

• 将拦截器注册到SpringMVC的拦截链中

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configuration
public class WebConfig implements WebMvcConfigurer {@Autowiredprivate RateLimitInterceptor rateLimitInterceptor;@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(rateLimitInterceptor).addPathPatterns("/api/**");}
}

此时需注意，有可能这会导致内存泄漏，所以我们要设置一个定时器来定时释放内存：

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;@Component
@Slf4j
public class RequestCounterCleaner {@Scheduled(fixedRate = 30000) // 每分钟清理一次public void cleanRequestCounts() {log.info("清理请求表内容");RateLimitInterceptor.requestCounts.clear();}
}

最后在启动文件下启动定时器：
@EnableScheduling

@SpringBootApplication
@EnableTransactionManagement
@Slf4j
@EnableAspectJAutoProxy
@EnableScheduling
@ComponentScan(basePackages = {"com.game.common","com.game.server"})
public class ServerApplication {public static void main(String[] args) {SpringApplication.run(ServerApplication.class, args);log.info("游戏后端启动");}
}

2. 使用过滤器（Filter）

• 和上面差不多，先创建过滤器，实现“Filter"接口
• 在过滤器中实现对请求的逻辑处理
• 写Filter配置文件，将过滤器注册到SpringBoot的过滤链中，确保所有请求都会通过这个过滤器
• 写定时器定时清理数据
• 在SpringBoot请求类中启动定时器

3. 使用切面（Aspect）

大概项目目录结构如下：

• 创建注解 RequestLimit：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
@Order(Ordered.HIGHEST_PRECEDENCE)
public @interface RequestLimit {/*** 最大访问次数*/public int maxCount() default Integer.MAX_VALUE;/*** 访问时间段*/public long timeout() default 60*1000;
}

• 创建切面类RequestLimitAspect:

@Slf4j
@Aspect
@Component
public class RequestLimitAspect {@Autowiredprivate RedisTemplate redisTemplate;// 以下是定义切入点@Pointcut("within(@org.springframework.web.bind.annotation.RestController *) && @annotation(com.game.server.annotation.RequestLimit)")public void autoRequestLimitPointCut(){}@Before("autoRequestLimitPointCut()")public void requestLimit(final JoinPoint joinPoint) throws RequestLimitException {log.info("开始记录请求");MethodSignature signature = (MethodSignature) joinPoint.getSignature();RequestLimit requestLimit = signature.getMethod().getAnnotation(RequestLimit.class);ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();HttpServletRequest request = null;if (requestAttributes != null) {request = requestAttributes.getRequest();}String ip = request.getRemoteAddr();String uri = request.getRequestURI();String url = request.getRequestURL().toString();String key = "request-limit-"+url;long count = redisTemplate.opsForValue().increment(key,1);if(count == 1){redisTemplate.expire(key,requestLimit.timeout(), TimeUnit.MILLISECONDS);}if(count > requestLimit.maxCount()){String error = "HTTP请求【"+url+"】超过限制，限制次数为【"+requestLimit.maxCount()+"】，请稍后再试";log.error(error);throw new RequestLimitException(error);}}}

• 开始切：
  加入如下注解，顺便定义参数
  
  这样就实现了请求限制。这个切面相比于拦截器和过滤器来说跟灵活。

4. 使用限流组件

• 用第三方库Bucket4j，Sentinel来实现限流

5. 使用API网关

• 在微服务中可以到微服务网关实现限流。

6. 使用Nginx配置：

在Nginx中可以通过limit_req_zone和limit_req指令来实现请求限流

http {limit_req_zone $binary_remote_addr zone=one:10m rate=10r/s;server {location /api/ {limit_req zone=one burst=5 nodelay;# 其他处理逻辑}}
}

在上面的配置中：

limit_req_zone指令用于定义请求限流的地理位置和速率。$binary_remote_addr表示使用客户端的IP地址来区分不同的地理位置，zone=one表示限流区域的名称，10m表示用于存储请求状态的内存大小，rate=10r/s表示每秒允许的请求速率为10。
在location /api/中使用了limit_req指令，将请求限流应用于/api/路径的所有请求。burst=5表示同时可以处理的并发请求的最大数量，nodelay表示当超出限流时立即返回限制状态码，而不是延迟处理。
通过这样的配置，Nginx会对/api/路径下的请求进行限流，每个IP地址每秒最多只能发送10个请求，并且使用令牌桶算法进行请求处理。

这样的配置可以有效地保护后端服务器免受过多请求的影响，防止恶意攻击和负载过载。同时，Nginx的请求限流功能可用于稳定系统并提高系统的可靠性。