SpringBoot | Redis序列化与分布式锁

欢迎参观我的博客，一个Vue 与 SpringBoot结合的产物：https://poetize.cn

• 博客：https://gitee.com/littledokey/poetize-vue2.git
• 聊天室：https://gitee.com/littledokey/poetize-im-vue3.git
• 后端：https://gitee.com/littledokey/poetize.git
• 七牛云登录/注册地址（文件服务器，CDN）：https://s.qiniu.com/Mz6Z32

原文链接：https://poetize.cn/article?id=40

RedisTemplate自定义序列化方式

@Configuration
@EnableCaching
@EnableConfigurationProperties(RedisProperties.class)
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        //ObjectMapper 将序列化对象的所有属性，不管它们的可见性如何。这对于确保所有属性都被包括在JSON中非常有用，尤其是当你需要在序列化时包括私有属性或其他非公共属性时。
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //ObjectMapper 将在序列化时包括类型信息，以便在反序列化时能够正确地还原对象的具体类型。
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(mapper);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);

        template.afterPropertiesSet();
        return template;
    }
}

Redisson分布式锁

可重入锁

@Slf4j
@Component
public class RedisLock {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 加锁
     *
     * @param lockName 锁
     * @return Boolean
     */
    public Boolean lock(String lockName) {
        try {
            RLock lock = redissonClient.getLock(lockName);
            lock.lock();
            log.info("Thread [{}] DistributedRedisLock lock [{}] success", Thread.currentThread().getName(), lockName);
            return true;
        } catch (Exception e) {
            log.error("DistributedRedisLock lock [{}] Exception: {}", lockName, e.getMessage());
            return false;
        }
    }


    /**
     * 加锁
     *
     * @param lockName 锁
     * @return Boolean
     */
    public Boolean lock(long leaseTime, TimeUnit timeUnit, String lockName) {
        try {
            RLock lock = redissonClient.getLock(lockName);
            //leaseTime 秒钟自动解锁，自动解锁时间一定要大于业务执行时间
            lock.lock(leaseTime, timeUnit);
            log.info("Thread [{}] DistributedRedisLock lock [{}] success", Thread.currentThread().getName(), lockName);
            return true;
        } catch (Exception e) {
            log.error("DistributedRedisLock lock [{}] Exception: {}", lockName, e.getMessage());
            return false;
        }
    }

    /**
     * 加锁
     *
     * @param lockName 锁
     * @return Boolean
     */
    public Boolean tryLock(String lockName) {
        try {
            RLock lock = redissonClient.getLock(lockName);
            boolean b = lock.tryLock();
            log.info("Thread [{}] DistributedRedisLock lock [{}] {}", Thread.currentThread().getName(), lockName, b);
            return b;
        } catch (Exception e) {
            log.error("DistributedRedisLock lock [{}] Exception: {}", lockName, e.getMessage());
            return false;
        }
    }

    /**
     * 加锁
     *
     * @param lockName 锁
     * @return Boolean
     */
    public Boolean tryLock(long waitTime, long leaseTime, TimeUnit timeUnit, String lockName) {
        try {
            RLock lock = redissonClient.getLock(lockName);
            //尝试加锁，最多等待 waitTime 秒，上锁以后 leaseTime 秒自动解锁
            boolean b = lock.tryLock(waitTime, leaseTime, timeUnit);
            log.info("Thread [{}] DistributedRedisLock tryLock [{}] {}", Thread.currentThread().getName(), lockName, b);
            return b;
        } catch (Exception e) {
            log.error("DistributedRedisLock tryLock [{}] Exception: {}", lockName, e.getMessage());
            return false;
        }
    }

    /**
     * 释放锁
     *
     * @param lockName 锁
     * @return Boolean
     */
    public Boolean unlock(String lockName) {
        try {
            RLock lock = redissonClient.getLock(lockName);
            if (lock.isLocked()) {
                if (lock.isHeldByCurrentThread()) {
                    lock.unlock();
                    log.info("Thread [{}] DistributedRedisLock unlock [{}] success", Thread.currentThread().getName(), lockName);
                }
            }
            return true;
        } catch (Exception e) {
            log.error("DistributedRedisLock unlock [{}] Exception: {}", lockName, e.getMessage());
            return false;
        }
    }

    /**
     * 判断key是否被锁定
     *
     * @param lockName 锁
     * @return Boolean
     */
    public Boolean isLock(String lockName) {
        try {
            RLock lock = redissonClient.getLock(lockName);
            boolean b = lock.isLocked();
            log.info("Thread [{}] DistributedRedisLock isLock [{}] {}", Thread.currentThread().getName(), lockName, b);
            return b;
        } catch (Exception e) {
            log.error("DistributedRedisLock isLock [{}] Exception: ", lockName, e);
            return false;
        }
    }
}

联锁

RLock lock1 = redissonInstance1.getLock("lock1");
RLock lock2 = redissonInstance2.getLock("lock2");
RLock lock3 = redissonInstance3.getLock("lock3");

RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
//同时加锁：lock1 lock2 lock3
//所有的锁都上锁成功才算成功。
lock.lock();
...
lock.unlock();

红锁

RLock lock1 = redissonInstance1.getLock("lock1");
RLock lock2 = redissonInstance2.getLock("lock2");
RLock lock3 = redissonInstance3.getLock("lock3");

RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
//同时加锁：lock1 lock2 lock3
//红锁在大部分节点上加锁成功就算成功。
lock.lock();
...
lock.unlock();

看门狗

Redisson提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期，也就是说，如果一个拿到锁的线程一直没有完成逻辑，那么看门狗会帮助线程不断的延长锁超时时间，锁不会因为超时而被释放。

默认情况下，看门狗的续期时间是30s，也可以通过修改Config.lockWatchdogTimeout来另行指定。另外Redisson 还提供了可以指定leaseTime参数的加锁方法来指定加锁的时间。超过这个时间后锁便自动解开了，不会延长锁的有效期。