@Service("redisCacheUtil")
public class RedisCacheUtil {
private static Logger logger = LoggerFactory.getLogger(RedisCacheUtil.class);
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Resource(name = "redisTemplate")
private SetOperations<String, Object> setOps;
@Resource(name = "redisTemplate")
private HashOperations<String, String, Object> hashOps;
private static String redisCode = "utf-8";
/**
* 删除key值的所有数据，包括列表，键值对，hash等
*
* @param key
*/
public void delete(String key) {
redisTemplate.delete(key);
}
public void deleteKeys(Collection<String> keys) {
redisTemplate.delete(keys);
}
public void set(final byte[] key, final byte[] value, final long liveTime) {
redisTemplate.execute(new RedisCallback<Long>() {
public Long doInRedis(RedisConnection connection) throws DataAccessException {
connection.set(key, value);
if (liveTime > 0) {
}
return 1L;
}
});
}
/**
* 设置key,value对
*
* @param key
* @param value
*/
public void set(String key, String value, long liveTime) {
set(key.getBytes(), value.getBytes(), liveTime);
}
public void set(String key, String value) {
this.set(key, value, 0L);
}
/**
* redis incr的使用，将键的整数值增加
*
* @param key
* @param step
* @return
*/
public long setIncr(final String key, long step) {
return redisTemplate.opsForValue().increment(key, step);
}
/**
* 根据key获取value
*
* @param key
* @return
*/
public String get(final String key) {
return redisTemplate.execute(new RedisCallback<String>() {
public String doInRedis(RedisConnection connection) throws DataAccessException {
try {
return new String(connection.get(key.getBytes()), redisCode);
} catch (UnsupportedEncodingException e) {
logger.error(e.getMessage(), e);
}
return "";
}
});
}
public Set<String> getKeys(final String key) {
return redisTemplate.keys(key);
}
public long getIncrValue(final String key) {
return redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection) throws DataAccessException {
RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
byte[] rowkey = serializer.serialize(key);
byte[] rowval = connection.get(rowkey);
try {
String val = serializer.deserialize(rowval);
return Long.parseLong(val);
} catch (Exception e) {
return 0L;
}
}
});
}
public void expire(final String key, final long timeout, final TimeUnit unit) {
redisTemplate.expire(key, timeout, unit);
}
/**
* 向列表头部添加值
*
* @param key
* @param value
*/
public void addListFromHeader(String key, Object obj) {
redisTemplate.opsForList().leftPush(key, obj);
}
/**
* 添加列表
*
* @param key
* @param value
*/
public void addList(String key, Object value) {
redisTemplate.opsForList().rightPush(key, value);
}
/**
* 获取列表数据
*
* @param key
* @param start
* @param end
* @return
*/
public Object listPop(String key, int start, int end) {
List<Object> objs = redisTemplate.opsForList().range(key, start, end);
return objs;
}
/**
* 获取列表长度
*
* @param key
* @return
*/
public Long getListLength(String key) {
return redisTemplate.opsForList().size(key);
}
/**
* 获取列表最后一位值,并删除
*
* @param key
* @return
*/
public Object popListLast(String key) {
return redisTemplate.opsForList().rightPop(key);
}
/**
* 删除列表某一位值
*
* @param key
* @param i
* @param value
*/
public Long delList(String key, long i, Object value) {
return redisTemplate.opsForList().remove(key, i, value);
}
/**
* 获取列表第一位，并删除
*
* @param key
* @return
*/
public Object popListFirst(String key) {
return redisTemplate.opsForList().leftPop(key);
}
/**
* 设置某一位值
*
* @param key
* @param index
* @param value
*/
public void setListByIndex(String key, int index, Object value) {
redisTemplate.opsForList().set(key, index, value);
}
/**
* 向列表尾部追加一组数据
*
* @param key
* @param values
*/
public void addListBundle(String key, List<Object> values) {
redisTemplate.opsForList().rightPushAll(key, values);
}
/**
* 向列表头部追加一组数据
*
* @param key
* @param values
*/
public void addListBundleFromHeader(String key, List<Object> values) {
redisTemplate.opsForList().leftPushAll(key, values);
}
/**
* 获取列表某一位值
*/
public Object getListByIndex(String key, long index) {
return redisTemplate.opsForList().index(key, index);
}
/**
*
* 功能描述: (Set集合)将一个或多个 member 元素加入到集合 key 当中，已经存在于集合的 member 元素将被忽略。
* 〈功能详细描述〉
*
* @param key
* @param values
* @since [产品/模块版本](可选)
*/
public void addSet(String key, Object... values) {
setOps.add(key, values);
}
/**
*
* 功能描述:(Set集合)移除集合 key 中的一个或多个 member 元素，不存在的 member 元素会被忽略。
* 〈功能详细描述〉
*
* @param key
* @param values
* @since [产品/模块版本](可选)
*/
public void removeSet(String key, Object... values) {
setOps.remove(key, values);
}
/**
*
* 功能描述:(Set集合)返回集合 key 中的所有成员
* 〈功能详细描述〉
*
* @param key
* @return
* @since [产品/模块版本](可选)
*/
public Set<Object> getMembers(String key) {
Set<Object> members = setOps.members(key);
return members;
}
/**
* set Hash列表值(String,Long)
*/
public void setAllHash(String key, Map<String, String> m) {
hashOps.putAll(key, m);
}
/**
* set Object对象到hash表,字段必须为基本数据类型或包装类,已经时间和String类型
*/
public void setObjectToHash(String key, Object obj) {
Map<String, String> stringMap = EntityUtils.objectToHash(obj);
hashOps.putAll(key, stringMap);
}
/**
* get Object对象到 根据hashKey;
*/
public <T> T getHashToObjectBykey(String key, Class t) {
Map<String, Object> entries = hashOps.entries(key);
return EntityUtils.hashToObject2(entries, t);
}
/**
* get Hash列表值
*/
public Map<String, Object> getAllHash(String key) {
return hashOps.entries(key);
}
/**
* 判断某个key是否存在
*/
public Boolean isExist(String key) {
return redisTemplate.hasKey(key);
}
/**
* 向hash指定key加一
*/
public void incrHash(String key, String hashKey, Integer i) {
hashOps.increment(key, hashKey, i);
}
/**
* 增加hash字段
*/
public void putHashKey(String key, String hashKey, String value) {
hashOps.put(key, hashKey, value);
}
/**
* 获取hash字段
*/
public String getHashKey(String key, String hashKey) {
return (String) hashOps.get(key, hashKey);
}
/**
* 删除hash字段
*/
public void delHashKey(String key, String hashKey) {
hashOps.delete(key, hashKey);
}
// 当 key 不存在时，返回 -2 。 当 key 存在但没有设置剩余生存时间时，返回 -1 。 否则，以秒为单位，返回 key 的剩余生存时间
public long getExpire(String key) {
return redisTemplate.getExpire(key);
}
/**
* 增加hash字段
*/
public void addHashKey(String key, String hashKey, Object value) {
hashOps.put(key, hashKey, value);
}
/**
* 获取hash字段
*/
public Object getHashValse(String key, String hashKey) {
return hashOps.get(key, hashKey);
}
// redisTemplate操作 zset的一些 封装;
/**
* 给指定的集合添加 字段和分数
*/
public void addZset(String key, Object var, double score) {
redisTemplate.opsForZSet().add(key, var, score);
}
/**
* 批量添加, 实现了ZSetOperations.TypedTuple<>接口的的set集合 对象内要有getVule,和getSorce方法;
*
* @param key
* @param var2
*/
public void addZset(String key, Set<ZSetOperations.TypedTuple<Object>> var2) {
redisTemplate.opsForZSet().add(key, var2);
}
/**
* 给指定的集合移除字段
*/
public void removeZset(String key, Object var) {
redisTemplate.opsForZSet().remove(key, var);
}
/**
* 获取排序后的结果
*/
public Set<Object> reverseRange(final String key, final long start, final long end) {
Set<Object> objects = redisTemplate.opsForZSet().reverseRange(key, start, end);
return objects;
}
}
