Redis 分布式锁遇到的序列化问题

Redis 分布式锁遇到的序列化问题

作者： jaxer 2021-03-24 08:41:38

开发

前端

分布式

Redis 最近使用 Redis 遇到了一个类似分布式锁的场景，跟 Redis 实现分布式锁类比一下，就是释放锁失败，也就是缓存删不掉。又踩了一个 Redis 的坑……本文主要对此做个复盘。

为淮阴等地区用户提供了全套网页设计制作服务，及淮阴网站建设行业解决方案。主营业务为成都网站设计、做网站、淮阴网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

场景描述

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

这是什么个情况、又是怎样排查的呢?

本文主要对此做个复盘。

问题排查

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

释放锁

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

释放锁示例代码

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

释放锁使用的 Lua 脚本

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

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

如果释放成功，也就是 Redis 缓存删除成功，返回值为 1，否则失败返回为 0。

乍一看代码似乎没啥问题，测一下试试?

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

加锁

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

示例代码一

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

示例代码二

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

其实它们的区别就在于前者使用了 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 的配置是自定义的，如下：

  
 
 
 
       
  
  
  
  1. @Configuration 
    2.    
  
  
  
  2. @AutoConfigureAfter(RedisAutoConfiguration.class) 
    3.    
  
  
  
  3. public class RedisConfig { 
    4.    
  
  
  
  4.   @Bean 
    5.    
  
  
  
  5.   public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) { 
    6.    
  
  
  
  6.     RedisTemplate redisTemplate = new RedisTemplate<>(); 
    7.    
  
  
  
  7.     redisTemplate.setConnectionFactory(redisConnectionFactory); 
    8.    
  
  
  
  8.  
    9.    
  
  
  
  9.     // 使用 Jackson2JsonRedisSerialize 替换默认序列化 
    10.    
  
  
  
  10.     Jackson2JsonRedisSerializer jackson2JsonRedisSerializer    
  
  
  
  11.         = new Jackson2JsonRedisSerializer<>(Object.class); 
    12.    
  
  
  
  12.  
    13.    
  
  
  
  13.     ObjectMapper objectMapper = new ObjectMapper(); 
    14.    
  
  
  
  14.     objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); 
    15.    
  
  
  
  15.     objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); 
    16.    
  
  
  
  16.     objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); 
    17.    
  
  
  
  17.  
    18.    
  
  
  
  18.     jackson2JsonRedisSerializer.setObjectMapper(objectMapper); 
    19.    
  
  
  
  19.  
    20.    
  
  
  
  20.     // 设置 key、value 的序列化规则（尤其是 value） 
    21.    
  
  
  
  21.     redisTemplate.setKeySerializer(new StringRedisSerializer()); 
    22.    
  
  
  
  22.     redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); 
    23.    
  
  
  
  23.     redisTemplate.afterPropertiesSet(); 
    24.    
  
  
  
  24.  
    25.    
  
  
  
  25.     return redisTemplate; 
    26.    
  
  
  
  26.   } 
    27.    
  
  
  
  27. } 
    28.   
 
 

    StringRedisTemplate 的配置是 SpringBoot 默认的，即：
      
 
 
 
         
  
  
  
    1. @Configuration 
      2.    
  
  
  
    2. @ConditionalOnClass({RedisOperations.class}) 
      3.    
  
  
  
    3. @EnableConfigurationProperties({RedisProperties.class}) 
      4.    
  
  
  
    4. @Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class}) 
      5.    
  
  
  
    5. public class RedisAutoConfiguration { 
      6.    
  
  
  
    6.   public RedisAutoConfiguration() { 
      7.    
  
  
  
    7.   } 
      8.    
  
  
  
    8.  
      9.    
  
  
  
    9.   @Bean 
      10.    
  
  
  
    10.   @ConditionalOnMissingBean 
      11.    
  
  
  
    11.   public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { 
      12.    
  
  
  
    12.     StringRedisTemplate template = new StringRedisTemplate(); 
      13.    
  
  
  
    13.     template.setConnectionFactory(redisConnectionFactory); 
      14.    
  
  
  
    14.     return template; 
      15.    
  
  
  
    15.   } 
      16.    
  
  
  
    16. } 
      17.   
 
 

    PS: SpringBoot 版本为 2.1.13.RELEASE
    点进去 StringRedisTemplate 看下：
      
 
 
 
         
  
  
  
    1. public class StringRedisTemplate extends RedisTemplate { 
      2.    
  
  
  
    2.      
      3.    
  
  
  
    3.   public StringRedisTemplate() { 
      4.    
  
  
  
    4.     // 注意这里的序列化设置 
      5.    
  
  
  
    5.     setKeySerializer(RedisSerializer.string()); 
      6.    
  
  
  
    6.     setValueSerializer(RedisSerializer.string()); 
      7.    
  
  
  
    7.     setHashKeySerializer(RedisSerializer.string()); 
      8.    
  
  
  
    8.     setHashValueSerializer(RedisSerializer.string()); 
      9.    
  
  
  
    9.   } 
      10.    
  
  
  
    10.   // ... 
      11.    
  
  
  
    11. } 
      12.   
 
 

    注意下序列化设置，继续跟进，看到底是什么方式：
      
 
 
 
         
  
  
  
    1. public interface RedisSerializer { 
      2.    
  
  
  
    2.   static RedisSerializer string() { 
      3.    
  
  
  
    3.     return StringRedisSerializer.UTF_8; 
      4.    
  
  
  
    4.   } 
      5.    
  
  
  
    5. } 
      6.   
 
 

      
 
 
 
         
  
  
  
    1. public class StringRedisSerializer implements RedisSerializer { 
      2.    
  
  
  
    2.   public static final StringRedisSerializer UTF_8 = new StringRedisSerializer(StandardCharsets.UTF_8); 
      3.    
  
  
  
    3.     // ... 
      4.    
  
  
  
    4. } 
      5.   
 
 

    可以看到，StringRedisTemplate 的 key 和 value 默认都是用 StringRedisSerializer(StandardCharsets.UTF_8) 进行序列化的。
    而 RedisTemplate 的 key 使用 StringRedisSerializer，value 使用的是 Jackson2JsonRedisSerializer 序列化(至于为什么用这个，这里就不是我写的了)。
    到这里，基本可以定位到问题所在了：就是 RedisTemplate 的 value 序列化和 StringRedisTemplate 不一致。
    如果改成一致就可以了吗?验证一下试试。
    验证推论
    把 RedisTemplate 的 value 序列化方式修改为 StringRedisSerializer：
      
 
 
 
         
  
  
  
    1. @Configuration 
      2.    
  
  
  
    2. @AutoConfigureAfter(RedisAutoConfiguration.class) 
      3.    
  
  
  
    3. public class RedisConfig { 
      4.    
  
  
  
    4.   @Bean 
      5.    
  
  
  
    5.   public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) { 
      6.    
  
  
  
    6.     RedisTemplate redisTemplate = new RedisTemplate<>(); 
      7.    
  
  
  
    7.        
      8.    
  
  
  
    8.     // ... 
      9.    
  
  
  
    9.  
      10.    
  
  
  
    10.     redisTemplate.setKeySerializer(new StringRedisSerializer()); 
      11.    
  
  
  
    11.     redisTemplate.setValueSerializer(new StringRedisSerializer()); 
      12.    
  
  
  
    12.  
      13.    
  
  
  
    13.     // ... 
      14.    
  
  
  
    14.     return redisTemplate; 
      15.    
  
  
  
    15.   } 
      16.    
  
  
  
    16. } 
      17.   
 
 

    再调用两种加锁逻辑，看下 k1、k2 的值：
    可以看到，v1 的双引号没了，释放锁的服务也能正常删掉了。
    嗯，就是这里的问题。
    至于两者序列化的源码，有兴趣的盆友们可以继续研究，这里就不再深入探讨了。
    小结
    本文遇到的这个问题，主要是因为使用了不同的 RedisTemplate 来加锁和释放锁，而这两个 template 使用了不同的序列化方式，最终还是序列化带来的问题。
    当初真是草率了，而且一时还没测出来……
    对于生产环境，还是要慎之又慎：如临深渊，如履薄冰。
                
    
                本文名称：Redis 分布式锁遇到的序列化问题
                
    
                分享路径：http://www.shufengxianlan.com/qtweb/news29/44229.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联
            
    
        
        
    
            
    猜你还喜欢下面的内容
    
            
        
    
    
    
    
        
    
            
    外贸网站建设知识
    
            
        
    
        
    
            
    同城分类信息
    
            
        
    
    
    


    
    
    
        户外广告设计　　 　眉山网站建设　　 　高县网站建设　　 　成都网站设计　　 　重庆水土机房托管　　 　短视频拍摄　　 　南充做网站　　 　成都高电机柜租用　　 　seo推广公司　　 　百度推广公司　　 　成都app开发公司　　 　成都IDC机房托管　　 　成都免费网站建设公司　　 　泸州洋跃建站　　 　重庆网站建设　　 　成都网站建设　　 　成都网站设计公司　　 　资阳网站建设　　 　做网站　　 　小程序开发