基于Redis接口限流策略

最新推荐文章于 2025-06-09 23:15:22 发布

原创最新推荐文章于 2025-06-09 23:15:22 发布 · 695 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#限流 #redis #高并发

架构专栏收录该内容

38 篇文章

订阅专栏

本文介绍了使用Redis实现的三种限流策略：暴力限流、滑动窗口限流和令牌桶限流。在高并发场景下，这些策略能有效保护服务器。暴力限流基于key存储访问人数；滑动窗口限流利用zset记录请求，避免流量突增；令牌桶限流则通过定时任务往令牌桶中添加令牌，用户访问需先获取令牌。示例代码展示了如何通过自定义注解和AOP在Java中实现这些限流策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Reids限流

随着业务不增加我们面对高并发场景机会也越来越多，保护我们服务器方式有很多，限流就是其中一种，小编这里介绍并实现三种方式限流策略：暴力限流、滑动窗口限流、令牌桶限流。

暴力限流

暴力限流依据redis中key，只存储访问人数并设置一个过期时间，当key值大于规定人数则限流。有一个弊端：生成key时候访问人数很少，当key还有一秒即将过期，现在来了很多请求，结果key过期了，又产生一个key值从0开始，这时服务器承担两倍的压力。而下面滑动窗口可以解决这个问题。

自定义注解加AOP方式

通过方法或类上注解拦截请求方法是否需要限流（方法注解优先类上注解），如果有规定时间内大于配置请求数量就抛出异常。
因为我们机器是集群状态，所以必须用redis做限流，可以避免并发等问题。

代码

自定义注解：AccessLimit

/**
 * @Author: LailaiMonkey
 * @Description：
 * @Date：Created in 2021-01-13 14:41
 * @Modifi ed By：
 */
@Documented
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface AccessLimit {
    //标识 指定time时间段内的访问次数限制
    int limit() default 5;

    //标识 时间段秒
    int time() default 5;

    //提示信息
    String message() default "太火爆了";
}

AOP实现代码

/**
 * @Author: LailaiMonkey
 * @Description：
 * @Date：Created in 2021-01-13 14:43
 * @Modified By：
 */
@Component
@Aspect
public class RateLimitAop {

    private final static String RATE_LIMIT_KEY = "LIMIT:";

    @Autowired
    private RedisTemplate redisTemplate;

    @Pointcut("@annotation(com.monkey.redisLimit.AccessLimit)" +
            "||@within(com.monkey.redisLimit.AccessLimit)")
    public void serviceLimit() {

    }

    @Around("serviceLimit()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        Class<?> targetCls = joinPoint.getTarget().getClass();
        //获取方法签名(通过此签名获取目标方法信息)
        MethodSignature ms = (MethodSignature) joinPoint.getSignature();
        Method targetMethod =
                targetCls.getDeclaredMethod(
                        ms.getName(),
                        ms.getParameterTypes());

        //获得路径URI
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String requestURI = request.getRequestURI();

        //获得方法注解
        AccessLimit accessLimit = targetMethod.getAnnotation(AccessLimit.class);
        if (accessLimit == null) {
            accessLimit = targetCls.getAnnotation(AccessLimit.class);
        }

        //是否进行限流
        boolean pass = redisLimit(RATE_LIMIT_KEY + requestURI, accessLimit.limit(), accessLimit.time());
        if (pass) {
            throw new RuntimeException(accessLimit.message());
        }

        return joinPoint.proceed();
    }

    /**
     * 是否进行限流，true：限流，false：不限流
     *
     * @param key
     * @param limit
     * @param time
     * @return
     */
    private boolean redisLimit(String key, int limit, int time) {
        //设置lua脚本
        DefaultRedisScript<Integer> rs = new DefaultRedisScript<>(buildSlideWindowLimitLuaScript(), Integer.class);

        //执行Lua脚本
        int count = (int) redisTemplate.execute(rs, Collections.singletonList(key), time);
        return count > limit;
    }

    /**
     * lua限流脚本
     * ARGV[1] 过期时间
     */
    private String buildSlideWindowLimitLuaScript() {

        StringBuilder sb = new StringBuilder();

        sb.append("local c");
        //没有值并放入该请求数：1
        sb.append("\n c = redis.call('GET', KEYS[1])");

        //没有值则返回1
        sb.append("\n if tonumber(c) == nil then");
        sb.append("\n redis.call('SET', KEYS[1], 1)");
        sb.append("\n redis.call('EXPIRE', KEYS[1], ARGV[1])");
        sb.append("\n return '1' ");
        //有值没则添加1
        sb.append("\n else");
        sb.append("\n redis.call('INCR', KEYS[1])");
        sb.append("\n c = redis.call('GET', KEYS[1])");
        sb.append("\n return c ");
        sb.append("\n end");
        return sb.toString();
    }

}

接口类方法

@AccessLimit
@RestController
public class TblDeptController {

	//如果类上有该注解，方法注解可以省略
	//类上注解和方法注解相冲突，方法注解优先级大于类上注解
	@AccessLimit
    @GetMapping("/AccessLimit")
    public void AccessLimit() {

    }
}

滑动窗口限流

滑动窗口算法是在给定窗口大小情况下计算结果操作。

基于redis滑动窗口限流我们可以用zset数组，当每一次请求进来的时候，我们可以给指定key值生成一个value和score。value保持唯一，可以用UUID生成。score可以用当前时间戳表示。因为zset数据结构也提供了range方法可以让我们统计2个时间间隔中有多少个请求。

自定义注解加AOP方式

代码

自定义注解代码：同上
AOP实现代码

/**
 * @Author: LailaiMonkey
 * @Description：
 * @Date：Created in 2021-01-13 14:43
 * @Modified By：
 */
@Component
@Aspect
public class RateLimitAop {

    private final static String RATE_LIMIT_KEY = "LIMIT:";

    @Autowired
    private RedisTemplate redisTemplate;

    @Pointcut("@annotation(com.monkey.redisLimit.AccessLimit)" +
            "||@within(com.monkey.redisLimit.AccessLimit)")
    public void serviceLimit() {

    }

    @Around("serviceLimit()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        Class<?> targetCls = joinPoint.getTarget().getClass();
        //获取方法签名(通过此签名获取目标方法信息)
        MethodSignature ms = (MethodSignature) joinPoint.getSignature();
        Method targetMethod =
                targetCls.getDeclaredMethod(
                        ms.getName(),
                        ms.getParameterTypes());

        //获得路径URI
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String requestURI = request.getRequestURI();

        //获得方法注解
        AccessLimit accessLimit = targetMethod.getAnnotation(AccessLimit.class);
        if (accessLimit == null) {
            accessLimit = targetCls.getAnnotation(AccessLimit.class);
        }

        //是否进行限流
        boolean pass = redisLimit(RATE_LIMIT_KEY + requestURI, accessLimit.limit(), accessLimit.time());
        if (pass) {
            throw new RuntimeException(accessLimit.message());
        }

        return joinPoint.proceed();
    }

    /**
     * 是否进行限流，true：限流，false：不限流
     *
     * @param key
     * @param limit
     * @param time
     * @return
     */
    private boolean redisLimit(String key, int limit, int time) {
        long timeMillis = System.currentTimeMillis();
        String uuid = UUID.randomUUID().toString();
        RedisScript<Number> redisScript = new DefaultRedisScript<>(buildSlideWindowLimitLuaScript(), Number.class);

        //获得两时间周期内请求个数
        Number count = (Number) redisTemplate.execute(redisScript, Collections.singletonList(key), uuid, (double) timeMillis, timeMillis - time * 1000, limit);
        return count != null && count.longValue() > limit;
    }

    /**
     * lua限流脚本
     * ARGV[1] uuid
     * ARGV[2] 当前时间戳
     * ARGV[3] 当前时间戳-窗口时间
     * ARGV[4] 限制的大小
     */
    private String buildSlideWindowLimitLuaScript() {

        StringBuilder sb = new StringBuilder();

        //定义c
        sb.append("local c");
        // 删除无用数据
        sb.append("\nredis.call('zremrangebyscore',KEYS[1],0,ARGV[3])");
        //获取redis中的值
        sb.append("\nc = redis.call('zcard',KEYS[1])");

        //如果调用超过最大值，直接返回
        sb.append("\nif c and tonumber(c) > tonumber(ARGV[4]) then");
        sb.append("\n return c;");
        sb.append("\nend");

        //添加请求
        sb.append("\nredis.call('zadd',KEYS[1],ARGV[2],ARGV[1])");
        //获取数量数量
        sb.append("\nreturn c + 1");

        return sb.toString();
    }
    
}

接口类方法：同上

令牌桶限流

每隔一段时间系统往桶中放一定数量令牌，如果令牌已经满了停止放入。用户访问接口先获取令牌，获得令牌可以访问，否则拒绝访问。

在这里插入图片描述

代码

自定义注解代码：同上

这时注解中参数已经不起作用了，所有参数由定时器控制。

定时器代码

	@Autowired
    private RedisTemplate redisTemplate;

	//每秒放一个令牌
    @Scheduled(fixedDelay = 1000, initialDelay = 1000)
    public void setIntervalTimeTask() {
        Long size = redisTemplate.opsForList().size("LIMIT:/limit");
        if (size < 5) {
            redisTemplate.opsForList().rightPush("LIMIT:/limit", UUID.randomUUID().toString());
        }
    }

AOP实现代码

/**
 * @Author: LailaiMonkey
 * @Description：
 * @Date：Created in 2021-01-13 14:43
 * @Modified By：
 */
@Component
@Aspect
public class RateLimitAop {

    private final static String RATE_LIMIT_KEY = "LIMIT:";

    @Autowired
    private RedisTemplate redisTemplate;

    @Pointcut("@annotation(com.monkey.redisLimit.AccessLimit)" +
            "||@within(com.monkey.redisLimit.AccessLimit)")
    public void serviceLimit() {

    }

    @Around("serviceLimit()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        Class<?> targetCls = joinPoint.getTarget().getClass();
        //获取方法签名(通过此签名获取目标方法信息)
        MethodSignature ms = (MethodSignature) joinPoint.getSignature();
        Method targetMethod =
                targetCls.getDeclaredMethod(
                        ms.getName(),
                        ms.getParameterTypes());

        //获得路径URI
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String requestURI = request.getRequestURI();

        //获得方法注解
        AccessLimit accessLimit = targetMethod.getAnnotation(AccessLimit.class);
        if (accessLimit == null) {
            accessLimit = targetCls.getAnnotation(AccessLimit.class);
        }

        //是否进行限流
        boolean pass = redisLimit(RATE_LIMIT_KEY + requestURI, accessLimit.limit(), accessLimit.time());
        if (pass) {
            throw new RuntimeException(accessLimit.message());
        }

        return joinPoint.proceed();
    }

    /**
     * 是否进行限流，true：限流，false：不限流
     *
     * @param key
     * @param limit
     * @param time
     * @return
     */
    private boolean redisLimit(String key, int limit, int time) {
        Object result = redisTemplate.opsForList().leftPop(key);
        return result == null;
    }
    
}

接口类方法：同上