用Redis实现分布式锁以及redission使用

https://my.oschina.net/wangnian/blog/668830

前言：分布式环境有很多问题，比如你前一个请求访问的是服务器A，第二个请求访问到了服务器B，就会发生并发重复插入问题，这个时候需要依赖单点来实现分布锁，而redis就是。

先导入maven依赖  redission

    org.redisson
    redisson
    2.2.13

创建redission工具类

package redis;
import org.redisson.Config;
import org.redisson.Redisson;
import org.redisson.RedissonClient;
import org.redisson.core.RAtomicLong;
import org.redisson.core.RBucket;
import org.redisson.core.RCountDownLatch;
import org.redisson.core.RDeque;
import org.redisson.core.RList;
import org.redisson.core.RLock;
import org.redisson.core.RMap;
import org.redisson.core.RQueue;
import org.redisson.core.RSet;
import org.redisson.core.RSortedSet;
import org.redisson.core.RTopic;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/***
 * Redis client的辅助工具类
 * 用于连接Redis服务器 创建不同的Redis Server对应的客户端对象
 * @author wangnian
 * 博客地址：http://my.oschina.net/wangnian
 */
public class RedisUtils {

   private static   Logger logger= LoggerFactory.getLogger(RedisUtils.class);
   
   private static RedisUtils redisUtils;
   
   private RedisUtils(){}
   
   /**
    * 提供单例模式
    * @return
    */
   public static RedisUtils getInstance(){
      if(redisUtils==null) 
         synchronized (RedisUtils.class) {
            if(redisUtils==null) redisUtils=new RedisUtils();
         }
      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  RBucket getRBucket(RedissonClient redisson,String objectName){
      RBucket bucket=redisson.getBucket(objectName);
      return bucket;
   }
   
   /**
    * 获取Map对象
    * @param redisson
    * @param objectName
    * @return
    */
   public  RMap getRMap(RedissonClient redisson,String objectName){
      RMap map=redisson.getMap(objectName);
      return map;
   }
   
   /**
    * 获取有序集合
    * @param redisson
    * @param objectName
    * @return
    */
   public  RSortedSet getRSortedSet(RedissonClient redisson,String objectName){
      RSortedSet sortedSet=redisson.getSortedSet(objectName);
      return sortedSet;
   }
   
   /**
    * 获取集合
    * @param redisson
    * @param objectName
    * @return
    */
   public  RSet getRSet(RedissonClient redisson,String objectName){
      RSet rSet=redisson.getSet(objectName);
      return rSet;
   }
   
   /**
    * 获取列表
    * @param redisson
    * @param objectName
    * @return
    */
   public  RList getRList(RedissonClient redisson,String objectName){
      RList rList=redisson.getList(objectName);
      return rList;
   }
   
   /**
    * 获取队列
    * @param redisson
    * @param objectName
    * @return
    */
   public  RQueue getRQueue(RedissonClient redisson,String objectName){
      RQueue rQueue=redisson.getQueue(objectName);
      return rQueue;
   }
   
   /**
    * 获取双端队列
    * @param redisson
    * @param objectName
    * @return
    */
   public  RDeque getRDeque(RedissonClient redisson,String objectName){
      RDeque rDeque=redisson.getDeque(objectName);
      return rDeque;
   }
   
   /**
    * 此方法不可用在Redisson 1.2 中 
    * 在1.2.2版本中 可用
    * @param redisson
    * @param objectName
    * @return
    */
   /**
   public  RBlockingQueue 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  RTopic getRTopic(RedissonClient redisson,String objectName){
       RTopic rTopic=redisson.getTopic(objectName);
       return rTopic;
   }
   
   
}

例子

package redis;

import org.junit.Test;
import org.redisson.Config;
import org.redisson.RedissonClient;
import org.redisson.SingleServerConfig;
import org.redisson.core.RBucket;
import org.redisson.core.RLock;

import java.util.concurrent.TimeUnit;

/**
 * Created by wangnian on 2016/5/2.
 *博客地址：http://my.oschina.net/wangnian
 */
public class RedissonTest {

    @Test
    public void test() throws InterruptedException {
        //redisson配置
        Config config = new Config();
        SingleServerConfig singleSerververConfig = config.useSingleServer();
        singleSerververConfig.setAddress("127.0.0.1:6379");
        singleSerververConfig.setPassword("redis");
        //redisson客户端
        RedissonClient redissonClient = RedisUtils.getInstance().getRedisson(config);
        RBucket