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

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

前言：分布式环境有很多问题，比如你前一个请求访问的是服务器A，第二个请求访问到了服务器B，就会发生并发重复插入问题，这个时候需要依赖单点来实现分布锁，而redis就是。先导入maven依赖  redission<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>2.2.13</version>
</dependency>创建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 <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;
}

}
例子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<Object> rBucket = RedisUtils.getInstance().getRBucket(redissonClient, "key");
//rBucket.set("wangnian");
System.out.println(rBucket.get());

while (true) {
RLock lock = redissonClient.getLock("lock");
lock.tryLock(0, 1, TimeUnit.SECONDS);//第一个参数代表等待时间，第二是代表超过时间释放锁，第三个代表设置的时间制
try {
System.out.println("执行");
} finally {
lock.unlock();
}
}
}

}
如果生产上，我建议用 注解aop的方式 写个 lock的注解  比如  @lock("name")