// ? 反例：硬編碼，邏輯混雜且難以復用
if (!rateLimiter.tryAcquire()) {
    throw new RuntimeException("系統(tǒng)繁忙");
}
doBusiness();

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>32.1.3-jre</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimit {
    /**
     * 限流閾值 (QPS)，默認每秒 5 個
     */
    double qps() default 5.0;
    /**
     * 獲取令牌的策略
     * true: 阻塞模式（直到拿到令牌或超時）
     * false: 非阻塞模式（拿不到立即失?。?
     */
    boolean block() default true;
    /**
     * 阻塞等待的超時時間（僅當 block=true 時生效）
     * 默認 0，表示無限等待
     */
    long timeout() default 0;
    /**
     * 超時時間單位
     */
    TimeUnit timeUnit() default TimeUnit.MILLISECONDS;
    /**
     * 預熱時間
     * 默認 0 (SmoothBursty)；設(shè)置 >0 則開啟預熱模式 (SmoothWarmingUp)
     */
    long warmupPeriod() default 0;
    /**
     * 預熱時間單位
     */
    TimeUnit warmupUnit() default TimeUnit.SECONDS;
    /**
     * 限流提示信息
     */
    String message() default "系統(tǒng)繁忙，請稍后再試";
}

public class RateLimitException extends RuntimeException {
    public RateLimitException(String message) {
        super(message);
    }
}

import com.google.common.util.concurrent.RateLimiter;
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.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Slf4j
@Aspect
@Component
public class RateLimitAop {
    
    // 使用 ConcurrentHashMap 緩存 RateLimiter 實例，確保線程安全
    // Key: 方法簽名 (類名.方法名(參數(shù)類型)), Value: 限流器實例
    private final Map<String, RateLimiter> rateLimiterCache = new ConcurrentHashMap<>();

    @Pointcut("@annotation(com.example.annotation.RateLimit)")
    public void rateLimitPointcut() {}

    @Around("rateLimitPointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        RateLimit annotation = method.getAnnotation(RateLimit.class);

        // 1. 構(gòu)建方法唯一 Key，防止方法重載沖突
        String methodKey = buildMethodKey(method);
        
        // 2. 線程安全地創(chuàng)建或獲取限流器
        RateLimiter rateLimiter = rateLimiterCache.computeIfAbsent(methodKey, key -> createRateLimiter(annotation));

        // 3. 執(zhí)行獲取令牌邏輯
        boolean acquireSuccess;
        if (annotation.block()) {
            // --- 阻塞模式 ---
            if (annotation.timeout() <= 0) {
                // 無限等待，直到成功
                rateLimiter.acquire();
                acquireSuccess = true;
            } else {
                // 限時等待
                acquireSuccess = rateLimiter.tryAcquire(annotation.timeout(), annotation.timeUnit());
            }
        } else {
            // --- 非阻塞模式 ---
            // 立即嘗試，失敗即返回
            acquireSuccess = rateLimiter.tryAcquire();
        }

        // 4. 限流攔截
        if (!acquireSuccess) {
            log.warn("【限流報警】方法 {} 請求頻率過高，已拒絕。", methodKey);
            throw new RateLimitException(annotation.message());
        }

        // 5. 放行
        return joinPoint.proceed();
    }

    /**
     * 生成方法簽名：Package.Class.Method(ParamType1,ParamType2)
     */
    private String buildMethodKey(Method method) {
        StringBuilder keyBuilder = new StringBuilder();
        keyBuilder.append(method.getDeclaringClass().getName())
                .append(".").append(method.getName()).append("(");
        Class<?>[] parameterTypes = method.getParameterTypes();
        for (int i = 0; i < parameterTypes.length; i++) {
            keyBuilder.append(parameterTypes[i].getSimpleName());
            if (i < parameterTypes.length - 1) {
                keyBuilder.append(",");
            }
        }
        keyBuilder.append(")");
        return keyBuilder.toString();
    }

    /**
     * 工廠方法：根據(jù)配置創(chuàng)建具體的 RateLimiter
     */
    private RateLimiter createRateLimiter(RateLimit annotation) {
        if (annotation.warmupPeriod() > 0) {
            log.info("創(chuàng)建預熱限流器: QPS={}, Warmup={}s", annotation.qps(), annotation.warmupPeriod());
            return RateLimiter.create(annotation.qps(), annotation.warmupPeriod(), annotation.warmupUnit());
        } else {
            log.info("創(chuàng)建標準限流器: QPS={}", annotation.qps());
            return RateLimiter.create(annotation.qps());
        }
    }
}

@Service
public class DataSyncService {

    // 場景1：核心數(shù)據(jù)同步，允許排隊等待500ms，保證盡可能執(zhí)行
    @RateLimit(qps = 10.0, block = true, timeout = 500)
    public void syncImportantData(List<Data> dataList) {
        // ... 業(yè)務(wù)邏輯 ...
    }

    // 場景2：非核心接口，流量大時直接丟棄，保護系統(tǒng)
    @RateLimit(qps = 50.0, block = false, message = "當前訪問人數(shù)過多")
    public void refreshCache() {
        // ... 刷新邏輯 ...
    }
}

@Service
public class TradeService {
    public void process() {
        // ... 前置處理 ...
        pay(); // ? 重點在這里：直接調(diào)用內(nèi)部方法
    }

    @RateLimit(qps = 5.0) 
    public void pay() { ... }
}

// 偽代碼示例：無縫切換分布式限流
private RRateLimiter getRedisLimiter(String key) {
    RRateLimiter limiter = redissonClient.getRateLimiter(key);
    // ... 初始化 Redis 限流器 ...
    return limiter;
}

// 在 around 方法里，將 RateLimiter.tryAcquire() 替換為 Redisson 的實現(xiàn)
RRateLimiter limiter = getRedisLimiter(methodKey);
if (!limiter.tryAcquire(annotation.qps(), annotation.timeout(), annotation.timeUnit())) {
    throw new RateLimitException("分布式限流生效中...");
}