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