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
[图片上传中...(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
注意逗号的左右两边的都有一个空格。
可以看到逗号左右两边如果没有空格，会报错。
在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操作文件，这样就可以序列化直接操作对象。
