Redis学习笔记(二) Redis实用工具类
import org.slf4j.Logger;import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.ShardedJedis;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class RedisUtil {
private static Logger logger = LoggerFactory.getLogger(RedisUtil.class);
/**
* 设置超时锁
* @param lock
* @param expired
* @return
*/
public static boolean acquireLock(String lock,long expired) {
boolean success = false;
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
// 1. 通过SETNX试图获取一个lock
long value = System.currentTimeMillis() + expired + 1;
long acquired = shardedJedis.setnx(lock, String.valueOf(value));
//SETNX成功，则成功获取一个锁
if (acquired == 1)
success = true;
//SETNX失败，说明锁仍然被其他对象保持，检查其是否已经超时
else {
String tempValue = shardedJedis.get(lock);
if (tempValue != null){
long oldValue = Long.valueOf(tempValue);
//超时
if (oldValue < System.currentTimeMillis()) {
String getValue = shardedJedis.getSet(lock, String.valueOf(value));
// 获取锁成功
if (Long.valueOf(getValue) == oldValue)
success = true;
// 已被其他进程捷足先登了
else
success = false;
}
//未超时，则直接返回失败
else
success = false;
}else {
success = false;
}
}
} catch (Exception e) {
//释放redis对象
JedisPoolHolder.cleanup();
e.printStackTrace();
}
return success;
}
/**
* 获取队列数据
*
* @param key 键名
* @return
*/
public static byte[] rpop(byte[] key) {
byte[] bytes = null;
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
bytes = shardedJedis.rpop(key);
} catch (Exception e) {
//释放redis对象
JedisPoolHolder.cleanup();
e.printStackTrace();
}
return bytes;
}
/**
* 存储REDIS队列 顺序存储
*
* @param key reids键名
* @param value 键值
*/
public static void lpush(byte[] key, byte[] value) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
// jedis = jedisPool.getResource();
shardedJedis.lpush(key, value);
} catch (Exception e) {
//释放redis对象
JedisPoolHolder.cleanup();
e.printStackTrace();
}
}
public static Long setnx(byte[] key, Object obj) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
byte[] value = SerializeUtil.serialize(obj);
return shardedJedis.setnx(key, value);
} catch (Exception e) {
//释放redis对象
JedisPoolHolder.cleanup();
e.printStackTrace();
}
return 0L;
}
public static boolean setObject(byte[] key, Object obj) {
boolean result = true;
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
byte[] value = SerializeUtil.serialize(obj);
shardedJedis.set(key, value);
} catch (Exception e) {
//释放redis对象
JedisPoolHolder.cleanup();
e.printStackTrace();
result = false;
}
return result;
}
/**
* 缓存对象时包括过期时间。时间单位：秒。
* @param key
* @param obj
* @param seconds
* @return
*/
public static boolean setObject(byte[] key, Object obj, int seconds) {
boolean result = true;
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
byte[] value = SerializeUtil.serialize(obj);
shardedJedis.setex(key, seconds, value);
} catch (Exception e) {
//释放redis对象
JedisPoolHolder.cleanup();
e.printStackTrace();
result = false;
}
return result;
}
public static Object getObject(byte[] key) {
Object obj = new Object();
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
obj = SerializeUtil.unserialize(shardedJedis.get(key));
return obj;
} catch (Exception e) {
//释放redis对象
JedisPoolHolder.cleanup();
e.printStackTrace();
}
return null;
}
/**
* 设置一个key的过期时间（单位：秒）
*
* @param key key值
* @param seconds 多少秒后过期
* @return 1：设置了过期时间0：没有设置过期时间/不能设置过期时间
*/
public static long expire(String key, int seconds) {
if (key == null || key.equals("")) {
return 0;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
// shardedJedisPool.getResource();
return shardedJedis.expire(key, seconds);
} catch (Exception ex) {
logger.error("EXPIRE error" + ex.getMessage(), ex);
//returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return 0;
}
/**
* 设置一个key在某个时间点过期
*
* @param key key值
* @param unixTimestamp unix时间戳，从1970-01-01 00:00:00开始到现在的秒数
* @return 1：设置了过期时间0：没有设置过期时间/不能设置过期时间
*/
public static long expireAt(String key, int unixTimestamp) {
if (key == null || key.equals("")) {
return 0;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
return shardedJedis.expireAt(key, unixTimestamp);
} catch (Exception ex) {
logger.error("EXPIRE error" + ex.getMessage(), ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return 0;
}
/**
* 截断一个List
*
* @param key 列表key
* @param start 开始位置 从0开始
* @param end 结束位置
* @return 状态码
*/
public static String trimList(String key, long start, long end) {
if (key == null || key.equals("")) {
return "-";
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
return shardedJedis.ltrim(key, start, end);
} catch (Exception ex) {
logger.error("LTRIM 出错" + ex.getMessage(), ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return "-";
}
/**
* 检查Set长度
*
* @param key
* @return
*/
public static long countSet(String key) {
if (key == null) {
return 0;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
return shardedJedis.scard(key);
} catch (Exception ex) {
logger.error("countSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return 0;
}
/**
* 添加到Set中（同时设置过期时间）
*
* @param key key值
* @param seconds 过期时间 单位s
* @param value
* @return
*/
/*public static boolean addSet(String key, int seconds, String... value) {
boolean result = addSet(key, value);
if (result) {
long i = expire(key, seconds);
return i == 1;
}
return false;
}*/
/**
* 添加到Set中
*
* @param key
* @param value
* @return
*/
public static boolean addSet(String key, String... value) {
if (key == null || value == null) {
return false;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
long result = shardedJedis.sadd(key, value);
return true;
} catch (Exception ex) {
ex.printStackTrace();
logger.error("setList error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
/**
* @param key
* @param value
* @return 判断值是否包含在set中
*/
public boolean containsInSet(String key, String value) {
if (key == null || value == null) {
return false;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
return shardedJedis.sismember(key, value);
} catch (Exception ex) {
logger.error("setList error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
/**
* 获取Set
*
* @param key
* @return
*/
public static Set<String> getSet(String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
return shardedJedis.smembers(key);
} catch (Exception ex) {
logger.error("getList error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return null;
}
/**
* 从set中删除value
*
* @param key
* @return
*/
public static boolean removeSetValue(String key, String... value) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
shardedJedis.srem(key, value);
return true;
} catch (Exception ex) {
logger.error("getList error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
/**
* 从list中删除value 默认count 1
*
* @param key
* @param values 值list
* @return
*/
public static int removeListValue(String key, List<String> values) {
return removeListValue(key, 1, values);
}
/**
* 从list中删除value
*
* @param key
* @param count
* @param values 值list
* @return
*/
public static int removeListValue(String key, long count, List<String> values) {
int result = 0;
if (values != null && values.size() > 0) {
for (String value : values) {
if (removeListValue(key, count, value)) {
result++;
}
}
}
return result;
}
/**
* 从list中删除value
*
* @param key
* @param count 要删除个数
* @param value
* @return
*/
public static boolean removeListValue(String key, long count, String value) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
shardedJedis.lrem(key, count, value);
return true;
} catch (Exception ex) {
logger.error("getList error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
/**
* 截取List
*
* @param key
* @param start 起始位置
* @param end 结束位置
* @return
*/
public static List<String> rangeList(String key, long start, long end) {
if (key == null || key.equals("")) {
return null;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
return shardedJedis.lrange(key, start, end);
} catch (Exception ex) {
logger.error("rangeList 出错" + ex.getMessage(), ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return null;
}
/**
* 检查List长度
*
* @param key
* @return
*/
public static long countList(String key) {
if (key == null) {
return 0;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
return shardedJedis.llen(key);
} catch (Exception ex) {
logger.error("countList error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return 0;
}
/**
* 添加到List中（同时设置过期时间）
*
* @param key key值
* @param seconds 过期时间 单位s
* @param value
* @return
*/
public static boolean addList(String key, int seconds, String... value) {
boolean result = addList(key, value);
if (result) {
long i = expire(key, seconds);
return i == 1;
}
return false;
}
/**
* 添加到List
*
* @param key
* @param value
* @return
*/
public static boolean addList(String key, String... value) {
if (key == null || value == null) {
return false;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
shardedJedis.lpush(key, value);
return true;
} catch (Exception ex) {
logger.error("setList error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
/**
* 添加到List(只新增)
*
* @param key
* @param list
* @return
*/
public static boolean addList(String key, List<String> list) {
if (key == null || list == null || list.size() == 0) {
return false;
}
for (String value : list) {
addList(key, value);
}
return true;
}
/**
* 获取List
*
* @param key
* @return
*/
public static List<String> getList(String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
return shardedJedis.lrange(key, 0, -1);
} catch (Exception ex) {
logger.error("getList error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return null;
}
/**
* 设置HashSet对象
*
* @param domain 域名
* @param key 键值
* @param valueJson String or String value
* @return
*/
public static boolean setHSet(String domain, String key, String value) {
if (value == null) return false;
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
shardedJedis.hset(domain, key, value);
return true;
} catch (Exception ex) {
logger.error("setHSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
/**
* 获得HashSet对象
*
* @param domain 域名
* @param key 键值
* @return Json String or String value
*/
public static String getHSet(String domain, String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
return shardedJedis.hget(domain, key);
} catch (Exception ex) {
logger.error("getHSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return null;
}
/**
* 删除HashSet对象
*
* @param domain 域名
* @param key 键值
* @return 删除的记录数
*/
public static long delHSet(String domain, String key) {
ShardedJedis shardedJedis = null;
long count = 0;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
count = shardedJedis.hdel(domain, key);
} catch (Exception ex) {
logger.error("delHSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return count;
}
/**
* 删除HashSet对象
*
* @param domain 域名
* @param key 键值
* @return 删除的记录数
*/
public static long delHSet(String domain, String... key) {
ShardedJedis shardedJedis = null;
long count = 0;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
count = shardedJedis.hdel(domain, key);
} catch (Exception ex) {
logger.error("delHSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return count;
}
/**
* 判断key是否存在
*
* @param domain 域名
* @param key 键值
* @return
*/
public static boolean existsHSet(String domain, String key) {
ShardedJedis shardedJedis = null;
boolean isExist = false;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
isExist = shardedJedis.hexists(domain, key);
} catch (Exception ex) {
logger.error("existsHSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return isExist;
}
public static boolean existsKey(String key) {
ShardedJedis shardedJedis = null;
boolean isExist = false;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
isExist = shardedJedis.exists(key);
} catch (Exception ex) {
logger.error("existsKey error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return isExist;
}
/**
* 全局扫描hset
*
* @param match field匹配模式
* @return
*/
public static List<Map.Entry<String, String>> scanHSet(String domain, String match) {
ShardedJedis shardedJedis = null;
try {
int cursor = 0;
shardedJedis = JedisPoolHolder.getShardedJedis(true);
ScanParams scanParams = new ScanParams();
scanParams.match(match);
Jedis jedis = shardedJedis.getShard(domain);
ScanResult<Map.Entry<String, String>> scanResult;
List<Map.Entry<String, String>> list = new ArrayList<Map.Entry<String, String>>();
do {
scanResult = jedis.hscan(domain, String.valueOf(cursor), scanParams);
list.addAll(scanResult.getResult());
cursor = Integer.parseInt(scanResult.getStringCursor());
} while (cursor > 0);
return list;
} catch (Exception ex) {
logger.error("scanHSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return null;
}
/**
* 返回 domain 指定的哈希集中所有字段的value值
*
* @param domain
* @return
*/
public static List<String> hvals(String domain) {
ShardedJedis shardedJedis = null;
List<String> retList = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
retList = shardedJedis.hvals(domain);
} catch (Exception ex) {
logger.error("hvals error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return retList;
}
/**
* 返回 domain 指定的哈希集中所有字段的key值
*
* @param domain
* @return
*/
public static Set<String> hkeys(String domain) {
ShardedJedis shardedJedis = null;
Set<String> retList = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
retList = shardedJedis.hkeys(domain);
} catch (Exception ex) {
logger.error("hkeys error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return retList;
}
/**
* 返回 domain 指定的哈希key值总数
*
* @param domain
* @return
*/
public static long lenHset(String domain) {
ShardedJedis shardedJedis = null;
long retList = 0;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
retList = shardedJedis.hlen(domain);
} catch (Exception ex) {
logger.error("hkeys error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return retList;
}
/**
* 设置排序集合
*
* @param key
* @param score
* @param value
* @return
*/
public static boolean addSortSet(String key, long score, String value) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
shardedJedis.zadd(key, score, value);
return true;
} catch (Exception ex) {
logger.error("setSortedSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
/**
* 获得排序集合
*
* @param key
* @param startScore
* @param endScore
* @param orderByDesc
* @return
*/
public static Set<String> getSortSet(String key, long startScore, long endScore, boolean orderByDesc) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
if (orderByDesc) {
return shardedJedis.zrevrangeByScore(key, endScore, startScore);
} else {
return shardedJedis.zrangeByScore(key, startScore, endScore);
}
} catch (Exception ex) {
logger.error("getSoredSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return null;
}
/**
* 计算排序长度
*
* @param key
* @param startScore
* @param endScore
* @return
*/
public static long countSortZSet(String key, long startScore, long endScore) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
Long count = shardedJedis.zcount(key, startScore, endScore);
return count == null ? 0L : count;
} catch (Exception ex) {
logger.error("countSoredSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return 0L;
}
/**
* 计算排序长度
*
* @param key
* @return
*/
public static long countSortZSet(String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
Long count = shardedJedis.zcard(key);
return count == null ? 0L : count;
} catch (Exception ex) {
logger.error("countSoredSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return 0L;
}
/**
* 删除排序集合
*
* @param key
* @param value
* @return
*/
public static boolean delSortSet(String key, String value) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
long count = shardedJedis.zrem(key, value);
return count > 0;
} catch (Exception ex) {
logger.error("delSortedSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
/**
* 获得排序集合
*
* @param key
* @param startRange
* @param endRange
* @param orderByDesc
* @return
*/
public static Set<String> getSortSetByRange(String key, int startRange, int endRange, boolean orderByDesc) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
if (orderByDesc) {
return shardedJedis.zrevrange(key, startRange, endRange);
} else {
return shardedJedis.zrange(key, startRange, endRange);
}
} catch (Exception ex) {
logger.error("getSoredSetByRange error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return null;
}
/**
* 获得排序打分
*
* @param key
* @return
*/
public static Double getScore(String key, String member) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
return shardedJedis.zscore(key, member);
} catch (Exception ex) {
logger.error("getSoredSet error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return null;
}
public static boolean set(String key, String value, int second) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
shardedJedis.setex(key, second, value);
return true;
} catch (Exception ex) {
logger.error("set error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
public static boolean setTestKeyValue(String key, String value) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
shardedJedis.set(key, value);
return true;
} catch (Exception ex) {
logger.error("set error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
public static String get(String key, String defaultValue) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
return shardedJedis.get(key) == null ? defaultValue : shardedJedis.get(key);
} catch (Exception ex) {
logger.error("get error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return defaultValue;
}
public static boolean del(String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
shardedJedis.del(key);
return true;
} catch (Exception ex) {
logger.error("del error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
public static boolean del(byte[] key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
shardedJedis.del(key);
return true;
} catch (Exception ex) {
logger.error("del error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return false;
}
//排序
public static long incr(String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
return shardedJedis.incr(key);
} catch (Exception ex) {
logger.error("incr error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return 0;
}
public static long decr(String key) {
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis();
return shardedJedis.decr(key);
} catch (Exception ex) {
logger.error("incr error.", ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return 0;
}
/**
* 获取分页set
*
* @param key 列表key
* @param start 开始位置 从0开始
* @param end 结束位置
* @return 状态码
*/
public static java.util.Set<java.lang.String> getPageSet(String key, long start, long end) {
if (key == null || key.equals("")) {
return null;
}
ShardedJedis shardedJedis = null;
try {
shardedJedis = JedisPoolHolder.getShardedJedis(true);
return shardedJedis.zrevrange(key, start, end);
} catch (Exception ex) {
logger.error("LTRIM 出错" + ex.getMessage(), ex);
returnBrokenResource(shardedJedis);
} finally {
returnResource(shardedJedis);
}
return null;
}
private static void returnBrokenResource(ShardedJedis shardedJedis) {
try {
// shardedJedisPool.returnBrokenResource(shardedJedis);
JedisPoolHolder.cleanup();
} catch (Exception e) {
logger.error("returnBrokenResource error.", e);
}
}
private static void returnResource(ShardedJedis shardedJedis) {
try {
// JedisPoolHolder(shardedJedis);
JedisPoolHolder.cleanup();
// .returnResource(shardedJedis);
} catch (Exception e) {
logger.error("returnResource error.", e);
}
}
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.*;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
public class JedisPoolHolder {
private static final Logger logger = LoggerFactory.getLogger(JedisPoolHolder.class);
private static ShardedJedisPool pool;
private static ShardedJedisPool poolRead;
private static List<String[]> jedisList=new ArrayList<String[]>();
private static final ThreadLocal<Unit> holder = new ThreadLocal()
{
protected JedisPoolHolder.Unit initialValue() {
return new JedisPoolHolder.Unit();
}
};
private static final ThreadLocal<UnitRead> holderRead = new ThreadLocal()
{
protected JedisPoolHolder.UnitRead initialValue() {
return new JedisPoolHolder.UnitRead();
}
};
publicstatic ShardedJedis getShardedJedis(){
return ((Unit)holder.get()).get();
}
publicstatic ShardedJedis getShardedJedis(boolean isRead){
if(isRead){
return ((UnitRead)holderRead.get()).get();
}else{
return ((Unit)holder.get()).get();
}
}
public static void cleanup()
{
((Unit)holder.get()).cleanup();
holder.remove();
((UnitRead)holderRead.get()).cleanup();
holderRead.remove();
}
public static void destroyJedisPool()
{
pool.destroy();
poolRead.destroy();
}
static {
String str =ConfigUtil.getValue("framework.redis.url");
if(str.indexOf("#")>0){
String[] array = str.split("#");
List<JedisShardInfo> jdsInfoList= new ArrayList<JedisShardInfo>();
List<JedisShardInfo> jdsInfoReaderList= new ArrayList<JedisShardInfo>();
for(int i=0;i<array.length;i++){
getRedisServer(array);
}
String[] masterArray= new String;
for(int j =0 ;j<jedisList.size();j++){
if(j==0){
String[] masterHostAndPort = (String[])jedisList.get(j);
masterArray = masterHostAndPort;
Jedis master = new Jedis(masterHostAndPort,Integer.valueOf(masterHostAndPort));
JedisShardInfo info = new JedisShardInfo(masterHostAndPort,Integer.valueOf(masterHostAndPort));
if(masterHostAndPort!=null){
info.setPassword(masterHostAndPort);
master.auth(masterHostAndPort);
}
jdsInfoList.add(info);
master.slaveofNoOne();
pool =new ShardedJedisPool(getConfig(getURI(array)), jdsInfoList);
}else{
String[]slaveHostAndPort = (String[])jedisList.get(j);
Jedis slave = new Jedis(slaveHostAndPort,Integer.valueOf(slaveHostAndPort));
if(slaveHostAndPort!=null){
slave.auth(slaveHostAndPort);
}
slave.slaveof(masterArray,Integer.valueOf(masterArray));
JedisShardInfo infoRead = new JedisShardInfo(slaveHostAndPort,Integer.valueOf(slaveHostAndPort));
if(slaveHostAndPort!=null){
infoRead.setPassword(slaveHostAndPort);
}
jdsInfoReaderList.add(infoRead);
poolRead =new ShardedJedisPool(getConfig(getURI(array)), jdsInfoReaderList);
}
}
}else{
List<JedisShardInfo> jdsInfoList= new ArrayList<JedisShardInfo>();
getRedisServer(str);
JedisShardInfo info =null;
String[] masterHostAndPort = (String[])jedisList.get(0);
info = new JedisShardInfo(masterHostAndPort,Integer.valueOf(masterHostAndPort));
if(masterHostAndPort!=null){
info.setPassword(masterHostAndPort);
}
jdsInfoList.add(info);
pool =new ShardedJedisPool(getConfig(getURI(str)), jdsInfoList);
}
}
privatestatic JedisPoolConfig getConfig(URI uri){
int database = Integer.parseInt(uri.getPath().split("/", 2));
String clientName = null;
String sMaxActive = null; String sMaxWait = null; String sTestOnBorrow = null;
String query = uri.getQuery();
if (query != null) {
String[] kvs = query.split("&");
for (String kv : kvs) {
String[] arr = kv.split("=");
if (arr.length == 2)
{
if ("clientName".equals(arr)) clientName = arr;
else if ("maxActive".equals(arr)) sMaxActive = arr;
else if ("maxWait".equals(arr)) sMaxWait = arr;
else if ("testOnBorrow".equals(arr)) sTestOnBorrow = arr;
}
}
}
JedisPoolConfig config = new JedisPoolConfig();
if (sMaxActive != null) {
config.setMaxTotal(Integer.parseInt(sMaxActive));
}
config.setBlockWhenExhausted(true);
if (sMaxWait != null) {
config.setMaxWaitMillis(Long.parseLong(sMaxWait));
}
if (sTestOnBorrow != null) {
config.setTestOnBorrow("true".equals(sTestOnBorrow));
}
config.setTestWhileIdle(true);
config.setMinEvictableIdleTimeMillis(60000L);
config.setTimeBetweenEvictionRunsMillis(30000L);
config.setNumTestsPerEvictionRun(-1);
return config;
}
private static URI getURI(String str){
URI uri;
try
{
uri = new URI(str);
} catch (URISyntaxException e) {
throw new Error("framework.redis.url [" + str + "] 格式错误：" + e.getMessage());
}
return uri;
}
private static void getRedisServer(String str)
{
String[] hostAndPort =new String;
// String str = ConfigHelper.loadString("framework.redis.url");
URI uri = getURI(str);
String host = uri.getHost();
int port = uri.getPort();
String password = null;
if (uri.getUserInfo() != null) {
password = uri.getUserInfo().split(":", 2);
}
Jedis jedis = new Jedis(host,port);
hostAndPort=host;
hostAndPort=String.valueOf(port);
hostAndPort=password;
try {
jedis.connect();
} catch (Exception e){
JedisPoolHolder.logger.error("error ", e);
JedisPoolHolder.logger.info("server "+ port+"down");
}
if(jedis.isConnected()){
jedisList.add(hostAndPort);
jedis.disconnect();
}else{
JedisPoolHolder.logger.info("server "+ port+"down");
}
}
private static class Unit
{
// Jedis jedis;
ShardedJedis jedis;
void cleanup()
{
if (this.jedis != null)
{
try
{
// JedisHolder.pool.returnResource(this.jedis);
pool.returnResource(this.jedis);
} catch (RuntimeException e) {
try {
JedisPoolHolder.pool.returnBrokenResource(this.jedis);
} catch (RuntimeException e2) {
JedisPoolHolder.logger.error("error close Jedis", e2);
}
}
this.jedis = null;
}
}
public ShardedJedis get(){
if (this.jedis != null) return this.jedis;
return this.jedis = (ShardedJedis)pool.getResource();
}
}
private static class UnitRead
{
// Jedis jedis;
ShardedJedis jedis;
void cleanup()
{
if (this.jedis != null)
{
try
{
// JedisHolder.pool.returnResource(this.jedis);
poolRead.returnResource(this.jedis);
} catch (RuntimeException e) {
try {
JedisPoolHolder.poolRead.returnBrokenResource(this.jedis);
} catch (RuntimeException e2) {
JedisPoolHolder.logger.error("error close Jedis", e2);
}
}
this.jedis = null;
}
}
public ShardedJedis get(){
if (this.jedis != null) return this.jedis;
return this.jedis = (ShardedJedis)poolRead.getResource();
}
}
}
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.4.2</version>
</dependency>
配置文件
#redis配置模板
#framework.redis.url=redis://:mypass@localhost:6379/0?clientName=open&maxActive=100&maxWait=4000
#redis集群配置用#号隔开
framework.redis.url=redis://localhost:6379/0?clientName=scheduler&maxActive=100&maxWait=4000
分布式锁应用
if(RedisUtil.acquireLock(lockKey, 1000)) {
log.info("线程成功获取锁");
}
页:
[1]