两万字的Redis笔记！

声明：所有内容均来自B站《狂神说Java系列课程》一个宝藏男孩，强烈推荐！
视频地址：https://www.bilibili.com/video/BV1S54y1R7SB
笔者也是基于视频做的笔记，方便日后复习与查看。有不懂的地方可观看视频讲解。也希望大家多多支持狂神！

Redis

1、NoSQL概述

1.1、为什么要使用NoSQL？

1、单机MySQL的时代

在90年代，一个基本的网站访问量一般不会太大，单个数据库已经足够了！那个时代更多的是使用静态网页HTML

服务器根本没有那么大的压力。

思考一下，这种情况下，一个网站的瓶颈是什么？

1、数据量如果太大、一个机器放不下了!

2、数据的索引(B+Tree ) ，一个机器内存也放不下

3、访问量（读写混合），一个服务器承受不了~

只要你开始出现以上的三种情况之一，那么你就必须要晋级!

2、Memcached（缓存）+ MySQL + 垂直拆分(读写分离)

• 网站80%的情况都是在读，每次都要去查询数据库的话就十分的麻烦!所以说我们希望减轻数据的压力，我们可以使用缓存来保证效率!

• 发展过程:优化数据结构和索引–>文件缓存( io ) —> Memcached（当时最热门的技术!)
  

3、分库分表 + 水平拆分 + MySQL集群

技术和业务在发展的同时，对人的要求也越来越高!
本质：数据库(读、写)

早些年的搜索引擎 MylSAM: 表锁，十分影响效率!高并发下就会出现严重的锁问题

转战 Innodb: 行锁

慢慢的就开始使用分库分表来解决写的压力！ MySQL在哪个年代推出了表分区!这个并没有多少公司使用！MySQL的集群，很好满足哪个年代的所有需求！

4、如今最近的年代

• 2010-2020年十年之间，世界已经发生了翻天覆地的变化；(定位，也是一种数据，音乐，热榜！)mysql等关系型数据库就不够用了！数据量很多，变化很快~！

• MySQL有的使用它来村粗一些比较大的文件，博客，图片!数据库表很大，效率就低了!如果有一种数据库来专门处理这种数据,MySQL压力就变得十分小（研究如何处理这些问题！)大数据的IO压力下，表几乎没法更大!

5、目前一个基本的互联网项目架构图

6、为什么要使用NoSQL

用户的个人信息，社交网络，地理位置。用户自己产生的数据，用户日志等等爆发式增长！这时候我们就需要使用NoSQL数据库的，Nosql可以很好的处理以上的情况！

1.2、什么是NoSQL

1、NoSQL

关系型数据库：表格、行、列

NoSQL= Not Only SQL (不仅仅是SQL)。泛指非关系型数据库，随着web2.0互联网的诞生，传统的关系型数据库很难对付web2.0时代的产物，尤其是大规模、高并发的数据社区。暴露出来很多难以客服的问题，NoSQL在当今大数据环境卞发展的十分迅速，Redis是发展最快的，而且是我们当下必须要掌握的一个技术。

很多的数据类型用户的个人信息，社交网络，地理位置。这些数据类型的存储不需要一个固定的格式！不需要过多的操作就可以横向扩展的 ! 类似 Java 里的 Map<String,Object>。使用键值对控制。

2、NoSQL的特点

1、方便扩展（数据之间没有关系，很好扩展! )

2、大数据量高性能（Redis一秒写8万次，读取11万，NoSQL的缓存记录级，是一种细粒度的缓存，性能会比较高!

3、数据类型是多样型的!（不需要事先设计数据库!随取随用!如果是数据量十分大的表，很多人就无法设计了! )

4、传统RDBMS和NoSQL

/*
传统的关系型数据库：RDBMS
- 结构化组织
- sQL
- 数据和关系都存在单独的表中-操作操作，数据定义语言-严格的一致性
- 基础的事务等等

非关系型数据库：NoSQL
- 不仅仅是数据
- 没有固定的查询语言
- 键值对存储，列存储，文档存储，图形数据库（社交关系)-最终一致性，
- CAP定理和BASE(异地多活)初级架构师!(狂神理念:只要学不死，就往死里学!)
- 高性能，高可用，高可扩
*/

5、3V和3高（了解）：

大数据时代的3V︰主要是描述问题的

1. 海量 Volume
2. 多样 Variety
3. 实时 Velocity

大数据时代的3高:主要是对程序的要求

1. 高并发
2. 高可拓
3. 高性能

真正在公司中的实践:NoSQL+RDBMS(关系型数据库) 一起使用才是最强的。

1.3、阿里巴巴演进分析

思考：以淘宝为例，里面的视频、图片、评论等庞大复杂的数据真的是一个关系型数据库就能搞定的吗？

# 1、商品的基本信息
	名称、价格、商家信息;
	关系型数据库就可以解决了! MysqL / oracle（淘宝早年就去ToE了!-王坚:推荐文章:阿里云的这群疯子:40分钟重要!)淘宝内部的MysQL不是大家用的MysQL
                
# 2、商品的描述、评论（文字比较多)
	文档型数据库中，MongoDB
    
# 3、图片
	分布式文件系统FastDFS
    -淘宝自己的 TFS
	- Gooale的 GFS
    - Hadoop HDFS
	-阿里云的 oss
    
# 4、商品的关键字(搜索) 
	- 搜索引擎 solr elasticsearch
    - Isearce （多隆一个人开发出来）

# 5、商品的波段信息
	- 内存数据库
    - Redis Tair Memcached
    
# 6、商品的交易，外部的支付接口
	- 第三方应用

要知道，一个简单的网页背地里的技术一定不是大家所想的那么简单！

大型互联网应用问题：

• 数据类型太多了
• 数据源繁多，经常重构
• 数据要改造，大面积改造，关系型数据非常麻烦

解决问题：

1.4、NoSQL的四大分类

1、kv 键值对

• 新浪: Redis
• 美团: Redis + Tair
• 阿里、百度: Redis + memecache

2、文档型数据库( bson 格式和 json 一样)

• MongoDB(一般必须要掌握)
  MongoDB是一个基于分布式文件存储的数据库，C++编写，主要用来处理大量的文档!oMongoDB是一个介于关系型数据库和非关系型数据中中间的产品！MongoDB是非关系型数据库中功能最丰富，最像关系型数据库。
• CouchDB

3、列存储数据库

• HBase
• 分布式文件系统

4、图关系数据库

• 他不是存图形，放的是关系，比如∶朋友圈社交网络，广告推荐！
• Neo4j ,InfoGrid

5、4种类型对比

2、Redis入门

2.1、Redis概述

1、Redis是什么？

Redis = Remote Dictionary Server(Redis) 即远程字典服务。是一个由Salvatore Sanfilippo写的key-value存储系统。是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库。

免费和开源，是当下最热门NoSQL技术之一，也被人们称为结构化数据库。

2、Redis能做什么？

1. 内存存储、持久化、内存中是断电即失、所以说持久化很重要( rdb、aof )

2. 效率高、可以用于高速缓存

3. 发布订阅系统

4. 地图信息分析

5. 计时器，计数器(浏览量)等

3、Redis的特性

1. 多样的数据类型
2. 持久化
3. 集群
4. 事务等

4、Redis学习工具分享

Redis中文网：http://www.redis.cn/

Redis推荐都是在Linux服务器上搭建的，我们是基于Linux学习!

2.2、Windows安装Redis

1、下载安装包

下载地址：https://github.com/microsoftarchive/redis/releases/tag/win-3.2.100

1、下载完毕得到压缩包 -> 解压到自己电脑上的环境目录下就可以了(Redis十分的小)

2、开启服务，双击运行服务(redis-server.exe)即可。

3、使用Redis客户端(redis-cli.exe)连接Redis

在Windows系统下使用Redis确实很简单，但是Redis推荐我们使用Linux系统去开发使用！
因为官方不支持Windows版本的Redis！

2.3、Linux安装Redis

1、下载安装包：https://redis.io/

2、解压Redis安装包！执行程序一般放在 /opt 目录下

# 解压命令
tar -zxvf redis-6.0.9.tar.gz

3、进入解压后的目录，可以看到Redis的配置文件

4、基本的环境安装(gcc)

安装Redis 6.0以上版本：

# 依次执行以下命令
# 1.安装gcc
yum -y install centos-release-scl
yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils
source /opt/rh/devtoolset-9/enable
echo “source /opt/rh/devtoolset-9/enable” >>/etc/profile

# 2.编译
make
# 3.安装
make install # 安装，将redis的命令安装到/usr/local/bin/

我们来查看以下Redis是否存在

5、将Redis配置文件 (redis.conf) 复制到当前目录下

cp /opt/redis-6.0.9/redis.conf my_redis_config # my_redis_config 是自己创建的文件夹

6、Redis默认不是后台启动，需要修改配置文件

vim redis.conf

7、启动Redis，redis-server 通过制定的配置文件启动

redis-server my_redis_config/redis.conf

8、使用 redis-cli 进行测试连接

9、查看Redis进程是否开启

10、如何关闭Redis服务

11、再次查看进程是否存在

12、后面我们会使用单机多Redis启动集群测试！

2.4、测试性能

redis-benchmark 是一个压力测试工具，官方自带的性能测试工具。

redis 性能测试的基本命令如下：

redis-benchmark [option] [option value]

redis 性能测试工具可选参数如下所示(来自菜鸟教程)

我们来简单的测试一下

# 测试100个并发连接，100000请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000

如何查看这些分析？

2.5、Redis基础知识

Redis默认有16个数据库(可查看看配置文件)

默认使用的是第0个数据库

可以使用 select 进行切换数据库(例如切换为3号数据库)

127.0.0.1:6379> select 3 # 切换数据库
OK 
127.0.0.1:6379[3]> dbsize # 查看db大小
(integer) 0
127.0.0.1:6379[3]> 

查看当前数据库所有key

127.0.0.1:6379[3]> keys * # 查看当前数据库所有key
1) "name"
127.0.0.1:6379[3]>

清除当前数据库与清除全部数据库内容

127.0.0.1:6379[3]> flushdb # 清空数据库
OK
127.0.0.1:6379[3]> keys *
(empty array)

# flushall 清空全部数据库内容

思考：redis的端口号为什么是6379？(可网上查询，了解即可)

Redis是单线程的！(6.0版本以上，Redis网络处理是多线程)

官方表示Redis是很快的，Redis是给予内存操作的，CPU不是Redis的性能瓶颈，Redis的瓶颈是根据机器的内存和网络宽带，既然可以使用单线程来实现，就使用单线程了！

Redis是C 语言写的，官方提供的数据为100000+的QPS，完全不比同样是使用key-vale的Memecache差!

Redis为什么使用单线程还这么快？

误区1∶高性能的服务器一定是多线程的?
误区2∶多线程(CPU上下文会切换!)一定比单线程效率高!

速度快的原因：

核心：redis是将所有的数据全部放在内存中的，所以说使用单线程去操作效率就是最高的，多线程(CPU上下文会切换︰耗时的操作! ! ! )，对于内存系统来说，如果没有上下文切换效率就是最高的！多次读写都是在一个CPU上，在内存情况下，这种方案才是最佳的。

3、Redis五大数据类型

官方文档 Redis可以作为数据库、缓存、消息中间件

/* Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作 数据库、缓存和消息中间件
(MQ)。 它支持多种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合
（sets）， 有序集合（sorted sets） 与范围查询， bitmaps， hyperloglogs 和 地理空间（geospatial） 
索引半径查询。 Redis 内置了 复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），
事务（transactions） 和不同级别的 磁盘持久化（persistence）， 并通过 Redis哨兵（Sentinel）和自动 分区（Cluster）
提供高可用性（high availability */

3.1、Redis-key 学习

127.0.0.1:6379> keys * # 查看所有key
(empty array)
127.0.0.1:6379> set name howie
OK
127.0.0.1:6379> exists name # 判断key是否存在
(integer) 1
127.0.0.1:6379> move name 3 # 移动当前key到制定的数据库
(integer) 1
127.0.0.1:6379> set age 21
OK
127.0.0.1:6379> expire age 10 # 设置key的过期时间，单位是秒
(integer) 1
127.0.0.1:6379> ttl name # 查看当前key的剩余时间，单位是秒，负数代表当前key以到期
(integer) -2
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

Redis的命令远不止这些，全部拿来学习也不现实，所以遇到不会的命令，我们要学会在官网上查询

官网命令查询地址：http://www.redis.cn/commands.html

3.2、String(字符串)

1、追加与获取长度

127.0.0.1:6379> set str "hello" # 设置值
OK
127.0.0.1:6379> get str # 获取值
"hello"
127.0.0.1:6379> append str " world" # 追加字符串，如果当前字符串不存在，就相当于set key
(integer) 11
127.0.0.1:6379> get str
"hello world"
127.0.0.1:6379> strlen str # 获取字符串长度
(integer) 11

2、自增/减，指定步长自增/减

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> get views
"1"
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> decr views # 自减1
(integer) 1
127.0.0.1:6379> incrby views 9 # 指定步长，自增
(integer) 10
127.0.0.1:6379> get views
"10"
127.0.0.1:6379> decrby views 9 # 指定步长，自减
(integer) 1
127.0.0.1:6379> get views
"1"

3、字符串范围 getrange

127.0.0.1:6379> set str "hello world"
OK
127.0.0.1:6379> getrange str 0 1 # 截取闭区间的子字符串，索引从0开始[0,1]
"he"
127.0.0.1:6379> getrange str 0 -1 # 获取全部字符串，这里和get key 是一样的
"hello world"

4、替换 setrange

127.0.0.1:6379> get str
"hello world"
127.0.0.1:6379> setrange str 6 "Java" # 替换指定位置开始的字符串
(integer) 11
127.0.0.1:6379> getrange str 0 -1
"hello Javad"

setex # set with expire 设置过期时间
setnx # set if not exist 不存在再设置(在分布式锁中经常使用)

127.0.0.1:6379> setex age 30 "21" # 设置过期时间
OK
127.0.0.1:6379> ttl age
(integer) 25
127.0.0.1:6379> get ge
(nil)

127.0.0.1:6379> set name "alex"
OK
127.0.0.1:6379> get name
"alex"
127.0.0.1:6379> setnx name "Java" # 设置key-value，如果key存在，不会覆盖，并且返回0，表示设置失败
(integer) 0
127.0.0.1:6379> get name
"alex"

5、批量设置(mset)和获取(mget)

127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 # 批量设置
OK
127.0.0.1:6379> keys * # 查看所有的key
1) "k2"
2) "k1"
3) "k3"
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)

6、对象

# 对象
set user:1 {
    
    name:alex,age:21} # 设置一个 user:1 对象，值为json字符来保存一个对象！

# 这里的 key 是一个巧妙的设计：user:{id}:{fild}，如此设计在Redis中是完全ok的。
127.0.0.1:6379> mset user:1:name Java user:1:age 25
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "Java"
2) "25"

7、组合命令 getset

# 先get再set
127.0.0.1:6379> getset money "1w" # 如果不存在值，则返回nil,然后设置新值
(nil)
127.0.0.1:6379> get money
"1w"
127.0.0.1:6379> getset money "2w" # 如果存在值，则返回，并重新设置值
"1w"
127.0.0.1:6379> get money
"2w"

8、String类型的使用场景

String类似的使用场景: value除了是我们的字符串还可以是我们的数字！

• 计数器
• 统计多单位的数量 例如粉丝数量：uid:95256449:follow o
• 对象缓存

3.3、List(列表)

首先，list是一种基本的数据类型，在Redis中，我们可以把List完成，队列、栈、阻塞队列。

所有的list命令都是 l 开头的

1、添加 lpush 和 rpush

127.0.0.1:6379> lpush list Java # 将一个值或多个值插入到列表的头部(左 left)
(integer) 1
127.0.0.1:6379> lpush list Python
(integer) 2
127.0.0.1:6379> lpush list C/C++
(integer) 3
127.0.0.1:6379> lrange list 0 -1
1) "C/C++"
2) "Python"
3) "Java"
127.0.0.1:6379> lrange list 0 1 # 通过区间来获取具体的值
1) "C/C++"
2) "Python"

127.0.0.1:6379> rpush list JavaScript # 将一个值或多个值插入到列表的尾部(右 right)
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "C/C++"
2) "Python"
3) "Java"
4) "JavaScript"

2、移除 lpop 和rpop

127.0.0.1:6379> lrange list 0 -1 # 打印list元素
1) "C/C++"
2) "Python"
3) "Java"
4) "JavaScript"
127.0.0.1:6379> lpop list # 移除list的第一个元素
"C/C++"
127.0.0.1:6379> rpop list # 移除list的最后一个元素
"JavaScript"
127.0.0.1:6379> lrange list 0 -1 # 再次打印list元素
1) "Python"
2) "Java"

3、取值 lindex 和 列表长度

127.0.0.1:6379> lrange list 0 -1
1) "JavaScript"
2) "C/C++"
3) "Python"
4) "Java"
127.0.0.1:6379> lindex list 0 # 通过下表获取list的对应的值
"JavaScript" 
127.0.0.1:6379> llen list # 获取list的元素个数
(integer) 4

4、移除指定的值，lrem

127.0.0.1:6379> lpush list JavaScript # 在向list添加一个相同的元素，注意可重复添加元素
(integer) 5
127.0.0.1:6379> lrange list 0 -1 # 查看所有list元素
1) "JavaScript"
2) "JavaScript"
3) "C/C++"
4) "Python"
5) "Java"
127.0.0.1:6379> lrem list 1 JavaScript # 移除list集合中指定个数的value，精确匹配
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "JavaScript"
2) "C/C++"
3) "Python"
4) "Java"

5、ltrim 修剪，list 截断

127.0.0.1:6379> lpush list Java
(integer) 1
127.0.0.1:6379> lpush list Python
(integer) 2
127.0.0.1:6379> lpush list C/C++
(integer) 3
127.0.0.1:6379> lpush list JavaScript
(integer) 4
127.0.0.1:6379> ltrim list 0 1 # 通过区间截取指定的元素，这个list已经被改变了。只剩下截取的元素
OK
127.0.0.1:6379> lrange list 0 -1
1) "JavaScript"
2) "C/C++"

6、组合命令，rpoplpush

移除list列表最后一个元素，并将他移动到新的列表中。

127.0.0.1:6379> lrange list 0 -1 # list列表中有两个元素
1) "JavaScript"
2) "C/C++"
127.0.0.1:6379> rpoplpush list Java # 删除list列表中的最后一个元素，并将此元素移动到新的Java列表
"C/C++"
127.0.0.1:6379> lrange list 0 -1 # 查看list列表元素
1) "JavaScript"
127.0.0.1:6379> keys *
1) "list"
2) "Java"
127.0.0.1:6379> lrange Java 0 -1 # 查看新列表元素
1) "C/C++"

7、lset

lset：将列表中指定下标的值，替换为另外一个值

127.0.0.1:6379> exists list # 判断这个列表是否存在
(integer) 1
127.0.0.1:6379> lset item 0 go # 不存在列表，我们去更新就会报错
(error) ERR no such key
127.0.0.1:6379> lpush list Java
(integer) 2
127.0.0.1:6379> lrange list 0 0
1) "Java"
127.0.0.1:6379> lset list 0 Linux # 如果当前下标的值存在，就更新当前下标的值
OK
127.0.0.1:6379> lrange list 0 0
1) "Linux"
127.0.0.1:6379> lset list 2 golang # 如果当前下标不存在，也会报错
(error) ERR index out of range

8、linsert

linsert：将某个具体的value插入到列表中，某个元素的前面或者后面

127.0.0.1:6379> rpush list hello
(integer) 1
127.0.0.1:6379> rpush list world
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "world"
127.0.0.1:6379> linsert list before "world" "Java" # 将java元素插入到world元素的前面
(integer) 3
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "Java"
3) "world"
127.0.0.1:6379> linsert list after "world" "welcome" # 将welcome元素插入到world元素后面
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "Java"
3) "world"
4) "welcome"

9、小结

• 他实际上是一个链表，before Node after , left , right都可以插入值
• 如果key不存在，创建新的链表
• 如果key存在，新增内容
• 如果移除了所有值，空链表，也代表不存在!
• 在两边插入或者改动值，效率最高!中间元素，相对来说效率会低一点~

消息排队!消息队列( Lpush Rpop ) ，栈( Lpush Lpop )

3.4、Set(集合)

set中的元素是无序不可以重复的！与Java中的set集合类型一样

1、基本的存值

127.0.0.1:6379> sadd myset "Java" # set集合里添加元素
(integer) 1
127.0.0.1:6379> sadd myset "hello"
(integer) 1
127.0.0.1:6379> sadd myset "Python"
(integer) 1
127.0.0.1:6379> smembers myset # 查看指定set的所有值
1) "hello"
2) "Python"
3) "Java"
127.0.0.1:6379> sismember myset "hello" # 判断某个元素是否存在set集合中
(integer) 1
127.0.0.1:6379> sismember myset "world"
(integer) 0

2、获取set集合元素个数

127.0.0.1:6379> scard myset # 获取set集合中元素内容个数
(integer) 3

3、移除 rem

127.0.0.1:6379> smembers myset
1) "hello"
2) "Python"
3) "Java"
127.0.0.1:6379> srem myset "hello" # 移除set集合中指定元素
(integer) 1
127.0.0.1:6379> smembers myset
1) "Python"
2) "Java"

4、随机获取一个set集合元素

127.0.0.1:6379> smembers myset # 查看set所有元素
1) "JavaScript"
2) "Python"
3) "Java"
127.0.0.1:6379> srandmember myset # 随机获取一个set集合元素
"JavaScript"
127.0.0.1:6379> srandmember myset
"Java"
127.0.0.1:6379> srandmember myset 2 # 随机获取指定个数的set集合元素
1) "JavaScript"
2) "Python"

5、随机删除set集合的元素

127.0.0.1:6379> smembers myset
1) "JavaScript"
2) "Python"
3) "Java"
127.0.0.1:6379> spop myset # 随机删除set集合里的元素
"Java"
127.0.0.1:6379> smembers myset
1) "JavaScript"
2) "Python"

6、将一个指定的值，移动到另外一个set集合中

127.0.0.1:6379> smembers myset
1) "JavaScript"
2) "Linux"
3) "Java"
4) "Python"
127.0.0.1:6379> smove myset myset2 "Linux" # 将myset 里的元素Linux，移动到myset2集合
(integer) 1
127.0.0.1:6379> smembers myset2
1) "Linux"

7、集合间的交集、差集、并集

# 数字集合
 - sdiff 差集
 - sinter 交集
 - sunion 并集
127.0.0.1:6379> sadd myset1 Java
(integer) 1
127.0.0.1:6379> sadd myset2 Python
(integer) 1
127.0.0.1:6379> sadd myset1 Python
(integer) 1
127.0.0.1:6379> sadd myset2 Linux # 添加元素
(integer) 1
127.0.0.1:6379> sdiff myset1 myset2 # myset1对myset2的差集
1) "Java"
127.0.0.1:6379> sdiff myset2 myset1 # myset2对myset1的差集
1) "Linux"
127.0.0.1:6379> sinter myset1 myset2 # 交集 (共同好友)
1) "Python"
127.0.0.1:6379> sunion myset1 myset2 # 并集
1) "Linux"
2) "Java"
3) "Python"

应用场景：

微博，A用户将所有关注的人放在一个set集合中！将它的粉丝也放在一个集合中！
共同关注，共同爱好，二度好友，推荐好友!(六度分割理论)

3.5、Hash(散列)

Map集合，key-map!时候这个值是一个map集合!本质和String类型没有太大区别，还是一个简单的key-vlaue !set myhash field kuangshen

1、存值与取值

127.0.0.1:6379> hset myhash filed1 alex # set 一个具体的key-value
(integer) 1
127.0.0.1:6379> hget myhash filed1 # 获取一个字段值
"alex"
127.0.0.1:6379> hset  myhash filed1 "hello" filed2 "world" # set多个key-value
(integer) 1
127.0.0.1:6379> hmget myhash filed1 filed2 # 获取多个字段值
1) "hello"
2) "world"
127.0.0.1:6379> hgetall myhash # 获取hash全部的数据
1) "filed1"
2) "hellot"
3) "filed2"
4) "world"
127.0.0.1:6379> hdel myhash filed2 # 删除hash指定的key字段
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "filed1"
2) "hellot"

2、获取hash长度

127.0.0.1:6379> hgetall myhash
1) "filed1"
2) "hellot"
3) "filed2"
4) "world"
127.0.0.1:6379> hlen myhash # 获取长度
(integer) 2

3、判断hash中指定字段是否存在

127.0.0.1:6379> hexists myhash filed1 # 判断hash中指定字段是否存在
(integer) 1
127.0.0.1:6379> hexists myhash filed3
(integer) 0

4、获取所有的filed与value

127.0.0.1:6379> hkeys myhash # 获取所有的filed
1) "filed1"
2) "filed2"
127.0.0.1:6379> hvals myhash # 获取所有的value
1) "hellot"
2) "world"

5、字段值自增与自减

- hincrby 自增
- hdecrby 自减
127.0.0.1:6379> hset myhash filed3 5 # filed3字段的值初始化为 5
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "filed1"
2) "hellot"
3) "filed2"
4) "world"
5) "filed3"
6) "5"
127.0.0.1:6379> hincrby myhash filed3 1 # 字段值自增 1
(integer) 6
127.0.0.1:6379> hget myhash filed3
"6"
127.0.0.1:6379> hincrby myhash filed3 -1 # 字段值自减1
(integer) 5

127.0.0.1:6379> hsetnx myhash filed2 Java # 如果不存在，就能设置
(integer) 1
127.0.0.1:6379> hsetnx myhash filed2 Python # 如果存在，就不能设置
(integer) 0

6、hash的应用

hash变更的数据user name age,尤其是是用户信息之类的，经常变动的信息! hash更适合于对象的存储，String更加适合字符串存储！

3.6、Zset(有序集合)

在set的基础上，增加了一个值。sadd k1 v1 zadd k1 score v1

127.0.0.1:6379> zadd myset 1 C/C++ # 添加一个值
(integer) 1
127.0.0.1:6379> zadd myset 2 Java 3 Python # 添加多个值
(integer) 2
127.0.0.1:6379> zrange myset 0 -1 # 遍历
1) "C/C++"
2) "Java"
3) "Python"

1、排序的实现

127.0.0.1:6379> zadd salary 100 "C/C++" 300 "Java" 50 "Python" # 添加3门语言
(integer) 3
127.0.0.1:6379> zrangebyscore salary -inf +inf # 从小到大排序，显示全部值value
1) "Python"
2) "C/C++"
3) "Java"
127.0.0.1:6379> zrangebyscore salary -inf 200
1) "Python"
2) "C/C++"
127.0.0.1:6379> zrangebyscore salary -inf +inf withscores # 从小到大排序，显示全部的数据
1) "Python"
2) "50"
3) "C/C++"
4) "100"
5) "Java"
6) "300"

127.0.0.1:6379> zrevrange salary 0 -1 # 从大到小排序，并显示value
1) "Java"
2) "C/C++"
3) "Python"

2、移除元素

127.0.0.1:6379> zrange salary 0 -1
1) "Python"
2) "C/C++"
3) "Java"
127.0.0.1:6379> zrem salary "Java" # 移除有序集合中的指定元素
(integer) 1
127.0.0.1:6379> zrange salary 0 -1
1) "Python"
2) "C/C++"

3、获取有序集合长度

127.0.0.1:6379> zcard salary
(integer) 2

4、获取区间的成员数量

127.0.0.1:6379> zrangebyscore myset -inf +inf withscores
1) "C/C++"
2) "1"
3) "Python"
4) "3"
5) "Java"
6) "5"
127.0.0.1:6379> zcount myset 1 4 # 获取指定区间的成员数量
(integer) 2

案例思路： set排序存储班级成绩表，工资表排序！普通消息。

1、重要消息

2、带权重进行判断!

排行榜应用实现，取Top N测试！

4、三种特殊的数据类型

4.1、geospatial 地理位置

朋友的定位、附近的人、打车的距离计算？

Redis 的 geo在 3.2版本就已经推出了，这个功能可以推算地理的位置信息！两地之间的距离，方圆几里的人等

在官网中只有6个命令：

• GEOADD / geoadd
• GEODIST / geodist
• GEOHASH / geohash
• GEOPOS / geopos
• GEORADIUS / georadius
• GEORADIUSBYMEMBER / georadiusbymember

城市经纬度查询网址：http://www.jsons.cn/lngcode/

1、geoadd 将指定的地理空间位置（经度、纬度度、名称）添加到指定的key

# geoadd 添加地理位置
# 规则：无法添加南北两极的地理位置，我们一般也会使用下载好的城市地理位置数据，使用Java程序导入
 - 有效的经度从-180度到180度。
 - 有效的纬度从-85.05112878度到85.05112878度。
# 当坐标位置超出上述指定范围时，该命令将会返回一个错误
127.0.0.1:6379> geoadd china:city 102.712251 25.040609 kunming # 添加单个城市地理位置
(integer) 1
127.0.0.1:6379> geoadd china:city 102.70786 25.03521 wuhua 102.71994 25.04053 panlong # 添加多个城市地理位置
(integer) 2

2、geopos 从key里返回所有给定位置元素的位置（经度和纬度）

127.0.0.1:6379> geopos china:city kunming # 昆明市经纬度(获得当前定位)
1) 1) "102.71225184202194214"
   2) "25.04060791987412671"
127.0.0.1:6379> geopos china:city wuhua # 五华区经纬度
1) 1) "102.7078583836555481"
   2) "25.0352089638047417"

3、geodist 返回两个给定位置之间的距离，如果两个位置之间的其中一个不存在， 那么命令返回空值。

# 单位
- m 表示单位为米。
- km 表示单位为千米。
- mi 表示单位为英里。
- ft 表示单位为英尺

127.0.0.1:6379> geodist china:city kunming wuhua # 返回昆明市到五华区的距离，默认单位是m
"746.0779"
127.0.0.1:6379> geodist china:city kunming panlong m
"774.7046"
127.0.0.1:6379> geodist china:city kunming wuhua km # 返回昆明市到五华区的距离，指定单位是km
"0.7461"

4、georadius 以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素

单位：

• m 表示单位为米。
• km 表示单位为千米。
• mi 表示单位为英里。
• ft 表示单位为英尺

127.0.0.1:6379> georadius china:city 100 25 1000 km
1) "wuhua"
2) "kunming"
3) "panlong"
127.0.0.1:6379> georadius china:city 100 25 1000 km withdist # 以此经纬度为中心，返回方圆1000km 以内的城市并显示距离(单位为m)
1) 1) "wuhua"
   2) "272.9508"
2) 1) "kunming"
   2) "273.3968"
3) 1) "panlong"
   2) "274.1714"

5、georadiusbymember 以指定位置元素为中心，返回与中心的距离不超过给定最大距离的所有位置元素

127.0.0.1:6379> georadiusbymember china:city kunming 10 km
1) "wuhua"
2) "kunming"
3) "panlong"
127.0.0.1:6379> georadiusbymember china:city kunming 100 m
1) "kunming"

6、geohash 返回一个或多个位置元素的 Geohash 表示

127.0.0.1:6379> geohash china:city "kunming" # 返回hash值(经纬度计算出来的11位字符串)
1) "wk3n3q8b0g0"

7、geo的底层实现原理其实就是Zset，我们可以使用Zset的命令来操作geo

127.0.0.1:6379> zrange china:city 0 -1
1) "wuhua"
2) "kunming"
3) "panlong"
127.0.0.1:6379> zrange china:city 0 -1 withscores # 遍历，显示所有数据
1) "wuhua"
2) "4021138656314992"
3) "kunming"
4) "4021138666681726"
5) "panlong"
6) "4021138669271381"
127.0.0.1:6379> zrem china:city wuhua # 删除元素
(integer) 1
127.0.0.1:6379> zrange china:city 0 -1
1) "kunming"
2) "panlong"

4.2、Hyperloglog

1、什么是基数？

A{1,3,5,7,8,7} B{1,3,5,7,8}

基数 (不重复的元素) = 5个 可以接受误差

2、Hyperloglog 简介

Redis 2.8.9版本就更新了Hyperloglog 数据结构！Redis Hyperloglog 基数统计的算法！

优点:占用的内存是固定，2^64不同的元素的技术，只需要废12KB内存!如果要从内存角度来比较的话Hyperloglog

首选 ！网页的UV (一个人访问一个网站多次，但是还是算作一个人! )

传统的方式，set保存用户的id，然后就可以统计set中的元素数量作为标准判断！

这个方式如果保存大量的用户id，就会比较麻烦!我们的目的是为了计数，而不是保存用户id

0.81%错误率！统计UV任务，可以忽略不计的!

127.0.0.1:6379> pfadd myset a b c d e f g i # 创建第一组元素 myset
(integer) 1
127.0.0.1:6379> pfcount myset # 统计myset中的基数数量
(integer) 8
127.0.0.1:6379> pfadd myset2 g i j k l m # 创建第二组元素  myset2
(integer) 1
127.0.0.1:6379> pfcount myset2 # 统计myset2中基数的数量
(integer) 6
127.0.0.1:6379> pfmerge myset3 myset myset2 # 合并 myset 和 myset2
OK
127.0.0.1:6379> pfcount myset3 # 我们可以看到两组元素中，g 和 i 是重复的，只能记一次，所以myset3的基数是12
(integer) 12

3、小结

如果允许容错，那么一定可以使用Hyperloglog !

如果不允许容错，就使用set或者自己的数据类型即可!

4.3、Bitmaps 位图

1、位存储

应用场景：统计用户信息，活跃，不活跃!登录、未登录!打卡，365打卡!两个状态的，都可以使用！

Bitmaps位图，数据结构!都是操作 二进制位 来进行记录，就只有0和1两个状态！

365天= 365 bit1字节=8bit 46个字节左右！

2、测试Bitmaps

假设周一到周天以 0 1 2 3 4 5 6来表示，使用Bitmaps记录周一到周天的打卡，0 代表未打卡，1代表打卡。

127.0.0.1:6379> setbit sign 0 1
(integer) 0
127.0.0.1:6379> setbit sign 1 1
(integer) 0
127.0.0.1:6379> setbit sign 2 1
(integer) 0
127.0.0.1:6379> setbit sign 3 1
(integer) 0
127.0.0.1:6379> setbit sign 4 1
(integer) 0
127.0.0.1:6379> setbit sign 5 1
(integer) 0
127.0.0.1:6379> setbit sign 6 0 # 表示周天未打卡
(integer) 0

127.0.0.1:6379> getbit sign 3 # 查看周3有没有打卡，返回1，表示已打卡
(integer) 1
127.0.0.1:6379> getbit sign 6 # 查看周6有没有打卡
(integer) 0

统计打卡天数

127.0.0.1:6379> bitcount sign # 查看打卡天数
(integer) 6

5、事务

5.1、Redis事务概述

Redis事务本质: 一组命令的集合!一个事务中的所有命令都会被序列化，在事务执行过程的中，会按照顺序执行!

一次性、顺序性、排他性！执行一些列的命令！

----- 队列 set set set 执行 -----

Redis事务没有没有隔离级别的概念！

所有的命令在事务中，并没有直接被执行!只有发起执行命令的时候才会执行 ! Exec

Redis单条命令式保存原子性的，但是事务不保证原子性!

Redis的事务：

• 开启事务（multi）
• 命令入队（书写命令）
• 执行事务（exec）

5.2、事务执行流程演示

127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379> set name "Java" # 命令入队
QUEUED
127.0.0.1:6379> set age "25" # 命令入队
QUEUED
127.0.0.1:6379> get name # 命令入队
QUEUED
127.0.0.1:6379> set gender 0 # 命令入队
QUEUED
127.0.0.1:6379> exec # 执行所写的命令
1) OK
2) OK
3) "Java"
4) OK

5.3、放弃事务

127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379> set k1 v1 # 命令入队
QUEUED
127.0.0.1:6379> get k1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> discard # 放弃事务
OK

5.4、事务编译时异常

事务编译异常：(代码有错，命令有错)，事务中所有的命令都不会被执行

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> getset 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> exec # 执行事务报错
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k1 # 事务中所有的命令都不会被执行
(nil)

5.5、事务运行时异常

事务运行时异常(i/o)：如果事务队列中存在语法性，那么执行命令的时候，其他命令是可以正常执行的，错误命令抛出异常

127.0.0.1:6379> set name howie # 事务外设置一个非数字字符
OK
127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379> incr name # 进行自增1操作，执行的时候回报错
QUEUED
127.0.0.1:6379> set age 21
QUEUED
127.0.0.1:6379> get age
QUEUED
127.0.0.1:6379> exec # 执行事务，虽然第一条命令报错了，但是并没有影响，后面命令执行
1) (error) ERR value is not an integer or out of range
2) OK
3) "21"
127.0.0.1:6379> get age
"21"

5.6、监控 Watch

1、乐观锁与悲观锁

悲观锁∶

• 很悲观，认为什么时候都会出问题，无论做什么都会加锁!

乐观锁：

• 很乐观，认为什么时候都不会出问题，所以不会上锁!更新数据的时候去判断一下，在此期间是否有人修改过这个数据
• 获取version
• 更新的时候比较version

2、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，可以当做Redis的乐观锁操作！

127.0.0.1:6379> watch money # 监视money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby money 50
QUEUED
127.0.0.1:6379> incrby out 50
QUEUED
127.0.0.1:6379> exec # 执行之前另外一个线程，修改了money的值，这个时候，就会导致事务执行失败！
(nil)

如果修改失败，获取最新值就好

127.0.0.1:6379> unwatch # 如果发现事务执行失败，就先解锁！
OK
127.0.0.1:6379> watch money # 获取最新值，重新监控money,更新数据时，比较money就相同了
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby money 50
QUEUED
127.0.0.1:6379> incrby out 50
QUEUED
127.0.0.1:6379> exec # 比对监视的值，事务执行成功
1) (integer) 150
2) (integer) 70

6、Jedis

我们要是Java来操作Redis！

6.1、什么是Jedis

是Redis官方推荐的Java连接开发工具，使用Java操作Redis的中间件，如果你要使用Java操作Redis，你要对Redis非常的熟悉！

6.2、测试

1、新建一个空项目，通过maven，新添一个module

2、导入相关依赖

<dependencies>
    <!--导入JRedis依赖-->
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.2.0</version>
    </dependency>
    <!--导入FastJson依赖-->
    <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.73</version>
    </dependency>
</dependencies>

3、编写代码进行测试

• 连接数据库
• 操作命令
• 断开连接

package com.howie.jedis;

import redis.clients.jedis.Jedis;

public class JedisTest {
    
    
    public static void main(String[] args) {
    
    
        // 主机号 + 端口号
        Jedis jedis = new Jedis("127.0.0.1",6379); // 这里要确保windows系统里的Redis服务打开
        // jedis所有命令就是我们所学习的那些指令
        System.out.println(jedis.ping("hello world"));
    }
}
/*
用Jedis连接阿里云等服务器上的redis
1、配置redis.conf
    1.设置访问redis的密码：requirepass 要设置密码
    2.注释bind 127.0.0.1
    (重启redis-server服务,进入redis后要先验证密码,用这个命令：auth 密码 ,然后ping一下看有没有配置成功)
2、idea访问时添加auth密码
  Jedis jedis = new Jedis("服务器的外网ip",6379);
  jedis.auth("redis的密码");
  System.out.println(jedis.ping());
（输出PONG的话就成功了）
3、有可能连接失败，可能原因：
	①未开启安全组策略6379端口号
	②redis.conf配置文件里受到保护选项设置了yes
	③防护墙未关闭
	④需要重启才能生效
*/

输出：

6.3、常用的API

Redis-key

public class JedisTest {
    
    
    public static void main(String[] args) {
    
    
        // 主机号 + 端口号
        Jedis jedis = new Jedis("127.0.0.1",6379);
        // jedis所有命令就是我们所学习的那些指令
        System.out.println(jedis.ping("hello world"));

        System.out.println("清空数据:"+jedis.flushDB());
        System.out.println("判断某个键是否存在: "+jedis.exists("username"));
        System.out.println("新增< 'username ', 'howie'>的键值对:"+jedis.set("username", "howie"));
        System.out.println("新增< 'password' , ' password'>的键值对:"+jedis.set("password","password"));
        System.out.print("系统中所有的键如下:");
        Set<String> keys = jedis.keys("*");

        System.out.println(keys) ;
        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空间的一个: "+jedis.randomKey());
        System.out.println("重命名key: "+jedis.rename("username", "name"));
        System.out.println("取出改后的name: "+jedis.get( "name" ) );
        System.out.println("修改数据库: "+jedis.select(0));
        System.out.println("删除当前选择数据库中的所有key: "+jedis.flushDB());
        System.out.println("返回当前数据库中key的数目: "+jedis.dbSize());
        System.out.println("删除所有数据库中的所有key: "+jedis.flushAll());
    }
}

1、String
2、List
3、Set
4、Hash
5、Zset

所有的API命令，就是我们对应的上面学习的指令，一个都没有变化。

6.4、通过jedis再次理解事务

package com.howie.jedis;

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class JedisTest {
    
    
    public static void main(String[] args) {
    
    
        // 主机号 + 端口号
        Jedis jedis = new Jedis("127.0.0.1",6379); // 连接远程Redis服务
        JSONObject data = new JSONObject();
        data.put("hello","world");
        data.put("name","howie");
        // 1、开启事务
        Transaction multi = jedis.multi();
        try {
    
    
            multi.set("k1","v1"); // 2、命令入队
            multi.set("json_data",data.toString()); // 2、命令入队

            // 模拟异常
            int sum = 1/0;

            // 3、执行事务
            multi.exec();
            System.out.println(jedis.get("k1"));
            System.out.println(jedis.get("json_data"));
        } catch (Exception e) {
    
    
            multi.discard(); // 放弃事务
            e.printStackTrace();
        } finally {
    
    
            // 关闭连接
            jedis.close();
        }
    }
}

7、SpringBoot整合Redis

SpringBoot操作数据: spring-data jpa jdbc mongodb redis !

SpringData也是和SpringBoot齐名的项目！

7.1、Redis整合SpringBoot

说明：在SpringBoot 2.x 之后，原来使用的jedis被替换成了lettuce。

jedis：采用的直连，多个线程操作的话，是不安全的。如果想要避免不安全因素，就要使用jedis pool连接池。更像 BIO 模式

lettuce：采用netty，实例可以在多个线程中进行共享，不存在线程不安全的情况！可以减少线程数据了。更像NIO模式

1、新建SpringBoot项目

源码分析(RedisAutoConfiguration.java)：

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate") // 此注解功能，如果没有名为 "redisTemplate" 的类注入Bean容器，就使用以下的默认的，言外之意，我们要自定义一个 "redisTemplate"
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
    
    
        // 默认的 RedisTemplate 是没有过多的配置，Redis对象都需要序列化！
        // 两个泛型都是 Object 类型，我们后面使用需要强制转换 <String,Object>
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean // 由于String类型是我们Redis中最常用的类型，所以单独提出来了一个Bean
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
    
    
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

2、导入依赖(创建SpringBoot时，勾选对应内容即可)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

3、修改配置文件，配置Redis连接

# 配置Redis连接，这只是基本配置，当然在实际开发中，可根据需要配置更多的redis服务
spring:
  redis:
    host: 127.0.0.1
    port: 6379

4、测试！注意本地Redis服务要打开才能测试成功！

class Day10ApplicationTests {
    
    
	@Autowired
	private RedisTemplate<String,String> template;
	@Test
	void contextLoads() {
    
    
		/*
		RedisTemplate的常用操作：
		template.opsForValue() 操作字符串String
		template.opsForList() 操作列表List
		template.opsForSet() 操作集合Set
		template.opsForHash() 操作散列Hash
		template.opsForZset() 操作有序集合Zset
		template.opsForGeo() 操作地理位置geo
		template.opsForHyperLogLog() 操作HyperLogLog数据类型

		除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务，基本的curd等
		*/
		// 获取Redis连接对象
		/*RedisConnection redisConnection = template.getConnectionFactory().getConnection();
		redisConnection.flushDb(); // 清空当前数据内容
		redisConnection.flushAll(); // 清空所有数据库内容*/

		template.opsForValue().set("message","Hello World !");
		String message = template.opsForValue().get("message");
		System.out.println(message);
	}
}

输出：

5、序列化问题

以上代码，如果我们对应的值存的是中文，在远程服务里会进行转义。这不是我们希望看到的。为什么会转义呢？

源码分析(RedisTemplate)：

// 序列化的相关配置，可自己查看源码
@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;

// 默认的序列化配置，这里我们可以看到，当默认序列化(defaultSerializer)等于null的时候
// RedisTemplate默认使用的是jdk的序列化机制(JdkSerializationRedisSerializer)
if (defaultSerializer == null) {
    
    
	defaultSerializer = new JdkSerializationRedisSerializer(
        classLoader != null ? classLoader : this.getClass().getClassLoader());
}

如果set一个没有序列化的Java对象，会报错！

6、编写我们自己的 RedisTemplate 解决序列化出现的问题

@Configuration
public class RedisConfig {
    
    
    // 编写我们自己的 RedisTemplate
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
            throws UnknownHostException {
    
    
        // 我们为了开发方便，直接使用<String,Object>泛型
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        // 序列化配置
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String序列化的配置
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化
        template.setKeySerializer(stringRedisSerializer);
        // Hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value采用Jackson2JsonRedisSerializer的序列化方式
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // Hash的value也采用jackson2JsonRedisSerializer的序列化方式
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

7.2、Redis工具类的撰写

在实际开发过程中，我们操作Redis时，不可能每次都写opsForXXX，这是非常繁琐费时间的，我们要常用的操作封装到一个工具类里，方便我们调用Redis里的命令和在多个项目里实现代码的复用！

参考博客1：https://www.cnblogs.com/zeng1994/p/03303c805731afc9aa9c60dbbd32a323.html

参考博客2：https://www.cnblogs.com/zhzhlong/p/11434284.html

参考博客3：https://www.cnblogs.com/laizhenghua/articles/13922662.html

测试：

// 使用自己封装的Redis工具类
@Autowired
private RedisUtil redisUtil;

// 编写测试方法
@Test
public void redisUtilTest(){
    
    
    redisUtil.set("name","howie");
    System.out.println("debug ==> " + redisUtil.get("name"));
}

所有Redis操作，对于Java开发人员来说，是非常简单，重要的是去理解Redis的思想和每一种数据结构的用处和作用场景！

8、redis.conf配置文件详解

8.1、基本配置知识

1、单位

# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# units are case insensitive so 1GB 1Gb 1gB are all the same.

配置文件 unit 单位对大小写不敏感

2、包含，多个配置文件可组合在一起

################################## INCLUDES ###################################
# 包含
# Include one or more other config files here.  This is useful if you
# have a standard template that goes to all Redis servers but also need
# to customize a few per-server settings.  Include files can include
# other files, so use this wisely.
#
# Note that option "include" won't be rewritten by command "CONFIG REWRITE"
# from admin or Redis Sentinel. Since Redis always uses the last processed
# line as value of a configuration directive, you'd better put includes
# at the beginning of this file to avoid overwriting config change at runtime.
#
# If instead you are interested in using includes to override configuration
# options, it is better to use include as the last line.
# 修改配置如下
# include /path/to/local.conf 
# include /path/to/other.conf

就好比我们学习的Spring: import、include
3、网络

################################## NETWORK #####################################

# By default, if no "bind" configuration directive is specified, Redis listens
# for connections from all available network interfaces on the host machine.
# It is possible to listen to just one or multiple selected interfaces using
# the "bind" configuration directive, followed by one or more IP addresses.

bind 127.0.0.1 # 绑定IP
protected-mode yes # 是否受保护
port 6379 # 端口设置

4、通用设置

################################# GENERAL #####################################

# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.

daemonize yes # 是否以守护进程的方式运行，默认是no
pidfile /var/run/redis_6379.pid # 如果以后台的方式运行，我们需要制定一个 pid 文件！

# ===== 日志 =====
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably) 生产环境适用
# warning (only very important / critical messages are logged)
loglevel notice # 日志级别
logfile "" # 日志的文件位置名

databases 16 # 数据库的数量，默认是 16 个
always-show-logo yes # 是否总是显示logo

5、快照，持久化时使用

################################ SNAPSHOTTING  ################################
#
# Save the DB on disk:

在规定时间内，执行了多少次操作，则会持久化到文件 .rdb .aof

Redis是持久化数据库，如果没有持久化，那么数据就会断电即失！

# 如果900s内，如果至少有一个1 key 进行了修改，就会进行持久化操作
save 900 1
# 如果300s内，如果至少10 key 进行了修改，就会进行持久化操作
save 300 10
# 如果60s内，如果至少10000 key 进行了修改，就会进行持久化操作
save 60 10000
# 实际开发中，我们会自己设置持久化规则，后面会讲

stop-writes-on-bgsave-error yes # 持久化出错时，是否继续工作
rdbcompression yes # 是否压缩rdb文件，此时需要消耗CPU资源
rdbchecksum yes # 保存rdb文件时，进行错误的检查校验
dir ./ # rdb 文件保存的目录

6、主从复制

################################# REPLICATION #################################

# Master-Replica replication. Use replicaof to make a Redis instance a copy of
# another Redis server. A few things to understand ASAP about Redis replication.
#
#   +------------------+      +---------------+
#   |      Master      | ---> |    Replica    |
#   | (receive writes) |      |  (exact copy) |
#   +------------------+      +---------------+
# === 后面主从复制在介绍 ===

7、安全相关

################################## SECURITY ###################################

# Warning: since Redis is pretty fast, an outside user can try up to
# 1 million passwords per second against a modern box. This means that you
# should use very strong passwords, otherwise they will be very easy to break.
# Note that because the password is really a shared secret between the client
# and the server, and should not be memorized by any human, the password
# can be easily a long string from /dev/urandom or whatever, so by using a
# long and unguessable password no brute force attack will be possible.

可以在这里设置密码(一般不直接修改配置文件，使用命令行设置)，默认是没有密码！

# 设置密码，设置完后，记得重启Redis
127.0.0.1:6379> config set requirepass "123456"
OK
# 设置以后所有命令都需要登录才可以使用
127.0.0.1:6379> shutdown
(error) NOAUTH Authentication required.
# 登录
127.0.0.1:6379> auth 123456 # 验证服务器命令
OK
# 获取密码
127.0.0.1:6379> config get requirepass
1) "requirepass"
2) "123456"

8、aof配置

############################## APPEND ONLY MODE ###############################

# By default Redis asynchronously dumps the dataset on disk. This mode is
# good enough in many applications, but an issue with the Redis process or
# a power outage may result into a few minutes of writes lost (depending on
# the configured save points).

appendonly no # 默认是不开启 aof模式的，默认是rdb模式持久化数据，大多数情况 rdb已经够用了！
appendfilename "appendonly.aof" # 持久化文件的名字

# appendfsync always # 每次修改都会 sync，可能会导致速度慢(消耗性能)
appendfsync everysec # 每秒执行一次 sync，可能会丢失这一秒的数据
# appendfsync no # 不同步，这个时候操作系统自己同步数据，速度较快

8.2、配置文件命令

所有配置都可以通过 config 命令查看(get)和设置(set)！

# 查看配置信息语法
config get xxx
# 例子：查看数据库数量
127.0.0.1:6379> config get databases
1) "databases"
2) "16"

# 设置配置信息语法
config set xxx "xxx"
# 实例：设置访问密码
127.0.0.1:6379> config set requirepass "123456"
OK

9、Redis数据持久化

9.1、RDB(Redis Data Base)

Redis是内存数据库，如果不将内存中的数据库状态保存到磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失。所以Redis提供了持久化功能！

1、什么是RDB ?

在主从复制中，rdb是备用的，在从机里面！

在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里。Redis会单独创建( fork )一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。

默认的就是RDB模式，一般情况下一般不需要修改这个配置！

RDB保存的文件是 dump.rdb。在配置文件快照(sna)里进行配置！

# The filename where to dump the DB
dbfilename dump.rdb

2、修改持久化规则

#   It is also possible to remove all the previously configured save
#   points by adding a save directive with a single empty string argument
#   like in the following example:
#
#   save ""

#save 900 1
#save 300 10
#save 60 10000
save 60 5 # 60s内修改5个key，就会触发rdb操作

3、rdb操作触发机制

1、 save的规则满足的情况下，会自动触发rdb规则

2、执行flushall命令，也会触发我们的rdb规则!

3、退出redis，也会产生rdb文件!

备份就自动生成一个 dump.rdb 文件

4、如何恢复rdb文件

1、只需要将rdb文件放在我们redis启动目录就可以，redis启动的时候会自动检查dump.rdb恢复其中的数据!

2、查看需要存在的位置

127.0.0.1:6379> config get dir
1) "dir"
2) "/usr/local/bin" # 如果在这个目录下存在dump.rdb文件，启动就会自动恢复其中的数据

几乎Redis默认的配置，就够我们使用了，但是还是需要去学习！

5、RDB模式的优缺点

优点：

​ 1、适合大规模的数据恢复！

​ 2、对数据的完整性要求不高！

缺点：

​ 1、需要一定的时间间隔进行操作！如果Redis意外关机了，最后一次修改的数据就没有了！

​ 2、fork进程，会占用一定的内容空间

更多可查看官网：http://www.redis.cn/topics/persistence.html

9.2、AOF(Append Only File)

将我们所有命令都记录下来，history，恢复的时候就把这个文件全部执行一遍！

以日志的形式来记录每个写操作，将Redis执行过的所有指令记录下来（读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。

AOF保存的是 appendonly.aof 文件

2、append

AOF模式默认是不开启的，我们需要手动开启！

appendonly yes # 把no改为yes，就开启了AOF

重启Redis就生效了！

如果这个 appendonly.aof 文件有错误，此时Redis是启动不了的，我们需要修复这个 appendonly.aof文件。Redis就提供了这样一个修复工具叫 redis-check-aof

使用方式：

redis-check-aof --fix appendonly.aof

# 修复appendonly.aof文件，注意此文件已手动修改过
[root@laizhenghua bin]# redis-check-aof --fix appendonly.aof 
0x              59: Expected \r\n, got: 7365
AOF analyzed: size=171, ok_up_to=81, diff=90
This will shrink the AOF from 171 bytes, with 90 bytes, to 81 bytes
Continue? [y/N]: y
Successfully truncated AOF

如果 appendonly.aof 文件修复成功，Redis就可以正常使用了！

3、AOF的优点和缺点

优点：

​	1、每一次修改都同步，文件的完整会更加好!

​	2、每秒同步一次，可能会丢失一秒的数据

​	3、从不同步，效率最高的!

缺点：

​	1、相对于数据文件来说，aof远远大于rdb，修复的速度也比rdb慢!

​	2、Aof运行效率也要比rdb 慢，所以我们redis默认的配置就是rdb持久化!

9.3、RDB和AOF的对比

9.4、扩展

1、RDB持久化方式能够在指定的时间间隔内对你的数据进行快照存储

2、AOF持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据，AOF命令以Redis协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不至于过大。

3、只做缓存，如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何持久化

4、同时开启两种持久化方式

• 在这种情况下，当redis重启的时候会优先载入AOF文件来恢复原始的数据，因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整。
• RDB的数据不实时，同时使用两者时服务器重启也只会找AOF文件，那要不要只使用AOF呢?作者建议不要，因为RDB更适合用于备份数据库(AOF在不断变化不好备份），快速重启，而且不会有AOF可能潜在的Bug，留着作为一个万一的手段。

5、性能建议

• 因为RDB文件只用作后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟备份一次就够了，只保留save 900 1这条规则。

• 如果Enable AOF，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持续的IO，二是AOF rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值。

• 如果不Enable AOF，仅靠Master-Slave Repllcation实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果Master/Slave同时倒掉，会丢失十几分钟的数据，启动脚本也要比较两个MasterlSlave 中的RDB文件，载入较新的那个，微博就是这种架构。

10、Redis发布订阅

Redis 发布订阅(pub/sub)是一种消息通信模式︰发送者(pub)发送消息，订阅者(sub)接收消息。应用场景有微信、微博、关注系统等！Redis 客户端可以订阅任意数量的频道。

订阅/发布消息图︰

10.1、理解频道与客户端之间的关系

下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：

10.2、发布订阅的相关命令

这些命令被广泛用于构建及时通信应用，比如网络聊天室(chatroom)和实时广播，实时提醒等

1、测试

订阅端：

127.0.0.1:6379> subscribe howie # 订阅名为 howie 的频道信息
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "howie"
3) (integer) 1
# 监听等待推送的信息
1) "message" # 消息
2) "howie" # 来自于哪个频道
3) "hello world" # 从发布端接收到 message

发布端：

127.0.0.1:6379> publish howie "hello world" # 给 howie 频道发送 消息
(integer) 1

2、原理

Redis是使用C实现的，通过分析Redis源码里的pubsub.c文件，了解发布和订阅机制的底层实现，籍此加深对Redis的理解。Redis通过PUBLISH、SUBSCRIBE 和PSUBSCRIBE等命令实现发布和订阅功能。

通过SUBSCRIBE命令订阅某频道后，redis-server里维护了一个字典，字典的键就是一个个频道(channel)，而字典的值则是一个链表，链表中保存了所有订阅这个channel的客户端。SUBSCRIBE命令的关键，就是将客户端添加到给定 channel的订阅链表中。

通过PUBLISH命令向订阅者发送消息，redis-server会使用给定的频道作为键，在它所维护的channel字典中查找记录了订阅这个频道的所有客户端的链表，遍历这个链表，将消息发布给所有订阅者。

Pub/Sub从字面上理解就是发布( Publish )与订阅(Subscribe )，在Redis中，你可以设定对某一个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实时消息系统，比如普通的即时聊天，群聊等功能。

3、应用场景
1、实时消息系统!

2、事实聊天!（频道当做聊天室，将信息回显给所有人即可! )

3、订阅，关注系统都是可以的!|

稍微复杂的场景我们会使用消息中间件 MQ()

11、Redis主从复制

11.1、概念

主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master/leader)，后者称为从节点(slave/follower)、数据的复制是单向的，只能由主节点到从节点。Master以写为主，Slave以读为主。

默认情况下，每台Redis服务器都是主节点

且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。

主从复制的作用主要包括:

​ 1、数据冗余∶主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。

​ 2、故障恢复∶当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复;实际上是一种服务的冗余。

​ 3、负载均衡∶在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载;尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。

​ 4、高可用基石︰除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是Redis高可用的基础。

一般来说，要将Redis运用于工程项目中，只使用一台Redis是万万不能的（宕机），原因如下∶

​ 1、从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大;

​ 2、从容量上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有内存用作Redis存储内存，一般来说，单台Redis最大使用内存不应该超过20G。

电商网站上的商品，一般都是一次上传，无数次浏览的，说专业点也就是"多读少写"。对于这种场景，我们可以使如下这种架构︰

主从复制，读写分离! 80%的情况下都是在进行读操作!减缓服务器的压力!架构中经常使用!一主二从!

在实际开发中，主从复制必须要使用的，不可能单独使用单机使用Redis。

11.2、主从复制测试环境配置

只配置从库，不用配置主库！

127.0.0.1:6379> info replication # 查看当前库的信息
# Replication
role:master # 角色 master
connected_slaves:0 # 没有从机
master_replid:a07536544fe4b9f27c1129da005785750d729cf2
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

测试一主二从！复制3个配置文件，修改对应的信息：

# 我们在一台服务器测试即可，分别用不同的端口号开启3个redis服务，并以端口号命名加以区分
[root@laizhenghua my_redis_config]# cp redis.conf redis-6379.conf
[root@laizhenghua my_redis_config]# cp redis.conf redis-6380.conf
[root@laizhenghua my_redis_config]# cp redis.conf redis-6381.conf

下面修改配置文件，以6379默认的为例，其他两个修改方式一样！

1、端口号

port 6379 # 其他两个配置文件改为对应的端口即可

2、pid 名字

pidfile /var/run/redis_6379.pid # 修改对应端口号位置即可

3、log文件

logfile "6379.log" # 改为对应端口号即可

4、dump.rdb 文件名

dbfilename dump6379.rdb # 与拼接上端口号即可

修改完配置文件后，我开启这三个服务！可以通过进程查看！

[root@laizhenghua bin]# ps -ef|grep redis
root     31755     1  0 19:08 ?        00:00:00 redis-server 127.0.0.1:6379
root     32057     1  0 19:10 ?        00:00:00 redis-server 127.0.0.1:6380
root     32105     1  0 19:10 ?        00:00:00 redis-server 127.0.0.1:6381

以上！我们的测试环境已搭建完毕！

11.3、一主二从

1、设置主从关系

注意重点记住：默认情况下每台Redis服务都是主节点！

那如何配置才能让他们变成主从关系呢？

我们一般只配置从机就可以了，言外之意，就是选择一个作为主机，此主机不用修改任何配置！

一主(79)二从(80,81)

127.0.0.1:6380> slaveof 127.0.0.1 6379 # slaveof host 6379 把此主机当做老大(主机)
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:3
master_sync_in_progress:0
slave_repl_offset:14
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:b66aa0be8e83a83fe06e913a6a5e4cc6baf0302d
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:14
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:14

# 我们把6381端口的也配置了，就可以在主机中查看到从机的信息
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:2 # 多了从机的配置
slave0:ip=127.0.0.1,port=6380,state=online,offset=406,lag=1 # 从机信息1
slave1:ip=127.0.0.1,port=6381,state=online,offset=406,lag=0 # 从机信息2
master_replid:b66aa0be8e83a83fe06e913a6a5e4cc6baf0302d
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:406
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:406

小结：以上命令配置只是临时性的，只要所有服务重启，他们的主从关系就不复存在！所以实际开发过程中，主从配置应该在配置文件中配置，这样的话就是永久的！

# =======redis.conf=========
# replicaof <masterip> <masterport> 可在这里配置 主机ip和主机端口号
replicaof <127.0.0.1> <6379>
# If the master is password protected (using the "requirepass" configuration
# directive below) it is possible to tell the replica to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the replica request.
#
# masterauth <master-password> 如果主机设置了验证密码，填写即可
#
# However this is not enough if you are using Redis ACLs (for Redis version
# 6 or greater), and the default user is not capable of running the PSYNC
# command and/or other commands needed for replication. In this case it's
# better to configure a special user to use with replication, and specify the
# masteruser configuration as such:
#
# masteruser <username>

2、细节讲解
主机可以写，从机不可以写，只可以读。主机中的所有信息和数据，都会自动被从机保存！

127.0.0.1:6379> set name "Java" # 主机可以读和写
OK
# 从机只可以读
127.0.0.1:6380> get name
"Java"
127.0.0.1:6380> set k1 v1 
(error) READONLY You can't write against a read only replica.

测试发现︰

• 主机断开连接，从机依旧连接到主机的，但是没有写操作，这个时候，主机如果回来了，从机依旧可以直接获取到主机写的信息!
• 如果是使用命令行，来配置的主从，这个时候如果重启了，就会变回主机！只要变为从机，立马就会从主机中获取值。

复制或从机获取主机数据原理：

• Slave启动成功连接到master后会发送一个sync同步命令
• Master接到命令，启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到节点slave，并完成一次完全同步。
• 全量复制：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。
• 增量复制：Master继续将新的所有收集到的修改命令依次传给slave，完成同步但是只要是重新连接master，一次完全同步（全量复制)将被自动执行)，我们的数据一定可以在从机中看到！

3、另一种主从复制模式

上面的主从复制模式：

不过我们还有另一种主从复制模式：

这个时候也可以完成我么的主从复制！

如果6379这个主节点死机了，6380这个主节点又不能写，严格意义上又不算作为主节点，所以这个时候，6380节点和6381已经群龙无首了。这个时候能不能选一个作为主节点呢？答案能，我么可以手动配置！

我们可以使用slaveof no one 使自己变为主机！其他的节点就可以手动连接到这个新的主节点！(在哨兵没有出来前都是手动的)

如果老大恢复了，也只能重新连接！

11.4、哨兵模式(重点)

以上主从复制出现的问题和手动配置等都是为哨兵模式做铺垫。这时我们可以确定哨兵模式就是可以自动选取主节点的一种机制。

1、概述

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。Redis从2.8开始正式提供了Sentinel (哨兵）架构来解决这个问题。

谋朝篡位的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。
哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

这里的哨兵有两个作用

• 通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
• 当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。

然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。

假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象成为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover[故障转移]操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。

2、测试

1、配置哨兵配置文件sentinel.conf

[root@laizhenghua my_redis_config]# pwd
/usr/local/bin/my_redis_config

[root@laizhenghua my_redis_config]# vim sentinel.conf
# 书写如下配置，这里只是简单配置，更多配置可查看官网：http://www.redis.cn/topics/sentinel.html
sentinel monitor myredis 127.0.0.1 6379 1
# sentinel monitor 被监控的名称 host port 1

后面的这个数字1，代表主节点挂了，slave投票看让谁接替称为主机，票数最多的，就会称为主机！

2、启动哨兵

[root@laizhenghua bin]# redis-sentinel my_redis_config/sentinel.conf # 启动哨兵
19632:X 03 Nov 2020 12:20:44.002 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
19632:X 03 Nov 2020 12:20:44.002 # Redis version=6.0.9, bits=64, commit=00000000, modified=0, pid=19632, just started
19632:X 03 Nov 2020 12:20:44.002 # Configuration loaded
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 6.0.9 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in sentinel mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 26379
 |    `-._   `._    /     _.-'    |     PID: 19632
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

19632:X 03 Nov 2020 12:20:44.003 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
19632:X 03 Nov 2020 12:20:44.013 # Sentinel ID is 778ca949c71564b3c9dbe4b82ceee679722a65ff
19632:X 03 Nov 2020 12:20:44.013 # +monitor master myredis 127.0.0.1 6379 quorum 1
19632:X 03 Nov 2020 12:20:44.013 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
19632:X 03 Nov 2020 12:20:44.020 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379

如果master主节点断开了，这个时候就会在从机中投票选择一个服务器作为主节点！(这里面有一个投票算法)

# 哨兵模式输出的日志，我们可以清楚的看到6380端口已经被选为新的主节点！
19632:X 03 Nov 2020 12:25:41.327 # +switch-master myredis 127.0.0.1 6379 127.0.0.1 6380
19632:X 03 Nov 2020 12:25:41.327 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6380
19632:X 03 Nov 2020 12:25:41.327 * +slave slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6380
19632:X 03 Nov 2020 12:26:11.362 # +sdown slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6380

再来验证6380端口是否真的的主从复制的新节点info replication

127.0.0.1:6380> info replication
# Replication
role:master # 角色已变为master
connected_slaves:1
slave0:ip=127.0.0.1,port=6381,state=online,offset=23694,lag=1 # 从机的信息
master_replid:0cefbf7e3b80c4561542c3413d9ac47339b3c29e
master_replid2:da64bedc85891d862a729fe89be237760e1ee5bb
master_repl_offset:23694
second_repl_offset:20448
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:23694

哨兵模式的规则：

此时6379端口的服务重新连接回来，也不再是主节点了，只能手动配置作为新主机的从机！

3、哨兵模式的优缺点

优点：

1、哨兵集群，基于主从复制模式，所有的主从配置优点，它全有

2、主从可以切换，故障可以转移，系统的可用性就会更好

3、哨兵模式就是主从模式的升级，手动到自动，更加健壮!

缺点：

1、Redis不好在线扩容的，集群容量一旦到达上限，在线扩容就十分麻烦!

2、实现哨兵模式的配置其实是很麻烦的，里面有很多选择!

4、哨兵模式的全部配置

#Example sentinel.conf

#哨兵sentinel实例运行的端口 默认26379
port 26379

#哨兵sentinel的工作目录
dir /tmp

#哨兵sentinel监控的redis主节点的 ip port
#master-name可以自己命名的主节点名字，只能由字母A-z、数字0-9、这三个字符".-_"组成。
#quorum 配置多少个sentinel哨兵统一认为master主节点失联 那么这时客观上认为主节点失联了
#sentinel monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor mymaster 127.0.0.1 6379 2
 
#当在Redis实例中开启了requirepass foobared授权密码，这样所有连接Redis实例的客户端都要提供密码 
#设置哨兵sentinel连接主从的密码，注意必须为主从设置一样的验证密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster XXX
#指定多少毫秒之后主节点没有应答哨兵，此时哨兵主观上认为主节点下线，默认30秒
# sentinel down-after-milliseconds <master-name> <milliseconds>
sentinel down-after-milliseconds mymaster 30000

# 这个配置项指定了在发生failover主备切换（选举）时多可以有多少个slave同时对新的master进行同步，数字越小，完成failover所需的时间就越长，但是如果这个数字越大，就意味着越多的slave因为replication而不可用。可以通过将这个值设为1来保证每次只有一个slave处于不能处理命令请求的状态。
# sentinel parallel-syncs <master-name> <numslaves>
sentinel parallel-syncs mymaster 1

#故障转移的超时时间failover-timeout可以用在以下这些方面：
#1. 同一个sentinel对同一个master两次failover之间的间隔时间。
#2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的failover所需要的时间。
#4.当进行failover时，配置所有slaves指向新的master所需的大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了#默认三分钟
# sentinel failover-timeout <master-name> <milliseconds>
sentinel failover-timeout mymaster 180000

#SCRIPTS EXECUTION

#配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
#对于脚本的运行结果有以下规则：
#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
#若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。#一个脚本的大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。

#通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本，这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，一个是事件的类型，一个是事件的描述。如果sentinel.conf配 置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无 法正常启动成功。
#通知脚本
# sentinel notification-script <master-name> <script-path>
sentinel notification-script mymaster /var/redis/notify.sh

#客户端重新配置主节点参数脚本
# 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。
#以下参数将会在调用脚本时传给脚本:
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
# 目前<state>总是“failover”, # <role>是“leader”或者“observer”中的一个。
#参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
# 这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentinel client-reconfig-script <master-name> <script-path>
sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

12、Redis缓存穿透与雪崩

面试高频+工作常用

12.1、引子

Redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。但同时，它也带来了一些问题。其中，最要害的问题，就是数据的一致性问题，从严格意义上讲，这个问题无解。如果对数据的一致性要求很高，那么就不能使用缓存。

另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前，业界也都有比较流行的解决方案。

12.2、缓存穿透(查不到)

1、概念

缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。

2、解决方案

①布置过滤器：

布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力;

②缓存空对象：

当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源

但是这种方法会存在两个问题︰

1、如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键;

2、即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。

12.3、缓存击穿(量太大)

1、概述

这里需要注意和缓存击穿的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。

当某个key在过期的瞬间，有大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓存，会导使数据库瞬间压力过大。

2、解决方案

设置热点数据永不过期

从缓存层面来看，没有设置过期时间，所以不会出现热点key过期后产生的问题。

加互斥锁

分布式锁∶使用分布式锁，保证对于每个key同时只有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大。

12.4、缓存雪崩

1、概念

缓存雪崩，是指在某士个时间段，缓存集中过期失效。

产生雪崩的原因之一，比如在写本文的时候，马上就要到双十二零点，很快就会迎来一波抢购，这波商品时间比较集中的放入了缓存，假设缓存一个小时。那么到了凌晨一点钟的时候，这批商品的缓存就都过期了。而对这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压力波峰。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。

其实集中过期，倒不是非常致命，比较致命的缓存雪崩，是缓存服务器某个节点宕机或断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压垮。

双十一：停掉一些业务(保证主要的业务可用！)

2、解决方案

redis高可用

这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。(异地多活!)

限流降级（在SpringCloud讲解过!)

这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。

数据预热

数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

end

Thank you for watching!

end