分布式限流

前言

本文接着上文应用限流进行讨论。

之前谈到的限流方案只能针对于单个 JVM 有效，也就是单机应用。而对于现在普遍的分布式应用也得有一个分布式限流的方案。

基于此尝试写了这个组件：

https://github.com/crossoverJie/distributed-redis-tool

DEMO

以下采用的是

https://github.com/crossoverJie/springboot-cloud

来做演示。

在 Order 应用提供的接口中采取了限流。首先是配置了限流工具的 Bean:

1. @Configuration

2. public class RedisLimitConfig {

3.    @Value("${redis.limit}")

4.    private int limit;

5.    @Autowired

6.    private JedisConnectionFactory jedisConnectionFactory;

7.    @Bean

8.    public RedisLimit build() {

9.        RedisClusterConnection clusterConnection = jedisConnectionFactory.getClusterConnection();

10.        JedisCluster jedisCluster = (JedisCluster) clusterConnection.getNativeConnection();

11.        RedisLimit redisLimit = new RedisLimit.Builder<>(jedisCluster)

12.                .limit(limit)

13.                .build();

14.        return redisLimit;

15.    }

16. }

接着在 Controller 使用组件：

1.    @Autowired

2.    private RedisLimit redisLimit ;

3.    @Override

4.    @CheckReqNo

5.    public BaseResponse<OrderNoResVO> getOrderNo(@RequestBody OrderNoReqVO orderNoReq) {

6.        BaseResponse<OrderNoResVO> res = new BaseResponse();

7.        //限流

8.        boolean limit = redisLimit.limit();

9.        if (!limit){

10.            res.setCode(StatusEnum.REQUEST_LIMIT.getCode());

11.            res.setMessage(StatusEnum.REQUEST_LIMIT.getMessage());

12.            return res ;

13.        }

14.        res.setReqNo(orderNoReq.getReqNo());

15.        if (null == orderNoReq.getAppId()){

16.            throw new SBCException(StatusEnum.FAIL);

17.        }

18.        OrderNoResVO orderNoRes = new OrderNoResVO() ;

19.        orderNoRes.setOrderId(DateUtil.getLongTime());

20.        res.setCode(StatusEnum.SUCCESS.getCode());

21.        res.setMessage(StatusEnum.SUCCESS.getMessage());

22.        res.setDataBody(orderNoRes);

23.        return res ;

24.    }

为了方便使用，也提供了注解:

1.    @Override

2.    @ControllerLimit

3.    public BaseResponse<OrderNoResVO> getOrderNoLimit(@RequestBody OrderNoReqVO orderNoReq) {

4.        BaseResponse<OrderNoResVO> res = new BaseResponse();

5.        // 业务逻辑

6.        return res ;

7.    }

该注解拦截了 http 请求，会再请求达到阈值时直接返回。

普通方法也可使用:

1. @CommonLimit

2. public void doSomething(){}

会在调用达到阈值时抛出异常。

为了模拟并发，在 User 应用中开启了 10 个线程调用 Order(限流次数为5) 接口(也可使用专业的并发测试工具 JMeter 等)。

1.    @Override

2.    public BaseResponse<UserResVO> getUserByFeign(@RequestBody UserReqVO userReq) {

3.        //调用远程服务

4.        OrderNoReqVO vo = new OrderNoReqVO();

5.        vo.setAppId(1L);

6.        vo.setReqNo(userReq.getReqNo());

7.        for (int i = 0; i < 10; i++) {

8.            executorService.execute(new Worker(vo, orderServiceClient));

9.        }

10.        UserRes userRes = new UserRes();

11.        userRes.setUserId(123);

12.        userRes.setUserName("张三");

13.        userRes.setReqNo(userReq.getReqNo());

14.        userRes.setCode(StatusEnum.SUCCESS.getCode());

15.        userRes.setMessage("成功");

16.        return userRes;

17.    }

18.    private static class Worker implements Runnable {

19.        private OrderNoReqVO vo;

20.        private OrderServiceClient orderServiceClient;

21.        public Worker(OrderNoReqVO vo, OrderServiceClient orderServiceClient) {

22.            this.vo = vo;

23.            this.orderServiceClient = orderServiceClient;

24.        }

25.        @Override

26.        public void run() {

27.            BaseResponse<OrderNoResVO> orderNo = orderServiceClient.getOrderNoCommonLimit(vo);

28.            logger.info("远程返回:" + JSON.toJSONString(orderNo));

29.        }

30.    }    

为了验证分布式效果启动了两个 Order 应用。

效果如下： 

实现原理

实现原理其实很简单。既然要达到分布式全局限流的效果，那自然需要一个第三方组件来记录请求的次数。

其中 Redis 就非常适合这样的场景。

• 每次请求时将当前时间(精确到秒)作为 Key 写入到 Redis 中，超时时间设置为 2 秒，Redis 将该 Key 的值进行自增。

• 当达到阈值时返回错误。

• 写入 Redis 的操作用 Lua 脚本来完成，利用 Redis 的单线程机制可以保证每个 Redis 请求的原子性。

Lua 脚本如下:

1. --lua 下标从 1 开始

2. -- 限流 key

3. local key = KEYS[1]

4. -- 限流大小

5. local limit = tonumber(ARGV[1])

6. -- 获取当前流量大小

7. local curentLimit = tonumber(redis.call('get', key) or "0")

8. if curentLimit + 1 > limit then

9.    -- 达到限流大小 返回

10.    return 0;

11. else

12.    -- 没有达到阈值 value + 1

13.    redis.call("INCRBY", key, 1)

14.    redis.call("EXPIRE", key, 2)

15.    return curentLimit + 1

16. end

Java 中的调用逻辑:

1.    public boolean limit() {

2.        String key = String.valueOf(System.currentTimeMillis() / 1000);

3.        Object result = null;

4.        if (jedis instanceof Jedis) {

5.            result = ((Jedis) this.jedis).eval(script, Collections.singletonList(key), Collections.singletonList(String.valueOf(limit)));

6.        } else if (jedis instanceof JedisCluster) {

7.            result = ((JedisCluster) this.jedis).eval(script, Collections.singletonList(key), Collections.singletonList(String.valueOf(limit)));

8.        } else {

9.            //throw new RuntimeException("instance is error") ;

10.            return false;

11.        }

12.        if (FAIL_CODE != (Long) result) {

13.            return true;

14.        } else {

15.            return false;

16.        }

17.    }

所以只需要在需要限流的地方调用该方法对返回值进行判断即可达到限流的目的。

当然这只是利用 Redis 做了一个粗暴的计数器，如果想实现类似于上文中的令牌桶算法可以基于 Lua 自行实现。

Builder 构建器

在设计这个组件时想尽量的提供给使用者清晰、可读性、不易出错的 API。

比如第一步，如何构建一个限流对象。

最常用的方式自然就是构造函数，如果有多个域则可以采用重叠构造器的方式:

1. public A(){}

2. public A(int a){}

3. public A(int a,int b){}

缺点也是显而易见的：如果参数过多会导致难以阅读，甚至如果参数类型一致的情况下客户端颠倒了顺序，但不会引起警告从而出现难以预测的结果。

第二种方案可以采用 JavaBean 模式，利用 setter 方法进行构建:

1. A a = new A();

2. a.setA(a);

3. a.setB(b);

这种方式清晰易读，但却容易让对象处于不一致的状态，使对象处于线程不安全的状态。

所以这里采用了第三种创建对象的方式，构建器：

1. public class RedisLimit {

2.    private JedisCommands jedis;

3.    private int limit = 200;

4.    private static final int FAIL_CODE = 0;

5.    /**

6.     * lua script

7.     */

8.    private String script;

9.    private RedisLimit(Builder builder) {

10.        this.limit = builder.limit ;

11.        this.jedis = builder.jedis ;

12.        buildScript();

13.    }

14.    /**

15.     * limit traffic

16.     * @return if true

17.     */

18.    public boolean limit() {

19.        String key = String.valueOf(System.currentTimeMillis() / 1000);

20.        Object result = null;

21.        if (jedis instanceof Jedis) {

22.            result = ((Jedis) this.jedis).eval(script, Collections.singletonList(key), Collections.singletonList(String.valueOf(limit)));

23.        } else if (jedis instanceof JedisCluster) {

24.            result = ((JedisCluster) this.jedis).eval(script, Collections.singletonList(key), Collections.singletonList(String.valueOf(limit)));

25.        } else {

26.            //throw new RuntimeException("instance is error") ;

27.            return false;

28.        }

29.        if (FAIL_CODE != (Long) result) {

30.            return true;

31.        } else {

32.            return false;

33.        }

34.    }

35.    /**

36.     * read lua script

37.     */

38.    private void buildScript() {

39.        script = ScriptUtil.getScript("limit.lua");

40.    }

41.    /**

42.     *  the builder

43.     * @param <T>

44.     */

45.    public static class Builder<T extends JedisCommands>{

46.        private T jedis = null ;

47.        private int limit = 200;

48.        public Builder(T jedis){

49.            this.jedis = jedis ;

50.        }

51.        public Builder limit(int limit){

52.            this.limit = limit ;

53.            return this;

54.        }

55.        public RedisLimit build(){

56.            return new RedisLimit(this) ;

57.        }

58.    }

59. }

这样客户端在使用时:

1. RedisLimit redisLimit = new RedisLimit.Builder<>(jedisCluster)

2.                .limit(limit)

3.                .build();

更加的简单直接，并且避免了将创建过程分成了多个子步骤。

这在有多个构造参数，但又不是必选字段时很有作用。

因此顺便将分布式锁的构建器方式也一并更新了：

https://github.com/crossoverJie/distributed-redis-tool#features

更多内容可以参考 Effective Java

API

从上文可以看出，使用过程就是调用 limit 方法。

1.   //限流

2.    boolean limit = redisLimit.limit();

3.    if (!limit){

4.       //具体限流逻辑

5.    }

为了减少侵入性，也为了简化客户端提供了两种注解方式。

@ControllerLimit

该注解可以作用于 @RequestMapping 修饰的接口中，并会在限流后提供限流响应。

实现如下：

1. @Component

2. public class WebIntercept extends WebMvcConfigurerAdapter {

3.    private static Logger logger = LoggerFactory.getLogger(WebIntercept.class);

4.    @Autowired

5.    private RedisLimit redisLimit;

6.    @Override

7.    public void addInterceptors(InterceptorRegistry registry) {

8.        registry.addInterceptor(new CustomInterceptor())

9.                .addPathPatterns("/**");

10.    }

11.    private class CustomInterceptor extends HandlerInterceptorAdapter {

12.        @Override

13.        public boolean preHandle(HttpServletRequest request, HttpServletResponse response,

14.                                 Object handler) throws Exception {

15.            if (redisLimit == null) {

16.                throw new NullPointerException("redisLimit is null");

17.            }

18.            if (handler instanceof HandlerMethod) {

19.                HandlerMethod method = (HandlerMethod) handler;

20.                ControllerLimit annotation = method.getMethodAnnotation(ControllerLimit.class);

21.                if (annotation == null) {

22.                    //skip

23.                    return true;

24.                }

25.                boolean limit = redisLimit.limit();

26.                if (!limit) {

27.                    logger.warn("request has bean limit");

28.                    response.sendError(500, "request limit");

29.                    return false;

30.                }

31.            }

32.            return true;

33.        }

34.    }

35. }

其实就是实现了 SpringMVC 中的拦截器，并在拦截过程中判断是否有使用注解，从而调用限流逻辑。

前提是应用需要扫描到该类，让 Spring 进行管理。

1. @ComponentScan(value = "com.crossoverjie.distributed.intercept")

@CommonLimit

当然也可以在普通方法中使用。实现原理则是 Spring AOP (SpringMVC 的拦截器本质也是 AOP)。

1. @Aspect

2. @Component

3. @EnableAspectJAutoProxy(proxyTargetClass = true)

4. public class CommonAspect {

5.    private static Logger logger = LoggerFactory.getLogger(CommonAspect.class);

6.    @Autowired

7.    private RedisLimit redisLimit ;

8.    @Pointcut("@annotation(com.crossoverjie.distributed.annotation.CommonLimit)")

9.    private void check(){}

10.    @Before("check()")

11.    public void before(JoinPoint joinPoint) throws Exception {

12.        if (redisLimit == null) {

13.            throw new NullPointerException("redisLimit is null");

14.        }

15.        boolean limit = redisLimit.limit();

16.        if (!limit) {

17.            logger.warn("request has bean limit");

18.            throw new RuntimeException("request has bean limit") ;

19.        }

20.    }

21. }

很简单，也是在拦截过程中调用限流。

当然使用时也得扫描到该包:

1. @ComponentScan(value = "com.crossoverjie.distributed.intercept")

总结

限流在一个高并发大流量的系统中是保护应用的一个利器，成熟的方案也很多，希望对刚了解这一块的朋友提供一些思路。

以上所有的源码：

• https://github.com/crossoverJie/distributed-redis-tool

• https://github.com/crossoverJie/springboot-cloud

感兴趣的朋友可以点个 Star 或是提交 PR。

号外

最近在总结一些 Java 相关的知识点，感兴趣的朋友可以一起维护。

地址: https://github.com/crossoverJie/Java-Interview