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语言脚本

上图中执行了两个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....]

使用签名运行Lua脚本

下面看看结合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 rs = new DefaultRedisScript<>();
        // 设置脚本
        rs.setScriptText("redis.call('set',KEYS[1],ARGV[1]) return redis.call('get', KEYS[1])");
        // 定义操作的key列表
        List 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
[图片上传中...(14.png-dada88-1534800159271-0)]
end
if n1 < n2 then
    return 2
end

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

在linux中执行下面的命令

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

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

redis-cli的命令执行

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

在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操作文件，这样就可以序列化直接操作对象。