基于Redis接口限流策略

Dear 丶 2023-01-07 07:29 127阅读 0赞

# 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();
        }
        
    }

*  **接口类方法：同上**

## 令牌桶限流 ##

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gyNzM5Nzk1ODY_size_16_color_FFFFFF_t_70]

###### 代码 ######

*  **自定义注解代码：同上**

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

*  **定时器代码**

@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实现代码**

*  **接口类方法：同上**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2gyNzM5Nzk1ODY_size_16_color_FFFFFF_t_70]: /images/20221119/c0dab66201504662bfb71a0385edb591.png