redis令牌桶限流

男娘i 2023-02-20 12:17 18阅读 0赞

## 常见的限流算法： ##

*  漏桶算法：能够强行限制数据的传输速率，但是由于流速是恒定的，对突发特性的流量是无法处理的 （nginx限流使用的是漏桶算法，借助limit\_conn\_zone模块进行限流）
 *  令牌桶算法 ：能够在限制数据的平均传输速率的同时还允许某种程度的突发传输。
 *  滑动窗口算法：它本质上是计数算法，每个时间片段都有独立的计数器，通过这些计数器来限制请求的涌入。

总的来说：

1.  令牌桶算法：能够保证自身系统的流量均匀；
2.  漏桶算法：保证被调用系统（目标系统）流量均匀。

实际的生产中通常采用 漏桶算法+令牌桶算法的方式来对网络流量进行高效地控制。详细的限流算法介绍可参考我的博客：[限流算法][Link 1]

# Redis使用令牌桶方式进行限流 #

## 自定义接口：AccessLimit ##

@Inherited
    @Documented
    @Target({ ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AccessLimit { 
    
    
        int limit() default 5; //限制的次数
    
    
        int sec() default 5;//限制的时间段（秒）
    }

## 配置拦截器：AccessLimitConfig ##

public class AccessLimitConfig implements WebMvcConfigurer { 
    
        @Bean
        public AccessLimitInterceptor accessLimitInterceptor(){ 
            return new AccessLimitInterceptor();
        }
    
    
        /** * 配置拦截器 */
        @Override
        public void addInterceptors(InterceptorRegistry registry) { 
            registry.addInterceptor(accessLimitInterceptor()).addPathPatterns("/**").excludePathPatterns("/attendance/userinfo/loginValidateCode","/swagger-ui.html","/swagger-resources/configuration/security",
                    "/swagger-resources/configuration/ui","/swagger*//**","/api/v1/login","/v2/api-docs",
                   "/configuration/ui", "/swagger-resources", "/configuration/security", "/swagger-ui.html", "/webjars/**");
    }

## 限流拦截器：AccessLimitInterceptor ##

public class AccessLimitInterceptor implements HandlerInterceptor { 
    
        @Autowired
        RedisTemplate redisTemplate;
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
            if (handler instanceof HandlerMethod) { 
                HandlerMethod handlerMethod = (HandlerMethod) handler;
                Method method = handlerMethod.getMethod();
                if (!method.isAnnotationPresent(AccessLimit.class)) { 
                    return true;
                }
                AccessLimit accessLimit = method.getAnnotation(AccessLimit.class);
                if (accessLimit == null) { 
                    return true;
                }
                int limit = accessLimit.limit();
                int sec = accessLimit.sec();
                String key = CommonUtil.getIpAddr(request) + request.getRequestURI();
                Integer maxLimit = null;
                if(redisTemplate.opsForValue().get(key)!=null){ 
                    maxLimit =Integer.valueOf(redisTemplate.opsForValue().get(key).toString()) ;
                }
    
                if (maxLimit == null) { 
                    redisTemplate.opsForValue().set(key, "1", sec, TimeUnit.SECONDS);  //set时一定要加过期时间
                } else if (maxLimit < limit) { 
                    redisTemplate.opsForValue().set(key, (maxLimit + 1)+"", sec, TimeUnit.SECONDS);
                } else { 
                    output(response, "请求太频繁!");
                    return false;
                }
            }
            return true;
        }
    
        public void output(HttpServletResponse response, String msg) throws IOException { 
            response.setContentType("application/json;charset=UTF-8");
            ServletOutputStream outputStream = null;
            try { 
                outputStream = response.getOutputStream();
                outputStream.write(msg.getBytes("UTF-8"));
            } catch (IOException e) { 
                e.printStackTrace();
            } finally { 
                outputStream.flush();
                outputStream.close();
            }
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { 
    
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { 
    
        }
    }

## 接口使用 ##

/** * 这是用户模块的Controller */
    @RestController
    @RequestMapping("/attendance/commodity")
    @Api(value = "商品模块")
    public class CommodityController { 
    
        @Autowired
        CommodityService commodityService;
    
    
        @Autowired
        RabbitTemplate rabbitTemplate;
    
    
        @Autowired
        RedisTemplate redisTemplate;
    
    
        @Autowired
        private Environment env;
    
        //日志记录器
        private static Logger logger = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);
    
        /** * 进行商品秒杀 */
        @PostMapping("/seckill")
        @ApiOperation(value = "进行商品秒杀")
        @AccessLimit(limit = 4,sec = 10)  //加上自定义注解即可
        public ResponseResult seckill(HttpServletRequest request) { 
            logger.info("start UserController.seckill");
            String productId ="43486796d2871dfbec0f62951750ea4c";
            String user ="admin";
            OrderPojo orderPojo =new OrderPojo();
            orderPojo.setUserId(user);
            orderPojo.setProductId(productId);
            orderPojo.setOrderPrice(100L);
            orderPojo.setTempId(CommonUtil.getUUID());
            rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
            rabbitTemplate.setExchange(env.getProperty("order.exchange.name"));
            rabbitTemplate.setRoutingKey(env.getProperty("order.routing.key.name"));
            try { 
                Message message = MessageBuilder.withBody(JacksonUtils.toJson(orderPojo).getBytes("UTF-8")).build();
                //设置请求编码格式
                message.getMessageProperties().setHeader(AbstractJavaTypeMapper.DEFAULT_CONTENT_CLASSID_FIELD_NAME, MessageProperties.CONTENT_TYPE_JSON);
                rabbitTemplate.convertAndSend(message);
            }catch (Exception e){ 
                logger.error("订单消息生产者发送消息失败"+e.getMessage(),e);
                return ResponseResult.error(ConstantsUtil.OPERATE_ERROR);
            }
            logger.info("end UserController.seckill");
            return ResponseResult.success(orderPojo.getTempId(),ConstantsUtil.OPERATE_SUCCESS);
        }
    
    }

## 验证 ##

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

[Link 1]: https://blog.csdn.net/weixin_40990818/article/details/108190826
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk5MDgxOA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200626203824686.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk5MDgxOA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk5MDgxOA_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200812232314401.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDk5MDgxOA==,size_16,color_FFFFFF,t_70#pic_center