关于java:Redis-分布式锁遇到的序列化问题

场景形容

最近应用 Redis 遇到了一个相似分布式锁的场景，跟 Redis 实现分布式锁类比一下，就是开释锁失败，也就是缓存删不掉。又踩了一个 Redis 的坑……

这是什么个状况、又是怎么排查的呢？

本文次要对此做个复盘。

问题排查

既然是开释锁有问题，那就先看看开释锁的代码吧。

开释锁

开释锁应用了 Lua 脚本，代码逻辑和 Lua 脚本如下：

• 开释锁示例代码

public Object release(String key, String value) {Object existedValue = stringRedisTemplate.opsForValue().get(key);
  log.info("key:{}, value:{}, redis 旧值：{}", key, value, existedValue);
  
  DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(COMPARE_AND_DELETE, Long.class);
  return stringRedisTemplate.execute(redisScript, Collections.singletonList(key), value);
}

• 开释锁应用的 Lua 脚本

if redis.call('get',KEYS[1]) == ARGV[1]
then
    return redis.call('del',KEYS[1])
else
    return 0
end;

删除脚本中，会先获取 Redis key 的旧值，并与入参 value 比拟，二者相等时才会删除。

如果开释胜利，也就是 Redis 缓存删除胜利，返回值为 1，否则失败返回为 0。

乍一看代码仿佛没啥问题，测一下试试？

不过既然要开释锁，在此之前必定要加锁，先看看加锁的逻辑吧。

加锁

说到加锁这里的逻辑，代码里有两种实现形式：

• 示例代码一

public Object lock01(String key, String value) {log.info("lock01, key={}, value={}", key, value);
  return redisTemplate.opsForValue().setIfAbsent(key, value, LOCKED_TIME, TimeUnit.SECONDS);
}

• 示例代码二

public Object lock02(String key, String value) {log.info("lock02, key={}, value={}", key, value);
  return stringRedisTemplate.opsForValue().setIfAbsent(key, value, LOCKED_TIME, TimeUnit.SECONDS);
}

其实它们的区别就在于前者应用了 RedisTemplate，而后者应用的是 StringRedisTemplate。

Q: 等等……为什么会有两个 template？？

A: 憋说了，是我挖的坑，RedisTemplate 是我加的……当初回忆都没想明确当初为什么这样搞，可能真是脑子一时抽风了。

先测试一下这两个办法？

测试一下

应用两种形式别离加锁，其中：lock01 为 k1 和 v1，lock02 为 k2 和 v2。

别离看下 k1、k2 的值（应用工具：RDM, Redis Desktop Manager）：

能够看到 v1 是有双引号的，而 v2 没有。

猜想应该是序列化的问题，看看 Redis 配置？

RedisTemplate 配置

加锁那里能够看到，k1 应用了 RedisTemplate，而 k2 是 StringRedisTemplate，它们两个的配置有什么区别呢？

其中 RedisTemplate 的配置是自定义的，如下：

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig {
  @Bean
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(redisConnectionFactory);

    // 应用 Jackson2JsonRedisSerialize 替换默认序列化
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer
        = new Jackson2JsonRedisSerializer<>(Object.class);

    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

    jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

    // 设置 key、value 的序列化规定（尤其是 value）redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
    redisTemplate.afterPropertiesSet();

    return redisTemplate;
  }
}

StringRedisTemplate 的配置是 SpringBoot 默认的，即：

@Configuration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {public RedisAutoConfiguration() { }

  @Bean
  @ConditionalOnMissingBean
  public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {StringRedisTemplate template = new StringRedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
  }
}

PS: SpringBoot 版本为 2.1.13.RELEASE

点进去 StringRedisTemplate 看下：

public class StringRedisTemplate extends RedisTemplate<String, String> {public StringRedisTemplate() {
    // 留神这里的序列化设置
    setKeySerializer(RedisSerializer.string());
    setValueSerializer(RedisSerializer.string());
    setHashKeySerializer(RedisSerializer.string());
    setHashValueSerializer(RedisSerializer.string());
  }
  // ...
}

留神下序列化设置，持续跟进，看到底是什么形式：

public interface RedisSerializer<T> {static RedisSerializer<String> string() {return StringRedisSerializer.UTF_8;}
}

public class StringRedisSerializer implements RedisSerializer<String> {public static final StringRedisSerializer UTF_8 = new StringRedisSerializer(StandardCharsets.UTF_8);
    // ...
}

能够看到，StringRedisTemplate 的 key 和 value 默认都是用 StringRedisSerializer(StandardCharsets.UTF_8) 进行序列化的。

而 RedisTemplate 的 key 应用 StringRedisSerializer，value 应用的是 Jackson2JsonRedisSerializer 序列化（至于为什么用这个，这里就不是我写的了）。

到这里，根本能够定位到问题所在了：就是 RedisTemplate 的 value 序列化和 StringRedisTemplate 不统一。

如果改成统一就能够了吗？验证一下试试。

验证推论

把 RedisTemplate 的 value 序列化形式批改为 StringRedisSerializer：

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig {
  @Bean
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
      
    // ...

    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.setValueSerializer(new StringRedisSerializer());

    // ...
    return redisTemplate;
  }
}

再调用两种加锁逻辑，看下 k1、k2 的值：

能够看到，v1 的双引号没了，开释锁的服务也能失常删掉了。

嗯，就是这里的问题。

至于两者序列化的源码，有趣味的盆友们能够持续钻研，这里就不再深入探讨了。

小结

本文遇到的这个问题，次要是因为应用了不同的 RedisTemplate 来加锁和开释锁，而这两个 template 应用了不同的序列化形式，最终还是序列化带来的问题。

当初真是粗率了，而且一时还没测进去……

对于生产环境，还是要慎之又慎：如临深渊，如履薄冰。