文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
社区首页 >专栏 >使用 Spring Boot 实现限流功能：从理论到实践

使用 Spring Boot 实现限流功能：从理论到实践

原创
作者头像
小马哥学JAVA
发布于 2024-06-18 10:14:18
发布于 2024-06-18 10:14:18
2.2K0
举报

在微服务和高并发系统中，限流（Rate Limiting）是一种非常重要的技术手段，用于保护系统免受过载，确保服务的稳定性。限流可以控制请求的速率，防止单个客户端或恶意用户消耗过多的资源，从而影响其他用户。

一、限流的理论基础

常见的限流算法包括：

  1. 固定窗口计数算法（Fixed Window Counter）：将时间分为固定的窗口，计数当前窗口内的请求数。
  2. 滑动窗口计数算法（Sliding Window Counter）：在固定窗口计数的基础上，引入滑动窗口，细化时间粒度。
  3. 漏桶算法（Leaky Bucket）：请求以恒定的速率流出，处理请求时模拟水从桶中流出。
  4. 令牌桶算法（Token Bucket）：系统以恒定的速率向桶中添加令牌，请求到达时取走令牌，没有令牌则拒绝服务。

二、Spring Boot 实现限流

使用 Spring Boot 实现限流，可以通过以下几种方式：

  1. 基于过滤器（Filter）的限流实现。
  2. 使用第三方库，如 Bucket4j。
  3. 使用 Redis 实现分布式限流。

下面我们分别介绍这些方法的实现。

方法一：基于过滤器的限流实现

1.1 创建过滤器

首先，我们创建一个限流过滤器，通过 AtomicInteger 或 Semaphore 来控制请求速率。

代码语言：javascript
复制
java复制代码import org.springframework.stereotype.Component;

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.HttpServletResponse;
import java.io.IOException;
import java.util.concurrent.Semaphore;

@Component
public class RateLimitingFilter implements Filter {

    private static final int MAX_REQUESTS_PER_SECOND = 10;
    private Semaphore semaphore = new Semaphore(MAX_REQUESTS_PER_SECOND);

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        if (semaphore.tryAcquire()) {
            try {
                chain.doFilter(request, response);
            } finally {
                semaphore.release();
            }
        } else {
            ((HttpServletResponse) response).setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);
        }
    }

    @Override
    public void destroy() {
    }
}
1.2 配置过滤器

在 Spring Boot 应用中，过滤器自动注册，只需要添加 @Component 注解即可。不过，你也可以手动配置：

代码语言：javascript
复制
java复制代码import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<RateLimitingFilter> loggingFilter() {
        FilterRegistrationBean<RateLimitingFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new RateLimitingFilter());
        registrationBean.addUrlPatterns("/*");
        return registrationBean;
    }
}

方法二：使用 Bucket4j 实现限流

2.1 添加依赖

在 pom.xml 中添加 Bucket4j 依赖：

代码语言：javascript
复制
xml复制代码<dependency>
    <groupId>com.github.vladimir-bukhtoyarov</groupId>
    <artifactId>bucket4j-core</artifactId>
    <version>6.2.0</version>
</dependency>
2.2 创建限流过滤器
代码语言：javascript
复制
java复制代码import com.github.bucket4j.Bandwidth;
import com.github.bucket4j.Bucket;
import com.github.bucket4j.Refill;
import org.springframework.stereotype.Component;

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.HttpServletResponse;
import java.io.IOException;
import java.time.Duration;

@Component
public class Bucket4jRateLimitingFilter implements Filter {

    private static final int CAPACITY = 10;
    private static final int REFILL_TOKENS = 10;
    private static final Duration REFILL_DURATION = Duration.ofSeconds(1);

    private final Bucket bucket;

    public Bucket4jRateLimitingFilter() {
        Bandwidth limit = Bandwidth.classic(CAPACITY, Refill.greedy(REFILL_TOKENS, REFILL_DURATION));
        this.bucket = Bucket.builder().addLimit(limit).build();
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        if (bucket.tryConsume(1)) {
            chain.doFilter(request, response);
        } else {
            ((HttpServletResponse) response).setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);
        }
    }

    @Override
    public void destroy() {
    }
}
2.3 配置过滤器

与方法一类似，配置过滤器即可：

代码语言：javascript
复制
java复制代码import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<Bucket4jRateLimitingFilter> loggingFilter() {
        FilterRegistrationBean<Bucket4jRateLimitingFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new Bucket4jRateLimitingFilter());
        registrationBean.addUrlPatterns("/*");
        return registrationBean;
    }
}

方法三：使用 Redis 实现分布式限流

3.1 添加依赖

在 pom.xml 中添加 Redis 和 Redisson 依赖：

代码语言：javascript
复制
xml复制代码<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.15.6</version>
</dependency>
3.2 配置 Redis 和 Redisson

在 application.properties 中配置 Redis：

代码语言：javascript
复制
properties复制代码spring.redis.host=localhost
spring.redis.port=6379
3.3 创建 Redis 限流过滤器
代码语言：javascript
复制
java复制代码import org.redisson.api.RRateLimiter;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

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.HttpServletResponse;
import java.io.IOException;

@Component
public class RedisRateLimitingFilter implements Filter {

    @Autowired
    private RedissonClient redissonClient;

    private RRateLimiter rateLimiter;

    @Bean
    public RRateLimiter rateLimiter() {
        RRateLimiter rateLimiter = redissonClient.getRateLimiter("rateLimiter");
        rateLimiter.trySetRate(RRateType.OVERALL, 10, 1, RateIntervalUnit.SECONDS);
        return rateLimiter;
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        this.rateLimiter = rateLimiter();
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        if (rateLimiter.tryAcquire(1)) {
            chain.doFilter(request, response);
        } else {
            ((HttpServletResponse) response).setStatus(HttpServletResponse.SC_TOO_MANY_REQUESTS);
        }
    }

    @Override
    public void destroy() {
    }
}
3.4 配置过滤器

与之前的方法一样，配置过滤器：

代码语言：javascript
复制
java复制代码import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean<RedisRateLimitingFilter> loggingFilter() {
        FilterRegistrationBean<RedisRateLimitingFilter> registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(new RedisRateLimitingFilter());
        registrationBean.addUrlPatterns("/*");
        return registrationBean;
    }
}

结论

在本指南中，我们介绍了三种在 Spring Boot 中实现限流的方法：

  1. 基于过滤器的简单限流实现。
  2. 使用第三方库 Bucket4j 实现限流。
  3. 使用 Redis 实现分布式限流。

每种方法都有其优缺点和适用场景，可以根据具体需求选择合适的方案。希望本文能帮助你在项目中实现限流功能，保障系统的稳定性和可靠性。

我正在参与2024腾讯技术创作特训营最新征文，快来和我瓜分大奖！

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

腾讯技术创作特训营S7

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

腾讯技术创作特训营S7
评论
登录后参与评论
0 条评论
热度
最新
登录 后参与评论
推荐阅读
目录
  • 一、限流的理论基础
  • 二、Spring Boot 实现限流
  • 方法一：基于过滤器的限流实现
    • 1.1 创建过滤器
    • 1.2 配置过滤器
  • 方法二：使用 Bucket4j 实现限流
    • 2.1 添加依赖
    • 2.2 创建限流过滤器
    • 2.3 配置过滤器
  • 方法三：使用 Redis 实现分布式限流
    • 3.1 添加依赖
    • 3.2 配置 Redis 和 Redisson
    • 3.3 创建 Redis 限流过滤器
    • 3.4 配置过滤器
  • 结论
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

Copyright © 2013 - 2025 Tencent Cloud.

All Rights Reserved. 腾讯云 版权所有

登录 后参与评论