<!-- Spring AOP 核心依賴（限流核心） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- Redis 依賴（分布式限流必備，單機(jī)可省略） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 工具包（JSON 響應(yīng)、緩存操作，簡化代碼） -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.32</version>
</dependency>
<!--  lombok 依賴（簡化實(shí)體類、工具類代碼） -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

server:
  port: 8080 # 服務(wù)器端口
# Redis 配置（分布式限流必備）
spring:
  redis:
    host: localhost # Redis 地址（本地測試用）
    port: 6379 # Redis 端口
    password: # Redis 密碼（無密碼則留空）
    database: 0 # 數(shù)據(jù)庫索引
    lettuce:
      pool:
        max-active: 100 # 最大連接數(shù)
        max-idle: 10 # 最大空閑連接
        min-idle: 5 # 最小空閑連接
# 限流全局配置（可選，可在注解中覆蓋）
rate-limit:
  default-time: 60 # 默認(rèn)時(shí)間窗口（秒）
  default-count: 10 # 默認(rèn)最大請求次數(shù)
  default-type: FIXED_WINDOW # 默認(rèn)限流策略（FIXED_WINDOW：固定窗口，SLIDING_WINDOW：滑動(dòng)窗口）
  default-key-type: IP # 默認(rèn)限流key類型（IP：按IP限流，USER_ID：按用戶ID限流）

import java.lang.annotation.*;
/**
 * 自定義接口限流注解
 * @Target(ElementType.METHOD)：僅作用于方法（接口方法）
 * @Retention(RetentionPolicy.RUNTIME)：運(yùn)行時(shí)保留，AOP 切面可獲取注解屬性
 * @Documented：生成 API 文檔時(shí)，顯示該注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimit {
    /**
     * 限流策略（固定窗口/滑動(dòng)窗口）
     * 默認(rèn)為全局配置的策略，可在接口上單獨(dú)配置覆蓋
     */
    LimitType type() default LimitType.FIXED_WINDOW;
    /**
     * 限流key類型（按IP/按用戶ID）
     * 默認(rèn)為全局配置的key類型，可單獨(dú)覆蓋
     */
    KeyType keyType() default KeyType.IP;
    /**
     * 時(shí)間窗口（單位：秒）
     * 默認(rèn)為全局配置的時(shí)間，可單獨(dú)覆蓋（如 60=1分鐘，10=10秒）
     */
    int time() default 0;
    /**
     * 單位時(shí)間內(nèi)的最大請求次數(shù)（限流閾值）
     * 默認(rèn)為全局配置的次數(shù)，可單獨(dú)覆蓋
     */
    int count() default 0;
    /**
     * 限流提示信息（觸發(fā)限流時(shí)返回）
     */
    String message() default "請求過于頻繁，請稍后再試！";
    /**
     * 限流存儲(chǔ)方式（本地緩存/Redis）
     * 默認(rèn)為 Redis，單機(jī)部署可改為 LOCAL
     */
    StoreType storeType() default StoreType.REDIS;
    /**
     * 限流策略枚舉
     */
    enum LimitType {
        FIXED_WINDOW,  // 固定窗口限流
        SLIDING_WINDOW // 滑動(dòng)窗口限流
    }
    /**
     * 限流key類型枚舉
     */
    enum KeyType {
        IP,        // 按請求IP限流（最常用）
        USER_ID    // 按當(dāng)前登錄用戶ID限流（需結(jié)合用戶上下文）
    }
    /**
     * 存儲(chǔ)方式枚舉
     */
    enum StoreType {
        LOCAL,  // 本地緩存（單機(jī)部署用）
        REDIS   // Redis（分布式部署用）
    }
}

/**
 * 限流常量類（統(tǒng)一管理 Redis/本地緩存的key前綴，避免混亂）
 */
public class RateLimitConstant {
    // 限流key前綴（Redis中使用，如 rate_limit:ip:127.0.0.1:接口路徑）
    public static final String RATE_LIMIT_KEY_PREFIX = "rate_limit:";
    // 滑動(dòng)窗口小窗口大?。J(rèn)10秒，可根據(jù)需求調(diào)整）
    public static final int SLIDING_WINDOW_INTERVAL = 10;
}

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson2.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
/**
 * 限流工具類（實(shí)現(xiàn)固定窗口、滑動(dòng)窗口限流，支持本地/Redis存儲(chǔ)）
 */
@Slf4j
@Component
public class RateLimitUtil {
    // 本地緩存（單機(jī)限流用，ConcurrentHashMap 線程安全）
    private final ConcurrentHashMap&lt;String, Integer&gt; localCache = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, Long> localWindowCache = new ConcurrentHashMap<>();
    // Redis 模板（分布式限流用）
    @Autowired(required = false) // 單機(jī)部署時(shí)，Redis 可省略，避免報(bào)錯(cuò)
    private StringRedisTemplate stringRedisTemplate;
    /**
     * 固定窗口限流（核心方法）
     * @param key 限流key（如 ip:127.0.0.1:接口路徑）
     * @param time 時(shí)間窗口（秒）
     * @param count 最大請求次數(shù)
     * @param storeType 存儲(chǔ)方式（本地/Redis）
     * @return true=觸發(fā)限流，false=未觸發(fā)限流
     */
    public boolean fixedWindowLimit(String key, int time, int count, RateLimit.StoreType storeType) {
        if (storeType == RateLimit.StoreType.LOCAL) {
            // 本地緩存實(shí)現(xiàn)固定窗口
            return localFixedWindowLimit(key, time, count);
        } else {
            // Redis 實(shí)現(xiàn)固定窗口（分布式）
            return redisFixedWindowLimit(key, time, count);
        }
    }
    /**
     * 滑動(dòng)窗口限流（核心方法）
     * @param key 限流key（如 ip:127.0.0.1:接口路徑）
     * @param time 時(shí)間窗口（秒）
     * @param count 最大請求次數(shù)
     * @param storeType 存儲(chǔ)方式（本地/Redis）
     * @return true=觸發(fā)限流，false=未觸發(fā)限流
     */
    public boolean slidingWindowLimit(String key, int time, int count, RateLimit.StoreType storeType) {
        if (storeType == RateLimit.StoreType.LOCAL) {
            // 本地緩存實(shí)現(xiàn)滑動(dòng)窗口
            return localSlidingWindowLimit(key, time, count);
        } else {
            // Redis 實(shí)現(xiàn)滑動(dòng)窗口（分布式）
            return redisSlidingWindowLimit(key, time, count);
        }
    }
    /**
     * 本地緩存 - 固定窗口限流
     */
    private boolean localFixedWindowLimit(String key, int time, int count) {
        // 1. 獲取當(dāng)前窗口的請求次數(shù)
        Integer currentCount = localCache.getOrDefault(key, 0);
        // 2. 檢查是否超過限流閾值
        if (currentCount >= count) {
            log.warn("本地固定窗口限流觸發(fā)，key:{}，當(dāng)前次數(shù):{}，閾值:{}", key, currentCount, count);
            return true;
        }
        // 3. 第一次請求，設(shè)置窗口過期時(shí)間（time秒后清空）
        if (currentCount == 0) {
            localWindowCache.put(key, System.currentTimeMillis() + time * 1000);
        } else {
            // 檢查窗口是否過期，過期則重置次數(shù)和窗口時(shí)間
            Long expireTime = localWindowCache.get(key);
            if (System.currentTimeMillis() > expireTime) {
                localCache.put(key, 1);
                localWindowCache.put(key, System.currentTimeMillis() + time * 1000);
                return false;
            }
        }
        // 4. 未超過閾值，請求次數(shù)+1
        localCache.put(key, currentCount + 1);
        return false;
    }
    /**
     * Redis - 固定窗口限流（分布式，集群部署用）
     */
    private boolean redisFixedWindowLimit(String key, int time, int count) {
        // 1. 拼接 Redis key（加上前綴，避免與其他key沖突）
        String redisKey = RateLimitConstant.RATE_LIMIT_KEY_PREFIX + key;
        // 2. 自增請求次數(shù)（原子操作，避免并發(fā)問題）
        Long currentCount = stringRedisTemplate.opsForValue().increment(redisKey, 1);
        // 3. 第一次請求，設(shè)置過期時(shí)間（time秒）
        if (currentCount != null && currentCount == 1) {
            stringRedisTemplate.expire(redisKey, time, TimeUnit.SECONDS);
        }
        // 4. 檢查是否超過限流閾值
        if (currentCount != null && currentCount > count) {
            log.warn("Redis固定窗口限流觸發(fā)，key:{}，當(dāng)前次數(shù):{}，閾值:{}", redisKey, currentCount, count);
            return true;
        }
        return false;
    }
    /**
     * 本地緩存 - 滑動(dòng)窗口限流
     */
    private boolean localSlidingWindowLimit(String key, int time, int count) {
        long now = System.currentTimeMillis();
        // 1. 計(jì)算當(dāng)前窗口的起始時(shí)間（當(dāng)前時(shí)間 - 時(shí)間窗口）
        long windowStart = now - time * 1000;
        // 2. 拼接滑動(dòng)窗口的key（包含主key和小窗口時(shí)間）
        String windowKey = key + ":" + (now / (RateLimitConstant.SLIDING_WINDOW_INTERVAL * 1000));
        // 3. 獲取當(dāng)前小窗口的請求次數(shù)
        Integer currentWindowCount = localCache.getOrDefault(windowKey, 0);
        // 4. 遍歷所有小窗口，統(tǒng)計(jì)整個(gè)滑動(dòng)窗口內(nèi)的總請求次數(shù)
        int totalCount = 0;
        for (String cacheKey : localCache.keySet()) {
            if (cacheKey.startsWith(key + ":")) {
                // 解析小窗口時(shí)間
                long windowTime = Long.parseLong(cacheKey.split(":")[2]);
                long windowTimeMillis = windowTime * RateLimitConstant.SLIDING_WINDOW_INTERVAL * 1000;
                // 只統(tǒng)計(jì)當(dāng)前滑動(dòng)窗口內(nèi)的小窗口
                if (windowTimeMillis >= windowStart) {
                    totalCount += localCache.get(cacheKey);
                } else {
                    // 移除過期的小窗口緩存
                    localCache.remove(cacheKey);
                }
            }
        }
        // 5. 檢查是否超過限流閾值
        if (totalCount >= count) {
            log.warn("本地滑動(dòng)窗口限流觸發(fā)，key:{}，當(dāng)前總次數(shù):{}，閾值:{}", key, totalCount, count);
            return true;
        }
        // 6. 未超過閾值，當(dāng)前小窗口請求次數(shù)+1
        localCache.put(windowKey, currentWindowCount + 1);
        return false;
    }
    /**
     * Redis - 滑動(dòng)窗口限流（分布式，集群部署用）
     */
    private boolean redisSlidingWindowLimit(String key, int time, int count) {
        long now = System.currentTimeMillis();
        // 1. 計(jì)算當(dāng)前窗口的起始時(shí)間（當(dāng)前時(shí)間 - 時(shí)間窗口）
        long windowStart = now - time * 1000;
        // 2. 拼接 Redis key（加上前綴）
        String redisKey = RateLimitConstant.RATE_LIMIT_KEY_PREFIX + key;
        // 3. 小窗口大?。J(rèn)10秒，可調(diào)整）
        int interval = RateLimitConstant.SLIDING_WINDOW_INTERVAL;
        // 4. 當(dāng)前小窗口的時(shí)間戳（按小窗口大小取整）
        long currentWindow = now / (interval * 1000);
        // 5. Redis 原子操作：刪除過期小窗口 + 統(tǒng)計(jì)當(dāng)前窗口總次數(shù) + 自增當(dāng)前小窗口次數(shù)
        // 用 Lua 腳本實(shí)現(xiàn)原子操作，避免并發(fā)問題
        String luaScript = "local key = KEYS[1]\n" +
                "local windowStart = ARGV[1]\n" +
                "local currentWindow = ARGV[2]\n" +
                "local interval = ARGV[3]\n" +
                "local count = ARGV[4]\n" +
                "-- 刪除過期的小窗口（小于windowStart的小窗口）\n" +
                "redis.call('ZREMRANGEBYSCORE', key, 0, windowStart)\n" +
                "-- 統(tǒng)計(jì)當(dāng)前窗口內(nèi)的總請求次數(shù)\n" +
                "local total = redis.call('ZCARD', key)\n" +
                "if total >= tonumber(count) then\n" +
                "    return 1\n" +
                "end\n" +
                "-- 自增當(dāng)前小窗口的請求次數(shù)（將小窗口時(shí)間戳作為score，請求ID作為value）\n" +
                "redis.call('ZADD', key, currentWindow, currentWindow .. ':' .. redis.call('INCR', key .. ':seq'))\n" +
                "-- 設(shè)置過期時(shí)間（確保緩存自動(dòng)清理）\n" +
                "redis.call('EXPIRE', key, tonumber(interval) + 1)\n" +
                "return 0";
        // 執(zhí)行 Lua 腳本
        Long result = stringRedisTemplate.execute(
                new org.springframework.data.redis.core.script.DefaultRedisScript<>(luaScript, Long.class),
                Arrays.asList(redisKey),
                String.valueOf(windowStart),
                String.valueOf(currentWindow),
                String.valueOf(interval),
                String.valueOf(count)
        );
        // 6. 結(jié)果判斷：1=觸發(fā)限流，0=未觸發(fā)
        if (result != null && result == 1) {
            log.warn("Redis滑動(dòng)窗口限流觸發(fā)，key:{}，閾值:{}", redisKey, count);
            return true;
        }
        return false;
    }
    /**
     * 清除指定key的限流緩存（用于特殊場景，如用戶注銷、IP解封）
     */
    public void clearLimitCache(String key, RateLimit.StoreType storeType) {
        if (storeType == RateLimit.StoreType.LOCAL) {
            // 清除本地緩存（包含所有小窗口）
            localCache.keySet().removeIf(k -> k.startsWith(key) || k.equals(key));
            localWindowCache.remove(key);
        } else {
            // 清除Redis緩存
            String redisKey = RateLimitConstant.RATE_LIMIT_KEY_PREFIX + key;
            stringRedisTemplate.delete(redisKey);
            stringRedisTemplate.delete(redisKey + ":seq");
        }
    }
}

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
/**
 * IP工具類（獲取客戶端真實(shí)IP，處理Nginx代理等場景）
 */
public class IpUtil {
    /**
     * 獲取客戶端真實(shí)IP
     */
    public static String getClientIp() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes == null) {
            return "127.0.0.1"; // 非web環(huán)境，默認(rèn)本地IP
        }
        HttpServletRequest request = attributes.getRequest();
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        // 處理多代理場景，取第一個(gè)非unknown的IP
        if (ip != null && ip.contains(",")) {
            ip = ip.split(",")[0].trim();
        }
        // 本地環(huán)境默認(rèn)IP（避免localhost解析問題）
        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
    }
}

/**
 * 用戶上下文（獲取當(dāng)前登錄用戶信息，用于按用戶ID限流）
 */
public class UserContext {
    /**
     * 獲取當(dāng)前登錄用戶ID（模擬，實(shí)際從JWT/Token中解析）
     * @return 用戶ID（未登錄返回null）
     */
    public static Long getCurrentUserId() {
        // 模擬：登錄用戶ID為1001，未登錄返回null
        // 實(shí)際項(xiàng)目替換為：JwtUtils.parseToken(token).getUserId()
        return 1001L;
    }
}

import com.alibaba.fastjson2.JSONObject;
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.beans.factory.annotation.Value;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.lang.reflect.Method;
/**
 * 接口限流切面（核心類）
 * @Aspect：標(biāo)記此類為AOP切面
 * @Component：交給Spring管理，確保Spring能掃描到
 * @Order(1)：優(yōu)先級(jí)高于日志切面（避免限流請求被記錄日志）
 * @Slf4j：日志輸出
 */
@Aspect
@Component
@Order(1)
@Slf4j
public class RateLimitAspect {
    // 注入限流工具類
    @Resource
    private RateLimitUtil rateLimitUtil;
    // 全局默認(rèn)配置（從配置文件讀?。?
    @Value("${rate-limit.default-time}")
    private int defaultTime;
    @Value("${rate-limit.default-count}")
    private int defaultCount;
    @Value("${rate-limit.default-type}")
    private RateLimit.LimitType defaultLimitType;
    @Value("${rate-limit.default-key-type}")
    private RateLimit.KeyType defaultKeyType;
    // 1. 定義切點(diǎn)：攔截所有添加了 @RateLimit 注解的方法
    @Pointcut("@annotation(com.example.demo.annotation.RateLimit)")
    public void rateLimitPointcut() {}
    // 2. 環(huán)繞通知：包裹目標(biāo)方法，執(zhí)行限流校驗(yàn)
    @Around("rateLimitPointcut()")
    public Object doRateLimit(ProceedingJoinPoint joinPoint) throws Throwable {
        // 第一步：獲取目標(biāo)方法上的 @RateLimit 注解
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method targetMethod = signature.getMethod();
        RateLimit rateLimitAnno = targetMethod.getAnnotation(RateLimit.class);
        // 第二步：獲取注解配置的限流參數(shù)（無配置則用全局默認(rèn)值）
        RateLimit.LimitType limitType = rateLimitAnno.type() == RateLimit.LimitType.FIXED_WINDOW ?
                rateLimitAnno.type() : defaultLimitType;
        RateLimit.KeyType keyType = rateLimitAnno.keyType() == RateLimit.KeyType.IP ?
                rateLimitAnno.keyType() : defaultKeyType;
        int time = rateLimitAnno.time() == 0 ? defaultTime : rateLimitAnno.time();
        int count = rateLimitAnno.count() == 0 ? defaultCount : rateLimitAnno.count();
        String message = rateLimitAnno.message();
        RateLimit.StoreType storeType = rateLimitAnno.storeType();
        // 第三步：生成限流key（根據(jù)keyType生成，確保唯一）
        String limitKey = generateLimitKey(joinPoint, keyType);
        log.info("接口限流校驗(yàn)，key:{}，策略:{}，時(shí)間窗口:{}秒，閾值:{}次",
                limitKey, limitType, time, count);
        // 第四步：執(zhí)行限流校驗(yàn)（根據(jù)限流策略選擇對應(yīng)的方法）
        boolean isLimit = false;
        if (limitType == RateLimit.LimitType.FIXED_WINDOW) {
            isLimit = rateLimitUtil.fixedWindowLimit(limitKey, time, count, storeType);
        } else if (limitType == RateLimit.LimitType.SLIDING_WINDOW) {
            isLimit = rateLimitUtil.slidingWindowLimit(limitKey, time, count, storeType);
        }
        // 第五步：判斷是否觸發(fā)限流，觸發(fā)則拋出異常
        if (isLimit) {
            throw new RateLimitException(429, message);
        }
        // 第六步：限流校驗(yàn)通過，執(zhí)行目標(biāo)方法（核心業(yè)務(wù)邏輯）
        return joinPoint.proceed();
    }
    /**
     * 生成限流key（確保唯一，避免不同接口/不同IP/不同用戶的限流沖突）
     * @param joinPoint 切入點(diǎn)（獲取接口路徑）
     * @param keyType 限流key類型（IP/USER_ID）
     * @return 唯一限流key
     */
    private String generateLimitKey(ProceedingJoinPoint joinPoint, RateLimit.KeyType keyType) {
        // 獲取接口路徑（如 /api/auth/login）
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getDeclaringTypeName() + "." + signature.getMethod().getName();
        // 根據(jù)keyType生成不同的限流key
        if (keyType == RateLimit.KeyType.IP) {
            // 按IP限流：ip:接口路徑（如 ip:127.0.0.1:com.example.demo.controller.AuthController.login）
            String ip = IpUtil.getClientIp();
            return "ip:" + ip + ":" + methodName;
        } else if (keyType == RateLimit.KeyType.USER_ID) {
            // 按用戶ID限流：user:用戶ID:接口路徑（如 user:1001:com.example.demo.controller.UserController.edit）
            Long userId = UserContext.getCurrentUserId();
            if (userId == null) {
                // 未登錄用戶，按IP限流（避免key為空）
                String ip = IpUtil.getClientIp();
                return "ip:" + ip + ":" + methodName;
            }
            return "user:" + userId + ":" + methodName;
        }
        // 默認(rèn)按IP限流
        String ip = IpUtil.getClientIp();
        return "ip:" + ip + ":" + methodName;
    }
}

import lombok.Data;
import lombok.EqualsAndHashCode;
/**
 * 自定義限流異常（觸發(fā)限流時(shí)拋出）
 * 429 狀態(tài)碼：Too Many Requests（請求過于頻繁）
 */
@Data
@EqualsAndHashCode(callSuper = true)
public class RateLimitException extends RuntimeException {
    // 錯(cuò)誤碼（429 標(biāo)準(zhǔn)限流狀態(tài)碼）
    private Integer code;
    // 錯(cuò)誤信息（自定義提示）
    private String message;
    // 構(gòu)造方法（簡化異常拋出）
    public RateLimitException(Integer code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }
}

import com.alibaba.fastjson2.JSONObject;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
/**
 * 全局異常處理器（統(tǒng)一響應(yīng)格式）
 */
@RestControllerAdvice
public class GlobalExceptionHandler {
    // 攔截限流異常（429 狀態(tài)碼）
    @ExceptionHandler(RateLimitException.class)
    public JSONObject handleRateLimitException(RateLimitException e) {
        JSONObject response = new JSONObject();
        response.put("code", e.getCode());
        response.put("msg", e.getMessage());
        response.put("data", null);
        return response;
    }
    // 攔截其他異常（兜底處理）
    @ExceptionHandler(Exception.class)
    public JSONObject handleException(Exception e) {
        JSONObject response = new JSONObject();
        response.put("code", 500);
        response.put("msg", "服務(wù)器內(nèi)部異常，請聯(lián)系管理員");
        response.put("data", null);
        return response;
    }
}

import com.example.demo.annotation.RateLimit;
import com.example.demo.util.UserContext;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * 測試接口（覆蓋限流多場景）
 */
@RestController
@RequestMapping("/api")
public class TestController {
    /**
     * 場景1：短信驗(yàn)證碼接口（按IP限流，固定窗口，1分鐘最多3次）
     * 高頻場景，防止惡意刷短信
     */
    @RateLimit(
            type = RateLimit.LimitType.FIXED_WINDOW,
            keyType = RateLimit.KeyType.IP,
            time = 60, // 1分鐘
            count = 3, // 最多3次
            message = "短信發(fā)送過于頻繁，請1分鐘后再試！"
    )
    @PostMapping("/sms/send")
    public String sendSms(String phone) {
        // 核心業(yè)務(wù)邏輯：發(fā)送短信驗(yàn)證碼
        return "短信已發(fā)送至：" + phone;
    }
    /**
     * 場景2：登錄接口（按IP限流，滑動(dòng)窗口，10秒最多2次）
     * 防止惡意暴力破解密碼，滑動(dòng)窗口避免臨界問題
     */
    @RateLimit(
            type = RateLimit.LimitType.SLIDING_WINDOW,
            keyType = RateLimit.KeyType.IP,
            time = 10, // 10秒
            count = 2, // 最多2次
            message = "登錄請求過于頻繁，請10秒后再試！"
    )
    @PostMapping("/auth/login")
    public String login(String username, String password) {
        // 核心業(yè)務(wù)邏輯：用戶登錄
        return "登錄成功，歡迎您：" + username;
    }
    /**
     * 場景3：個(gè)人中心接口（按用戶ID限流，固定窗口，1分鐘最多10次）
     * 登錄后接口，按用戶ID限流，避免單個(gè)用戶惡意請求
     */
    @RateLimit(
            type = RateLimit.LimitType.FIXED_WINDOW,
            keyType = RateLimit.KeyType.USER_ID,
            time = 60,
            count = 10,
            message = "操作過于頻繁，請1分鐘后再試！"
    )
    @GetMapping("/user/profile")
    public String userProfile() {
        Long userId = UserContext.getCurrentUserId();
        // 核心業(yè)務(wù)邏輯：查詢用戶個(gè)人信息
        return "用戶ID：" + userId + "，個(gè)人信息查詢成功";
    }
    /**
     * 場景4：分布式限流（Redis存儲(chǔ)，滑動(dòng)窗口，5秒最多5次）
     * 集群部署場景，確保多節(jié)點(diǎn)限流統(tǒng)一
     */
    @RateLimit(
            type = RateLimit.LimitType.SLIDING_WINDOW,
            keyType = RateLimit.KeyType.IP,
            time = 5,
            count = 5,
            storeType = RateLimit.StoreType.REDIS,
            message = "請求過于頻繁，請5秒后再試！"
    )
    @GetMapping("/test/distributed")
    public String distributedLimit() {
        // 核心業(yè)務(wù)邏輯：分布式場景測試
        return "分布式限流測試成功";
    }
}