当前位置： 首页 > news >正文

Spring Boot 接口访问频率限制的实现详解

news 2025/6/25 12:31:17

目录

  1. 概述
  2. 为什么需要接口访问频率限制
  3. 常见的实现方式
    • 基于过滤器的实现
    • 基于拦截器的实现
    • 基于第三方库Bucket4j的实现
  4. 实际代码示例
    • 基于过滤器实现Rate Limiting
    • 基于拦截器实现Rate Limiting
    • 使用Bucket4j实现Rate Limiting
  5. 最佳实践
    • 选择合适的限流算法
    • 优化性能
    • 记录日志和监控
  6. 总结

概述

接口访问频率限制是通过在一定时间内限制用户对接口的访问次数来实现的。常见的限流算法包括令牌桶算法（Token Bucket）、漏桶算法（Leaky Bucket）、固定窗口计数器（Fixed Window Counter）和滑动窗口计数器（Sliding Window Counter）等。在Spring Boot中，我们可以通过多种方式来实现接口的限流，如使用过滤器、拦截器或者借助第三方库。

为什么需要接口访问频率限制

  1. 防止恶意攻击：通过限制接口的访问频率，可以有效防止恶意用户或机器人频繁访问接口，导致系统资源耗尽。
  2. 提升系统稳定性：在高并发场景下，限流可以有效保护后端服务，避免因流量过大而导致系统崩溃。
  3. 提升用户体验：合理的限流可以保障所有用户都能获得较好的服务质量，避免个别用户过度使用资源。

常见的实现方式

基于过滤器的实现

过滤器是Java Web应用中常用的一种组件，它可以在请求到达Servlet之前对请求进行预处理。通过在过滤器中实现限流逻辑，可以对所有的HTTP请求进行统一的限流控制。

基于拦截器的实现

拦截器是Spring框架提供的一种处理器，可以在请求处理之前和之后进行相关操作。相比于过滤器，拦截器可以更加细粒度地控制请求，适用于需要针对某些特定接口进行限流的场景。

基于第三方库Bucket4j的实现

Bucket4j是一个Java实现的高性能限流库，它支持多种限流算法，如令牌桶算法。通过使用Bucket4j，可以轻松地在Spring Boot应用中实现复杂的限流逻辑，并且它还提供了丰富的配置选项和统计功能。

实际代码示例

基于过滤器实现Rate Limiting

首先，我们需要创建一个自定义的过滤器类，并在其中实现限流逻辑。以下是一个示例代码：

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;public class RateLimitingFilter implements Filter {private final ConcurrentMap<String, Long> requestCounts = new ConcurrentHashMap<>();private static final long ALLOWED_REQUESTS_PER_MINUTE = 60;@Overridepublic void init(FilterConfig filterConfig) throws ServletException {// 初始化过滤器}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {HttpServletRequest httpRequest = (HttpServletRequest) request;HttpServletResponse httpResponse = (HttpServletResponse) response;String clientIp = httpRequest.getRemoteAddr();long currentTimeMillis = System.currentTimeMillis();requestCounts.putIfAbsent(clientIp, currentTimeMillis);long lastRequestTime = requestCounts.get(clientIp);if (TimeUnit.MILLISECONDS.toMinutes(currentTimeMillis - lastRequestTime) < 1) {long requestCount = requestCounts.values().stream().filter(time -> TimeUnit.MILLISECONDS.toMinutes(currentTimeMillis - time) < 1).count();if (requestCount > ALLOWED_REQUESTS_PER_MINUTE) {httpResponse.setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);httpResponse.getWriter().write("Too many requests");return;}}requestCounts.put(clientIp, currentTimeMillis);chain.doFilter(request, response);}@Overridepublic void destroy() {// 销毁过滤器}
}

然后，在Spring Boot应用的配置类中注册这个过滤器：

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class FilterConfig {@Beanpublic FilterRegistrationBean<RateLimitingFilter> loggingFilter(){FilterRegistrationBean<RateLimitingFilter> registrationBean = new FilterRegistrationBean<>();registrationBean.setFilter(new RateLimitingFilter());registrationBean.addUrlPatterns("/api/*");return registrationBean;}
}

基于拦截器实现Rate Limiting

首先，我们需要创建一个自定义的拦截器类，并在其中实现限流逻辑。以下是一个示例代码：

import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;public class RateLimitingInterceptor implements HandlerInterceptor {private final ConcurrentMap<String, Long> requestCounts = new ConcurrentHashMap<>();private static final long ALLOWED_REQUESTS_PER_MINUTE = 60;@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {String clientIp = request.getRemoteAddr();long currentTimeMillis = System.currentTimeMillis();requestCounts.putIfAbsent(clientIp, currentTimeMillis);long lastRequestTime = requestCounts.get(clientIp);if (TimeUnit.MILLISECONDS.toMinutes(currentTimeMillis - lastRequestTime) < 1) {long requestCount = requestCounts.values().stream().filter(time -> TimeUnit.MILLISECONDS.toMinutes(currentTimeMillis - time) < 1).count();if (requestCount > ALLOWED_REQUESTS_PER_MINUTE) {response.setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);response.getWriter().write("Too many requests");return false;}}requestCounts.put(clientIp, currentTimeMillis);return true;}
}

然后，在Spring Boot应用的配置类中注册这个拦截器：

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 RateLimitingInterceptor rateLimitingInterceptor;@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(rateLimitingInterceptor).addPathPatterns("/api/**");}
}

使用Bucket4j实现Rate Limiting

首先，在项目中引入Bucket4j依赖：

<dependency><groupId>com.github.vladimir-bukhtoyarov</groupId><artifactId>bucket4j-core</artifactId><version>7.0.0</version>
</dependency>

然后，创建一个自定义的过滤器类，并在其中实现限流逻辑：

import io.github.bucket4j.Bandwidth;
import io.github.bucket4j.Bucket;
import io.github.bucket4j.Bucket4j;
import io.github.bucket4j.Refill;import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.time.Duration;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;public class Bucket4jRateLimitingFilter implements Filter {private final ConcurrentMap<String, Bucket> buckets = new ConcurrentHashMap<>();@Overridepublic void init(FilterConfig filterConfig) throws ServletException {// 初始化过滤器}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {HttpServletRequest httpRequest = (HttpServletRequest) request;HttpServletResponse httpResponse = (HttpServletResponse) response;String clientIp = httpRequest.getRemoteAddr();Bucket bucket = buckets.computeIfAbsent(clientIp, this::newBucket);if (bucket.tryConsume(1)) {chain.doFilter(request, response);} else {httpResponse.setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);httpResponse.getWriter().write("Too many requests");}}private Bucket newBucket(String clientIp) {return Bucket4j.builder().addLimit(Bandwidth.classic(60, Refill.greedy(60, Duration.ofMinutes(1)))).build();}@Overridepublic void destroy() {// 销毁过滤器}
}

然后，在Spring Boot应用的配置类中注册这个过滤器：

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class FilterConfig {@Beanpublic FilterRegistrationBean<Bucket4jRateLimitingFilter> loggingFilter(){FilterRegistrationBean<Bucket4jRateLimitingFilter> registrationBean = new FilterRegistrationBean<>();registrationBean.setFilter(new Bucket4jRateLimitingFilter());registrationBean.addUrlPatterns("/api/*");return registrationBean;}
}

最佳实践

选择合适的限流算法

根据实际业务需求选择合适的限流算法，例如：

  • 令牌桶算法：适用于需要平滑突发流量的场景。
  • 漏桶算法：适用于需要严格控制流量的场景。
  • 固定窗口计数器：适用于对简单限流要求的场景。
  • 滑动窗口计数器：适用于需要精确控制限流的场景。

优化性能

  • 减少锁竞争：在高并发环境下，尽量减少锁的使用，可以采用无锁数据结构或者线程安全的数据结构。
  • 缓存结果：对于频繁访问的数据，可以考虑进行缓存，减少数据库查询的次数。
  • 异步处理：对于耗时的操作，可以考虑采用异步处理，提高系统的响应速度。

记录日志和监控

  • 记录访问日志：记录每次接口访问的详细信息，包括请求时间、IP地址、请求路径等。
  • 监控限流情况：对限流情况进行监控，及时发现和处理异常流量。
  • 报警机制：设置限流报警机制，当流量超过预设阈值时，及时报警。

总结

本文详细介绍了在Spring Boot中实现接口访问频率限制的几种方法，包括基于过滤器、拦截器和第三方库Bucket4j的实现。通过合理的限流策略，可以有效防止恶意攻击，提升系统的稳定性和用户体验。在实际应用中，选择合适的限流算法和实现方式，并结合业务需求进行优化，是确保系统高效运行的关键。

希望本文能够帮助你更好地理解和实现Spring Boot中的接口访问频率限制。如果你有任何问题或建议，欢迎在评论区留言讨论。

http://www.lryc.cn/news/405549.html

相关文章：

  • 前端页面：用户交互持续时间跟踪（duration）user-interaction-tracker
  • 中文分词库 jieba 详细使用方法与案例演示
  • EXO-helper解释
  • Qt开发网络嗅探器01
  • mysql面试（三）
  • 阿里云公共DNS免费版自9月30日开始限速 企业或商业场景需使用付费版
  • 捷配生产笔记-一文搞懂阻焊层基本知识
  • html 常用css样式及排布问题
  • 【SpingCloud】客户端与服务端负载均衡机制，微服务负载均衡NacosLoadBalancer， 拓展：OSI七层网络模型
  • 【Elasticsearch】Elasticsearch 中的节点角色
  • pip install与apt install区别
  • 分表分库是一种数据库架构的优化策略，用于处理大规模数据和高并发请求，提高数据库的性能和可扩展性。
  • 【ffmpeg命令入门】获取音视频信息
  • 【IoTDB 线上小课 05】时序数据文件 TsFile 三问“解密”！
  • python-爬虫实例（4）：获取b站的章若楠的视频
  • C# yaml 配置文件的用法（一）
  • 人工智能与机器学习原理精解【4】
  • Go channel实现原理详解（源码解读）
  • 数据结构-C语言-排序（4）
  • 灰色关联分析【系统分析+综合评价】
  • linux 部署flask项目
  • ES6 数值的扩展（十八）
  • 面试知识储备-redis和redission
  • 【5本可选】保证知网检索，现在投稿可在8月见刊，对文科领域友好
  • SpringBoot入门：如何新建SpringBoot项目（保姆级教程）
  • 数据恢复篇：适用于 Android 视频恢复的 6 个工具
  • Android笔试面试题AI答之控件Views（6）
  • 扭蛋机潮玩小程序搭建，扭蛋机行业的创新
  • supOS赋能千行百业
  • Vue中filter的使用