java 自定义注解方式 + spring AOP + ExpiringMap 实现限制接口请求次数

ExpiringMap简介：

它具有高性能、低开销、零依赖、线程安全、使用ConcurrentMa的实现过期entries等优点。主要特点包括：过期策略、可变有效期、最大尺寸、侦听器过期、延迟输入加载、过期自省。
可设置Map中的Entry在一段时间后自动过期,key过期 value同时会过期。
可设置Map最大容纳值，当到达Maximum size后，再次插入值会导致Map中的第一个值过期。
可添加监听事件，在监听到Entry过期时调度监听函数。
可以设置懒加载，在调用get()方法时创建对象。
可以设置过期策略:
ExpirationPolicy.CREATED：在每次更新元素时，过期时间同时清零。
ExpirationPolicy.ACCESSED：在每次访问元素时，过期时间同时清零。

添加依赖

<dependency>
    <groupId>net.jodah</groupId>
    <artifactId>expiringmap</artifactId>
    <version>0.5.10</version>
</dependency>

自定义注解

package com.**.annotation;

import java.lang.annotation.*;

/**
 * @author Jeff_Wan
 * @description 控制接口访问次数
 * @date 2023/4/14
 */
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestLimit {

    /**
     * 限制的时间间隔 毫秒
     */
    long time() default 1000;

    /**
     * 限制时间内允许请求的次数
     */
    int count() default 1;
}

自定义切面AOP

package com.**.interceptor;

import com.**.Result;
import com.**.ResultCode;
import com.**.RequestLimit;
import net.jodah.expiringmap.ExpirationPolicy;
import net.jodah.expiringmap.ExpiringMap;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * @author Jeff_Wan
 * @description 自定义切面判定访问频率
 * @date 2023/4/14
 */
@Aspect
@Component
public class RequestLimitAspect {

    /**
     * 登记 book<String, ExpiringMap>
     * key -> 请求路径URI
     * value -> ExpiringMap<String, Integer>
     *          key -> 请求地址URL
     *          value -> 请求次数
     * */
    private static ConcurrentHashMap<String, ExpiringMap> book = new ConcurrentHashMap<>();

    /**
     * 定义切点 让所有标注@LimitRequest注解的方法都执行切面方法
     *
     * @param requestLimit 过期时间和最大访问次数
     */
    @Pointcut("@annotation(requestLimit)")
    public void executeService(RequestLimit requestLimit) {

    }

    /**
     * 执行方法
     *
     * @param proceedingJoinPoint 接收参数
     * @param requestLimit 过期时间和最大访问次数
     * @return 结果
     * @throws Throwable 异常
     */
    @Around("executeService(requestLimit)")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint, RequestLimit requestLimit) throws Throwable {
        // 获得request对象
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = servletRequestAttributes.getRequest();
        // 获取Map对象，如果没有则返回默认值，第一个参数是key，第二个参数是默认值
        ExpiringMap<String, Integer> expiringMap = book.getOrDefault(request.getRequestURI(), ExpiringMap.builder().variableExpiration().build());
        Integer requestCount = expiringMap.getOrDefault(request.getRemoteAddr(), 0);
        // 如果请求超过次数，不执行目标方法
        if (requestCount >= requestLimit.count()) {
            return Result.failed(ResultCode.NORMAL_ERR, "请求频率太快啦,请勿重复请求");
        } else if (requestCount == 0) {
            // 第一次请求时，设置有效时间 ExpirationPolicy(过期策略),duration(持续时间), TimeUnit(时间格式: 日、时、分、秒、毫秒)
            expiringMap.put(request.getRemoteAddr(), requestCount + 1, ExpirationPolicy.CREATED, requestLimit.time(), TimeUnit.MILLISECONDS);
        } else {
            // 未超过请求次数，记录+1
            expiringMap.put(request.getRemoteAddr(), requestCount + 1);
        }
        book.put(request.getRequestURI(), expiringMap);
        // 被拦截方法的返回值
        return proceedingJoinPoint.proceed();
    }
}

ConcurrentHashMap是多线程安全的Map，它的key是接口url，value是一个多线程安全且键值对是有有效期的Map（ExpiringMap）。

ExpiringMap的key是请求的ip地址，value是已经请求的次数

示例（注解加在方法上即可）

	@RequestLimit(time = 60000)
    @PostMapping("/add")
    public Result<?> saveBusiness(@RequestBody BusinessSaveOrUpParam params) {
        boolean result = businessService.saveBusiness(params);
        return Result.judge(result);
    }

结果