使用spring操作redis

1. 渐进式遍历
1.1 概述
我们在之前学习过一个指令,叫做keys *,这个指令就是把Redis中所有的key采用遍历的方式全部都获取到.但是这个操作比较危险,可能在Redis中存储的key比较多,可能会阻塞Redis,影响其他指令的执行.
这时候我们就需要使用Redis中的渐进式遍历指令,scan指令.通过渐进式遍历,既可以获取到所有的key,同时又不会卡死服务器.这个命令,不是把所有的key一次性都拿到,而是每次执行命令,只获取其中的一小部分,如果key比较多的话,就需要多次执行scan命令,进行多次渐进式遍历.

1.2 常见指令
scan
scan cursor [MATCH pattern] [COUNT count] [TYPE type]
以渐进式遍历的方式对Redis中所有的键进行遍历.

cusor: 表示的是当前从哪个光标开始遍历.其中光标为0的时候,表示的是从头开始遍历所有的key.但是,光标的概念不可以理解为下标,它不是一个连续递增的整数,他只是一个普通的字符串,在每次遍历之后的返回结果中,都会返回下次遍历开始的光标,这个字符串看上去虽然是整数,但是他是一个字符串且和下标不对应,(如果返回的字符串是0,说明遍历已经完成)可能程序员不理解,但是Redis服务器是可以知道这个光标对应的元素的位置的.
pattern: 和前面介绍的keys命令是一样的.
count: 限制每次返回的元素个数,默认是10,但是需要注意的是,这里的count和MySQL中的limit不一样.count只是客户端给Redis服务器的一个建议,具体返回多少个,需要看具体的情况,比如只有9个key,但是count写的是10.这时候只返回9个key.但是limit是精确的,指定返回多少个就是返回多少个.
type: 指定key对应value的类型,其中包含5个通用类型,5个特殊场景使用的类型.

在遍历的过程中,不会在服务器中保存任何的状态信息.比如保存每次遍历之后的光标位置.此处的遍历是可以随时终止的,不会对服务器产生任何的副作用.

就像我们去吃烧烤,如果有一部分烧烤还没有上来,我们就需要退款,这时候老板就到后厨看了一眼,说已经烤上了,退不了了,再比如我们在遍历Redis服务器中的key的时候,遍历了一半,不想遍历了,但是这时候又取消不了,如果强行退出,这时候服务器就会保存状态,这时候就会对服务造成一定的影响,这时候就相当于服务器保存了客户端的状态.再比如我们去超市买东西,如果我们在结账的时候,发现钱没有带够,后面的东西不想要了,这时候可以不扫后面的商品.这时就像Redis中的渐进式遍历,没有保存之前遍历的状态,可以随时停止.

127.0.0.1:6379> mset k1 val1 k2 val2 k3 val3 k4 val4 k5 val5
OK
127.0.0.1:6379> scan 0 count 3
1) "1"//返回下次开始遍历的光标.
2) 1) "k3"
   2) "k4"
   3) "k5"
127.0.0.1:6379> scan 1 count 3
1) "0"
2) 1) "k1"
   2) "k2"//虽然输入的count是3,但是只遍历了2个.

但是scan也存在一定的缺点.渐进式遍历虽然解决了阻塞的问题,但是如果在遍历的期间键有所变化(增加修改删除),可能会导致重复遍历或者是遗漏.

2. 数据库管理
在我们之前学习MySQL中,有一个非常重要的概念,叫做database.其中一个MySQL服务器中可以有很多个database,一个database中也可以有很多张表.
其实在Redis中,也是有database这样的概念的,只不过不像MySQL那样随意,想创建多少个database就创建多少个.Redis中的database是现成的,用户不可以创建数据库,也不可以删除数据库.

默认Redis为我们提供了16个数据库.编号为0~15,这16个数据库之间是相互隔离的.默认的情况下使用的是0号数据库.

我们可以通过 select dbIndex(select+数据库编号)的指令来选择数据库.但是在实际使用中我们很少会关注数据库,一般我们使用0号数据库即可.
我们可以使用flushdb清除当前数据库中的所有数据.使用flushall清除Redis服务器中的所有数据.
127.0.0.1:6379> SELECT 1
OK
127.0.0.1:6379[1]> SELECT 0
OK
127.0.0.1:6379> FLUSHDB
OK
127.0.0.1:6379> keys *
(empty array)

3. 在Java程序中控制Redis
3.1 为什么可以使用Java支持Redis
这个问题,就相当于问,我们为什么可以编写出一个自定义的Redis客户端.首先我们需要知道,在网络通行中,我们会使用到很多的"协议",其中这些协议都是固定好的,是在系统内核中或者驱动程序中实现的,程序员只可以选择,不可以修改.其中传输层协议常见的包含两种,一种是TCP协议,一种是UDP协议,**其中Redis在传输层TCP协议的基础上,自定义了应用层协议,这个协议就是RESP协议.**作为第三方的Java,想要开发一个Redis的客户端,也就需要知道Redis的应用层协议,Redis的RESP协议是在官网上开源出来的.

3.2 配置Windows环境与服务器的连接
在Java开发中,我们一般使用idea进行开发,也就是我们不可以在Linux操作系统上直接对Java进行开发,我们是高度依赖Windows环境的.这就需要我们把Windows中的Redis客户端连接到Linux云服务器中的Redis服务器中.这样的操作,就需要通过Linux服务器的外网IP和Redis服务器的端口号来访问到.但是光知道外网IP和端口号还是不行的,因为Redis服务器对应的默认6379端口号是被云服务器的防火墙保护起来的.也就是这个端口不可以在外网中访问到.
但是千万不可以在云服务器中的安全组配置中开放6379端口号,因为Redis的6379端口号安全系数非常低.开放在公网上很容易被黑客入侵.
那怎么办呢,此时就需要我们来配置xshell客户端与Java客户端的ssh端口转发,把云服务器上的Redis端口映射到本地的主机上.

什么是ssh呢?
ssh就是一个应用层网络协议,ssh默认走的是云服务器的22端口.其中ssh协议最重要的功能就是支持端口转发,相当于通过22端口来传递其他端口的数据.
在Windows主机上访问云服务器的6379端口号的时候,ssh就会构造一个数据报,把要访问Redis的请求放到ssh数据报中(访问6379端口号).

这个数据就会通过22端口发送给服务器,服务器的ssh服务程序,就可以解析出上述数据报,然后把数据报交给6379端口的程序.

比如我们将Windows主机上的8888端口号使用ssh协议映射到服务器上的6379端口号.

关于这个转发,我们需要在xshell中进行配置,后续就可以把云服务器中的端口当做一个本地的端口使用.

在使用的服务器上右击,选择属性,选择隧道.

选择添加,设置侦听端口为8888,目标端口6379.

确定之后,重新连接云服务器生效

在Windows系统中的cmd操作版面上,输入指令netstat -nao|findstr 8888查看8888端口的连接状态,如果出现一下界面,说明连接正常.

配置完成之后,后续我们在Java代码中,就可以直接通过127.0.0.1:8888端口来直接访问到云服务器中的Redis.同时外面的客户端无法访问到云服务器的6379.
3.3 在Java中操作Redis
3.3.1 准备工作
引入jedis依赖
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.2</version>
</dependency>

创建Redis连接,并测试连接
public class Main {
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");//redis连接池
        try (Jedis jedis = jedisPool.getResource()){//获取数据源
            String ping  = jedis.ping();
            System.out.println(ping);
        }
    }
}

返回pong,说明连接成功.

3.3.2 关于String的操作
get,set.
public class Main {
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");//redis连接池
        try (Jedis jedis = jedisPool.getResource()){//获取数据源
            stringTest(jedis);
        }
    }
    private static void stringTest(Jedis jedis){
        jedis.set("key1","value1");//set一次只可以设置一个键值对
        jedis.set("key2","value2");
        jedis.set("key3","value3");
        String key1 = jedis.get("key1");
        String key2 = jedis.get("key2");
        String key3 = jedis.get("key100");
        System.out.println(key1);
        System.out.println(key2);
        System.out.println(key3);
    }
}

mset,mget
private static void stringTest2(Jedis jedis){
    jedis.flushAll();
    jedis.mset("key1","value1","key2","value2","key3","value3");//key和value交替设置
    List<String> list = jedis.mget("key1","key2","key3");//由于value的值可以重复,所以使用的是list来接收
    System.out.println(list);
}
 

在mset的时候,key和value是交替设置的.在mget接收value的时候,由于value的值是可以重复的.所以我们使用List来接收.

exists,del
private static void stringTest3(Jedis jedis){
    jedis.flushAll();
    jedis.set("key1","value1");
    Boolean ret = jedis.exists("key1");//返回Boolean,即该key是否存在
    System.out.println(ret);
    Long ret1 = jedis.del("key1");//返回的是Long类型,即删除成功的个数
    System.out.println(ret1);
}


exists返回的是Boolean,即该key是否存在,del返回的是Long类型,即删除成功的个数.

keys
private static void stringTest4(Jedis jedis){
    jedis.flushAll();
    jedis.set("key1","value1");
    jedis.set("key2","value2");
    jedis.set("key3","value3");
    jedis.set("key4","value4");
    jedis.set("key100","value100");
    Set<String> keys = jedis.keys("*");//由于key不可以重复,所以我们使用set来接收
    System.out.println(keys);
    Set<String> keys1 = jedis.keys("key?");//?只匹配一个字符
    System.out.println(keys1);
    Set<String> keys2 = jedis.keys("key*");//*可以匹配多个字符
    System.out.println(keys2);
}
 

expire,ttl
private static void stringTest5(Jedis jedis) throws InterruptedException {
    jedis.flushAll();
    jedis.set("key1","value1");
    jedis.set("key2","value2");
    jedis.set("key3","value3");
    jedis.set("key4","value4");
    jedis.expire("key1",5);
    Long key1 = jedis.ttl("key1");
    System.out.println(key1);
    Thread.sleep(6000);//阻塞6秒
    boolean ret = jedis.exists("key1");
    System.out.println(ret);
}
 

append
private static void stringTest6(Jedis jedis){
    jedis.flushAll();
    jedis.set("key1","value1");
    jedis.append("key1", "aaa");
    System.out.println(jedis.get("key1"));
}
 

getrange,setrange
getrange获取指定字符串区间的字符,setrange设置指定字符串区间的字符.
private static void stringTest7(Jedis jedis){
    jedis.flushAll();
    jedis.set("key1","value1aaaa");
    System.out.println(jedis.getrange("key1", 0, 4));
    jedis.setrange("key1",0,"bbbbb");
    System.out.println(jedis.getrange("key1",0,4));
}

 

setnx
如果存在key,则不设置,返回0,不存在,则设置
private static void stringTest8(Jedis jedis){
    jedis.flushAll();
    jedis.set("key1","value1");
    long setnx = jedis.setnx("key1", "value1");
    System.out.println(setnx);
}
 

setex
设置键值对,并设置过期时间
private static void stringTest9(Jedis jedis) throws InterruptedException {
    jedis.flushAll();
    jedis.setex("key1",2,"value1");
    Thread.sleep(3000);
    String s = jedis.get("key1");
    System.out.println(s);
}
 

incr,decr
给指定的key对应的value+1或-1
private static void stringTest10(Jedis jedis){
    jedis.flushAll();
    jedis.set("key1","1");
    jedis.incr("key1");
    System.out.println(jedis.get("key1"));
    jedis.decr("key1");
    System.out.println(jedis.get("key1"));
}
 

incrby,decrby
private static void stringTest11(Jedis jedis){
    jedis.flushAll();
    jedis.set("key1","1");
    jedis.incrBy("key1",2);
    System.out.println(jedis.get("key1"));
    jedis.decrBy("key1",2);
    System.out.println(jedis.get("key1"));
}
 

3.3.3 关于List的操作
lpush,lpop
private static void listTest1(Jedis jedis){
    jedis.flushAll();
    jedis.lpush("list1","v1","v2","v3");
    System.out.println(jedis.lpop("list1"));
    System.out.println(jedis.lpop("list1"));
    System.out.println(jedis.lpop("list1"));
}
 

rpush,rpop
private static void listTest2(Jedis jedis){
    jedis.flushAll();
    jedis.rpush("key1","v1","v2","v3");
    System.out.println(jedis.rpop("key1"));
    System.out.println(jedis.rpop("key1"));
    System.out.println(jedis.rpop("key1"));
}
 

lrange
查看指定下标区间的元素
private static void listTest3(Jedis jedis){
    jedis.flushAll();
    jedis.rpush("key1","v1","v2","v3");
    System.out.println(jedis.lrange("key1",0,1));//左闭右闭
}
 

blpop
private static void listTest4(Jedis jedis){
    jedis.flushAll();
    jedis.lpush("key1","v1");
    System.out.println(jedis.blpop(0, "key1"));
    System.out.println(jedis.blpop(5, "key1"));
}
 

brpop和blpop同理,这里不再赘述.

lindex
获取指定下标的元素
private static void listTest5(Jedis jedis){
    jedis.flushAll();
    jedis.lpush("key1","v1","v2","v3");
    System.out.println(jedis.lindex("key1", 2));
}
 

linsert
在指定的元素之前或者之后插入指定元素.
private static void listTest6(Jedis jedis){
    jedis.flushAll();
    jedis.lpush("key1","v1","v2");
    jedis.linsert("key1", ListPosition.BEFORE,"v2","100");
    System.out.println(jedis.lrange("key1",0,-1));
}
 

llen
private static void listTest7(Jedis jedis){
    jedis.flushAll();
    jedis.rpush("key1","v1","v2","v3");
    System.out.println(jedis.llen("key1"));
}
 

3.3.4 关于Hash的操作
hset,hget
private static void hashTest1(Jedis jedis){
    jedis.flushAll();
    jedis.hset("key1","field1","value1");
    jedis.hset("key1","field2","value2");
    jedis.hset("key1","field3","value3");
    System.out.println(jedis.hget("key1", "field1"));
    System.out.println(jedis.hget("key1", "field2"));
    System.out.println(jedis.hget("key1", "field3"));
}
 

hexists,hdel
private static void hashTest2(Jedis jedis){
    jedis.flushAll();
    jedis.hset("key1","field1","value1");
    jedis.hset("key1","field2","value2");
    jedis.hset("key1","field3","value3");
    System.out.println(jedis.hexists("key1", "field1"));
    System.out.println(jedis.hexists("key1", "field100"));
    jedis.hdel("key1","field1");
    System.out.println(jedis.hgetAll("key1"));
}
 

hkeys,hvals
private static void hashTest3(Jedis jedis){
    jedis.flushAll();
    jedis.hset("key1","field1","value1");
    jedis.hset("key1","field2","value2");
    jedis.hset("key1","field3","value3");
    System.out.println(jedis.hkeys("key1"));//获取所有的key
    System.out.println(jedis.hvals("key1"));//获取所有的val
}
 

hmget
private static void hashTest4(Jedis jedis){
    jedis.flushAll();
    jedis.hset("key1","field1","value1");
    jedis.hset("key1","field2","value2");
    jedis.hset("key1","field3","value3");
    System.out.println(jedis.hmget("key1","field1","field2"));
}
 

hlen
private static void hashTest5(Jedis jedis){
    jedis.flushAll();
    jedis.hset("key1","field1","value1");
    jedis.hset("key1","field2","value2");
    jedis.hset("key1","field3","value3");
    System.out.println(jedis.hlen("key1"));
}
 

hincrby,hincrbyfloat
private static void hashTest6(Jedis jedis){
    jedis.flushAll();
    jedis.hset("key1","field1","2");
    jedis.hincrBy("key1","field1",1);
    System.out.println(jedis.hget("key1","field1"));
    jedis.hincrByFloat("key1","field1",1.5);
    System.out.println(jedis.hget("key1","field1"));
}
 

3.3.5 关于set的操作
sadd,smember
private static void setTest1(Jedis jedis){
   jedis.flushAll();
   jedis.sadd("key1","m1","m2","m3");
   jedis.sadd("key1","m1");
   System.out.println(jedis.smembers("key1"));
}
 

srem,sismember
private static void setTest2(Jedis jedis){
    jedis.flushAll();
    jedis.sadd("key1","m1","m2","m3");
    System.out.println(jedis.smembers("key1"));
    jedis.srem("key1","m1");
    System.out.println(jedis.smembers("key1"));
    System.out.println(jedis.sismember("key1", "m1"));
    System.out.println(jedis.sismember("key1", "m2"));
}
 

scard
private static void setTest3(Jedis jedis){
    jedis.flushAll();
    jedis.sadd("key1","m1","m2","m3");
    System.out.println(jedis.scard("key1"));
}
 

sinter
private static void setTest4(Jedis jedis){
    jedis.flushAll();
    jedis.sadd("key1","m1","m2","m3");
    jedis.sadd("key2","m2","m3","m4");
    System.out.println(jedis.sinter("key1","key2"));
}
 

sunion和sdiff是同样的道理,这里不再赘述.

3.3.6 关于zset的操作
zadd,zrange,zrangeWithScores
private static void zsetTest1(Jedis jedis){
    jedis.flushAll();
    jedis.zadd("key1",90,"zhangfei");
    jedis.zadd("key1",91,"zhaoyun");
    jedis.zadd("key1",92,"guanyu");
    System.out.println(jedis.zrange("key1",0,-1));
    System.out.println(jedis.zrangeWithScores("key1",0,-1));//返回的是带有分数的二元组
}
 

zrem,zcard
private static void zsetTest2(Jedis jedis){
    jedis.flushAll();
    jedis.zadd("key1",90,"zhangfei");
    jedis.zadd("key1",91,"zhaoyun");
    jedis.zadd("key1",92,"guanyu");
    jedis.zrem("key1","guanyu");
    System.out.println(jedis.zcard("key1"));
    System.out.println(jedis.zrangeWithScores("key1",0,-1));
}
 

zcount
返回指定分数区间的所有key
private static void zsetTest3(Jedis jedis){
    jedis.flushAll();
    jedis.zadd("key1",90,"zhangfei");
    jedis.zadd("key1",91,"zhaoyun");
    jedis.zadd("key1",92,"guanyu");
    System.out.println(jedis.zcount("key1",90,91));
}
 

zpopmax,zpopmin
private static void zsetTest4(Jedis jedis){
    jedis.flushAll();
    jedis.zadd("key1",90,"zhangfei");
    jedis.zadd("key1",91,"zhaoyun");
    jedis.zadd("key1",92,"guanyu");
    System.out.println(jedis.zpopmax("key1"));
    System.out.println(jedis.zpopmin("key1"));
}
 

zrank
按升序的顺序返回指定元素的排名
private static void zsetTest5(Jedis jedis){
    jedis.flushAll();
    jedis.zadd("key1",90,"zhangfei");
    jedis.zadd("key1",91,"zhaoyun");
    jedis.zadd("key1",92,"guanyu");
    System.out.println(jedis.zrank("key1","guanyu"));
}
 

zscore
获取指定元素的分数.
private static void zsetTest6(Jedis jedis){
    jedis.flushAll();
    jedis.zadd("key1",90,"zhangfei");
    jedis.zadd("key1",91,"zhaoyun");
    jedis.zadd("key1",92,"guanyu");
    System.out.println(jedis.zscore("key1","zhaoyun"));
}
 

zincrby
给指定的元素加上指定的分数
private static void zsetTest7(Jedis jedis){
    jedis.flushAll();
    jedis.zadd("key1",90,"zhangfei");
    jedis.zadd("key1",91,"zhaoyun");
    jedis.zadd("key1",92,"guanyu");
    jedis.zincrby("key1",10,"zhaoyun");
    System.out.println(jedis.zscore("key1","zhaoyun"));
}
 

zinterstore
private static void zsetTest8(Jedis jedis){
    jedis.flushAll();
    jedis.zadd("key1",90,"zhangfei");
    jedis.zadd("key1",91,"zhaoyun");
    jedis.zadd("key1",92,"guanyu");
    jedis.zadd("key2",90,"zhangfei");
    jedis.zadd("key2",91,"zhaoyun");
    jedis.zadd("key2",93,"zhugeliang");
    jedis.zinterstore("key3","key1","key2");
    System.out.println(jedis.zrangeWithScores("key3",0, -1));
}
 

union和diff是同样的道理,这里不再赘述.

3.4 在Spring中操作Redis
3.4.1 准备工作
首先,我们需要创建一个Spring项目,在创建项目的时候,我们需要引入"Spring Data Redis"和"Spring Web"依赖.

之后我们需要配置Redis的主机与端口号.在yml配置文件中配置一下内容:

spring:
  redis:
    host: 127.0.0.1
    port: 8888

之后我们需要在Controller中注入StringRedisTemplate对象

@RequestMapping("/redis")
@RestController
public class SpringRedis {
    @Autowired
    public StringRedisTemplate redisTemplate;//注入StringRedisTemplate实例
}

后续我们在操作的时候,就像jedis中共使用jedis对象一样,都用的是注入的redisTemplate对象.

3.4.2 使用String
对于Spring中对Redis的操作,我们不再展示全部方法,有些方法是我们一看就知道什么意思的,学习成本较低,所以我们只展示一部分的方法.

@RequestMapping("/test1")
public String stringTest1(){
    redisTemplate.opsForValue().set("key1","value1");
    return redisTemplate.opsForValue().get("key1");
}
 

这里我们需要注意的是,Spring中的操作和jedis中的操作有些不一样的地方,我们在Spring中操作的时候,需要提前指定操作value的类型,比如我们上面使用opsForValue()指定的就是value为String类型的数据.
我们还需要注意一下几点:

在我们不知道Spring中的什么方法对应Redis中的方法,我们可以使用lambda表达式的方法来为execute()方法传递我们所要在Redis中所做的事情,在lambda表达式中,使用RedisConnection参数的时候,就可以使用我们熟悉的api来操作Redis了,在lambda表达式中操作Redis的方法与我们前面学习jedis的方法大相径庭.
比如我们在执行一个Controller方法之前,我们需要清空数据库:
redisTemplate.execute((RedisConnection connection)->{
    connection.flushAll();
    return null;
});

在使用Spring操作数据库的时候,在我们删除其中的键值对的时候,不需要指定操作的数据类型:
@RequestMapping("/test2")
public String stringTest2(){
    redisTemplate.execute((RedisConnection connection)->{
        connection.flushAll();
        return null;
    });
    redisTemplate.opsForValue().set("key1","value1");
    System.out.println(redisTemplate.opsForValue().get("key1"));
    System.out.println(redisTemplate.delete("key1"));
    return "ok";
}
 

3.4.3 使用List
这里的opsForList()就相当于Redis原生指令操作中开头的l一样,就是首先声明是要对一个List进行操作.

@RequestMapping("/test3")
public String listTest1(){
    redisTemplate.opsForList().rightPushAll("key1","value1","value2");
    System.out.println(redisTemplate.opsForList().range("key1", 0, -1));
    System.out.println(redisTemplate.opsForList().leftPop("key1"));
    System.out.println(redisTemplate.opsForList().leftPop("key1"));
    System.out.println(redisTemplate.opsForList().leftPop("key1"));
    redisTemplate.delete("key1");
    return "ok";
}

 

3.4.4 使用hash
@RequestMapping("/test4")
public String hashTest1(){
    redisTemplate.opsForHash().put("key1","field1","value1");
    redisTemplate.opsForHash().put("key1","field2","value2");
    redisTemplate.opsForHash().put("key1","field3","value3");
    System.out.println(redisTemplate.opsForHash().get("key1","field1"));
    redisTemplate.opsForHash().delete("key1","field1");
    System.out.println(redisTemplate.opsForHash().keys("key1"));
    System.out.println(redisTemplate.opsForHash().values("key1"));
    redisTemplate.delete("key1");
    return "ok";
}
 

3.4.5 使用set
@RequestMapping("/test5")
public String setTest(){
    redisTemplate.opsForSet().add("key1","value1","value2","value3");
    System.out.println(redisTemplate.opsForSet().isMember("key1", "value1"));//判断其中是否存在指定元素
    System.out.println(redisTemplate.opsForSet().remove("key1", "value2"));//删除指定元素
    System.out.println(redisTemplate.opsForSet().pop("key1"));//随机弹出一个元素
    System.out.println(redisTemplate.opsForSet().size("key1"));
    redisTemplate.delete("key1");
    return "ok";
}
 

3.4.6 使用zset
@RequestMapping("/test6")
public String zsetTest(){
    redisTemplate.delete("key1");
    redisTemplate.opsForZSet().add("key1","zhaoyun",90.0);
    redisTemplate.opsForZSet().add("key1","guanyu",91.0);
    redisTemplate.opsForZSet().add("key1","zhugeliang",92.0);
    System.out.println(redisTemplate.opsForZSet().range("key1", 0, -1));//返回指定区间的成员和分数
    System.out.println(redisTemplate.opsForZSet().count("key1", 90.0, 92.0));//返回指定分数区间的元素个数
    return "ok";
}