### Spring Boot 中基于
Redis 和 RateLimit
实现限流切面的示例
以下是完整的代码示例，展示如何在 Spring Boot 应用程序中使用 AOP 和
Redis 来
实现接口限流功能。
#### 1. 添加依赖项
首先，在 `pom.xml` 文件中引入必要的依赖项：
```xml
<dependencies>
<!-- Spring Boot Starter AOP -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- Spring Data
Redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-
redis</artifactId>
</dependency>
<!-- Lettuce or Jedis as the
Redis client -->
<dependency>
<groupId>io.lettuce.core</groupId>
<artifactId>lettuce-core</artifactId>
</dependency>
</dependencies>
```
---
#### 2. 配置
Redis 参数
在 `application.properties` 或 `application.yml` 文件中配置
Redis 连接参数：
```properties
#
Redis Configuration
spring.
redis.host=localhost
spring.
redis.port=6379
spring.
redis.password=
spring.
redis.timeout=10000ms
spring.
redis.lettuce.pool.max-active=10
spring.
redis.lettuce.pool.max-idle=5
spring.
redis.lettuce.pool.min-idle=1
```
---
#### 3. 创建自定义注解 `@RateLimit`
定义一个注解，用于标记需要限流的接口，并指定限流策略。
```
java
import
java.lang.annotation.ElementType;
import
java.lang.annotation.Retention;
import
java.lang.annotation.RetentionPolicy;
import
java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
int limit(); // 单位时间内允许的最大
请求数
long timeWindowInSeconds(); // 时间窗口长度（单位：秒）
}
```
---
#### 4. 编写限流服务类 `RateLimiterService`
封装
Redis 操作逻辑，提供限流判断方法。
```
java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.
redis.core.String
RedisTemplate;
import org.springframework.stereotype.Service;
@Service
public class RateLimiterService {
private final String
RedisTemplate
redisTemplate;
@Autowired
public RateLimiterService(String
RedisTemplate
redisTemplate) {
this.
redisTemplate =
redisTemplate;
}
/**
* 判断当前
请求是否被允许通过限流检查。
*
* @param key
请求唯一标识符（如用户ID/
IP地址/接口名称等）
* @param limit 允许的最大
请求数量
* @param duration 时间窗口长度（秒）
* @return true 表示允许访问；false 表示已超出限流范围
*/
public boolean isAllowed(String key, int limit, long duration) {
String value =
redisTemplate.opsForValue().get(key);
int currentCount = (value != null) ? Integer.parseInt(value) : 0;
if (currentCount >= limit) {
return false; // 已达到限流上限
}
// 更新计数器并设置过期时间
redisTemplate.opsForValue().setIfAbsent(key, "0", duration); // 初始化键值
redisTemplate.opsForValue().increment(key);
return true;
}
}
```
---
#### 5. 创建 AOP 切面类 `RateLimitAspect`
利用 Spring AOP 截获带有 `@RateLimit` 注解的方法，并应用限流逻辑。
```
java
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class RateLimitAspect {
private static final Logger logger = LoggerFactory.getLogger(RateLimitAspect.class);
@Autowired
private RateLimiterService rateLimiterService;
@Around("@annotation(rateLimit)")
public Object handleRateLimit(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
String methodName = joinPoint.getSignature().getName();
String uniqueKey = "rate_limit:"
+ methodName;
// 获取限流参数
int maxRequests = rateLimit.limit();
long windowSizeInSeconds = rateLimit.timeWindowInSeconds();
// 执行限流检查
if (!rateLimiterService.isAllowed(uniqueKey, maxRequests, windowSizeInSeconds)) {
logger.warn("Request rejected due to exceeding rate limit: {}", methodName);
throw new RuntimeException("Too many requests");
}
// 继续执行目标方法
return joinPoint.proceed();
}
}
```
---
#### 6. 测试控制器
创建一个简单的 REST 控制器，测试限流效果。
```
java
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestController {
@GetMapping("/test")
@RateLimit(limit = 5, timeWindowInSeconds = 10) // 每10秒最多允许5次
请求
public String testMethod() {
return "This method has been accessed successfully!";
}
}
```
---
### 总结
以上代码展示了如何在 Spring Boot 中集成
Redis 和 AOP 技术来
实现接口限流功能。核心思路是通过
Redis 记录
请求次数，并结合滑动窗口算法动态调整限流状态[^1]。
```
lua
--
Lua 脚本用于更高效的限流操作
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local increment = tonumber(ARGV[2])
local current = tonumber(
redis.call('GET', key) or '0')
if current
+ increment > limit then
return 0 -- 达到限流阈值
else
redis.call('INCRBY', key, increment)
redis.call('EXPIRE', key, ARGV[3]) -- 设置超时时间
return 1 -- 正常
请求
end
```
本文介绍了如何利用SpringBoot、Redis和Lua脚本来防止IP重复请求，以防御黑客或恶意用户的防刷攻击。通过限制10秒内同一IP最多访问30次，有效避免系统资源被耗尽。详细阐述了分析过程和具体实现，包括Lua脚本的使用。
最低0.47元/天 解锁文章
扫一扫
1152
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
