<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表達(dá)式，如 #dto.id）
     */
    String key();
 
    /**
     * 防抖時(shí)間，單位秒
     */
    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. 獲取方法、參數(shù)
        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表達(dá)式得到唯一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);
            // 是否返回上次結(jié)果
            if (debounceLimit.returnLastResult() && debounceResult.getResult() != null) {
                return debounceResult.getResult();
            }
            // 統(tǒng)一失敗響應(yīng)，可自定義異?；蚍祷亟Y(jié)構(gòu)
            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("在{}收到了請求，參數(shù)為：{}", DateUtil.now(), dto);
        return userService.getById(dto.getId()).getUsername();
    }
}