Springboot进阶：如何利用redis快速简单的实现全局接口限流_springboot 集群qps限制 redis

对于某些特殊的业务场景，比如抢单、秒杀等业务，会导致服务流量瞬间飙升，我们虽然可以通过部署集群的方式分散请求压力，但是仍然可能造成很大的请求延迟。

这时，我们可以通过接口限流的方式来保证系统的稳定运行。

实现逻辑

我们可以通过filter对所有的接口进行拦截，判断这个接口在当前时间窗口内的请求次数，如果超出我们设定的请求上限，就返回无效请求。

以限制每个接口最大为10个QPS为例，可以有两种实现逻辑：

其一，将这10个请求进行拆分，相当于每100ms可以请求一次；

其二，每秒内最多请求10次，而不判断其请求分布范围。

两种逻辑的实现也略有差异。

实现一

每秒请求一次。

@Component
@RequiredArgsConstructor
@Order(Ordered.HIGHEST_PRECEDENCE)
public class RateLimiterFilter implements Filter {
    private final RedisTemplate<String, String> redisTemplate;
    private final ObjectMapper objectMapper;
    private final static String rateLimiterKey = "rateLimiterKey_";

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;

        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        //获取接口请求路径
        String servletPath = httpServletRequest.getServletPath();
        //利用setIfAbsent设置key，如果设置成功，说明可以放行，其实就是redis的set nx命令
        Boolean setIfAbsent = this.redisTemplate.opsForValue()
                .setIfAbsent(rateLimiterKey + servletPath, "1", 1, TimeUnit.SECONDS);
        if (Boolean.TRUE.equals(setIfAbsent)) {
            chain.doFilter(httpServletRequest, httpServletResponse);
        } else {
            httpServletResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);
            httpServletResponse.setCharacterEncoding("utf-8");
            httpServletResponse.setStatus(HttpStatus.UNAUTHORIZED.value());
            httpServletResponse.getWriter().print(objectMapper.writeValueAsString("超过访问频率限制"));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

实现二

每秒请求N次。

判断每秒请求N次会比每秒一次稍微复杂一点，主要是需要判断当前秒内已经请求了多少次。

这里利用redis的increment和expire配合使用达到限流的目的。

以限制每秒5次为例：

@Component
@RequiredArgsConstructor
@Order(Ordered.HIGHEST_PRECEDENCE)
public class RateLimiterFilter implements Filter {
    private final RedisTemplate<String, String> redisTemplate;
    private final ObjectMapper objectMapper;
    private final static String rateLimiterKey = "rateLimiterKey_";

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {

        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        //获取接口请求路径
        String servletPath = httpServletRequest.getServletPath();
        //直接递增
        Long increment = this.redisTemplate.opsForValue().increment(rateLimiterKey + servletPath);
        if (increment != null && increment > 5) {
            //超过5次的限制
            this.redisTemplate.delete(rateLimiterKey + servletPath);
            httpServletResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);
            httpServletResponse.setCharacterEncoding("utf-8");
            httpServletResponse.setStatus(HttpStatus.UNAUTHORIZED.value());
            httpServletResponse.getWriter().print(objectMapper.writeValueAsString("超过访问频率限制"));
            return;
        } else if (increment != null && increment == 1) {
            //第一次请求时，一定要记得给key设置过期时间
            this.redisTemplate.expire(rateLimiterKey + servletPath, 1, TimeUnit.SECONDS);
        }
        chain.doFilter(httpServletRequest, httpServletResponse);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

总结

以上两种利用redis实现限流的方式基本能满足我们大部分的业务需要，对于部分要求限流粒度更高更准的业务，可以引入sentinel来满足业务需要。

感谢您的点赞和关注。