如果你希望在 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 异常。
