概述
Redis（全称：Remote Dictionary Server 远程字典服务）是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库、并提供多种语言的API。日常开发中会经常使用到该数据库，在这里记录一下常用到的方法。
相关代码
Maven配置
redis.clients
jedis
初始化
/**
*Redis配置类
*/
@Component
public class DataConfig {
@Value("${redis.ip}")
String ip;
@Value("${redis.port}")
int port;
@Value("${redis.password}")
String password;
@PostConstruct
public void init() {
if(StringUtils.isNotEmpty(password)) {
RedisUtils.init(ip, port, password);
}else {
RedisUtils.init(ip, port);
}
}
}
初始化配置操作
public class RedisUtils {
private static JedisPool pool;
public static JedisPool getPool() {
return pool;
}
//用于判断当前Redis连接是否已经初始化
public static boolean isInit;
// 最大空闲连接数
private static final int MAX_IDLE_COUNT = 500;
// 最大连接数
private static final int MAX_TOTAL_COUNT = 300;
// 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间, 默认-1
private static final int MAX_WAIT_MILLIS = 5000;
// 默认数据过期时间
public static final int DEFAULT_EXPIRE_SECONDS = 2 * 24 * 60 * 60;
//不过期的时间
public static final int FOREVER_EXPIRE_SECONDS = -1;
public static void init(String ip, int port) {
init(ip, port, null, MAX_IDLE_COUNT, MAX_TOTAL_COUNT, MAX_WAIT_MILLIS);
}
public static void init(String ip, int port, String password) {
init(ip, port, password, MAX_IDLE_COUNT, MAX_TOTAL_COUNT, MAX_WAIT_MILLIS);
}
public static void init(String ip, int port, String password, int maxIdleCount, int maxTotalCount,
int maxWaitMillis) {
if (isInit) {
return;
}
isInit = true;
// 建立连接池配置参数
JedisPoolConfig config = new JedisPoolConfig();
// 最大空闲连接数
config.setMaxIdle(maxIdleCount);
// 设置最大阻塞时间，记住是毫秒数milliseconds
config.setMaxWaitMillis(maxWaitMillis);
// 最大连接数, 默认8个
config.setMaxTotal(maxTotalCount);
// 创建连接池
if (org.apache.commons.lang3.StringUtils.isEmpty(password)) {
pool = new JedisPool(config, ip, port);
} else {
pool = new JedisPool(config, ip, port, 5000, password);
}
}
/**
* 释放资源
* @param jedis
*/
private static void closeResource(Jedis jedis) {
try {
jedis.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
Key值的常用操作，放在RedisUtils类中
/**
* 是否存在指定的key
* @param key
* @return
*/
public static boolean existsKey(String key) {
Jedis jedis = pool.getResource();
try {
return jedis.exists(key);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
} finally {
closeResource(jedis);
}
}
/**
* key表达式,如：brand_*
* @param keyExpression
* @return
*/
public static Set getKeys(String keyExpression) {
Jedis jedis = pool.getResource();
try {
return jedis.keys(keyExpression);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return Sets.newHashSet();
} finally {
closeResource(jedis);
}
}
/**
* 移除指定的key
* @param key
*/
public static void delKey(String key) {
Jedis jedis = pool.getResource();
try {
jedis.del(key);
} catch (Exception e) {
jedis.close();
Logger.error(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 单独设置指定key的过期时间
* @param key-key
* @param expireSeconds--过期时间(秒)
*/
public static void setKeyExpireTime(String key, int expireSeconds) {
if (expireSeconds <= 0) {
return;
}
Jedis jedis = pool.getResource();
try {
jedis.expire(key, expireSeconds);
} catch (Exception e) {
jedis.close();
Logger.error(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
Incr 命令
Redis Incr 命令将 key 中储存的数字值增一。
如果 key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作。
如果值包含错误的类型，或字符串类型的值不能表示为数字，那么返回一个错误。
本操作的值限制在 64 位(bit)有符号数字表示之内。
/**
* 获取自增id
*
* @param key-key
* @return
*/
public static int getAutoIncreaseId(String key) {
Jedis jedis = pool.getResource();
try {
return jedis.incr(key).intValue();
} catch (Exception e) {
Logger.error(e.getMessage(), e);
return -1;
} finally {
closeResource(jedis);
}
}
/**
* 将key中储存的数字值增1
* @param key -key
* @return
*/
public static long incr(String key, int expireSeconds) {
Jedis jedis = pool.getResource();
try {
// 当 key 不存在时，返回 -2 。
// 当 key 存在但没有设置剩余生存时间时，返回 -1 。
// 否则，以毫秒为单位，返回 key 的剩余生存时间。
long ttl = jedis.ttl(key);
if (ttl > 0) {
return jedis.incr(key);
} else if (ttl < 0) {
Long incr = jedis.incr(key);
jedis.expire(key, expireSeconds);
return incr;
}
return -1;
} catch (Exception e) {
Logger.error(e.getMessage(), e);
return -1;
} finally {
closeResource(jedis);
}
}
/**
* 将key中储存的数字值增1
* @param key -key
* @return
*/
public static long incr(String key) {
Jedis jedis = pool.getResource();
try {
Long incr = jedis.incr(key);
return incr;
} catch (Exception e) {
Logger.error(e.getMessage(), e);
return -1;
} finally {
closeResource(jedis);
}
}
/**
* 自减操作
*/
public static int getAutoDecrement(String key) {
Jedis jedis = pool.getResource();
try {
return jedis.decr(key).intValue();
} catch (Exception e) {
// Logger.error(e.getMessage(), e);
e.printStackTrace();
return -1;
} finally {
closeResource(jedis);
}
}
根据Key查询/写入值或对象
/**
* 从缓存获取指定key的对象
*
* @param key
* @param c
* @return
*/
public static T getValue(String key, Class c) {
String s = getValue(key);
if (StringUtils.isEmpty(s)) {
return null;
}
return gson.fromJson(s, c);
}
/**
* 从缓存批量获取keys的对象集合
* @param keys
* @param c
* @param
* @return
*/
public static List getValues(String[] keys, Class c) {
Jedis jedis = pool.getResource();
List list = new ArrayList();
try {
List results = jedis.mget(keys);
for (String s : results) {
if (!StringUtils.isEmpty(s)) {
list.add(JSONObject.parseObject(s, c));
}
}
} catch (Exception e) {
jedis.close();
e.printStackTrace();
} finally {
closeResource(jedis);
}
return list;
}
/**
* 从缓存取得指定key的字符串
* 该方法不对外提供，以免与T参数方法误用
*
* @param key
* @return
*/
private static String getValue(String key) {
Jedis jedis = pool.getResource();
try {
String s = jedis.get(key);
return s == null ? "" : s;
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return "";
} finally {
closeResource(jedis);
}
}
/**
* 保存单个对象(如果对象已经存在，则覆盖)
* 默认过期时间：3天
*
* @param key
* @param value
*/
public static void setValue(String key, T value) {
setValue(key, value, DEFAULT_EXPIRE_SECONDS);
}
/**
* 保存单个对象(如果对象已经存在，则覆盖)
*
* @param key
* @param value
* @param expireSeconds-过期时间(秒)
*/
public static void setValue(String key, T value, int expireSeconds) {
if (value != null) {
setValue(key, value, expireSeconds, false);
}
}
/**
* 保存单个对象(如果对象已经存在，则覆盖)-包括flag
* @param key
* @param value
* @param expireSeconds
* @param needSetFlag
* @param
*/
public static void setValue(String key, T value, int expireSeconds, boolean needSetFlag) {
if (value != null) {
setValue(key, JSONObject.toJSONString(value), expireSeconds, needSetFlag);
// setValue(key, gson.toJson(value), expireSeconds, needSetFlag);
}
}
/**
* 保存字符串(如果对象已经存在，则覆盖)
*
* @param key-key
* @param value-value
* @param expireTime-过期时间，类型：yyyy-MM-dd
* HH:mm:ss
*/
public static void setValue(String key, T value, String expireTime) {
if (value != null) {
long toTime = FastDateUtils.getTime(expireTime, FastDateFormat.DATE_TIME);
int expireSeconds = (int) (toTime - System.currentTimeMillis()) / 1000;
if (expireSeconds > 0) {
setValue(key, value, expireSeconds);
}
}
}
/**
* 保存字符串(如果对象已经存在，则覆盖)
* @param key
* @param value
* @param expireSeconds
* @param needSetFlag
*/
private static void setValue(String key, String value, int expireSeconds, boolean needSetFlag) {
Jedis jedis = pool.getResource();
try {
if (expireSeconds > 0) {
jedis.set(key, value);
jedis.expire(key, expireSeconds);
} else {// 不设置过期时间则需检测之前是否设置有过期时间，有则需设置回原有的过期时间
// 获取key过期时间，因为set后原有的key过期时间将被清空
long expireTime = jedis.pttl(key);// 剩余过期毫秒数
jedis.set(key, value);
if (expireTime > 0) {
int time = (int) Math.ceil((float) expireTime / 1000);
jedis.expire(key, time);// 再设置原有剩余秒数 向上取整，如2.1 则为3
}
}
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
setnx命令操作
将 key 的值设为 value ，当且仅当 key 不存在。
若给定的 key 已经存在，则 SETNX 不做任何动作。
SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。
/**
* 保存对象（如果不存在key的话）
*
* @param key
* @param value
* @return 不存在key，则保存成功，返回true，存在key，则保存失败，返回false
*/
public static boolean setnxWithNoExpire(String key, T value) {
return setnx(key, value, 0);
}
/**
* 保存对象（如果不存在key的话）
*
* @param key
* @param value
* @return 不存在key，则保存成功，返回true，存在key，则保存失败，返回false
*/
public static boolean setnx(String key, T value, int expireSeconds) {
return setnx(key, JSONObject.toJSONString(value), expireSeconds);
}
/**
* 保存字符串（如果不存在key的话）
*
* @param key
* @param value
* @return 不存在key，则保存成功，返回true，存在key，则保存失败，返回false
*/
private static boolean setnx(String key, String value, int expireSeconds) {
Jedis jedis = pool.getResource();
try {
// 1 if the key was set 0 if the key was not set
boolean setnxOK = jedis.setnx(key, value) == 1;
// 设置过期时间
if (expireSeconds > 0) {
if (setnxOK) { // 设置成功了，则设置失效时间
jedis.expire(key, expireSeconds);
} else if (!setnxOK && jedis.pttl(key) < 0) {// 或者由于某些异常状态setnx执行成功
// 但expire没有成功，可能会导致锁永远释放不掉，这里强制设置过期时间
jedis.expire(key, expireSeconds);
}
}
if (setnxOK) {
return true;
}
} catch (Exception e) {
jedis.close();
e.printStackTrace();
} finally {
closeResource(jedis);
}
return false;
}
List操作
/**
* 设置一个全新的list
* 如果之前已经存在key，则会先移除，再添加
*
* @param key
* @param list
*/
public static void setList(String key, List list) {
if (list == null || list.size() == 0) {
return;
}
Jedis jedis = pool.getResource();
try {
String[] ss = new String[list.size()];
for (int i = 0; i < list.size(); i++) {
ss[i] = JSONObject.toJSONString(list.get(i));
}
delKey(key);// 先移除之前的key，再新增
jedis.rpush(key, ss);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
*
* @param key
* @param list
* @param timeOut
* @param
*/
public static void setList(String key, List list,Integer timeOut) {
if (list == null || list.size() == 0) {
return;
}
Jedis jedis = pool.getResource();
try {
String[] ss = new String[list.size()];
for (int i = 0; i < list.size(); i++) {
ss[i] = JSONObject.toJSONString(list.get(i));
}
jedis.rpush(key, ss);
jedis.expire(key,timeOut);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 添加一个value到原有列表到尾部
* @param key
* @param value
* @param
*/
public static void addList(String key, T value) {
Jedis jedis = pool.getResource();
try {
String[] ss = new String[1];
ss[0] = JSONObject.toJSONString(value);
jedis.rpush(key, ss);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 添加一个value到原有列表头部
*
* @param key
* @param value
*/
public static void addListToHead(String key, T value) {
Jedis jedis = pool.getResource();
try {
String[] ss = new String[1];
ss[0] = JSONObject.toJSONString(value);
jedis.lpush(key, JSONObject.toJSONString(value));
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 设置list中指定索引的值
*
* @param key
* @param index-索引
* @param value
*/
public static void setListElement(String key, int index, T value) {
Jedis jedis = pool.getResource();
try {
jedis.lset(key, index, JSONObject.toJSONString(value));
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 返回某个范围内的集合，无结果集则返回空list
*
* @param key
* @param start-起始索引（包含，从0开始）
* @param end-结束索引（包含）
* @return
*/
private static List getListRange(String key, int start, int end) {
Jedis jedis = pool.getResource();
try {
return jedis.lrange(key, start, end);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return null;
} finally {
closeResource(jedis);
}
}
/**
* 返回某个范围内的集合，无结果集则返回空list
*
* @param key
* @param start-起始索引（包含，从0开始）
* @param end-结束索引（包含）
* @param c-具体类
* @return
*/
public static List getListRange(String key, int start, int end, Class c) {
List slist = getListRange(key, start, end);
List list = new ArrayList();
for (String s : slist) {
list.add(gson.fromJson(s, c));
}
return list.isEmpty() ? null : list;
}
/**
* 分页获取list
*
* @param key
* @param pageNow-当前页数
* @param pageSize-每页记录数
* @param c
* @return
*/
public static List getListPage(String key, int pageNow, int pageSize, Class c) {
int startIndex = (pageNow - 1) * pageSize;
int endIndex = pageNow * pageSize - 1;
return getListRange(key, startIndex, endIndex, c);
}
/**
* 获取指定key下的列表所有记录
*
* @param key
* @param c
* @return
*/
public static List getAllList(String key, Class c) {
return getListRange(key, 0, -1, c);
}
/**
* 获取列表第一个元素
*
* @param key
* @param c
* @return
*/
public static T getListFirstElement(String key, Class c) {
Jedis jedis = pool.getResource();
try {
return JSONObject.parseObject(jedis.lindex(key, 0), c);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return null;
} finally {
closeResource(jedis);
}
}
/**
* 返回并删除list中的首元素
*
* @param key
* @return
*/
public static T getListPop(String key, Class c) {
Jedis jedis = pool.getResource();
try {
return JSONObject.parseObject(jedis.lpop(key), c);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return null;
} finally {
closeResource(jedis);
}
}
/**
* 获取列表最后一个元素
*
* @param key
* @param c
* @return
*/
public static T getListLastElement(String key, Class c) {
Jedis jedis = pool.getResource();
try {
return JSONObject.parseObject(jedis.lindex(key, -1), c);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return null;
} finally {
closeResource(jedis);
}
}
/**
* 返回list的集合个数
*
* @param key
* @return
*/
public static int getListSize(String key) {
Jedis jedis = pool.getResource();
try {
return jedis.llen(key).intValue();
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return 0;
} finally {
closeResource(jedis);
}
}
/**
* 删除list的指定对象
*
* @param key
* @param values
*/
@SuppressWarnings("unchecked")
public static void removeValueFromList(String key, T... values) {
Jedis jedis = pool.getResource();
try {
for (T v : values) {
jedis.lrem(key, 0, JSONObject.toJSONString(v));
}
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 删除一个列表
*
* @param key
*/
public static void removeList(String key) {
Jedis jedis = pool.getResource();
try {
if (jedis.llen(key) > 0) {
jedis.ltrim(key, 1, 0);
}
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
Map操作
/**
* 保存Java map to Redis map
* @param hashKey
* @param map
*/
public static void addToHashMap(String hashKey, Map map) {
if (map == null || map.isEmpty()) {
return;
}
Jedis jedis = pool.getResource();
try {
for (String key : map.keySet()) {
String value = JSONObject.toJSONString(map.get(key));
jedis.hset(hashKey, key, value);
}
jedis.expire(hashKey, DEFAULT_EXPIRE_SECONDS);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 保存Java map to Redis map
*
* @param hashKey
* @param map
*/
public static void addToHashMap2(String hashKey, Map map) {
if (map == null || map.isEmpty()) {
return;
}
Jedis jedis = pool.getResource();
try {
for (K key : map.keySet()) {
String value = JSONObject.toJSONString(map.get(key));
jedis.hset(hashKey, String.valueOf(key), value);
}
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 保存Java value to Redis map
*
* @param hashKey
* @param key
* @param value
*/
public static void addToHashMap(String hashKey, String key, T value) {
Jedis jedis = pool.getResource();
try {
jedis.hset(hashKey, key, JSONObject.toJSONString(value));
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 从hashmap中返回某个key的值
*
* @param hashKey
* @param key
* @param c-类型
* @return
*/
public static T getValueFromHashMap(String hashKey, String key, Class c) {
Jedis jedis = pool.getResource();
try {
String s = jedis.hget(hashKey, key);
if (StringUtils.isEmpty(s)) {
return null;
}
return JSONObject.parseObject(s, c);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return null;
} finally {
closeResource(jedis);
}
}
/**
* 从hashmap中返回某个key的值
* @param hashKey
* @param key
* @param typeOfT
* @param
* @return
*/
public static T getValueFromHashMap(String hashKey, String key, Type typeOfT) {
Jedis jedis = pool.getResource();
try {
String s = jedis.hget(hashKey, key);
if (StringUtils.isEmpty(s)) {
return null;
}
return JSONObject.parseObject(s, typeOfT);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return null;
} finally {
closeResource(jedis);
}
}
/**
* 返回整个map对象
*
* @param hashKey
* @return
*/
public static Map getAllFromHashMap(String hashKey, Class c) {
Jedis jedis = pool.getResource();
try {
Map map = jedis.hgetAll(hashKey);
Map tMap = new HashMap(map.size());
for (String key : map.keySet()) {
T value = JSONObject.parseObject(map.get(key), c);
tMap.put(key, value);
}
return tMap;
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return null;
} finally {
closeResource(jedis);
}
}
/**
* 获取hashmap的size
*
* @param hashKey
* @return
*/
public static long getSizeFromHashMap(String hashKey) {
Jedis jedis = pool.getResource();
try {
return jedis.hlen(hashKey);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return 0;
} finally {
closeResource(jedis);
}
}
/**
* 删除map中的指定key
*
* @param hashKey
* @param keys
*/
public static void removeFromHashMap(String hashKey, String... keys) {
Jedis jedis = pool.getResource();
try {
jedis.hdel(hashKey, keys);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
} finally {
closeResource(jedis);
}
}
/**
* 获取某个Map的所有key集合
*
* @param hashKey
* @return
*/
public static Set getKeysFromHashMap(String hashKey) {
Jedis jedis = pool.getResource();
try {
return jedis.hkeys(hashKey);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return null;
} finally {
closeResource(jedis);
}
}
/**
* 删除某Map所有的元素
*
* @param hashKey
*/
public static void removeHashMap(String hashKey) {
if (StringUtils.isEmpty(hashKey)) {
return;
}
Set keySet = getKeysFromHashMap(hashKey);
if (keySet == null || keySet.isEmpty()) {
return;
}
// 化成数组
String[] keyArr = keySet.toArray(new String[] {});
if (keyArr == null || keyArr.length == 0) {
return;
}
// 批量删除
removeFromHashMap(hashKey, keyArr);
}
/**
* 在hashmap中是否存在指定的key
* @param hashKey
* @param key
* @return
*/
public static boolean hasKeyFromHashMap(String hashKey, String key) {
Jedis jedis = pool.getResource();
try {
return jedis.hexists(hashKey, key);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return false;
} finally {
closeResource(jedis);
}
}
zSet操作
Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
有序集合的成员是唯一的,但分数(score)却可以重复。
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。
/**
* 写入zset队列
* @param key
* @param map
* @return
*/
public static boolean setZsetValue(String key, Map map) {
if (StringUtils.isEmpty(key)) {
return false;
}
if(map == null || map.size() <= 0) {
return false;
}
Jedis jedis = pool.getResource();
try {
Long count = jedis.zadd(key, map);
if(count > 0) {
return true;
}
} catch (Exception e) {
closeResource(jedis);
Logger.error("RedisClient->setZsetValue插入队列失败 map=[" + JSONObject.toJSONString(map) + "]", e);
} finally {
closeResource(jedis);
}
return false;
}
/**
* 根据范围返回zSet队列任务
* @param key
* @param minIndex
* @param maxIndex
* @return
*/
public static Set getZsetValuesByRange(String key, int minIndex, int maxIndex) {
Set set = Collections.emptySet();
if(existsKey(key)) {
if(getZsetCount(key) <= 0) {
return set;
}
Jedis jedis = pool.getResource();
try {
set = jedis.zrange(key, minIndex, maxIndex);
return set;
} catch (Exception e) {
closeResource(jedis);
Logger.error("RedisClient->getZsetValuesByRange获取队列任务失败 key=[" + key + "], index=["+minIndex+","+maxIndex+"]", e);
} finally {
closeResource(jedis);
}
}
return set;
}
/**
* 根据Value删除指定Zset队列元素
* @param key
* @param value
* @return
*/
public static boolean remZsetValue(String key, String value) {
if (StringUtils.isEmpty(key)) {
return false;
}
if(existsKey(key)) {
Jedis jedis = pool.getResource();
try {
Long count = jedis.zrem(key, value);
if(count > 0) {
return true;
}
} catch (Exception e) {
closeResource(jedis);
Logger.error("RedisClient->remZsetValue删除队列任务失败 key=[" + key + "], value=["+value+"]", e);
return false;
} finally {
closeResource(jedis);
}
}
return false;
}
public static long getZsetCount(String key) {
if (StringUtils.isEmpty(key)) {
return 0;
}
if(existsKey(key)) {
Jedis jedis = pool.getResource();
try {
return jedis.zcard(key);
} catch (Exception e) {
closeResource(jedis);
e.printStackTrace();
return 0;
} finally {
closeResource(jedis);
}
}
return 0;
}
Redis Hincrby 命令
Redis Hincrby 命令用于为哈希表中的字段值加上指定增量值。
增量也可以为负数，相当于对指定字段进行减法操作。
如果哈希表的 key 不存在，一个新的哈希表被创建并执行 HINCRBY 命令。
如果指定的字段不存在，那么在执行命令前，字段的值被初始化为 0 。
对一个储存字符串值的字段执行 HINCRBY 命令将造成一个错误。
本操作的值被限制在 64 位(bit)有符号数字表示之内。
/**
* 为哈希表 key 中的域 field 的值加1
* @param key
* @param field
* @return
*/
public static long incrementHashMapValue(String key, String field) {
return incrementHashMapValue(key, field, 1);
}
/**
* 为哈希表 key 中的域 field 的值减1
* @param key
* @param field
* @return
*/
public static long decrementHashMapValue(String key, String field) {
return incrementHashMapValue(key, field, -1);
}
public static long incrementHashMapValue(String key, String field, long increment) {
Jedis jedis = pool.getResource();
try {
return jedis.hincrBy(key, field, increment);
} catch (Exception e) {
// Logger.error(e.getMessage(), e);
e.printStackTrace();
return -1;
} finally {
closeResource(jedis);
}
}
Set集合(无序列表)操作
/**
* 添加set集合
*/
public static void addSetValue(String key, String value, int expireSeconds) {
Jedis jedis = pool.getResource();
try {
if (expireSeconds > 0) {
jedis.sadd(key, value);
jedis.expire(key, expireSeconds);
} else {// 不设置过期时间则需检测之前是否设置有过期时间，有则需设置回原有的过期时间
// 获取key过期时间，因为set后原有的key过期时间将被清空
long expireTime = jedis.pttl(key);// 剩余过期毫秒数
jedis.sadd(key, value);
if (expireTime > 0) {
int time = (int) Math.ceil((float) expireTime / 1000);
jedis.expire(key, time);// 再设置原有剩余秒数 向上取整，如2.1 则为3
}
}
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 批量-添加set集合
*/
public static void addSetValue(String key, String[] value, int expireSeconds) {
Jedis jedis = pool.getResource();
try {
if (expireSeconds > 0) {
jedis.sadd(key, value);
jedis.expire(key, expireSeconds);
} else {// 不设置过期时间则需检测之前是否设置有过期时间，有则需设置回原有的过期时间
// 获取key过期时间，因为set后原有的key过期时间将被清空
long expireTime = jedis.pttl(key);// 剩余过期毫秒数
jedis.sadd(key, value);
if (expireTime > 0) {
int time = (int) Math.ceil((float) expireTime / 1000);
jedis.expire(key, time);// 再设置原有剩余秒数 向上取整，如2.1 则为3
}
}
} catch (Exception e) {
jedis.close();
e.printStackTrace();
throw new RedisException(e.getMessage(), e);
} finally {
closeResource(jedis);
}
}
/**
* 移除集合中一个或多个成员
* @param key
* @param members
* @return
*/
public static boolean delSetValues(String key, String... members){
Jedis jedis = null;
try {
jedis = pool.getResource();
Long value = jedis.srem(key, members);
if(value > 0){
return true;
}
}catch (Exception e) {
e.printStackTrace();
}finally{
if(jedis != null){
jedis.close();
}
}
return false;
}
/**
* 获取set集合
*/
public static Set getSetValue(String key) {
Jedis jedis = pool.getResource();
try {
return jedis.smembers(key);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return Sets.newHashSet();
} finally {
closeResource(jedis);
}
}
/**
* 获取对象转换的Set集合
* @param key
* @param c
* @param
* @return
*/
public static Set getSetValue(String key, Class c) {
Set set = getSetValue(key);
Set temp = new HashSet<>();
if(set.size() > 0){
for (String s : set) {
temp.add(JSONObject.parseObject(s, c));
}
}
return temp;
}
/**
* 弹出Set集合
* @param sourceKey
* @param targetKey
* @return
*/
public static Set moveSetValue(String sourceKey, String targetKey){
Jedis jedis = pool.getResource();
try {
//获取当前列表元素
Set currentSet = jedis.smembers(sourceKey);
if(currentSet.size() <= 0){
return Sets.newHashSet();
}
//将元素移到另外一个集合
for (String value :currentSet){
jedis.smove(sourceKey, targetKey, value);
}
Set set = jedis.smembers(targetKey);
return set;
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return Sets.newHashSet();
} finally {
closeResource(jedis);
}
}
/**
* 弹出Set对象集合
* @param sourceKey
* @param targetKey
* @param c
* @param
* @return
*/
public static Set moveSetValue(String sourceKey, String targetKey, Class c) {
Set set = moveSetValue(sourceKey, targetKey);
Set temp = new HashSet<>();
if(set.size() > 0){
for (String s : set) {
temp.add(JSONObject.parseObject(s, c));
}
}
return temp;
}
/**
* 获取Set集合总数
* @param key
* @return
*/
public static long getSetCount(String key) {
Jedis jedis = pool.getResource();
try {
return jedis.scard(key);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return BasicDataUtil.DEFAULT_LONG;
} finally {
closeResource(jedis);
}
}
/**
* 查询set集合内是否存在该元素
* @param key
* @param val
* @return
*/
public static Boolean existsKeyInSet(String key, String val) {
Jedis jedis = pool.getResource();
try {
return jedis.sismember(key, val);
} catch (Exception e) {
jedis.close();
e.printStackTrace();
return Boolean.FALSE;
} finally {
closeResource(jedis);
}
}
/**
* 从set集合中弹出一定数量的元素(数量由传入参数控制)
*/
public static Set getSetValueBySpop(String key, long count){
Jedis jedis = pool.getResource();
Set value;
try {
value = jedis.spop(key,count);
}catch (Exception e) {
jedis.close();
e.printStackTrace();
return new HashSet<>();
} finally {
closeResource(jedis);
}
return value;
}
Redis提供的API函数十分丰富，能帮助我们解决系统中很多性能问题。后续会提供一些用到Redis的技术方案。