package com.yxb.common.redis;
import com.yxb.base.util.CommonUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Repository;
import java.util.*;
import java.util.concurrent.TimeUnit;
@Repository("redisDao")
public class RedisDao {
@Autowired
private StringRedisTemplate redisTemplate;
private static Logger logger = LoggerFactory.getLogger(RedisDao.class);
/**
* 设置对象
* */
public <T> boolean set(String key, T value) {
boolean result = false;
try {
String str = CommonUtil.beanToString(value);
ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
valueOperations.set(key,str);
result = true;
}catch (Exception e){
logger.error("redis set error key={},value={}",key,value,e);
}
return result;
}
/**
* 带过期时间
* @param key
* @param value
* @param timeout 过期时间(单位:秒)
* @param <T>
* @return
*/
public <T> boolean set(String key,T value, Integer timeout){
boolean result = false;
String str = CommonUtil.beanToString(value);
try {
ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
valueOperations.set(key,str,timeout.longValue(), TimeUnit.SECONDS);
result = true;
}catch (Exception e){
logger.error("redis set error key={},value={},timeout={}",key,str,timeout,e);
}
return result;
}
//带过期时间类型
public <T> boolean set(String key,T value,Integer timeout, TimeUnit unit){
String str = CommonUtil.beanToString(value);
try {
ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
valueOperations.set(key,str,timeout.longValue(),unit);
}catch (Exception e){
logger.error("redis set error key={},value={},timeout={},unit={}",key,str,timeout,unit,e);
return false;
}
return true;
}
//通过key获取value
public <T> T get(String key,Class<T> clazz){
String result = null;
try{
ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
result = valueOperations.get(key);
}catch (Exception e){
logger.error("redis get error key={}",key,e);
}
T t = CommonUtil.stringToBean(result,clazz);
return t;
}
//删除key
public boolean del(String key){
boolean result = false;
try{
redisTemplate.delete(key);
result = true;
}catch (Exception e){
logger.error("redis del error key={}",key,e);
}
return result;
}
public boolean delCollection(Set<String> keys){
boolean result = false;
try{
redisTemplate.delete(keys);
result = true;
}catch (Exception e){
logger.error("redis delCollection error key={}",keys.toString(),e);
}
return result;
}
//判断key是否存在
public boolean hasKey(String key){
boolean result = false;
try{
result = redisTemplate.hasKey(key);
}catch (Exception e){
logger.error("redis hasKey error key = {}",key,e);
}
return result;
}
//递增 递减
public long increment(String key, Integer delta){
try{
ValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
return valueOperations.increment(key, delta.longValue());
}catch (Exception e){
logger.error("redis increment error key = {}, delta = {}", key, delta, e);
}
return 0;
}
/**
* 递增和递减 如果key在redis中不存在(即第一次往redis中放这个key),则设置该key的过期时间timeout
* @param key
* @param delta
* @param timeout 单位是秒
* @return
*/
public long increment(String key, Integer delta, Integer timeout){
try{
boolean hasKey = false;
if(!hasKey(key)){
hasKey = true;
}
long value = increment(key, delta);
if(hasKey){
expire(key,timeout);
}
return value;
}catch (Exception e){
logger.error("redis increment error key = {}, delta = {}", key, delta, e);
}
return 0;
}
//设置key的过期时间
public boolean expire(String key,Integer timeout){
boolean result = false;
try{
redisTemplate.expire(key,timeout.longValue(),TimeUnit.SECONDS);
result = true;
}catch (Exception e){
logger.error("redis expire error key = {}", key, e);
}
return result;
}
//设置key的过期时间(自定义时间单位)
public boolean expire(String key, Integer timeout, TimeUnit timeUnit){
boolean result = false;
try{
redisTemplate.expire(key,timeout.longValue(),timeUnit);
result = true;
}catch (Exception e){
logger.error("redis expire error key = {}", key, e);
}
return result;
}
//获取key的过期时间 返回秒
public long ttl(String key){
try{
long time = redisTemplate.getExpire(key,TimeUnit.SECONDS);
return time;
}catch (Exception e){
logger.error("redis expire error key = {}", key, e);
}
return (long)0;
}
//--------------Map-----------------//
//put整个map
public boolean putAll(String key, Map map){
boolean result = false;
try{
HashOperations<String, String, String> options = redisTemplate.opsForHash();
options.putAll(key,map);
result = true;
}catch (Exception e){
logger.error("redis putAll error key={},map={}",key,map,e);
}
return result;
}
//带过期时间 单位是秒
public boolean putAll(String key, Map map,Integer timeout){
boolean result = false;
try{
HashOperations<String, String, String> options = redisTemplate.opsForHash();
options.putAll(key,map);
redisTemplate.expire(key,timeout.longValue(),TimeUnit.SECONDS);
result = true;
}catch (Exception e){
logger.error("redis putAll error key={},map={}",key,map,e);
}
return result;
}
//map中放单个键值对
public boolean put(String key,String hashKey,String hashValue){
boolean result = false;
try{
HashOperations<String, String, String> options = redisTemplate.opsForHash();
options.put(key,hashKey,hashValue);
result = true;
}catch (Exception e){
logger.error("redis put error key={},hashKey={},hashValue={}",key,hashKey,hashValue,e);
}
return result;
}
//判断map中hashKey是否存在
public boolean hasKey(String key,String hashKey){
try{
HashOperations<String, String, String> options = redisTemplate.opsForHash();
return options.hasKey(key,hashKey);
}catch (Exception e){
logger.error("redis hasKey error key={},hashKey={}",key,hashKey,e);
}
return false;
}
//get 获取map中键的值
public String getHashValue(String key,String hashKey){
try{
HashOperations<String, String, String> options = redisTemplate.opsForHash();
return options.get(key,hashKey);
}catch (Exception e){
logger.error("redis get error key={},hashKey={}",key,hashKey,e);
}
return null;
}
//multiGet 获取多个value
public List<String> multiGet(String key, Collection<String> fields){
try{
HashOperations<String, String, String> options = redisTemplate.opsForHash();
return options.multiGet(key,fields);
}catch(Exception e){
logger.error("redis multiGet error key={},hashKey={}",key,fields,e);
}
return null;
}
//delete 删除map中的key 可以是多个
public long delete(String key,String... hashKeys){
try{
HashOperations<String, String, String> options = redisTemplate.opsForHash();
return options.delete(key,hashKeys);
}catch (Exception e){
logger.error("redis delete error key={},hashKeys={}",key,hashKeys,e);
}
return 0;
}
//increment map中的key对应的value 做递增操作
public long increment(String key,String hashKey,Integer delta){
try {
HashOperations<String, String, String> options = redisTemplate.opsForHash();
return options.increment(key,hashKey,delta.longValue());
}catch (Exception e){
logger.error("redis delete error key={},hashKey={},delta={}",key,hashKey,delta,e);
}
return 0;
}
//keys 获取map中的所有的keys
public Set<String> keys(String key){
try{
HashOperations<String, String, String> options = redisTemplate.opsForHash();
return redisTemplate.keys(key);
// return options.keys(key);
}catch (Exception e){
logger.error("redis keys error key={}",key,e);
}
return null;
}
//keys 获取map中的所有的map
public Map<String,String> entries(String key){
try{
HashOperations<String, String, String> options = redisTemplate.opsForHash();
return options.entries(key);
}catch (Exception e){
logger.error("redis keys error key={}",key,e);
}
return null;
}
/**
* 往redis中放入set
* @param key
* @param time 过期时间 可传null null代表不设置过期时间
* @param values
* @return
*/
public long sAdd(String key,Integer time,String... values){
try{
SetOperations<String,String> setOperations = redisTemplate.opsForSet();
//the number of elements that were added to the set,
// not including all the elements already present into the set.
long n = setOperations.add(key,values);
if(time != null){
expire(key,time);
}
return n;
}catch (Exception e){
logger.error("redis set add error ",e);
}
return 0;
}
//判断value 是否是 keySet中的元素
public boolean sIsMember(String key,String value){
try{
SetOperations<String,String> setOperations = redisTemplate.opsForSet();
return setOperations.isMember(key,value);
}catch (InvalidDataAccessApiUsageException e1){
this.del(key);
}catch(Exception e){
logger.error("redis set sisMember error",e);
}
return false;
}
//redis set 移除
public long sRem(String key,String... hashKeys){
try {
SetOperations<String,String> setOperations = redisTemplate.opsForSet();
//the number of members that were removed from the set,
// not including non existing members
return setOperations.remove(key,hashKeys);
}catch (Exception e){
logger.error("redis set sRem error",e);
}
return 0;
}
//the cardinality (number of elements) of the set, or 0 if key does not exist.
public long sCard(String key){
try{
SetOperations<String,String> setOperations = redisTemplate.opsForSet();
long n = setOperations.size(key);
// setOperations.members();
return n;
}catch(Exception e){
logger.error("redis set sSize error ",e);
}
return 0;
}
/**
* 返回当前key下的集合
* @param key
* @return
*/
public Set<String> members(String key){
Set<String> set = null;
try {
SetOperations<String, String> setOperations = redisTemplate.opsForSet();
set = setOperations.members(key);
return set;
}catch (InvalidDataAccessApiUsageException e1){
this.del(key);
}catch(Exception e){
logger.error("redis members sSize error ",e);
}
return set;
}
/****************************** ZSET start ************************/
/**
* 往zset中放入一个value
* @param key redis的key
* @param value redis中保存的value
* @param score value对应的分值
* @return
*/
public boolean zAdd(String key,String value,double score){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
return zSetOperations.add(key,value,score);
}catch(Exception e){
logger.error("redis zset zadd error e:{}",e);
}
return false;
}
/**
* 从zset中删除一个value
* @param key redis的key
* @param value redis的key中要删除的value
* @return
*/
public boolean zRem(String key,String... value){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
long row = zSetOperations.remove(key,value);
return row > 0 ?true:false;
}catch(Exception e){
logger.error("redis zset remove error e:{}",e);
}
return false;
}
/**
* 返回value在redis的key中的排名 有小到大的排名 分数最小的,排名为1
* @param key redis中的key
* @param value
* @return
*/
public long zRank(String key,String value){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
return (zSetOperations.rank(key,value)+1);
}catch(Exception e){
logger.error("redis zset zRank error e:{}",e);
}
return 0;
}
/**
* 返回value在redis的key中的排名,有大到小排名 分数最大的,排名为1
* @param key redis中的key
* @param value
* @return
*/
public long zRevRank(String key,String value){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
Long res = zSetOperations.reverseRank(key,value);
if(null == res){
return 0;
}else
return res + 1;
}catch(Exception e){
logger.error("redis zset zRevRank error e:{}",e);
}
return 0;
}
/**
* 返回redis的key中的成员数
* @param key
* @return
*/
public long zCard(String key){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
return zSetOperations.zCard(key);
}catch (Exception e){
logger.error("redis zset zCard error e:{}",e);
}
return 0;
}
/**
* 在redis的key中对应的value 增加 delta分值
* @param key
* @param value
* @param delta
* @return
*/
public double zIncrby(String key,String value,double delta){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
return zSetOperations.incrementScore(key,value,delta);
}catch (Exception e){
logger.error("redis zset zCard error e:{}",e);
}
return 0;
}
public double zIncrby(String key,String value,double delta,Long secend){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
double d = zSetOperations.incrementScore(key,value,delta);
redisTemplate.expire(key,secend,TimeUnit.SECONDS);
}catch (Exception e){
logger.error("redis zset zCard error e:{}",e);
}
return 0;
}
/**
* 返回redis的key中从start到end结束的集合 start,end表示的是下标 下标从0开始 返回的数据中包含下标为start和end的值
* 其中-1代表最后一个成员,-2代表倒数第二个成员 start=0 end=-1 代表返回整个有序集合
* 注意:该接口返回的是有小到大的排列顺序 如需返回有大到小 请调用 zRevrange 接口
* @param key
* @param start
* @param end
* @return
*/
public Set<String> zRange(String key,Integer start,Integer end){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
return zSetOperations.range(key,start.longValue(),end.longValue());
}catch (Exception e){
logger.error("redis zset zRange error e:{}",e);
}
return new HashSet<String>();
}
public Map<String,Double> zRangeWithScores(String key,Integer start,Integer end){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
Set<ZSetOperations.TypedTuple<String>> set = zSetOperations.rangeWithScores(key,start.longValue(),end.longValue());
Map<String,Double> idAndScores = new HashMap<>();
for (ZSetOperations.TypedTuple<String> z : set){
idAndScores.put(z.getValue(),z.getScore());
}
return idAndScores;
}catch (Exception e){
logger.error("redis zset zRange error e:{}",e);
}
return new HashMap<>();
}
/**
* 返回redis的key中从start到end结束的集合 start,end表示的是下标 下标从0开始 返回的数据中包含下标为start和end的值
* 其中-1代表最后一个成员,-2代表倒数第二个成员 start=0 end=-1 代表返回整个有序集合
* 注意:该接口返回的是有大到小的排列顺序 如需返回有小到大 请调用 zRange 接口
* @param key
* @param start
* @param end
* @return
*/
public Set<String> zRevrange(String key,Integer start,Integer end){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
return zSetOperations.reverseRange(key,start.longValue(),end.longValue());
}catch (Exception e){
logger.error("redis zset zRange error e:{}",e);
}
return new HashSet<String>();
}
/**
* 返回value在key中排名的分数值
* @param key
* @param value
* @return
*/
public double zScore(String key,String value){
try{
ZSetOperations<String,String> zSetOperations = redisTemplate.opsForZSet();
Double db = zSetOperations.score(key,value);
return db==null?0:db;
}catch(Exception e){
logger.error("redis zset zscore error e:{}",e);
}
return 0;
}
/****************************** ZSET end ************************/
/******************************List start************************/
/**
* 类似于压栈操作,将元素放入头部
* @param key
* @param object
* @return
*/
public long leftPush(String key,Object object){
try{
ListOperations listOperations = redisTemplate.opsForList();
long n = listOperations.leftPush(key,object);
return n;
}catch (Exception e){
logger.error("redis leftPush error e:{}",e);
}
return 0;
}
/**
* 将元素push在list的尾部
* @param key
* @param object
* @return
*/
public long rightPush(String key,Object object){
try{
ListOperations listOperations = redisTemplate.opsForList();
long n = listOperations.rightPush(key,object);
return n;
}catch (Exception e){
logger.error("redis leftPush error e:{}",e);
}
return 0;
}
/**
* 删除尾部数据
* @param key
* @return
*/
public Object rightPop(String key){
try{
ListOperations listOperations = redisTemplate.opsForList();
Object o = listOperations.rightPop(key);
return o;
}catch (Exception e){
logger.error("redis leftPush error e:{}",e);
}
return null;
}
/**
* 删除首位数据
* @param key
* @return
*/
public Object leftPop(String key){
try{
ListOperations listOperations = redisTemplate.opsForList();
Object o = listOperations.leftPop(key);
return o;
}catch (Exception e){
logger.error("redis leftPop error e:{}",e);
}
return null;
}
/**
* 通过key和索引获取对象
* @param key
* @param index
* @return
*/
public Object getFromList(String key,Integer index){
try{
ListOperations listOperations = redisTemplate.opsForList();
Object o = listOperations.index(key,index.longValue());
return o;
}catch (Exception e){
logger.error("redis getFromList error e:{}",e);
}
return null;
}
/**
* 获取列表
* @param key
* @param start
* @param end
* @return
*/
public List<Object> range(String key,Integer start,Integer end){
try{
ListOperations listOperations = redisTemplate.opsForList();
List<Object> list = listOperations.range(key,start.longValue(),end.longValue());
return list;
}catch (Exception e){
logger.error("redis range error e:{}",e);
}
return null;
}
/**
* 获取列表全部
* @param key
* @return
*/
public List<Object> range(String key){
try{
ListOperations listOperations = redisTemplate.opsForList();
List<Object> list = listOperations.range(key, 0, -1);
return list;
}catch (Exception e){
logger.error("redis range error e:{}",e);
}
return null;
}
/**
* 删除集合指定元素
* @param key 集合key
* @param itme 集合中的指定元素
* @return
*/
public Long remove(String key, String itme) {
try {
ListOperations listOperations = redisTemplate.opsForList();
Long removeNum = listOperations.remove(key, 0, itme);
return removeNum;
} catch (Exception e) {
logger.error("redis range error e:{}",e);
}
return 0l;
}
/**
* 获取集合长度
* @param key
* @return
*/
public Long size(String key){
try{
ListOperations listOperations = redisTemplate.opsForList();
long n = listOperations.size(key);
return n;
}catch (Exception e){
logger.error("redis size error e:{}",e);
}
return null;
}
public Set<String> getKeysByLike(String cachePrefix) {
return redisTemplate.keys(cachePrefix);
}
/**
* 获取key类型
* @param key
* @return
*/
public DataType getKeysType(String key) {
return redisTemplate.type(key);
}
}
redis工具类
最新推荐文章于 2021-01-03 01:16:12 发布