Redis详细学习

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