正文

java并发：分布式应用限流redis+lua实践

 2022-04-09  218

关键词：

任何限流都不是漫无目的的，也不是一个开关就可以解决的问题，常用的限流算法有：令牌桶，漏桶。在之前的文章中，也讲到过，但是那是基于单机场景来写。

然而再牛逼的机器，再优化的设计，对于特殊场景我们也是要特殊处理的。就拿秒杀来说，可能会有百万级别的用户进行抢购，而商品数量远远小于用户数量。如果这些请求都进入队列或者查询缓存，对于最终结果没有任何意义，徒增后台华丽的数据。对此，为了减少资源浪费，减轻后端压力，我们还需要对秒杀进行限流，只需保障部分用户服务正常即可。

就秒杀接口来说，当访问频率或者并发请求超过其承受范围的时候，这时候我们就要考虑限流来保证接口的可用性，以防止非预期的请求对系统压力过大而引起的系统瘫痪。通常的策略就是拒绝多余的访问，或者让多余的访问排队等待服务。

分布式限流

单机限流，可以用到 AtomicInteger、RateLimiter、Semaphore 这些。但是在分布式中，就不能使用了。常用分布式限流用 Nginx 限流，但是它属于网关层面，不能解决所有问题，例如内部服务，短信接口，你无法保证消费方是否会做好限流控制，所以自己在应用层实现限流还是很有必要的。

本文不涉及 nginx + lua，简单介绍 redis + lua分布式限流的实现。如果是需要在接入层限流的话，应该直接采用nginx自带的连接数限流模块和请求限流模块。

Redis + Lua 限流示例

本次项目使用SpringBoot 2.0.4，使用到 Redis 集群，Lua 限流脚本

引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>

Redis 配置

application.properties

spring.application.name=spring-boot-limit

# Redis数据库索引
spring.redis.database=0
# Redis服务器地址
spring.redis.host=10.4.89.161
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=10000

Lua 脚本

参考：聊聊高并发系统之限流特技
 http://jinnianshilongnian.iteye.com/blog/2305117

local key = "rate.limit:" .. KEYS[1] --限流KEY
local limit = tonumber(ARGV[1])        --限流大小
local current = tonumber(redis.call(‘get‘, key) or "0")
if current + 1 > limit then --如果超出限流大小
  return 0
else  --请求数+1，并设置2秒过期
  redis.call("INCRBY", key,"1")
   redis.call("expire", key,"2")
   return current + 1
end

1、我们通过KEYS[1] 获取传入的key参数
2、通过ARGV[1]获取传入的limit参数
3、redis.call方法，从缓存中get和key相关的值，如果为nil那么就返回0
4、接着判断缓存中记录的数值是否会大于限制大小，如果超出表示该被限流，返回0
5、如果未超过，那么该key的缓存值+1，并设置过期时间为1秒钟以后，并返回缓存值+1

限流注解

注解的目的，是在需要限流的方法上使用

package com.souyunku.example.annotation;
/**
 * 描述: 限流注解
 *
 * @author yanpenglei
 * @create 2018-08-16 15:24
 **/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {

    /**
     * 限流唯一标示
     *
     * @return
     */
    String key() default "";

    /**
     * 限流时间
     *
     * @return
     */
    int time();

    /**
     * 限流次数
     *
     * @return
     */
    int count();
}

公共配置

package com.souyunku.example.config;

@Component
public class Commons {

    /**
     * 读取限流脚本
     *
     * @return
     */
    @Bean
    public DefaultRedisScript<Number> redisluaScript() {
        DefaultRedisScript<Number> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("rateLimit.lua")));
        redisScript.setResultType(Number.class);
        return redisScript;
    }

    /**
     * RedisTemplate
     *
     * @return
     */
    @Bean
    public RedisTemplate<String, Serializable> limitRedisTemplate(LettuceConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Serializable> template = new RedisTemplate<String, Serializable>();
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

}

拦截器

通过拦截器拦截@RateLimit注解的方法，使用Redsi execute 方法执行我们的限流脚本，判断是否超过限流次数

以下下是核心代码

package com.souyunku.example.config;

/**
 * 描述:拦截器
 *
 * @author yanpenglei
 * @create 2018-08-16 15:33
 **/
@Aspect
@Configuration
public class LimitAspect {

    private static final Logger logger = LoggerFactory.getLogger(LimitAspect.class);

    @Autowired
    private RedisTemplate<String, Serializable> limitRedisTemplate;

    @Autowired
    private DefaultRedisScript<Number> redisluaScript;

    @Around("execution(* com.souyunku.example.controller ..*(..) )")
    public Object interceptor(ProceedingJoinPoint joinPoint) throws Throwable {

        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Class<?> targetClass = method.getDeclaringClass();
        RateLimit rateLimit = method.getAnnotation(RateLimit.class);

        if (rateLimit != null) {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            String ipAddress = getIpAddr(request);

            StringBuffer stringBuffer = new StringBuffer();
            stringBuffer.append(ipAddress).append("-")
                    .append(targetClass.getName()).append("- ")
                    .append(method.getName()).append("-")
                    .append(rateLimit.key());

            List<String> keys = Collections.singletonList(stringBuffer.toString());

            Number number = limitRedisTemplate.execute(redisluaScript, keys, rateLimit.count(), rateLimit.time());

            if (number != null && number.intValue() != 0 && number.intValue() <= rateLimit.count()) {
                logger.info("限流时间段内访问第：{} 次", number.toString());
                return joinPoint.proceed();
            }

        } else {
            return joinPoint.proceed();
        }

        throw new RuntimeException("已经到设置限流次数");
    }

    public static String getIpAddr(HttpServletRequest request) {
        String ipAddress = null;
        try {
            ipAddress = request.getHeader("x-forwarded-for");
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getRemoteAddr();
            }
            // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照‘,‘分割
            if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length()
                // = 15
                if (ipAddress.indexOf(",") > 0) {
                    ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
                }
            }
        } catch (Exception e) {
            ipAddress = "";
        }
        return ipAddress;
    }
}

控制层

添加 @RateLimit() 注解，会在 Redsi 中生成 10 秒中，可以访问5次的key

RedisAtomicLong 是为测试例子例，记录累计访问次数，跟限流没有关系。

package com.souyunku.example.controller;

/**
 * 描述: 测试页
 *
 * @author yanpenglei
 * @create 2018-08-16 15:42
 **/
@RestController
public class LimiterController {

    @Autowired
    private RedisTemplate redisTemplate;

    // 10 秒中，可以访问10次
    @RateLimit(key = "test", time = 10, count = 10)
    @GetMapping("/test")
    public String luaLimiter() {
        RedisAtomicInteger entityIdCounter = new RedisAtomicInteger("entityIdCounter", redisTemplate.getConnectionFactory());

        String date = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss.SSS");

        return date + " 累计访问次数：" + entityIdCounter.getAndIncrement();
    }
}

启动服务

package com.souyunku.example;

@SpringBootApplication
public class SpringBootLimitApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootLimitApplication.class, args);
    }
}

启动项目页面访问：http://127.0.0.1:8080/test

10 秒中，可以访问10次,超过十次，页面就报错，等够10秒，重新计算。

后台日志

2018-08-16 18:41:08.205  INFO 18076 --- [nio-8080-exec-1] com.souyunku.example.config.LimitAspect  : 限流时间段内访问第：1 次
2018-08-16 18:41:08.426  INFO 18076 --- [nio-8080-exec-3] com.souyunku.example.config.LimitAspect  : 限流时间段内访问第：2 次
2018-08-16 18:41:08.611  INFO 18076 --- [nio-8080-exec-5] com.souyunku.example.config.LimitAspect  : 限流时间段内访问第：3 次
2018-08-16 18:41:08.819  INFO 18076 --- [nio-8080-exec-7] com.souyunku.example.config.LimitAspect  : 限流时间段内访问第：4 次
2018-08-16 18:41:09.021  INFO 18076 --- [nio-8080-exec-9] com.souyunku.example.config.LimitAspect  : 限流时间段内访问第：5 次
2018-08-16 18:41:09.203  INFO 18076 --- [nio-8080-exec-1] com.souyunku.example.config.LimitAspect  : 限流时间段内访问第：6 次
2018-08-16 18:41:09.406  INFO 18076 --- [nio-8080-exec-3] com.souyunku.example.config.LimitAspect  : 限流时间段内访问第：7 次
2018-08-16 18:41:09.629  INFO 18076 --- [nio-8080-exec-5] com.souyunku.example.config.LimitAspect  : 限流时间段内访问第：8 次
2018-08-16 18:41:09.874  INFO 18076 --- [nio-8080-exec-7] com.souyunku.example.config.LimitAspect  : 限流时间段内访问第：9 次
2018-08-16 18:41:10.178  INFO 18076 --- [nio-8080-exec-9] com.souyunku.example.config.LimitAspect  : 限流时间段内访问第：10 次
2018-08-16 18:41:10.702 ERROR 18076 --- [nio-8080-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.RuntimeException: 已经到设置限流次数] with root cause

java.lang.RuntimeException: 已经到设置限流次数
    at com.souyunku.example.config.LimitAspect.interceptor(LimitAspect.java:73) ~[classes/:na]
    at sun.reflect.GeneratedMethodAccessor35.invoke(Unknown Source) ~[na:na]
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) ~[na:1.8.0_112]
    at java.lang.reflect.Method.invoke(Method.java:498) ~[na:1.8.0_112]

Contact

作者：鹏磊
出处：http://www.ymq.io/2018/08/16/redis-lua/
版权归作者所有，转载请注明出处
Wechat：关注公众号，搜云库，专注于开发技术的研究与知识分享

技术分享图片

redis应用场景中布隆过滤及高并发限流及分布式锁等应用(代码片段)

...；以及令牌桶、漏斗算法原理如何做到限流的；分布式锁，如何利用redis实现一个分布式锁，通过这几种应用场景去了解redis的应用Redis实现去幂等性例如在租房时，有一张房屋信息表& 查看详情

使用redis+lua脚本实现分布式限流(代码片段)

...（enhance-boot-limiting）主要是基于Redis+lua实现了分布式限流功能项目中提供两种分布式限流算法（一种是滑动时间窗口算法、一种是令牌桶算法）项目中提供了方便使用的注解形式来直接对接口进行限流，详... 查看详情

使用redis+lua脚本实现分布式限流(代码片段)

...（enhance-boot-limiting）主要是基于Redis+lua实现了分布式限流功能项目中提供两种分布式限流算法（一种是滑动时间窗口算法、一种是令牌查看详情

java基于redis实现分布式应用限流(代码片段)

查看详情

springboot分布式限流实践

高并发访问时，缓存、限流、降级往往是系统的利剑，在互联网蓬勃发展的时期，经常会面临因用户暴涨导致的请求不可用的情况，甚至引发连锁反映导致整个系统崩溃。这个时候常见的解决方案之一就是限流了，当请... 查看详情

大型电商分布式网站架构设计与实践，java分布式架构，java事务分布式高并发-视频教程

...优化、Springboot、Redis、ActiveMQ、Nginx、Mycat、Netty、Jvm大型分布式项目实战视频教程视频课程包含：高级Java架构师包含：Springboot、Spring cloud、Dubbo、Redis、ActiveMQ、Nginx、Mycat、Spring、MongoDB、Ze 查看详情

redis限流的3种方式，还有谁不会

...近的人等功能，这些可能会后续写到。我们在使用Redis的分布式锁的时候，大家都知道是依靠了setnx的指令，在CAS（Compareandswap）的操作的时候，同时给指定的key设置了过期实践（expire），我们在限流的主要目的就是为了在单位时... 查看详情

redis限流的3种方式，还有谁不会！

...到。1第一种：基于Redis的setnx的操作我们在使用Redis的分布式锁的时候，大家都知道是依靠了setnx的指令，在CAS（Compareandswap）的操作的时候，同时给指定的key设置了过期实践（expire），我们在限... 查看详情

springboot如何进行限流，老鸟们还可以这样玩！(代码片段)

...具类实现了接口限流。但是这种方式有个问题，无法实现分布式限流。那今天我们来利用Redis+Lua来实现分布式限流。Lua脚本和MySQL数据库的存储过程比较相似，他们执行一组命令，所有命令的执行要么全部成功或者失败，以此达... 查看详情

java并发编程-应用限流及其常见算法

应用限流在开发高并发系统时，有三把利器用来保护系统：缓存、降级和限流：缓存：缓存的目的是提升系统访问速度和增大系统处理容量降级：降级是当服务出现问题或者影响到核心流程时，需要暂时屏蔽掉，待高峰或者问题... 查看详情

分布式限流redis-cell

...子性的限流功能，并允许突发流量，可以很方便的应用于分布式环境中。令牌桶算法的原理是定义一个按一定速率产生token的桶，每次去桶中申请token，若桶中没有足够的token则申请失败，否则成功。在请求不多的情况下，桶中的... 查看详情

基于redis+lua的令牌桶限流器的实现

参考技术A例如: 查看详情

lua脚本在redis事务中的应用实践

使用过Redis事务的应该清楚，Redis事务实现是通过打包多条命令，单独的隔离操作，事务中的所有命令都会按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。事务中的命令要么全部被执行，要么... 查看详情

redis限流的3种方式，还有谁不会..(代码片段)

...到。第一种：基于Redis的setnx的操作我们在使用Redis的分布式锁的时候，大家都知道是依靠了setnx的指令，在CAS（Compareandswap）的操作的时候，同时给指定的key设置了过期实践（expire），我们在限... 查看详情

springboot-优雅的实现流控

...息队列思路+应用拆分思路+应用限流思路深入理解分布式技术-限流计数器查看详情

详解redisson分布式限流的实现原理

...一些注意事项。本文分享自华为云社区《详解Redisson分布式限流的实现原理》，作者：xindoo。我们目前在工作中遇到一个性能问题，我们有个定时任务需要处理大量的数据，为了提升吞吐量，所以部署了很多台机器，但... 查看详情

ja17-大型电商分布式系统应用实践+性能优化+分布式应用架构+负载均衡+高并发设计+持久化存储视频教程

JA17-大型电商分布式系统应用实践+性能优化+分布式应用架构+负载均衡+高并发设计+持久化存储视频教程新年伊始，学习要趁早，点滴记录，学习就是进步!不要到处找了，抓紧提升自己。对于学习有困难不知道如何提升自己可以... 查看详情

springboot如何进行限流？老鸟们还可以这样玩！

...实现了接口限流。但是这种方式有个问题，无法实现分布式限流。那今天我们来利用Redis+Lua来实现分布式限流。Lua脚本和MySQL数据库的存储过程比较相似，他们执行一组命令，所有命令查看详情

正文

java并发：分布式应用限流redis+lua实践

Redis + Lua 限流示例

引入依赖

Redis 配置

Lua 脚本

限流注解

公共配置

拦截器

控制层

启动服务

推荐阅读

Contact

redis应用场景中布隆过滤及高并发限流及分布式锁等应用(代码片段)

使用redis+lua脚本实现分布式限流(代码片段)

使用redis+lua脚本实现分布式限流(代码片段)

java基于redis实现分布式应用限流(代码片段)

springboot分布式限流实践

大型电商分布式网站架构设计与实践，java分布式架构，java事务分布式高并发-视频教程

redis限流的3种方式，还有谁不会

redis限流的3种方式，还有谁不会！

springboot如何进行限流，老鸟们还可以这样玩！(代码片段)

java并发编程-应用限流及其常见算法

分布式限流redis-cell

基于redis+lua的令牌桶限流器的实现

lua脚本在redis事务中的应用实践

redis限流的3种方式，还有谁不会..(代码片段)

springboot-优雅的实现流控

详解redisson分布式限流的实现原理

ja17-大型电商分布式系统应用实践+性能优化+分布式应用架构+负载均衡+高并发设计+持久化存储视频教程

springboot如何进行限流？老鸟们还可以这样玩！