package com.example.demo.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface WindowRateLimit {
    // 允許的最大請求數(shù)
    int limit();
    // 窗口時間長度，單位毫秒
    long timeWindowMilliseconds();
}

package com.example.demo.uitls;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.LinkedList;
/**
 * SlidingWindowRateLimiter : 滑動窗口限流算法
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SlidingWindowRateLimiter implements Serializable {
    /**
     * 請求隊列
     */
    private LinkedList<Long> requests = new LinkedList<>();
    /**
     * 最大請求數(shù)
     */
    private int maxRequests;
    /**
     * 窗口大小
     */
    private long windowSizeInMilliseconds;
    public SlidingWindowRateLimiter(int maxRequests, long windowSizeInMilliseconds) {
        this.maxRequests = maxRequests;
        this.windowSizeInMilliseconds = windowSizeInMilliseconds;
    }
    /**
     * 判斷是否允許請求
     * @return
     */
    public synchronized boolean allowRequest() {
        // 獲取當前時間
        long currentTime = System.currentTimeMillis();
        // 清除窗口之外的舊請求
        while (!requests.isEmpty() && currentTime - requests.peekFirst() > windowSizeInMilliseconds) {
            requests.removeFirst();
        }
        // 如果當前窗口請求未達到上限，則允許請求并記錄
        if (requests.size() < maxRequests) {
            requests.addLast(currentTime);
            return true;
        } else {
            // 達到限流閾值，拒絕請求
            return false;
        }
    }
}

package com.example.demo.aspect;
import com.example.demo.annotation.WindowRateLimit;
import com.example.demo.config.redis.RedisKeyEnum;
import com.example.demo.uitls.RedisUtil;
import com.example.demo.uitls.SlidingWindowRateLimiter;
import jakarta.annotation.Resource;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
/**
 * RateLimiterAspect :
 */
@Aspect
@Component
public class SlidingWindowRateLimiterAspect {
    @Resource
    private RedisUtil redisUtil;
    @Around("@annotation(rateLimit)")
    public Object applyRateLimit(ProceedingJoinPoint joinPoint, WindowRateLimit rateLimit) throws Throwable {
        // 獲取調(diào)用的方法名
        String methodName = joinPoint.getSignature().getName();
        // 獲取方法對應的緩存滑動窗口限流器KEY
        String key = RedisKeyEnum.WINDOW_CURRENT_LIMITING.getKey() + methodName;
        // 從緩存中獲取滑動窗口限流器
        SlidingWindowRateLimiter rateLimiter = redisUtil.getCacheObject(key);
        // 如果滑動窗口限流器不存在，則創(chuàng)建一個新限流器
        if (rateLimiter == null) {
            rateLimiter = new SlidingWindowRateLimiter(rateLimit.limit(), rateLimit.timeWindowMilliseconds());
        }
        // 如果滑動窗口限流器存在，則判斷是否允許請求
        if (!rateLimiter.allowRequest()) {
            throw new RuntimeException("Too many requests, please try again later.");
        }
        // 如果允許請求，則更新滑動窗口限流器,緩存過期時間設置為滑動窗口限流器時間窗口
        redisUtil.setCacheObject(key, rateLimiter, rateLimit.timeWindowMilliseconds(), TimeUnit.MILLISECONDS);
        // 允許執(zhí)行方法
        return joinPoint.proceed();
    }
}

package com.example.demo.service.impl;
import com.example.demo.annotation.WindowRateLimit;
import com.example.demo.service.TestService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
@Service
public class TestServiceImpl implements TestService {
    @Override
    @WindowRateLimit(limit = 5, timeWindowMilliseconds = 60L*1000) // 每最多允許5次請求
    public String getContent() {
        return "Hello Word";
    }
}