Java通过Caffeine和自定义注解实现本地防抖接口限流

        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>2.9.3</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

import java.lang.annotation.*;
 
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DebounceLimit {
    /**
     * 唯一key（支持SpEL表达式，如 #dto.id）
     */
    String key();
 
    /**
     * 防抖时间，单位秒
     */
    int ttl() default 2;
 
    /**
     * 是否返回上次缓存的返回值
     */
    boolean returnLastResult() default true;
}

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import java.util.concurrent.TimeUnit;
 
@Configuration
public class DebounceCacheConfig {
    @Bean
    public Cache<String, Object> debounceCache() {
        return Caffeine.newBuilder()
                .expireAfterWrite(1, TimeUnit.MINUTES)
                .maximumSize(100_000)
                .build();
    }
}

import com.github.benmanes.caffeine.cache.Cache;
import com.lps.anno.DebounceLimit;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
 
@Slf4j
@Aspect
@Component
public class DebounceLimitAspect {
 
    @Autowired
    private Cache<String, Object> debounceCache;
 
    private final ExpressionParser parser = new SpelExpressionParser();
 
    @Around("@annotation(debounceLimit)")
    public Object around(ProceedingJoinPoint pjp, DebounceLimit debounceLimit) throws Throwable {
        // 1. 获取方法、参数
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        Method method = methodSignature.getMethod();
        Object[] args = pjp.getArgs();
        String[] paramNames = methodSignature.getParameterNames();
        StandardEvaluationContext context = new StandardEvaluationContext();
        for (int i = 0; i < paramNames.length; i++) {
            context.setVariable(paramNames[i], args[i]);
        }
 
        // 2. 解析SpEL表达式得到唯一key
        String key = parser.parseExpression(debounceLimit.key()).getValue(context, String.class);
        String cacheKey = method.getDeclaringClass().getName() + "." + method.getName() + ":" + key;
 
        long now = System.currentTimeMillis();
        DebounceResult<Object> debounceResult = (DebounceResult<Object>) debounceCache.getIfPresent(cacheKey);
 
        if (debounceResult != null && (now - debounceResult.getTimestamp() < debounceLimit.ttl() * 1000L)) {
            String methodName = pjp.getSignature().toShortString();
            log.error("接口[{}]被限流, key={}", methodName, cacheKey);
            // 是否返回上次结果
            if (debounceLimit.returnLastResult() && debounceResult.getResult() != null) {
                return debounceResult.getResult();
            }
            // 统一失败响应，可自定义异常或返回结构
            return new RuntimeException("操作过于频繁，请稍后再试！");
        }
 
        Object result = pjp.proceed();
        debounceCache.put(cacheKey, new DebounceResult<>(result, now));
        return result;
    }
 
    @Getter
    static class DebounceResult<T> {
        private final T result;
        private final long timestamp;
 
        public DebounceResult(T result, long timestamp) {
            this.result = result;
            this.timestamp = timestamp;
        }
    }
}

@RestController
@RequiredArgsConstructor
@Slf4j
public class DebounceControl {
    private final UserService userService;
    @PostMapping("/getUsernameById")
    @DebounceLimit(key = "#dto.id", ttl = 10)
    public String test(@RequestBody User dto) {
        log.info("在{}收到了请求，参数为：{}", DateUtil.now(), dto);
        return userService.getById(dto.getId()).getUsername();
    }
}