redissonclient类_Redisson的使用

电玩女神 2023-09-28 21:01 36阅读 0赞

Redisson的使用

简介

在现在的项目中，经常会有并发问题，解决并发问题的一个思路就是使用分布式锁。在以前的项目中，经常会使用Redis的setnx特性来实现分布式锁，但是有可能会带来死锁的问题，那么就可以使用Redisson来实现Redis的分布式锁。这里我使用的场景是短信验证码服务，同一时刻只能有一个线程给同一个手机号发送短信。

原生的使用方式

在不使用redisson时，我们一般这样去使用Redis实现分布式锁。@Component

public class RedissonLockImpl implements RedissonLock \{

private static ThreadLocal threadLocal = new ThreadLocal<>();

@Autowired

private StringRedisTemplate redisTemplate;

@Override

public boolean tryLock(String key, long timeout, TimeUnit timeUnit) \{

if (threadLocal.get() == null)\{

String lockName = "redis:test:name";

threadLocal.set(lockName);

return redisTemplate.opsForValue().setIfAbsent(key, lockName, timeout, timeUnit);

\}else if (threadLocal.get().equals(redisTemplate.opsForValue().get(key)))\{

return true;

return false;

然后在代码中这样使用：@RestController

public class RedissonController \{

@Autowired

private StringRedisTemplate redisTemplate;

@Autowired

private RedissonLock redissonLock;

@RequestMapping("/submitOrder")

public String submitOrder()\{

String key = "test";

// 这里可能存在在你设置的时间内当前线程还没有结束

boolean lock = redissonLock.tryLock(key, 4, TimeUnit.SECONDS);

if (!lock)\{

return "error";

try \{

// 具体的业务逻辑

int stock = Integer.parseInt(redisTemplate.opsForValue().get("stock"));

if (stock>0)\{

// 下单

stock = stock - 1;

redisTemplate.opsForValue().set("stock", stock+"");

return "success";

\} else \{

System.out.println("库存不足");

return "false";

\} finally \{

// 这里可以释放锁

这样可能就会导致在你设置的锁的时间结束后，该线程还没有执行结束，但是锁已经释放，就会导致后面获取锁，释放锁的顺序变乱，导致业务出问题。

原生改进

对于这种某个线程超时的问题，可以给这个线程new一个守护线程，守护线程每10s去刷新这个时间完成续命。主线程运行结束，守护线程就会自己死亡，不需要我们操作。(但是一般线程都是线程池，线程不会死亡，守护线程也就不能自动死亡，所以有风险)。

当然你可以手动实现一个线程专门维护这个续命的时间，但是实现起来就会很麻烦。所以我们推荐直接使用redisson。redisson本身已经实现了这里的续命。

Redisson的具体使用

Redisson中的Rlock等已经实现了续命，保证我们的业务执行结束。

引入依赖

org.redisson

redisson

3.11.4

编写配置类@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

public RedissonClient redissonClient()\{

Config config = new Config();

config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);

//添加主从配置

// config.useMasterSlaveServers().setMasterAddress("").setPassword("").addSlaveAddress(new String\[\]\{"",""\});

return Redisson.create(config);

在代码中使用

这样我们可以自动注入RedissonClient进行使用。但是一般我们可以在上面再包装一层service，来包装我们一般的异常等场景。/\*\*

\* redisson操作类

\* @author 朱友德

\*/

@Service("redissonService")

public class RedissonService \{

@Autowired

private RedissonClient redissonClient;

public void getRedissonClient() throws IOException \{

Config config = redissonClient.getConfig();

System.out.println(config.toJSON().toString());

/\*\*\`

\* 获取字符串对象

\* @param objectName

\* @return

\*/

public RBucket getRBucket(String objectName) \{

RBucket bucket = redissonClient.getBucket(objectName);

return bucket;

/\*\*

\* 获取Map对象

\* @param objectName

\* @return

\*/

public RMap getRMap(String objectName) \{

RMap map = redissonClient.getMap(objectName);

return map;

/\*\*

\* 获取有序集合

\* @param objectName

\* @return

\*/

public RSortedSet getRSortedSet(String objectName) \{

RSortedSet sortedSet = redissonClient.getSortedSet(objectName);

return sortedSet;

/\*\*

\* 获取集合

\* @param objectName

\* @return

\*/

public RSet getRSet(String objectName) \{

RSet rSet = redissonClient.getSet(objectName);

return rSet;

/\*\*

\* 获取列表

\* @param objectName

\* @return

\*/

public RList getRList(String objectName) \{

RList rList = redissonClient.getList(objectName);

return rList;

/\*\*

\* 获取队列

\* @param objectName

\* @return

\*/

public RQueue getRQueue(String objectName) \{

RQueue rQueue = redissonClient.getQueue(objectName);

return rQueue;

/\*\*

\* 获取双端队列

\* @param objectName

\* @return

\*/

public RDeque getRDeque(String objectName) \{

RDeque rDeque = redissonClient.getDeque(objectName);

return rDeque;

/\*\*

\* 获取锁

\* @param objectName

\* @return

\*/

public RLock getRLock(String objectName) \{

RLock rLock = redissonClient.getLock(objectName);

return rLock;

public Boolean tryLock(String key, long leaseTime, TimeUnit unit) \{

RLock rLock = redissonClient.getLock(key);

boolean tryLock = false;

try \{

tryLock = rLock.tryLock(0, leaseTime, unit);

\} catch (InterruptedException e) \{

return false;

return tryLock;

public Boolean verifyTryLock(RLock rLock, long leaseTime, TimeUnit unit) \{

boolean tryLock = false;

try \{

tryLock = rLock.tryLock(0, leaseTime, unit);

\} catch (InterruptedException e) \{

return false;

return tryLock;

/\*\*

\* 获取读取锁

\* @param objectName

\* @return

\*/

public RReadWriteLock getRWLock(String objectName) \{

RReadWriteLock rwlock = redissonClient.getReadWriteLock(objectName);

return rwlock;

/\*\*

\* 获取原子数

\* @param objectName

\* @return

\*/

public RAtomicLong getRAtomicLong(String objectName) \{

RAtomicLong rAtomicLong = redissonClient.getAtomicLong(objectName);

return rAtomicLong;

/\*\*

\* 获取记数锁

\* @param objectName

\* @return

\*/

public RCountDownLatch getRCountDownLatch(String objectName) \{

RCountDownLatch rCountDownLatch = redissonClient.getCountDownLatch(objectName);

return rCountDownLatch;

具体业务场景使用@Service

public class MyService \{

@Autowired

private RedissonService redissonService;

@Autowired

private StringRedisTemplate redisTemplate;

public String sendCodeByTemplate(final String phone)\{

// 过期时间

String ttlKey = "redis:ttl:phone:"+phone;

String key = "redis:phone:"+phone;

// 对这个手机号发送消息时会对发送手机号加锁

if (!redissonService.tryLock(key, 10, TimeUnit.SECONDS))\{

//获取过期时间

Long ttl = redisTemplate.getExpire(ttlKey);

//发送验证码频繁

return "发送频繁";

// 发送验证码

sendCode(phone);

return "true";

private boolean sendCode(String phone)\{

// 写具体发送逻辑

return true;

————————————————  
版权声明：本文为CSDN博主「灯灯藕粉」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/weixin\_36027833/article/details/113681484