redisTemplate的基本操作

通用方法 

    //============================通用方法=============================//
    //删除key
    public void delete(String key){
        redisTemplate.delete(key);
    }
    //    删除多个key
    public void deleteKey (String ...keys){
        redisTemplate.delete(keys);
    }
    //    指定key的失效时间
    public void expire(String key,long time){
        redisTemplate.expire(key,time,TimeUnit.MINUTES);
    }
    //    根据key获取过期时间
    public long getExpire(String key){
        Long expire = redisTemplate.getExpire(key);
        return expire;
    }
    //    判断key是否存在
    public boolean hasKey(String key){
        return redisTemplate.hasKey(key);
    }

String操作方法

//============================String操作方法=============================//
    /**设置值*/
    public void setString(String key,String value){
	    //点进源码查看、二者本身无区别，只是操作便捷性   分步骤看
	    //ValueOperations是普通的操作对象
	    //BoundValueOperations是绑定好Key的ValueOperations对象    
        //也就是BoundValueOperations对象
        redisTemplate.boundValueOps(key).set(value);
        redisTemplate.opsForValue().set(key,value);

        //2、通过BoundValueOperations设置值
        BoundValueOperations stringKey = redisTemplate.boundValueOps(key);
        stringKey.set(value);
        stringKey.set(value,1, TimeUnit.MINUTES);

        //3、通过ValueOperations设置值
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set(key,value);
        ops.set(key,value,1, TimeUnit.MINUTES);
    }
    /**设置某个key过期时间*/
    public void setExpire(String key,long time,TimeUnit timeType){
        //直接传入key操作
        redisTemplate.expire(key,time,timeType);
    }
    /**获取key值*/
    public String getKey(String key){
        return (String) redisTemplate.opsForValue().get(key);
    }
    /**设置数据递增递减(传入正负数)*/
    public void increment(String key,long l){
        redisTemplate.opsForValue().increment(key,l);
    }

Hash类型操作方法

 //============================Hash类型操作方法=============================//
    public void setHash(String hashKey,String key,String value){
        redisTemplate.opsForHash().put(hashKey, key, value);
    }
    /**直接丢map进去*/
    public void setHashByMap(String hashKey,Map<String,String> value){
        redisTemplate.opsForHash().putAll(hashKey,value);
    }
    /**提取hash的所有key*/
    public Set<String> getAllHashKey(String hashKey){
        return redisTemplate.opsForHash().keys(hashKey);
    }
    /**提取hash的所有value*/
    public Set<String> getAllHashValue(String hashKey){
        return redisTemplate.opsForHash().keys(hashKey);
    }
    /**根据key提取value值*/
    public String getHashValue(String hashKey,String key){
        return (String)redisTemplate.opsForHash().get(hashKey,key);
    }
    /**根据key提取所有Hash键值对*/
    public Map<String,String> getHashMap(String hashKey){
        return redisTemplate.opsForHash().entries(hashKey);
    }
    /**删除某个Hash值里面指定的key*/
    public Long deleteSmallKey(String hashKey,String... keys){
        return redisTemplate.opsForHash().delete(hashKey,keys);
    }
    /**删除整个Hash值*/
    public Boolean deleteBigKey(String key){
        return redisTemplate.delete(key);
    }
    /**判断某个Hash值里面是否含有指定的key*/
    public Boolean hasKeyInHash(String hashKey,String key){
        return redisTemplate.opsForHash().hasKey(hashKey,key);
    }

Set类型操作方法

//创建set并设置值
    public Long addSetValue(String key ,Object... values){
        return redisTemplate.opsForSet().add(key, values);
    }
    //获取set的值
    public Set getSetValue(String key){
        return redisTemplate.opsForSet().members(key);
    }
    //查询set中是否存在该值
    public Boolean hasValueInSet(String key,String value){
        return redisTemplate.opsForSet().isMember(key,value);
    }
    //查询set长度
    public Long getSetSize(String key){
        return redisTemplate.opsForSet().size(key);
    }
    //从set中移除某些个元素
    public Long removeFromSet(String key,String... values){
        return redisTemplate.opsForSet().remove(key,values);
    }
    //移除整个set
    public Boolean removeSet(String key){
        return redisTemplate.delete(key);
    }

List类型操作方法

//从头部push进一个元素   类似于链表往左边加一个元素
    public Long leftPushList(String key,String value){
        return redisTemplate.opsForList().leftPush(key,value);
    }
    //从尾部push进一个元素   类似于链表往右边加一个元素
    public Long rightPushList(String key,String value){
        return redisTemplate.opsForList().rightPush(key,value);
    }

    //从头部push进一个list   类似于链表往左边加多个元素
    public Long leftPushList(String key,List<String> value){
        return redisTemplate.opsForList().leftPushAll(key,value);
    }

    //从尾部push进一个list   类似于链表往右边加多个元素
    public Long rightPushList(String key,List<String> value){
        return redisTemplate.opsForList().rightPushAll(key,value);
    }

    //根据索引获取所有元素
    public List getListByIndex(String key,int begin,int end){
        return redisTemplate.opsForList().range(key,begin,end);
    }
    //获取所有元素
    public List getList(String key){
        return getListByIndex(key,0,-1);
    }
    //从左侧拿出一个元素  (并且会将该元素删除)     类似于消费者消费
    public String leftPop(String key){
        return (String) redisTemplate.opsForList().leftPop(key);
    }
    //从右侧拿出一个元素  (并且会将该元素删除)     类似于消费者消费
    public String rightPop(String key){
        return (String) redisTemplate.opsForList().rightPop(key);
    }
    //根据索引获取list中的元素  (不会将该元素删除)
    public String getItemByIndex(String key,int index){
        return (String) redisTemplate.opsForList().index(key,index);
    }
    //获取list的长度
    public Long getListSize(String key){
        return redisTemplate.opsForList().size(key);
    }
    //根据索引修改list里面的某个值
    public void setListValue(String key,int index,String value){
        redisTemplate.opsForList().set(key,index,value);
    }
    //移除多个值为value的list元素
    //  [100, 100, 100, 100] 移除3个值为100的元素  ==> [100]
    public void removeValuesFromList(String key,int count,String value){
        redisTemplate.opsForList().remove(key,count,value);
    }

Zset有序集合操作方法

//往Zset中添加元素
    public Boolean addZsetItem(String key,String value,Double score){
        return redisTemplate.opsForZSet().add(key, value, score);
    }
    //根据索引获取Zset的元素
    public Set<String> getZset(String key,int begin,int end){
        return redisTemplate.opsForZSet().range(key,begin,end);
    }
    //获取Zset的所有元素
    public Set<String> getZset(String key){
        return getZset(key,0,-1);
    }
    // 往Zset中添加多个元素
    // DefaultTypedTuple<String> p1 = new DefaultTypedTuple<>("value1", 1.0);
    public Long addZsetList(String key,List<DefaultTypedTuple<String>> list){
        HashSet<DefaultTypedTuple<String>> defaultTypedTuples = new HashSet<>(list);
        return redisTemplate.opsForZSet().add(key,defaultTypedTuples);
    }
    //获取Zset中指定元素的分数
    public Double getScore(String key,String value){
        return redisTemplate.opsForZSet().score(key,value);
    }
    //获取Zset集合的大小
    public Long getSize(String key){
        return redisTemplate.opsForZSet().size(key);
    }
    //获取Zset指定分数内集合的大小
    public Long getSizeByScore(String key,Double begin,Double end){
        return redisTemplate.opsForZSet().count(key,begin,end);
    }

    //获取Zset指定分数内的集合
    public Set getZsetByScore(String key,Double begin,Double end){
        return redisTemplate.opsForZSet().rangeByScore(key,begin,end);
    }

    //根据 Index 获取Zset集合 (包括分数)
    public Set<ZSetOperations.TypedTuple<String>> getZsetWithScore(String key, Long begin, Long end){
        return redisTemplate.opsForZSet().rangeWithScores(key,begin, end);
    }
    //获取Zset集合
    public Set<ZSetOperations.TypedTuple<String>> getZsetWithScore(String key){
        return getZsetWithScore(key,0L, -1L);
    }
    //获取指定成员的排名   从大到小排   a,b,c,d     a排0
    public Long zSetRank(String key,String value){
        return redisTemplate.opsForZSet().rank(key,value);
    }
    //获取指定成员的排名   从大到小排   a,b,c,d     a排3
    public Long zSetReverseRank(String key,String value){
        return redisTemplate.opsForZSet().reverseRank(key,value);
    }
    //从集合中删除指定元素
    public Long zSetRemove(String key,String... value){
        return redisTemplate.opsForZSet().remove(key,value);
    }
    //从集合中删除指定范围索引元素
    public Long zSetRemoveByIndex(String key,Long begin,Long end){
        return redisTemplate.opsForZSet().removeRange(key,begin,end);
    }
    //从集合中删除指定范围分数元素
    public Long zSetRemoveByScore(String key,Double begin,Double end){
        return redisTemplate.opsForZSet().removeRangeByScore(key,begin,end);
    }
    //修改指定元素的分数
    public Double incrementScore(String key,String value,Double score){
        return redisTemplate.opsForZSet().incrementScore(key,value,score);
    }