redis工具类

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);
    }




}