狂神聊Redis
Nosql概述
为什么用Nosql
Memcached(缓存)+Mysql + 垂直拆分
分库分表+水平拆分+MySQL集群
早些年MyISAM:表锁,十分影响效率!高并发下就会出现严重的锁问题。
早些年Innodb:行锁
慢慢的就开始使用分库分表来解决写的压力!MySQL在那个年代推出表分区。
4、如今最近的年代。
用户的个人信息,社交网络,地理位置。用户自己产生的数据,用户日志等等爆发式增长!
这时候就需要我们是用NoSQL数据库,NoSQL数据库可以很好的处理以上的情况。
什么是NoSQL?
NoSQL=Not Only SQL (不仅仅是SQL!)
泛指非关系型数据库的,随着web2.0互联网的诞生!传统的关系型数据库很难对付web2.0时代!尤其是超大规模的高并发的社区!暴露出来很多难以克服的问题,NoSQL在当今大数据环境下发展的十分迅速。
很多的数据类型:用户的个人信息,社交网络,地理位置。这些数据类型的存储不需要一个固定的格式!不需要多余的操作就可以横向扩展的! Map<String,Object> 使用键值对来控制!
NoSQL的特点
解藕!!!
1、方便扩展(数据之间没有关系,很好扩展!
2、大数据量,高性能(Redis一秒可以写8万次,写读11万次,NoSQL的缓存记录级,是一种细粒度的缓存,性能会比较高!)
3、数据类型是多样型的。(不需要事先设计数据库!随取随用!如果是数据量十分大的表,很多人就无法设计了!)
4、传统的RDBMS和NoSQL
传统的RDBMS
--结构化组织
--SQL
--数据和关系都存在单独的表中
--操作操作,数据定义语言
--严格的一致性
--基础的事务
NoSQL
--不仅仅是数据
--没有固定的查询语言
--键值对存储,列存储,文档存储、图形数据库(社交关系)
--最终一致性
--CAP定理和BASE(异地多活)初级架构师!
--高性能。高可用,高可扩
--。。。
大数据时代的3V:主要是描述问题的
1、海量Volume 2、多样Variety 3、实时Velocity
互联网需求的3高:主要是对程序的要求
高并发、高可扩(随时水平拆分)、高性能(保证用户体验)
真正在公司中的实践:NoSQL+RDBMS一起使用才是最强的,阿里巴巴的架构演进!
技术没有高低之分,就看你如何使用!(提升内功,思维的提高!)
阿里巴巴的演进分析
# 1、商品的基本信息
名称、价格、商家信息
关系型数据库就可以解决了!MySQL/Oracle(淘宝早年就去IOE了!-王坚:推荐文章:阿里云的这群疯子:40分钟重要!)
淘宝内部的MySQL不是大家用的MySQL
# 2、商品的描述、评论(文字比较多)
文档型数据库中,MongoDB
# 3、图片
分布式文件系统 FastDFS
-淘宝自己的TFS
-Gooale的GFS
-Hadoop HDFS
-阿里云的OSS
# 4、商品的关键字(搜索)
-搜索引擎 solr elasticsearch
-ISerach:多隆(多去了解一下这些技术大佬!)
所有牛逼的人都有一段苦逼的岁月。
# 5、商品的波段信息
-内存数据库
-Redis Tair、 Memache...
# 6、商品的交易,外部的支付接口
-三方应用
大型互联网应用问题:
·数据类型太多了
·数据源繁多,经常重构!
·数据要改造,大面积改造!
NoSQL的四大分类
KV键值对:
新浪:Reids
美团:Redis+Tair
阿里、百度:Redis+memecache
文档型数据库(bson格式和json一样):
MongoDB(一般必须要掌握)
MongoDB:是一个基于分布式文件存储的数据库,C++编写,主要用来处理大量的文档!
MongoDB是一个介于关系型数据库和非关系数据库中间的产品!MongoDB是非关系型数据库中功能最丰富,最像关系型数据库的!
ConthDB
列存储数据库
HBase
分布式文件系统
图关系数据库
不是用来存图型的,放的是关系,比如朋友圈社交网络,广告推荐!
Neo4j,InfoGrid;
Redis入门
概述
Redis是什么?
Redis(Remote DiDictionary Server),即远程字典服务。
是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。
免费和开源!也被人称之为结构化数据库!
Redis能干什么?
1、内存存储、持久化,内存中是断电即失的,所以说持久化很重要(rdb、aof)
2、效率高,可以用于高速缓存
3、发布订阅系统
4、地图信息分析
5、计时器、计数器(浏览量!)
6、…
特性
1、多样的数据类型
2、持久化
3、集群
4、事务
…
学习中要用到的东西
官网:http://Redis.IO/
中文网:http://www.redis.cn/
Redis推荐都是在Linux服务器上搭建的。
ping 测试链接
set key value 设置key value
get key 获取key键对应的value
Linux 安装
1、下载安装包
2、解压Redis的安装包!程序/opt
3、进入解压后的文件,可以看到redis.conf
4、基本的环境安装
yum install gcc-C++
make
5、redis的默认安装路径 ‘/usr/local/bin’
6、将redis配置文件。
7、redis默认不是后台启动的
8、启动redis服务
redis-server kconfig/redis.conf
//按照选定的配置文件进行启动
redis-cli -p 6379
keys * 查看所有的key
9、使用redis-cli进行测试连接
10、查看redis的进程是否开启
ps -ef|grep redis
11、如何关闭Redis服务呢?
shutdown //关闭redis
exit //退出
13、后面我们会使用单机多Redis启动集群服务
使用docker 来安装redis
docker start redis
连接客户端语句
docker exec -it myredis redis-cli
关闭myredis服务
docker stop redis
查看当前涉及到redis的进程
工具的使用
测试性能
redis-benchmark是一个压力测试工具
我们来简单测试下:
#测试:100个并发连接 100000个请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000
序号 选项 描述 默认值
1 -h 指定服务器主机名 127.0.0.1
2 -p 指定服务器端口 6379
3 -s 指定服务器 socket
4 -c 指定并发连接数 50
5 -n 指定请求数 10000
6 -d 以字节的形式指定 SET/GET 值的数据大小 2
7 -k 1=keep alive 0=reconnect 1
8 -r SET/GET/INCR 使用随机 key, SADD 使用随机值
9 -P 通过管道传输 请求 1
10 -q 强制退出 redis。仅显示 query/sec 值
11 –csv 以 CSV 格式输出
12 -l 生成循环,永久执行测试
13 -t 仅运行以逗号分隔的测试命令列表。
14 -I Idle 模式。仅打开 N 个 idle 连接并等待。
====== SET ======
100000 requests completed in 3.56 seconds #10万个请求3.56s
100 parallel clients #100个并发客户端
3 bytes payload #每次写入3个字节
keep alive: 1 #只有一台服务器来处理这些请求,单机性能
host configuration “save”:
host configuration “appendonly”: yes
multi-thread: no
6.49% <= 1 milliseconds #第一毫秒处理了
1.88% <= 2 milliseconds
80.50% <= 3 milliseconds
93.31% <= 4 milliseconds
98.07% <= 5 milliseconds
99.48% <= 6 milliseconds
99.73% <= 7 milliseconds
99.80% <= 8 milliseconds
99.85% <= 9 milliseconds
99.88% <= 10 milliseconds
99.90% <= 11 milliseconds
99.90% <= 12 milliseconds
99.92% <= 15 milliseconds
99.92% <= 16 milliseconds
99.94% <= 17 milliseconds
99.98% <= 18 milliseconds
100.00% <= 18 milliseconds
28074.12 requests per second #每秒处理多少请求
基础的知识
redis默认的有16个数据库
默认使用的是第0个数据库
可以使用select切换数据库
127.0.0.1:6379> select 3 #切换数据库
OK
127.0.0.1:6379[3]> DBSIZE #查看数据库大小
(integer) 0
127.0.0.1:6379[3]> set name wangqinghua
OK
127.0.0.1:6379[3]> DBSIZE #只针对于3号数据库,其他数据库没有
(integer) 1
查看当前数据库所有的key
127.0.0.1:6379[3]> keys *
1) "name"
127.0.0.1:6379[3]> get name
"wangqinghua"
清除当前的数据库
127.0.0.1:6379[3]> flushdb
OK
127.0.0.1:6379[3]> keys *
(empty array)
清除全部数据库的内容
127.0.0.1:6379> select 3
OK
127.0.0.1:6379[3]> flushall
OK
127.0.0.1:6379[3]> select 0
OK
127.0.0.1:6379> keys * #本来我们测试性能的时候插入了,但是在3 数据库执行了flushall清空了全部
(empty array)
Redis是单线程的!
Redis是基于内存操作的,CPU不是Redis的瓶颈,Redis的瓶颈是根据机器的内存和网络的带宽,既然可以使用单线程来做,就使用了单线程!
Redis是C语言写的,官方提供的是100000+的QPS,完全不比同样是使用KV的Memecache差
Redis单线程怎么还这么快?
误区1.高性能的服务器一定是多线程的么?
误区2.多线程(CPU上下文切换)一定比单线程效率高么?
核心 :
redis是将所有的数据全部放在内存中的,所以说使用单线程效率最高(如果是多线程,需要上下文切换),对于内存系统来说,没有上下文切换就是效率最高的,多次读写在一个CPU上,在内存系统看来,单线程的Redis就是最佳方案
五大数据类型
Redis是一种开放源代码(BSD许可)的内存中数据结构存储,用作数据库,缓存和消息代理。它支持数据结构,例如字符串,哈希,列表,集合,带范围查询的排序集合,位图,超日志,带有半径查询和流的地理空间索引。Redis具有内置的复制,Lua脚本,LRU驱逐,事务和不同级别的磁盘持久性,并通过Redis Sentine(哨兵模式)l和Redis Cluster自动分区提供高可用性。
Redis-Key
什么是Redis-Key
判断键值是否存在
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> set name wanghua
OK
127.0.0.1:6379> set age 1
OK
127.0.0.1:6379> key *
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> exists name #存在这个键值么
(integer) 1
127.0.0.1:6379> exists name1
(integer) 0
127.0.0.1:6379> move name 1 #移除这个 1代表当前库
(integer) 1
127.0.0.1:6379> keys *
1) "age"
我们可以联想到我们的单点登录
127.0.0.1:6379> set name wang
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> get name
"wang"
127.0.0.1:6379> expire name 10 #设置我们这个键值对的过期时间
(integer) 1
127.0.0.1:6379> ttl name
(integer) 5
127.0.0.1:6379> ttl name #查看当前key的剩余时间
(integer) 3
127.0.0.1:6379> ttl name
(integer) 2
127.0.0.1:6379> ttl name
(integer) 0
127.0.0.1:6379> get name #已经没了
(nil)
查看key的类型(type)
127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379> set name wang
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> type name
string
127.0.0.1:6379> type age
string
String(字符串)
127.0.0.1:6379> set key1 v1 #设置值
OK
127.0.0.1:6379> get key1
"v1"
127.0.0.1:6379> keys * #获得所有key
1) "key1"
127.0.0.1:6379> exists key1 #是否存在
(integer) 1
127.0.0.1:6379> APPEND key1 "hello" #像一个key中追加字符串
(integer) 7
127.0.0.1:6379> get key1 #追加成功
"v1hello"
127.0.0.1:6379> STRLEN key1 #获取字符串长度
(integer) 7
127.0.0.1:6379> APPEND key1 "wanghuahua"
(integer) 17
127.0.0.1:6379> STRLEN key1
(integer) 17
127.0.0.1:6379> get key1
"v1hellowanghuahua"
127.0.0.1:6379> keys *
1) "key1"
#给一个不存在的key追加值会怎么样呢?
127.0.0.1:6379> APPEND name "wangtaotao"
(integer) 10 #返回长度
#实验发现给一个不存在的key追加值会创建出来一个key
127.0.0.1:6379> keys *
1) "name"
2) "key1"
127.0.0.1:6379> get name
"wangtaotao"
127.0.0.1:6379>
#######################################################
#Redis中自增自减操作(我们的浏览量怎么做)
127.0.0.1:6379> set views 0
OK
127.0.0.1:6379> get views
"0"
127.0.0.1:6379> incr views #自增1
(integer) 1
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> get views
"2"
127.0.0.1:6379> decr views #自减1
(integer) 1
127.0.0.1:6379> get views
"1"
####怎么设置步长呢?
127.0.0.1:6379> incrby views 10 #设置增长量
(integer) 11
127.0.0.1:6379> incrby views 10
(integer) 21
127.0.0.1:6379> get views
"21"
127.0.0.1:6379> decrby views 10 #设置自减量
(integer) 11
127.0.0.1:6379> get views
"11"
#######################################################
字符串范围
#######################################################
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> set key1 "hello,wangtaotao"
OK
127.0.0.1:6379> get key1
"hello,wangtaotao"
127.0.0.1:6379> GETRANGE key1 0 3 #截取字符串[0,3]的内容
"hell"
127.0.0.1:6379> GETRANGE key1 0 -1 #相当于获取全部了setget
"hello,wangtaotao"
####替换
127.0.0.1:6379> keys *
1) "key1"
2) "key2"
127.0.0.1:6379> get key2
"abcdefg"
127.0.0.1:6379> SETRANGE key2 1 xx #指定我们的下标1替换为
(integer) 7
127.0.0.1:6379> get key2
"axxdefg"
#######################################################
#setex (set with expire) #设置过期时间
#setnx (set if not expire) #不存在在设置(在分布式锁中会常常使用)
127.0.0.1:6379> clear
127.0.0.1:6379> setex key3 30 "hello" #设置了一个key3有过期时 间,30s过期
OK
127.0.0.1:6379> ttl key3 #查看该key过期时间
(integer) 25
127.0.0.1:6379> ttl key3
(integer) 22
127.0.0.1:6379> get key3
"hello"
127.0.0.1:6379> setnx myvalue "redis" #如果myvalue不存在,则 myvalue创建
(integer) 1
127.0.0.1:6379> get key3
(nil)
127.0.0.1:6379> setnx myvalue "MongoDB" #如果myvalue存在,则创 建失败
(integer) 0 #返回0 说明我们没有修改成功
127.0.0.1:6379> get myvalue
"redis"
批量获取/设置
#######################################################
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 #同时设置多个值
OK
127.0.0.1:6379> keys *
1) "k2"
2) "k3"
3) "k1"
127.0.0.1:6379> mget k1 k2 k3 #同时获取多个值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v1 k4 v4 #存在不创建,不存在创建?
(integer) 0 #返回0==>原子性操作,要么全成功,要么全失败
127.0.0.1:6379> get k4
(nil)
#######################################################
对象
#######################################################
#设置user对象
#这里的key的设计是:
user:{id}:{filed}
127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "zhangsan"
2) "2"
#######################################################
组合命令
############################################################
#先get在set getset
#如果不存在则返回null,再去赋值
#存在的话,先返回原来的值,再去赋成新的值
127.0.0.1:6379> getset db redis
(nil)
127.0.0.1:6379> get db
"redis"
127.0.0.1:6379> getset db MongoDB
"redis"
127.0.0.1:6379> get db
"MongoDB"
############################################################
String的类似使用场景:
计数器
统计浏览量
粉丝数
对象缓存存储
List
基本数据类型:列表
在Redis里面,List可以当做栈、队列、阻塞队列等等
所有的List命令都是以L开头
添加数据
############################################################
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> LPUSH list one #将一个或多个插入列表头部
(integer) 1
127.0.0.1:6379> LPUSH list two
(integer) 2
127.0.0.1:6379> LPUSH list three
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> LRANGE list 0 1 #后面的先拿出来
1) "three"
2) "two"
#从右边插入,插到了最后边的位置
127.0.0.1:6379> RPUSH list right
(integer) 4
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"
############################################################
移出数据POP
############################################################
LPOP RPOP
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"
######移出list第一个元素
127.0.0.1:6379> LPOP list
"three"
#####移出list最后一个元素
127.0.0.1:6379> RPOP list
"right"
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"
############################################################
LINDEX
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"
127.0.0.1:6379> LINDEX list 1 #通过下标获得list中的某一个值
"one"
127.0.0.1:6379> LINDEX list 0
"two"
############################################################
其他操作
############################################################
#######获取list长度
127.0.0.1:6379> LPUSH list one
(integer) 1
127.0.0.1:6379> LPUSH list two
(integer) 2
127.0.0.1:6379> LPUSH list threre
(integer) 3
127.0.0.1:6379> LLEN list
(integer) 3
#####移除指定的值
#取关 踢出粉丝
127.0.0.1:6379> LPUSH list threre
(integer) 4
127.0.0.1:6379> LREM list 1 one #移出多少个指定的数据 精确匹配
(integer) 1
127.0.0.1:6379> LRANGE list 0 -1
1) "threre"
2) "threre"
3) "two"
127.0.0.1:6379> LREM list 1 threre #我们先移出一个
(integer) 1
127.0.0.1:6379> LRANGE list 0 -1
1) "threre"
2) "two"
127.0.0.1:6379> LPUSH list threre
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1
1) "threre"
2) "threre"
3) "two"
127.0.0.1:6379> LREM list 2 threre #添加后一次性移出两个
(integer) 2
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
############################################################
########只获取/保留一部分
##Java中有trim去空格 修剪list:截断
127.0.0.1:6379> RPUSH mylist hello
(integer) 1
127.0.0.1:6379> RPUSH mylist hello1
(integer) 2
127.0.0.1:6379> RPUSH mylist hello2
(integer) 3
127.0.0.1:6379> RPUSH mylist hello3
(integer) 4
###通过下标截取指定的长度 list被修改了原地操作,只剩下了截取的元素
127.0.0.1:6379> LTRIM mylist 1 2
OK
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello1"
2) "hello2"
############################################################
## rpoplpush 移除列表最后一个元素并添加到新的列表
127.0.0.1:6379> RPUSH mylist "hello"
(integer) 1
127.0.0.1:6379> RPUSH mylist "hello1"
(integer) 2
127.0.0.1:6379> RPUSH mylist "hello2"
(integer) 3
#移除列表最后一个元素并添加到目标的列表 目标列表不存在则自动创建
127.0.0.1:6379> RPOPLPUSH mylist myotherlist
"hello2"
127.0.0.1:6379> LRANGE mylist 0 -1 #查看原来列表
1) "hello"
2) "hello1"
127.0.0.1:6379> LRANGE myotherlist 0 -1 #查看目标列表
1) "hello2"
############################################################
## lset将列表指定下标的值替换成另一个值,相当于更新
## 如果不存在该列表或下标则会报错,存在才会修改
127.0.0.1:6379> exists list
(integer) 0
127.0.0.1:6379> lset list 0 item #列表吧不存在能set值么
(error) ERR no such key #报错不能
127.0.0.1:6379> LPUSH list value1
(integer) 1
127.0.0.1:6379> LRANGE list 0 -1 #我们创建了这个列表
1) "value1"
127.0.0.1:6379> lset list 0 item #我们现在有值能这样set么
OK
127.0.0.1:6379> LRANGE list 0 -1 #可以set,相当于修改
1) "item"
127.0.0.1:6379> lset list 1 other #列表中不存在的下标能set么
(error) ERR index out of range #不能够set
############################################################
## linsert将某个具体的值插入的列表指定元素前面或者后面
127.0.0.1:6379> RPUSH mylist "hello"
(integer) 1
127.0.0.1:6379> RPUSH mylist "world"
(integer) 2
127.0.0.1:6379> LINSERT mylist before "world" "other" #在 其前面插入
(integer) 3
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "other"
3) "world"
127.0.0.1:6379> LINSERT mylist after "world" "hhh" #在 其后面插入
(integer) 4
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "other"
3) "world"
4) "hhh"
############################################################
小结
实际上是一个链表,有before Node after,left,right 都可以插入
如果key不存在,创建新链表
如果key存在,新增内容
如果移除了所有的值,空链表也代表不存在
在两边插入或者改动,效率最高!!!中间元素,相对效率低一点
消息排队!!:LPUSH RPOP 左边进,右边出 队列
LPUSH LPOP 左边进,左边出栈
Set(集合类型)
**特点:**set中的值是不能重复的
set中的值是无序的
set集合操作基本上以S开头
添加取出
############################################################
## sadd添加元素
## smembers 查看set集合
## Java中有contans SISMEMBER查看set中是否包含指定值
127.0.0.1:6379> sadd myset "hello"
(integer) 1
127.0.0.1:6379> sadd myset "taotao"
(integer) 1
127.0.0.1:6379> sadd myset "love taotao"
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "love taotao"
2) "hello"
3) "taotao"
#判断有没有指定的元素
127.0.0.1:6379> SISMEMBER myset hello #不加""也可以
(integer) 1
127.0.0.1:6379> SISMEMBER myset world
(integer) 0
############################################################
## SCARD获取set集合中元素的个数
127.0.0.1:6379> SCARD myset
(integer) 3
127.0.0.1:6379> sadd myset "taotao22222"
(integer) 1
127.0.0.1:6379> SCARD myset
(integer) 4
#### SREM移除set中的指定元素
127.0.0.1:6379> SREM myset hello
(integer) 1
127.0.0.1:6379> scard myset
(integer) 3
127.0.0.1:6379> SMEMBERS myset
1) "taotao22222"
2) "love taotao"
3) "taotao"
#### set无序不重复集合抽取随机
#### SRANDMEMBER随机抽取指定个数元素
127.0.0.1:6379> SMEMBERS myset
1) "taotao22222"
2) "love taotao"
3) "taotao"
127.0.0.1:6379> SRANDMEMBER myset
"love taotao"
127.0.0.1:6379> SRANDMEMBER myset
"taotao22222"
127.0.0.1:6379> SRANDMEMBER myset 2
1) "taotao22222"
2) "taotao"
############################################################
# SPOP随机删除set中的元素
127.0.0.1:6379> SPOP myset
"taotao22222"
127.0.0.1:6379> SMEMBERS myset
1) "love taotao"
2) "taotao"
127.0.0.1:6379> SPOP myset
"taotao"
127.0.0.1:6379> SMEMBERS myset
1) "love taotao"
############################################################
## SMOVE 将一个指定的值移动到另外一个set中
127.0.0.1:6379> sadd myset "hello"
(integer) 1
127.0.0.1:6379> sadd myset "world"
(integer) 1
127.0.0.1:6379> sadd myset "taotao"
(integer) 1
127.0.0.1:6379> sadd myset2 "set2"
(integer) 1
127.0.0.1:6379> keys *
1) "myset2"
2) "myset"
#将"taotao"这个元素从myset移动到myset2中
127.0.0.1:6379> SMOVE myset myset2 "taotao"
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "hello"
2) "world"
127.0.0.1:6379> SMEMBERS myset2
1) "set2"
2) "taotao"
############################################################
## 微博、B站 共同关注!!(并集)
#数字集合类
# --差集 SDIFF返回前者不同于后者的元素
# --交集 SINTER返回两者相同的元素 共同好友的实现
# --并集 SUNION返回两者合在一起的元素
127.0.0.1:6379> sadd key1 a
(integer) 1
127.0.0.1:6379> sadd key1 b
(integer) 1
127.0.0.1:6379> sadd key1 c
(integer) 1
127.0.0.1:6379> sadd key2 c
(integer) 1
127.0.0.1:6379> sadd key2 d
(integer) 1
127.0.0.1:6379> sadd key2 e
(integer) 1
127.0.0.1:6379> SDIFF key1 key2
1) "b"
2) "a"
127.0.0.1:6379> SINTER key1 key2
1) "c"
127.0.0.1:6379> SUNION key1 key2
1) "d"
2) "a"
3) "c"
4) "b"
5) "e"
############################################################
微博
A用户将所有关注的人放在一个集合中!将他的粉丝也放到一个集合中
B用户将所有关注的人放在一个集合中!将他的粉丝也放到一个集合中
共同专注,爱好,粉丝A,B两个集合做SINTER交集计算就出来了
二度好友(六度分割理论)
Hash(哈希)
Map集合,key-map====key-<key,value>
本质上和String没有太大区别,还是简单的key-value
set myhash field taotao
hash操作基本以h开头
存取值
############################################################
## hset单个赋值
## hget单个取出
## hmset多个赋值,存在的覆盖掉,不存在创建
## hmget取出多个hash值
## HGETALL 取出全部hash值
# key value
127.0.0.1:6379> hset myhash field1 taotao
(integer) 1
127.0.0.1:6379> hget myhash field1
"taotao"
####我们的field1存在,理论上是要被覆盖的
127.0.0.1:6379> hmset myhash field1 hello field2 world
OK
127.0.0.1:6379> hmget myhash field1 field2
1) "hello"
2) "world"
127.0.0.1:6379> HGETALL myhash
1) "field1"
2) "hello"
3) "field2"
4) "world"
############################################################
### hdel删除指定的key字段,对应的value值也就消失了
127.0.0.1:6379> hdel myhash field1
(integer) 1
127.0.0.1:6379> HGETALL myhash
1) "field2"
2) "world"
############################################################
## hlen获取hash表的字段数量
127.0.0.1:6379> hmset myhash field1 hello field2 world
OK
127.0.0.1:6379> HGETALL myhash
1) "field2"
2) "world"
3) "field1"
4) "hello"
127.0.0.1:6379> HLEN myhash
(integer) 2
############################################################
### HEXISTS判断hash中指定字段存不存在
127.0.0.1:6379> HEXISTS myhash field1
(integer) 1
127.0.0.1:6379> HEXISTS myhash field3
(integer) 0
############################################################
### HKEYS 只获得我们的field字段
### HVALS 只获得我们的value
127.0.0.1:6379> HKEYS myhash
1) "field2"
2) "field1"
127.0.0.1:6379> HVALS myhash
1) "world"
2) "hello"
############################################################
## HINCRBY 自增 -1相当于自减
## hsetnx 不存在则设置,如果存在则不设置
127.0.0.1:6379> hset myhash field3 5
(integer) 1
127.0.0.1:6379> HINCRBY myhash field3 1
(integer) 6
127.0.0.1:6379> HINCRBY myhash field3 -1
(integer) 5
127.0.0.1:6379> hsetnx myhash field4 hello
(integer) 1
127.0.0.1:6379> hsetnx myhash field4 world
(integer) 0
############################################################
应用
127.0.0.1:6379> hset user:1 name wangtaotao
(integer) 1
127.0.0.1:6379> hget user:1 name
"wangtaotao"
127.0.0.1:6379> hset user:1 age 18
(integer) 1
127.0.0.1:6379> hget user:1 age
"18"
127.0.0.1:6379> HGETALL user:1
1) "name"
2) "wangtaotao"
3) "age"
4) "18"
Zset(有序集合)
在set的基础上,增加了一个值
set:set k1 v1
zset:zset k1 score1 v1
方法
############################################################
### zadd 增加一个zset元素 可以添加多个值
### ZRANGE 查看zset指定范围元素
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> zadd myset 1 one
(integer) 1
127.0.0.1:6379> zadd myset 2 two 3 there
(integer) 2
127.0.0.1:6379> ZRANGE myset 0 -1
1) "one"
2) "two"
3) "there"
############################################################
## 添加三个用户的薪水
127.0.0.1:6379> zadd salary 2500 xiaohong
(integer) 1
127.0.0.1:6379> zadd salary 5000 zahngsan
(integer) 1
127.0.0.1:6379> zadd salary 100000 taotao
(integer) 1
### 从小到大
#### ZRANGEBYSCORE 排序 包括-无穷到正无穷
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf
1) "xiaohong"
2) "zahngsan"
3) "taotao"
#### ZRANGEBYSCORE 从大到小排序
127.0.0.1:6379> ZREVRANGE salary 0 -1
1) "taotao"
2) "zahngsan"
#### ZRANGEBYSCORE 排序 包括-无穷到正无穷 带上sources数据
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores
1) "xiaohong"
2) "2500"
3) "zahngsan"
4) "5000"
5) "taotao"
6) "100000"
#### ZRANGEBYSCORE 指定限制范围查询出来 带sources数据
127.0.0.1:6379> ZRANGEBYSCORE salary -inf 2500 withscores
1) "xiaohong"
2) "2500"
############################################################
### ZRANGE 移除元素
### ZCARD 获取有序集合中的个数
127.0.0.1:6379> ZRANGE salary 0 -1
1) "xiaohong"
2) "zahngsan"
3) "taotao"
127.0.0.1:6379> ZREM salary xiaohong
(integer) 1
127.0.0.1:6379> ZRANGE salary 0 -1
1) "zahngsan"
2) "taotao"
127.0.0.1:6379> ZCARD salary
(integer) 2
############################################################
#### ZCOUNT 获取指定区间Zset的成员数量
flushdb
127.0.0.1:6379> zadd myset 1 hello
(integer) 1
127.0.0.1:6379> zadd myset 2 world 3 taotao
(integer) 2
127.0.0.1:6379> ZCOUNT myset 1 3
(integer) 3
127.0.0.1:6379> ZCOUNT myset 1 2
(integer) 2
############################################################
案例思路:set的排序版
存储班级成绩,员工工资表!
带权重执行 普通消息!重要消息!加权操作!!1
排行榜应用场景 取TOP10功能
三种特殊数据类型
geospatial 地理位置
朋友的定位、附近的人、打车距离计算?
Redis的Geo在Redis3.2版本就推出了!这个功能可以推算地理位置的信息,两地之间的距离,方圆几里的人
可以查询一些测试数据 :http://www.json.cn/Ingcodeinfo/0706D99C19A781A3/
只有六个命令!
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XLwuMo1h-1675266237933)(./FILES/狂神聊Redis.md/截屏2022-12-29%20下午10.28.03.png)]
geoadd
将指定的地理空间位置(纬度、经度、名称)添加到指定的key中
#getadd 添加地理位置
127.0.0.1:6379> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
127.0.0.1:6379> GEOHASH Sicily Palermo Catania
1) "sqc8b49rny0"
2) "sqdtr74hyu0"
127.0.0.1:6379> keys *
1) "Sicily"
127.0.0.1:6379>
GEODIST
GEODIST key member1 member2 [unit]
返回两个给定位置之间的距离。
如果两个位置之间的其中一个不存在, 那么命令返回空值。
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEODIST Sicily Palermo Catania
"166274.15156960039"
redis> GEODIST Sicily Palermo Catania km
"166.27415156960038"
redis> GEODIST Sicily Palermo Catania mi
"103.31822459492736"
redis> GEODIST Sicily Foo Bar
(nil)
redis>
GEOHASH
GEOHASH key member [member ...]
返回一个或多个位置元素的 Geohash 表示。
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEOHASH Sicily Palermo Catania
1) "sqc8b49rny0"
2) "sqdtr74hyu0"
redis>
GEOPOS
GEOPOS key member [member ...]
从key里返回所有给定位置元素的位置(经度和纬度)。
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEOPOS Sicily Palermo Catania NonExisting
1) 1) "13.361389338970184"
2) "38.115556395496299"
2) 1) "15.087267458438873"
2) "37.50266842333162"
3) (nil)
redis>
GEORADIUS
GEORADIUS key longitude latitude radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count]
以给定的经纬度为中心, 返回键包含的位置元素当中, 与中心的距离不超过给定最大距离的所有位置元素。
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEORADIUS Sicily 15 37 200 km WITHDIST
1) 1) "Palermo"
2) "190.4424"
2) 1) "Catania"
2) "56.4413"
redis> GEORADIUS Sicily 15 37 200 km WITHCOORD
1) 1) "Palermo"
2) 1) "13.361389338970184"
2) "38.115556395496299"
2) 1) "Catania"
2) 1) "15.087267458438873"
2) "37.50266842333162"
redis> GEORADIUS Sicily 15 37 200 km WITHDIST WITHCOORD
1) 1) "Palermo"
2) "190.4424"
3) 1) "13.361389338970184"
2) "38.115556395496299"
2) 1) "Catania"
2) "56.4413"
3) 1) "15.087267458438873"
2) "37.50266842333162"
redis>
GEORADIUSBYMEMBER
这个命令和 GEORADIUS 命令一样,都可以找出位于指定范围内的元素,但是 GEORADIUSBYMEMBER的中心点是由给定的位置元素决定的,而不是像 GEORADIUS 那样,使用输入的经度和纬度来决定中心点.
指定成员的位置被用作查询的中心
GEORADIUSBYMEMBER key member radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count]
redis> GEOADD Sicily 13.583333 37.316667 "Agrigento"
(integer) 1
redis> GEOADD Sicily 13.361389 38.115556 "Palermo" 15.087269 37.502669 "Catania"
(integer) 2
redis> GEORADIUSBYMEMBER Sicily Agrigento 100 km
1) "Agrigento"
2) "Palermo"
redis>
GEO底层的实现原理其实就是Zset!我们可以使用Zset命令来操作geo!
zrange china:city 0 -1
#查看地图中全部元素
zrem china:city beijing
#移除地图中指定元素
Hyperloglog
什么是基数?
A{1,3,5,7,9,7}
B{1,3,5,7,8}
基数(不重复的元素)=5,可以接受误差!
简介
Redis2.8.9版本就更新了Hyperloglog数据结构!
RedusHyperloglog基数统计的算法!
优点:占用的内存是固定的,2^64不同的元素的技术,只需要废12KB内存!如果从内存角度来比较的话 Hyperloglog首选!
网页的UV(一个人访问一个网站多次,但是还算作一个人!)
传统的方式,set保存用户的ID,然后就可以统计set中的元素数量作为标准判断!
这个方式如果保存大量的用户id,就会比较麻烦!我们的目的是为了计数,而不是保存用户id;
0.81%错误率!统计UV任务,可以忽略不计的!
测试使用
127.0.0.1:6379> PFadd mykey a b c d e f g h i j #创建第一组元素
(integer) 1
127.0.0.1:6379> PFcount mykey #统计mykey中元素的基数数量
(integer) 10
127.0.0.1:6379> PFadd mykey2 #创建第二组元素
(integer) 1
127.0.0.1:6379> Pfadd mykey2 i j k z x c v b
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 8
127.0.0.1:6379> pfmerge mykey3 mykey mykey2 #合并两组 mykey mykey2=>mykey3 取并集
OK
127.0.0.1:6379> pfcount mykey3 #查看并集的数量
(integer) 14
如果允许容错 那么一定可以使用Hyperloglog!
如果不允许容错 那么使用set或者自己的数据类型即可!
Bitmaps
位存储
统计疫情感染人数:0 1 0 1
统计用户信息,活跃,不活跃!登陆、未登录!打卡,365打卡!userid status day
两个状态的都可以使用Bitmaps位图,数据结构!都是操作二进制位来进行记录,就只有0和1两个状态。
测试
使用bitmap来记录周一到周日的打卡!
周一:1 周二:0 周三:0 …
127.0.0.1:6379> setbit sign 0 1
(integer) 0
127.0.0.1:6379> setbit sign 1 0
(integer) 0
127.0.0.1:6379> setbit sign 2 0
(integer) 0
127.0.0.1:6379> setbit sign 3 0
(integer) 0
127.0.0.1:6379> setbit sign 4 1
(integer) 0
127.0.0.1:6379> setbit sign 5 1
(integer) 0
127.0.0.1:6379> setbit sign 6 0
(integer) 0
127.0.0.1:6379> setbit sign 7 1
(integer) 0
127.0.0.1:6379>
查看某一天是否打卡
127.0.0.1:6379> getbit sign 6
(integer) 0
127.0.0.1:6379> getbit sign 7
(integer) 1
127.0.0.1:6379>
统计操作,统计打卡的天数!
127.0.0.1:6379> bitcount sign #统计这周的打卡记录,就可以
(integer) 4
事务
Redis事务的本质:一组命令的集合!一个事务中的所有命令都会被序列化,在事务执行过程中,会按照顺序执行!
一次性、顺序性、排他性!执行一系列的命令!
Redis要么同时成功,要么同时失败,原子性!
---队列 set set set 执行---
Redis事务没有隔离级别的概念!
所有的命令在事务中,并没有直接被执行!只有发起执行命令的时候才会执行!Exec
Redis单条命令是保存原子性的,但是事务不保证原子性!
Redis的事务:
·开启事务(multi)
·命令入队()
·执行事务()
锁:Redis可以实现乐观锁,watch
正常执行事务!
127.0.0.1:6379> multi #开启事务
OK
#命令入队
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) OK
3) OK
127.0.0.1:6379>
放弃事务
127.0.0.1:6379> multi #开启事务
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> discard #取消事务
OK
127.0.0.1:6379> get k4 #事务队列中命令都不会执行!
(nil)
127.0.0.1:6379> get k3
"v3"
编译型异常(代码有问题!命令有错!),事务中所有的命令都不会被执行
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> getset k3 #错误的命令
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> set k5 v5
QUEUED
127.0.0.1:6379(TX)> exec #执行事务报错
(error) EXECABORT Transaction discarded because of previous errors. #所有的命令都不会被执行
127.0.0.1:6379>
运行时异常(1/0),如果事务队列中存在语法性,那么执行命令的时候,其它命令是可以正常执行的,错误命令【抛出异常】
127.0.0.1:6379> set k1 "v1"
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incr k1 #会执行的时候失败!
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 b3
QUEUED
127.0.0.1:6379(TX)> get v3
QUEUED
127.0.0.1:6379(TX)> exec
1) (error) ERR value is not an integer or out of range #虽然第一条命令报错了,但是依旧正常执行成功了!
2) OK
3) OK
4) (nil)
127.0.0.1:6379> get k2
"v2"
监控!Watch(面试常问!)
悲观锁:
· 很悲观,什么时候都会出问题,无论做什么都会加锁!
乐观锁:
· 很乐观,认为什么时候都不会出问题,所以不会上锁!更新数据的时候去判断一下,在此之间是否有人修改过这个数据,
· 获取version
· 更新的时候比较version
Redis测监视测试
正常执行成功
127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> get out
"0"
127.0.0.1:6379> watch money #监视money对象
OK
127.0.0.1:6379> multi #事务正常结束,数据期间没有发生变动,这个时候就正常执行成功
OK
127.0.0.1:6379(TX)> decrby money 20
QUEUED
127.0.0.1:6379(TX)> incrby out 20
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 80
2) (integer) 20
测试多线程修改值,使用watch可以当作redis的乐观锁操作!
127.0.0.1:6379> watch money #监视 money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> decrby money 10
QUEUED
127.0.0.1:6379(TX)> incrby out 10
QUEUED
127.0.0.1:6379(TX)> exec #执行之前,另外一个线程修改了我们的值,这个时候就会导致我们事务执行失败!
(nil)
如果修改失败,获取最新的值就好!
127.0.0.1:6379> unwatch #1、如果发现事务执行失败,就先解锁
OK
127.0.0.1:6379> watch money #2、获取最新的值,再次监视,select version
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> decrby money 10
QUEUED
127.0.0.1:6379(TX)> incrby out 10
QUEUED
127.0.0.1:6379(TX)> exec #3、比对监视的值是否发生了变化,如果没有变化,那么可以执行成功,如果变化了就执行失败!
1) (integer) 990
2) (integer) 30
127.0.0.1:6379>
Jedis
我们要使用Java来操作Redis
什么是Jedis 是Redis官方推荐的java连接开发工具!使用Java操作Redis中间件!如果你要使用java操作redis,那么一定要对Jedis十分熟悉
测试
<!-- 导入jedis包-->
<dependencies>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.6.3</version>
</dependency>
<!-- fastjson-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.79</version>
</dependency>
</dependencies>
2、编码测试
·连接测试
·操作命令
·断开连接
package com.kuang;
import redis.clients.jedis.Jedis;
public class TestPing {
public static void main(String[] args) {
//1、new jedis对象即可
Jedis jedis = new Jedis();
//Jedis 所有的命令就是我们之前学习的所有指令!所以之前的指令学习很重要!
jedis.auth("root");
System.out.println(jedis.ping());
jedis.set("king", String.valueOf(1));
System.out.println(jedis.get("king"));
}
}
常用的Api
String
List
Set
Hash
Zset
package com.kuang;
import redis.clients.jedis.Jedis;
import java.util.Set;
public class TestPing {
public static void main(String[] args) {
//1、new jedis对象即可
Jedis jedis = new Jedis("127.0.0.1",6379);
//Jedis 所有的命令就是我们之前学习的所有指令!所以之前的指令学习很重要!
jedis.auth("root");
System.out.println(jedis.ping());
jedis.set("king", String.valueOf(1));
System.out.println(jedis.get("king"));
System.out.println("清空数据!:"+jedis.flushDB());
System.out.println("判断某个键是否存在:"+jedis.exists("username"));
System.out.println("新增键值对:"+jedis.set("username", String.valueOf("kuang")));
System.out.println("新增键值对:"+jedis.set("password", String.valueOf("password")));
Set<String> keys = jedis.keys("*");
System.out.println("删除键:"+jedis.del("password"));
System.out.println("判断键是否存在:"+jedis.exists("password"));
System.out.println("判断键所存储的值是什么类型:"+jedis.type("username"));
System.out.println("随机返回key空间中的一个:"+jedis.randomKey());
System.out.println("重命名key:"+jedis.rename("username", "name"));
System.out.println("取出键值:"+jedis.get("name"));
System.out.println("按照索引查询:"+jedis.select(0));
System.out.println("返回当前数据库中key的数目:"+jedis.dbSize());
System.out.println("清空所有数据库中的key:"+jedis.flushAll());
}
}
package com.kuang;
import redis.clients.jedis.Jedis;
import java.util.concurrent.TimeUnit;
public class TestString {
public static void main(String[] args) {
Jedis jedis = new Jedis("127.0.0.1",6379);
jedis.auth("root");
// 添加数据
jedis.set("key1", String.valueOf("value1"));
jedis.set("key2","value2");
jedis.set("key3","value3");
// 删除键值
jedis.del("key2");
// 获取键值
jedis.get("key2");
// 修改键值
jedis.set("key1","value1");
// 在key3后面加入值
jedis.append("key3","End");
// 添加多个键值对
jedis.mset("key01","value01","key02","value02","key03","value03");
// 获取多个键值对
jedis.mget("key01","key02","key03");
// 删除多个键值对
jedis.del("key01","key02","key03");
jedis.flushDB();
// 新增键值对防止覆盖原先值 分布式锁的应用
jedis.setnx("key1","value1");
jedis.setnx("key2","value2");
jedis.setnx("key3","value3");
// 新增键值对并设置有效时间
jedis.setex("key3",2,"value3");
try
{
TimeUnit.SECONDS.sleep(3);
}catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println(jedis.keys("*"));
}
}
package com.kuang;
import redis.clients.jedis.Jedis;
import java.util.HashMap;
import java.util.Map;
public class TestHash {
public static void main(String[] args) {
Jedis jedis = new Jedis("127.0.0.1",6379);
jedis.auth("root");
jedis.flushDB();
Map<String, String> map = new HashMap<>();
map.put("key1","value1");
map.put("key2","value2");
map.put("key3","value3");
// 添加名称为Hash(key)的hash元素
jedis.hmset("hash",map);
// 向名称为hash的hash中添加key为key5,value为value5元素
jedis.hset("hash","key5","value5");
}
}
事务
package com.kuang;
import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
public class TestTX {
public static void main(String[] args) {
Jedis jedis = new Jedis("127.0.0.1",6379);
jedis.auth("root");
jedis.flushDB();
JSONObject jsonObject = new JSONObject();
jsonObject.put("hello","world");
jsonObject.put("name","ala");
// 开启事务
Transaction multi = jedis.multi();
String result = jsonObject.toJSONString();
try{ //如果成功则执行事务
multi.set("user1",result);
multi.set("user2",result);
int i =1/0; //代码执行失败,抛出异常!
multi.exec(); //执行事务!
}
catch (Exception e)
{
multi.discard();//如果失败,则放弃事务
e.printStackTrace();
}
finally {
System.out.println(jedis.get("user1"));
System.out.println(jedis.get("user2"));
jedis.close();//关闭连接
}
}
}
SpringBoot集合
SpringBoot操作数据:Spring-Data jpa jdbc mongodb redis!
SpringData也是和SpirngBoot齐名的项目!
说明:在SoringBoot2.x之后,原来使用的Jedis被替换成了lettuce-core
Jedis:采用的是直连,多个线程操作的话是不安全的,如果想要避免不安全的,使用Jedis pool连接池!更像是BIO模式
lettuce:采用Netty,实例可以在多个线程中进行共享,不存在线程不安全的情况!可以减少线程数量,更像是NIO模式
源码分析:
@Bean
@ConditionalOnMissingBean(
name = {"redisTemplate"}//我们可以自己定义一个RedisTemplate来替换这个默认的!
)
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
//默认的RedisTemplate没有过多的设置,Redis对象都是需要序列化!同Dubbo、
//两个泛型都是Object,Object的类型,我们后使用需要强制转换成<Spring,Object>
RedisTemplate<Object, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
@Bean
@ConditionalOnMissingBean //由于String是Redis中最常用的类型,所以说单独提出来了一个bean!
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
return new StringRedisTemplate(redisConnectionFactory);
}
整合测试一下
1、导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
2、配置连接
# SpringBoot所有的配置类,都有一个自动配置类
# 自动配置类都会绑定一个Properties配置文件RedisProperties
#配置redis
spring.data.redis.host=127.0.0.1
spring.data.redis.port=6379
spring.data.redis.database=0
3、测试
@SpringBootTest
class Redis02SpringbootApplicationTests {
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
// redisTemplate 操作不同的数据类型
//opsForValue 操作字符串 类似于String
// opsForList 操作List 类似于List
// opsForHash 操作Hash
// opsForZSet
// opsForHyperLogLog
// 除了基本的操作,我们常用的方法,都可以直接通过redisTemplate操作,比如事务和基本的CRUD
// 获取Redis的连接对象
RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
connection.flushDb();
connection.flushAll();
//
redisTemplate.opsForValue().set("mykey","alakuang");
System.out.println(redisTemplate.opsForValue().get("mykey"));
System.out.println("1111");
}
}
默认序列化配置
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WSK6s2vh-1675266237934)(media/16731853661514/16737991763411.png)]
所有的对象需要序列化
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GQgzw2ON-1675266237934)(media/16731853661514/16738002279689.png)]
序列化配置
@Configuration
public class RedisConfig {
// 固定模版
// 编写我们自己的redisTemplate
// 我们自定义了一个RedisTemplate
@Bean
@SuppressWarnings("all")
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory)
throws UnknownHostException {
// 我们为了自己开发方便,一般使用<String,Object>方式
RedisTemplate<String , Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
// Json序列化配置
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>();
// 转义
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// String的序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// 配置具体的序列化方式
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
// value序列化采用jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
所有的redis操作,其实对于java开发人员来说,十分的简单,更重要的是去理解Redis的思想和每一种数据结构的用处和作用场景!
Redis.conf详解
1、配置文件unit单位对大小写不敏感!
包含 include
就好比我们学习Spring、import,include
网络。network
bind 127.0.0.1 *代表所有 #绑定的ip
protected-mode yes #保护模式
port 6379 #端口设置
通用 GENERAL
daemonize yes. #以守护进程的方式运行,默认是 no,我们需要自己开始为yes!
pidfile /var/run/redis_6379.pid #如果以后台方式运行,我们就需要指定一个pid文件!
#日志
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably) 生产环境
# warning (only very important / critical messages are logged)
loglevel notice
logfile "" #日志的文件位置名
databases 16 #数据库的数量,默认是16个数据库
always-show-logo no #是否总是显示logo
快照
持久化,在规定的时间内,执行了多少次操作,则会持久化文件 .rdb .aof
redis是内存数据库,如果没有持久化,那么数据断电即失!
#如果900s内,如果至少有一个key进行了修改,我们就进行持久化操作
#假设300s内,如果至少100个key进行了修改,我们即进行持久化操作
#假设60s内,如果有10000个key进行了修改,我们即进行持久化操作
save 3600 1 300 100 60 10000
#我们之后学习持久化,会自己定义这个测试!
stop-writes-on-bgsave-error yes #持久化如果出错,是否还会持续工作
rdbcompression yes #是否压缩rdb文件,这个时候会需要消耗一些cpu资源
rdbchecksum yes #保存rdb文件,是否校验rdb文件。
dir ./ #rdb文件保存的目录!
replication复制,我们后面讲解主从复制的时候再进行讲解
SECURITY 安全
可以在这里设置redis的密码,默认是没有密码
127.0.0.1:6379> config set requirepass "root" #设置redis的密码
OK
127.0.0.1:6379> config get requirepass #获取redis的密码
1) "requirepass"
2) "root"
127.0.0.1:6379> auth root #使用密码进行登录
OK
限制CLIENTS
maxclients 10000 #设置能连接上redis的最大客户端的数量
maxmemory <bytes> #redis配置最大的内存容量
maxmemory-policy noeviction #内存到达上限之后的处理策略
##六种策略
①noeviction: 不删除策略, 达到最大内存限制时, 如果需要更多内存, 直接返回错误信息。
②allkeys-lru: 所有key通用; 优先删除最近最少使用(less recently used ,LRU) 的 key。
③volatile-lru: 只限于设置了 expire 的部分; 优先删除最近最少使用又过期(less recently used ,LRU) 的 key。
④allkeys-random: 所有key通用; 随机删除一部分 key。
⑤volatile-random: 只限于设置了 expire 的部分; 随机删除一部分过期 key。
⑥volatile-ttl: 只限于设置了 expire 的部分; 优先删除剩余时间(time to live,TTL) 短的key。
APPEND ONLY MODE aof配置
appendonly no #默认是不开启aof模式的,默认是使用rdb方式持久化的,在大部分所有的情况下,rdb完全够用!
appendfilename "appendonly.aof" #持久化文件名。
appendfsync always #每次修改都会sync,消耗性能
appendfsync everysec #每秒执行一次sync,可能会丢失这1s的数据!
appendfsync no #不执行sync,这个时候操作系统自己同步数据,速度最快!
具体的配置在持久化中详细讲解
配置过程redis.conf中遇到的问题
#启动容器并加载配置
docker run -d --name redis -v /Users/ala_kuang/docker/redis/redis.conf:/etc/redis/redis.conf -p 6380:6380 -p 16380:16380 redis --cluster-enabled yes --port 6380
#docker redis 容器内部不存在vim,需要再进行下载vim
apt-get update #更新软件列表
apt-get install vim #下载
vim命令
:%d #清空文件内容
bash命令 rm -f 文件夹或文件名 #强制删除文件或文件夹
#解决Could not connect to Redis at 127.0.0.1:6379: Connection refused问题
redis-cli -h 127.0.0.1 -p 6380 #使用6380端口开启redis-cli
Redis持久化
面试和工作,持久化都是重点!
Redis是内存数据库,如果不将内存中的数据库状态保存到磁盘,那么一旦服务器进程退出,服务器中的数据库状态也会消失。所以Redis提供了持久化功能!
RDB(Redis DataBase)
什么是RDB
在主从复制中,rdb就是用来备用的!丛机上面!不占用主机内存。
RDB:每隔一段时间,把内存中的数据写入磁盘的临时文件,作为快照,恢复的时候把快照文件读进内存。如果宕机重启,那么内存里的数据肯定会没有的,重启Redis后,则会恢复。是一个全量的备份模式。
简单说,就是Redis定期备份内存数据,系统重启后,再从备份数据读取到内存中。
Redis会单独创建(fork)一个子进程来进行持久化,会先将数据写入到一个临时文件中,待持久化过程都结束了,再用这个临时文件替换上次持久化好的文件。整个过程中,主进程是不进行任何IO操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复,且对于数据恢复的完整性不是非常的敏感,那RDB方式要比AOF方式更加的高效。RDB的缺点就是最后一次持久化后的数据可能丢失。
我们默认的就是RDB,一般情况下不需要修改这个配置!
有时候在生产环境,我们会将这个文件进行备份!
rdb保存的文件是 dump.rdb 都是在我们的配置文件中的快照中进行配置的
dbfilename dump.rdb
sava 60 5 #只要60s内修改了5次key,就会触发rdb操作
触发机制
1、save的规则满足的情况下,会自动触发rdb规则
2、执行flushall命令,也会触发我们的rdb规则!
3、退出redis,也会产生rdb文件!
备份就自动生成一个dump.rdb
如何恢复rdb文件!
1、只需要将rdb文件放在我们redis启动目录就可以,redis启动的时候会自动检测dump.rdb恢复其中的数据!
2、查看需要存放的位置
127.0.0.1:6379> config get dir
1) "dir"
2) "/data" #如果在这个目录下存在 dump.rdb文件,启动就会自动恢复其中的数据
几乎就他自己默认的配置就够用了,但是我们还是需要去学习
优点 | 1、适合大规模的数据恢复!2、如果对数据的完整性要求不高! |
---|---|
缺点 | 1、需要一定的时间间隔进行操作!如果redis意外宕机了,最后一次修改数据就没有了!2、fork进程的时候,会占有一定的内存空间! |
AOF (Append Only File)
将我们的所有命令都记录下来,history,恢复的时候就把这个文件全部再执行一遍
是什么
以日志的形式来记录每个写操作,将Redis执行过的所有指令记录下来(读操作不记录),只许追加文件但不可以改写文件,redis启动之初会读取该文件重新构建数据,换言之,redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作
AOF保存的是appendonly.aof文件
############################## APPEND ONLY MODE ###############################
# By default Redis asynchronously dumps the dataset on disk. This mode is
# good enough in many applications, but an issue with the Redis process or
# a power outage may result into a few minutes of writes lost (depending on
# the configured save points).
#
# The Append Only File is an alternative persistence mode that provides
# much better durability. For instance using the default data fsync policy
# (see later in the config file) Redis can lose just one second of writes in a
# dramatic event like a server power outage, or a single write if something
# wrong with the Redis process itself happens, but the operating system is
# still running correctly.
#
# AOF and RDB persistence can be enabled at the same time without problems.
# If the AOF is enabled on startup Redis will load the AOF, that is the file
# with the better durability guarantees.
#
# Please check https://redis.io/topics/persistence for more information.
appendonly no #默认不开启,我们需要开启,修改为yes开启AOF
重启,redis就可以生效了
如果AOF这个文件有错误,这个时候redis是启动不起来的,我们需要修复这个AOF文件
redis给我们提供了这样一个工具
docker exec -it redis redis-check-aof --fix appendoly.aof
如果文件正常,重启就可以直接恢复了!
重写规则说明
AOF默认的就是文件的无限追加,文件会越来越大!
重写是为了将AOF文件变得更小,降低文件占用空间,以便于更快的被Redis加载
no-appendfsync-on-rewrite no
# Automatic rewrite of the append only file.
# Redis is able to automatically rewrite the log file implicitly calling
# BGREWRITEAOF when the AOF log size grows by the specified percentage.
#
# This is how it works: Redis remembers the size of the AOF file after the
# latest rewrite (if no rewrite has happened since the restart, the size of
# the AOF at startup is used).
#
# This base size is compared to the current size. If the current size is
# bigger than the specified percentage, the rewrite is triggered. Also
# you need to specify a minimal size for the AOF file to be rewritten, this
# is useful to avoid rewriting the AOF file even if the percentage increase
# is reached but it is still pretty small.
#
# Specify a percentage of zero in order to disable the automatic AOF
# rewrite feature.
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
如果aof文件大于64m,太大了!fork一个新的进程来将我们的文件进行重写!
AOF的优点和缺点
appendonly no #默认是不开启aof模式的,默认是使用rdb方式持久化的,在大部分所有的情况下,rdb完全够用!
appendfilename "appendonly.aof" #持久化文件名。
appendfsync always #每次修改都会sync,消耗性能
appendfsync everysec #每秒执行一次sync,可能会丢失这1s的数据!
appendfsync no #不执行sync,这个时候操作系统自己同步数据,速度最快!
#rewrite
优点 | 1、每一次修改都同步,文件的完整性会更好!2、每秒同步一次,可能会丢失一秒的数据!3、从不同步,效率最高的! |
---|---|
缺点 | 1、相对于数据文件来说,AOF远远大于RDB,修复的速度也比RDB慢!2、AOF运行效率也要比RDB慢,所以我们redis默认的配置就是RDB持久化! |
扩展
1、RDB持久化方式能够在指定时间间隔内对你的数据进行快照存储
2、AOF持久化方式记录每次对服务器写的操作,当服务器重启的时候会重新执行这些命令来恢复原始的数据,AOF命令以Redis协议追加保存每次写的操作到文件末尾,Redis还能对AOF文件进行后台重写,使得AOF的文件体积不至于过大
3、只做缓存,如果你只希望你的数据在服务区运行的时候存在,你也可以不使用任何持久化
4、同时开启两种持久化方式
·在这种情况下,当Redis重启的时候会优先载入AOF文件来恢复原始的数据,因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整
·RDB的数据不实时,同时使用两者是服务器重启也只会找AOF文件,那要不要只使用AOF呢?不建议。因为RDB更适合用于备份数据库(AOF在不断变化不好备份),快速重启,而且不会有AOF可能潜在的BUG,留着作为万一的手段
5、性能建议
·因为RDB文件只用作后备用途,建议只在Slave上持久化RDB文件,而且只要15分钟备份一次就够了,只保留save 900 1这条规则
·如果Enable AOF,好处是在最恶劣的情况下也只会丢失不超过两秒的数据,启动脚本较简单只load自己的AOF文件就可以了,代价一是带来了持续的IO,二是AOF rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可,应该尽量减少AOF rewrite的频率,AOF重写的基础大小默认值64M太小了,可以设置到5G以上,默认超过原大小100%大小重写可以改到适当的数值。
·如果不Enable AOF,仅靠Master-Slave Repllcation实现高可用性也可以,能省掉一大笔IO,也减少了rewrite时带来的系统波动。代价是如果Master/Slave同时倒掉(断电!),会丢失十几分钟的数据,启动脚本也要比较两个Master/Slave中的RDB文件,载入比较新的那个,微博就是这种架构。
Redis发布订阅
Redis发布订阅(pub/sub)是一种消息通信方式:发布者(pub)发送消息,订阅者(sub)接收消息。微信、微博、关注系统!
Redis客户端可以订阅任意数量的频道
订阅/发布消息图
1、消息发送者 2、频道 3、消息订阅者!
这些命令被广泛用于构建即时通信应用,比如网络聊天室(chatroom)和实时广播、实时提醒等。
命令
1、PSUBSCRIBE pattern [pattern…] #订阅一个或多个符合给定模式的频道
2、PUBSUB subcommand[argument[argument…]] #查看订阅与发布系统状态
3、PUBLISH channel message #将信息发送到指定的频道
4、PUNSUBSCRIBE[pattern[pattern…]] #退订所有给定模式的频道
5、SUBSCRIBE channel[channel…] #订阅给定的一个或多个频道的信息
6、UNSUBSCRIBE[channel[channel…]] #指退订给定的频道
#发送端
127.0.0.1:6379> publish kuang "hello kuang" #发布者发送消息到频道
(integer) 1
127.0.0.1:6379>
#订阅端
127.0.0.1:6379> subscribe kuang #订阅一个频道 kuang
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "kuang"
3) (integer) 1
# 等待推送信息
1) "message" #消息
2) "kuang" #频道名
3) "hello kuang" #消息的具体内容
原理
Redis是使用C实现的,通过分析Redis源码里的pubsub.c文件,了解发布和订阅机制的底层实现。藉此加深对Redis的理解。
Redis通过PUBLISH、SUBSCRIBE和PSUBSCRIBE等命令实现发布和订阅功能。
通过SUBSCRIBE命令订阅某频道后,Redis-server里维护了一个字典,字典的键就是一个个channel,而字典的值则是一个链表,链表中保存了所有订阅这个channel的客户端。SUBSCRIBE命令的关键,就是将客户端添加给定的channel字典中查找记录了订阅这个频道的所有客户端的链表,便利这个链表,将消息发布给所有订阅者。
PUB/SUB从字面上理解就是发布(Publish)与订阅(Subscribe),在Redis中,你可以设定对某一个key值进行消息发布及消息订阅,当一个key值上进行了消息发布后,所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实现消息系统,比如普通的即时聊天,群聊等功能。
使用场景
1、实时消息系统!2、实时聊天!(频道当作聊天室,将信息回显给所有人即可!)3、订阅、关注系统都是可以的!
稍微复杂的场景我们就会使用消息中间件!
Redis主从复制
概念
主从复制,是指将一台Redis服务器的数据,复制到其他的Redis服务器。前者称为主节点(master/leader),后者称为从节点(slave/follower);数据的复制是单向的,只能由主节点到从节点。Master以写为主,Slave以读为主。
默认情况下,每台Redis服务器都是主节点;
且一个主节点可以有多个从节点(或没有从节点),但是一个从节点只能有一个主节点。
主从复制的作用主要包括:
1、数据冗余:主从复制实现了数据的热备份,是持久化之外的一种数据冗余方式。
2、故障恢复:当主节点出现问题时,可以由从节点提供服务,实现快速的故障恢复;实际上是一种服务的冗余。
3、负载均衡:在主从复制的基础上,配合读写分离,可以由主节点提供写服务,由从节点提供读服务(即写Redis数据时应用连接主节点,读Redis数据时应用连接从节点),分担服务器负载;尤其是在写少读多的情况下,通过多个从节点分担读负载,可以大大提高Redis服务器的并发量。
4、高可用基石:除了上述作用外,主从复制还是哨兵和集群能够实施的基础,因此说主从复制是Redis高可用的基础。
一般来说,要将Redis运用于工程项目中,只使用一台Redis是万万不能的(宕机!),原因如下:
1、从结构上,单个Redis服务器会发生单点故障,并且一台服务器需要处理所有的请求负载,压力较大!
2、从容量上,单个Redis服务器内存容量有限,就算一台Redis服务器内存容量为256G,也不能将所有内存用作Redis存储内存,一般来说,单台Redis最大使用内存不应该超过20G。
电商网站上的商品,一般都是一次上传,无数次浏览的,说专业点就是“多读少写”。
主从复制,读写分离!80%的情况下都是在进行读操作!减缓服务器的压力!架构中经常使用!一主多从!
环境配置
只配置从库,不用配置主库!
127.0.0.1:6379> info replication #查看当前库的信息
# Replication
role:master #角色 master
connected_slaves:0 #没有从机
master_failover_state:no-failover
master_replid:8f8af2cab2681c6c933158b6dc4660a9e775dff3
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histle
复制3个配置文件,然后修改对应的信息
1、端口
2、Pid名字
3、log文件名字
4、dump.rdb 文件名
在单机情况下可以通过不同的config来配置不同的启动项
但是在docker环境下或者多机的情况下不需要配置,只需将端口号进行修改即可
修改完毕之后,启动三个redis服务器,可以通过进程信息来查看
一主二从
默认情况下,每一台都是主机;我们一般情况下,只用配置从机就好了!
认老大!一主(79)二从(80、81)
只是针对主从模式下,例如加入了sentinel 的主从关系。没有这样的中间件帮忙。自身切换很麻烦。
redis -cluster 集群模式不能使用主从复制相关命令
会报错:(error) ERR REPLICAOF not allowed in cluster mode.
配置方法:
一种:在每个slave节点的redis.conf配置文件增加一行
slaveof 127.0.0.1 6379
二种:启动时候通过启动参数指定master节点
redis-server --slaveof 192.168.20.202 6379
主从切换
slaveof xx xx 这样自己就变成从了
主从切换的时候,这个配置会被重写成
SLAVEOF 127.0.0.1 配置master主机 #暂时的
真实的配置应该在redis.conf中配置
replicaof 127.0.0.1 6379 #永久性的
细节
主机可以写,从机只能读!主机中的所有信息和数据,都会自动被我们的从机保存
没有配置哨兵的时候,主机宕机从机依旧连接,但是没有写操作
如果是使用命令行,来配置的主从,这个时候如果重启了,就会变成主机,如果再次变为从机,即可获取主机中的值:全量复制
复制原理
Slave启动成功连接到master后会发送一个sync同步命令
Master接到命令,启动后台的存盘进程,同时收集所有接收到的用于修改数据集命令,在后台进程执行完毕之后,master将传送整个数据文件到Slave,并完成一次完全同步
全量复制:而slave服务在接收到数据库文件数据后,将其存盘并加载到内存中。
增量复制:Master继续将新的所有收集到的修改命令依次传给Slave,完成同步。
但是只要是重新连接master,一次完全同步(全量复制)将被自动执行!
如果没有老大了,这个时候能不能选择一个老大出来呢?手动!
如果主机断开了连接,我们可以使用“SLAVEOF no one”使自己变成主机!其他的节点就可以手动连接到最新的这个主节点(手动)!
哨兵模式(自动选取老大的模式)
概述
主从切换技术的方法是:当主服务器宕机之后,需要手动把一台服务器切换成主服务器,这就需要人工干预,费时费力,还会造成一段时间服务不可用。这不是一种推荐的方法,更多时候,我们优先考虑哨兵模式。Redis从2.8开始正式提供了Sentinel(哨兵)架构来解决这个问题。
切换主从的自动版,能够后台监控主机是否故障,如果故障了根据投票数“自动将从库切换为主库”。
哨兵模式是一种特殊的模式,首先Redis提供了哨兵的命令,哨兵是一个独立的进程,作为进程,他会独立运行。其原理是哨兵通过发送命令,等待Redis服务器响应,从而监控运行的多个Redis实例。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-esUlYl7V-1675266237934)(media/16731853661514/16748894125695.jpg)]
这里的哨兵有两个作用
·通过发送命令,让Redis服务器返回监控其运行状态,包括主服务器和从服务器。
·当哨兵监测到master宕机,会自动将Slave切换成master,然后通过发布订阅模式通知其他的从服务器,修改配置文件,让它们切换主机。
然而一个哨兵进程对Redis服务器进行监控,可能会出现问题,为此,我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控,这样就形成了多哨兵模式。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QkO0S3Jj-1675266237934)(media/16731853661514/16748897451485.jpg)]
除了监控各个Redis服务器之外,哨兵之间也会互相监督。
假设主服务器宕机,哨兵1就会检测到这个结果,系统并不会马上进行failover过程,仅仅是哨兵1主观的认为主服务器不可用,这个现象称为主观下限,当后面的哨兵也检测到主服务器不可用,并且数量达到一定值时,那么哨兵之间就会进行一次投票,投票的结果由一个哨兵发起,进行failover【故障转移】操作,切换成功后,就会通过发布订阅模式,让各个哨兵把自己监控的从服务器实现切换主机,这个过程称为客观下限。
测试
我们目前的状态是一主二从。
1、在kconfig文件夹中创建sentinel.conf
2、文件中进行简单配置
#sentinel monitor 被监视的名称 host port 1
sentinel monitor myredis 127.0.0.1 6379 1
后面的这个数字1,代表主机挂了,slave投票看让谁接替成为主机,票数最多的,就会成为主机!
3、启动哨兵
redis-sentinel kconfig/sentinel.conf
如果Master节点断开了,这个时候就会从主机中随机选择一个服务器!(这里面有一个vote算法!)
如果主机此时回来了,只能归并到新的主机下,当作从机,这就是哨兵模式的规则!
哨兵模式
优点:
1、哨兵集群,基于主从复制模式,所有的主从配置优点,它都有
2、主从可以切换,故障可以转移,系统的可用性就会更好
3、哨兵模式就是主从模式的升级,手动到自动,更加健壮!
缺点:
1、Redis不好在线扩容的,集群容量一旦到达上限,在线扩容就会十分麻烦!
2、实现哨兵模式的配置其实是很麻烦的,里面有很多选择!
哨兵模式的全部配置
# Example sentinel.conf
# 哨兵sentinel实例运行的端口 默认26379
port 26379
# 哨兵sentinel的工作目录
dir /tmp
# 哨兵sentinel监控的redis主节点的 ip port
# master-name 可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。
# quorum 配置多少个sentinel哨兵统一认为master主节点失联 那么这时客观上认为主节点失联了
# sentinel monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor mymaster 127.0.0.1 6379 2
# 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供密码
# 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
# 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒
# sentinel down-after-milliseconds <master-name> <milliseconds>
sentinel down-after-milliseconds mymaster 30000
# 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同步,这个数字越小,完成failover所需的时间就越长,但是如果这个数字越大,就意味着越 多的slave因为replication而不可用。可以通过将这个值设为 1 来保证每次只有一个slave 处于不能处理命令请求的状态。
# sentinel parallel-syncs <master-name> <numslaves>
sentinel parallel-syncs mymaster 1
# 故障转移的超时时间 failover-timeout 可以用在以下这些方面:
#1. 同一个sentinel对同一个master两次failover之间的间隔时间。
#2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的failover所需要的时间。
#4.当进行failover时,配置所有slaves指向新的master所需的最大时间。不过,即使过了这个超时,slaves依然会被正确配置为指向master,但是就不按parallel-syncs所配置的规则来了
# 默认三分钟
# sentinel failover-timeout <master-name> <milliseconds>
sentinel failover-timeout mymaster 180000
# SCRIPTS EXECUTION
#配置当某一事件发生时所需要执行的脚本,可以通过脚本来通知管理员,例如当系统运行不正常时发邮件通知相关人员。
#对于脚本的运行结果有以下规则:
#若脚本执行后返回1,那么该脚本稍后将会被再次执行,重复次数目前默认为10
#若脚本执行后返回2,或者比2更高的一个返回值,脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了,则同返回值为1时的行为相同。
#一个脚本的最大执行时间为60s,如果超过这个时间,脚本将会被一个SIGKILL信号终止,之后重新执行。
#通知型脚本:当sentinel有任何警告级别的事件发生时(比如说redis实例的主观失效和客观失效等等),将会去调用这个脚本,这时这个脚本应该通过邮件,SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时,将传给脚本两个参数,一个是事件的类型,一个是事件的描述。如果sentinel.conf配置文件中配置了这个脚本路径,那么必须保证这个脚本存在于这个路径,并且是可执行的,否则sentinel无法正常启动成功。
#通知脚本
# shell编程
# sentinel notification-script <master-name> <script-path>
sentinel notification-script mymaster /var/redis/notify.sh
# 客户端重新配置主节点参数脚本
# 当一个master由于failover而发生改变时,这个脚本将会被调用,通知相关的客户端关于master地址已经发生改变的信息。
# 以下参数将会在调用脚本时传给脚本:
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
# 目前<state>总是“failover”,
# <role>是“leader”或者“observer”中的一个。
# 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
# 这个脚本应该是通用的,能被多次调用,不是针对性的。
# sentinel client-reconfig-script <master-name> <script-path>
sentinel client-reconfig-script mymaster /var/redis/reconfig.sh # 一般都是由运维来配置!
社会目前程序员饱和(初级和中级)、高级程序员重金难求!(提升自己!)
Redis缓存穿透和雪崩(面试高频)
服务器的高可用性
Redis缓存的使用,极大的提升了应用程序的性能和效率,特别是数据查询方面。但同时,它也带来了一些问题。其中,最要害的问题就是数据一致性问题,从严格意义上讲,这个问题无解。如果对数据的一致性要求很高,那么就不能使用缓存。
另外的一些典型的问题就是,缓存穿透、缓存雪崩和缓存击穿。目前,业界也都有比较流行的解决方案。
缓存穿透(查不到)
概念
缓存穿透的概念很简单,用户想要查询一个数据,发现Redis内存数据库中没有,也就是缓存没有命中,于是向持久层数据库查询,没有,于是本次查询失败!当用户很多的时候,缓存都没有命中(秒杀!),都请求了持久层数据库。这就会给持久层数据库造成很大的压力,这时候就相当于出现了缓存穿透!
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-otrA5LUU-1675266237934)(media/16731853661514/16748926237075.jpg)]
解决方案
布隆过滤器
布隆过滤器是一种数据结构,对所有可能查询的参数以hash形式存储,在控制层先进行校验,不符合则丢弃,从而避免了对底层存储系统的查询压力;
缓存空对象
当缓存层不命中后,即使返回的空对象也将其缓存起来,同时会设置一个过期时间,之后再访问这个数据将会从缓存中获取,保护了后端数据源;
但是这种方法会存在两个问题:
1、如果空值能够被缓存起来,这就意味着缓存需要更多的空间存储更多的键,因为这当中可能会有很多的空值的键;
2、即使对空值设置了过期时间,还是会存在缓存层和存储层的数据会有一段时间窗口不一致,这对于需要保持一致性的业务会有影响。
缓存击穿(量太大了,缓存过期)
概述
这里需要注意和缓存击穿的区别,缓存击穿,是指一个key非常热点,在不停的扛着大并发,大并发集中对这一个点进行访问,当这个key在失效的瞬间,持续的大并发就穿破缓存,直接请求数据库,就像是在一个屏幕上凿开了一个洞。
当某个key在过期的瞬间,有大量的请求并发访问,这类数据一般是热点数据,由于缓存过期,会同时访问数据库来查询最新的数据,并且写回缓存,会导致数据库瞬间压力过大。
解决方案
设置热点数据永不过期
从缓存层面来看,没有设置过期时间,所以不会出现热电key过期后产生的问题。
加互斥锁
分布式锁:使用分布式锁,保证对于每个key同时只有一个线程去查询后端服务,其他线程没有获得分布式锁的权限,因此只需要等待即可。这种方法将高并发的压力转移到了分布式锁,因此对分布式锁的考验很大。
缓存雪崩
概念
缓存雪崩,是指在某一个时间段,缓存集中过期失效。Redis宕机!
产生雪崩的原因之一,比如双十一抢购,这波商品时间比较集中的放在了缓存,假设缓存一小时,那么到了凌晨一点的时候,这批商品的缓存就都过期了。而对这批商品的访问查询,都落到了数据库上,对于数据库而言,就会产生周期性的压力波峰。于是所有的请求都会达到存储层,存储层的调用量会暴增,造成存储层也会挂掉的情况。
双十一:停掉一些服务。(保证主要的服务可用!)
解决方案
Redis高可用
这个思想的含义是,既然Redis有可能挂掉,那我多增设几台,这样一台挂掉之后其他的还可以继续工作,其实就是搭建的集群。(异地多活!)
限流降级(在SpringCloud讲解过!)
这个解决方案的思想是,在缓存失效后,通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存,其他线程等待。
数据预热
数据预热的含义就是在正式部署之前,我先把可能的数据先预先访问一遍,这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key,设置不同的过期时间,让缓存失效的时间点尽量均匀。