springboot 根据请求IP做的分布式限流

港控/mmm° 2021-10-15 08:01 455阅读 0赞

在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流

>     缓存 缓存的目的是提升系统访问速度和增大系统处理容量  
>     降级 降级是当服务出现问题或者影响到核心流程时，需要暂时屏蔽掉，待高峰或者问题解决后再打开  
>     限流 限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理  
>

缓存的目的是提升系统访问速度和增大系统能处理的容量，可谓是抗高并发流量的银弹；而降级是当服务出问题或者影响到核心流程的性能则需要暂时屏蔽掉，待高峰或者问题解决后再打开；而有些场景并不能用缓存和降级来解决，比如稀缺资源（秒杀、抢购）、写服务（如评论、下单）、频繁的复杂查询（评论的最后几页），因此需有一种手段来限制这些场景的并发/请求量，即限流。

系统在设计之初就会有一个预估容量，长时间超过系统能承受的TPS/QPS阈值，系统可能会被压垮，最终导致整个服务不够用。为了避免这种情况，我们就需要对接口请求进行限流。

限流的目的是通过对并发访问请求进行限速或者一个时间窗口内的的请求数量进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待。

一般开发高并发系统常见的限流模式有控制并发和控制速率，一个是限制并发的总数量（比如数据库连接池、线程池），一个是限制并发访问的速率（如nginx的limit\_conn模块，用来限制瞬时并发连接数），另外还可以限制单位时间窗口内的请求数量（如Guava的RateLimiter、nginx的limit\_req模块，限制每秒的平均速率）。其他还有如限制远程接口调用速率、限制MQ的消费速率。另外还可以根据网络连接数、网络流量、CPU或内存负载等来限流。

## 解决方案 ##

**采用springboot + redis 方式实现分布式限流，自定义注解 + 拦截器**

1.新建一个springboot项目，引入redis包

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

在配置文件中配置redis

spring:
        redis:
          database: 0
          host: 127.0.0.1
          port: 6379
          password:
          jedis:
            pool:
              max-active: 8
              max-wait: -1ms
              max-idle: 8
              min-idle: 0
          timeout: 2000ms

2.新建一个自定义注解 AccessLimit 用在后面接口上

/**
     * @author: lockie
     * @Date: 2019/8/13 16:09
     * @Description: 限流自定义注解
     */
    @Inherited
    @Documented
    @Target({ElementType.FIELD, ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface AccessLimit {
        /**
         * 指定second 时间内，API最多的请求次数
         */
        int times() default 3;
    
        /**
         * 指定时间second，redis数据过期时间
         */
        int second() default 10;
    }

新建一个拦截器，获取有自定义注解上的参数，然后存到redis中校验

@Component
    public class AccessLimitIntercept implements HandlerInterceptor {
        private static final Logger logger = LoggerFactory.getLogger(AccessLimitIntercept.class);
    
        @Autowired
        private StringRedisTemplate redisTemplate;
    
        /**
         * 接口调用前检查对方ip是否频繁调用接口
         * @param request
         * @param response
         * @param handler
         * @return
         * @throws Exception
         */
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            try {
                // handler是否为 HandleMethod 实例
                if (handler instanceof HandlerMethod) {
                    // 强转
                    HandlerMethod handlerMethod = (HandlerMethod) handler;
                    // 获取方法
                    Method method = handlerMethod.getMethod();
                    // 判断方式是否有AccessLimit注解，有的才需要做限流
                    if (!method.isAnnotationPresent(AccessLimit.class)) {
                        return true;
                    }
    
                    // 获取注解上的内容
                    AccessLimit accessLimit = method.getAnnotation(AccessLimit.class);
                    if (accessLimit == null) {
                        return true;
                    }
                    // 获取方法注解上的请求次数
                    int times = accessLimit.times();
                    // 获取方法注解上的请求时间
                    Integer second = accessLimit.second();
    
                    // 拼接redis key = IP + Api限流
                    String key = IpUtil.getIpAddr(request) + request.getRequestURI();
    
                    // 获取redis的value
                    Integer maxTimes = null;
                    String value = redisTemplate.opsForValue().get(key);
                    if (StringUtils.isNotEmpty(value)) {
                        maxTimes = Integer.valueOf(value);
                    }
                    if (maxTimes == null) {
                        // 如果redis中没有该ip对应的时间则表示第一次调用，保存key到redis
                        redisTemplate.opsForValue().set(key, "1", second, TimeUnit.SECONDS);
                    } else if (maxTimes < times) {
                        // 如果redis中的时间比注解上的时间小则表示可以允许访问,这是修改redis的value时间
                        redisTemplate.opsForValue().set(key, maxTimes + 1 + "", second, TimeUnit.SECONDS);
                    } else {
                        // 请求过于频繁
                        logger.info(key + " 请求过于频繁");
                        return setResponse(new Results(ResultEnum.BAD_REQUEST), response);
                    }
                }
            } catch (Exception e) {
                logger.error("API请求限流拦截异常，异常原因：", e);
                throw new ParameterException(e);
            }
            return true;
        }
    
        @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 {
    
        }
    
        private boolean setResponse(Results results, HttpServletResponse response) throws IOException {
            ServletOutputStream outputStream = null;
            try {
                response.setHeader("Content-type", "application/json; charset=utf-8");
                outputStream = response.getOutputStream();
                outputStream.write(JsonUtil.toJson(results).getBytes("UTF-8"));
            } catch (Exception e) {
                logger.error("setResponse方法报错", e);
                return false;
            } finally {
                if (outputStream != null) {
                    outputStream.flush();
                    outputStream.close();
                }
            }
            return true;
        }
    }

配置拦截器，注意需要先注入拦截器不然获取不到redis里面的值，可以参考之前的文章 [拦截器无法注入redisTemplate][redisTemplate]

@Configuration
    public class WebFilterConfig implements WebMvcConfigurer {
    
    	/**
    	 * 这里需要先将限流拦截器入住，不然无法获取到拦截器中的redistemplate
    	 * @return
    	 */
    	@Bean
    	public AccessLimitIntercept getAccessLimitIntercept() {
    		return new AccessLimitIntercept();
    	}
    
    	/**
    	 * 多个拦截器组成一个拦截器链
    	 * @param registry
    	 */
    	@Override
    	public void addInterceptors(InterceptorRegistry registry) {
    		registry.addInterceptor(getAccessLimitIntercept()).addPathPatterns("/**");
    
    	}
    
    
    }

新建一个接口并加上注解，@AccessLimit(times = 5, second = 10) 注解表示的意思10秒内同一个IP最多能调用5次

@RestController
    @RequestMapping("/")
    public class PingController extends BaseController {
    
    	@AccessLimit(times = 5, second = 10)
    	@GetMapping(value = "/ping")
    	public Results ping() {
    		return succeed("pong", "");
    	}
    
    }

使用postman在10点不停的点至少5次，第六次的时候就会得到操作太频繁的提示

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4bDY0NjgwMTkyNA_size_16_color_FFFFFF_t_70][]

[redisTemplate]: https://blog.csdn.net/zxl646801924/article/details/99544463
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4bDY0NjgwMTkyNA_size_16_color_FFFFFF_t_70]: /images/20211015/f852fded8c2b4688a44a3762cae8036e.png