maven引入Redisson使用

如果你希望在 Maven 项目中使用 Redisson，你需要向你的 pom.xml 文件添加以下依赖项：

<dependency>
  <groupId>org.redisson</groupId>
  <artifactId>redisson</artifactId>
  <version>${redisson.version}</version>
</dependency>

其中 ${redisson.version} 是 Redisson 版本号，可以根据你的需求进行替换。
然后引入 Redisson 的相关类并进行配置，我写了一个下面的工具类：

package src.main.biz.ucenter.redis;

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public class RedissonUtils {

    private RedissonClient redissonClient;

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

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

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

    /**
     * 获取RedissonClient单例实例
     *
     * @return RedissonClient
     */
    public RedissonClient getRedissonClient() {
        if (redissonClient == null) {
            Config config = new Config();
            config.useSingleServer()
                    .setAddress("redis://" + redisHost + ":" + redisPort)
                    .setPassword(redisPassword)
                    .setDatabase(0);
            redissonClient = Redisson.create(config);
        }
        return redissonClient;
    }

    /**
     * 根据key获取分布式锁
     *
     * @param key 锁的key
     * @return RLock分布式锁对象
     */
    public RLock getLock(String key) {
        return getRedissonClient().getLock(key);
    }

    /**
     * 尝试获取分布式锁，等待指定时间
     *
     * @param lock    分布式锁对象
     * @param timeout 超时时间（单位：秒）
     * @return 是否成功获取锁
     * @throws InterruptedException 中断异常
     */
    public boolean tryLock(RLock lock, long timeout) throws InterruptedException {
        return lock.tryLock(timeout, TimeUnit.SECONDS);
    }

    /**
     * 释放分布式锁
     *
     * @param lock 分布式锁对象
     */
    public void unlock(RLock lock) {
        lock.unlock();
    }

}

在上面的代码中，RedissonUtils 类对 Redisson 的使用进行了优化和简化。取消了 getLock 方法中的超时时间参数，默认使用 Redisson 的默认超时时间；将尝试获取锁的方法单独提取出来作为一个公共方法，以便于自定义等待时间；取消了 getRedissonClient 方法中的单例实现，并改为直接返回 RedissonClient 实例。

同时，在 tryLock 方法中，我们抛出了 InterruptedException 异常，因此在调用 tryLock 方法时需要进行异常处理，通常是将异常向上层方法传递或者捕获并处理异常。在释放锁时，我们使用 lock.unlock() 来释放锁。

下面的是demo

import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import src.main.biz.ucenter.redis.RedissonUtils;

@Service
public class MyService {

    @Autowired
    private RedissonUtils redissonUtils;

    public void myMethod() {
        String lockKey = "myLock";
        RLock lock = redissonUtils.getLock(lockKey);
        try {
            boolean locked = redissonUtils.tryLock(lock, 60);
            if (locked) {
                // 获取到锁，执行业务逻辑
                // ...
            } else {
                // 获取锁失败，处理异常情况
                // ...
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            // 处理中断异常
            // ...
        } finally {
            redissonUtils.unlock(lock);
        }
    }

}

在上面的代码中，MyService 类中的 myMethod 方法使用了 Redisson 获取分布式锁。我们首先定义一个锁的 key 值，然后通过 redissonUtils.getLock(lockKey) 来获取对应的分布式锁对象。接着，我们调用 redissonUtils.tryLock(lock, 60) 来尝试获取锁，并指定超时时间为 60 秒。如果成功获得锁，则可以执行业务逻辑，否则需要处理获取锁失败的异常情况。在最后，我们使用 redissonUtils.unlock(lock) 来释放锁。

需要注意的是，在 tryLock 方法中，我们抛出了 InterruptedException 异常，因此在调用 tryLock 方法时需要进行异常处理，通常是将异常向上层方法传递或者捕获并处理异常。

在 Redisson 中，getLock() 方法获取锁时默认的等待时间是 30 秒（30,000 毫秒），可以通过 org.redisson.api.RLock#lock(long waitTime, long leaseTime, TimeUnit unit) 方法的第一个参数来指定等待时间。例如，lock.lock(10, TimeUnit.SECONDS) 将会在获取锁之前等待最多 10 秒钟，如果在这个时间内无法获取到锁，则会抛出 org.redisson.api.RLockTimeoutException 异常。