package com.tebon.ams.utils;
import com.alibaba.fastjson.JSON;
import com.tebon.ams.util.ObjectUtil;
import org.codehaus.jackson.map.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.io.*;
import java.util.*;
public class JedisUtil {
private final static Logger logger = LoggerFactory.getLogger(JedisUtil.class);
private static JedisPool pool;
private JedisUtil() {
}
static {
InputStream is = null;
try {
Properties constant = new Properties();
is = JedisUtil.class.getClassLoader().getResourceAsStream("redis.properties");
if (is != null) {
constant.load(is);
}
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxIdle(Integer.valueOf(constant.getProperty("redis.maxIdle", "100")));
poolConfig.setMinIdle(Integer.valueOf(constant.getProperty("redis.minIdle", "20")));//设置最小空闲数
poolConfig.setMaxTotal(Integer.valueOf(constant.getProperty("redis.maxTotal", "300")));
poolConfig.setTimeBetweenEvictionRunsMillis(-1);
poolConfig.setTestOnBorrow(true);
String host = constant.getProperty("redis.host");
int port = Integer.valueOf(constant.getProperty("redis.port"));
int timeout = Integer.valueOf(constant.getProperty("redis.timeout"));
String pwd = constant.getProperty("redis.pwd");
int db = Integer.valueOf(constant.getProperty("redis.db", "0"));
if (pwd == null || pwd.isEmpty()) {
pool = new JedisPool(poolConfig, host, port, timeout);
} else {
pool = new JedisPool(poolConfig, host, port, timeout, pwd, db);
}
} catch (IOException e) {
logger.error("读取redis配置文件出错", e);
} catch (Exception e) {
logger.error("JedisUtil init error", e);
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
logger.error("关闭redis配置文件流出错", e);
}
}
}
}
public static JedisPool getJedisPool() {
return pool;
}
//-----------String Start ------------------
/**
* String类型的增加操作
*
* @param key
* @param value
*/
public static void set(String key, String value) {
Jedis jedis = null;
try {
jedis = pool.getResource();
jedis.set(key, value);
} catch (Exception e) {
logger.error("set error.", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
}
/**
* 字符串
*
* @param key
* @param value
* @param expireTimeInSec
*/
public static void set(String key, String value, int expireTimeInSec) {
Jedis jedis = null;
try {
jedis = pool.getResource();
jedis.setex(key, expireTimeInSec, value);
} catch (Exception e) {
logger.error("set ex error.", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
}
public static String get(String key) {
Jedis jedis = null;
String value = null;
try {
jedis = pool.getResource();
value = jedis.get(key);
} catch (Exception e) {
logger.error("getkey error.", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return value;
}
/**
* 删除某个key
*
* @param name
*/
public static void del(String name) {
Jedis jedis = null;
try {
jedis = pool.getResource();
jedis.del(name);
} catch (Exception e) {
logger.error("pop ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
}
/**
* 存入对象之前进行序列化
*
* @param key 键
* @param value 值
* @return
*/
public static String setObj(String key, Object value) {
String result = null;
Jedis jedis = null;
try {
jedis = pool.getResource();
result = jedis.set(key.getBytes(), ObjectUtil.serialize(value));
logger.debug("setObject {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObject {} = {}", key, value, e);
} finally {
pool.returnResource(jedis);
}
return result;
}
/**
* 设置缓存
*
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static String setObj(String key, Object value, int cacheSeconds) {
String result = null;
Jedis jedis = null;
try {
jedis = pool.getResource();
result = jedis.set(key.getBytes(), ObjectUtil.serialize(value));
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setObject {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObject {} = {}", key, value, e);
} finally {
pool.returnResource(jedis);
}
return result;
}
/**
* getObj
*
* @param key 键
* @return
*/
public static Object getObj(String key) {
Jedis jedis = null;
try {
jedis = pool.getResource();
byte[] bytes = jedis.get(key.getBytes());
if (null != bytes && bytes.length > 0) {
return ObjectUtil.unSerialize(bytes);
}
return null;
} catch (Exception e) {
logger.error("getobj error.", e);
pool.returnBrokenResource(jedis);
return null;
} finally {
pool.returnResource(jedis);
}
}
/**
* 删除key
*/
public static Long delObj(String key) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.del(key.getBytes());
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
if (jedis != null) {
jedis.close();
}
}
}
/**
* 判断某个key值是否存在
*
* @param key
* @return
*/
public Boolean exists(String key) {
Jedis jedis = null;
Boolean flag = false;
try {
jedis = pool.getResource();
flag = jedis.exists(key);
} catch (Exception e) {
logger.error("set error.", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return flag;
}
//-----------String End ------------------
//----------Set Start ------------------
/**
* 向Set缓存中添加值
*
* @param key 键
* @param value 值
* @return
*/
public static long setSetAdd(String key, String... value) {
long result = 0;
Jedis jedis = null;
try {
jedis = pool.getResource();
result = jedis.sadd(key, value);
logger.debug("setSetAdd {} = {}", key, value);
} catch (Exception e) {
logger.warn("setSetAdd {} = {}", key, value, e);
} finally {
pool.returnResource(jedis);
}
return result;
}
/**
* 设置Set缓存
*
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static long setSet(String key, Set<String> value, int cacheSeconds) {
long result = 0;
Jedis jedis = null;
try {
jedis = pool.getResource();
if (jedis.exists(key)) {
jedis.del(key);
}
result = jedis.sadd(key, value.toArray(new String[value.size()]));
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setSet {} = {}", key, value);
} catch (Exception e) {
logger.warn("setSet {} = {}", key, value, e);
} finally {
pool.returnResource(jedis);
}
return result;
}
/**
* 获取缓存
*
* @param key 键
* @return 值
*/
public static Set<String> getSet(String key) {
Set<String> value = null;
Jedis jedis = null;
try {
jedis = pool.getResource();
if (jedis.exists(key)) {
value = jedis.smembers(key);
logger.debug("getSet {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getSet {} = {}", key, value, e);
} finally {
pool.returnResource(jedis);
}
return value;
}
/**
* 设置Set缓存
*
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static long setObjectSet(String key, Set<Object> value, int cacheSeconds) {
long result = 0;
Jedis jedis = null;
try {
jedis = pool.getResource();
if (jedis.exists(key.getBytes())) {
jedis.del(key);
}
Set<byte[]> set = new HashSet();
for (Object o : value) {
set.add(ObjectUtil.serialize(o));
}
result = jedis.sadd(key.getBytes(), set.toArray(new byte[set.size()][]));
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setObjectSet {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObjectSet {} = {}", key, value, e);
} finally {
pool.returnResource(jedis);
}
return result;
}
/**
* 获取缓存
*
* @param key 键
* @return 值
*/
public static Set<Object> getObjectSet(String key) {
Set<Object> value = null;
Jedis jedis = null;
try {
jedis = pool.getResource();
if (jedis.exists(key.getBytes())) {
value = new HashSet();
Set<byte[]> set = jedis.smembers(key.getBytes());
for (byte[] bs : set) {
value.add(ObjectUtil.unSerialize(bs));
}
logger.debug("getObjectSet {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getObjectSet {} = {}", key, value, e);
} finally {
pool.returnResource(jedis);
}
return value;
}
/**
* 向Set缓存中添加值
*
* @param key 键
* @param value 值
* @return
*/
public static long setSetObjectAdd(String key, Object... value) {
long result = 0;
Jedis jedis = null;
try {
jedis = pool.getResource();
Set<byte[]> set = new HashSet();
for (Object o : value) {
//防止传数组，有null报错
if (o == null) {
continue;
}
set.add(ObjectUtil.serialize(o));
}
result = jedis.sadd(key.getBytes(), set.toArray(new byte[set.size()][]));
logger.debug("setSetObjectAdd {} = {}", key, value);
} catch (Exception e) {
logger.warn("setSetObjectAdd {} = {}", key, value, e);
} finally {
pool.returnResource(jedis);
}
return result;
}
/**
* 获取给定key中元素个数
*
* @param String key
* @return 元素个数
*/
public static long scard(String key) {
Jedis jedis = null;
long len = 0;
try {
jedis = pool.getResource();
len = jedis.scard(key);
} catch (Exception e) {
logger.warn("scard {} = {}", key, e);
} finally {
pool.returnResource(jedis);
}
return len;
}
/**
* 判断KEY关联的SET集合是否存在对应的成员
*
* @param key Redis里面实际的KEY
* @param value 要查找的成员
*/
public static boolean sismember(String key, String value) {
Jedis jedis = null;
boolean flag = false;
try {
jedis = pool.getResource();
flag = jedis.sismember(key, value);
} catch (Exception e) {
logger.error("set cache error.", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return flag;
}
/**
* 从集合中删除指定成员
*
* @param key
* @param value
* @return
*/
public static long srem(String key, String value) {
Jedis jedis = null;
long flag = 0;
try {
jedis = pool.getResource();
flag = jedis.srem(key, value);
} catch (Exception e) {
logger.error("set cache error.", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return flag;
}
//-----------Set End --------------------
//-----------List Start-------------------
@SuppressWarnings("unchecked")
public static <T extends Serializable> void push(String name, T... ts) {
Jedis jedis = null;
try {
jedis = pool.getResource();
for (T t : ts)
jedis.lpush(name, JSON.toJSONString(t));
} catch (Exception e) {
logger.error("push error.", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
}
public static long lpush(String name, String json) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.lpush(name, json);
} catch (Exception e) {
logger.error("push error.", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return -1;
}
public static <T extends Serializable> void push(String name, Collection<T> collection) {
Jedis jedis = null;
try {
jedis = pool.getResource();
for (T t : collection)
jedis.lpush(name, JSON.toJSONString(t));
} catch (Exception e) {
logger.error("push collection error.", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
}
/**
* 从列表最后一位开始移除并获取列表该元素
*
* @param name
* @param size
* @param <T>
* @return
*/
@SuppressWarnings("unchecked")
public static <T extends Serializable> List<T> pop(String name, int size) {
if (size < 1) {
return null;
}
Jedis jedis = null;
List<T> list = new ArrayList<T>();
try {
jedis = pool.getResource();
if (jedis.exists(name)) {
String value = jedis.rpop(name);
for (int i = 1; i <= size && value != null; i++) {
list.add((T) JedisUtil.str2Object(value));
value = jedis.rpop(name);
}
}
} catch (Exception e) {
logger.error("pop ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return list;
}
@SuppressWarnings("unchecked")
public static <T extends Serializable> List<T> lrange(String name, int start, int end) {
Jedis jedis = null;
List<T> list = new ArrayList<T>();
try {
jedis = pool.getResource();
if (jedis.exists(name)) {
List<String> strList = jedis.lrange(name, start, end);
int size = strList == null ? 0 : strList.size();
for (int i = 0; i < size; i++) {
list.add((T) JedisUtil.str2Object(strList.get(i)));
}
}
} catch (Exception e) {
logger.error("lrange ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return list;
}
public static <T extends Serializable> List<T> lrange(String name, int start, int end, Class<T> classes) {
Jedis jedis = null;
List<T> list = new ArrayList<T>();
try {
jedis = pool.getResource();
if (jedis.exists(name)) {
List<String> strList = jedis.lrange(name, start, end);
int size = strList == null ? 0 : strList.size();
ObjectMapper objectMapper = new ObjectMapper();
for (int i = 0; i < size; i++) {
list.add(objectMapper.readValue(strList.get(i), classes));
}
}
} catch (Exception e) {
logger.error("lrange ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return list;
}
public static long length(String name) {
Jedis jedis = null;
long length = 0;
try {
jedis = pool.getResource();
length = jedis.llen(name);
} catch (Exception e) {
logger.error("pop ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return length;
}
/**
* 移除列表中的元素
*
* @param name
* @param count count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
* count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
* count = 0 : 移除表中所有与 VALUE 相等的值。
*/
public static void lrem(String name, int count, String value) {
Jedis jedis = null;
try {
jedis = pool.getResource();
jedis.lrem(name, count, JSON.toJSONString(value));
} catch (Exception e) {
logger.error("pop ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
}
//---------------List End----------------
//--------------ZSet Start---------------
/**
* 向有序不重复集合添加数据
*
* @param key
* @param score
* @param member
* @return
*/
public static long zadd(String key, double score, String member) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.zadd(key, score, member);
} catch (Exception e) {
logger.error("zadd ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return 0;
}
public static long zadd(String key, Map<String, Double> scoreMembers) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.zadd(key, scoreMembers);
} catch (Exception e) {
logger.error("zadd ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return 0;
}
/**
* 移除有序集合中给定的字典区间的所有成员
*
* @param key
* @param start
* @param end
* @return
*/
public static long zremrangeByRank(String key, long start, long end) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.zremrangeByRank(key, start, end);
} catch (Exception e) {
logger.error("zremrangeByRank ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return 0;
}
/**
* 通过索引区间返回有序集合成指定区间内的成员
*
* @param key
* @param start
* @param end
* @return
*/
public static Set<String> zrange(String key, long start, long end) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.zrange(key, start, end);
} catch (Exception e) {
logger.error("zrang ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return null;
}
/**
* 获取有序集合的成员数
*
* @param key
* @return
*/
public static long zcard(String key) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.zcard(key);
} catch (Exception e) {
logger.error("zcard ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return 0;
}
//--------------End ZSet-----------------------
//--------------Start Hash---------------------
/**
* 将哈希表 key 中的字段 field 的值设为 value
*
* @param key
* @param field
* @param value
* @return
*/
public static long hset(String key, String field, String value) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.hset(key, field, value);
} catch (Exception e) {
logger.error("hset ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return 0;
}
/**
* 获取所有给定字段的值
*
* @param key
* @param field
* @return
*/
public static String hget(String key, String field) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.hget(key, field);
} catch (Exception e) {
logger.error("hget ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return null;
}
/**
* 删除一个或多个哈希表字段
*
* @param key
* @param field
* @return
*/
public static Long hdel(String key, String field) {
Jedis jedis = null;
try {
jedis = pool.getResource();
return jedis.hdel(key, field);
} catch (Exception e) {
logger.error("hget ", e);
pool.returnBrokenResource(jedis);
} finally {
pool.returnResource(jedis);
}
return null;
}
/**
* 获取byte[]类型Key
*
* @param key
* @return /*
*/
/* public static byte[] getBytesKey(Object object) {
if (object instanceof String) {
return StringUtils.getBytes((String) object);
} else {
return ObjectUtil.serialize(object);
}
}*/
public static Object str2Object(String str) throws Exception {
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(getByte(str)));
return ois.readObject();
}
public static byte[] getByte(String str) {
byte[] bt = null;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
if (str != null) {
ObjectOutputStream objos = new ObjectOutputStream(baos);
objos.writeObject(str);
bt = baos.toByteArray();
}
} catch (Exception e) {
bt = (byte[]) null;
e.printStackTrace();
}
return bt;
}
}