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