springboot整合redisson分布式锁（redis集群模式）_springboot redissonclient redis集群-CSDN博客

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qsssyyw/article/details/81562868
1.maven引入redisson

<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.5.0</version>
</dependency>
2.redisson配置类，得到redisson对象，之后的分布式锁由redisson对象操作

2.1 在springboot的配置文件application.yml中添加redis集群的ip和端口还有密码

spring:
   redis:
       password: 123456
       clusters: 10.10.1.1:7000,10.10.1.1:7001,10.10.1.1:7002,10.10.1.1:7003,10.10.1.1:7004,10.10.1.1:7005
2.2 创建 redisson配置类RedissonManager

import java.io.IOException;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
* redisson配置
*/
@Configuration
public class RedissonManager {
@Value("${spring.redis.clusters}")
private String cluster;
@Value("${spring.redis.password}")
private String password;

@Bean
public RedissonClient getRedisson(){
   String[] nodes = cluster.split(",");
//redisson版本是3.5，集群的ip前面要加上“redis://”，不然会报错，3.2版本可不加
   for(int i=0;i<nodes.length;i++){
   nodes[i] = "redis://"+nodes[i];
   }
   RedissonClient redisson = null;
Config config = new Config();
config.useClusterServers() //这是用的集群server
.setScanInterval(2000) //设置集群状态扫描时间
.addNodeAddress(nodes)
.setPassword(password);
redisson = Redisson.create(config);

//可通过打印redisson.getConfig().toJSON().toString()来检测是否配置成功
return redisson;
}

}
3.创建分布式锁的接口DistributedLocker

import java.util.concurrent.TimeUnit;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;

public interface DistributedLocker {

RLock lock(String lockKey);

RLock lock(String lockKey, long timeout);

RLock lock(String lockKey, TimeUnit unit, long timeout);

boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime);

void unlock(String lockKey);

void unlock(RLock lock);

}
4.创建接口DistributedLocker的实现类

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Component
public class RedissonDistributedLocker implements DistributedLocker {
   @Autowired
private RedissonClient redissonClient; //RedissonClient已经由配置类生成，这里自动装配即可

//lock(), 拿不到lock就不罢休，不然线程就一直block
@Override
public RLock lock(String lockKey) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock();
return lock;
}

//leaseTime为加锁时间，单位为秒
@Override
public RLock lock(String lockKey, long leaseTime) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock(leaseTime, TimeUnit.SECONDS);
return lock;
}

//timeout为加锁时间，时间单位由unit确定
@Override
public RLock lock(String lockKey, TimeUnit unit ,long timeout) {
RLock lock = redissonClient.getLock(lockKey);
lock.lock(timeout, unit);
return lock;
}
//tryLock()，马上返回，拿到lock就返回true，不然返回false。
//带时间限制的tryLock()，拿不到lock，就等一段时间，超时返回false.
@Override
public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime) {
RLock lock = redissonClient.getLock(lockKey);
try {
return lock.tryLock(waitTime, leaseTime, unit);
} catch (InterruptedException e) {
return false;
}
}

@Override
public void unlock(String lockKey) {
RLock lock = redissonClient.getLock(lockKey);
lock.unlock();
}

@Override
public void unlock(RLock lock) {
lock.unlock();
}
}
5.使用分布式锁

@RestController
@RequestMapping("/redisson")
public class AdvMaterialController {
   @Autowired
   private DistributedLocker distributedLocker;

   @RequestMapping("/test")
   public void redissonTest() {
       String key = "redisson_key";
       for (int i = 0; i < 100; i++) {
       Thread t = new Thread(new Runnable() {
           @Override
           public void run() {
               try {
                   System.err.println("=============线程开启============"+Thread.currentThread().getName());
                   /*distributedLocker.lock(key,10L); //直接加锁，获取不到锁则一直等待获取锁
                   Thread.sleep(100); //获得锁之后可以进行相应的处理
                   System.err.println("======获得锁后进行相应的操作======"+Thread.currentThread().getName());
                   distributedLocker.unlock(key); //解锁
                   System.err.println("============================="+Thread.currentThread().getName());*/
                   boolean isGetLock = distributedLocker.tryLock(key,TimeUnit.SECONDS,5L,10L); //尝试获取锁，等待5秒，自己获得锁后一直不解锁则10秒后自动解锁
                   if(isGetLock){
                       Thread.sleep(100); //获得锁之后可以进行相应的处理
                       System.err.println("======获得锁后进行相应的操作======"+Thread.currentThread().getName());
                       //distributedLocker.unlock(key);
                       System.err.println("============================="+Thread.currentThread().getName());
                   }
               } catch (Exception e) {
                   e.printStackTrace();
               }
           }
       });
       t.start();
   }
   }