在SpringBoot应用中，我们经常会遇到需要限制控制器访问次数的需求，以防止恶意用户或机器人对特定接口进行频繁的请求，从而影响服务器性能或安全性。本文将详细介绍如何通过自定义注解来实现这一功能。
我们需要创建一个自定义注解`RequestLimit`，用于标记在哪个控制器方法上应用访问限制。以下是一个简单的`RequestLimit`注解定义：
```java
package example.controller.limit;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
@Order(Ordered.HIGHEST_PRECEDENCE)
public @interface RequestLimit {
int count() default Integer.MAX_VALUE; // 允许访问的次数，默认为最大值
long time() default 60000; // 时间段，单位为毫秒，默认为一分钟
}
```
这个注解有两个属性：`count`和`time`。`count`定义了在`time`时间内允许的请求次数，`time`定义了这个时间窗口的长度。
接下来，我们需要定义一个异常类`RequestLimitException`，当访问次数超过限制时抛出此异常。这将帮助我们在处理此类问题时提供统一的错误响应：
```java
package example.controller.exception;
public class RequestLimitException extends Exception {
public RequestLimitException() {
super("HTTP请求超出设定的限制");
}
public RequestLimitException(String message) {
super(message);
}
}
```
然后，我们需要创建一个切面（Aspect）类`RequestLimitContract`，它使用Spring AOP（面向切面编程）来拦截标记有`RequestLimit`注解的方法，并执行访问次数检查：
```java
package example.controller.limit;
import example.controller.exception.RequestLimitException;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;
@Aspect
@Component
public class RequestLimitContract {
private static final Logger logger = LoggerFactory.getLogger("RequestLimitLogger");
private Map<String, Integer> redisTemplate = new HashMap<>();
@Before("within(@org.springframework.stereotype.Controller *) && @annotation(requestLimit)")
public void limitRequest(JoinPoint joinPoint, RequestLimit requestLimit) throws RequestLimitException {
HttpServletRequest request = ((HttpServletRequest) joinPoint.getArgs()[0]);
String key = request.getRequestURI();
synchronized (redisTemplate) {
if (redisTemplate.containsKey(key)) {
int currentCount = redisTemplate.get(key);
if (currentCount >= requestLimit.count()) {
throw new RequestLimitException();
} else {
redisTemplate.put(key, currentCount + 1);
}
} else {
redisTemplate.put(key, 1);
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
redisTemplate.remove(key);
}
}, requestLimit.time());
}
}
}
}
```
在这个切面类中，我们定义了一个`@Before`注解的方法，该方法会在标记有`RequestLimit`注解的方法执行之前被调用。我们获取请求的URI作为key，存储在内存中的`redisTemplate`映射中。如果访问次数超过限制，就抛出`RequestLimitException`。同时，我们使用`TimerTask`定时器来清除过期的记录。
请注意，这个示例中使用的是一个简单的内存数据结构来存储计数信息。在实际生产环境中，可能需要使用Redis等持久化存储来确保数据的可靠性，并处理并发访问时的同步问题。此外，为了更精确地控制访问限制，可以考虑使用Spring Cache或Spring Data Redis等工具来实现。
总结来说，通过自定义`RequestLimit`注解、异常类`RequestLimitException`以及切面类`RequestLimitContract`，我们可以有效地在SpringBoot中实现控制器访问次数的限制，以增强应用程序的安全性和性能。这种方法具有较高的灵活性，可以根据业务需求调整限制策略，同时也易于扩展以适应不同的场景。
