package com.hollywood.common.redis;
|
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Component;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.util.StringUtils;
|
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
|
/**
|
* Redis工具类
|
*
|
* @author xiaochen
|
* @date 2023年2月25日
|
*/
|
@Component
|
@Slf4j
|
public final class RedisAutoTemplate {
|
|
private final RedisTemplate<String, Object> redisTemplate;
|
|
@Autowired
|
public RedisAutoTemplate(RedisTemplate<String, Object> redisTemplate) {
|
this.redisTemplate = redisTemplate;
|
}
|
|
/* Common 相关 */
|
|
/**
|
* 指定缓存失效时间
|
*
|
* @param key 键
|
* @param time 时间(秒)
|
* @return
|
*/
|
public boolean expire(String key, long time) {
|
try {
|
if (isEmpty(key)) {
|
return false;
|
}
|
if (time > 0) {
|
redisTemplate.expire(key, time, TimeUnit.SECONDS);
|
}
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 判断key是否存在
|
*
|
* @param key 键
|
* @return true 存在 false不存在
|
*/
|
public boolean hasKey(String key) {
|
try {
|
if (isEmpty(key)) {
|
return false;
|
}
|
return redisTemplate.hasKey(key);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 匹配符合正则的key
|
* 如果用keys模糊，好像会产生性能问题
|
*
|
* @param patternKey
|
* @return key的集合
|
*/
|
public Set<String> keys(String patternKey) {
|
log.debug(" keys key :{}", patternKey);
|
try {
|
if (isEmpty(patternKey)) {
|
return Collections.emptySet();
|
}
|
return redisTemplate.keys(patternKey);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return Collections.emptySet();
|
}
|
|
|
/**
|
* 根据key删除缓存
|
*
|
* @param key
|
* @return true:成功 false:失败
|
*/
|
public boolean del(String... key) {
|
log.debug(" delete key :{}", key.toString());
|
try {
|
if (isEmpty(key)) {
|
return false;
|
}
|
Set<String> keySet = new HashSet<>();
|
for (String str : key) {
|
keySet.add(str);
|
}
|
redisTemplate.delete(keySet);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 根据key删除缓存
|
*
|
* @param key
|
* @return true:成功 false:失败
|
*/
|
public boolean delPattern(String key) {
|
log.debug(" delete Pattern keys :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return false;
|
}
|
redisTemplate.delete(redisTemplate.keys(key));
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 删除一组key值
|
*
|
* @param keys
|
* @return true:成功 false:失败
|
*/
|
public boolean del(Set<String> keys) {
|
log.debug(" delete keys :{}", keys.toString());
|
try {
|
if (isEmpty(keys)) {
|
return false;
|
}
|
redisTemplate.delete(keys);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * 设置过期时间
|
*
|
* @param key 缓存key
|
* @param seconds 过期秒数
|
* @return true:成功 false:失败
|
*/
|
public boolean setExpire(String key, long seconds) {
|
log.debug(" setExp key :{}, seconds: {}", key, seconds);
|
try {
|
if (isEmpty(key)) {
|
return false;
|
}
|
return redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 查询过期时间
|
*
|
* @param key 缓存key
|
* @return 秒数 返回0代表为永久有效
|
*/
|
public Long getExpire(String key) {
|
log.debug(" getExpire key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return 0L;
|
}
|
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return 0L;
|
}
|
|
/**
|
* 缓存中的最大值并+1
|
*
|
* @param key 缓存key值
|
* @return long 缓存中的最大值+1
|
*/
|
public long incr(String key) {
|
log.debug(" incr key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return 0L;
|
}
|
return redisTemplate.opsForValue().increment(key, 1);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return 0L;
|
}
|
|
/**
|
* *递增
|
*
|
* @param key 键
|
* @param delta 要增加几(大于0)
|
* @return
|
*/
|
public long incr(String key, long delta) {
|
try {
|
if (isEmpty(key)) {
|
return 0L;
|
}
|
if (delta < 0) {
|
throw new RuntimeException("递增因子必须大于0");
|
}
|
return redisTemplate.opsForValue().increment(key, delta);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return 0L;
|
}
|
|
/**
|
* 递减
|
*
|
* @param key 键
|
* @param delta 要减少几(小于0)
|
* @return
|
*/
|
public long decr(String key, long delta) {
|
try {
|
if (isEmpty(key)) {
|
return 0L;
|
}
|
if (delta < 0) {
|
throw new RuntimeException("递减因子必须大于0");
|
}
|
return redisTemplate.opsForValue().increment(key, -delta);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return 0L;
|
}
|
|
/* String 相关 */
|
|
/**
|
* * 缓存存入key-value
|
*
|
* @param key 缓存键
|
* @param value 缓存值
|
* @return true:成功 false:失败
|
*/
|
public boolean setStr(String key, String value) {
|
log.debug(" setString key :{}, value: {}", key, value);
|
try {
|
redisTemplate.opsForValue().set(key, value);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * 缓存存入key-value
|
*
|
* @param key 缓存键
|
* @param value 缓存值
|
* @param seconds 秒数
|
* @return true:成功 false:失败
|
*/
|
public boolean setStr(String key, String value, long seconds) {
|
log.debug(" setString key :{}, value: {}, timeout:{}", key, value, seconds);
|
try {
|
if (isEmpty(key) || isEmpty(value)) {
|
return false;
|
}
|
redisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 根据key取出String value
|
*
|
* @param key 缓存key值
|
* @return String 缓存的String
|
*/
|
public String getStr(String key) {
|
log.debug(" getString key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return null;
|
}
|
return (String) redisTemplate.opsForValue().get(key);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return null;
|
}
|
|
|
|
/* 对象 相关 */
|
|
/**
|
* * 缓存中存入序列化的Object对象
|
*
|
* @param key 缓存key
|
* @param obj 存入的序列化对象
|
* @return true:成功 false:失败
|
*/
|
public boolean setObj(String key, Object obj) {
|
log.debug(" set key :{}, value:{}", key, obj);
|
try {
|
if (isEmpty(key) || isEmpty(obj)) {
|
return false;
|
}
|
redisTemplate.opsForValue().set(key, obj);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * 缓存中存入序列化的Object对象
|
*
|
* @param seconds 秒
|
* @param key 缓存key
|
* @param obj 存入的序列化对象
|
* @return true:成功 false:失败
|
*/
|
public boolean setObj(String key, Object obj, long seconds) {
|
log.debug(" set key :{}, value:{}, seconds:{}", key, obj, seconds);
|
try {
|
if (isEmpty(key) || isEmpty(obj)) {
|
return false;
|
}
|
redisTemplate.opsForValue().set(key, obj);
|
if (seconds > 0) {
|
redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
|
} else {
|
return false;
|
}
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * 取出缓存中存储的序列化对象
|
*
|
* @param key 缓存key
|
*/
|
public Object getObj(String key) {
|
log.debug(" get key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return null;
|
}
|
return redisTemplate.opsForValue().get(key);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return null;
|
}
|
|
|
/**
|
* * 取出缓存中存储的序列化对象
|
*
|
* @param key 缓存key
|
* @param clazz 对象类
|
* @return <T> 序列化对象
|
*/
|
public <T> T getObj(String key, Class<T> clazz) {
|
log.debug(" get key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return null;
|
}
|
return (T) redisTemplate.opsForValue().get(key);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return null;
|
}
|
|
|
/* Map 相关 */
|
|
/**
|
* * 存入Map数组
|
*
|
* @param <T>
|
* @param key 缓存key
|
* @param map 缓存map
|
* @return true:成功 false:失败
|
*/
|
public <T> boolean setMap(String key, Map<String, T> map) {
|
try {
|
if (isEmpty(key) || isEmpty(map)) {
|
return false;
|
}
|
redisTemplate.opsForHash().putAll(key, map);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * 存入Map数组并设置时间
|
*
|
* @param <T>
|
* @param key 缓存key
|
* @param map 缓存map
|
* @param seconds 秒数
|
* @return true:成功 * false:失败
|
*/
|
public <T> boolean setMap(String key, Map<String, T> map, long seconds) {
|
log.debug(" setMapExp key :{}, value: {}, seconds:{}", key, map, seconds);
|
try {
|
if (setMap(key, map)) {
|
redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
|
} else {
|
return false;
|
}
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * 根据key以及hashKey取出对应的Object对象
|
*
|
* @param key 缓存key
|
* @param hashKey 对应map的key
|
* @return object map中的对象
|
*/
|
public <T> T getMapObj(String key, String hashKey, Class<T> clazz) {
|
log.debug(" getMapkey :{}, hashKey:{}", key, hashKey);
|
try {
|
if (isEmpty(key) || isEmpty(hashKey)) {
|
return null;
|
}
|
return (T) redisTemplate.opsForHash().get(key, hashKey);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return null;
|
}
|
|
|
/**
|
* 取出缓存key的map,对应的所有键值
|
*
|
* @param key 缓存key
|
* @return map 缓存的map
|
*/
|
public Map getMap(String key) {
|
log.debug(" getMap key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return null;
|
}
|
return redisTemplate.opsForHash().entries(key);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return null;
|
}
|
|
|
/**
|
* * map中加入新的key
|
*
|
* @param <T>
|
* @param key 缓存key
|
* @param hashKey map的Key值
|
* @param value map的value值
|
* @return true:成功 * false:失败
|
*/
|
public <T> boolean addMap(String key, Object hashKey, T value) {
|
log.debug(" addMap key :{}, hashKey: {}, value:{}", key, hashKey, value);
|
try {
|
if (isEmpty(key) || isEmpty(hashKey) || isEmpty(value)) {
|
return false;
|
}
|
redisTemplate.opsForHash().put(key, hashKey, value);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * map中加入新的key
|
*
|
* @param <T>
|
* @param key 缓存key
|
* @param hashKey map的Key值
|
* @param value map的value值
|
* @param seconds 秒数
|
* @return true:成功 * false:失败
|
*/
|
public <T> boolean addMap(String key, Object hashKey, T value, long seconds) {
|
log.debug(" addMap key :{}, hashKey: {}, seconds:{}, value:{}", key, hashKey, seconds, value);
|
try {
|
if (seconds > 0) {
|
if (addMap(key, hashKey, value)) {
|
expire(key, seconds);
|
} else {
|
return false;
|
}
|
} else {
|
return false;
|
}
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 取出缓存中map的所有key值
|
*
|
* @param key 缓存key
|
* @return Set<String> map的key值合集
|
*/
|
public Set<Object> getMapKeys(String key) {
|
log.debug(" getMapKeys key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return Collections.emptySet();
|
}
|
return redisTemplate.opsForHash().keys(key);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return Collections.emptySet();
|
}
|
|
/**
|
* * 删除map中指定的key值,删除hash表中的值
|
*
|
* @param key 缓存key
|
* @param hashKey map中指定的hashKey
|
* @return true:成功 false:失败
|
*/
|
public boolean delMapKey(String key, Object... hashKey) {
|
log.debug(" delMapKey key :{}, hashKey:{}", key, hashKey);
|
try {
|
if (isEmpty(key) || isEmpty(hashKey)) {
|
return false;
|
}
|
redisTemplate.opsForHash().delete(key, hashKey);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
|
/**
|
* 判断hash表中是否有该项的值
|
*
|
* @param key 缓存key
|
* @param hashKey map中指定的hashKey
|
* @return true 存在 false不存在
|
*/
|
public boolean hasKeyMap(String key, Object hashKey) {
|
log.debug(" hasKeyMap key :{}, hashKey:{}", key, hashKey);
|
try {
|
if (isEmpty(key) || isEmpty(hashKey)) {
|
return false;
|
}
|
return redisTemplate.opsForHash().hasKey(key, hashKey);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
|
*
|
* @param key 键
|
* @param hashKey 项
|
* @param by 要增加几(大于0)
|
* @return
|
*/
|
public double incrMap(String key, Object hashKey, double by) {
|
try {
|
if (isEmpty(key) || isEmpty(hashKey)) {
|
return 0L;
|
}
|
return redisTemplate.opsForHash().increment(key, hashKey, by);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return 0L;
|
}
|
|
/**
|
* hash递减
|
*
|
* @param key 键
|
* @param hashKey 项
|
* @param by 要减少记(小于0)
|
* @return
|
*/
|
public double decrMap(String key, Object hashKey, double by) {
|
try {
|
if (isEmpty(key) || isEmpty(hashKey)) {
|
return 0L;
|
}
|
return redisTemplate.opsForHash().increment(key, hashKey, -by);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return 0L;
|
|
}
|
|
/**
|
* 查询缓存的map的集合大小
|
*
|
* @param key 缓存key
|
* @return long 缓存map的集合大小
|
*/
|
public long getMapSize(String key) {
|
log.debug(" getMap key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return 0L;
|
}
|
return redisTemplate.opsForHash().size(key);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return 0L;
|
}
|
|
|
|
/* List 相关 */
|
|
|
/**
|
* * 缓存存入List
|
*
|
* @param <T>
|
* @param key 缓存key
|
* @param list 缓存List
|
* @return true:成功 * false:失败
|
*/
|
public <T> boolean setList(String key, List<T> list) {
|
log.debug("setList key :{}, list: {}", key, list);
|
try {
|
if (isEmpty(key) || isEmpty(list)) {
|
return false;
|
}
|
redisTemplate.opsForList().leftPushAll(key, list.toArray());
|
// redisTemplate.opsForList().rightPushAll(key, list.toArray());
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * 缓存存入List
|
*
|
* @param <T>
|
* @param key 缓存key
|
* @param list 缓存List
|
* @param seconds 秒数
|
* @return true:成功 * false:失败
|
*/
|
public <T> boolean setList(String key, List<T> list, long seconds) {
|
log.debug(" setList key :{}, value:{}, seconds:{}", key, list, seconds);
|
try {
|
if (seconds > 0) {
|
if (setList(key, list)) {
|
expire(key, seconds);
|
} else {
|
return false;
|
}
|
} else {
|
return false;
|
}
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
|
/**
|
* * Object存入List
|
*
|
* @param key 缓存key
|
* @param value List中的值
|
* @return true:成功 * false:失败
|
*/
|
public boolean addList(String key, Object value) {
|
log.debug(" addList key :{}, value:{}", key, value);
|
try {
|
if (isEmpty(key) || isEmpty(value)) {
|
return false;
|
}
|
redisTemplate.opsForList().leftPush(key, value);
|
// redisTemplate.opsForList().rightPush(key, value);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * Object存入List
|
*
|
* @param key 缓存key
|
* @param value List中的值
|
* @param seconds 秒数
|
* @return true:成功 * false:失败
|
*/
|
public boolean addList(String key, Object value, long seconds) {
|
log.debug(" addList key :{}, value:{}", key, value);
|
try {
|
if (seconds > 0) {
|
if (addList(key, value)) {
|
expire(key, seconds);
|
} else {
|
return false;
|
}
|
} else {
|
return false;
|
}
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 获取list缓存的内容
|
*
|
* @param key 键
|
* @param start 开始
|
* @param end 结束 0 到 -1代表所有值
|
* @return
|
*/
|
public List<Object> getList(String key, long start, long end) {
|
try {
|
if (isEmpty(key)) {
|
return null;
|
}
|
return redisTemplate.opsForList().range(key, start, end);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return null;
|
}
|
}
|
|
/**
|
* * 根据key值取出对应的list合集
|
*
|
* @param key 缓存key
|
* @return List<Object> 缓存中对应的list合集
|
*/
|
public <V> List<V> getList(String key) {
|
log.debug(" getList key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return null;
|
}
|
List<V> lists = (List<V>) redisTemplate.opsForList().range(key, 0, -1);
|
return lists.size() == 0 ? null : lists;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return null;
|
}
|
|
/**
|
* * 根据key值截取对应的list合集
|
*
|
* @param key 缓存key
|
* @param start 开始位置
|
* @param end 结束位置
|
* @return
|
*/
|
public boolean trimList(String key, long start, long end) {
|
log.debug(" trimList key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return false;
|
}
|
redisTemplate.opsForList().trim(key, start, end);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * 取出list合集中指定位置的对象
|
*
|
* @param key 缓存key
|
* @param index 索引位置 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
|
* @return Object list指定索引位置的对象
|
*/
|
public Object getIndexList(String key, long index) {
|
log.debug(" getIndexList key :{}, index:{}", key, index);
|
try {
|
if (isEmpty(key)) {
|
return null;
|
}
|
return redisTemplate.opsForList().index(key, index);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return null;
|
}
|
|
|
/**
|
* 获取list缓存的长度
|
*
|
* @param key 键
|
* @return
|
*/
|
public long getListSize(String key) {
|
try {
|
if (isEmpty(key)) {
|
return 0L;
|
}
|
return redisTemplate.opsForList().size(key);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
return 0L;
|
}
|
}
|
|
|
/**
|
* 根据索引修改list中的某条数据
|
*
|
* @param key 键
|
* @param index 索引
|
* @param value 值
|
* @return
|
*/
|
public boolean updateIndexList(String key, long index, Object value) {
|
try {
|
if (isEmpty(key)) {
|
return false;
|
}
|
redisTemplate.opsForList().set(key, index, value);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
return false;
|
}
|
}
|
|
/**
|
* 移除N个值为value
|
*
|
* @param key 键
|
* @param count 移除多少个
|
* @param value 值
|
* @return 移除的个数
|
*/
|
public long removeList(String key, long count, Object value) {
|
try {
|
if (isEmpty(key)) {
|
return 0L;
|
}
|
Long remove = redisTemplate.opsForList().remove(key, count, value);
|
return remove;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
return 0L;
|
}
|
}
|
|
|
/* Set 相关 */
|
|
/**
|
* * set集合存入缓存
|
*
|
* @param <T>
|
* @param key 缓存key
|
* @param set 缓存set集合
|
* @return true:成功 * false:失败
|
*/
|
public <T> boolean setSet(String key, Set<T> set) {
|
log.debug(" setSet key :{}, value:{}", key, set);
|
try {
|
if (isEmpty(key) || isEmpty(set)) {
|
return false;
|
}
|
redisTemplate.opsForSet().add(key, set.toArray());
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * set集合中增加value
|
*
|
* @param key 缓存key
|
* @param value 增加的value
|
* @return true:成功 * false:失败
|
*/
|
public boolean addSet(String key, Object value) {
|
log.debug(" addSet key :{}, value:{}", key, value);
|
try {
|
if (isEmpty(key) || isEmpty(value)) {
|
return false;
|
}
|
redisTemplate.opsForSet().add(key, value);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 将数据放入set缓存
|
*
|
* @param key 键
|
* @param values 值 可以是多个
|
* @return true:成功 * false:失败
|
*/
|
public boolean addSet(String key, Object... values) {
|
try {
|
if (isEmpty(key) || isEmpty(values)) {
|
return false;
|
}
|
redisTemplate.opsForSet().add(key, values);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * set集合存入缓存
|
*
|
* @param <T>
|
* @param key 缓存key
|
* @param set 缓存set集合
|
* @param seconds 秒数
|
* @return true:成功 * false:失败
|
*/
|
public <T> boolean setSet(String key, Set<T> set, long seconds) {
|
log.debug(" setSet key :{}, value:{}, seconds:{}", key, set, seconds);
|
try {
|
if (seconds > 0) {
|
if (setSet(key, set)) {
|
redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
|
} else {
|
return false;
|
}
|
} else {
|
return false;
|
}
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * 取出缓存中对应的set合集
|
*
|
* @param <T>
|
* @param key 缓存key
|
* @return Set<Object>
|
* 缓存中的set合集
|
*/
|
public <T> Set<T> getSet(String key) {
|
log.debug(" getSet key :{}", key);
|
try {
|
if (isEmpty(key)) {
|
return null;
|
}
|
return (Set<T>) redisTemplate.opsForSet().members(key);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return null;
|
}
|
|
/**
|
* * 有序集合存入数值
|
*
|
* @param key 缓存key
|
* @param value 缓存value
|
* @param score 评分
|
* @return true:成功 * false:失败
|
*/
|
public boolean addZSet(String key, Object value, double score) {
|
log.debug(" addZSet key :{},value:{}, score:{}", key, value, score);
|
try {
|
if (isEmpty(key) || isEmpty(value)) {
|
return false;
|
}
|
return redisTemplate.opsForZSet().add(key, value, score);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 从有序集合中删除指定值
|
*
|
* @param key 缓存key
|
* @param value 缓存value
|
* @return true:成功 * false:失败
|
*/
|
public boolean removeZSet(String key, Object value) {
|
log.debug(" removeZSet key :{},value:{}", key, value);
|
try {
|
if (isEmpty(key) || isEmpty(value)) {
|
return false;
|
}
|
redisTemplate.opsForZSet().remove(key, value);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* * 从有序集合中删除指定位置的值
|
*
|
* @param key 缓存key
|
* @param start 起始位置
|
* @param end 结束为止
|
* @return true:成功 * false:失败
|
*/
|
public boolean removeZSet(String key, long start, long end) {
|
log.debug(" removeZSet key :{},start:{}, end:{}", key, start, end);
|
try {
|
if (isEmpty(key)) {
|
return false;
|
}
|
redisTemplate.opsForZSet().removeRange(key, start, end);
|
return true;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
/**
|
* 移除值为value的
|
*
|
* @param key 键
|
* @param values 值 可以是多个
|
* @return 移除的个数
|
*/
|
public long setRemove(String key, Object... values) {
|
try {
|
if (isEmpty(key)) {
|
return 0L;
|
}
|
Long count = redisTemplate.opsForSet().remove(key, values);
|
return count;
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return 0L;
|
}
|
|
/**
|
* * 从有序集合中获取指定位置的值
|
*
|
* @param key 缓存key
|
* @param start 起始位置
|
* @param end 结束为止
|
* @return Set<Object>
|
* 缓存中的set合集
|
*/
|
public <T> Set<T> getZSet(String key, long start, long end) {
|
log.debug(" getZSet key :{},start:{}, end:{}", key, start, end);
|
try {
|
if (isEmpty(key)) {
|
return Collections.emptySet();
|
}
|
return (Set<T>) redisTemplate.opsForZSet().range(key, start, end);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return Collections.emptySet();
|
}
|
|
|
/**
|
* 根据key获取Set中的所有值
|
*
|
* @param key 键
|
* @return
|
*/
|
public Set<Object> sGet(String key) {
|
try {
|
return redisTemplate.opsForSet().members(key);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return null;
|
}
|
}
|
|
/**
|
* 根据value从一个set中查询,是否存在
|
*
|
* @param key 键
|
* @param value 值
|
* @return true 存在 false不存在
|
*/
|
public boolean hasKeySet(String key, Object value) {
|
try {
|
if (isEmpty(key) || isEmpty(value)) {
|
return false;
|
}
|
return redisTemplate.opsForSet().isMember(key, value);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return false;
|
}
|
|
|
/**
|
* 获取set缓存的长度
|
*
|
* @param key 键
|
* @return
|
*/
|
public long getSetSize(String key) {
|
try {
|
if (isEmpty(key)) {
|
return 0L;
|
}
|
return redisTemplate.opsForSet().size(key);
|
} catch (Exception e) {
|
log.error(e.getMessage(), e);
|
}
|
return 0L;
|
}
|
|
|
/**
|
* 判断是否为空
|
*
|
* @param obj
|
* @return
|
*/
|
private boolean isEmpty(Object obj) {
|
if (Objects.isNull(obj)) {
|
return true;
|
}
|
if (obj instanceof String) {
|
String str = obj.toString();
|
if ("".equals(str.trim())) {
|
return true;
|
}
|
return false;
|
}
|
if (obj instanceof List) {
|
List<Object> list = (List<Object>) obj;
|
if (CollectionUtils.isEmpty(list)) {
|
return true;
|
}
|
return false;
|
}
|
if (obj instanceof Map) {
|
Map map = (Map) obj;
|
if (map.isEmpty()) {
|
return true;
|
}
|
return false;
|
}
|
if (obj instanceof Set) {
|
Set set = (Set) obj;
|
if (CollectionUtils.isEmpty(set)) {
|
return true;
|
}
|
return false;
|
}
|
if (obj instanceof Object[]) {
|
Object[] objs = (Object[]) obj;
|
if (objs.length <= 0) {
|
return true;
|
}
|
return false;
|
}
|
return false;
|
}
|
|
/* Set lock */
|
|
/**
|
* 加锁
|
* 参考：https://blog.csdn.net/qq_37892957/article/details/89322334
|
*
|
* @param key seckillId
|
* @param value 当前时间+超时时间
|
* @return
|
*/
|
public boolean lock(String key, String value) {
|
// 可以设置返回true
|
Boolean isLock = redisTemplate.opsForValue().setIfAbsent(key, value);
|
if (isLock) {
|
return true;
|
}
|
String currentValue = (String) redisTemplate.opsForValue().get(key);
|
// 如果锁已经过期
|
if (StringUtils.hasLength(currentValue)
|
&& Long.valueOf(currentValue) < System.currentTimeMillis()) {
|
// 获取上一个锁的时间，并设置新锁的时间
|
// 获取上一个锁的时间 如果高并发的情况可能会出现已经被修改的问题 所以多一次判断保证线程的安全
|
String oldValue = (String) redisTemplate.opsForValue().getAndSet(key, value);
|
if (StringUtils.hasLength(oldValue)
|
&& oldValue.equals(currentValue)) {
|
log.info("锁过期并返回true");
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/**
|
* 解锁
|
*
|
* @param key
|
* @return
|
*/
|
public void unlock(String key, String value) {
|
try {
|
String currentValue = (String) redisTemplate.opsForValue().get(key);
|
if (StringUtils.hasLength(currentValue)
|
&& currentValue.equals(value)) {
|
redisTemplate.opsForValue().getOperations().delete(key);
|
}
|
} catch (Exception e) {
|
log.error("redis分布式锁，解锁异常, {}", e.getMessage());
|
}
|
|
}
|
|
}
|
