本篇文章的主要内容是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<>();

    @Override
    public 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;
    }

    @Override
    public 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 {

    @Autowired
    private RateLimitInterceptor rateLimitInterceptor;

    @Override
    public 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 {
    @Autowired
    private 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的请求限流功能可用于稳定系统并提高系统的可靠性。