踩坑:RedisTemplate执行Lua脚本

1、背景

有时候，我们需要一次性操作多个 Redis 命令，但是 这样的多个操作不具备原子性，而且 Redis 的事务也不够强大，不支持事务的回滚，还无法实现命令之间的逻辑关系计算。所以，一般在开发中，我们会利用 lua 脚本来实现 Redis 的事务。

2、lua 脚本

Redis 中使用 lua 脚本，我们需要注意的是，从 Redis 2.6.0后才支持 lua 脚本的执行。

使用 lua 脚本的好处：

• 原子操作：lua脚本是作为一个整体执行的，所以中间不会被其他命令插入。
• 减少网络开销：可以将多个请求通过脚本的形式一次发送，减少网络时延。
• 复用性：lua脚本可以常驻在redis内存中，所以在使用的时候，可以直接拿来复用，也减少了代码量。

3、Redis 中执行 lua 脚本

1、命令格式

：EVAL script numkeys key [key ...] arg [arg ...]

说明：

• script是第一个参数，为Lua 5.1脚本(字符串)。
• 第二个参数numkeys指定后续参数有几个key。
• key [key …]，被操作的key，可以多个，在lua脚本中通过KEYS[1], KEYS[2]获取
• arg [arg …]，参数，可以多个，在lua脚本中通过ARGV[1], ARGV[2]获取。

2、如果直接使用 redis-cli命令：

redis-cli --eval lua_file key1 key2 , arg1 arg2 arg3

说明：

• eval 命令后不再是 lua 脚本的字符串形式，而是一个 lua 脚本文件。后缀为.lua
• 不再需要numkeys参数，而是用 , 隔开多个key和多个arg

4、使用 RedisTemplate 执行 lua 脚本

例子：删除 Redis 分布式锁

引入依赖：此依赖为我们整合了 Redis ，并且提供了非常好用的 RedisTemplate。

1.  
   <dependency>
2.  
   <groupid>org.springframework.boot</groupid>
3.  
   <artifactid>spring-boot-starter-data-redis</artifactid>
4.  
   </dependency>

方式一：lua 脚本文件

1、新建 lua 脚本文件：

1.  
   if redis.call("get",KEYS[1]) == ARGV[1] then
2.  
   return redis.call("del",KEYS[1])
3.  
   else
4.  
   return 0
5.  
   end

说明：先获取指定key的值，然后和传入的arg比较是否相等，相等值删除key，否则直接返回0。

2、代码测试：

1.  
   @RunWith(SpringJUnit4ClassRunner.class)
2.  
   @ActiveProfiles("test")
3.  
   @SpringBootTest(classes = ThirdPartyServerApplication.class)
4.  
   public class RedisTest {
5.  
   @Autowired
6.  
   private StringRedisTemplate redisTemplate;
7.  
   @Test
8.  
   public void contextLoads() {
9.  
   String lockKey = "123";
10.  
    String UUID = cn.hutool.core.lang.UUID.fastUUID().toString();
11.  
    boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey,UUID,3, TimeUnit.MINUTES);
12.  
    if (!success){
13.  
    System.out.println("锁已存在");
14.  
    }
15.  
    // 执行 lua 脚本
16.  
    DefaultRedisScript redisScript = new DefaultRedisScript<>();
17.  
    // 指定 lua 脚本
18.  
    redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("redis/DelKey.lua")));
19.  
    // 指定返回类型
20.  
    redisScript.setResultType(Long.class);
21.  
    // 参数一：redisScript，参数二：key列表，参数三：arg（可多个）
22.  
    Long result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey),UUID);
23.  
    System.out.println(result);
24.  
    }
25.  
    }

方式二：直接编写 lua 脚本（字符串）

1、代码测试：

1.  
   @RunWith(SpringJUnit4ClassRunner.class)
2.  
   @ActiveProfiles("test")
3.  
   @SpringBootTest(classes = ThirdPartyServerApplication.class)
4.  
   public class RedisTest {
5.  
   /** 释放锁lua脚本 */
6.  
   private static final String RELEASE_LOCK_LUA_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
7.  
   @Autowired
8.  
   private StringRedisTemplate redisTemplate;
9.  
    
10.  
    @Test
11.  
    public void contextLoads() {
12.  
    String lockKey = "123";
13.  
    String UUID = cn.hutool.core.lang.UUID.fastUUID().toString();
14.  
    boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey,UUID,3, TimeUnit.MINUTES);
15.  
    if (!success){
16.  
    System.out.println("锁已存在");
17.  
    }
18.  
    // 指定 lua 脚本，并且指定返回值类型
19.  
    DefaultRedisScript redisScript = new DefaultRedisScript<>(RELEASE_LOCK_LUA_SCRIPT,Long.class);
20.  
    // 参数一：redisScript，参数二：key列表，参数三：arg（可多个）
21.  
    Long result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey),UUID);
22.  
    System.out.println(result);
23.  
    }
24.  
    }

踩坑：不要使用Integer作为返回类型

注意：

为什么返回值不用 Integer 接收而是用 Long。这里是因为 spring-boot-starter-data-redis 提供的返回类型里面不支持 Integer。

现在可以看看源码：

1.  
   /**
2.  
   * Represents a data type returned from Redis, currently used to denote the expected return type of Redis scripting
3.  
   * commands
4.  
   *
5.  
   * @author Jennifer Hickey
6.  
   * @author Christoph Strobl
7.  
   */
8.  
   public enum ReturnType {
9.  
   /**
10.  
    * Returned as Boolean
11.  
    */
12.  
    BOOLEAN,
13.  
    /**
14.  
    * Returned as {@link Long}
15.  
    */
16.  
    INTEGER,
17.  
    /**
18.  
    * Returned as {@link List}
19.  
    */
20.  
    MULTI,
21.  
    /**
22.  
    * Returned as {@literal byte[]}
23.  
    */
24.  
    STATUS,
25.  
    /**
26.  
    * Returned as {@literal byte[]}
27.  
    */
28.  
    VALUE;
29.  
    /**
30.  
    * @param javaType can be {@literal null} which translates to {@link ReturnType#STATUS}.
31.  
    * @return never {@literal null}.
32.  
    */
33.  
    public static ReturnType fromJavaType(@Nullable Class javaType) {
34.  
    if (javaType == null) {
35.  
    return ReturnType.STATUS;
36.  
    }
37.  
    if (javaType.isAssignableFrom(List.class)) {
38.  
    return ReturnType.MULTI;
39.  
    }
40.  
    if (javaType.isAssignableFrom(Boolean.class)) {
41.  
    return ReturnType.BOOLEAN;
42.  
    }
43.  
    if (javaType.isAssignableFrom(Long.class)) {
44.  
    return ReturnType.INTEGER;
45.  
    }
46.  
    return ReturnType.VALUE;
47.  
    }
48.  
    }

所以当我们使用 Integer 作为返回值的时候，是报以下错误：

1.  
   org.springframework.data.redis.RedisSystemException: Redis exception; nested exception is io.lettuce.core.RedisException: java.lang.IllegalStateException
2.  
   at org.springframework.data.redis.connection.lettuce.LettuceExceptionConverter.convert(LettuceExceptionConverter.java:74)
3.  
   at org.springframework.data.redis.connection.lettuce.LettuceExceptionConverter.convert(LettuceExceptionConverter.java:41)

这篇好文章是转载于：学新通技术网