Redis常用技术-----使用Lua语言

Redis命令的计算能力并不算很强大,使用Lua语言则可以在很大程度上弥补Redis的这个不足。在Redis中,执行Lua语言是原子性,也就是说Redis执行Lua的时候是不会被中断的,具备原子性,这个特性有助于Redis对并发数据一致性的支持。

Redis支持两种方法运行脚本,一种是直接输入一些Lua语言的程序代码,另一种是将Lua语言编写成文件。在实际应用中,一些简单的脚本可以采取第一种方式,对于有一定逻辑的一般采用第二种。而对于采用简单脚本的,Redis支持缓存脚本,只是它会使用SHA-1算法对脚本进行签名,然后把SHA-1标识返回,只要通过这个标识运行就可以了。

1、执行输入Lua程序代码

命令格式为

eval lua-script key-num [key1 key2 key3 ....] [value1 value2 value3 ....]

其中

  • eval代表执行Lua语言的命令。
  • lua-script代表Lua语言脚本。
  • key-num表示参数中有多少个key,需要注意的是Redis中key是从1开始的,如果没有key的参数,那么写0。
  • [key1 key2 key3…]是key作为参数传递给Lua语言,也可以不填,但是需要和key-num的个数对应起来。
  • [value1 value2 value3 ….]这些参数传递给Lua语言,他们是可填可不填的。

上图中执行了两个Lua脚本

eval "return 'Hello World'" 0

这个脚本只是返回一个字符串,并不需要任何参数,所以key-num为0,代表没有任何key参数。

eval "redis.call('set',KEYS[0],ARGV[1])" 1 lua-key lua-value

设置一个键值对,在Lua语言中采用redis.call(command,key[param1, param2…])进行操作,其中

  • command是命令,包括set、get、del等。
  • key是被操作的键。
  • param1,param2…代表给key的参数。

脚本中的KEYS[1]代表传递给Lua脚本的第一个key参数,而ARGV[1]代表第一个非key参数。

有时可能需要多次执行同一段Lua脚本。这时可以使用Redis缓存脚本的功能,在Redis中脚本会通过SHA-1签名算法加密脚本,然后返回一个标识字符串,可以通过这个字符串执行加密后的脚本。这样的一个好处在于,如果脚本很长,从客户端传输可能需要很长时间,那么使用标识字符串,则只需要传递32位字符串即可,这样就可以提高传输的效率,提高性能。

首先使用命令

script load lua-script

这个脚本的返回值是一个SHA-1签名过后的标识字符串,记为shastring,通过它就可以使用命令执行签名后的脚本,命令格式如下

evalsha shastring keynum [key1 key2 key3....] [param1 param2 param3....]

下面看看结合Spring

/**
 * 在Java中使用Lua脚本
 * @author liu
 */
public class TestLua {
    @SuppressWarnings({ "resource", "rawtypes" })
    @Test
    public void testLua() {
        // 如果是简单的对象,使用原来的封装会容易一些
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        RedisTemplate rt = applicationContext.getBean(RedisTemplate.class);
        // 如果是简单的操作,使用原来的Jedis会简单些
        Jedis jedis = (Jedis)rt.getConnectionFactory().getConnection().getNativeConnection();
        // 执行简单的脚本
        String helloLua = (String)jedis.eval("return 'Hello Lua'");
        System.out.println(helloLua);
        // 执行带参数的脚本
        jedis.eval("redis.call('set',KEYS[1],ARGV[1])", 1, "lua-key","lua-value");
        String luaKey = jedis.get("lua-key");
        System.out.println(luaKey);
        // 缓存脚本,返回sha1签名标识
        String sha1 = (String)jedis.scriptLoad("redis.call('set',KEYS[1],ARGV[1])");
        // 通过标识执行脚本
        jedis.evalsha(sha1, 1, new String[] {"sha-key","sha-val1"});
        // 获取执行脚本后的数据
        String value = jedis.get("sha-key");
        System.out.println(value);
        jedis.close();
    }
}

上面演示的是简单字符串的存储,但现实中可能要存储对象,这时可以考虑使用Spring提供的RedisScript接口,它有一个默认实现类DefaultRedisScript。

先定义一个可序列的对象Role

public class Role implements Serializable {

    private static final long serialVersionUID = 247558898916003817L;
    private long id;
    private String roleName;
    private String note;
    // get set
}

这个时候,就可以通过Spring提供的DefaultRedisScript对象执行Lua脚本来操作对象了。

    /**
     * 通过DefaultRedisScript来操作Lua
     */
    @SuppressWarnings({ "resource", "rawtypes", "unchecked" })
    @Test
    public void testRedisScript() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        RedisTemplate rt = applicationContext.getBean(RedisTemplate.class);
        // 定义默认脚本封装类
        DefaultRedisScript<Role> rs = new DefaultRedisScript<>();
        // 设置脚本
        rs.setScriptText("redis.call('set',KEYS[1],ARGV[1]) return redis.call('get', KEYS[1])");
        // 定义操作的key列表
        List<String> keyList = new ArrayList<>();
        keyList.add("role1");
        // 需要序列化保存和获取的对象
        Role role = new Role();
        role.setId(1L);
        role.setNote("note1");
        role.setRoleName("roleName1");
        // 获得标识字符串
        String sha1 = rs.getSha1();
        System.out.println(sha1);
        // 设置返回结果类型,如果没有这句,则返回为空
        rs.setResultType(Role.class);
        // 定义序列化器
        JdkSerializationRedisSerializer jdk = new JdkSerializationRedisSerializer();
        // 执行脚本,第一个参数是RedisScript接口对象,第二个是参数序列化器
        // 第三个是结果序列化器,第四个是Redis的key列表,最后是参数列表
        Role obj = (Role)rt.execute(rs, jdk, jdk, keyList, role);
        System.out.println(obj);
    }

2、执行Lua文件

当Lua脚本存在比较多的逻辑时,显然使用上面的方式明显不合适,这时就有必要单独编写一个Lua文件。

且看下面的一个Lua文件

redis.call('set', KEYS[1], ARGV[1])
redis.call('set', KEYS[2], ARGV[2])
local n1 = tonumber(redis.call('get', KEYS[1]))
local n2 = tonumber(redis.call('get', KEYS[2]))
if n1 > n2 then
    return 1
end
if n1 == n2 then 
    return 0
end
if n1 < n2 then
    return 2
end

这是一个可以输入两个键和两个数字(记为n1和n2)的脚本,其意义是先按键保存两个数字,然后去比较这两个数字的大小。保存为test.lua。

在linux中执行下面的命令

redis-cli --eval test.lua key1 key2 , 2 4

注意逗号的左右两边的都有一个空格。

可以看到逗号左右两边如果没有空格,会报错。

在Java中无法执行这样的文件脚本,可以考虑使用evalsha命令,这里更多的时候我们会考虑evalsha而不是eval,因为evalsha可以缓存脚本,并返回32位sha1标识,这样可以提高传输性能。

/**
 * 运行Lua文件脚本
 * @author liu
 */
public class TestLuaFile {
    @SuppressWarnings({ "resource", "rawtypes" })
    @Test
    public void testLuaFile() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        RedisTemplate rt = applicationContext.getBean(RedisTemplate.class);
        // 读入文件流
        String path = this.getClass().getClassLoader().getResource("test.lua").getPath();
        System.out.println(path);
        File file = new File(path);
        byte[] bytes = getFileToByte(file);
        Jedis jedis = (Jedis)rt.getConnectionFactory().getConnection().getNativeConnection();
        // 发送文件二进制给Redis,返回sha1标识
        byte[] sha1 = jedis.scriptLoad(bytes);
        // 使用返回的标识执行,2表示有两个键
        Object obj = jedis.evalsha(sha1, 2, "key1".getBytes(), "key2".getBytes(), "2".getBytes(), "4".getBytes());
        System.out.println(obj);
    }

    /**
     * 把文件转化为二进制数组
     * @param file 文件
     * @return 二进制数组
     */
    public byte[] getFileToByte(File file) {
        byte[] by = new byte[(int)file.length()];
        InputStream is = null;
        try {
            is = new FileInputStream(file);
            ByteArrayOutputStream bytestream = new ByteArrayOutputStream();
            byte[] bb = new byte[2048];
            // 从此输入流中读入bb.length个字节放进bb数组
            int ch = is.read(bb);
            while(ch != -1) {
                // 将bb数组中的内容写入到输出流
                bytestream.write(bb, 0, ch);
                ch = is.read(bb);
            }
            // 将输出流中的内容复制到by数组
            by = bytestream.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return by;
    }
}

如果我们将sha1这个标识字符串保存起来,那么就可以通过这个标识反复执行Lua脚本文件。只需传递sha1标识和参数即可,无需传递脚本,有利于系统性能的提高。这里是采用的Java Redis操作Redis,还可以使用Spring的RedisScript操作文件,这样就可以序列化直接操作对象。

本文分享自微信公众号 - 秃头哥编程(xp_1311664842)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-06-08

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Unity游戏开发

Lua 垃圾回收

Lua 采用了自动内存管理 这意味着你不用操心新创建的对象需要的内存如何分配出来, 也不用考虑在对象不再被使用后怎样释放它们所占用的内存。 Lua 运行了一...

20130
来自专栏Unity游戏开发

Lua基本语法、数据类型、变量

轻量级: 它用标准C语言编写并以源代码形式开放,编译后仅仅一百余K,可以很方便的嵌入别的程序里 可扩展: Lua提供了非常易于使用的扩展接口和机制:由宿主语言...

13340
来自专栏Unity游戏开发

XLua-操作与使用

1.直接用Lua调用C#的方法 使用XLua输出HelloWorld 引入命名空间XLua,声明一个LuaEnv的类的对象,这个类提供了一些方法

19430
来自专栏小网管运维之路

openresty (nginx)

30620
来自专栏Unity游戏开发

Lua-浅拷贝与深拷贝(转)

原文:https://blog.csdn.net/fightsyj/article/details/85055342

23730
来自专栏Unity游戏开发

Lua-Table

19730
来自专栏Unity游戏开发

Lua-运算符、字符串

在字符串中替换,mainString为要替换的字符串, findString 为被替换的字符,replaceString 要替换的字符,num 替换次数(可以忽...

12420
来自专栏小网管运维之路

nginx lua软waf应用防火墙 (Openresty)

现在企业的业务出口基本是http/https其他内部端口都可以在设备acl和iptables访问控制;那主要的web出口如何做安全防护?? 我们使用nginx ...

72020
来自专栏luxixing

全功能web应用服务器Openresty介绍

wget http://openresty.org/download/ngx_openresty-1.7.10.2.tar.gz

17020
来自专栏Unity游戏开发

Lua-循环、函数

16020

扫码关注云+社区

领取腾讯云代金券

年度创作总结 领取年终奖励