我要评论一、guava库
在springboot项目中实现限流，我们可以使用多种策略，如基于令牌桶（token bucket）的guava ratelimiter，或者基于漏桶（leaky bucket）算法的自定义实现，甚至是基于redis的分布式限流。以下是一个使用guava ratelimiter在springboot项目中实现限流的完整示例。
1. 引入依赖
首先，在pom.xml文件中添加guava库的依赖：
<dependencies>
<!-- spring boot starter web -->
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-web</artifactid>
</dependency>
<!-- guava for ratelimiter -->
<dependency>
<groupid>com.google.guava</groupid>
<artifactid>guava</artifactid>
<version>31.0.1-jre</version> <!-- 请使用最新版本 -->
</dependency>
<!-- 其他依赖项 -->
</dependencies>2. 创建ratelimiter配置类
创建一个配置类来初始化ratelimiter，并将其作为bean注入到其他组件中：
import com.google.common.util.concurrent.ratelimiter;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
@configuration
public class ratelimiterconfig {
@bean
public ratelimiter apiratelimiter() {
// 每秒允许10个请求
return ratelimiter.create(10.0);
}
}3. 创建控制器类
在控制器类中注入ratelimiter，并在请求处理方法中使用它：
import com.google.common.util.concurrent.ratelimiter;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.getmapping;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.restcontroller;
import java.util.concurrent.timeunit;
@restcontroller
@requestmapping("/api")
public class apicontroller {
@autowired
private ratelimiter apiratelimiter;
@getmapping("/limited")
public string limitedendpoint() {
// 尝试获取许可，如果失败则等待一段时间再重试（可选）
boolean acquired = false;
try {
acquired = apiratelimiter.tryacquire(1, timeunit.seconds); // 等待最多1秒获取许可
} catch (interruptedexception e) {
thread.currentthread().interrupt(); // 恢复中断状态
}
if (acquired) {
return "request processed successfully";
} else {
return "too many requests - try again later";
}
}
}在这个例子中，limitedendpoint方法会尝试从ratelimiter中获取一个许可。如果获取成功，则返回成功响应；如果获取失败（即请求被限流），则返回一个错误响应。注意，这里使用了tryacquire(long timeout, timeunit unit)方法来允许请求在指定的时间内等待获取许可，但这在实际应用中可能会导致请求的延迟增加。如果不希望等待，可以直接使用tryacquire()方法。
二、使用redis实现分布式限流
1. 引入依赖
首先，在你的pom.xml文件中添加spring boot starter data redis的依赖：
<dependencies>
<!-- spring boot starter web -->
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-web</artifactid>
</dependency>
<!-- spring boot starter data redis -->
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-data-redis</artifactid>
</dependency>
<!-- 其他依赖项 -->
</dependencies>2. 配置redis
在application.properties或application.yml文件中配置redis连接信息：
# application.properties spring.redis.host=localhost spring.redis.port=6379 # 如果redis设置了密码，请取消以下行的注释并设置密码 # spring.redis.password=yourpassword
或者
# application.yml
spring:
redis:
host: localhost
port: 6379
# 如果redis设置了密码，请设置密码
# password: yourpassword3. 创建redis限流服务
创建一个服务类，用于实现限流逻辑：
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.data.redis.core.stringredistemplate;
import org.springframework.data.redis.core.valueoperations;
import org.springframework.stereotype.service;
import java.util.concurrent.timeunit;
@service
public class ratelimiterservice {
private static final string key_prefix = "rate_limiter:";
private static final long limit_period = 60; // 限流周期，单位：秒
private static final int limit_count = 10; // 限流阈值
@autowired
private stringredistemplate redistemplate;
public boolean isallowed(string userid) {
string key = key_prefix + userid;
valueoperations<string, string> ops = redistemplate.opsforvalue();
// 获取当前请求时间戳
long currenttime = system.currenttimemillis();
// 获取上一次请求时间戳，如果不存在则为-1
string lastrequesttimestr = ops.get(key);
long lastrequesttime = lastrequesttimestr != null ? long.parselong(lastrequesttimestr) : -1;
if (lastrequesttime == -1 || (currenttime - lastrequesttime) > timeunit.seconds.tomillis(limit_period)) {
// 如果上一次请求时间不存在，或者当前时间与上一次请求时间之差超过了限流周期，则重置计数器
ops.set(key, string.valueof(currenttime));
ops.expire(key, limit_period, timeunit.seconds); // 设置键的过期时间
return true;
} else {
// 获取当前周期内的请求次数
string requestcountstr = ops.get(key + ":count");
int requestcount = requestcountstr != null ? integer.parseint(requestcountstr) : 0;
if (requestcount < limit_count) {
// 如果当前周期内的请求次数未达到阈值，则允许请求并增加计数器
ops.increment(key + ":count", 1);
return true;
} else {
// 如果当前周期内的请求次数已达到阈值，则拒绝请求
return false;
}
}
}
}注意：上面的代码实现了一个简单的滑动窗口限流算法，但它有一个问题，即在redis中存储了两个键（一个用于存储最后请求时间，另一个用于存储请求计数）。这可能会导致在极端情况下（如redis崩溃并重启后）的数据不一致性。为了简化示例，这里采用了这种方法。在生产环境中，你可能需要更复杂的实现，比如使用lua脚本来原子地执行这些操作，或者使用更高级的限流算法（如令牌桶或漏桶算法）。
4. 创建控制器
创建一个控制器类，用于处理api请求并调用限流服务：
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.getmapping;
import org.springframework.web.bind.annotation.requestparam;
import org.springframework.web.bind.annotation.restcontroller;
@restcontroller
public class apicontroller {
@autowired
private ratelimiterservice ratelimiterservice;
@getmapping("/limited")
public string limitedendpoint(@requestparam string userid) {
if (ratelimiterservice.isallowed(userid)) {
return "request processed successfully";
} else {
return "too many requests - try again later";
}
}
}三、resilience4j限流
resilience4j 是一个轻量级的、易于使用的容错库，它提供了多种容错机制，包括限流（rate limiter）。resilience4j 的限流器可以帮助你控制对某个服务的并发访问数量，从而防止系统过载。
以下是一个使用 resilience4j 限流器结合 spring boot 的完整代码示例：
1. 引入依赖
首先，在你的 pom.xml 文件中添加 resilience4j 和 spring boot starter 的依赖：
<dependencies>
<!-- spring boot starter web -->
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-web</artifactid>
</dependency>
<!-- resilience4j spring boot2 starter -->
<dependency>
<groupid>io.github.resilience4j</groupid>
<artifactid>resilience4j-spring-boot2</artifactid>
<version>你的版本号</version>
</dependency>
<!-- 其他依赖项 -->
</dependencies>2. 配置 resilience4j 限流器
在 application.yml 或 application.properties 文件中配置 resilience4j 限流器：
resilience4j.ratelimiter:
instances:
backenda:
limitforperiod: 10 # 在指定时间窗口内允许的请求数量
limitrefreshperiod: 10s # 时间窗口大小
timeoutduration: 0 # 可选，请求超时时间3. 创建限流配置类
创建一个配置类来定义和配置 resilience4j 的限流器实例：
import io.github.resilience4j.ratelimiter.ratelimiter;
import io.github.resilience4j.ratelimiter.ratelimiterconfig;
import io.github.resilience4j.ratelimiter.ratelimiterregistry;
import io.github.resilience4j.ratelimiter.annotation.ratelimiterconfigproperties;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;
@configuration
public class ratelimiterconfig {
@bean
public ratelimiterconfig ratelimiterconfig() {
return ratelimiterconfig.custom()
// 这里可以配置自定义的限流参数，如果已经在 application.yml 中配置了，则不需要在这里重复配置
.build();
}
@bean
public ratelimiterregistry ratelimiterregistry(ratelimiterconfig ratelimiterconfig) {
return ratelimiterregistry.of(ratelimiterconfig);
}
// 如果你想要通过代码方式配置限流器实例，而不是依赖 application.yml，可以这样做：
/*
@bean
@ratelimiterconfigproperties(name = "backenda")
public ratelimiter backendaratelimiter(ratelimiterregistry ratelimiterregistry) {
return ratelimiterregistry.ratelimiter("backenda");
}
*/
}注意：上面的 ratelimiterconfig 和 ratelimiterregistry bean 是为了展示如何通过代码配置 resilience4j，但在这个例子中，我们实际上是通过 application.yml 文件来配置限流器的。因此，上面的 ratelimiterconfig 和 backendaratelimiter bean 是可选的，并且在这个例子中不会被使用。
4. 使用限流器注解
在你的控制器或服务类中使用 @ratelimiter 注解来应用限流器：
import io.github.resilience4j.ratelimiter.annotation.ratelimiter;
import org.springframework.web.bind.annotation.getmapping;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.restcontroller;
@restcontroller
@requestmapping("/api")
public class mycontroller {
@ratelimiter(name = "backenda")
@getmapping("/limited")
public string limitedendpoint() {
return "请求成功！";
}
}5. 启动应用程序
现在，你可以启动你的 spring boot 应用程序，并通过浏览器或 api 测试工具发送请求到 /api/limited 端点来验证限流是否按预期工作。
当你超过配置的限流阈值时，resilience4j 会自动返回一个 blockedexception，你可以通过自定义异常处理器来处理这个异常，并向客户端返回友好的错误信息。
6. 自定义异常处理（可选）
你可以创建一个全局异常处理器来捕获 blockedexception 并返回自定义的响应：
import io.github.resilience4j.circuitbreaker.callnotpermittedexception;
import io.github.resilience4j.ratelimiter.blockedexception;
import org.springframework.http.httpstatus;
import org.springframework.http.responseentity;
import org.springframework.web.bind.annotation.controlleradvice;
import org.springframework.web.bind.annotation.exceptionhandler;
import org.springframework.web.context.request.webrequest;
@controlleradvice
public class globalexceptionhandler {
@exceptionhandler(blockedexception.class)
public responseentity<string> handleblockedexception(blockedexception ex, webrequest request) {
return new responseentity<>("too many requests - try again later", httpstatus.too_many_requests);
}
// 你可以在这里添加其他异常处理器的定义
}这样，当限流器阻止请求时，客户端将收到一个带有 429 too many requests 状态码的响应。
四、使用spring boot中的过滤器实现api限流
在spring boot中，你可以通过创建一个自定义过滤器（filter）来实现api限流。这种方法允许你在请求到达控制器之前进行拦截，并根据某些条件（如请求的ip地址、用户id等）来决定是否允许请求继续处理。
以下是一个使用spring boot中的过滤器实现简单api限流的完整代码示例：
1. 引入依赖
确保你的pom.xml文件中包含了spring boot的web依赖：
<dependencies>
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-web</artifactid>
</dependency>
<!-- 其他依赖项 -->
</dependencies>2. 创建限流过滤器
创建一个实现javax.servlet.filter接口的类，用于实现限流逻辑：
import javax.servlet.*;
import java.io.ioexception;
import java.util.concurrent.concurrenthashmap;
import java.util.concurrent.timeunit;
import java.util.concurrent.atomic.atomicinteger;
public class apiratelimiterfilter implements filter {
private static final int limit = 10; // 限流阈值
private static final int window_size_seconds = 60; // 时间窗口大小
private final concurrenthashmap<string, atomicinteger> requestcounts = new concurrenthashmap<>();
private final concurrenthashmap<string, long> lastrequesttimes = new concurrenthashmap<>();
@override
public void init(filterconfig filterconfig) throws servletexception {
// 初始化逻辑（可选）
}
@override
public void dofilter(servletrequest request, servletresponse response, filterchain chain)
throws ioexception, servletexception {
if (request instanceof httpservletrequest) {
httpservletrequest httprequest = (httpservletrequest) request;
string clientid = getclientid(httprequest); // 获取客户端id（可以是ip地址、用户id等）
long currenttime = system.currenttimemillis();
long lastrequesttime = lastrequesttimes.get(clientid);
atomicinteger count = requestcounts.computeifabsent(clientid, k -> new atomicinteger(0));
if (lastrequesttime == null || (currenttime - lastrequesttime) > timeunit.seconds.tomillis(window_size_seconds)) {
// 如果在时间窗口外，重置计数器
requestcounts.put(clientid, new atomicinteger(1));
lastrequesttimes.put(clientid, currenttime);
} else {
// 如果在时间窗口内，增加计数器
if (count.incrementandget() > limit) {
// 如果超过限流阈值，拒绝请求
response.getwriter().write("too many requests - try again later");
return;
}
// 更新最后请求时间
lastrequesttimes.put(clientid, currenttime);
}
// 允许请求继续处理
chain.dofilter(request, response);
} else {
chain.dofilter(request, response);
}
}
@override
public void destroy() {
// 清理逻辑（可选）
requestcounts.clear();
lastrequesttimes.clear();
}
// 获取客户端id的方法（这里以ip地址为例）
private string getclientid(httpservletrequest request) {
return request.getremoteaddr();
}
}3. 注册过滤器
你需要将过滤器注册到spring boot应用程序中。这可以通过在配置类上添加@component注解或使用filterregistrationbean来完成。
使用@component注解
import org.springframework.stereotype.component;
@component
public class apiratelimiterfilter extends ... {
// 过滤器实现（如上所示）
}使用filterregistrationbean
如果你不想在过滤器类上直接添加@component注解，你可以在配置类中注册它：
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<apiratelimiterfilter> loggingfilter(){
filterregistrationbean<apiratelimiterfilter> registrationbean
= new filterregistrationbean<>();
registrationbean.setfilter(new apiratelimiterfilter());
registrationbean.addurlpatterns("/api/*"); // 设置需要过滤的url模式
return registrationbean;
}
}4. 测试限流
现在，你可以启动spring boot应用程序，并通过浏览器或api测试工具发送请求到你的api端点来验证限流是否按预期工作。
注意：上面的代码实现了一个简单的计数器限流算法，但它并没有考虑多线程环境下的并发问题。在生产环境中，你可能需要使用更复杂的限流算法（如令牌桶、漏桶算法）或结合redis等分布式存储来实现更可靠的限流机制。此外，上面的代码示例没有实现持久化逻辑，因此在应用重启后，限流计数器会被重置。如果你需要持久化限流数据，你可能需要将其存储在数据库或其他持久化存储中。
到此这篇关于springboot高效实现api限流的多种方法实战的文章就介绍到这了,更多相关springboot api限流内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论