集成 Redisson 实现 Redis 分布式锁

Redisson 是 Redis 官方推荐的 Java 客户端之一，提供了强大的分布式锁功能。通过集成 Redisson，可以在分布式系统中方便地实现分布式锁，确保多节点之间的同步和数据一致性。以下是如何在若依项目中集成 Redisson 实现 Redis 分布式锁的详细步骤。

1. 引入 Redisson 依赖

首先，在 ruoyi-common/pom.xml 文件中添加 Redisson 的 Maven 依赖：

<!-- Redisson 锁功能 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.2</version>
</dependency>

此依赖将自动为项目引入 Redisson，并提供与 Spring Boot 的集成支持。

2. 创建 RedisLock 工具类

为了便于在项目中使用 Redisson 实现分布式锁，我们可以创建一个 RedisLock 工具类，封装常用的锁操作。新建 RedisLock.java 文件，并添加以下内容：

package com.ruoyi.common.core.redis;

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * Redis 锁工具类
 * 
 * 提供了一些常用的分布式锁操作方法，如加锁、尝试加锁和解锁等。
 * 
 * @author ruoyi
 */
@Component
public class RedisLock {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 获取锁实例
     * 
     * @param lockKey 锁实例的唯一标识
     * @return 锁实例
     */
    public RLock getRLock(String lockKey) {
        return redissonClient.getLock(lockKey);
    }

    /**
     * 加锁（阻塞式）
     * 
     * 调用此方法会阻塞当前线程，直到成功获取锁。
     * 
     * @param lockKey 锁实例的唯一标识
     * @return 锁实例
     */
    public RLock lock(String lockKey) {
        RLock lock = getRLock(lockKey);
        lock.lock();
        return lock;
    }

    /**
     * 尝试加锁
     * 
     * 此方法会尝试在指定时间内获取锁，如果超时则返回失败。
     * 
     * @param lockKey 锁实例的唯一标识
     * @param leaseTime 自动释放锁的时间
     * @return 是否成功加锁
     */
    public Boolean tryLock(String lockKey, long leaseTime) {
        return tryLock(lockKey, 0, leaseTime, TimeUnit.SECONDS);
    }

    /**
     * 尝试加锁
     * 
     * @param lockKey 锁实例的唯一标识
     * @param leaseTime 自动释放锁的时间
     * @param unit 时间单位
     * @return 是否成功加锁
     */
    public Boolean tryLock(String lockKey, long leaseTime, TimeUnit unit) {
        return tryLock(lockKey, 0, leaseTime, unit);
    }

    /**
     * 尝试加锁
     * 
     * @param lockKey 锁实例的唯一标识
     * @param waitTime 获取锁的最大等待时间
     * @param leaseTime 自动释放锁的时间
     * @param unit 时间单位
     * @return 是否成功加锁
     */
    public Boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) {
        RLock lock = getRLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            return false;
        }
    }

    /**
     * 解锁
     * 
     * @param lockKey 锁实例的唯一标识
     */
    public void unlock(String lockKey) {
        RLock lock = getRLock(lockKey);
        lock.unlock();
    }

    /**
     * 解锁
     * 
     * @param lock 锁实例
     */
    public void unlock(RLock lock) {
        lock.unlock();
    }
}

3. 配置 RedissonConfig 类

为了使 Redisson 正确工作，我们需要配置 Redisson 客户端的初始化。新建 RedissonConfig.java 文件，并添加以下内容：

package com.ruoyi.framework.config;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Redisson 配置类
 * 
 * 初始化 RedissonClient，并根据应用配置 Redis 连接信息。
 * 
 * @author ruoyi
 */
@Configuration
public class RedissonConfig {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private String port;

    @Value("${spring.redis.password}")
    private String password;

    @Bean(destroyMethod = "shutdown")
    @ConditionalOnMissingBean(RedissonClient.class)
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://" + host + ":" + port);
        return Redisson.create(config);
    }
}

在这个配置类中，RedissonClient 将根据 application.yml 或 application.properties 中的 Redis 配置信息进行初始化。

4. 使用方式

在需要使用分布式锁的地方，可以通过注入 RedisLock 工具类来进行锁操作：

@Autowired
private RedisLock redisLock;

// 锁定资源
redisLock.lock("myLockKey");

// 尝试锁定资源，设置自动解锁时间
redisLock.tryLock("myLockKey", 10, TimeUnit.SECONDS);

// 解锁
redisLock.unlock("myLockKey");

5. 注意事项

• 分布式锁的适用场景：分布式锁主要适用于多节点并发操作时需要确保数据一致性的场景，如分布式事务、库存扣减等操作。
• 锁超时设置：建议在业务逻辑中合理设置锁的超时时间，以防止死锁的发生。
• 锁的粒度：确保锁的粒度适当，避免因为锁范围过大而导致系统性能下降。