分享自己封装基于RedisTemplate的redisUtil
作者：互联网
/**
* Redis工具类
* <p>注:无论哪种数据类型的key都不能为null</p>
*
* @author ldm
*/
@Slf4j
public class RedisUtil {
private static final RedisTemplate<String, Object> REDIS_TEMPLATE = SpringUtil.getBean("redisTemplate");
private RedisUtil() {
}
/**
* 指定缓存失效时间
*
* @param key 键
* @param timeout 失效时间(秒)
*/
public static Boolean expire(String key, long timeout) {
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 指定缓存失效时间
*
* @param key 键
* @param timeout 失效时间,负数为永久
*/
public static Boolean expire(String key, long timeout, TimeUnit unit) {
try {
return REDIS_TEMPLATE.expire(key, timeout, unit);
} catch (Exception e) {
log.error("redis设置失效时间异常:{}", e.getMessage(), e);
}
return Boolean.FALSE;
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 失效时间(秒) 返回-1代表为永久有效
*/
public static Long getExpire(String key) {
return getExpire(key, TimeUnit.SECONDS);
}
/**
* 根据key 获取过期时间
*
* @param key 键 不能为null
* @return 失效时间 返回-1代表为永久有效
*/
public static Long getExpire(String key, TimeUnit unit) {
try {
if (Objects.nonNull(key) && Objects.nonNull(unit)) {
return REDIS_TEMPLATE.getExpire(key, unit);
}
} catch (Exception e) {
log.error("redis获取过期时间异常:{}", e.getMessage(), e);
}
return null;
}
/**
* 判断key是否存在
*
* @param key 键
* @return true存在 false不存在
*/
public static Boolean hasKey(String key) {
try {
return REDIS_TEMPLATE.hasKey(key);
} catch (Exception e) {
log.error("redis判断key是否存在异常:{}", e.getMessage(), e);
}
return Boolean.FALSE;
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
@SuppressWarnings("unchecked")
public static void del(String... key) {
try {
if (Objects.nonNull(key) && key.length > 0) {
REDIS_TEMPLATE.delete(CollectionUtils.arrayToList(key));
}
} catch (Exception e) {
log.error("redis删除缓存异常:{}", e.getMessage(), e);
}
}
// ============================String=============================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public static Object get(String key) {
try {
return Objects.isNull(key) ? null : REDIS_TEMPLATE.opsForValue().get(key);
} catch (Exception e) {
log.error("redis普通缓存获取异常:{}", e.getMessage(), e);
}
return null;
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public static boolean set(String key, Object value) {
return set(key, value, 0L, null);
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param timeout 失效时间(秒) time要大于1如果time小于等于0将设置无限期
* @return true成功 false失败
*/
public static boolean set(String key, Object value, long timeout) {
return set(key, value, timeout, TimeUnit.SECONDS);
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param timeout 失效时间
* @param unit 时间单位
* @return true成功 false失败
*/
public static boolean set(String key, Object value, long timeout, TimeUnit unit) {
try {
REDIS_TEMPLATE.opsForValue().set(key, value);
if (timeout > 0 && Objects.nonNull(unit)) {
expire(key, timeout, unit);
}
return true;
} catch (Exception e) {
log.error("redis普通缓存放入异常:{}", e.getMessage(), e);
}
return false;
}
/**
* 递增(其实就是值做加法,每次加一,次数为 {@code delta})
*
* @param key 键
* @param delta 要增加几
* @return 增加后的值
*/
public static Long incr(String key, long delta) {
Long result = null;
try {
result = REDIS_TEMPLATE.opsForValue().increment(key, delta);
} catch (Exception e) {
log.error("redis递增异常:{}", e.getMessage(), e);
}
return result;
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几
* @return 减少后的值
*/
public static Long decr(String key, long delta) {
Long result = null;
try {
result = REDIS_TEMPLATE.opsForValue().increment(key, -delta);
} catch (Exception e) {
log.error("redis递减异常:{}", e.getMessage(), e);
}
return result;
}
// ================================Hash=================================
/**
* 根据key和hashKey获取Hash表的值
*
* @param key key 不能为null
* @param hashKey hashKey 不能为null
* @return hash值
*/
public static Object hGetHashKey(String key, String hashKey) {
try {
return REDIS_TEMPLATE.opsForHash().get(key, hashKey);
} catch (Exception e) {
log.error("redis hGetHashKey异常:{}", e.getMessage(), e);
}
return null;
}
/**
* 根据key获取Hash表
*
* @param key 键
* @return {@link Map}
*/
public static Map<Object, Object> hGet(String key) {
try {
return REDIS_TEMPLATE.opsForHash().entries(key);
} catch (Exception e) {
log.error("redis hGet异常:{}", e.getMessage(), e);
}
return null;
}
/**
* 向一张Hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param hashKey hashKey
* @param value hashValue
* @return true成功 false失败
*/
public static boolean hSetHashKey(String key, String hashKey, Object value) {
return hSetHashKey(key, hashKey, value, 0L, null);
}
/**
* 向一张Hash表中放入数据,如果不存在将创建 并设置时间
*
* @param key 键
* @param hashKey hashKey
* @param value hashValue
* @param timeout 失效时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true成功 false失败
*/
public static boolean hSetHashKey(String key, String hashKey, Object value, long timeout) {
return hSetHashKey(key, hashKey, value, timeout, TimeUnit.SECONDS);
}
/**
* 向一张Hash表中放入数据,如果不存在将创建 并设置时间
*
* @param key 键
* @param hashKey hashKey
* @param value hashValue
* @param timeout 失效时间 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true成功 false失败
*/
public static boolean hSetHashKey(String key, String hashKey, Object value, long timeout, TimeUnit unit) {
try {
REDIS_TEMPLATE.opsForHash().put(key, hashKey, value);
if (timeout > 0 && Objects.nonNull(unit)) {
expire(key, timeout, unit);
}
return true;
} catch (Exception e) {
log.error("redis hSetHashKey异常:{}", e.getMessage(), e);
}
return false;
}
/**
* setHash
*
* @param key 键
* @param map hash
* @return true成功 false失败
*/
public static boolean hSet(String key, Map<String, Object> map) {
return hSet(key, map, 0L, null);
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map hash
* @param timeout 失效时间(秒)
* @return true成功 false失败
*/
public static boolean hSet(String key, Map<String, Object> map, long timeout) {
return hSet(key, map, timeout, TimeUnit.SECONDS);
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map hash
* @param timeout 失效时间
* @param unit 时间单位
* @return true成功 false失败
*/
public static boolean hSet(String key, Map<String, Object> map, long timeout, TimeUnit unit) {
try {
REDIS_TEMPLATE.opsForHash().putAll(key, map);
if (timeout > 0 && Objects.nonNull(unit)) {
expire(key, timeout, unit);
}
return true;
} catch (Exception e) {
log.error("redis hSet异常:{}", e.getMessage(), e);
}
return false;
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param hashKey hashKey 可以使多个 不能为null
*/
public static void hDelHashKey(String key, Object... hashKey) {
try {
REDIS_TEMPLATE.opsForHash().delete(key, hashKey);
} catch (Exception e) {
log.error("redis hDelHashKey异常:{}", e.getMessage(), e);
}
}
/**
* 判断hash表中是否有该hashKey的值
*
* @param key 键 不能为null
* @param hashKey hashKey 不能为null
* @return true存在 false不存在
*/
public static Boolean hHasHashKey(String key, String hashKey) {
try {
return REDIS_TEMPLATE.opsForHash().hasKey(key, hashKey);
} catch (Exception e) {
log.error("redis hHasHashKey异常:{}", e.getMessage(), e);
}
return Boolean.FALSE;
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param hashKey hashKey
* @param delta 要增加几
* @return 增加后的值
*/
public static Long hIncr(String key, String hashKey, long delta) {
Long result = null;
try {
result = REDIS_TEMPLATE.opsForHash().increment(key, hashKey, delta);
} catch (Exception e) {
log.error("redis hIncr异常:{}", e.getMessage(), e);
}
return result;
}
/**
* hash递减
*
* @param key 键
* @param hashKey hashKey
* @param delta 要减少几
* @return 减少后的值
*/
public static Long hDecr(String key, String hashKey, long delta) {
Long result = null;
try {
result = REDIS_TEMPLATE.opsForHash().increment(key, hashKey, -delta);
} catch (Exception e) {
log.error("redis hDecr异常:{}", e.getMessage(), e);
}
return result;
}
// ============================Set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
* @return {@link Set}
*/
public static Set<Object> sGet(String key) {
try {
return REDIS_TEMPLATE.opsForSet().members(key);
} catch (Exception e) {
log.error("redis sGet异常:{}", e.getMessage(), e);
}
return Collections.emptySet();
}
/**
* 根据value从一个Set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true存在 false不存在
*/
public static Boolean sHasValue(String key, Object value) {
try {
return REDIS_TEMPLATE.opsForSet().isMember(key, value);
} catch (Exception e) {
log.error("redis sHasValue异常:{}", e.getMessage(), e);
}
return Boolean.FALSE;
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return true成功 false失败
*/
public static boolean sSet(String key, Object... values) {
return sSet(key, 0L, null, values);
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param timeout 失效时间(秒)
* @param values 值 可以是多个
* @return true成功 false失败
*/
public static boolean sSet(String key, long timeout, Object... values) {
return sSet(key, timeout, TimeUnit.SECONDS, values);
}
/**
* 将数据放入Set缓存
*
* @param key 键
* @param timeout 失效时间
* @param unit 时间单位
* @param values 值 可以是多个
* @return true成功 false失败
*/
public static boolean sSet(String key, long timeout, TimeUnit unit, Object... values) {
try {
REDIS_TEMPLATE.opsForSet().add(key, values);
if (timeout > 0 && Objects.nonNull(unit)) {
expire(key, timeout, unit);
}
return true;
} catch (Exception e) {
log.error("redis sSet异常:{}", e.getMessage(), e);
}
return false;
}
/**
* 获取Set缓存的长度
*
* @param key 键
* @return 长度
*/
public static Long sGetSize(String key) {
try {
return REDIS_TEMPLATE.opsForSet().size(key);
} catch (Exception e) {
log.error("redis getSetSize异常:{}", e.getMessage(), e);
}
return null;
}
/**
* 移除Set值为value的
*
* @param key 键
* @param values 值 可以是多个
*/
public static void sRemove(String key, Object... values) {
try {
REDIS_TEMPLATE.opsForSet().remove(key, values);
} catch (Exception e) {
log.error("redis sRemove异常:{}", e.getMessage(), e);
}
}
// ===============================List=================================
/**
* 获取List缓存的内容
*
* @param key 键
* @return {@link List}
*/
public static List<Object> lGet(String key) {
return lGet(key, 0L, -1L);
}
/**
* 获取指定索引List缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0到 -1代表所有值
* @return {@link List}
*/
public static List<Object> lGet(String key, long start, long end) {
try {
return REDIS_TEMPLATE.opsForList().range(key, start, end);
} catch (Exception e) {
log.error("redis lGet异常:{}", e.getMessage(), e);
}
return Collections.emptyList();
}
/**
* 获取List缓存的长度
*
* @param key 键
* @return List的size
*/
public static Long lGetSize(String key) {
try {
return REDIS_TEMPLATE.opsForList().size(key);
} catch (Exception e) {
log.error("redis lGetSize异常:{}", e.getMessage(), e);
}
return null;
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时， 0 首个元素，依次类推；index<0时，-1，最后一个元素，-2倒数第二个元素，依次类推
* @return List对应索引的值
*/
public static Object lGetIndex(String key, long index) {
try {
return REDIS_TEMPLATE.opsForList().index(key, index);
} catch (Exception e) {
log.error("redis lGetIndex异常:{}", e.getMessage(), e);
}
return null;
}
/**
* 将值放入List缓存
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public static boolean lSet(String key, Object value) {
return lSet(key, Collections.singleton(value), 0L, null, true);
}
/**
* 将值放入List缓存 并设置失效时间
*
* @param key 键
* @param value 值
* @param timeout 失效时间(秒)
* @return true成功 false失败
*/
public static boolean lSet(String key, Object value, long timeout) {
return lSet(key, Collections.singleton(value), timeout, TimeUnit.SECONDS, true);
}
/**
* 将值放入List缓存 并设置失效时间
*
* @param key 键
* @param value 值
* @param timeout 失效时间
* @param unit 时间单位
* @return true成功 false失败
*/
public static boolean lSet(String key, Object value, long timeout, TimeUnit unit) {
return lSet(key, Collections.singleton(value), timeout, unit, true);
}
/**
* 将集合放入List缓存
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public static boolean lSet(String key, Collection<Object> value) {
return lSet(key, value, 0L, null, true);
}
/**
* 将集合放入List缓存 并设置失效时间
*
* @param key 键
* @param value 值
* @param timeout 失效时间
* @param unit 时间单位
* @return true成功 false失败
*/
public static boolean lSet(String key, Collection<Object> value, long timeout, TimeUnit unit) {
return lSet(key, value, timeout, unit, true);
}
/**
* 将值放入List缓存 并设置失效时间
*
* @param key 键
* @param value 值
* @param timeout 失效时间
* @param unit 时间单位
* @param isRight 是否在尾部插入(List正常顺序)
* @return true成功 false失败
*/
public static boolean lSet(String key, Collection<Object> value, long timeout, TimeUnit unit, boolean isRight) {
try {
if (isRight) {
REDIS_TEMPLATE.opsForList().rightPushAll(key, value);
} else {
REDIS_TEMPLATE.opsForList().leftPushAll(key, value);
}
if (timeout > 0 && Objects.nonNull(unit)) {
expire(key, timeout, unit);
}
return true;
} catch (Exception e) {
log.error("redis lSet异常:{}", e.getMessage(), e);
}
return false;
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引 index>=0时， 0 首个元素，依次类推；index<0时，-1，最后一个元素，-2倒数第二个元素，依次类推
* @param value 值
* @return true成功 false失败
*/
public static boolean lUpdateIndex(String key, long index, Object value) {
try {
REDIS_TEMPLATE.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
log.error("redis lUpdateIndex异常:{}", e.getMessage(), e);
return false;
}
}
/**
* 移除List值为value(所有)
*
* @param key 键
* @param value 值
*/
public static void lRemove(String key, Object value) {
lRemove(key, 0L, value);
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 0:等于这个值的所有值,正数:移除从头部开始count个,负数:移除从尾部开始count个
* @param value 值
*/
public static void lRemove(String key, long count, Object value) {
try {
REDIS_TEMPLATE.opsForList().remove(key, count, value);
} catch (Exception e) {
log.error("redis lRemove异常:{}", e.getMessage(), e);
}
}
}
标签：return,String,timeout,param,static,key,封装,redisUtil,RedisTemplate 来源： https://blog.csdn.net/LDM228247714/article/details/117921459