RateLimiter 限流 —— 通过切面对单个用户进行限流和黑名单处理

<script>
  // Initialize the agent at application startup.
  const fpPromise = import('https://openfpcdn.io/fingerprintjs/v4')
    .then(FingerprintJS => FingerprintJS.load())
 
  // Get the visitor identifier when you need it.
  fpPromise
    .then(fp => fp.get())
    .then(result => {
      // This is the visitor identifier:
      const visitorId = result.visitorId
      console.log(visitorId)
    })
</script>

public @interface AccessInterceptor {
 
    /** 用哪个字段作为拦截标识，未配置则默认走全部 */
    String key() default "all";
 
    /** 限制频次（每秒请求次数） */
    double permitsPerSecond();
 
    /** 黑名单拦截（多少次限制后加入黑名单）0 不限制 */
    double blacklistCount() default 0;
 
    /** 黑名单持续时间（秒） */
    long blacklistDurationSeconds() default 24 * 3600; // 默认为24小时
 
    /** 拦截后的执行方法 */
    String fallbackMethod();
 
 
}

@Slf4j
@Aspect
public class RateLimiterAOP {
 
    @Resource
    private RedissonClient redissonClient;
 
 
    @Pointcut("@annotation(cn.bugstack.chatgpt.data.types.annotation.AccessInterceptor)")
    public void aopPoint() {
    }
 
 
    @Around("aopPoint() && @annotation(accessInterceptor)")
    public Object doRouter(ProceedingJoinPoint jp, AccessInterceptor accessInterceptor) throws Throwable {
        String key = accessInterceptor.key();
        if (key == null || key.isEmpty()) {
            throw new IllegalArgumentException("RateLimiter key is null or empty!");
        }
 
        // 获取拦截字段
        String keyAttr = getAttrValue(key, jp.getArgs());
        log.info("aop attr {}", keyAttr);
 
        // 黑名单拦截
        if (!"all".equals(keyAttr) && accessInterceptor.blacklistCount() != 0 && isBlacklisted(keyAttr, accessInterceptor)) {
            log.info("限流-黑名单拦截(24h)：{}", keyAttr);
            return fallbackMethodResult(jp, accessInterceptor.fallbackMethod());
        }
 
        // 速率限制
        if (!isRateLimited(keyAttr, accessInterceptor)) {
            log.info("限流-超频次拦截：{}", keyAttr);
            return fallbackMethodResult(jp, accessInterceptor.fallbackMethod());
        }
 
        // 返回结果
        return jp.proceed();
    }
 
    /**
     * 黑名单
     * @param keyAttr
     * @param accessInterceptor
     * @return
     */
    private boolean isBlacklisted(String keyAttr, AccessInterceptor accessInterceptor) {
        String blacklistKey = "blacklist:" + keyAttr;
        long count = redissonClient.getAtomicLong(blacklistKey).incrementAndGet();
        redissonClient.getAtomicLong(blacklistKey).expire(accessInterceptor.blacklistDurationSeconds(), TimeUnit.SECONDS);
        return count > accessInterceptor.blacklistCount();
    }
 
    /**
     * 限流
     * @param keyAttr
     * @param accessInterceptor
     * @return
     */
    private boolean isRateLimited(String keyAttr, AccessInterceptor accessInterceptor) {
        String rateLimitKey = "ratelimit:" + keyAttr;
        RRateLimiter rateLimiter = redissonClient.getRateLimiter(rateLimitKey);
        // 设置速率
        rateLimiter.trySetRate(RateType.OVERALL, (long) accessInterceptor.permitsPerSecond(), 1, RateIntervalUnit.SECONDS);
        // 尝试获取许可
        return rateLimiter.tryAcquire();
    }
 
 
    /**
     * 调用用户配置的回调方法，当拦截后，返回回调结果。
     */
 
    private Object fallbackMethodResult(ProceedingJoinPoint jp, String fallbackMethod) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        MethodSignature methodSignature = (MethodSignature) jp.getSignature();
        Method method = jp.getTarget().getClass().getMethod(fallbackMethod, methodSignature.getParameterTypes());
        return method.invoke(jp.getThis(), jp.getArgs());
    }
 
 
    /**
     * 实际根据自身业务调整，主要是为了获取通过某个值做拦截
     */
    private String getAttrValue(String attr, Object[] args) {
        if (args[0] instanceof String) {
            return (String) args[0];
        }
        String fieldValue = null;
        for (Object arg : args) {
            try {
                if (fieldValue != null) {
                    break;
                }
                fieldValue = String.valueOf(getValueByName(arg, attr));
            } catch (Exception e) {
                log.error("获取属性值失败 attr：{}", attr, e);
            }
        }
        return fieldValue;
    }
 
 
    /**
     * 获取对象的特定属性值
     *
     * @param item 对象
     * @param name 属性名
     * @return 属性值
     * @author tang
     */
 
    private Object getValueByName(Object item, String name) {
        try {
            Field field = getFieldByName(item, name);
            if (field == null) {
                return null;
            }
            field.setAccessible(true);
            Object value = field.get(item);
            field.setAccessible(false);
            return value;
        } catch (IllegalAccessException e) {
            return null;
        }
    }
 
    /**
     * 根据名称获取方法，该方法同时兼顾继承类获取父类的属性
     *
     * @param item 对象
     * @param name 属性名
     * @return 该属性对应方法
     * @author tang
     */
 
    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;
        }
    }
 
 
}

@Configuration
public class RateLimiterAOPConfig {
 
    @Bean
    public RateLimiterAOP rateLimiter(){
        return new RateLimiterAOP();
    }
 
}