Redis基础

一、Redis介绍

1.1 NoSQL介绍

  • Redis就是一款NoSQL。
  • NoSQL->非关系型数据库->Not Only SQL。
  • Key-Value : Redis
  • 文档型:ElasticSearch,Solr,Mongodb
  • 面向列:Hbase,Cassandra
  • 图形化:Neo4j
  • 除了关系型数据库都是非关系型数据库。
  • NoSQL只是一种概念,泛指非关系型数据库,和关系型数据库做一个区分。

1.2 Redis介绍

Redis (Remote Dictionary Server)即远程字典服务,Redis是由C语言去编写,Redis是一款基于Key-Value的NoSQL,而且Redis是基于内存存储数据的,Redis还提供了多种持久化机制,性能可以达到11000/s读取数据以及81000/s写入数据,Redis还提供了主从,哨兵以及集群的搭建方式,可以更方便的横向扩展以及垂直扩展。

二、Redis的安装

2.1 安装Redis

Docker-Compose安装

1
2
3
4
5
6
7
8
9
10
version: "3.1"
services:
redis:
image: redis:5.0.7
restart: always
container_name: redis
environment:
- TZ=Asia/Shanghai
ports:
- 6379:6379

2.2 使用redis-cli连接Redis

进去Redis容器的内部

docker exec -it 容器id bash

在容器内部,使用redis-cli连接

2.3 使用图形化界面连接Redis

RedisDesktopManager:https://github.com/lework/RedisDesktopManager-Windows/releases

三、Redis常用命令

3.1 Redis存储数据的结构

常用的5种数据结构:

  • key-string:一个key对应一个值。
  • key-hash:一个key对应一个Map。
  • key-list:一个key对应一个列表。
  • key-set:一个key对应一个集合。
  • key-zset:一个key对应一个有序的集合。

另外三种数据结构:

  • HyperLogLog:计算近似值的。
  • GEO:地理位置。
  • BIT:一般存储的也是一个字符串,存储的是一个byte[]。

五种常用的数据结构

3.2 string常用命令

string常用操作命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#1.添加值
set key value

#2.取值
get key

#3.批量操作
mset key value [key value...]
mget key [key...]

#4.自增命令(自增1)
incr key

#5.自减命令(自减1)
decr key

#6.自增或自减指定数量
incrby key increment
decrby key increment

#7.设置值的同时,指定生存时间(每次向Redis中添加数据时,尽量都设置上生存时间)
setex key second value

#8.设置值,如果当前key不存在的话(如果这个key存在,什么事都不做,如果这个key不存在,和set命令一样)
setnx key value

#9.在key对应的value后,追加内容
append key value

#10.查看value字符串的长度
strlen key

3.3 hash常用命令

hash常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#1.存储数据
hset key field value

#2.获取数据
hget key field

#3.批量操作
hmset key field value [field value...]
hmget key field [field ... ]

#4.自增(指定自增的值)
hincrby key field increment

#5.设置值(如果key-field不存在,那么就正常添加,如果存在,什么事都不做)
hsetnx key field value

#6.检查field是否存在
hexists key field

#7.删除key对应的field,可以删除多个
hdel key field [ field ... ]

#8.获取当前hash结构中的全部field和value
hgetall key

#9.获取当前hash结构中的全部field
hkeys key

#10.获取当前hash结构中的全部value
hvals key

#11.获取当前hash结构中field的数量
hlen key

3.4 list常用命令

list常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#1.存储数据(从左侧插入数据,从右侧插入数据)
lpush key value [ value ... ]
rpush key value [ value ... ]

#2.存储数据(如果key不存在,什么事都不做,如果key存在,但是不是list结构,什么都不做)
lpushx key value
rpushx key value

#3.修改数据(在存储数据时,指定好你的索引位置,覆盖之前索引位置的数据,index超出整个列表的长度,也会失败)
lset key index value

#4.弹栈方式获取数据(左侧弹出数据,从右侧弹出数据)
lpop key
rpop key

#5.获取指定索引范围的数据(start从0开始,stop输入-1,代表最后一个,-2代表倒数第二个)
lrange key start stop

#6.获取指定索引位置的数据
lindex key index

#7.获取整个列表的长度
llen key

#8.删除列表中的数据(他是删除当前列表中的count个value值,count>8从左侧向右侧删除,count 0从右侧向左侧删除,count == 0删除列表中全部的value)
lrem key count value

#9.保留列表中的数据(保留你指定索引范围内的数据,超过整个索引范围被移除掉)
ltrim key start stop

#10.将一个列表中最后的一个数据,插入到另外一个列表的头部位置
rpoplpush list1 list2

3.5set常用命令

set常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#1.存储数据
sadd key member [member ... ]

#2.获取数据(获取全部数据)
smembers key

#3.随机获取一个数据(获取的同时,移除数据,count默认为1,代表弹出数据的数量)
spop key [count]

#4.交集(取多个set集合交集)
sinter set1 set2...

#5.并集(获取全部集合中的数据)
sunion set1 set2...

#6.差集(获取多个集合中不一样的数据)
sdiff set1 set2...

#7.删除数据
srem key member [member...]

#8.查看当前的set集合中是否包含这个值
sismember key member

3.6 zset的常用命令

zset常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#1.添加数据(score必须是数值。member不允许重复的。)
zadd key score member [score member ...]

#2.修改member的分数(如果member是存在于key中的,正常增加分数,如果memeber不存在,这个命令就相当于zadd)
zincrby key increment member

#3.查看指定的member的分数
zscore key member

#4.获取zset中数据的数量
zcard key

#5.根据score的范围查询member数量
zcount key min max

#6.删除zset中的成员
zrem key member [member...]

#7.根据分数从小到大排序,获取指定范围内的数据(withscores如果添加这个参数,那么会返回member对应的分数)
zrange key start stop [withscores]

#8.根据分数从大到小排序,获取指定范围内的数据(withscores如果添加这个参数,那么会返回member对应的分数)
zrevrange key start stop [withscores]

#9.根据分数的返回去获取member(withscores代表同时返回score,添加1imit,就和MySQL中一样,如果不希望等于min或者max的值被查询出来可以采用‘(分数’相当于 < 但是不等于的方式,最大值和最小值使用+inf和-inf来标识)
zrangebyscore key min max [withscores] [limit offset count]

#10.根据分数的返回去获取member(withscores代表同时返回score,添加limit,就和MySQL中一样)
zrangebyscore key max min [withscores] [limit offset count]

3.7key常用命令

key常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#1.查看Redis中的全部的key(pattern:*,XXX*,*XXX)
keys pattern

#2.查看某一个key是否存在(1-key存在,0-key不存在)
exists key

#3.删除key
del key [ key ... ]

#4.设置key的生存时间,单位为秒,单位为毫秒,设置还能活多久
expire key second
pexpire key milliseconds

#5.设置key的生存时间,单位为秒,单位为毫秒,设置能活到什么时间点
expireat key timestamp
pexpireat key milliseconds

#6.查看key的剩余生存时间,单位为秒,单位为毫秒(-2-当前key不存在,-1-当前key没有设置生存时间,具体剩余的生存时间)
ttl key
pttl key

#7.移除key的生存时间(1-移除成功,0-key不存在生存时间,key不存在)
persist key

#8.选择操作的库
select 0~15

#9.移动key到另外一个库中
move key db

3.8库的常用命令

db常用命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#1.清空当前所在的数据库
flushdb

#2.清空全部数据库
flushall

#3.查看当前数据库中有多少个key
dbsize

#4.查看最后一次操作的时间
lastsave

#5.实时监控Redis服务接收到的命令
monitor

四、Java连接Redis

4.1 Jedis连接Redis

4.1.1 导入依赖

1
2
3
4
5
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>

4.1.2 测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Demo1 {
@Test
public void test() {
//1.连接redis
Jedis jedis = new Jedis("192.168.31.108", 6379);
//2.操作Redis
jedis.set("name", "李四");
//3.释放资源
jedis.close();
}

@Test
public void get() {
//1.连接redis
Jedis jedis = new Jedis("192.168.31.108", 6379);
String value = jedis.get("name");
System.out.println(value);
jedis.close();
}
}

4.2 Jedis存储一个对象到Redis以byte[]的形式

4.2.1 准备实体类

1
2
3
4
5
6
7
8
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
private Integer id;
private String name;
private Date birthday;
}

4.2.2 导入spring-context依赖

1
2
3
4
5
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.18.RELEASE</version>
</dependency>

4.2.3 测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
@Test
public void setByteArray() {
//1.连接服务
Jedis jedis = new Jedis("192.168.31.108", 6379);
//2.1准备key(String)-value(User)
String key = "user";
User user = new User(1, "张三", new Date());
//2.2将key和value转换为byte[]
byte[] byteKey = SerializationUtils.serialize(key);
byte[] value = SerializationUtils.serialize(user);
//2.3将key和value存储到Redis
jedis.set(byteKey, value);
//3.释放资源
jedis.close();
}

@Test
public void getByteArray() {
//1.连接Redis服务
Jedis jedis = new Jedis("192.168.31.108", 6379);
//----
//2.1准备key
String key = "user";
//2.2将key转换为byte[]
byte[] byteKey = SerializationUtils.serialize(key);
//2.3 jedis去Redis中获取value
byte[] value = jedis.get(byteKey);
//2.4将value反序列化为User对象
User user = (User) SerializationUtils.deserialize(value);
//2.5输出
System.out.println("user:" + user);
}

4.3 Jedis存储一个对象到Redis以String的形式

4.3.1 导入fastJSON依赖

1
2
3
4
5
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.54</version>
</dependency>

4.3.2 测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Test
public void setString() {
//1.连接Redis
Jedis jedis = new Jedis("192.168.31.108", 6379);
//2.1准备key(String)-value(User)
String key = "StringUser";
User user = new User(2, "李四", new Date());
//2.2使用fastJSON将value转化为,sor字符串
String value = JSON.toJSONString(user);
//2.3存储到Redis中
jedis.set(key, value);
//3. 释放资源
jedis.close();
}

@Test
public void getString() {
//1.连接Redis
Jedis jedis = new Jedis("192.168.31.108", 6379);
//2.1 准备一个key
String key = "StringUser";
//2.2 去redis中查询value
String value = jedis.get(key);
//2.3将value反序列化为User
User user = JSON.parseObject(value, User.class);
//2.4 书橱
System.out.println(user);
//3. 释放资源
jedis.close();
}

4.4 Jedis连接池操作

使用连接池操作Redis,避免频繁创建和销毁链接对象消耗资源

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Test
public void pool2(){
//1.创建连接池配置信息
GenericobjectPoolConfig poolConfig=new GenericobjectPoolConfig();
poolConfig.setMaxTotal(100);//连接池中最大的活跃数
poolConfig.setMaxIdle(10);//最大空闲数
poolConfig.setMinIdle(5);//最小空闲数
poolConfig.setMaxWaitMillis(3000);//当连接池空了之后,多久没获取到Jedis对象,就超时

//2.创建连接池
JedisPool pool = new JedisPool(poolConfig,"192.168.31.108",6379);

//3.通过连接池获取jedis对象
Jedis jedis=pool.getResource();

//4.操作
String value = jedis.get("stringUser");
System.out.println("user:"+value);

//5.释放资源
jedis.close():
}

4.5 Redis的管道操作

因为在操作Redis的时候,执行一个命令需要先发送请求到Redis服务器,这个过程需要经历网络的延迟,Redis还需要给客户端一个响应。

如果我需要一次性执行很多个命令,上述的方式效率很低,可以通过Redis的管道,先将命令放到客户端的一个Pipeline中,之后一次性的将全部命令都发送到Redis服务,Redis服务一次性的将全部的返回结果响应给客户端。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//Redis管道的操作
@Test
public void pipeline(){
//1.创建连接池
JedisPool pool = new JedisPool("192.168.31.108",6379);
long l=System.currentTimeMillis();
//2.获取一个连接对象
Jedis jedis = pool.getResource();
//3.创建管道
Pipeline pipelined = jedis.pipelined();
//3.执行incr - 100000次放到管道中
for(int i=0;1< 100000;i++){
pipelined.incr("qq");
}
//4.执行命令
pipelined.syncAndReturnAll();
//5.释放资源
jedis.close();

System.out.println(System.currentTimeMillis()-1);
}

五、Redis其他配置

修改yml文件,以方便后期修改Redis配置信息

1
2
3
4
5
6
7
8
9
10
11
12
13
version: "3.1"
services:
redis:
image: redis:5.0.7
restart: always
container_name: redis
environment:
- TZ=Asia/Shanghai
ports:
- 6379:6379
volumes:
- ./conf/redis.conf:/usr/local/redis/redis.conf
command:["redis-server","/usr/local/redis/redis.conf"]

5.1 Redis的AUTH

方式一:通过修改Redis的配置文件,实现Redis的密码校验

1
2
# redis.conf
requirepass 密码

三种客户端的连接方式

  • redis-cli:在输入正常命令之前,先输入auth密码即可。
  • 图形化界面:在连接Redis的信息中添加上验证的密码。
  • Jedis客户端:
    • jedis.auth(password);
  • 使用JedisPool的方式
1
2
//使用当前有参构造设置密码
public JedisPool (final GenericobjectPoolConfig poolconfig, final String host, int port, int timeout, final String password)

方式二:在不修改redis.conf文件的前提下,在第一次链接Redis时,输入命令:Config set requirepass密码
后续向再次操作Redis时,需要先AUTH做一下校验。

5.2 Redis的事务

Redis的事务:一次事务操作,改成功的成功,该失败的失败。

先开启事务,执行一些列的命令,但是命令不会立即执行,会被放在一个队列中,如果你执行事务,那么这个队列中的命令全部执行,如果取消了事务,一个队列中的命令全部作废。

  • 开启事务:multi

  • 输入要执行的命令:被放入到一个队列中

  • 执行事务:exec

  • 取消事务:discard

Redis的事务向发挥功能,需要配置watch监听机制

在开启事务之前,先通过watch命令去监听一个或多个key,在开启事务之后,如果有其他客户端修改了我监听的key,事务会自动取消

如果执行了事务,或者取消了事务,watch监听自动消除,一般不需要手动执行unwatch。

5.3 Redis持久化机制

5.3.1 RDB

RDB是Redis默认的持久化机制

  • RDB持久化文件,速度比较快,而且存储的是一个二进制的文件,传输起来很方便。
  • RDB持久化的时机:
    save9001:在900秒内,有1个key改变了,就执行RDB持久化。
    save30010:在300秒内,有10个key改变了,就执行RDB持久化。
    save 60 10000:在60秒内,有10000个key改变了,就执行RDB持久化。
  • RDB无法保证数据的绝对安全。

5.3.2 AOF

AOF持久化机制默认是关闭的,Redis官方推荐同时开启RDB和AOF持久化,更安全,避免数据丢失。

  • AOF持久化的速度,相对RDB较慢的,存储的是一个文本文件,到了后期文件会比较大,传输困难。
  • AOF持久化时机。
    • appendfsync always:每执行一个写操作,立即持久化到AOF文件中,性能比较低。
    • appendfsync everysec:每秒执行一次持久化。
    • appendfsync no:会根据你的操作系统不同,环境的不同,在一定时间内执行一次持久化。
  • AOF相对RDB更安全,推荐同时开启AOF和RDB。

5.3.3 注意事项

同时开启RDB和AOF的注意事项:

如果同时开启了AOF和RDB持久化,那么在Redis岩机重启之后,需要加载一个持久化文件,优先选择AOF文件。

如果先开启了RDB,再次开启AOF,如果RDB执行了持久化,那么RDB文件中的内容会被AOF覆盖掉。

六、Redis常见问题

6.1 key的生存时间到了,Redis会立即删除吗?

不会立即删除。

  • 定期删除:Redis每隔一段时间就去会去查看Redis设置了过期时间的key,会再100ms的间隔中默认查看3个key。
  • 惰性删除:如果当你去查询一个已经过了生存时间的key时,Redis会先查看当前key的生存时间,是否已经到了,直接删除当前key,并且给用户返回一个空值。

6.2 Redis的淘汰机制

在Redis内存已经满的时候,添加了一个新的数据,执行淘汰机制。

  • volatile-lru:在内存不足时,Redis会再设置过了生存时间的key中干掉一个最近最少使用的key。
  • allkeys-lru:在内存不足时,Redis会再全部的key中干掉一个最近最少使用的key。
  • volatile-lfu:在内存不足时,Redis会再设置过了生存时间的key中干掉一个最近最少频次使用的key
  • allkeys-lfu:在内存不足时,Redis会再全部的key中干掉一个最近最少频次使用的key
  • volatile-random:在内存不足时,Redis会再设置过了生存时间的key中随机干掉一个
  • allkeys-random:在内存不足时,Redis会再全部的key中随机干掉一个。
  • volatile-ttl:在内存不足时,Redis会再设置过了生存时间的key中干掉一个剩余生存时间最少的key
  • noeviction:(默认)在内存不足时,直接报错。

指定淘汰机制的方式:maxmemory-policy 具体策略,设置Redis的最大内存:maxmemory 字节大小

6.3 缓存的常见问题

6.3.1 缓存穿透问题

问题出现的原因:查询的数据,Redis中没有,数据库中也没有。

1:根据id查询时,如果id是自增的,将id的最大值放到Redis中,在查询数据库之前,直接比较一下id。

2:如果id不是整形,可以将全部的id放到set中,在用户查询之前,去set中查看一下是否有一个id。

3:获取客户端的ip地址,可以将ip的访问添加限制。

缓存穿透

6.3.2 缓存击穿问题

问题:缓存中的热点数据,突然到期了,造成了大量的请求都去访问数据库,造成数据库岩机?

1.在访问缓存中没有的时候,直接添加一个锁,让几个请求去访问数据库,避免数据库启机。

2.热点数据的生存时间去掉。

缓存击穿

6.3.3 缓存雪崩问题

问题:当大量缓存同时到期时,最终大量的同时去访问数据,导致数据库宏机。

将缓存中的数据的生存时间,设置为30~60的一个随机时间。

缓存雪崩

6.3.4 缓存倾斜问题

问题:热点数据放在了一个Redis几点上,导致Redis几点无法承受住大量的请求,最终Redis启机

1.扩展主从架构,搭建大量的从节点,缓解Redis的压力。

2.可以在Tomcat中做JVM缓存,在查询Redis之前,先去查询Tomcat中的缓存。

缓存倾斜


本博客所有文章除特别声明外,均采用 CC BY-SA 4.0 协议 ,转载请注明出处!