目录
NoSql概述
为什么要用Nosql
我们现在处于什么年代? 2020年,大数据时代;
所以一般的关系型数据库就完全无法支撑数据的存储,所以必须使用一种新的数据架构;
那么NoSQL就是这角色.
1、单体Mysql的年代
90年代,一个基本的网站访问量一般不会太大,单个数据库完全足够。
那个时候,更多的是去使用静态网页 Html ~ 服务器根本没有太大压力!
思考:整个网站的瓶颈是什么?
1、数据量如果太大、一个机器放不下!
2、数据的索引(B+ Tree):当数据量较大的时候,索引也不足以加速了;
3、访问量(读写混合),一个服务器承受不了~
2、Memcached(缓存)+Mysql+垂直拆分(读写分离)
对于网站来说,80%的情况都是在读取,那么大部分都是读取!
所以我们可以做一个缓存机制,这样存在同样的读取的时候,我们就可以从缓存中去读取。
这样我们就可以减少对服务器的压力:
发展过程: 优化数据结构和索引–>文件缓存(IO)–>Memcached(当时最热门的技术!)
3、分库分表+水平拆分+集群
技术和业务在发展的同时,对于人的要求也越来越高。
发展过程:本质:数据库(读,写)
早些年MyISAM:表锁,十分影响效率!高并发下会严重的锁问题
转战Innodb:行锁
读的压力使用缓存的方法来解决读的压力
慢慢的就开始使用分库分表来解决写的压力!Mysql在当时推出了表分区!
Mysql也推出了集群,很好满足了当初的需求。
4、如今最近的年代
这个年代是一个技术爆炸的年代:
2010-2020年代,十年的技术爆炸达到了一个很高的水平。
Mysql等关系型数据库就不够用了! 数据量很多,变化很快~!
Mysql有的使用它来存储一些比较大的文件:博客、图片!数据库表会非常大,这样效率会很低!
如果有一种数据库来专门处理这种数据,MySql压力就变得十分小(研究如果处理这个问题!)大数据
的IO压力下,表几乎无法变得更大!
为什么要使用NoSQL!
用户的个人信息,社交网络,地理位置,用户自己产生的数据,用户日志等等爆发式增长!
这时候我们需要使用NoSQL数据库,NoSQL可以解决以上的难题。
5、什么是NoSQL
NoSQL=Not Only SQL(不仅仅是SQL)
关系型数据库:行、列 二维表。
泛指非关系型数据库,随着web2.0互联网的诞生,传统的数据库无法应对web2.0时代。
尤其是超大规模的高并发的社区,暴露出很多难以克服的问题。
NoSQL在当前大数据环境下发展非常迅速,基本大多数都需要使用Redis等非关系型数据库。
Redis是发展最快的,而且是我们当下必须掌握的一个技术。
很多的数据类型:用户的个人信息,社交网络,地理位置,用户自己产生的数据
这些数据类型的存储不需要一个固定的格式!不需要过多的操作就可以横向扩展!
Map<String,Object> 使用键值对来控制就可以达到。
6、NoSQL特点:
解耦!
1、方便扩展(数据之间没有关系,很好的扩展)
2、大数据量高性能(Redis 一秒写8w次,读取11w次,NoSQL的缓存记录级,是一种细粒度的缓存,性能会比较高)
3、数据类型是多样型的。(不需要事先设计数据库!随取随用!如果数据量十分打的表,很多人就无法设计了!)
4、传统RDBMS和NoSQL
传统的RDBMS
- 结构化组织
- SQL
- 数据和关系都存在单独的表中
- 操作,数据定义语言
- 严格的一致性
- 基础的事务
NoSQL
- 不仅仅是数据
- 没有固定的查询语言
- 键值对存储,列存储,文档存储,图数据库
- 最终一致性
- CAP定理和BASE (异地多活) --->初级架构师!
- 高性能、高可用、高扩展
公司中的实践:NoSQL+MySQL共同使用
7、阿里巴巴演进分析
# 1、商品的基本信息:
名称、价格、商家信息
关系型数据库:MySQL、Oracle
# 2、商品的描述、评论
文档型数据库,MongoDB
# 3、图片
分布式文件系统 FastDFS
- 淘宝: TES
- Google: GFS
- HADOOP HDFS
- 阿里云的 OSS
# 4、商品的关键字:搜索引擎
- 搜索引擎:solr elasticSearch
- ISerach: 多隆(技术大牛)
# 5、商品的波段信息
- 内存数据库
- Redis Tair、Memache....
# 6、商品的交易、外部的支付接口
- 三分应用
大型互联网应用问题:
- 数据类型太多了
- 数据源繁多,经常重构
- 数据要改造,大面积改造
以上是NoSQL入门概述,了解大厂的工作内存。
NoSQL的四大分类
KV键值对:
- 新浪:Redis
- 美团:Redis+Tair
- 阿里、百度:Redis+memecache
文档型数据库(bson格式和json一样):
- MongoDB(掌握):
- MongoDB是一个基于分布式文件存储的数据库,C++编写,主要用来处理大量的文档
- MongoDB是一个介于关系型数据和非关系型数据库中中间的产品,MongoDB是非关系型数据库中功能最丰富的NoSQL,是最像关系型数据库的。
- ConthDB
列存储数据库:
- HBase
- 分布式文件系统
图关系数据库:
- 他不是存图像的,放的是关系,比如:朋友圈社交网络,广告推荐等!
- Neo4j,infoGrid;
敬畏之心可以使人进步!
追求幸福(帮助他人),探索未知(努力学习)
Redis入门
概述:
Redis是什么?
Redis(Remote Dictionary Server),即远程字典服务!
是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。
免费和开源!是当前最热门的NoSQL技术之一!也被人们称之为结构化数据库。
Redis能干嘛?
读的速度是110000次/s,写的速度是81000次/s 。
- 1、内存存储、持久化,内存中是断电即失、所以是持久化很重要(rdb、aof)
- 2、效率高,可以用于高速缓存
- 3、发布订阅系统
- 4、地图信息分析
- 5、计时器、计数器
特性:
1、多样的数据类型
2、持久化
3、集群
4、事物
…
学习中需要用到的东西
1、公众号:狂神说
2、官网:https://redis.io/
3、中文网:http://www.redis.cn/
Redis推荐都是在Linux服务器上搭建的
Redis的使用:
设置key:set name key_value
得到key:get name
Linux 安装使用:
1、下载安装包
2、解压Redis压缩包 tar -zxvf name
3、进入redis文件
4、基本的环境安装
yum install gcc-c++
make
5、redis的默认安装路径usr/local/bin
6、将redis配置文件拷贝过来
7、redis默认不是后台启动的,修改配置文件为后台启动。
8、启动redis服务!
通过指定的配置文件启动:
9、测试连接:
10、查看redis进程是否开启:
11、如果关闭redis服务呢?
12、后面我们会使用单机多Redis启动集群
性能测试
redis-benchmark是一个压力测试工具
官方自带的性能测试工具!
redis-benchmark命令参数:
序号 | 选项 | 描述 | 默认值 |
---|---|---|---|
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 连接并等待。 |
测试:
# 测试:100个并发连接 10w个请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000
如何查看这些分析呢?
基础的知识
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> keys * # 查看数据库所有的key
1) "counter:{tag}:__rand_int__"
2) "key:{tag}:__rand_int__"
3) "myhash:{tag}:__rand_int__"
4) "mylist:{tag}"
5) "name"
127.0.0.1:6379>
清除当前数据库 flushdb
清除所有数据库的内容flushall
127.0.0.1:6379> keys *
1) "counter:{tag}:__rand_int__"
2) "key:{tag}:__rand_int__"
3) "myhash:{tag}:__rand_int__"
4) "mylist:{tag}"
5) "name"
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> keys *
(empty array)
思考:为什么redis是6379?(了解一下)
Redis是单线程的!
明白Redis是很快的,官方表示,Redis是基于内存开发操作的,CPU 不是性能瓶颈,Redis的瓶颈是根据机器的内存和网络带宽,既然可以使用单线程来实现,所以就使用单线程了!
Redis是C语言写的,官方提供的数据为100000+的QPS,完全不比Memecache差!
Redis为什么单线程还那么快?
1、误区1:高性能的服务器一定是多线程?
2、误区2:多线程(CPU上下文切换!)一定比单线程效率高!
核心:redis是将所有的数据全部放在内存中的,所以使用单线程去操作效率就是最高的,多线程(CPU会上下文切换:耗时的操作!!!),对于内存系统来说,如果没有上下文切换效率就是最高的!多次读写都是在一个CPU上运行的,在内存情况下,这个就是最佳的方案!
五大数据类型
- Redis 是一个开源(BSD许可)的,内存中的数据结构存储系统,它可以用作数据库、缓存和消息中间件。 它支持多种类型的数据结构,如 字符串(strings), 散列(hashes), 列表(lists), 集合(sets), 有序集合(sorted sets) 与范围查询, bitmaps, hyperloglogs 和 地理空间(geospatial) 索引半径查询。 Redis 内置了 复制(replication),LUA脚本(Lua scripting), LRU驱动事件(LRU eviction),事务(transactions) 和不同级别的 磁盘持久化(persistence), 并通过 Redis哨兵(Sentinel)和自动 分区(Cluster)提供高可用性(high availability)。
1、Redis-Key
27.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> clear
127.0.0.1:6379> flushall
OK
127.0.0.1:6379> clear
127.0.0.1:6379> keys * # 查看所有的key
(empty array)
127.0.0.1:6379> clear
127.0.0.1:6379> set name ogj
OK
127.0.0.1:6379> keys *
1) "name"
127.0.0.1:6379> set age 1
OK
127.0.0.1:6379> keys *
1) "age"
2) "name"
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
(integer) 1
127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379> set name ogj
OK
127.0.0.1:6379> keys *
1) "age"
2) "name"
127.0.0.1:6379> clear
127.0.0.1:6379> EXPIRE name 10 # 设置过期时间
(integer) 1
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) 2
127.0.0.1:6379> ttl name
(integer) 1
127.0.0.1:6379> ttl name
(integer) 1
127.0.0.1:6379> ttl name
(integer) 0
127.0.0.1:6379> ttl name
(integer) -2
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> keys *
1) "age"
2) "name"
127.0.0.1:6379> TYPE name # 查看key的一个类型
string
127.0.0.1:6379> TYPE age
string
后面如果遇到不会的命令,可以到官网进行查询即可。
2、String(字符串)
###################################################################
127.0.0.1:6379> set key1 v1 #设置值
OK
127.0.0.1:6379> get key1 #获得值
"v1"
127.0.0.1:6379> append key1 "hello" # 追加字符串
(integer) 7
127.0.0.1:6379> get key1
"v1hello"
127.0.0.1:6379> append key1 " ogjdasda"
(integer) 16
127.0.0.1:6379> get key1
"v1hello ogjdasda"
127.0.0.1:6379> STRLEN key1 # 获取字符串的长度
(integer) 16
###################################################################
###################################################################
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> incr views
(integer) 3
127.0.0.1:6379> incr views
(integer) 4
127.0.0.1:6379> incr views
(integer) 5
127.0.0.1:6379> incr views
(integer) 6
127.0.0.1:6379> get views
"6"
127.0.0.1:6379> decr views # 自减1
(integer) 5
127.0.0.1:6379> decr views
(integer) 4
127.0.0.1:6379> decr views
(integer) 3
127.0.0.1:6379> decr views
(integer) 2
127.0.0.1:6379> get views
"2"
127.0.0.1:6379> incrby view 10 #设置步长 自增10
(integer) 10
127.0.0.1:6379> incrby view 10
(integer) 20
127.0.0.1:6379> decrby view 5 #自减 5
(integer) 15
127.0.0.1:6379> decrby view 5
(integer) 10
###################################################################
###################################################################
# 字符串范围 range
127.0.0.1:6379> get key1
"v1hello ogjdasda"
127.0.0.1:6379> GETRANGE key1 0 3 #截取 0 到 3
"v1he"
127.0.0.1:6379> GETRANGE key1 0 -1 #截取 全部字符串
"v1hello ogjdasda"
###################################################################
###################################################################
# 替换
127.0.0.1:6379> GETRANGE key1 0 -1
"v1hello ogjdasda"
127.0.0.1:6379> clear
127.0.0.1:6379> SETRANGE key1 1 xx # 替换字符串
(integer) 16
127.0.0.1:6379> get key1
"vxxello ogjdasda"
127.0.0.1:6379>
###################################################################
###################################################################
# setex(set with expire) # 设置过期时间
# setnx(set if not exist) # 不存在在设置 # 不存在再设置(在分布式锁中会常常使用)
127.0.0.1:6379> setex keys 30 "hello" #设置keys 为 hello 并且过期时间为30
OK
127.0.0.1:6379> keys *
1) "keys"
127.0.0.1:6379> ttl keys
(integer) 7
127.0.0.1:6379> ttl keys
(integer) 6
127.0.0.1:6379> ttl keys
(integer) 5
127.0.0.1:6379> setnx mykey "redis" #如果mykey不存在,再设置
(integer) 1
127.0.0.1:6379> keys *
1) "mykey"
127.0.0.1:6379> ttl keys
(integer) -2
127.0.0.1:6379> get mykey
"redis"
127.0.0.1:6379> setnx mykey "redis1" #如果存在mykey,则无法再设置,设置无效
(integer) 0
127.0.0.1:6379> get mykey
"redis"
###################################################################
###################################################################
# 批量设置 和 批量获取
mset
mget
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 # 同时设置多个值
OK
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
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 # msetnx是一个原子操作,要么一起成功要么一起失败
(integer) 0
127.0.0.1:6379> get k4
(nil)
###################################################################
#############################################################################
# 对象
set user:1{name:zhangsan,age:3} # 设置一个user:1 对象值为 json字符来保存一个对象!
# 这里的key是一个巧妙的设计:user:{id}:{field}
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"
############################################################################
########################################################################
getset #先get然后set
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"
########################################################################
3、List
基本的数据类型,列表
在redis中,我们可以把list转换为堆、栈、队列
所有的list命令都是l开头的。
########################################################################
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 #获取list中的值,也可以通过区间来获取具体的值
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"
########################################################################
LPOP #左边移除
RPOP #右边移除
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"
127.0.0.1:6379> RPOP list
"right"
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> LPOP list
"three"
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"
########################################################################
lindex
127.0.0.1:6379> keys *
1) "list"
127.0.0.1:6379> lindex list 0 #通过下标获得 list中的某一个值
"two"
127.0.0.1:6379> lindex list 1
"one"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
########################################################################
llen 获取长度
127.0.0.1:6379> llen list
(integer) 2
########################################################################
# 移除指定的值
取关:uid
lrem
127.0.0.1:6379> lrange list 0 -1 #移除指定个数的value 精确匹配
1) "one"
2) "two"
3) "one"
127.0.0.1:6379> lrem list 1 two
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "one"
2) "one"
127.0.0.1:6379> lrem list 2 one
(integer) 2
127.0.0.1:6379> lrange list 0 -1
(empty array)
########################################################################
trim 修剪
127.0.0.1:6379> lrange list 0 -1
1) "eeeee3"
2) "eeeee2"
3) "eeeee1"
4) "eeeee"
5) "eee"
6) "one"
7) "one"
8) "one"
127.0.0.1:6379> ltrim list 0 4 # 通过下标截取指定的长度,这个list已经被改变了
OK
127.0.0.1:6379> lrange list 0 -1
1) "eeeee3"
2) "eeeee2"
3) "eeeee1"
4) "eeeee"
5) "eee"
########################################################################
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 将列表中指定下标的值替换为另外一个值,相当于update操作
127.0.0.1:6379> EXISTS list # 判断这个列表是否存在
(integer) 0
127.0.0.1:6379> lset list 0 item # 如果不存在我们去更新就会保存
(error) ERR no such key
127.0.0.1:6379> EXISTS list
(integer) 0
127.0.0.1:6379> lset list 0 item
(error) ERR no such key
127.0.0.1:6379> lpush list value1
(integer) 1
127.0.0.1:6379> lrange list 0 0
1) "value1"
127.0.0.1:6379> lset list 0 item # 如果存在 我们会更新当前下标的值
OK
127.0.0.1:6379> LRANGE list 0 0
1) "item"
127.0.0.1:6379> lset list 1 other # 不存在则会报错
(error) ERR index out of range
127.0.0.1:6379>
########################################################################
linsert # 将某个具体的value插入到列表中某个元素的前面或者后面
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" "other2"
(integer) 4
127.0.0.1:6379> Lrange mylist 0 -1
1) "hello"
2) "other"
3) "world"
4) "other2"
########################################################################
# 小结:
- 他实际上是一个链表,before Node after,left、right都可以插入值
- 如果key不存在,创建新的链表
- 如果key存在,新增内容
- 如果移除了所有值,空链表,也代表不存在
- 在两边插入或者改动值效率最高!中间元素相对来说效率会低一点
4、Set(集合)
set中的值是不能重复的!
########################################################################
127.0.0.1:6379> sadd myset "hello" # set集合中添加元素
(integer) 1
127.0.0.1:6379> sadd myset "ogj"
(integer) 1
127.0.0.1:6379> sadd myset "xiaowang1"
(integer) 1
127.0.0.1:6379> sadd myset "xiaowang2"
(integer) 1
127.0.0.1:6379> sadd myset "xiaowang3"
(integer) 1
127.0.0.1:6379> SMEMBERS myset #查看所有的值
1) "xiaowang2"
2) "hello"
3) "xiaowang1"
4) "ogj"
5) "xiaowang3"
127.0.0.1:6379> SISMEMBER myset hello # 判断元素是否在集合中
(integer) 1
127.0.0.1:6379> SISMEMBER myset hello1
(integer) 0
########################################################################
scard # 获取set集合中的元素个数
127.0.0.1:6379> scard myset
(integer) 5
127.0.0.1:6379> sadd myset "xiaowang4"
(integer) 1
127.0.0.1:6379> scard myset
(integer) 6
########################################################################
srem # 移除set集合中的指定元素
127.0.0.1:6379> scard myset
(integer) 6
127.0.0.1:6379> SMEMBERS myset
1) "ogj"
2) "xiaowang1"
3) "xiaowang3"
4) "hello"
5) "xiaowang2"
6) "xiaowang4"
127.0.0.1:6379> srem myset hello
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "ogj"
2) "xiaowang1"
3) "xiaowang3"
4) "xiaowang2"
########################################################################
set 无序不重复集合,抽随机
127.0.0.1:6379> SRANDMEMBER myset # 随机抽选出一个元素
"xiaowang1"
127.0.0.1:6379> SRANDMEMBER myset
"xiaowang3"
127.0.0.1:6379> SRANDMEMBER myset
"xiaowang2"
127.0.0.1:6379> SRANDMEMBER myset
"xiaowang4"
127.0.0.1:6379> SRANDMEMBER myset 2 # 随机抽取出指定个数的元素,并且不会抽出相同的两个数
1) "ogj"
2) "xiaowang4"
127.0.0.1:6379> SRANDMEMBER myset 3
1) "ogj"
2) "xiaowang1"
3) "xiaowang4"
########################################################################
删除指定的key,随机删除key!
127.0.0.1:6379> SMEMBERS myset
1) "ogj"
2) "xiaowang1"
3) "xiaowang3"
4) "xiaowang2"
5) "xiaowang4"
127.0.0.1:6379> spop myset # 随机删除一些set集合中的元素
"xiaowang4"
127.0.0.1:6379> SMEMBERS myset
1) "ogj"
2) "xiaowang1"
3) "xiaowang3"
4) "xiaowang2"
########################################################################
将一个指定的值,移动到另外一个集合中
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 "ogj"
(integer) 1
127.0.0.1:6379> sadd myset1 "set2"
(integer) 1
127.0.0.1:6379> SMOVE myset myset2 "ogj"
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "world"
2) "hello"
127.0.0.1:6379> SMEMBERS myset1
1) "set2"
########################################################################
微博、B站、共同关注!(交集)
做交、并、差操作
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 # key1 和 key2 不同的元素
1) "a"
2) "b"
127.0.0.1:6379> SINTER key1 key2 # key1 和 key2 相同的元素 交集
1) "c"
127.0.0.1:6379> SUNION key1 key2 # key1 和 key2 全部的元素 并集
1) "c"
2) "b"
3) "a"
4) "e"
5) "d"
#######################################################################
5、Hash(哈希)
Map集合,Key-Map集合:key- 也是键值对,但是这个值是一个map集合!本质和String类型没有太大的区别,还是一个简单的key-value!
set myhash field ogj
127.0.0.1:6379> hset myhash field1 ogj # set 一个 具体的key-value
(integer) 1
127.0.0.1:6379> hget myhash field1
"ogj"
127.0.0.1:6379> hmset myhash field1 hello field2 world # set 多个key-value
OK
127.0.0.1:6379> hmget myhash field1 field2 #get 多个key-value
1) "hello"
2) "world"
127.0.0.1:6379> hgetall myhash # 获取一个hash中所有的值
1) "field1"
2) "hello"
3) "field2"
4) "world"
127.0.0.1:6379> hdel myhash field1 # 删除hash指定key字段!
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "world"
#######################################################################
hlen
127.0.0.1:6379> hmset myhash field1 hello field2 world
OK
127.0.0.1:6379> hgetall
(error) ERR wrong number of arguments for 'hgetall' command
127.0.0.1:6379> HGETALL myhash
1) "field2"
2) "world"
3) "field1"
4) "hello"
127.0.0.1:6379> hlen myhash # 获取hash表的字段数量!
(integer) 2
#######################################################################
127.0.0.1:6379> hexists myhash field1 # 判断是否存在该字段
(integer) 1
127.0.0.1:6379> hexists myhash field2
(integer) 1
127.0.0.1:6379> hexists myhash field3
(integer) 0
#######################################################################
127.0.0.1:6379> hkeys myhash # 获取hash中所有的key
1) "field2"
2) "field1"
127.0.0.1:6379> HVALS myhash # 获取hash中所有的value
1) "world"
2) "hello"
#######################################################################
incr 自增 和 自减
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
#######################################################################
hsetnx 如果不存在 则可以设置成功,
如果存在 就不可以设置
127.0.0.1:6379> hsetnx myhash field4 hello
(integer) 1
127.0.0.1:6379> hsetnx myhash field4 hello
(integer) 0
#######################################################################
hash变更的数据 user: name age,尤其是用户信息之类的,经常变动的信息!hash 更适合于对象的存储,String更适合字符串。
6、Zset(有序集合)
在set的基础上,增加了一个值,set k1 v1 zset k1 score1 v1
#######################################################################
127.0.0.1:6379> zadd myset 1 one
(integer) 1
127.0.0.1:6379> zadd myset 2 two
(integer) 1
127.0.0.1:6379> zadd myset 2 two 3 three 4 four
(integer) 2
127.0.0.1:6379> ZRANGE myset 0 -1
1) "one"
2) "two"
3) "three"
4) "four"
#######################################################################
排序如何实现?zrangebyscore
# 升序排列
127.0.0.1:6379> zadd salary 2500 xiaohong
(integer) 1
127.0.0.1:6379> zadd salary 5000 zhangsan
(integer) 1
127.0.0.1:6379> zadd salary 200 ogj
(integer) 1
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf
1) "ogj"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores # 显示所有用户,并且携带成绩
1) "ogj"
2) "200"
3) "xiaohong"
4) "2500"
5) "zhangsan"
6) "5000"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf 2500 withscores # 显示低于2500的用户排列
1) "ogj"
2) "200"
3) "xiaohong"
4) "2500"
# 升序
127.0.0.1:6379> ZREVRANGE salary 0 -1
1) "zhangsan"
2) "ogj"
127.0.0.1:6379> ZREVRANGE salary 0 -1 withscores
1) "zhangsan"
2) "5000"
3) "ogj"
4) "200"
#######################################################################
# 移除rem中的元素
127.0.0.1:6379> zrange salary 0 -1
1) "ogj"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> zrem salary xiaohong # 移除指定元素
(integer) 1
127.0.0.1:6379> zrange salary 0 -1
1) "ogj"
2) "zhangsan"
127.0.0.1:6379> zcard salary # 获取有序集合的个数
(integer) 2
#######################################################################
# 获取有序集合区间的个数
127.0.0.1:6379> zadd myset 1 hello
(integer) 1
127.0.0.1:6379> zadd myset 2 world 3 ogj
(integer) 2
127.0.0.1:6379> zcount myset 1 3
(integer) 3
127.0.0.1:6379> zcount myset 1 2
(integer) 2
127.0.0.1:6379> zcount myset 1 3
(integer) 3
127.0.0.1:6379> zcount myset 1 1
(integer) 1
#######################################################################
更多命令可以去官方文档查找:http://www.redis.cn/commands.html
案例思路: set 排序 存储班级成绩表,工资表排序!
普通消息:1、重要消息,2、带权重进行判断
排行榜的实现。
三种特殊数据类型
一、geospatial地理位置
朋友的定位,附近的人,打车距离的计算等功能都可以使用这个进行实现。
Redis 的 Geo 在3.2就推出来了。 这个功能可以推算地理位置的信息,两地之间的距离,方圆几里的人!
测试数据:经度纬度查询:https://jingweidu.51240.com/
命令只有6个:
1、geoadd
# getadd 添加地理位置
# 规则: 两级无法导入,我们一般会下载城市数据集,直接通过java一次性导入
# 参考:经度,纬度,名字
# 有效的经度:-180 , 180
# 有效的纬度:-80 , 80
127.0.0.1:6379> geoadd china:city 116.51 39.84 beijing
(integer) 1
127.0.0.1:6379> geoadd china:city 121.48941 31.40527 shanghai
(integer) 1
127.0.0.1:6379> geoadd china:city 106.54041 29.40268 chongqing
(integer) 1
127.0.0.1:6379> geoadd china:city 113.88308 22.55329 shenzhen
(integer) 1
127.0.0.1:6379> geoadd china:city 120.21201 30.2084 hangzhou
(integer) 1
127.0.0.1:6379> geoadd china:city 108.93425 34.23053 xian
(integer) 1
2、geopos
获取当前定位:一定是一个坐标值!
127.0.0.1:6379> geopos china:city beijing
1) 1) "116.51000171899795532"
2) "39.84000070710821007"
127.0.0.1:6379> geopos china:city beijing chongqing
1) 1) "116.51000171899795532"
2) "39.84000070710821007"
2) 1) "106.54040783643722534"
2) "29.40268053517299762"
3、geodist
单位:
- m 表示单位为米。
- km 表示单位为千米。
- mi 表示单位为英里。
- ft 表示单位为英尺。
两个人的定位的距离
127.0.0.1:6379> geodist china:city beijing shanghai
"1040124.1936"
127.0.0.1:6379> geodist china:city beijing shanghai km # 查看 北京到上海的距离
"1040.1242"
127.0.0.1:6379> geodist china:city beijing chongqing
"1474488.1541"
127.0.0.1:6379> geodist china:city beijing chongqing km # 查看 北京到重庆的距离
"1474.4882"
4、georadius以给定的经纬度为中心,找出某一半径内的元素
我附近的人?(获得所有附近的人的地址,定位!) 通过半径来查询!
获得指定数量的人,200: 添加count参数
127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km # 获取以(110,30)为中心,寻找方圆1000km内的城市
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km # 获取以(110,30)为中心,寻找方圆500km内的城市
1) "chongqing"
2) "xian"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist # 获取以(110,30)为中心,寻找方圆500km内的城市,并显示直线距离
1) 1) "chongqing"
2) "340.7667"
2) 1) "xian"
2) "481.1278"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withcoord # 显示经纬度
1) 1) "chongqing"
2) 1) "106.54040783643722534"
2) "29.40268053517299762"
2) 1) "xian"
2) 1) "108.93425256013870239"
2) "34.23053097599082406"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist withcoord
1) 1) "chongqing"
2) "340.7667"
3) 1) "106.54040783643722534"
2) "29.40268053517299762"
2) 1) "xian"
2) "481.1278"
3) 1) "108.93425256013870239"
2) "34.23053097599082406"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist withcoord count 1 # 限制只显示指定人数
1) 1) "chongqing"
2) "340.7667"
3) 1) "106.54040783643722534"
2) "29.40268053517299762"
5、GEORADIUSBYMEMBER
找出位于指定元素位置周围的其他元素
127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijing 1000 km
1) "beijing"
2) "xian"
127.0.0.1:6379> GEORADIUSBYMEMBER china:city shanghai 400 km
1) "hangzhou"
2) "shanghai"
6、geohash
返回一个或者多个位置元素的Geohash 表示
该命令将返回11个字符的Geohash 字符串!
# 将二维的经纬度转换为一维的字符串,如果两个字符串越接近,那么则距离越近
127.0.0.1:6379> geohash china:city beijing chongqing
1) "wx4fehxuzf0"
2) "wm5z22s7520"
原理:
GEO底层的实现原理其实就是Zset!我们可以使用Zset命令来操作geo!
127.0.0.1:6379> ZRANGE china:city 0 -1 # 查看地图geo中所有的元素
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
6) "beijing"
127.0.0.1:6379> zrem china:city beijing # 移除指定元素
(integer) 1
127.0.0.1:6379> ZRANGE china:city 0 -1
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
7、Hyperloglog
什么是基数?
A(1,3,5,7,8,9,7)B(1,3,5,7,8)
基数(不重复的数)=5
Redis Hyperloglog 基数统计的算法!
网页的UV(一个人访问一个网站多次,但是还是算作一个人!)
传统的方式:set保存用户的id,这样就可以把重复的id 直接去掉!就可以统计set元素中的元素数量作为标准判断!
这个方式入股 保存大量的用户id,就会比较麻烦!但是我们的目的是为了计数,而不是保存用户id;
Hyperloglog的优点:
占用的内存是固定的,2^64不同的元素的基数,只需要费12kb的内存!
错误率:0.81%!
我们就可以使用Hyperloglog来解决这个业务问题!
Hyperloglog专业用来计算计数功能!
127.0.0.1:6379> clear
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
(integer) 10
127.0.0.1:6379> pfadd mykay2 i j z x c v b n m
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 0
127.0.0.1:6379> pfcount mykay2
(integer) 9
127.0.0.1:6379> pfmerge mykey3 mykey mykay2 # 合并两个集合
OK
127.0.0.1:6379> PFCOUNT mykey3 # 会自动去掉重复的值
(integer) 15
如果允许容错,那么一定可以使用Hyperloglog
如果不允许容错,那么就使用set集合或者数据库进行计数,但是这种方式的内存占用和效率会极低!
8、Bitmap
位运算,位存储!
统计用户信息,活跃,不活跃!登录、未登录!打卡、未打卡!类似于两种状态的存储,我们都可以使用Bitmaps!
Bitmap位图,数据结构!都是操作二进制位来进行记录,就只有0和1两个状态!
365天=365bit 1字节=8bit 46个字节左右就可以保存一个用户一年的签到
使用Bitmap来记录周一到周日的打卡!
周一:1 周二:0 周三:0 依次…
查看某一天是否有打卡:
127.0.0.1:6379> getbit sign 3
(integer) 1
127.0.0.1:6379> getbit sign 6
(integer) 0
统计打卡的天数:
127.0.0.1:6379> bitcount sign # 统计这周的打卡记录
(integer) 3
二、事务
MYSQL:ACID. 要么同时成功,要么同时失败,原子性!
注意:Redis单条命令是保证原子性的,但是事务不保证原子性的!
Redis事务本质:一组命令的集合!
----
set
set
set
----
执行
在事务执行过程中,会按照顺序执行。
特性:一次性、顺序性、排他性! 执行一系列的命令!
== Redis事务没有隔离级别的概念 ==
所有的命令在事务中,并没有直接被执行!只有发起执行命令的时候才会执行!
redis的事务:
- 开启事务(multi)
- 命令入队(…)
- 执行事务(exec)
1、正常执行事务!
127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> exec # 执行事务
1) OK
2) OK
3) "v2"
4) OK
2、放弃事务!
127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> discard # 取消事务
OK
127.0.0.1:6379> get k4
(nil)
# 事务队列中的命令都不会执行
3、编译性异常!(代码有问题!命令有错!),事务中所有的命令都不会被执行!
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> getset k3
(error) ERR wrong number of arguments for 'getset' command # 错误的命令
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> set k5 v5
QUEUED
127.0.0.1:6379> exec
(error) EXECABORT Transaction discarded because of previous errors. # 事务报错,所有的命令都不会被执行
127.0.0.1:6379> get k5
(nil)
4、运行时异常!(1/0),如果事务队列中存在语法错误,那么执行命令的时候,其他命令是可以正常执行的,错误命令抛出异常!
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 "v1"
QUEUED
127.0.0.1:6379> incr k1 # 运行时错误
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> get k3
QUEUED
127.0.0.1:6379> exec # 事务依旧可以正常执行
1) OK
2) (error) ERR value is not an integer or out of range
3) OK
4) "v3"
5、锁:Redis可以执行乐观锁,Watch监控
悲观锁:
- 很悲观,认为什么时候都会出问题,无论做什么都加锁!
乐观锁:
-
很乐观,认为什么时候都不会出问题,所以不会上锁!更新数据的时候去判断一下,在此期间是否有人修改过这个数据,version版本控制!
-
获取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> watch money # 监视 money 对象
OK
127.0.0.1:6379> multi # 事务正常结束,数据期间没有发生变动,这个时候就正常执行成功!
OK
127.0.0.1:6379> decrby money 20
QUEUED
127.0.0.1:6379> incrby out 20
QUEUED
127.0.0.1:6379> exec
1) (integer) 80
2) (integer) 20
在两个线程同时操作的时候,对值进行修改后,使用watch监视后,事务一定会提交失败!
线程1:
127.0.0.1:6379> watch money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> DECRBY money 10
QUEUED
127.0.0.1:6379> INCRBY money 10
QUEUED
127.0.0.1:6379> DECRBY money 10
QUEUED
127.0.0.1:6379> INCRBY out 10
QUEUED
127.0.0.1:6379> exec
(nil)
线程2:
127.0.0.1:6379> get money
"80"
127.0.0.1:6379> set money 1000
OK
127.0.0.1:6379> get money
"1000"
127.0.0.1:6379>
=使用Redis的Watch可以当做redis的乐观锁操作=
在提交失败后,应该取消监视,重新对新的版本进行监视。
127.0.0.1:6379> get money
"1010"
127.0.0.1:6379> get out
"10"
127.0.0.1:6379> unwatch
OK
127.0.0.1:6379> watch money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby money 100
QUEUED
127.0.0.1:6379> incrby out 100
QUEUED
127.0.0.1:6379> exec
1) (integer) 910
2) (integer) 110
三、Jedis
Jedis是什么?是Redis官方推荐的java连接开发工具,使用java操作Redis的中间件!如果你要使用java操作Redis,那么一定要对jedis十分的熟悉!
1、导入对应依赖:
<dependencies>
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.2.0</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.60</version>
</dependency>
</dependencies>
2、编码测试
- 连接数据库
- 操作命令
- 断开连接
package com.ogj;
import redis.clients.jedis.Jedis;
public class TestPing {
public static void main(String[] args) {
//1、new 一个 jedis 对象
Jedis jedis = new Jedis("47.97.192.241",6379);
//jedis 所有的命令就是我们之前学习的所有命令-->方法
System.out.println(jedis.ping());
}
}
常用的API
String
List
Set
Hash
Zset
package com.ogj;
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("47.97.192.241",6379);
//jedis 所有的命令就是我们之前学习的所有命令-->方法
System.out.println(jedis.ping());
System.out.println("清空数据:"+jedis.flushDB());
System.out.println("判断某个键是否存在:"+jedis.exists("username"));
System.out.println("新增<'username','ogj'>的键值对:"+jedis.set("username","ogj"));
System.out.println("新增<'password','123'>的键值对"+jedis.set("password","123"));
System.out.println("现在所有的键如下:");
Set<String> keys = jedis.keys("*");
System.out.println(keys);
System.out.println("-------------------------------------------------------------");
System.out.println("删除键password"+jedis.del("password"));
System.out.println("判断password是否存在:"+jedis.exists("password"));
System.out.println("查看键username所存储的值的类型:"+jedis.type("username"));
System.out.println("随机返回key空间一个key值:"+jedis.randomKey());
System.out.println("重命名key:"+jedis.rename("username","ogj1"));
System.out.println("重命名后的key:"+jedis.get("ogj1"));
System.out.println("按索引查询:"+jedis.select(0));
System.out.println("删除当前选择数据库中的所有key:"+jedis.flushDB());
System.out.println("当前数据库中的key的数目:"+jedis.dbSize());
}
}
结果如下:
=== 所有的命令 和前面学到的命令是一模一样的 ===
重点:事务:
package com.ogj;
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("47.97.192.241",6379);
JSONObject jsonObject = new JSONObject();
jedis.flushDB();
jsonObject.put("hello","world");
jsonObject.put("name","ogj");
Transaction transaction = jedis.multi();//开启事务
String result = jsonObject.toJSONString();
// jedis.watch(result); //乐观锁
try {
transaction.set("user1", result);
transaction.set("user2", result);
int i = 1/0; //抛出异常,事务失败
transaction.exec();//成功了 就执行事务
}catch (Exception e){
transaction.discard(); //失败了就放弃事务
e.printStackTrace();
}finally {
System.out.println(jedis.get("user1"));
System.out.println(jedis.get("user2"));
jedis.close();
}
}
}
四、SpringBoot的整合:
SpringBoot 操作数据:spring-data jpa jdbc mongdb redis!
SpringData也是和SpringBoot齐名的项目
=== 整合springboot ===
在SpringBoot2.x之后,原来使用的jedis被替换成了lettuce
jedis:采用的是直连的server,如果多个线程操作的话,是不安全的,如果想要避免不安全,需要使用jedis pool连接池!BIO模式;
lettuce:采用netty,实例可以再多个线程中进行共享,不存在线程不安全的情况!可以减少线程数据,更像NIO模式;
源码分析:
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
@Bean
@ConditionalOnMissingBean(name = "redisTemplate") // 判断是否存在这个类,如果不存在,该方法生效,如果存在就不生效,这样我们就可以自定义
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
@Bean
@ConditionalOnMissingBean //由于String 是最常用的,所有存在一个单独的bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}
=测试springboot=:
-
导入依赖
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>
-
配置连接
# SpringBoot 所有的配置类,都有一个自动配置类 # 自动配置类都会绑定一个properties # 配置redis spring.redis.host=47.97.192.241 spring.redis.port=6379
-
测试
@SpringBootTest class Redis01SpringbootApplicationTests { @Autowired private RedisTemplate redisTemplate; @Test void contextLoads() { //opsForValue 操作字符串 String //opsForList 操作List //opsForZSet //opsForGeo // //ops .... //除了基本的操作,我们常用的方法 都可以直接通过redisTemplate来操作:事务、CRUD //获取redis 连接 //RedisConnection connection = redisTemplate.getConnectionFactory().getConnection(); //connection.flushDb(); //connection.flushAll(); redisTemplate.opsForValue().set("myKey","ogj springboot,学习redis"); System.out.println(redisTemplate.opsForValue().get("myKey")); } }
我们来看一下自动配置中的序列化:
@SuppressWarnings("rawtypes") private @Nullable RedisSerializer keySerializer = null; @SuppressWarnings("rawtypes") private @Nullable RedisSerializer valueSerializer = null; @SuppressWarnings("rawtypes") private @Nullable RedisSerializer hashKeySerializer = null; @SuppressWarnings("rawtypes") private @Nullable RedisSerializer hashValueSerializer = null;
-
在RedisTemplate中有自带的序列化,所以我们在对于中文的操作的过程中,java中是可以得到正常的值的,但是在命令行中得到的大概率是一个乱码的值。
-
如果传递对象,必须实现序列化,否则不允许传输:
if (defaultSerializer == null) {
//默认的是JDK序列化,我们一般需要json序列化,所以我们需要自定义序列化类,添加一个配置类
defaultSerializer = new JdkSerializationRedisSerializer(
classLoader != null ? classLoader : this.getClass().getClassLoader());
}
-
在我们序列化后:
public class User implements Serializable {
因为JDK自带的序列化,那么就只会返回一个User对象,对于常用情况下,JDK的序列化并不适合,所有我们需要自定义序列化,最好的序列化是JSON序列化。
-
我们就来写一个自定义的redis配置类:由刚刚源码分析,只要我们自定义了redis配置类,那么原本的配置类就不生效了,所以我们不用担心配置的重复和冲突关系,自定义的配置会生效的时候,初始的配置就会失效。
@Configuration public class RedisConfig { //编写我们自己的配置类: @Bean public RedisTemplate<String , Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { RedisTemplate<String, Object> template = new RedisTemplate<>(); //我们来自定义配置JSON序列化 //配置具体的序列化方式 template.setKeySerializer();//这里可以设置我们需要的序列化类,我们可以来看一下源码中可以使用的序列化类 template.setConnectionFactory(redisConnectionFactory); return template; } }
设置的对象是RedisSerializer:我们来看一下这个的实现
ctrl+点击进入源码: 这是一个接口,我们来看一下他的实现类:
实现类:
这里有各种各样的实现类,包括我们需要的JSON的序列化类。所以我们可以在配置类中new 一个JSON的对象,然后设置到redis中,就可以生效。
@Configuration public class RedisConfig { //编写我们自己的配置类: @Bean public RedisTemplate<String , Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); //我们来自定义配置JSON序列化 //配置具体的序列化方式 Jackson2JsonRedisSerializer<Object> jsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class); //进行转义 ObjectMapper objectMapper = new ObjectMapper(); objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); jsonRedisSerializer.setObjectMapper(objectMapper); // String的序列化 StringRedisSerializer stringRedisSerializer=new StringRedisSerializer(); //key采用String的序列化方式 template.setKeySerializer(stringRedisSerializer); //hash的key也采用String的序列方式 template.setHashKeySerializer(stringRedisSerializer); //value序列化采用JSON template.setValueSerializer(jsonRedisSerializer); //hash的value template.setHashValueSerializer(jsonRedisSerializer); template.afterPropertiesSet(); return template; } }
该模板为基本完善的模板,直接使用即可。
对于redis操作,我们可以脱离出来,自己写一个操作类:
RedisUtil:
package com.ogj.utils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.stereotype.Component; import org.springframework.util.CollectionUtils; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.concurrent.TimeUnit; @Component public class RedisUtil { @Autowired private RedisTemplate<String,Object> redisTemplate; @Autowired private StringRedisTemplate stringRedisTemplate; public RedisUtil() { } /** * 设置缓存过期时间 * @param key * @param time * @return */ public boolean expire(String key,long time){ try { if(time>0){ redisTemplate.expire(key,time, TimeUnit.SECONDS); } return true; }catch (Exception e){ e.printStackTrace(); return false; } } /** * 根据key 获取过期时间 * @param key * @return 秒 */ public long getExpire(String key){ return redisTemplate.getExpire(key,TimeUnit.SECONDS); } /** * 判断Key是否存在 * @param key * @return */ public boolean hasKey(String key){ try { return redisTemplate.hasKey(key); }catch (Exception e){ e.printStackTrace(); return false; } } /** * 删除键 * @param key */ public void del(String... key){ if(key!=null&&key.length>0) { if (key.length == 1) { redisTemplate.delete(key[0]); } else{ redisTemplate.delete(CollectionUtils.arrayToList(key)); } } } /** * 获得对象 * @param key * @return */ public Object get(String key){ return (key == null) ? null : redisTemplate.opsForValue().get(key); } /** * 存放缓存 * @param key * @param value * @return */ public boolean set(String key,Object value){ try { redisTemplate.opsForValue().set(key, value); return true; } catch (Exception e){ e.printStackTrace(); return false; } } /** * 设置缓存 并设置过期时间 * @param key * @param value * @param time * @return */ public boolean set(String key,Object value,long time){ try { if (time>0){ redisTemplate.opsForValue().set(key, value, time); }else { set(key,value); } return true; }catch (Exception e){ e.printStackTrace(); return false; } } /** * 递增 key * @param key * @param delta * @return */ public long incr(String key,long delta){ if(delta<0){ throw new RuntimeException("递增因子必须大于0"); } return redisTemplate.opsForValue().increment(key, delta); } /** * 递减 * @param key * @param delta * @return */ public long decr(String key,long delta){ if(delta<0){ throw new RuntimeException("递减因子必须大于0"); } return redisTemplate.opsForValue().increment(key, -delta); } /** * 设置List类型对象专用 * @param key * @param value * @param <T> */ public <T> Long setValToListLeft(String key, List<T> value) { return this.redisTemplate.opsForList().leftPush(key, value); } /** * 获得List类型对象专用 * @param key * @return */ public Object getValToListLeft(String key) { return this.redisTemplate.opsForList().leftPop(key); } /** * 设置List类型对象专用 * @param key * @param value * @param <T> */ public <T> Long setValToListRight(String key, List<T> value) { return this.redisTemplate.opsForList().rightPush(key, value); } /** * 获得List类型对象专用 * @param key * @return */ public Object getValToListRight(String key) { return this.redisTemplate.opsForList().rightPop(key); } /** * 开启Redis 事务 * * @param isTransaction */ public void multi() { // 开启Redis 事务权限 stringRedisTemplate.setEnableTransactionSupport(true); // 开启事务 stringRedisTemplate.multi(); } /** * 提交事务 * * @param isTransaction */ public void exec() { // 成功提交事务 stringRedisTemplate.exec(); } /** * 回滚Redis 事务 */ public void discard() { // 回滚Redis 事务 stringRedisTemplate.discard(); } }
注意: 对于SpringBoot2.x来说,jedis pool 已经没有加入到bean中,所以使用lecture;
在SpringBoot中使用Redis的时候,可以很快进行开发。
五、Redis进阶:
1、Redis.conf配置
初始配置
1、配置文件 unit单位 对大小写不敏感
包含配置
2、可以包含多个comf,使用include进行包含
网络配置
bind 127.0.0.1 # 绑定的ip
protected-mode yes # 保护模式
port 6379 # 端口设置
通用配置
daemonize yes # 以守护进程的方式运行,默认是no,我们需要手动开启yes
pidfile /var/run/redis_6379.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
# Specify the log file name. Also the empty string can be used to force
# Redis to log on the standard output. Note that if you use standard
# output for logging but daemonize, logs will be sent to /dev/null
logfile "" # 设置日志文件的文件名
# Set the number of databases. The default database is DB 0, you can select
# a different one on a per-connection basis using SELECT <dbid> where
# dbid is a number between 0 and 'databases'-1
databases 16 # 默认的数据库的数量 默认是16个数据库
always-show-logo yes # 是否显示logo
快照配置
后面使用持久化的时候,在规定的时间内,执行了多少次操作,则会持久化到文件:.rdb .aof文件
redis是内存的数据库,如果没有持久化,那么断电就会失去数据。
save 900 1 # 如果900s内 至少有一个key进行了修改,那么就进行一次持久化操作
save 300 10 # 如果300s内 至少10 key进行了修改,那么就会进行一次持久化
save 60 10000 # 如果60s内 至少 10000个key进行了修改,那么就会进行一次持久化
stop-writes-on-bgsave-error yes # 持久化如果出错了,是否还继续工作
rdbcompression yes # 是否压缩rdb文件,此时需要消耗cpu资源
rdbchecksum yes # 保存rdb文件的时候,进行文件校验
dir ./ # rdb保存的目录
REPLICATION 复制,后面讲解主从复制的时候 进行详情学习
SECURITY 安全
获取redis的密码:config get requirepass
设置密码:格式为-> requirepass 1234567
命令设置: config set requirepass “1234567”
密码验证: auth
=注意=: 一般情况修改了conf ,需要去重启redis
CLIENTS 限制
maxclients 10000 # 设置redis 最大客户端的数量
maxmemory <bytes> # redis 最大的内存大小
maxmemory-policy noeviction # 内存到达上限的之后处理策略
# maxmemory-policy 六种方式
# 1、volatile-lru:只对设置了过期时间的key进行LRU(默认值)
# 2、allkeys-lru : 删除lru算法的key
# 3、volatile-random:随机删除即将过期key
# 4、allkeys-random:随机删除
# 5、volatile-ttl : 删除即将过期的
# 6、noeviction : 永不过期,返回错误
APPEND ONLY MODE 模式 aof 配置
appendonly no # 默认是不开启aof持久化的,基本都是使用rdb进行持久化的
appendfilename "appendonly.aof" # 持久化的文件的名字
# appendfsync always # 每次修改都会sync ,消耗性能
appendfsync everysec # 每秒都执行一次sync,可能会丢失这1s的数据
# appendfsync no # 不执行同步,这时候 操作系统自己同步数据,速度最快!
2、Redis持久化
1、RDB(Redis Database)
RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘,实际操作过程是fork一个子进程,先将数据集写入临时文件,写入成功后,再替换之前的文件,用二进制压缩存储。
rdb保存的文件->dump.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) "/usr/local/bin" # 如果在这个文件夹下有dump.rdb文件,启动就会自动恢复其中的数据
优点:
1、适合大规模的数据恢复! dump.rdb
2、对数据完整性不高!
缺点:
1、需要一定的时间间隔进程操作!如果redis意外宕机了,那么最后一次修改数据就没有了
2、fork进程的时候,会占用一定的内存空间。
2、AOF(Append Only File)
讲我们所有的命令都记录下来,相当于history文件,在恢复的时候,直接把这个文件全部执行一遍就可以了。
AOF持久化以日志的形式记录服务器所处理的每一个写、删除操作,查询操作不会记录,以文本的方式记录,可以打开文件看到详细的操作记录。
append
默认aof是不开启的,我们需要修改为yes开启。appendonly no 改为 yes
root@ogj:/usr/local/bin#redis-server ./ogjconfig/redis.conf
4542:C 28 May 2020 22:19:29.140 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
4542:C 28 May 2020 22:19:29.140 # Redis version=6.0.1, bits=64, commit=00000000, modified=0, pid=4542, just started
4542:C 28 May 2020 22:19:29.140 # Configuration loaded
root@ogj:/usr/local/bin#netstat -antlp | grep redis
tcp 0 0 0.0.0.0:6379 0.0.0.0:* LISTEN 4543/redis-server *
tcp6 0 0 :::6379 :::* LISTEN 4543/redis-server *
root@ogj:/usr/local/bin#redis-cli
127.0.0.1:6379> shutdown
not connected> exit
root@ogj:/usr/local/bin#ls
chardetect iptest jupyter-console jupyter-troubleshoot redis-benchmark
cheetah iptest3 jupyter-kernel jupyter-trust redis-check-aof
cheetah-analyze ipython jupyter-kernelspec markdown_py redis-check-rdb
cheetah-compile ipython3 jupyter-migrate ogjconfig redis-cli
cloud-init jsondiff jupyter-nbconvert pip redis-sentinel
cloud-init-per jsonpatch jupyter-nbextension pip2 redis-server
dump.rdb jsonpointer jupyter-notebook pip2.7 wheel
easy_install jsonschema jupyter-qtconsole pip3
easy_install-2.7 jupyter jupyter-run pip3.5
easy_install-3.6 jupyter-bundlerextension jupyter-serverextension pygmentize
root@ogj:/usr/local/bin#vim ogjconfig/redis.conf
root@ogj:/usr/local/bin#netstat -antlp | grep redis
root@ogj:/usr/local/bin#redis-server ./ogjconfig/redis.conf
4577:C 28 May 2020 22:22:28.249 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
4577:C 28 May 2020 22:22:28.249 # Redis version=6.0.1, bits=64, commit=00000000, modified=0, pid=4577, just started
4577:C 28 May 2020 22:22:28.249 # Configuration loaded
root@ogj:/usr/local/bin#redis-cli
127.0.0.1:6379>
在重新启动后,会自动产生appendonly.aof文件
我们来添加一些数据,然后save一下,来查看aof中保存的数据:
我们可以看到,这个文件中,保存了所有的数据,k1 v1 ;k2 v2 ; k3 v3;k4 v4
如果这个文件中存在问题,我们就可以进行修复
我们来给这个文件中添加一些垃圾数据:
然后我们来连接:
我们发现现在无法连接,说明自动加载了aof文件,在加载的过程中存在了问题。
这个时候:我们可以使用redis-check-aof来修复这个aof文件。
我们来看看是不是修复成功了:
我们添加的数据就全部删除了,修复了该文件。
我们现在就可以重新连接redis了:
成功连接
如果AOF文件大于64m,那么就太大了!那么就会fork一个新的进程进行文件重写!
AOF默认的是文件的无限追加!文件就会越来越大
优点:
1、每一次修改都同步,文件的完整性会更加好;
2、每秒同步一次,可能会丢失一秒的数据;
3、从不同步,效率是最高的;
缺点:
1、相当于数据文件来说,aof远远大于rdb,修复的速度也比rdb慢!
2、Aof运行效率也比rdb要慢,所以我们redis默认的配置就是rdb持久化。
3、Redis发布订阅
通信、队列、发送者、订阅者
Redis 发布订阅(pub/sub)是一种消息通信模式:发送者(pub)发送消息,订阅者(sub)接收消息
Redis客户端可以订阅任意数量的频道。
发布/订阅消息图:
第一个:消息发送者,第二个:频道,第三个:消息接受者。
下图展示了频道 channel1 , 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系:
当有新消息通过 PUBLISH 命令发送给频道 channel1 时, 这个消息就会被发送给订阅它的三个客户端:
Redis 发布订阅命令
下表列出了 redis 发布订阅常用命令:
序号 | 命令及描述 |
---|---|
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 …]] 指退订给定的频道。 |
测试
1、订阅端
127.0.0.1:6379> SUBSCRIBE ogjshuo # 订阅一个频道
Reading messages... (press Ctrl-C to quit) # 等待 推送的信息
1) "subscribe"
2) "ogjshuo"
3) (integer) 1
1) "message"
2) "ogjshuo"
3) "hello world"
1) "message" # 这就是发过来的消息
2) "ogjshuo" # 发送者的频道
3) "hello redis" # 发送的消息
2、发送端
root@ogj:/usr/local/bin#redis-cli -p 6379
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> publish ogjshuo "hello world" # publish 频道名 消息
(integer) 1
127.0.0.1:6379> publish ogjshuo "hello redis"
(integer) 1
127.0.0.1:6379>
原理
Redis是使用C 实现的,通过分析Redis源码里的pubsub.c文件,了解发布和订阅机制的底层实现。
Redis 通过PUBLISH、SUBSCRIBE和PSUBSCRIBE等命令实现发布和订阅功能。
通过SUBSCRIBE命令订阅某频道后,redis-server 里维护了一个字典,字典的键就是一个个channel频道,而字典的值则是一个链表,链表中保存了所有订阅这个channel频道的客户端。SUBSCRIBE命令的关键,就是将客户端添加到给定channel频道的订阅链表中。
通过PUBLISH命令向订阅者发送信息,redis-server会使用给定的频道作为键,在它所维护的channel字典中查找记录了订阅这个频道的所有客户端的链表,遍历整个链表,将消息发布给所有订阅者。
Pub/Sub 从字面上理解就是发布(Publish) 与 订阅(Subscribe),在Redis中,你可以设定对某一个key值进行消息发布及消息订阅,当一个key值上进行了消息发布后,所有订阅它的客户端都会收到相应的消息,这一功能最明显的用法就是用作实时消息系统,比如普通的即时聊天,群聊等功能。
使用场景:
1、实时消息系统
2、实时聊天!(频道当做聊天室,将信息回显给所有人即可)
3、订阅,关注系统都是可以的!
稍微复杂的场景我们就会使用 消息中间件MQ来实现啦
4、Redis主从复制
主从复制,是指将一台Redis服务器的数据,复制到其他的Redis服务器,前者称为主节点(master/leader),后者称为从节点(slave/follower);数据的复制是单向的,只能由主节点到从节点。Master以写为主,Slave以读为主。
默认情况下,每台redis服务器都是主节点,且一个主节点可以有多个从节点(或者没有从节点),但一个从节点只能有一个主节点。
主从复制的作用主要包括:
1、数据冗余:主从复制实现了数据的热备份,是持久化之外的一种数据冗余方式。
2、故障恢复:当主节点出现问题的时候,可以由从节点提供服务,实现快速的故障恢复,实际上是一种服务的冗余。
3、负载均衡:在主从复制的基础上,配合读写分离,可以由主节点提供写服务,由从节点提供读服务(即写Redis数据时应用连接主节点,读Redis数据时应连接从节点),分担服务器负载;尤其是在写少读多的时候。
4、高可用基石:除了上述以外,主从复制还是哨兵和集群能够实施的基础,因此说主从复制是Redis高可用的基础。
主从复制,读写分离! 80%的情况是进行读操作!减缓服务器的压力。
配置为:至少为1主2从节点。
注意:单台 Redis最大使用内存不应该超过20G,否则就应该转换为集群模式
只要在企业中,主从复制是必须要使用的,因为在真实的项目中,是不可能单机使用Redis的。
环境配置:
只需要配置从节点,因为Redis本身就是一个主节点
127.0.0.1:6379> info replication # 查看当前的信息
# Replication
role:master # 角色:master
connected_slaves:0 # 没有从机
master_replid:559da602bc27efa26b061bb501cc20dd3a9cb260
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
master_repl_meaningful_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
创建三个从节点的配置文件:redis79.conf、redis80.conf、redis81.conf
1、首先修改port端口:
2、修改pid文件
3、修改log文件
4、修改rdb文件
修改完毕:
启动三个从节点:
启动成功为:
一主二从搭建:
每一台都是主节点(默认),怎么去配置从节点呢?一般情况我们只需要配置从机就可以了
一主(79) 二从(80,81)
使用命令:Slaveof ip port,例:SLAVEOF 127.0.0.1 6379
127.0.0.1:6380> info replication # 未选择主机的时候
# Replication
role:master
connected_slaves:0
master_replid:e56c793d1f62cd0ca02027e188af4de3b563f8c6
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
master_repl_meaningful_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
127.0.0.1:6380> SLAVEOF 127.0.0.1 6379 # 选择主机: slaveof ip地址 端口port
OK
127.0.0.1:6380> info replication # 连接主机后的情况
# Replication
role:slave
master_host:127.0.0.1 # 主机地址
master_port:6379 # 主机端口
master_link_status:up
master_last_io_seconds_ago:4
master_sync_in_progress:0
slave_repl_offset:42
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:aa45329d4c2c40596d5ac33b2787d575429c29fa
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:42
master_repl_meaningful_offset:0
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:42
127.0.0.1:6380>
主机配置:
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6380,state=online,offset=42,lag=1 # 从机1
slave1:ip=127.0.0.1,port=6381,state=online,offset=42,lag=1 # 从机2
master_replid:aa45329d4c2c40596d5ac33b2787d575429c29fa
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:42
master_repl_meaningful_offset:0
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:42
真实的主从配置是在文件中配置的。在文件中配置是永久的,启动就称为主机或者从机
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aa4ATmPL-1590968809464)(C:\Users\ogj\AppData\Roaming\Typora\typora-user-images\image-20200529185636874.png)]
细节
主机可以写也可以读,从机只能读不能写!主机中的所有信息和数据,都会被从机所保存!
主机:
从机:
测试
主机断开,从机依旧连接到主机的,但是没有写操作了,这个时候,如果主机回来了,从机依旧可以获取到主机写的信息!
从机断开,这个时候主机set的键值对,然后从机恢复了,这个时候从机是拿不到主机的值的!
原因: 因为我们的配置中没有把这个从机设置为从机,我们之前是使用命令去设置主机的,所以我们重启了从机,那么这个机器就会把自己作为主机,那么肯定就不能拿到之前主机的值的啦!
我们只要把这个机子再配置为主机的从机,数据就会立马从主机中获取到值了,就可以拿到之前的值了。
复制原理
Slave 启动成功连接到 master 后会发送一个sync 同步请求
Master 接收到命令后,启动后台存盘进程,同时收集所有接收到的用于修改数据集命令,在后台进程执行完毕后,master将传送整个数据文件到slave,并完成一次完全同步。
全量复制:Slave 服务在接收到数据库文件数据后,将其存盘并加载到内存中
增量复制:Master 继续将新的所有收集到的修改命令依次传给 Slave ,完成同步。
但是只要重新连接master,一次完全同步(全量复制) 讲被自动执行,所以只要新的从机加入进来,就可以获取到所有的数据。
思考?
这种架构,一主对多从的情况下,当M被挂掉之后,那么整个集群就GG了,这种高度中心化的架构的高可用性不够高,并且容易整个集群崩掉。
新架构1:
所以提出了连续串联的方式,把从机一一连接起来,然后再连到主机上,这样的情况下,如果主机崩了,我们还可以从从机中选举出一个新的主机,使得集群不会崩溃。但是在这种的架构下,S依旧也是从节点,并不会变成主节点。
如果没有老大了,这个时候还能不能选择出一个老大出来呢? 以前的方式->手动
命令:Slaveof no one 可以把从节点自己作为主节点!其他的节点就可以手动连接到最新的主节点上了。但是这是手动的!当之前的皇帝回来的时候,需要手动把老皇帝继续作为新皇帝的子节点,被谋权篡位了。其余的节点也就会自动链接上了,所以新架构是相对于之前的中心化来说是更优秀的。
5、哨兵模式(自动选举的老大的模式):
概述
主从切换技术的方法是:当主服务器宕机后,需要手动把一台从服务器切换为主服务器,这就需要人工干预,费事费力,还会造成一段时间内服务不可用。这不是一种推荐的方式,更多时候,我们优先考虑哨兵模式。Redis从2.8开始正式提供了Sentinel(哨兵)架构来解决这个问题。
谋朝篡位的自动版!能够后台监控主机是否故障,如果故障了根据投票数自动将从节点转换为主节点。
哨兵模式是一种特殊的模式,首先Redis提供了哨兵的命令,哨兵是一个独立的进程,作为进程,它会独立运行。其原理是哨兵通过发送命令,等待Redis服务器响应,从而监控运行的多个Redis实例。
这里的哨兵有两个作用
- 通过发送命令,让Redis服务器返回监控其运行状态,包括主服务器和从服务器。
- 当哨兵监测到master宕机,会自动将slave切换成master,然后通过发布订阅模式通知其他的从服务器,修改配置文件,让它们切换主机。
然而一个哨兵进程对Redis服务器进行监控,可能会出现问题,为此,我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控,这样就形成了多哨兵模式。
假设主服务器宕机,哨兵1先检测到这个结果,系统并不会马上进行Failover过程,仅仅是哨兵1主观的认为主服务器不可用,这个现象为主观下线,当后面的哨兵也检测到主服务器不可用,并且数量达到一定值时,那么哨兵之间就会进行一次投票,投票的结果由一个哨兵发起,进行Failover故障转移操作。切换成功后,就会通过发布订阅模式,让各个哨兵把自己监控的从服务器实现切换主机,这个过程称为客观下线。
测试!
我们的状态是 一主二从!
1、哨兵配置文件:sentinel.conf
# sentinel monitor 被监控的名称 host port 1
sentinel monitor myredis 127.0.0.1 6379 1
后面这个数字1代表主机挂了,slave投票看让谁接替称为主机,票数最多的,就会称为主机!
2、启动哨兵!
root@ogj:/usr/local/bin#redis-sentinel ogjconfig/sentinel.conf
15290:X 31 May 2020 22:30:07.991 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
15290:X 31 May 2020 22:30:07.991 # Redis version=6.0.1, bits=64, commit=00000000, modified=0, pid=15290, just started
15290:X 31 May 2020 22:30:07.991 # Configuration loaded
_._
_.-``__ ''-._
_.-`` `. `_. ''-._ Redis 6.0.1 (00000000/0) 64 bit
.-`` .-```. ```\/ _.,_ ''-._
( ' , .-` | `, ) Running in sentinel mode
|`-._`-...-` __...-.``-._|'` _.-'| Port: 26379
| `-._ `._ / _.-' | PID: 15290
`-._ `-._ `-./ _.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' | http://redis.io
`-._ `-._`-.__.-'_.-' _.-'
|`-._`-._ `-.__.-' _.-'_.-'|
| `-._`-._ _.-'_.-' |
`-._ `-._`-.__.-'_.-' _.-'
`-._ `-.__.-' _.-'
`-._ _.-'
`-.__.-'
15290:X 31 May 2020 22:30:07.993 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
15290:X 31 May 2020 22:30:07.996 # Sentinel ID is 009fc927b47b5d2586e58a43090f2d511e5efdc8
15290:X 31 May 2020 22:30:07.996 # +monitor master myredis 127.0.0.1 6379 quorum 1
15290:X 31 May 2020 22:30:07.997 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
15290:X 31 May 2020 22:30:07.999 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
在主机宕机之后,会自动从从机中选举出一个新的主节点(投票算法:加权轮询算法):
15295:X 31 May 2020 22:32:41.235 * +failover-state-send-slaveof-noone slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
15295:X 31 May 2020 22:32:41.297 * +failover-state-wait-promotion slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
15295:X 31 May 2020 22:32:41.709 # +promoted-slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
15295:X 31 May 2020 22:32:41.709 # +failover-state-reconf-slaves master myredis 127.0.0.1 6379
15295:X 31 May 2020 22:32:41.759 * +slave-reconf-sent slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
15295:X 31 May 2020 22:32:42.707 * +slave-reconf-inprog slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
15295:X 31 May 2020 22:32:42.707 * +slave-reconf-done slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
15295:X 31 May 2020 22:32:42.783 # +failover-end master myredis 127.0.0.1 6379
15295:X 31 May 2020 22:32:42.783 # +switch-master myredis 127.0.0.1 6379 127.0.0.1 6381
15295:X 31 May 2020 22:32:42.783 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6381
15295:X 31 May 2020 22:32:42.783 * +slave slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6381
15295:X 31 May 2020 22:33:12.813 # +sdown slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6381
6381就变成了master:
127.0.0.1:6381> info replication
# Replication
role:master # 主节点
connected_slaves:1
slave0:ip=127.0.0.1,port=6380,state=online,offset=270009,lag=0
master_replid:aa92d567a9e345a6573a0d7c99566be36ff8b16a
master_replid2:a704f77c22fe4351e8c6a9eac7422e6a1427b13f
master_repl_offset:270009
master_repl_meaningful_offset:270009
second_repl_offset:266339
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:270009
127.0.0.1:6381>
哨兵模式
当之前的节点回来之后,只能作为新的主机的从机,作为主机的小弟!
优点:
1、哨兵集群,基于主从复制的模式,所有的主从配置优点,它全有。
2、主从可以切换,故障可以转移,系统的可用性就会更好。
3、哨兵模式就是主从模式的升级,从手动变为自动。
缺点:
1、Redis不好在线扩容,集群容量到达上限,在线的扩若十分麻烦。
2、实现哨兵模式的配置其实是很麻烦的,里面有很多选择!
哨兵模式的配置
# sentinel monitor <master-name> <ip> <redis-port> <quorum>
告诉sentinel去监听地址为ip:port的一个master,这里的master-name可以自定义,quorum是一个数字,指明当有多少个sentinel认为一个master失效时,master才算真正失效
# sentinel auth-pass <master-name> <password>
设置连接master和slave时的密码,注意的是sentinel不能分别为master和slave设置不同的密码,因此master和slave的密码应该设置相同。
# sentinel down-after-milliseconds <master-name> <milliseconds>
这个配置项指定了需要多少失效时间,一个master才会被这个sentinel主观地认为是不可用的。 单位是毫秒,默认为30秒
# sentinel parallel-syncs <master-name> <numslaves>
这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同步,这个数字越小,完成failover所需的时间就越长,但是如果这个数字越大,就意味着越 多的slave因为replication而不可用。可以通过将这个值设为 1 来保证每次只有一个slave 处于不能处理命令请求的状态。
# sentinel failover-timeout <master-name> <milliseconds>
failover-timeout 可以用在以下这些方面:
1. 同一个sentinel对同一个master两次failover之间的间隔时间。
2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
3.当想要取消一个正在进行的failover所需要的时间。
4.当进行failover时,配置所有slaves指向新的master所需的最大时间。不过,即使过了这个超时,slaves依然会被正确配置为指向master,但是就不按parallel-syncs所配置的规则来了。
6、Redis缓存穿透和雪崩(面试的重点)
服务器的高可用问题
Redis缓存的使用,极大的提升了应用程序的性能和效率,特别是效率查询方面。但同时,它也带来了一些问题,其中,最要害的问题,就是数据的一致性问题,从严格意义上将,这个问题无解。如果对数据的一致性要求很高,那么就不能使用缓存。
另外的一些典型问题:缓存穿透、缓存雪崩和缓存击穿。目前,业界也都有比较流行的解决方案。
缓存穿透(查不到):
概念
缓存穿透的概念很简单,用户想要查询一个数据,发现redis内存数据库里面没有,也就是缓存没有命中,于是向持久层数据库查询。发现也没有,于是本次查询失败。当用户很多的时候,缓存都没有命中,于是都去了请求持久层数据库,这就会给持久层数据库造成很大的压力,这时候就相当于出现了缓存穿透。
解决方案
1、布隆过滤器:
布隆过滤器是一种数据结构,对所有可能查询的参数以hash形式存储,在控制层先进行校验,不符合则丢弃,从而避免了对底层保存系统的查询压力。
布隆过滤器(Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法,缺点是有一定的误识别率和删除困难。
如果想判断一个元素是不是在一个集合里,一般想到的是将集合中所有元素保存起来,然后通过比较确定。链表、树、散列表(又叫哈希表,Hash table)等等数据结构都是这种思路。但是随着集合中元素的增加,我们需要的存储空间越来越大。同时检索速度也越来越慢,上述三种结构的检索时间复杂度分别为:O(n), O(log n), O(n/k)。
布隆过滤器的原理是,当一个元素被加入集合时,通过K个Hash函数将这个元素映射成一个位数组中的K个点,把它们置为1。检索时,我们只要看看这些点是不是都是1就(大约)知道集合中有没有它了:如果这些点有任何一个0,则被检元素一定不在;如果都是1,则被检元素很可能在。这就是布隆过滤器的基本思想。
对于缓存宕机的场景,使用白名单或者布隆过滤器都有可能会造成一定程度的误判。原因是除了Bloom Filter 本身有误判率,宕机之前的缓存不一定能覆盖到所有DB中的数据,当宕机后用户请求了一个以前从未请求的数据,这个时候就会产生误判。当然,缓存宕机时使用白名单/布隆过滤器作为应急的方式,这种情况应该也是可以忍受的。
2、缓存空对象
当存储层不命中,即使返回的空对象也将其缓存起来,同时会设置一个过期时间,之后再访问这个数据将会从缓存中获取,保护了后端数据源。
但是这种方法会存在两种问题:
1、如果控制能够被缓存起来,这就意味着缓存需要更多的空间存储更多的键,因为这当中可能会有很多的空值的键。
2、即使对空值设置了过期时间,还是会存在缓冲层和存储层的数据会有一段时间窗口的不一致,这对于需要保持一致性的业务会有影响。
缓存击穿(量太大,缓存过期!):
概述
这里需要注意和缓存穿透的区别,缓存击穿,是指一个key非常热点,在不停的扛着大并发,大并发集中对这一个点进行访问,当这个key在失效的瞬间,持续的大并发就会穿破缓存,直接请求数据库,就像在一个屏障上凿开了一个洞。
当某个key在过期的瞬间,有大量的请求并发访问,这类数据一版是热点数据,由于缓存过期,会同时访问数据库来查询最新的数据,并且回写缓存,会导致数据库瞬间压力过大。
解决方案
1、设置过期时间永不过期
从缓存层面来看,没有设置过期时间,就不会出现热点key过期后产生的问题。
2、加互斥锁
分布式锁:使用分布式锁,保证对于每个key同时只有一个线程去查询后端服务,其他线程没有获得分布式锁的权限,因此只需要等待即可。这种方式讲高并发的压力转移到了分布式锁,因此对分布式锁的考验很大。
缓存雪崩
概念
缓存雪崩,是指在某一个时间段,缓存集中过期失效。Redis宕机,停电等情况。
产生雪崩的原因之一,比如在写本文的时候,马上就要到双十二零点,很快就会迎来一波抢购,这波商品时间比较集中的放入了缓存,假设缓存一个小时。那么到了凌晨一点钟的时候,这批商品的缓存就都过期了。而对这批商品的访问查询,都落到了数据库上,对于数据库来说,就会产生周期性的压力波峰。于是所有的请求都会到达存储层,存储层的调用量会暴增,造成存储层也会挂掉的情况。
其中集中过期,倒不是非常致命,比较致命的缓存雪崩,是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩,一定是在某个时间段集中创建缓存,这个时候,数据库也是可以顶住压力的。无非就是对数据库产生周期性压力而已。而缓存服务器节点的宕机,对数据库服务器造成的压力是不可预知的,很有可能瞬间就把数据库压垮。
解决方案
1、redis高可用
这个思想的含义是,既然redis有可能挂掉,那么我就多增设几台redis,这样一台挂掉之后其他的还可以继续工作,其实就是搭建的集群。(异地多活!)
2、限流降级
这个解决方案的思想是,在缓存失效后,通过加锁或者队列来控制数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据或写缓存,其他线程等待。
3、数据预热
数据加热的含义就是在正式部署之前,我先把可能的数据先预先访问一遍,这样部分可能大量访问的数据就会加载到缓存中,在即将发生大并发访问前手动触发加载缓存不同的key,设置不同的过期时间,让缓存失效的时间点尽量均匀。
2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
3.当想要取消一个正在进行的failover所需要的时间。
4.当进行failover时,配置所有slaves指向新的master所需的最大时间。不过,即使过了这个超时,slaves依然会被正确配置为指向master,但是就不按parallel-syncs所配置的规则来了。
6、Redis缓存穿透和雪崩(面试的重点)
服务器的高可用问题
Redis缓存的使用,极大的提升了应用程序的性能和效率,特别是效率查询方面。但同时,它也带来了一些问题,其中,最要害的问题,就是数据的一致性问题,从严格意义上将,这个问题无解。如果对数据的一致性要求很高,那么就不能使用缓存。
另外的一些典型问题:缓存穿透、缓存雪崩和缓存击穿。目前,业界也都有比较流行的解决方案。
缓存穿透(查不到):
概念
缓存穿透的概念很简单,用户想要查询一个数据,发现redis内存数据库里面没有,也就是缓存没有命中,于是向持久层数据库查询。发现也没有,于是本次查询失败。当用户很多的时候,缓存都没有命中,于是都去了请求持久层数据库,这就会给持久层数据库造成很大的压力,这时候就相当于出现了缓存穿透。
解决方案
1、布隆过滤器:
布隆过滤器是一种数据结构,对所有可能查询的参数以hash形式存储,在控制层先进行校验,不符合则丢弃,从而避免了对底层保存系统的查询压力。
布隆过滤器(Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法,缺点是有一定的误识别率和删除困难。
如果想判断一个元素是不是在一个集合里,一般想到的是将集合中所有元素保存起来,然后通过比较确定。链表、树、散列表(又叫哈希表,Hash table)等等数据结构都是这种思路。但是随着集合中元素的增加,我们需要的存储空间越来越大。同时检索速度也越来越慢,上述三种结构的检索时间复杂度分别为:O(n), O(log n), O(n/k)。
布隆过滤器的原理是,当一个元素被加入集合时,通过K个Hash函数将这个元素映射成一个位数组中的K个点,把它们置为1。检索时,我们只要看看这些点是不是都是1就(大约)知道集合中有没有它了:如果这些点有任何一个0,则被检元素一定不在;如果都是1,则被检元素很可能在。这就是布隆过滤器的基本思想。
[外链图片转存中…(img-WKtzohAc-1590968809468)]
[外链图片转存中…(img-iUqRBjqR-1590968809468)]
对于缓存宕机的场景,使用白名单或者布隆过滤器都有可能会造成一定程度的误判。原因是除了Bloom Filter 本身有误判率,宕机之前的缓存不一定能覆盖到所有DB中的数据,当宕机后用户请求了一个以前从未请求的数据,这个时候就会产生误判。当然,缓存宕机时使用白名单/布隆过滤器作为应急的方式,这种情况应该也是可以忍受的。
2、缓存空对象
当存储层不命中,即使返回的空对象也将其缓存起来,同时会设置一个过期时间,之后再访问这个数据将会从缓存中获取,保护了后端数据源。
但是这种方法会存在两种问题:
1、如果控制能够被缓存起来,这就意味着缓存需要更多的空间存储更多的键,因为这当中可能会有很多的空值的键。
2、即使对空值设置了过期时间,还是会存在缓冲层和存储层的数据会有一段时间窗口的不一致,这对于需要保持一致性的业务会有影响。
缓存击穿(量太大,缓存过期!):
概述
这里需要注意和缓存穿透的区别,缓存击穿,是指一个key非常热点,在不停的扛着大并发,大并发集中对这一个点进行访问,当这个key在失效的瞬间,持续的大并发就会穿破缓存,直接请求数据库,就像在一个屏障上凿开了一个洞。
当某个key在过期的瞬间,有大量的请求并发访问,这类数据一版是热点数据,由于缓存过期,会同时访问数据库来查询最新的数据,并且回写缓存,会导致数据库瞬间压力过大。
解决方案
1、设置过期时间永不过期
从缓存层面来看,没有设置过期时间,就不会出现热点key过期后产生的问题。
2、加互斥锁
分布式锁:使用分布式锁,保证对于每个key同时只有一个线程去查询后端服务,其他线程没有获得分布式锁的权限,因此只需要等待即可。这种方式讲高并发的压力转移到了分布式锁,因此对分布式锁的考验很大。
缓存雪崩
概念
缓存雪崩,是指在某一个时间段,缓存集中过期失效。Redis宕机,停电等情况。
产生雪崩的原因之一,比如在写本文的时候,马上就要到双十二零点,很快就会迎来一波抢购,这波商品时间比较集中的放入了缓存,假设缓存一个小时。那么到了凌晨一点钟的时候,这批商品的缓存就都过期了。而对这批商品的访问查询,都落到了数据库上,对于数据库来说,就会产生周期性的压力波峰。于是所有的请求都会到达存储层,存储层的调用量会暴增,造成存储层也会挂掉的情况。
其中集中过期,倒不是非常致命,比较致命的缓存雪崩,是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩,一定是在某个时间段集中创建缓存,这个时候,数据库也是可以顶住压力的。无非就是对数据库产生周期性压力而已。而缓存服务器节点的宕机,对数据库服务器造成的压力是不可预知的,很有可能瞬间就把数据库压垮。
解决方案
1、redis高可用
这个思想的含义是,既然redis有可能挂掉,那么我就多增设几台redis,这样一台挂掉之后其他的还可以继续工作,其实就是搭建的集群。(异地多活!)
2、限流降级
这个解决方案的思想是,在缓存失效后,通过加锁或者队列来控制数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据或写缓存,其他线程等待。
3、数据预热
数据加热的含义就是在正式部署之前,我先把可能的数据先预先访问一遍,这样部分可能大量访问的数据就会加载到缓存中,在即将发生大并发访问前手动触发加载缓存不同的key,设置不同的过期时间,让缓存失效的时间点尽量均匀。
小结
在哔哩哔哩上学习狂神的课程半个月Redis详情,收获还是很大的,在这里谢谢老师的讲解了,推荐地址:
https://www.bilibili.com/video/BV1S54y1R7SB