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

妖狐艹你老母 2022-05-16 12:13 194阅读 0赞

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]

上图中执行了两个Lua脚本

eval "return 'Hello World'" 0

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

eval "redis.call('set',KEYS[1],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脚本][Lua 1]

下面看看结合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

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

![redis-cli的命令执行][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操作文件，这样就可以序列化直接操作对象。

[Lua]: /images/20220516/7c2ebba2b33b44398f782dfca23f9dd6.png
[Lua 1]: /images/20220516/cac223b98a4c416785f5e7d68978b6b2.png
[redis-cli]: /images/20220516/f64f27774b49490eb93fcbc9783d4f23.png