Redis工具类（redisTemplate）以及 redisTemplate 的用法

冷不防 2023-09-28 14:08 122阅读 0赞

## Redis工具类（redisTemplate）以及 redisTemplate 的用法 ##

### redisTemplate 的用法以及与Jedis的对照 ###

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>Jedis</th> 
   <th>StringRedisTemplate</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>String</strong></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>设置</td> 
   <td>set(“k”,“v”)</td> 
   <td>template.opsForValue().set(“k”,“v”)</td> 
  </tr> 
  <tr> 
   <td>获取</td> 
   <td>get(“k”)</td> 
   <td>template.opsForValue().get(“k”)</td> 
  </tr> 
  <tr> 
   <td>增1</td> 
   <td>incr(“k”)</td> 
   <td>template.boundValueOps(“k”).increment(1)</td> 
  </tr> 
  <tr> 
   <td>减1</td> 
   <td>decr(“k”)</td> 
   <td>template.boundValueOps(“k”).increment(-1)</td> 
  </tr> 
  <tr> 
   <td>设置时间</td> 
   <td>setex(“k”,seconds,“v”)</td> 
   <td>template.opsForValue().set(“k”,“v”,20, TimeUnit.SECONDS)</td> 
  </tr> 
  <tr> 
   <td>不存在 就设置</td> 
   <td>setnx(“k”,“v”)</td> 
   <td>template.opsForValue().setIfAbsent(“k”, “v”)</td> 
  </tr> 
  <tr> 
   <td>获取过期时间</td> 
   <td>ttl(“k”)</td> 
   <td>template.getExpire(“k”)</td> 
  </tr> 
  <tr> 
   <td>删除</td> 
   <td>del(“k”)</td> 
   <td>template.delete(“k”)</td> 
  </tr> 
  <tr> 
   <td><strong>Hash</strong></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>设置</td> 
   <td>jedis.hset(“pig”,“name”,“peiqi”);</td> 
   <td>template.opsForHash().put(“pig”,“name”,“peiqi”)</td> 
  </tr> 
  <tr> 
   <td>获取</td> 
   <td>jedis.hget(“pig”,“name”)</td> 
   <td>template.opsForHash().get(“pig”, “name”) 获取所有template.opsForHash().values(“pig”)</td> 
  </tr> 
  <tr> 
   <td>删除</td> 
   <td>jedis.hdel(“pig”,“name”)</td> 
   <td>template.opsForHash().delete(“pig”,“name”)</td> 
  </tr> 
  <tr> 
   <td>判断是否存在</td> 
   <td>jedis.hexists(“pig”,“name”)</td> 
   <td>template.opsForHash().hasKey(“pig”,“name”)</td> 
  </tr> 
  <tr> 
   <td><strong>List</strong></td> 
   <td>左/右不做区分</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>添加</td> 
   <td>rpush(“k”,“v”)</td> 
   <td>template.opsForList().rightPush(“k”,“v”)</td> 
  </tr> 
  <tr> 
   <td>移出</td> 
   <td>rpop(“list”)</td> 
   <td>template.opsForList().rightPop(“k”)</td> 
  </tr> 
  <tr> 
   <td>长度</td> 
   <td>llen(“k”)</td> 
   <td>template.opsForList().size(“k”)</td> 
  </tr> 
  <tr> 
   <td>获取</td> 
   <td>lrange(“list”,0,-1) //-1全部</td> 
   <td>template.opsForList().range(“list”, 0, -1)</td> 
  </tr> 
  <tr> 
   <td><strong>Set</strong></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>添加</td> 
   <td>sadd(“k”,“v”)</td> 
   <td>template.opsForSet().add(“k”,“v”)</td> 
  </tr> 
  <tr> 
   <td>值移除</td> 
   <td>srem(“k”,“v”)</td> 
   <td>template.opsForSet().remove(“k”,“v”)</td> 
  </tr> 
  <tr> 
   <td>直接移</td> 
   <td>spop(“k”)</td> 
   <td>template.opsForSet().pop(“k”)</td> 
  </tr> 
  <tr> 
   <td>长度</td> 
   <td>scard(“k”)</td> 
   <td>template.opsForSet().size(“k”)</td> 
  </tr> 
  <tr> 
   <td>交集</td> 
   <td>sinter(“k1”,“k2” )</td> 
   <td>template.opsForSet().intersect(“k”, “k2”)</td> 
  </tr> 
  <tr> 
   <td>并集</td> 
   <td>sunion(“k1”,“k2” )</td> 
   <td>template.opsForSet().union(“k”, “k2”)</td> 
  </tr> 
  <tr> 
   <td>差集</td> 
   <td>sdiff(“k1”,“k2” )</td> 
   <td>template.opsForSet().difference(“k”, “k2”)</td> 
  </tr> 
  <tr> 
   <td><strong>Zset</strong></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>增加</td> 
   <td>zadd(“k”,1,“a”)</td> 
   <td>template.opsForZSet().add(“k”,“aa”,12)</td> 
  </tr> 
  <tr> 
   <td>排名结果</td> 
   <td>zrevrange(“k”, 0, -1)</td> 
   <td>template.opsForZSet().reverseRange(“k”, 0, -1)</td> 
  </tr> 
  <tr> 
   <td>排名分数</td> 
   <td>zrevrangeByScoreWithScores(“k”, 12, 10);</td> 
   <td>template.opsForZSet().reverseRangeByScore(“k”, 1, 100)</td> 
  </tr> 
  <tr> 
   <td>修改分数</td> 
   <td>zincrby(“k”,20,“a”)</td> 
   <td>template.opsForZSet().incrementScore(“k”,“aa”,19)</td> 
  </tr> 
  <tr> 
   <td>数量</td> 
   <td>zcard(“k”)</td> 
   <td>template.opsForZSet().zCard(“k”)</td> 
  </tr> 
  <tr> 
   <td>获取排名</td> 
   <td>zrank(“k”,“a”)</td> 
   <td>template.opsForZSet().rank(“k”,“aa”)</td> 
  </tr> 
 </tbody> 
</table>

### Redis工具类（redisTemplate） ###

/**
     * Redis工具类
     * @author PING.AN.ZHAO
     * @date   2022年7月8日
     */
    @Component
    public final class RedisUtil {
        
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        // =============================common============================
        /**
         * 指定缓存失效时间
         * @param key 键
         * @param time 时间(秒)
         * @return
         */
        public boolean expire(String key, long time) {
        
            try {
        
                if (time > 0) {
        
                    redisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据key 获取过期时间
         * @param key 键 不能为null
         * @return 时间(秒) 返回0代表为永久有效
         */
        public long getExpire(String key) {
        
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
        /**
         * 判断key是否存在
         * @param key 键
         * @return true 存在 false不存在
         */
        public boolean hasKey(String key) {
        
            try {
        
                return redisTemplate.hasKey(key);
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除缓存
         * @param key 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public void del(String... key) {
        
            if (key != null && key.length > 0) {
        
                if (key.length == 1) {
        
                    redisTemplate.delete(key[0]);
                } else {
        
                    redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
                }
            }
        }
    
    
        // ============================= key相关操作 =============================
    
    
        /**
         * 可以实现分布式锁
         * @param key
         * @param value
         * @return key存在则返回false，不存在则存储key-value并返回true
         */
        public boolean setnx(String key,String value) {
        
            return Boolean.TRUE.equals(redisTemplate.opsForValue().setIfAbsent(key, value));
        }
    
        /**
         * 可以实现分布式锁
         * @param key
         * @param value
         * @param timeout
         * @param unit
         * @return key存在则返回false，不存在则存储key-value并返回true
         */
        public boolean setnx(String key,String value, long timeout, TimeUnit unit) {
        
            return Boolean.TRUE.equals(redisTemplate.opsForValue().setIfAbsent(key, value, timeout, unit));
        }
    
    
    
        /**
         * 删除key
         *
         * @param key
         */
        public void delete(String key) {
        
            redisTemplate.delete(key);
        }
    
        /**
         * 批量删除key
         *
         * @param keys
         */
        public void delete(Collection<String> keys) {
        
            redisTemplate.delete(keys);
        }
    
        /**
         * 序列化key
         *
         * @param key
         * @return
         */
        public byte[] dump(String key) {
        
            return redisTemplate.dump(key);
        }
    
        /**
         * 设置过期时间
         *
         * @param key
         * @param timeout
         * @param unit
         * @return
         */
        public Boolean expire(String key, long timeout, TimeUnit unit) {
        
            return redisTemplate.expire(key, timeout, unit);
        }
    
        /**
         * 设置过期时间
         *
         * @param key
         * @param date
         * @return
         */
        public Boolean expireAt(String key, Date date) {
        
            return redisTemplate.expireAt(key, date);
        }
    
        /**
         * 查找匹配的key
         *
         * @param pattern
         * @return
         */
        public Set<String> keys(String pattern) {
        
            return redisTemplate.keys(pattern);
        }
    
        /**
         * 将当前数据库的 key 移动到给定的数据库 db 当中
         *
         * @param key
         * @param dbIndex
         * @return
         */
        public Boolean move(String key, int dbIndex) {
        
            return redisTemplate.move(key, dbIndex);
        }
    
        /**
         * 移除 key 的过期时间，key 将持久保持
         *
         * @param key
         * @return
         */
        public Boolean persist(String key) {
        
            return redisTemplate.persist(key);
        }
    
        /**
         * 返回 key 的剩余的过期时间
         *
         * @param key
         * @param unit
         * @return
         */
        public Long getExpire(String key, TimeUnit unit) {
        
            return redisTemplate.getExpire(key, unit);
        }
    
        /**
         * 从当前数据库中随机返回一个 key
         *
         * @return
         */
        public String randomKey() {
        
            return redisTemplate.randomKey();
        }
    
        /**
         * 修改 key 的名称
         *
         * @param oldKey
         * @param newKey
         */
        public void rename(String oldKey, String newKey) {
        
            redisTemplate.rename(oldKey, newKey);
        }
    
        /**
         * 仅当 newkey 不存在时，将 oldKey 改名为 newkey
         *
         * @param oldKey
         * @param newKey
         * @return
         */
        public Boolean renameIfAbsent(String oldKey, String newKey) {
        
            return redisTemplate.renameIfAbsent(oldKey, newKey);
        }
    
        /**
         * 返回 key 所储存的值的类型
         *
         * @param key
         * @return
         */
        public DataType type(String key) {
        
            return redisTemplate.type(key);
        }
    
    
        // ============================String=============================
        /**
         * 普通缓存获取
         * @param key 键
         * @return 值
         */
        public Object get(String key) {
        
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         * @param key 键
         * @param value 值
         * @return true成功 false失败
         */
        public boolean set(String key, Object value) {
        
            try {
        
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
    
        }
    
        /**
         * 普通缓存放入并设置时间
         * @param key 键
         * @param value 值
         * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
        public boolean set(String key, Object value, long time) {
        
            try {
        
                if (time > 0) {
        
                    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                } else {
        
                    set(key, value);
                }
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 递增
         * @param key 键
         * @param delta 要增加几(大于0)
         * @return
         */
        public long incr(String key, long delta) {
        
            if (delta < 0) {
        
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
        /**
         * 递减
         * @param key 键
         * @param delta 要减少几(小于0)
         * @return
         */
        public long decr(String key, long delta) {
        
            if (delta < 0) {
        
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
        // ================================Map=================================
        /**
         * HashGet
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return 值
         */
        public Object hget(String key, String item) {
        
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取hashKey对应的所有键值
         * @param key 键
         * @return 对应的多个键值
         */
        public Map<Object, Object> hmget(String key) {
        
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet
         * @param key 键
         * @param map 对应多个键值
         * @return true 成功 false 失败
         */
        public boolean hmset(String key, Map<String, Object> map) {
        
            try {
        
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * HashSet 并设置时间
         * @param key 键
         * @param map 对应多个键值
         * @param time 时间(秒)
         * @return true成功 false失败
         */
        public boolean hmset(String key, Map<String, Object> map, long time) {
        
            try {
        
                redisTemplate.opsForHash().putAll(key, map);
                if (time > 0) {
        
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         * @param key 键
         * @param item 项
         * @param value 值
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value) {
        
            try {
        
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         * @param key 键
         * @param item 项
         * @param value 值
         * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value, long time) {
        
            try {
        
                redisTemplate.opsForHash().put(key, item, value);
                if (time > 0) {
        
                    expire(key, time);
                }
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 删除hash表中的值
         * @param key 键 不能为null
         * @param item 项 可以使多个 不能为null
         */
        public void hdel(String key, Object... item) {
        
            redisTemplate.opsForHash().delete(key, item);
        }
    
        /**
         * 判断hash表中是否有该项的值
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public boolean hHasKey(String key, String item) {
        
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
        /**
         * hash递增 如果不存在,就会创建一个 并把新增后的值返回
         * @param key 键
         * @param item 项
         * @param by 要增加几(大于0)
         * @return
         */
        public double hincr(String key, String item, double by) {
        
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
        /**
         * hash递减
         * @param key 键
         * @param item 项
         * @param by 要减少记(小于0)
         * @return
         */
        public double hdecr(String key, String item, double by) {
        
            return redisTemplate.opsForHash().increment(key, item, -by);
        }
    
        // ============================set=============================
        /**
         * 根据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 sHasKey(String key, Object value) {
        
            try {
        
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将数据放入set缓存
         * @param key 键
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSet(String key, Object... values) {
        
            try {
        
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 将set数据放入缓存
         * @param key 键
         * @param time 时间(秒)
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSetAndTime(String key, long time, Object... values) {
        
            try {
        
                Long count = redisTemplate.opsForSet().add(key, values);
                if (time > 0)
                    expire(key, time);
                return count;
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 获取set缓存的长度
         * @param key 键
         * @return
         */
        public long sGetSetSize(String key) {
        
            try {
        
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 移除值为value的
         * @param key 键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
        public long setRemove(String key, Object... values) {
        
            try {
        
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
        // ===============================list=================================
    
        /**
         * 获取list缓存的内容
         * @param key 键
         * @param start 开始
         * @param end 结束 0 到 -1代表所有值
         * @return
         */
        public List<Object> lGet(String key, long start, long end) {
        
            try {
        
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
        
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 获取list缓存的长度
         * @param key 键
         * @return
         */
        public long lGetListSize(String key) {
        
            try {
        
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 通过索引 获取list中的值
         * @param key 键
         * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
         * @return
         */
        public Object lGetIndex(String key, long index) {
        
            try {
        
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
        
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, Object value) {
        
            try {
        
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @param time 时间(秒)
         * @return
         */
        public boolean lSet(String key, Object value, long time) {
        
            try {
        
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0)
                    expire(key, time);
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         * @param key 键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, List<Object> value) {
        
            try {
        
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存
         *
         * @param key 键
         * @param value 值
         * @param time 时间(秒)
         * @return
         */
        public boolean lSet(String key, List<Object> value, long time) {
        
            try {
        
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0)
                    expire(key, time);
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据索引修改list中的某条数据
         * @param key 键
         * @param index 索引
         * @param value 值
         * @return
         */
        public boolean lUpdateIndex(String key, long index, Object value) {
        
            try {
        
                redisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) {
        
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 移除N个值为value
         * @param key 键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
        public long lRemove(String key, long count, Object value) {
        
            try {
        
                Long remove = redisTemplate.opsForList().remove(key, count, value);
                return remove;
            } catch (Exception e) {
        
                e.printStackTrace();
                return 0;
            }
        }
        // ============================= zSet相关操作 =============================
    
        /**
         * 添加元素,有序集合是按照元素的score值由小到大排列
         *
         * @param key
         * @param value
         * @param score
         * @return
         */
        public Boolean zAdd(String key, String value, double score) {
        
            return redisTemplate.opsForZSet().add(key, value, score);
        }
    
        /**
         *
         * @param key
         * @param values
         * @return
         */
        public Long zAdd(String key, Set<ZSetOperations.TypedTuple<Object>> values) {
        
            return redisTemplate.opsForZSet().add(key, values);
        }
    
        /**
         *
         * @param key
         * @param values
         * @return
         */
        public Long zRemove(String key, Object... values) {
        
            return redisTemplate.opsForZSet().remove(key, values);
        }
    
        /**
         * 增加元素的score值，并返回增加后的值
         *
         * @param key
         * @param value
         * @param delta
         * @return
         */
        public Double zIncrementScore(String key, String value, double delta) {
        
            return redisTemplate.opsForZSet().incrementScore(key, value, delta);
        }
    
        /**
         * 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
         *
         * @param key
         * @param value
         * @return 0表示第一位
         */
        public Long zRank(String key, Object value) {
        
            return redisTemplate.opsForZSet().rank(key, value);
        }
    
        /**
         * 返回元素在集合的排名,按元素的score值由大到小排列
         *
         * @param key
         * @param value
         * @return
         */
        public Long zReverseRank(String key, Object value) {
        
            return redisTemplate.opsForZSet().reverseRank(key, value);
        }
    
        /**
         * 获取集合的元素, 从小到大排序
         *
         * @param key
         * @param start
         *            开始位置
         * @param end
         *            结束位置, -1查询所有
         * @return
         */
        public Set<Object> zRange(String key, long start, long end) {
        
            return redisTemplate.opsForZSet().range(key, start, end);
        }
    
        /**
         * 获取集合元素, 并且把score值也获取
         *
         * @param key
         * @param start
         * @param end
         * @return
         */
        public Set<ZSetOperations.TypedTuple<Object>> zRangeWithScores(String key, long start, long end) {
        
            return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
        }
    
        /**
         * 根据Score值查询集合元素
         *
         * @param key
         * @param min
         *            最小值
         * @param max
         *            最大值
         * @return
         */
        public Set<Object> zRangeByScore(String key, double min, double max) {
        
            return redisTemplate.opsForZSet().rangeByScore(key, min, max);
        }
    
        /**
         * 根据Score值查询集合元素, 从小到大排序
         *
         * @param key
         * @param min
         *            最小值
         * @param max
         *            最大值
         * @return
         */
        public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max) {
        
            return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
        }
    
        /**
         *
         * @param key
         * @param min
         * @param max
         * @param start
         * @param end
         * @return
         */
        public Set<ZSetOperations.TypedTuple<Object>> zRangeByScoreWithScores(String key, double min, double max, long start, long end) {
        
            return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max, start, end);
        }
    
        /**
         * 获取集合的元素, 从大到小排序
         *
         * @param key
         * @param start
         * @param end
         * @return
         */
        public Set<Object> zReverseRange(String key, long start, long end) {
        
            return redisTemplate.opsForZSet().reverseRange(key, start, end);
        }
    
        /**
         * 获取集合的元素, 从大到小排序, 并返回score值
         *
         * @param key
         * @param start
         * @param end
         * @return
         */
        public Set<ZSetOperations.TypedTuple<Object>> zReverseRangeWithScores(String key, long start, long end) {
        
            return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
        }
    
        /**
         * 根据Score值查询集合元素, 从大到小排序
         *
         * @param key
         * @param min
         * @param max
         * @return
         */
        public Set<Object> zReverseRangeByScore(String key, double min, double max) {
        
            return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
        }
    
        /**
         * 根据Score值查询集合元素, 从大到小排序
         *
         * @param key
         * @param min
         * @param max
         * @return
         */
        public Set<ZSetOperations.TypedTuple<Object>> zReverseRangeByScoreWithScores(String key, double min, double max) {
        
            return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max);
        }
    
        /**
         *
         * @param key
         * @param min
         * @param max
         * @param start
         * @param end
         * @return
         */
        public Set<Object> zReverseRangeByScore(String key, double min, double max, long start, long end) {
        
            return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end);
        }
    
        /**
         * 根据score值获取集合元素数量
         *
         * @param key
         * @param min
         * @param max
         * @return
         */
        public Long zCount(String key, double min, double max) {
        
            return redisTemplate.opsForZSet().count(key, min, max);
        }
    
        /**
         * 获取集合大小
         *
         * @param key
         * @return
         */
        public Long zSize(String key) {
        
            return redisTemplate.opsForZSet().size(key);
        }
    
        /**
         * 获取集合大小
         *
         * @param key
         * @return
         */
        public Long zZCard(String key) {
        
            return redisTemplate.opsForZSet().zCard(key);
        }
    
        /**
         * 获取集合中value元素的score值
         *
         * @param key
         * @param value
         * @return
         */
        public Double zScore(String key, Object value) {
        
            return redisTemplate.opsForZSet().score(key, value);
        }
    
        /**
         * 移除指定索引位置的成员
         *
         * @param key
         * @param start
         * @param end
         * @return
         */
        public Long zRemoveRange(String key, long start, long end) {
        
            return redisTemplate.opsForZSet().removeRange(key, start, end);
        }
    
        /**
         * 根据指定的score值的范围来移除成员
         *
         * @param key
         * @param min
         * @param max
         * @return
         */
        public Long zRemoveRangeByScore(String key, double min, double max) {
        
            return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
        }
    
        /**
         * 获取key和otherKey的并集并存储在destKey中
         *
         * @param key
         * @param otherKey
         * @param destKey
         * @return
         */
        public Long zUnionAndStore(String key, String otherKey, String destKey) {
        
            return redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
        }
    
        /**
         *
         * @param key
         * @param otherKeys
         * @param destKey
         * @return
         */
        public Long zUnionAndStore(String key, Collection<String> otherKeys, String destKey) {
        
            return redisTemplate.opsForZSet()
                    .unionAndStore(key, otherKeys, destKey);
        }
    
        /**
         * 交集
         *
         * @param key
         * @param otherKey
         * @param destKey
         * @return
         */
        public Long zIntersectAndStore(String key, String otherKey, String destKey) {
        
            return redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey);
        }
    
        /**
         * 交集
         *
         * @param key
         * @param otherKeys
         * @param destKey
         * @return
         */
        public Long zIntersectAndStore(String key, Collection<String> otherKeys, String destKey) {
        
            return redisTemplate.opsForZSet().intersectAndStore(key, otherKeys, destKey);
        }
    
        /**
         *
         * @param key
         * @param options
         * @return
         */
        public Cursor<ZSetOperations.TypedTuple<Object>> zScan(String key, ScanOptions options) {
        
            return redisTemplate.opsForZSet().scan(key, options);
        }
    }