ZADD?[key]?[score]?[member]

Zremrangebyscore?[key]?[min]?[max]

min = 0
max = currentTimeMill - 5 * 1000

?ZCARD?[key]

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RateLimiter {
    /**
     * 限流時間，單位秒
     */
    int time() default 5;
    /**
     * 限流次數(shù)
     */
    int count() default 10;
}

-- 獲取redis鍵
local key = KEYS[1]
-- 獲取第一個參數(shù)（次數(shù)）
local count = tonumber(ARGV[1])
-- 獲取第二個參數(shù)（時間）
local time = tonumber(ARGV[2])
-- 獲取當前流量
local current = redis.call('get', key);
-- 如果current值存在，且值大于規(guī)定的次數(shù)，則拒絕放行（直接返回當前流量）
if current and tonumber(current) > count then
    return tonumber(current)
end
-- 如果值小于規(guī)定次數(shù)，或值不存在，則允許放行，當前流量數(shù)+1  (值不存在情況下，可以自增變?yōu)?)
current = redis.call('incr', key);
-- 如果是第一次進來，那么開始設置鍵的過期時間。
if tonumber(current) == 1 then 
    redis.call('expire', key, time);
end
-- 返回當前流量
return tonumber(current)

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        // 使用Jackson2JsonRedisSerialize 替換默認序列化(默認采用的是JDK序列化)
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;
    }
    /**
     * 解析lua腳本的bean
     */
    @Bean("limitScript")
    public DefaultRedisScript<Long> limitScript() {
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/limit.lua")));
        redisScript.setResultType(Long.class);
        return redisScript;
    }
}

@Slf4j
@Aspect
@Component
public class RateLimiterAspect {
 @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private RedisScript<Long> limitScript;
 @Before("@annotation(rateLimiter)")
    public void doBefore(JoinPoint point, RateLimiter rateLimiter) throws Throwable {
        int time = rateLimiter.time();
        int count = rateLimiter.count();
        String combineKey = getCombineKey(rateLimiter.type(), point);
        List<String> keys = Collections.singletonList(combineKey);
        try {
            Long number = (Long) redisTemplate.execute(limitScript, keys, count, time);
            // 當前流量number已超過限制，則拋出異常
            if (number == null || number.intValue() > count) {
             throw new RuntimeException("訪問過于頻繁，請稍后再試");
            }
            log.info("[limit] 限制請求數(shù)'{}',當前請求數(shù)'{}',緩存key'{}'", count, number.intValue(), combineKey);
        } catch (Exception ex) {
            ex.printStackTrace();
            throw new RuntimeException("服務器限流異常，請稍候再試");
        }
    }
    /**
     * 把用戶IP和接口方法名拼接成 redis 的 key
     * @param point 切入點
     * @return 組合key
     */
    private String getCombineKey(JoinPoint point) {
        StringBuilder sb = new StringBuilder("rate_limit:");
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        sb.append( Utils.getIpAddress(request) );
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        Class<?> targetClass = method.getDeclaringClass();
        // keyPrefix + "-" + class + "-" + method
        return sb.append("-").append( targetClass.getName() )
                .append("-").append(method.getName()).toString();
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RateLimiter {
    /**
     * 限流時間，單位秒
     */
    int time() default 5;
    /**
     * 限流次數(shù)
     */
    int count() default 10;
}

@Slf4j
@Aspect
@Component
public class RateLimiterAspect {
    @Autowired
    private RedisTemplate redisTemplate;
    /**
     * 實現(xiàn)限流（新思路）
     * @param point
     * @param rateLimiter
     * @throws Throwable
     */
    @SuppressWarnings("unchecked")
    @Before("@annotation(rateLimiter)")
    public void doBefore(JoinPoint point, RateLimiter rateLimiter) throws Throwable {
        // 在 {time} 秒內僅允許訪問 {count} 次。
        int time = rateLimiter.time();
        int count = rateLimiter.count();
        // 根據(jù)用戶IP（可選）和接口方法，構造key
        String combineKey = getCombineKey(rateLimiter.type(), point);
        // 限流邏輯實現(xiàn)
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
        // 記錄本次訪問的時間結點
        long currentMs = System.currentTimeMillis();
        zSetOperations.add(combineKey, currentMs, currentMs);
        // 這一步是為了防止member一直存在于內存中
        redisTemplate.expire(combineKey, time, TimeUnit.SECONDS);
        // 移除{time}秒之前的訪問記錄（滑動窗口思想）
        zSetOperations.removeRangeByScore(combineKey, 0, currentMs - time * 1000);
        // 獲得當前窗口內的訪問記錄數(shù)
        Long currCount = zSetOperations.zCard(combineKey);
        // 限流判斷
        if (currCount > count) {
            log.error("[limit] 限制請求數(shù)'{}',當前請求數(shù)'{}',緩存key'{}'", count, currCount, combineKey);
            throw new RuntimeException("訪問過于頻繁，請稍后再試!");
        }
    }
    /**
     * 把用戶IP和接口方法名拼接成 redis 的 key
     * @param point 切入點
     * @return 組合key
     */
    private String getCombineKey(JoinPoint point) {
        StringBuilder sb = new StringBuilder("rate_limit:");
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        sb.append( Utils.getIpAddress(request) );
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        Class<?> targetClass = method.getDeclaringClass();
        // keyPrefix + "-" + class + "-" + method
        return sb.append("-").append( targetClass.getName() )
                .append("-").append(method.getName()).toString();
    }
}