脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 数据库 → Redis → redis lua分布式限流

利用redis lua脚本实现时间窗分布式限流

 更新时间：2024年03月26日 09:42:14   作者：DimonHo  
Lua是一种轻量小巧的脚本语言,Redis是高性能的key-value内存数据库,在部分场景下,是对关系数据库的良好补充,本文给大家介绍了如何利用redis lua脚本实现时间窗分布式限流,需要的朋友可以参考下

需求背景：

限制某sql在30秒内最多只能执行3次

需求分析

微服务分布式部署，既然是分布式限流，首先自然就想到了结合redis的zset数据结构来实现。
分析对zset的操作，有几个步骤，首先，判断zset中符合rangeScore的元素个数是否已经达到阈值，如果未达到阈值，则add元素，并返回true。如果已达到阈值，则直接返回false。

代码实现

首先，我们需要根据需求编写一个lua脚本

redis.call('ZREMRANGEBYSCORE', KEYS[1], 0, tonumber(ARGV[3]))
local res = 0
if(redis.call('ZCARD', KEYS[1]) < tonumber(ARGV[5])) then
    redis.call('ZADD', KEYS[1], tonumber(ARGV[2]), ARGV[1])
    res = 1
end
redis.call('EXPIRE', KEYS[1], tonumber(ARGV[4]))
return res

ARGV[1]: zset element
ARGV[2]: zset score(当前时间戳)
ARGV[3]: 30秒前的时间戳
ARGV[4]: zset key 过期时间30秒
ARGV[5]: 限流阈值

private final RedisTemplate<String, Object> redisTemplate;

public boolean execLuaScript(String luaStr, List<String> keys, List<Object> args){
	RedisScript<Boolean> redisScript = RedisScript.of(luaStr, Boolean.class)
	return redisTemplate.execute(redisScript, keys, args.toArray());
}

测试一下效果

@SpringBootTest
public class ApiApplicationTest {
    @Test
    public void test2() throws InterruptedException{
        String luaStr = "redis.call('ZREMRANGEBYSCORE', KEYS[1], 0, tonumber(ARGV[3]))\n" +
                "local res = 0\n" +
                "if(redis.call('ZCARD', KEYS[1]) < tonumber(ARGV[5])) then\n" +
                "    redis.call('ZADD', KEYS[1], tonumber(ARGV[2]), ARGV[1])\n" +
                "    res = 1\n" +
                "end\n" +
                "redis.call('EXPIRE', KEYS[1], tonumber(ARGV[4]))\n" +
                "return res";
        for (int i = 0; i < 10; i++) {
            boolean res = execLuaScript(luaStr, Arrays.asList("aaaa"), Arrays.asList("ele"+i, System.currentTimeMillis(),System.currentTimeMillis()-30*1000, 30, 3));
            System.out.println(res);
            Thread.sleep(5000);
        }
    }
}

测试结果符合预期！

扩展阅读

lua脚本每次都需要传一长串脚本内容来回传输，会增加网络流量和延迟，而且每次都需要服务器重新解释和编译，效率较为低下。因此，不建议在实际生产环境中直接执行lua脚本，而应该使用lua脚本的hash值来进行传输。

为了方便使用，我们先把方法封装一下

import lombok.RequiredArgsConstructor;
import org.springframework.data.redis.connection.RedisScriptingCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @author 敖癸
 * @formatter:on
 * @since 2024/3/25
 */
@Component
@RequiredArgsConstructor
public class RedisService {

    private final RedisTemplate<String, Object> redisTemplate;
    private static RedisScriptingCommands commands;
    private static RedisSerializer keySerializer;
    private static RedisSerializer valSerializer;
    
    public String loadScript(String luaStr) {
        byte[] bytes = RedisSerializer.string().serialize(luaStr);
        return this.getCommands().scriptLoad(bytes);
    }

    public <T> T execLuaHashScript(String hash, Class<T> returnType, List<String> keys, Object[] args) {
        byte[][] keysAndArgs = toByteArray(this.getKeySerializer(), this.getValSerializer(), keys, args);
        return this.getCommands().evalSha(hash, ReturnType.fromJavaType(returnType), keys.size(), keysAndArgs);
    }

    private static byte[][] toByteArray(RedisSerializer keySerializer, RedisSerializer argsSerializer, List<String> keys, Object[] args) {
        final int keySize = keys != null ? keys.size() : 0;
        byte[][] keysAndArgs = new byte[args.length + keySize][];
        int i = 0;
        if (keys != null) {
            for (String key : keys) {
                keysAndArgs[i++] = keySerializer.serialize(key);
            }
        }
        for (Object arg : args) {
            if (arg instanceof byte[]) {
                keysAndArgs[i++] = (byte[]) arg;
            } else {
                keysAndArgs[i++] = argsSerializer.serialize(arg);
            }
        }
        return keysAndArgs;
    }

    private RedisScriptingCommands getCommands() {
        if (commands == null) {
            commands = redisTemplate.getRequiredConnectionFactory().getConnection().scriptingCommands();
        }
        return commands;
    }

    private RedisSerializer getKeySerializer() {
        if (keySerializer == null) {
            keySerializer = redisTemplate.getKeySerializer();
        }
        return keySerializer;
    }

    private RedisSerializer getValSerializer() {
        if (valSerializer == null) {
            valSerializer = redisTemplate.getValueSerializer();
        }
        return valSerializer;
    }
}
  • 测试一下：
@SpringBootTest
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class ApiApplicationTest implements ApplicationContextAware {

    private static ApplicationContext context;
    private static RedisService redisService;
    public static String luaHash;

    private final static String LUA_STR = "redis.call('ZREMRANGEBYSCORE', KEYS[1], 0, tonumber(ARGV[3]))\n" +
            "local res = 0\n" +
            "if(redis.call('ZCARD', KEYS[1]) < tonumber(ARGV[5])) then\n" +
            "    redis.call('ZADD', KEYS[1], tonumber(ARGV[2]), ARGV[1])\n" +
            "    res = 1\n" +
            "end\n" +
            "redis.call('EXPIRE', KEYS[1], tonumber(ARGV[4]))\n" +
            "return res";

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        context = applicationContext;
    }

    @BeforeAll
    public static void before(){
        redisService = context.getBean(RedisService.class);
        luaHash = redisService.loadScript(LUA_STR);
        System.out.println("lua脚本hash: "+ luaHash);
    }


    @Test
    public void testLuaHash() throws InterruptedException {
        for (int i = 0; i < 50; i++) {
            List<String> keys = Collections.singletonList("aaaa");
            Object[] args = new Object[]{"ele" + i, System.currentTimeMillis(), System.currentTimeMillis() - 30 * 1000, 30, 3};
            Boolean b = redisService.execLuaHashScript(luaHash, Boolean.class, keys, args);
            System.out.println(b);
            Thread.sleep(3000);
        }
    }
}

使用的时候在项目启动时候，把脚本load一下，后续直接用hash值就行了

搞定收工！

以上就是利用redis lua脚本实现时间窗分布式限流的详细内容，更多关于redis lua时间窗分布式限流的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • Redis结合Lua脚本实现分布式锁详解

    Redis结合Lua脚本实现分布式锁详解

    Lua 是一种轻量小巧的脚本语言,用标准C语言编写并以源代码形式开放, 本文主要为大家介绍了Redis如何结合Lua脚本实现分布式锁,需要的可以参考下
    2024-02-02
  • 解决redis启动的警告日志问题

    解决redis启动的警告日志问题

    这篇文章主要介绍了解决redis启动的警告日志问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
    2024-01-01
  • redis中的事务操作案例分析

    redis中的事务操作案例分析

    这篇文章主要介绍了redis中的事务操作案例,结合具体实例形式详细分析了redis事务操作的概念、原理、使用技巧与相关注意事项,需要的朋友可以参考下
    2019-07-07
  • redis基本类型和使用方法详解

    redis基本类型和使用方法详解

    这篇文章主要介绍了redis基本类型和使用方法详解,需要的朋友可以参考下
    2020-02-02
  • Redis 常见缓存问题总结

    Redis 常见缓存问题总结

    这篇文章主要给大家总结了一些Redis 常见缓存问题，并介绍了解决办法，文中的图文示例介绍的非常仔细，感兴趣的同学可以参考阅读下
    2023-06-06
  • 利用Redis实现访问次数限流的方法详解

    利用Redis实现访问次数限流的方法详解

    这篇文章主要给大家介绍了关于如何利用Redis实现访问次数限流的相关资料,文中通过实例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2022-02-02
  • Redis抢单预热的实现示例

    Redis抢单预热的实现示例

    本文主要介绍了Redis抢单预热的实现示例,以应对抢单活动带来的高并发访问压力,具有一定的参考价值,感兴趣的可以了解一下
    2023-11-11
  • Rocky9部署redis的实现示例

    Rocky9部署redis的实现示例

    本文主要介绍了Rocky9部署redis的实现示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2024-06-06
  • 基于Redis分布式锁的实现代码

    基于Redis分布式锁的实现代码

    这篇文章主要介绍了Redis分布式锁的实现,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2018-05-05
  • Redis官方可视化工具RedisInsight的安装使用详细教程(功能强大)

    Redis官方可视化工具RedisInsight的安装使用详细教程(功能强大)

    RedisInsight是Redis官方出品的可视化管理工具，可用于设计、开发、优化你的Redis应用。支持深色和浅色两种主题，界面非常炫酷，接下来通过本文给大家介绍Redis官方可视化工具RedisInsight的安装使用过程,需要的朋友可以参考下
    2022-04-04

最新评论