超全RedisTemplate常用方法工具类及案例

女爷i 2023-10-01 08:33 17阅读 0赞

**目录**

1.添加需要的jar依赖

2.通用common

3.String类型

4.String类型案例

5.Hash类型

6.Hash类型案例

7.set类型

8.Set类型案例

9.list类型

10.list类型案例

11.zset类型

12.zset类型案例

--------------------

操作redis的方式有面向java的jedis，还有经过spring封装的data-redis，此处提供spring封装的方式。

#### 1.添加需要的jar依赖 ####

工程中的pom.xml中添加依赖，版本号根据自己选定的redis决定

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>

#### 2.通用common ####

/**
         * 指定缓存失效时间
         * @param key
         * @param time
         * @return
         */
        public boolean setExpireTime(String key, long time) {
            try {
                if (time > 0) {
                    this.redisTemplate.expire(key, time, TimeUnit.MINUTES);
                }
                return true;
            } catch (Exception e) {
                logger.error("redisTemplate setExpireTime error {}", e.getMessage());
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据key获取过期时间
         * @param key
         * @return
         */
        public long getExpireTime(String key) {
            return redisTemplate.getExpire(key, TimeUnit.MINUTES);
        }
    
        /**
         * 判断key是否存在
         * @param key
         * @return
         */
        public boolean hasKey(String key) {
            try {
                return redisTemplate.hasKey(key);
            } catch (Exception e) {
                logger.error("redisTemplate hasKey error {}", e.getMessage());
                return false;
            }
        }
    
        /**
         * 删除缓存
         * @param key
         */
        public void delete(String... key) {
            if (key != null && key.length > 0) {
                if (key.length == 1) {
                    redisTemplate.delete(key[0]);
                } else {
                    redisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }

#### 3.String类型 ####

/**
         * 普通缓存获取
         * @param key
         * @return
         */
        public Object get(String key) {
            try {
                return (key == null ? null : redisTemplate.opsForValue().get(key));
            } catch (Exception e) {
                logger.error("redisTemplate get error {}", e.getMessage());
                throw new RuntimeException(e);
            }
        }
    
        /**
         * 普通缓存放入
         * @param key
         * @param value
         * @return
         */
        public boolean set(String key, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                logger.error("redisTemplate set error {}", e.getMessage());
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 只有在 key 不存在时设置 key 的值
         * @param key
         * @param value
         * @return 之前已经存在返回false,不存在返回true
         */
        public boolean setIfAbsent(String key, String value) {
            return redisTemplate.opsForValue().setIfAbsent(key, value);
        }
    
        /**
         * 普通缓存放入并设置时间
         * @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.MINUTES);
                } else {
                    set(key, value);
                }
                return true;
            } catch (Exception e) {
                logger.error("redisTemplate set by time error {}", e.getMessage());
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 递增
         * @param key 键
         * @param by要增加几(大于0)
         * @return
         */
        public long incr(String key, long delta){
            try {
                if(delta<0){
                    throw new RuntimeException("递增因子必须大于0");
                }
                return redisTemplate.opsForValue().increment(key, delta);
            } catch (Exception e) {
                logger.error("redisTemplate incr error {}", e.getMessage());
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }
    
        /**
         * 递减
         * @param key 键
         * @param by要减少几(大于0)
         * @return
         */
        public long decr(String key, long delta){
            try {
                if(delta<0){
                    throw new RuntimeException("递减因子必须大于0");
                }
                return redisTemplate.opsForValue().increment(key, -delta);
            } catch (Exception e) {
                logger.error("redisTemplate decr error {}", e.getMessage());
                e.printStackTrace();
                throw new RuntimeException(e);
            }
        }

#### 4.String类型案例 ####

public class StringDemo {
    
        @Autowired
        StringRedisTemplate redisTemplate;
    
        //向redis里存入数据
        @RequestMapping("/test1")
        public void test1() {
            redisTemplate.opsForValue().set("stringValue", "aaa");
            printString("stringValue");
        }
    
        //在原有的值基础上新增字符串到末尾
        @RequestMapping("/test2")
        public void test2() {
            redisTemplate.opsForValue().append("stringValue","bbb");
            printString("stringValue");
        }
    
        //截取key键对应值得字符串，从开始下标位置开始到结束下标的位置(包含结束下标)的字符串。
        @RequestMapping("/test3")
        public void test3() {
            String str = redisTemplate.opsForValue().get("stringValue",0,3);
            System.out.println(str);
        }
    
        //获取原来key键对应的值并重新赋新值
        @RequestMapping("/test4")
        public void test4() {
            String andSet = (String)redisTemplate.opsForValue().getAndSet("stringValue", "ccc");
            System.out.print("通过getAndSet(K key, V value)方法获取原来的" + andSet + ",");
            String newStringValue = redisTemplate.opsForValue().get("stringValue")+"";
            System.out.println("修改过后的值:"+newStringValue);
        }
    
        //key键对应的值value对应的ascii码,在offset的位置(从左向右数)变为value。按游标存放true或者false值，可以使用在签到需求上
        @RequestMapping("/test5")
        public void test5() {
            String beforeStringValue = redisTemplate.opsForValue().get("stringValue")+"";
            System.out.println("修改之前的值:"+beforeStringValue);
            redisTemplate.opsForValue().setBit("stringValue",2,false);
            String newStringValue = redisTemplate.opsForValue().get("stringValue")+"";
            System.out.println("通过setBit(K key,long offset,boolean value)方法修改过后的值:"+newStringValue);
        }
    
        //判断指定的位置ASCII码的bit位是否为1。
        @RequestMapping("/test6")
        public void test6() {
            boolean bitBoolean = redisTemplate.opsForValue().getBit("stringValue",2);
            System.out.println("通过getBit(K key,long offset)方法判断指定bit位的值是:" + bitBoolean);
        }
    
        //获取指定字符串的长度
        @RequestMapping("/test7")
        public void test7() {
            Long stringValueLength = redisTemplate.opsForValue().size("stringValue");
            System.out.println("通过size(K key)方法获取字符串的长度:"+stringValueLength);
        }
    
        // 以增量的方式将double值存储在变量中。
        @RequestMapping("/test8")
        public void test8() {
            double stringValueDouble = redisTemplate.opsForValue().increment("doubleValue",5);
            System.out.println("通过increment(K key, double delta)方法以增量方式存储double值:" + stringValueDouble);
        }
    
        // 如果键不存在则新增,存在则不改变已经有的值。
        @RequestMapping("/test9")
        public void test9() {
            boolean absentBoolean = redisTemplate.opsForValue().setIfAbsent("absentValue","fff");
            System.out.println("通过setIfAbsent(K key, V value)方法判断变量值absentValue是否存在:" + absentBoolean);
            if(absentBoolean){
                String absentValue = redisTemplate.opsForValue().get("absentValue")+"";
                System.out.print(",不存在，则新增后的值是:"+absentValue);
                boolean existBoolean = redisTemplate.opsForValue().setIfAbsent("absentValue","eee");
                System.out.print(",再次调用setIfAbsent(K key, V value)判断absentValue是否存在并重新赋值:" + existBoolean);
                if(!existBoolean){
                    absentValue = redisTemplate.opsForValue().get("absentValue")+"";
                    System.out.print("如果存在,则重新赋值后的absentValue变量的值是:" + absentValue);
                }
            }
        }
    
        //设置变量值的过期时间
        @RequestMapping("/test10")
        public void test10() throws InterruptedException {
            redisTemplate.opsForValue().set("timeOutValue","timeOut",5,TimeUnit.SECONDS);
            String timeOutValue = redisTemplate.opsForValue().get("timeOutValue")+"";
            System.out.println("通过set(K key, V value, long timeout, TimeUnit unit)方法设置过期时间，过期之前获取的数据:"+timeOutValue);
            Thread.sleep(6*1000);
            timeOutValue = redisTemplate.opsForValue().get("timeOutValue")+"";
            System.out.print(",等待6s过后，获取的值:"+timeOutValue);
        }
    
        // 覆盖从指定位置开始的值
        @RequestMapping("/test11")
        public void test11(){
            String absentValue = redisTemplate.opsForValue().get("absentValue")+"";
            System.out.print("没进行覆盖的值:"+absentValue);
            redisTemplate.opsForValue().set("absentValue","dd",1);
            String overrideString = redisTemplate.opsForValue().get("absentValue")+"";
            System.out.print("，通过set(K key, V value, long offset)方法覆盖部分的值:"+overrideString);
        }
    
        //  设置map集合到redis
        @RequestMapping("/test12")
        public void test12(){
            Map valueMap = new HashMap();
            valueMap.put("valueMap1","map1");
            valueMap.put("valueMap2","map2");
            valueMap.put("valueMap3","map3");
            redisTemplate.opsForValue().multiSet(valueMap);
    
        }
    
        // 根据集合取出对应的value值
        @RequestMapping("/test13")
        public void test13(){
            List paraList = new ArrayList();
            paraList.add("valueMap1");
            paraList.add("valueMap2");
            paraList.add("valueMap3");
            List<String> valueList = redisTemplate.opsForValue().multiGet(paraList);
            for (String value : valueList){
                System.out.println("通过multiGet(Collection<K> keys)方法获取map值:" + value);
            }
        }
    
        //如果对应的map集合名称不存在，则添加，如果存在则不做修改
        @RequestMapping("/test14")
        public void test14(){
            Map valueMap = new HashMap();
            valueMap.put("valueMap1","map1");
            valueMap.put("valueMap2","map2");
            valueMap.put("valueMap3","map3");
            Boolean aBoolean = redisTemplate.opsForValue().multiSetIfAbsent(valueMap);
            System.out.println("执行情况："+aBoolean);
        }
    
        //如果对应的map集合名称有存在的，也有不存在的，整个都不进行执行
        @RequestMapping("/test15")
        public void test15(){
            Map valueMap = new HashMap();
            valueMap.put("valueMap1","map1");
            valueMap.put("valueMap4","map4");
            valueMap.put("valueMap5","map5");
            Boolean aBoolean = redisTemplate.opsForValue().multiSetIfAbsent(valueMap);
            System.out.println("执行情况："+aBoolean);
        }
    
        //添加实体，获取实体
        @RequestMapping("/test16")
        public void test16(){
            UmappTest test = new UmappTest();
            test.setSex("男").setAge(2).setName("张三");
            redisTemplate.opsForValue().set("test", JSON.toJSONString(test));
            String test1 = redisTemplate.opsForValue().get("test");
            System.out.println(test1);
            UmappTest umappTest = JSONObject.parseObject(test1,UmappTest.class);
            System.out.println(umappTest.toString());
    
        }
    
    
        private void printString(String key) {
            String value = redisTemplate.opsForValue().get(key)+"";
            System.out.println(value);
        }
    
    
    }

#### 5.Hash类型 ####

/**
         * 向一张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){
                    setExpireTime(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * HashGet
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return 值
         */
        public Object hget(String key,String item){
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 删除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);
        }
    
        /**
         * Hash值为map
         * @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;
            }
        }
    
        /**
         * 获取hashKey对应的所有键值-map
         * @param key 键
         * @return 对应的多个键值
         */
        public Map<Object,Object> hmget(String key){
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * 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){
                    setExpireTime(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }

#### 6.Hash类型案例 ####

public class HashDemo {
    
        @Autowired
        RedisTemplate redisTemplate;
    
        // 新增hashMap值
        @RequestMapping("/test1")
        public void test1() {
            redisTemplate.opsForHash().put("hashValue","map1","map1-1");
            redisTemplate.opsForHash().put("hashValue","map2","map2-2");
            List<Object> hashList = redisTemplate.opsForHash().values("hashValue");
            System.out.println("通过values(H key)方法获取变量中的hashMap值:" + hashList);
        }
    
        // 获取指定变量中的hashMap值
        @RequestMapping("/test2")
        public void test2() {
            List<Object> hashList = redisTemplate.opsForHash().values("hashValue");
            System.out.println("通过values(H key)方法获取变量中的hashMap值:" + hashList);
        }
    
        //获取变量中的键值对
        @RequestMapping("/test3")
        public void test3() {
            Map map = redisTemplate.opsForHash().entries("hashValue");
            if(null != map){
                Iterator iterator = map.entrySet().iterator();
                while (iterator.hasNext()){
                    Map.Entry<String,Object> next = (Map.Entry<String, Object>) iterator.next();
                    System.out.println(next.getKey()+"===="+next.getValue());
                }
            }
    
        }
    
        //获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null
        @RequestMapping("/test4")
        public void test4() {
            Object mapValue = redisTemplate.opsForHash().get("hashValue", "map1");
            System.out.println("通过get(H key, Object hashKey)方法获取map键的值:" + mapValue);
        }
    
        //判断变量中是否有指定的map键
        @RequestMapping("/test5")
        public void test5() {
            Boolean hashKeyBoolean = redisTemplate.opsForHash().hasKey("hashValue", "map1");
            System.out.println("通过hasKey(H key, Object hashKey)方法判断变量中是否存在map键:" + hashKeyBoolean);
        }
    
        // 获取变量中的键
        @RequestMapping("/test6")
        public void test6() {
            Set keySet = redisTemplate.opsForHash().keys("hashValue");
            System.out.println("通过keys(H key)方法获取变量中的键:" + keySet);
        }
    
        // 获取变量的长度
        @RequestMapping("/test7")
        public void test7() {
            Long hashLength = redisTemplate.opsForHash().size("hashValue");
            System.out.println("通过size(H key)方法获取变量的长度:" + hashLength);
        }
    
        // 使变量中的键以double值的大小进行自增长
        @RequestMapping("/test8")
        public void test8() {
            double hashIncDouble = redisTemplate.opsForHash().increment("hashInc","map1",3);
            System.out.println("通过increment(H key, HK hashKey, double delta)方法使变量中的键以值的大小进行自增长:" + hashIncDouble);
        }
    
        // 以集合的方式获取变量中的值
        @RequestMapping("/test9")
        public void test9() {
            List<String> list = new ArrayList<String>();
            list.add("map1");
            list.add("map2");
            List mapValueList = redisTemplate.opsForHash().multiGet("hashValue", list);
            System.out.println("通过multiGet(H key, Collection<HK> hashKeys)方法以集合的方式获取变量中的值:"+mapValueList);
        }
    
        // 以map集合的形式添加键值对
        @RequestMapping("/test10")
        public void test10() {
            Map newMap = new HashMap();
            newMap.put("map3","map3-1");
            newMap.put("map5","map5-1");
            redisTemplate.opsForHash().putAll("hashValue", newMap);
            Map map = redisTemplate.opsForHash().entries("hashValue");
            System.out.println("通过putAll(H key, Map<? extends HK,? extends HV> m)方法以map集合的形式添加键值对:" + map);
        }
    
        // 如果变量值存在，在变量中可以添加不存在的的键值对，如果变量不存在，则新增一个变量，同时将键值对添加到该变量
        @RequestMapping("/test11")
        public void test11() {
            Boolean aBoolean = redisTemplate.opsForHash().putIfAbsent("hashValue", "map5", "map6-1");
            System.out.println("添加执行结果："+aBoolean);
            Map map = redisTemplate.opsForHash().entries("hashValue");
            System.out.println("通过putAll(H key, Map<? extends HK,? extends HV> m)方法以map集合的形式添加键值对:" + map);
        }
    
        //  匹配获取键值对，ScanOptions.NONE为获取全部键对，ScanOptions.scanOptions().match("map1").build()
        //  模糊匹配
        @RequestMapping("/test12")
        public void test12() throws IOException {
            try {
                Cursor<Map.Entry<Object,Object>> scan = redisTemplate.opsForHash().scan("hashValue", ScanOptions.scanOptions().match("*map*").build());
                //Cursor<Map.Entry<Object,Object>> cursor = redisTemplate.opsForHash().scan("hashValue",ScanOptions.NONE);//与entries方法一致
                while(scan.hasNext()){
                    Map.Entry<Object, Object> entry = scan.next();
                    System.out.println("通过scan(H key, ScanOptions options)方法获取匹配键值对:" + entry.getKey() + "---->" + entry.getValue());
                }
                //关闭cursor
                scan.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        //删除变量中的键值对，可以传入多个参数，删除多个键值对
        @RequestMapping("/test13")
        public void test13() {
            redisTemplate.opsForHash().delete("hashValue","map1","map2");
            Map map = redisTemplate.opsForHash().entries("hashValue");
            System.out.println("通过delete(H key, Object... hashKeys)方法删除变量中的键值对后剩余的:" + map);
        }
    
    
    }

#### 7.set类型 ####

/**
         * 将数据放入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 sset(String key,long time,Object...values) {
            try {
                Long count = redisTemplate.opsForSet().add(key, values);
                if(time>0) {
                    setExpireTime(key, time);
                }
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 根据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 键
         * @return
         */
        public long ssize(String key){
            try {
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 移除值为value的
         * @param key 键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
        public long sdel(String key, Object ...values) {
            try {
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        /**
         * 随机获取变量中的元素
         * @param key 键
         * @return value值
         */
        public Object srandom(String key) {
            try {
                return redisTemplate.opsForSet().randomMember(key);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }

#### 8.Set类型案例 ####

public class SetDemo {
    
        @Autowired
        RedisTemplate redisTemplate;
    
        //向变量中批量添加值
        @RequestMapping("/test1")
        public void test1() {
            redisTemplate.opsForSet().add("setValue","A","B","C","B","D","E","F");
        }
    
        //获取变量中的值
        @RequestMapping("/test2")
        public void test2() {
            Set set = redisTemplate.opsForSet().members("setValue");
            System.out.println("通过members(K key)方法获取变量中的元素值:" + set);
            Iterator iterator = set.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }
    
        // 获取变量中值的长度
        @RequestMapping("/test3")
        public void test3() {
            Long setLength = redisTemplate.opsForSet().size("setValue");
            System.out.println("通过size(K key)方法获取变量中元素值的长度:" + setLength);
        }
    
        //  随机获取变量中的元素
        @RequestMapping("/test4")
        public void test4() {
            Object randomMember = redisTemplate.opsForSet().randomMember("setValue");
            System.out.println("通过randomMember(K key)方法随机获取变量中的元素:" + randomMember);
    
        }
    
        // 随机获取变量中指定个数的元素
        @RequestMapping("/test5")
        public void test5() {
            List<String> setValue = redisTemplate.opsForSet().randomMembers("setValue", 3);
            for(String str : setValue){
                System.out.println(str);
            }
    
        }
    
        //  检查给定的元素是否在变量中
        @RequestMapping("/test6")
        public void test6() {
            Boolean isMember = redisTemplate.opsForSet().isMember("setValue", "R");
            System.out.println("通过isMember(K key, Object o)方法检查给定的元素是否在变量中:" + isMember);
        }
    
        //转移变量的元素值到目的变量，目的变量没有则创建
        @RequestMapping("/test7")
        public void test7() {
            Boolean move = redisTemplate.opsForSet().move("setValue", "A", "tempSetValue");
            if(move){
                Set setValue = redisTemplate.opsForSet().members("setValue");
                Set tempSetValue = redisTemplate.opsForSet().members("tempSetValue");
                System.out.print("通过move(K key, V value, K destKey)方法转移变量的元素值到目的变量后的剩余元素:" + setValue);
                System.out.println(",目的变量中的元素值:" + tempSetValue);
            }
    
        }
    
        // 弹出变量中的元素
        @RequestMapping("/test8")
        public void test8() {
            Set oldValue = redisTemplate.opsForSet().members("setValue");
            System.out.print("未操作之前的数值:" + oldValue);
            Object popValue = redisTemplate.opsForSet().pop("setValue");
            System.out.print("通过pop(K key)方法弹出变量中的元素:" + popValue);
            Set setValue = redisTemplate.opsForSet().members("setValue");
            System.out.println(",剩余元素:" + setValue);
        }
    
        // 批量移除变量中的元素
        @RequestMapping("/test9")
        public void test9() {
            Long removeCount = redisTemplate.opsForSet().remove("setValue", "E", "F", "G");
            System.out.print("通过remove(K key, Object... values)方法移除变量中的元素个数:" + removeCount);
            Set setValue = redisTemplate.opsForSet().members("setValue");
            System.out.println(",剩余元素:" + setValue);
    
        }
    
        //  匹配获取键值对，ScanOptions.NONE为获取全部键值对；ScanOptions.scanOptions().match("C").build()匹配获取
        @RequestMapping("/test10")
        public void test10() throws IOException {
            //查询所有
    /*        Cursor<Object> setValue = redisTemplate.opsForSet().scan("setValue", ScanOptions.NONE);
            while (setValue.hasNext()){
                System.out.println(setValue.next());
            }*/
            //根据条件查询
            Cursor<Object> scan = redisTemplate.opsForSet().scan("setValue",  ScanOptions.scanOptions().match("*B*").build());
            while (scan.hasNext()){
                Object object = scan.next();
                System.out.println("通过scan(K key, ScanOptions options)方法获取匹配的值:" + object);
            }
            scan.close();
    
        }
    
        //通过集合求差值，差集结果为第一个key的集合值
        @RequestMapping("/test11")
        public void test11() {
            List list = new ArrayList();
            list.add("tempSetValue");
            Set differenceSet = redisTemplate.opsForSet().difference("setValue", list);
            System.out.println("通过difference(K key, Collection<K> otherKeys)方法获取变量中与给定集合中变量不一样的值:" + differenceSet);
        }
    
        //通过给定的key求2个set变量的差值,以第一个集合为基准
        @RequestMapping("/test12")
        public void test12() {
            Set differenceSet = redisTemplate.opsForSet().difference("setValue", "tempSetValue");
            System.out.println("通过difference(K key, Collection<K> otherKeys)方法获取变量中与给定变量不一样的值:" + differenceSet);
        }
    
        // 通过给定的key求2个set变量的差值,保存到新的set集合中
        @RequestMapping("/test13")
        public void test13() {
            redisTemplate.opsForSet().differenceAndStore("setValue","tempSetValue","storeSetValue");
            Set storeSetValue = redisTemplate.opsForSet().members("storeSetValue");
            System.out.println("通过differenceAndStore(K key, K otherKey, K destKey)方法将求出来的差值元素保存:" + storeSetValue);
        }
    
        //通过集合求差值,保存到新的set集合中
        @RequestMapping("/test14")
        public void test14() {
            List list = new ArrayList();
            list.add("tempSetValue");
            redisTemplate.opsForSet().differenceAndStore("setValue",list,"storeSetValue");
            Set storeSetValue = redisTemplate.opsForSet().members("storeSetValue");
            System.out.println("通过differenceAndStore(K key, K otherKey, K destKey)方法将求出来的差值元素保存:" + storeSetValue);
        }
    
        //获取去重的随机元素
        @RequestMapping("/test15")
        public void test15() {
            //若当前集合中只有两个元素，去重获取，只会得到两个元素
            Set setValue = redisTemplate.opsForSet().distinctRandomMembers("setValue", 3);
            System.out.println("通过distinctRandomMembers(K key, long count)方法获取去重的随机元素:" + setValue);
        }
    
        //  获取2个结合中的交集
        @RequestMapping("/test16")
        public void test16() {
            Set intersect = redisTemplate.opsForSet().intersect("setValue", "tempSetValue");
            System.out.println("通过intersect(K key, K otherKey)方法获取交集元素:" + intersect);
        }
    
        // 获取多个集合之间的交集，第一个集合的元素需要都同时存在其他集合中才是交集
        @RequestMapping("/test17")
        public void test17() {
            List list = new ArrayList<>();
            list.add("tempSetValue");
            list.add("storeSetValue");
            Set setValue = redisTemplate.opsForSet().intersect("setValue", list);
            System.out.println("通过intersect(K key, Collection<K> otherKeys)方法获取交集元素:" + setValue);
        }
    
        // 获取2个变量交集后保存到最后一个参数上
        @RequestMapping("/test18")
        public void test18() {
            redisTemplate.opsForSet().intersectAndStore("setValue", "tempSetValue", "intersectSetValue");
            Set intersectSetValue = redisTemplate.opsForSet().members("intersectSetValue");
            System.out.println("通过intersectAndStore(K key, K otherKey, K destKey)方法将求出来的交集元素保存:" + intersectSetValue);
        }
    
        //  获取多个变量的交集并保存到最后一个参数上
        @RequestMapping("/test19")
        public void test19() {
            List list = new ArrayList<>();
            list.add("tempSetValue");
            list.add("intersectSetValue");
            redisTemplate.opsForSet().intersectAndStore("setValue", list, "intersectListSetValue");
            Set intersectListSetValue = redisTemplate.opsForSet().members("intersectListSetValue");
            System.out.println("通过intersectAndStore(K key, Collection<K> otherKeys, K destKey)方法将求出来的交集元素保存:" + intersectListSetValue);
        }
    
        //   获取2个变量的合集--已经去重
        @RequestMapping("/test20")
        public void test20() {
            Set union = redisTemplate.opsForSet().union("setValue", "tempSetValue");
            System.out.println("通过union(K key, K otherKey)方法获取2个变量的合集元素:" + union);
        }
    
        //   获取多个变量的合集
        @RequestMapping("/test21")
        public void test21() {
            List list = new ArrayList<>();
            list.add("tempSetValue");
            list.add("intersectSetValue");
            Set setValue = redisTemplate.opsForSet().union("setValue", list);
            System.out.println("通过union(K key, Collection<K> otherKeys)方法获取多个变量的合集元素:" + setValue);
        }
    
        //  获取2个变量合集后保存到最后一个参数上
        @RequestMapping("/test22")
        public void test22() {
            redisTemplate.opsForSet().unionAndStore("setValue","tempSetValue","unionSetValue");
            Set unionSetValue = redisTemplate.opsForSet().members("unionSetValue");
            System.out.println("通过unionAndStore(K key, K otherKey, K destKey)方法将求出来的交集元素保存:" + unionSetValue);
        }
    
        // 获取多个变量的合集并保存到最后一个参数上
        @RequestMapping("/test23")
        public void test23() {
            List list = new ArrayList<>();
            list.add("tempSetValue");
            list.add("intersectSetValue");
            redisTemplate.opsForSet().unionAndStore("setValue", list, "unionListSetValue");
            Set unionListSetValue = redisTemplate.opsForSet().members("unionListSetValue");
            System.out.println("通过unionAndStore(K key, Collection<K> otherKeys, K destKey)方法将求出来的交集元素保存:" + unionListSetValue);
        }
    
    
    
    }

#### 9.list类型 ####

/**
         * 将list放入缓存  --右进
         * @param key 键
         * @param value 值
         * @return
         */
        public boolean lrset(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 lrset(String key, Object value, long time) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0){
                    setExpireTime(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 将list放入缓存 --右进
         * @param key 键
         * @param value 值
         * @return
         */
        public boolean lrset(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 lrset(String key, List<Object> value, long time) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0){
                    setExpireTime(key, time);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 获取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 Object llpop(String key){
            try {
                return redisTemplate.opsForList().leftPop(key);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 获取list缓存的长度
         * @param key 键
         * @return
         */
        public long lsize(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 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;
            }
        }

#### 10.list类型案例 ####

public class ListDemo {
    
        @Autowired
        RedisTemplate redisTemplate;
    
        //在变量左边添加元素值
        @RequestMapping("/test1")
        public void test1() {
             redisTemplate.opsForList().leftPush("list","a");
             redisTemplate.opsForList().leftPush("list","b");
             redisTemplate.opsForList().leftPush("list","c");
        }
    
        //获取集合指定位置的值
        @RequestMapping("/test2")
        public void test2() {
            Object list = redisTemplate.opsForList().index("list", 1);
            System.out.println("通过index(K key, long index)方法获取指定位置的值:" + list);
        }
    
        //获取指定区间的值
        @RequestMapping("/test3")
        public void test3() {
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println("通过range(K key, long start, long end)方法获取指定范围的集合值:"+list);
        }
    
        //把最后一个参数值放到指定集合中第二个参数第一个出现的左边，如果中间参数值存在的话
        @RequestMapping("/test4")
        public void test4() {
            redisTemplate.opsForList().leftPush("list","a","n");
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println("通过leftPush(K key, V pivot, V value)方法把值放到指定参数值前面:" + list);
            //第二个参数不存在的情况-不进行插入
            redisTemplate.opsForList().leftPush("list","m","k");
            List list2 = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println("通过leftPush(K key, V pivot, V value)方法把值放到指定参数值前面:" + list2);
        }
    
        //  向左边批量添加参数元素
        @RequestMapping("/test5")
        public void test5() {
            redisTemplate.opsForList().leftPushAll("list","k","m","a");
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println("通过leftPushAll(K key, V... values)方法批量添加元素:" + list);
        }
    
        //  以集合的方式向左边批量添加元素
        @RequestMapping("/test6")
        public void test6() {
            List list = new ArrayList<>();
            list.add("l");
            list.add("p");
            list.add("q");
            redisTemplate.opsForList().leftPushAll("list",list);
            List list1 = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println("通过leftPushAll(K key, Collection<V> values)方法以集合的方式批量添加元素:" + list1);
        }
    
        //  如果存在集合则添加元素，不存在则不添加
        @RequestMapping("/test7")
        public void test7() {
            redisTemplate.opsForList().leftPushIfPresent("presentList","k");
            List presentList = redisTemplate.opsForList().range("presentList", 0, -1);
            System.out.println("通过leftPushIfPresent(K key, V value)方法向已存在的集合添加元素:" + presentList);
        }
    
        //   向集合最右边添加元素
        @RequestMapping("/test8")
        public void test8() {
            redisTemplate.opsForList().rightPush("list","q");
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println("通过rightPush(K key, V value)方法向最右边添加元素:" + list);
        }
    
        //   向集合中第一次出现第二个参数变量元素的右边添加第三个参数变量的元素值
        @RequestMapping("/test9")
        public void test9() {
            redisTemplate.opsForList().rightPush("list","a","kk");
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println("通过rightPush(K key, V pivot, V value)方法向最右边添加元素:" + list);
        }
    
        //  向右边批量添加元素
        @RequestMapping("/test10")
        public void test10() {
            redisTemplate.opsForList().rightPushAll("list","o","r");
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println("通过rightPushAll(K key, V... values)方法向最右边批量添加元素:" + list);
        }
    
        //  以集合方式向右边添加元素
        @RequestMapping("/test11")
        public void test11() {
            List list = new ArrayList<>();
            list.add("b");
            list.add("t");
            redisTemplate.opsForList().rightPushAll("list",list);
            List list1 = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println("通过rightPushAll(K key, Collection<V> values)方法向最右边以集合方式批量添加元素:" + list1);
        }
    
        //  向已存在的集合中添加元素，不存在不添加
        @RequestMapping("/test12")
        public void test12() {
            redisTemplate.opsForList().rightPushIfPresent("presentList","o");
            List presentList = redisTemplate.opsForList().range("presentList", 0, -1);
            System.out.println("通过rightPushIfPresent(K key, V value)方法已存在的集合向最右边添加元素:" + presentList);
        }
    
        //  获取集合长度
        @RequestMapping("/test13")
        public void test13() {
            Long listLength = redisTemplate.opsForList().size("list");
            System.out.println("通过size(K key)方法获取集合list的长度为:" + listLength);
        }
    
        //  移除集合中的左边第一个元素
        @RequestMapping("/test14")
        public void test14() {
            Object popValue = redisTemplate.opsForList().leftPop("list");
            System.out.print("通过leftPop(K key)方法移除的元素是:" + popValue);
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println(",剩余的元素是:" + list);
        }
    
        // 移除集合中左边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出
        @RequestMapping("/test15")
        public void test15() {
            Object popValue = redisTemplate.opsForList().leftPop("presentList", 1, TimeUnit.SECONDS);
            System.out.print("通过leftPop(K key, long timeout, TimeUnit unit)方法移除的元素是:" + popValue);
            List list = redisTemplate.opsForList().range("presentList", 0, -1);
            System.out.println(",剩余的元素是:" + list);
        }
    
        //移除集合中右边的元素
        @RequestMapping("/test16")
        public void test16() {
            Object popValue = redisTemplate.opsForList().rightPop("list");
            System.out.print("通过rightPop(K key)方法移除的元素是:" + popValue);
            List list =  redisTemplate.opsForList().range("list",0,-1);
            System.out.println(",剩余的元素是:" + list);
        }
    
        //移除集合中右边的元素在等待的时间里，如果超过等待的时间仍没有元素则退出
        @RequestMapping("/test17")
        public void test17() {
            Object popValue = redisTemplate.opsForList().rightPop("list", 1, TimeUnit.SECONDS);
            System.out.print("通过rightPop(K key, long timeout, TimeUnit unit)方法移除的元素是:" + popValue);
            List list =  redisTemplate.opsForList().range("list",0,-1);
            System.out.println(",剩余的元素是:" + list);
        }
    
        //移除集合中右边的元素，同时把移除的元素往第二个集合左边加入
        @RequestMapping("/test18")
        public void test18() {
            Object popValue  = redisTemplate.opsForList().rightPopAndLeftPush("list", "destList");
            System.out.print("通过rightPopAndLeftPush(K sourceKey, K destinationKey)方法移除的元素是:" + popValue);
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.print(",剩余的元素是:" + list);
            List destList = redisTemplate.opsForList().range("destList", 0, -1);
            System.out.print(",移动到目标集合的元素是:" + destList);
        }
    
        //移除集合中右边的元素，同时把移除的元素往第二个集合左边加入，如果超过等待的时间仍没有元素则退出
        @RequestMapping("/test19")
        public void test19() {
            Object popValue  = redisTemplate.opsForList().rightPopAndLeftPush("list", "destList",1,TimeUnit.SECONDS);
            System.out.println("通过rightPopAndLeftPush(K sourceKey, K destinationKey, long timeout, TimeUnit unit)方法移除的元素是:" + popValue);
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.print(",剩余的元素是:" + list);
            List destList = redisTemplate.opsForList().range("destList", 0, -1);
            System.out.print(",移动到目标集合的元素是:" + destList);
        }
    
        //在集合的指定位置插入元素,如果指定位置已有元素，则覆盖，没有则新增，超过集合下标+n则会报错
        @RequestMapping("/test20")
        public void test20() {
            redisTemplate.opsForList().set("list",1,"aa");
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.print("通过set(K key, long index, V value)方法在指定位置添加元素后:" + list);
        }
    
        //从存储在键中的列表中删除等于值的元素的第一个计数事件。
        //count（整数）：删除匹配值的数量，等于0时删除所有匹配的值；大于0时从左到右匹配，删除匹配到的count个记录；
        //小于0时从右到左匹配，删除匹配到的count绝对值个记录
        @RequestMapping("/test21")
        public void test21() {
            Long removeCount  = redisTemplate.opsForList().remove("list", 0, "m");
            List list =  redisTemplate.opsForList().range("list",0,-1);
            System.out.println("通过remove(K key, long count, Object value)方法移除元素数量:" + removeCount);
            System.out.println(",剩余的元素:" + list);
        }
    
        //截取集合元素长度，剩下长度内的数据(从左往右截取，截取部分包括end）
        @RequestMapping("/test22")
        public void test22() {
            redisTemplate.opsForList().trim("list",0,2);
            List list = redisTemplate.opsForList().range("list", 0, -1);
            System.out.println("通过trim(K key, long start, long end)方法截取后剩余元素:" + list);
        }
    
    
    
    
    
    
    
    
    
    
    
    
    }

#### 11.zset类型 ####

/**
         * 添加元素,有序集合是按照元素的score值由小到大排列
         * @param key 键
         * @param value 对象名称
         * @param score 数据值
         * @return
         */
        public Boolean zset(String key, String value, double score) {
            return redisTemplate.opsForZSet().add(key, value, score);
        }
    
        /**
         * 添加元素 向集合中插入多个元素
         * @param key 键
         * @param values set集合
         * @return
         */
        public Long zset(String key, Set<TypedTuple<Object>> values) {
            return redisTemplate.opsForZSet().add(key, values);
        }
    
        /*
         * 获取集合的元素, 从小到大排序
         * @param key
    	 * @param start 开始位置
    	 * @param end 结束位置, -1查询所有
    	 * @return
         */
        public Set<Object> zget(String key, long start, long end) {
            return redisTemplate.opsForZSet().range(key, start, end);
        }
    
        /**
         * 从集合中删除指定元素
         * @param key 键
         * @param values
         * @return
         */
        public Long zdel(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);
        }
    
        /**
         * 获取集合大小
         * @param key
         * @return
         */
        public Long zSize(String key) {
            return redisTemplate.opsForZSet().size(key);
        }

#### 12.zset类型案例 ####

public class ZsetDemo {
    
        @Autowired
        RedisTemplate redisTemplate;
    
        //向集合中插入元素，并设置分数
        //向集合中插入多个元素
        @RequestMapping("/test1")
        public void test1() {
            redisTemplate.opsForZSet().add("ranking-list", "p1", 2.1);
    
            DefaultTypedTuple<String> tuple1 = new DefaultTypedTuple<String>("p2",4.4);
            DefaultTypedTuple<String> tuple2 = new DefaultTypedTuple<String>("p3",5.0);
            redisTemplate.opsForZSet().add("ranking-list",new HashSet<>(Arrays.asList(tuple1,tuple2)));
            //打印
            printZSet("ranking-list");
        }
    
        //从集合中删除指定元素
        @RequestMapping("/test2")
        public void test2() {
            printZSet("ranking-list");
    
            redisTemplate.opsForZSet().remove("ranking-list","p1");
            printZSet("ranking-list");
        }
    
        //为指定元素加分
        @RequestMapping("/test3")
        public void test3() {
            Double score = redisTemplate.opsForZSet().incrementScore("ranking-list", "p1", 3);
            System.out.println(score);//返回加分后的得分
            printZSet("ranking-list");
        }
    
        //返回指定成员的排名（从小到大）
        @RequestMapping("/test4")
        public void test4() {
            Long rank = redisTemplate.opsForZSet().rank("ranking-list", "p1");
            //从大到小
            Long reverseRank = redisTemplate.opsForZSet().reverseRank("ranking-list", "p1");
            System.out.println(rank);
            System.out.println(reverseRank);
        }
    
        //返回集合内元素的排名，以及分数（从小到大）
        @RequestMapping("/test5")
        public void test5() {
            Set<ZSetOperations.TypedTuple<String>> tuples = redisTemplate.opsForZSet().rangeWithScores("ranking-list", 0, -1);
            for(ZSetOperations.TypedTuple<String> tuple : tuples){
                System.out.println(tuple.getValue()+":"+tuple.getScore());
            }
        }
    
        //返回集合内元素在指定分数范围内的排名（从小到大）
        @RequestMapping("/test6")
        public void test6() {
            Set<String> ranking = redisTemplate.opsForZSet().rangeByScore("ranking-list", 0, 5);
            System.out.println(ranking);
            //带偏移量和个数，下例意为从第二个开始，要三个
            Set<String> ranking2 = redisTemplate.opsForZSet().rangeByScore("ranking-list", 0, 5, 1, 3);
            System.out.println(ranking2);
    
        }
    
        //返回集合内指定分数范围的成员个数
        @RequestMapping("/test7")
        public void test7() {
            Long count = redisTemplate.opsForZSet().count("ranking-list", 0, 5);
            System.out.println(count);
            //返回集合内的成员个数
            Long size = redisTemplate.opsForZSet().size("ranking-list");
            System.out.println(size);
        }
    
        //获得指定元素的分数
        @RequestMapping("/test8")
        public void test8() {
            Double score = redisTemplate.opsForZSet().score("ranking-list", "p1");
            System.out.println(score);
    
        }
    
        //删除指定索引范围的元素
        @RequestMapping("/test9")
        public void test9() {
            redisTemplate.opsForZSet().removeRange("ranking-list",0,0);
            printZSet("ranking-list");
        }
    
        //删除指定分数范围内的元素
        @RequestMapping("/test10")
        public void test10() {
            redisTemplate.opsForZSet().removeRangeByScore("ranking-list",5,6);
            printZSet("ranking-list");
        }
    
        //按照排名先后(从小到大)打印指定区间内的元素, -1为打印全部
        private void printZSet(String key) {
            Set<String> range = redisTemplate.opsForZSet().range(key, 0, -1);
            //reverseRange 从大到小
            System.out.println(range);
        }
    }