redis netty依赖冲突 redisson netty

Redisson是一个基于java编程框架netty进行扩展了的redis,实现了分布式锁和批量的一些操作。

 

哨兵模式初始化

1 public class RedissonConfig {
 2 
 3     private  Redisson redisson;
 4 
 5     private  Config config = new Config();
 6 
 7     @Value("${spring.redis.sentinel.master}")
 8     private  String masterName;
 9 
10     @Value("${spring.redis.cluster.nodes}")
11     private  String[] address;
12 
13     /**
14      * 初始化Redisson 哨兵模式
15      */
16     @Bean
17     public Redisson getRedisson(){
18        try {
19             config.useSentinelServers()
20                     .setMasterName(masterName)
21                     .addSentinelAddress(address)
22                     //同任何节点建立连接时的等待超时。时间单位是毫秒。默认：10000
23                     .setConnectTimeout(30000)
24                    //当与某个节点的连接断开时，等待与其重新建立连接的时间间隔。时间单位是毫秒。默认:3000
25                     .setReconnectionTimeout(10000)
26                     //等待节点回复命令的时间。该时间从命令发送成功时开始计时。默认:3000
27                     .setTimeout(10000)
28                     //如果尝试达到 retryAttempts（命令失败重试次数） 仍然不能将命令发送至某个指定的节点时，将抛出错误。如果尝试在此限制之内发送成功，则开始启用 timeout（命令等待超时） 计时。默认值：3
29                     .setRetryAttempts(5)
30                     //在一条命令发送失败以后，等待重试发送的时间间隔。时间单位是毫秒。     默认值：1500
31                     .setRetryInterval(3000)
32             ;
33             redisson = (Redisson) Redisson.create(config);
34         }catch (Exception e){
35             e.printStackTrace();
36         }
37         return redisson;
38     }

集群模式初始化

private  Redisson redisson;

    private  Config config = new Config();

    @Value("${spring.redis.cluster.nodes}")
    private  String[] address;

    /**
     * 初始化Redisson 集群模式
     */
    @Bean
    public Redisson getRedisson(){
        try {
            config.useClusterServers()
                    .setScanInterval(2000)//设置集群状态扫描时间
                    .setMasterConnectionPoolSize(10000)//设置连接数
                    .setSlaveConnectionPoolSize(10000)
                    .addNodeAddress(address)
                    //同任何节点建立连接时的等待超时。时间单位是毫秒。默认：10000
                    .setConnectTimeout(30000)
                    //当与某个节点的连接断开时，等待与其重新建立连接的时间间隔。时间单位是毫秒。默认:3000
                    .setReconnectionTimeout(10000)
                    //等待节点回复命令的时间。该时间从命令发送成功时开始计时。默认:3000
                    .setTimeout(10000)
                    //如果尝试达到 retryAttempts（命令失败重试次数） 仍然不能将命令发送至某个指定的节点时，将抛出错误。如果尝试在此限制之内发送成功，则开始启用 timeout（命令等待超时） 计时。默认值：3
                    .setRetryAttempts(5)
                    //在一条命令发送失败以后，等待重试发送的时间间隔。时间单位是毫秒。     默认值：1500
                    .setRetryInterval(3000)
            ;
            redisson = (Redisson) Redisson.create(config);
        }catch (Exception e){
            e.printStackTrace();
        }
        return redisson;
    }

获取分布式锁工具类

@Component
public class LockUtil {

    @Autowired
    private  Redisson redisson;

    /**强制解锁时间设置*/
    private long LOCK_TIME = 2L;

    /**等待时间**/
    private long WAIT_TIME = 3L;

    /**休眠时间**/
    private long SLEEP_TIME = 100;


    /**
     *  根据key值获取锁
     * @param lockName
     */
    public void lock(String lockName){
        RLock lock = redisson.getLock(lockName);
        //lock提供带timeout参数，timeout结束强制解锁，防止死锁
        lock.lock(LOCK_TIME, TimeUnit.SECONDS);
    }

    /**
     * 获取锁
     * @param lockName
     * @return
     * @throws InterruptedException
     */
    public boolean tryLock(String lockName) throws InterruptedException {
        RLock lock = redisson.getLock(lockName);
        //tryLock，第一个参数是等待时间。 第二个参数 强制锁释放时间
        return lock.tryLock(WAIT_TIME,LOCK_TIME,TimeUnit.SECONDS);
    }

    /**
     * 解锁
     * @param lockName
     */
    public void unLock(String lockName){
        RLock lock = redisson.getLock(lockName);
        lock.unlock();
    }

    /**
     * 获取锁，一直等待到取到锁后返回
     * @param lockName
     * @throws InterruptedException
     */
    public boolean getUntilHaveLock(String lockName) throws InterruptedException {
        while (true){
            if(tryLock(lockName)){
                return true;
            }else{
                Thread.sleep(SLEEP_TIME);
            }
        }
    }