用注解完成接口拦截

/**
 * @Author bestrookie
 * @Date 2024/1/9 16:27
 * @Desc
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface AccessInterceptor {
    //用哪个字段作为拦截标识，未配置则默认走全部
    String key() default "all";

    //限制频次（每秒请求次数）
    double permitsPerSecond();

    //黑名单拦截（多少次限制后加入黑名单）0不限制
    double blacklistCount() default 0;
    //拦截后的执行方法
    String fallbackMethod();

}

/**
 * @Author bestrookie
 * @Date 2024/1/9 17:09
 * @Desc
 */
@Slf4j
@Aspect
public class RateLimiterAOP {
    /**
     * 个人限频记录 1 分钟
     */
    private final Cache<String, RateLimiter> loginRecord = CacheBuilder.newBuilder().
            expireAfterWrite(1, TimeUnit.MINUTES).
            build();

    /**
     * 个人限频黑名单 24h
     */
    private final Cache<String, Long> blackList = CacheBuilder.newBuilder()
            .expireAfterWrite(24, TimeUnit.HOURS)
            .build();

    @Pointcut("@annotation(com.bestrookie.annotation.AccessInterceptor)")
    public void aopPoint(){
    }

    @Around("aopPoint() && @annotation(accessInterceptor)")
    public Object doRouter(ProceedingJoinPoint jp, AccessInterceptor accessInterceptor) throws Throwable{
        String key = accessInterceptor.key();
        if (StringUtils.isBlank(key)){
            throw new RuntimeException("annotation RateLimiter uId is null");
        }
        //获取拦截字段
        String keyAttr = getAttrValue(key, jp.getArgs());
        log.info("aop attr {}", keyAttr);
        //黑名单拦截
        if (!"all".equals(keyAttr) && accessInterceptor.blacklistCount() != 0
                && null != blackList.getIfPresent(keyAttr) &&
                blackList.getIfPresent(keyAttr) > accessInterceptor.blacklistCount()){
            log.info("限流-黑名单拦截 24h：{}",keyAttr);
            return fallbackMethodResult(jp, accessInterceptor.fallbackMethod());
        }
        //获取限流 ->Guava 缓存一分钟
        RateLimiter rateLimiter = loginRecord.getIfPresent(keyAttr);
        if (null == rateLimiter){
            rateLimiter = RateLimiter.create(accessInterceptor.permitsPerSecond());
            loginRecord.put(keyAttr, rateLimiter);
        }
        // 限流拦截
        if (!rateLimiter.tryAcquire()){
            if (accessInterceptor.blacklistCount() != 0){
                if (null == blackList.getIfPresent(keyAttr)){
                    blackList.put(keyAttr, 1L);
                }else {
                    blackList.put(keyAttr, blackList.getIfPresent(keyAttr) + 1L);
                }
            }
            log.info("限流-超频次拦截：{}", keyAttr);
            return fallbackMethodResult(jp, accessInterceptor.fallbackMethod());
        }
        return jp.proceed();

    }

    private Object fallbackMethodResult(JoinPoint jp, String fallbackMethod) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Signature sig = jp.getSignature();
        MethodSignature methodSignature = (MethodSignature) sig;
        Method method = jp.getTarget().getClass().getMethod(fallbackMethod, methodSignature.getParameterTypes());
        return method.invoke(jp.getThis(), jp.getArgs());
    }

    private Method getMethod(JoinPoint jp) throws NoSuchMethodException {
        Signature sig = jp.getSignature();
        MethodSignature methodSignature = (MethodSignature) sig;
        return jp.getTarget().getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes());
    }

    /**
     * 根据自身业务调整，主要是为了获取某个值做拦截
     */
    public String getAttrValue(String attr, Object[] args){
        if (args[0] instanceof String){
            return args[0].toString();
        }
        String filedValue = null;
        for (Object arg : args) {
            try {
                if (StringUtils.isNotBlank(filedValue)){
                    break;
                }
                filedValue = String.valueOf(this.getValueByName(arg, attr));
            }catch (Exception e){
                log.error("获取路由属性值失败 attr:{}", attr,e);
            }
        }
        return filedValue;
    }


    /**
     * 获取对象的特定属性值
     * @param item 对象
     * @param name 属性名
     * @return 属性值
     */
    private Object getValueByName(Object item, String name){
        try {
            Field  field = getFieldByName(item, name);
            if (field == null){
                return null;
            }
            field.setAccessible(true);
            Object o = field.get(item);
            field.setAccessible(false);
            return o;

        }catch (IllegalAccessException e){
            return null;
        }
    }


    /**
     * 根据名称获取方法，该方法同时兼顾继承类获取父类的属性
     * @param item item 对象
     * @param name 属性名
     * @return 该属性对应方法
     */
    private Field getFieldByName(Object item, String name){
        try {
            Field field;
            try {
                field = item.getClass().getDeclaredField(name);
            }catch (NoSuchFieldException e){
                field = item.getClass().getSuperclass().getDeclaredField(name);
            }
            return field;
        } catch (NoSuchFieldException e){
            return null;
        }
    }
}

@SpringBootApplication
@Slf4j
@Configurable
@RestController()
@RequestMapping("/api/ratelimiter/")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }

    @AccessInterceptor(key = "fingerprint", fallbackMethod = "loginErr", permitsPerSecond = 1.0d, blacklistCount = 10)
    @RequestMapping(value = "login", method = RequestMethod.GET)
    public String login(String fingerprint, String uId, String token) {
        log.info("模拟登录 fingerprint:{}", fingerprint);
        return "模拟登录：登录成功 " + uId;
    }

    public String loginErr(String fingerprint, String uId, String token) {
        return "频次限制，请勿恶意访问！";
    }

}