基于redission的分布式锁

<dependency>
       <groupId>org.redisson</groupId>
       <artifactId>redisson</artifactId>
       <version>3.2.3</version>
</dependency>

public class RedissionUtils {
    private static Logger logger = LoggerFactory.getLogger(RedissionUtils.class);
 
    private static RedissionUtils redisUtils;
 
    private RedissionUtils() {
    }
 
    /**
     * 提供单例模式 还是双重校验
     * 
     * @return
     */
    public static RedissionUtils getInstance() {
        if (redisUtils == null)
            synchronized (RedisUtils.class) {
                if (redisUtils == null)
                    redisUtils = new RedissionUtils();
            }
        return redisUtils;
    }
 
    /**
     * 使用config创建Redisson Redisson是用于连接Redis Server的基础类
     * 
     * @param config
     * @return
     */
    public RedissonClient getRedisson(Config config) {
        RedissonClient redisson = Redisson.create(config);
        logger.info("成功连接Redis Server");
        return redisson;
    }
 
    /**
     * 使用ip地址和端口创建Redisson
     * 
     * @param ip
     * @param port
     * @return
     */
    public RedissonClient getRedisson(String ip, String port) {
        Config config = new Config();
        config.useSingleServer().setAddress(ip + ":" + port);
        RedissonClient redisson = Redisson.create(config);
        logger.info("成功连接Redis Server" + "\t" + "连接" + ip + ":" + port + "服务器");
        return redisson;
    }
 
    /**
     * 关闭Redisson客户端连接
     * 
     * @param redisson
     */
    public void closeRedisson(RedissonClient redisson) {
        redisson.shutdown();
        logger.info("成功关闭Redis Client连接");
    }
 
    /**
     * 获取字符串对象
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public <T> RBucket<T> getRBucket(RedissonClient redisson, String objectName) {
        RBucket<T> bucket = redisson.getBucket(objectName);
        return bucket;
    }
 
    /**
     * 获取Map对象
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public <K, V> RMap<K, V> getRMap(RedissonClient redisson, String objectName) {
        RMap<K, V> map = redisson.getMap(objectName);
        return map;
    }
 
    /**
     * 获取有序集合
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public <V> RSortedSet<V> getRSortedSet(RedissonClient redisson,
            String objectName) {
        RSortedSet<V> sortedSet = redisson.getSortedSet(objectName);
        return sortedSet;
    }
 
    /**
     * 获取集合
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public <V> RSet<V> getRSet(RedissonClient redisson, String objectName) {
        RSet<V> rSet = redisson.getSet(objectName);
        return rSet;
    }
 
    /**
     * 获取列表
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public <V> RList<V> getRList(RedissonClient redisson, String objectName) {
        RList<V> rList = redisson.getList(objectName);
        return rList;
    }
 
    /**
     * 获取队列
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public <V> RQueue<V> getRQueue(RedissonClient redisson, String objectName) {
        RQueue<V> rQueue = redisson.getQueue(objectName);
        return rQueue;
    }
 
    /**
     * 获取双端队列
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public <V> RDeque<V> getRDeque(RedissonClient redisson, String objectName) {
        RDeque<V> rDeque = redisson.getDeque(objectName);
        return rDeque;
    }
 
    /**
     * 此方法不可用在Redisson 1.2 中 在1.2.2版本中 可用
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    /**
     * public <V> RBlockingQueue<V> getRBlockingQueue(RedissonClient
     * redisson,String objectName){ RBlockingQueue
     * rb=redisson.getBlockingQueue(objectName); return rb; }
     */
 
    /**
     * 获取锁
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public RLock getRLock(RedissonClient redisson, String objectName) {
        RLock rLock = redisson.getLock(objectName);
        return rLock;
    }
 
    /**
     * 获取原子数
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public RAtomicLong getRAtomicLong(RedissonClient redisson, String objectName) {
        RAtomicLong rAtomicLong = redisson.getAtomicLong(objectName);
        return rAtomicLong;
    }
 
    /**
     * 获取记数锁
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public RCountDownLatch getRCountDownLatch(RedissonClient redisson,
            String objectName) {
        RCountDownLatch rCountDownLatch = redisson
                .getCountDownLatch(objectName);
        return rCountDownLatch;
    }
 
    /**
     * 获取消息的Topic
     * 
     * @param redisson
     * @param objectName
     * @return
     */
    public <M> RTopic<M> getRTopic(RedissonClient redisson, String objectName) {
        RTopic<M> rTopic = redisson.getTopic(objectName);
        return rTopic;
    }
 
}

 1 //单机
 2 RedissonClient redisson = Redisson.create();
 3 Config config = new Config();
 4 config.useSingleServer().setAddress("myredisserver:6379");
 5 RedissonClient redisson = Redisson.create(config);
 6  
 7  
 8 //主从
10 Config config = new Config();
11 config.useMasterSlaveServers()
12     .setMasterAddress("127.0.0.1:6379")
13     .addSlaveAddress("127.0.0.1:6389", "127.0.0.1:6332", "127.0.0.1:6419")
14     .addSlaveAddress("127.0.0.1:6399");
15 RedissonClient redisson = Redisson.create(config);
16  
17  
18 //哨兵
19 Config config = new Config();
20 config.useSentinelServers()
21     .setMasterName("mymaster")
22     .addSentinelAddress("127.0.0.1:26389", "127.0.0.1:26379")
23     .addSentinelAddress("127.0.0.1:26319");
24 RedissonClient redisson = Redisson.create(config);
25  
26  
27 //集群
28 Config config = new Config();
29 config.useClusterServers()
30     .setScanInterval(2000) // cluster state scan interval in milliseconds
31     .addNodeAddress("127.0.0.1:7000", "127.0.0.1:7001")
32     .addNodeAddress("127.0.0.1:7002");
33 RedissonClient redisson = Redisson.create(config);