限流是大家开发之路上一定会遇到的需求。比如：限制一定时间内，接口请求请求频率；一定时间内用户发言、评论次数等等，类似于滑动窗口算法。这里分享一份拿来即用的代码，一起看看如何利用常见的 Redis 实现一个实用并且原理简单的限流器。
限流核心原理以及代码
这个限流器的原理是使用 Redis 的incr命令来累计次数，key 的过期时间作为时间滑动窗口来实现。比如限制每5秒最多请求10次，那么就将 key 的过期时间设置为5秒，每次执行前对这个 key 自增，5秒内的次数将累计到这一个 key 上，如果自增的结果没有超过10次，代表没有被限流。5秒过后 key 将被 Redis 清除，后续次数将重新累计。
这里大家需要了解下incr使用的一些细节。incr每次执行都是将 key 的值自增1，并返回自增后的结果，比如对key=1执行incr结果为2；如果 key 不存在，将设置这个 key 值为1，返回结果自然也是1，并且这个 key 是没有过期时间的。
Redis 的incr不能在自增的同时设置过期时间，这就意味着自增和设置过期时间要分两步做，在第一次incr完成之后，紧接着使用expire指令来给这个 key 设置过期时间。非原子方式会带来并发问题，如果incr成功，而expire失败将导致生成了一个永不过期的 key，次数一直累计到最大值，永远进入限流状态。这个问题我们可以用个兜底逻辑来解决，在incr前获取这个 key 的过期时间，如果没有那就删掉。
看到这，有了解过 Redis lua 脚本的同学可能会提出，既然这么麻烦，为何不用 lua 脚本自己实现一个自增且同时能够同时设置过期时间的功能？这个思路很棒，代码量不大且 Redis 也是完全可以支持的。但是在大点的公司，运维可能会禁止开发使用 lua 这种扩展方式，Redis 只有一个主线程执行执行命令，如果脚本中的逻辑执行时间过长将导致后续指令排队等待，它们响应时间自然也会变长，这种不可控的风险运维肯定不愿意承担。当然如果公司允许，并且有其他手段可以控制这个风险，lua 实现还是非常可行的。
为何不直接使用JDK实现而要借助中间件？因为实现出来只能在当前进程有有效，集群情况下不能累计到一起。
下面是具体代码，可以直接使用，代码关键处有详细的注释：
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.lang.NonNull;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
/**
* 用Redis实现的限流器，用于限制方法或者接口请求频率。比如：限制接口每秒请求次数；某个用户请求接口的次数，属于滑动窗口算法。
* 核心方法是 {@link #acquire(RedisTemplate, String, long, long)}
*/
public abstract class RedisIncrLimiter {
/**
* 限制每秒次数，参考 {@link #acquire(RedisTemplate, String, long, long)}
*/
public static boolean acquireLimitPerSecond(@NonNull RedisTemplate<String, String> redisTemplate,
@NonNull String limiterKey, long maxTimes) {
return acquire(redisTemplate, limiterKey, 1, maxTimes);
}
/**
* 限制每分钟次数，参考 {@link #acquire(RedisTemplate, String, long, long)}
*/
public static boolean acquireLimitPerMinute(@NonNull RedisTemplate<String, String> redisTemplate,
@NonNull String limiterKey, long maxTimes) {
return acquire(redisTemplate, limiterKey, 60, maxTimes);
}
/**
* 限制每小时次数，参考 {@link #acquire(RedisTemplate, String, long, long)}
*/
public static boolean acquireLimitPerHour(@NonNull RedisTemplate<String, String> redisTemplate,
@NonNull String limiterKey, long maxTimes) {
return acquire(redisTemplate, limiterKey, 3600, maxTimes);
}
/**
* 限制每天次数，参考 {@link #acquire(RedisTemplate, String, long, long)}
*/
public static boolean acquireLimitPerDay(@NonNull RedisTemplate<String, String> redisTemplate,
@NonNull String limiterKey, long maxTimes) {
return acquire(redisTemplate, limiterKey, 86400, maxTimes);
}
/**
* 执行限流逻辑前，调用这个方法获取一个令牌，如果返回 true 代表没被限流，可以执行。比如：
* <pre>{@code
* // 限制每秒最多发10次消息
* if (RedisIncrLimiter.acquire(redisTemplate, "sendMessage", 1, 10)) {
* // 发消息
* } else {
* // 被限流后的操作
* }
* }</pre>
* 如果限流粒度是用户级，可以将用户的ID或者唯一身份标识加到限流Key中。<br>
* 这个也是限流核心方法，利用 Redis incr 命令累计次数，KEY过期时间作为时间窗口实现。<br>
* 相同的限流KEY、时间窗口和最大次数才会累计到一起，三个参数任一不一致会分开累计，
* 参考{@link #buildFinalLimiterKey(String, long, long)}
*
* @param redisTemplate redisTemplate
* @param limiterKey 限流Key（代表限流逻辑的字符串）
* @param timeWindowSecond 时间窗口
* @param maxTimes 时间窗口内最大次数
* @return true-没有被限流
*/
public static boolean acquire(@NonNull RedisTemplate<String, String> redisTemplate,
@NonNull String limiterKey, long timeWindowSecond, long maxTimes) {
limiterKey = buildFinalLimiterKey(limiterKey, timeWindowSecond, maxTimes);
/*
如果异常情况下产生了没有过期时间的KEY，将导致次数不断累积到最大值（被限流）而无法解除。
这个兜底操作就是为了避免这个问题，清除没有过期时间的KEY
*/
Long ttl = redisTemplate.getExpire(limiterKey);
if (ttl == null || ttl == -1L) {
redisTemplate.delete(limiterKey);
return true;
}
Long incr = redisTemplate.opsForValue().increment(limiterKey);
Objects.requireNonNull(incr);
// 在第一次请求的时候设置过期时间（时间窗口）
if (incr == 1L) {
redisTemplate.expire(limiterKey, timeWindowSecond, TimeUnit.SECONDS);
}
return incr <= maxTimes;
}
/**
* @param limiterKey 限流Key
* @param timeWindowSecond 时间窗口
* @param maxTimes 时间窗口内最大次数
* @return 构建最终的限流 Redis Key，格式为：限流Key:时间窗口:最多次数
*/
private static String buildFinalLimiterKey(String limiterKey, long timeWindowSecond, long maxTimes) {
return limiterKey + ":" + timeWindowSecond + ":" + maxTimes;
}
}
基于Spring切面实现的注解版本
注解版使用起来比较方便，只需要在限流的方法上指定时间三个关键的参数就行，底层逻辑还是上面的代码。比如：
// 每5秒最多10次
@RedisIncrLimit(limiterKey = "test", timeWindowSecond = 5L, maxTimes = 10L)
public String test() {
return "ok";
}
RedisIncrLimit只用来标记限流方法，接收限流参数。
import java.lang.annotation.*;
/**
* {@link RedisIncrLimiter} 注解版
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface RedisIncrLimit {
/**
* @return 限流KEY
*/
String limiterKey();
/**
* @return 时间窗口
*/
long timeWindowSecond();
/**
* @return 时间窗口内最大次数
*/
long maxTimes();
}
下面切面逻辑doBefore()会在加了RedisIncrLimit注解的方法前执行，先判断是否被限流。
import javax.annotation.Resource;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class RedisLimiterAspect {
@Resource
private RedisTemplate<String, String> redisTemplate;
@Pointcut("@annotation(redisLimit)")
public void pointcut(RedisIncrLimit redisLimit) {
}
@Before("pointcut(redisLimit)")
public void doBefore(RedisIncrLimit redisLimit) {
if (!RedisIncrLimiter.acquire(
redisTemplate, redisLimit.limiterKey(), redisLimit.timeWindowSecond(), redisLimit.maxTimes())) {
throw new IllegalStateException("rate limit");
}
}
}
