学习视频地址：https://www.bilibili.com/video/BV1S54y1R7SB
完结撒花，感谢狂神
文章目录
- 1. NoSQL
- 2. Redis
- 2.1 Redis概述
- 2.2 安装Redis
- 2.3 redis-benchmark 性能测试
- 2.4 Redis 基本知识说明
- 2.5 关于RedisKey基本命令
- 2.6 五大基本数据类型
- 2.7 三种特殊数据类型
- 2.8 Redis基本的事务操作
- 2.9 Redis实现乐观锁
- 2.10 使用Jedis操作Redis
- 2.11 SpringBoot整合Redis
- 2.12 自定义的RestTemplate
- 2.13 Redis.conf 配置文件详解
- 2.14 Redis 持久化之RDB操作
- 2.16 Redis 持久化之AOF（Append Only File）操作
- 2.17 Redis 订阅发布
- 2.18 Redis 主从复制
- 2.19 哨兵模式
- 2.20 缓存穿透和雪崩
1. NoSQL
1.1 单机Mysql的演进
- 单机MySQL时代。
一个网站的访问量一般都不大，而且更多的是静态页面，动态交互类型的网站不多，用单个数据库完全可以轻松应对。
上述架构下，数据存储的瓶颈是什么？
（1）数据量的总大小一个机器放不下时
（2）数据的索引（B+ Tree）一个机器的内存放不下时
（3）访问量（读写混合）一个实例不能承受 - Memcached（缓存）+ MySQL + 垂直拆分
随着访问量的上升，几乎大部分使用MySQL架构的网站在数据库上都开始出现性能问题，web程序不再仅仅专注在功能上，同时也在追求性能。程序员们开始大量的使用缓存技术来缓解数据库的压力，优化数据库的结构和索引。开始比较流行的是通过文件缓存来缓解数据库压力，但是访问量继续增大的时候，多台web机器通过文件缓存不能共享，大量的小文件缓存也带来了比较高的IO压力。因此，Memcached就成为了一个非常时尚的技术产品。
由于数据库的写入压力增加，Memcached只能缓解数据库的读取压力。读写集中在一个数据库上让数据库不堪重负，大部分网站开始使用主从复制技术来达到读写分离，以提高读写性能和读库的可扩展性。Mysql的master-slave模式成为这个时候的网站标配。
1.2 当今企业架构分析
-
分表分库 + 水平拆分 + mysql集群
在Memcached的高速缓存，MySQL的主从复制，读写分离的基础之上，这是MySQL的主库的写压力开始出现瓶颈，而数据量的持续猛增，由于MyISAM使用表锁，在高并发下会出现严重的锁问题，大量的高并发MySQL应用开始使用InnoDB（使用行锁）引擎代替MyISAM。
同时开始流行使用分表分库来缓解写压力和数据增长的扩展问题。这个时候，分表分库成了一个热门技术，是面试的热门问题也是业界讨论的热门技术问题。也就是在这个时候，MySQL推出了还不太稳定的表分区，虽然MySQL推出了MySQL Cluster集群，但性能也不能很好满足互联网的要求，只能在高可靠性上提供了非常大的保证。
-
MySQL的扩展性瓶颈
MySQL数据库也经常存储一些大文本字段，导致数据库表非常的大，在做数据库恢复的时候就导致非常的慢，不容易快速恢复数据库。比如1000万4KB大小的文本就接近40GB的大小，如果能把这些数据从MySQL省去，MySQL将变得非常的小。关系数据库很强大，但是它并不能很好的应付所有的应用场景。MySQL的扩展性差（需要复杂的技术来实现），大数据下IO压力大，表结构更改困难，正式当前使用MySQL的开发人员面临的问题。 -
今天是什么样子
-
为什么用NoSQL？
今天我们可以通过第三方平台（如Google，Facebook等）可以很容易的访问和抓取数据。用户个人信息，社交网络，地理位置，用户产生的数据和用户操作日志已经成倍的增加。我们如果要对这些用户数据进行挖掘，那SQL数据库已经不适合这些应用了，NoSQL数据库的发展却能很好的处理这些大的数据。
1.3 什么是NoSQL
- NoSQL = Not Only SQL（不仅仅是SQL）
传统关系型数据库：表格、行、列。
NoSQL泛指非关系型数据库的，随着web2.0互联网的诞生，传统的关系型数据库很难适应web2.0时代。尤其超大规模高并发的社区！NoSQL在当今大数据环境下发展十分迅速，Redis发展最快，也是必须要掌握的一门技术。
很多数据类型：用户的个人信息、社交网络、地理位置，这些数据类型的存储不需要一个固定的格式！不需要过多的操作就可以横向扩展！Map<String , Object> 就是典型的非关系型数据结构。 - NoSQL特点
- 方便扩展（数据之间没有关系，很好扩展）
- 大数据量高性能（Redis 一秒写8万次，读取11万次。NoSQL的缓存记录级，是一种细粒度的缓存，性能比较高）。
- 数据类型是多样性的。（不需要事先设计数据库，随去随用。）
- 传统的RDBMS 和 NoSQL
传统的RDBMS - 结构化组织 - SQL - 数据和关系都存在单独的表中 - 操作语句，数据定义语句 - 严格的一致性 - 基础的事务 - ...NoSQL - 不仅仅是数据 - 没有固定的查询语言 - 键值对存储，列存储，文档存储，图形数据库（社交关系） - 最终一致性 - CAP定义和BASE （异地多活） - ...
- 3v + 3高
- 大数据时代的3v：主要是用来描述问题的
（1）海量Volume
（2）多样Variety
（3）实时Velocity - 大数据时代的三高：主要是用来解决问题的
（1）高并发
（2）高可拓
（3）高性能
- 大数据时代的3v：主要是用来描述问题的
- 真正公司的实践是RDBMS + NoSQL一起使用的。
1.4 NoSQL 四大分类
K-V键值对：
- 新浪：Redis
- 美团：Redis + Tair
- 阿里、百度：Redis + Memcache
文档型数据库：
- MongoDB：
- MongoDB 是一个基于分布式文件存储的数据库，c++编写，用来处理大量的文档。
- MongoDB 是一个介于关系型数据库和非关系型数据库之间的一个产品，MongoDB是非关系型数据库中最丰富，最像关系型数据库的。
- ConthDB：
列存储数据库：
- HBase
- 分布式文件系统
图关系数据库：
- 存储的不是同行，而是关系，比如社交网络，广告推荐。
- Neo4j，InfoGrid
| 分类 | Examples举例 | 典型应用场景 | 数据模型 | 优点 | 缺点 |
|---|---|---|---|---|---|
| 键值（key-value） | Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB | 内容缓存，主要用于处理大量数据的高访问负载，也用于一些日志系统等等。 | Key 指向 Value 的键值对，通常用hash table来实现 | 查找速度快 | 数据无结构化，通常只被当作字符串或者二进制数据 |
| 列存储数据库 | Cassandra, HBase, Riak | 分布式的文件系统 | 以列簇式存储，将同一列数据存在一起 | 查找速度快，可扩展性强，更容易进行分布式扩展 | 功能相对局限 |
| 文档型数据库 | CouchDB, MongoDb | Web应用（与Key-Value类似，Value是结构化的，不同的是数据库能够了解Value的内容） | Key-Value对应的键值对，Value为结构化数据 | 数据结构要求不严格，表结构可变，不需要像关系型数据库一样需要预先定义表结构 | 查询性能不高，而且缺乏统一的查询语法。 |
| 图形(Graph)数据库 | Neo4J, InfoGrid, Infinite Graph | 社交网络，推荐系统等。专注于构建关系图谱 | 图结构 | 利用图结构相关算法。比如最短路径寻址，N度关系查找等 | 很多时候需要对整个图做计算才能得出需要的信息，而且这种结构不太好做分布式的集群 |
2. Redis
2.1 Redis概述
英文官方网站：https://redis.io/
中文官方网站：http://www.redis.cn/
- redis是什么？
Redis（Remote Dictionary Server )，即远程字典服务。
是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。 - redis能干吗？
- 内存存储、持久化、内存中是断电即失，所以持久化很重要（rdb，aof）
- 效率高，可以用于高速缓存
- 发布订阅系统
- 地图信息分析
- 特性
- 多样性的数据类型
- 持久化
- 集群
- 事务 …
2.2 安装Redis
2.2.1 Windows下安装Redis
-
解压，进入解压目录
-
双击 redis-server.exe 启动redis服务，启动后不要关闭窗口，否则服务关闭。
-
双击 redis-cli.exe 启动客户端
-
测试连接：ping，设置基本值：set key value，获取基本值：get key
注：redis推荐使用Linux开发使用。
2.2.2 Linux下安装Redis
-
下载获得安装包上传至服务器解压
-
基本的环境安装
yum install gcc-cc # 进入解压目录 make && make install
-
redis的默认安装目录
/usr/local/bin
-
复制解压目录下的 redis.conf 到安装目录下
cp /opt/redis-5.0.7/redis.conf /usr/local/bin/myconfig/
-
redis默认不是后台启动，修改配置
daemonize的值no改为yes
-
启动redis服务，通过指定的配置文件启动服务
redis-server ./myconfig/redis.conf
-
启动redis客户端，连接测试
# 6379 redis服务默认端口号 redis-cli -p 6379
-
关闭redis
-
查看redis进程
-
关闭redis，
shutdown
-
再次查看进程，进程结束。
-
2.3 redis-benchmark 性能测试
Redis自带的压力测试工具。
使用方法：redis-benchmark 命令参数
测试：
# 测试：100个连接，100000请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000
2.4 Redis 基本知识说明
- redis 默认有16个数据库
查看配置文件/usr/local/bin/myconfig/redis.conf
默认使用第0个数据库。 - 常用命令（切换数据库、清空数据库）：
127.0.0.1:6379> select 3 # 切换数据库 OK 127.0.0.1:6379[3]> dbsize # 查看数据库大小 (integer) 0 127.0.0.1:6379[3]> set name kid # 写入数据 OK 127.0.0.1:6379[3]> dbsize # 查看数据库大小 (integer) 1 127.0.0.1:6379[3]> select 6 # 切换数据库 OK 127.0.0.1:6379[6]> dbsize # 查看数据库大小 (integer) 0 127.0.0.1:6379> select 3 # 切换数据库 OK 127.0.0.1:6379[3]> keys * # 查看所有的key 1) "name" 127.0.0.1:6379[3]> flushdb # 清空当前库，清空所有库：flushall OK 127.0.0.1:6379[3]> keys * # 查看所有的key (empty list or set) - Redis是单线程的：
Redis是非常快的，官方表示Redis是基于内存操作的，CPU不是Redis的瓶颈，内存和带宽才是Redis的瓶颈，能使用单线程实现，就是用单线程了。
Redis是C语言写的，官方提供的数据为100000+的QPS，不比同样使用key-value的Memcache差。 - Redis为什么快？
(1) 误区：高性能的服务器一定是多线程的。
(2) 误区：多线程（CPU上下文会切换）一定比单线程快。
就速度而言：CPU > 内存 > 硬盘（CPU的上下文切换比较耗时间）
核心：redis是将所有的数据放在内存中的，多线程的CUP上下文切换是一个耗时操作，所以使用单线程去操作效率是最高。对于内存系统，如果没有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）。
2.5 关于RedisKey基本命令
官网地址：http://www.redis.cn/commands.html
[root@VM-0-3-centos bin]# redis-cli -p 6379
127.0.0.1:6379> ping # 测试连接 redis 服务
PONG
127.0.0.1:6379> flushall # 删除所有库的数据
OK
127.0.0.1:6379> set name kid # 写入数据
OK
127.0.0.1:6379> set age 1 # 写入数据
OK
127.0.0.1:6379> keys * # 查看所有的key
1) "name"
2) "age"
127.0.0.1:6379> exists name # 查看key是否存在
(integer) 1
127.0.0.1:6379> exists name1 # 查看key是否存在
(integer) 0
127.0.0.1:6379> expire name 10 # 设置数据的过期时间
(integer) 1
127.0.0.1:6379> ttl name # 查看剩余过期时间
(integer) 6
127.0.0.1:6379> ttl name
(integer) 3
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> keys * # 查看所有的key
1) "age"
127.0.0.1:6379> move age 1 # 移动数据到1号数据库
(integer) 1
127.0.0.1:6379> select 1 # 切换数据库
OK
127.0.0.1:6379[1]> keys * # 查看所有key
1) "age"
127.0.0.1:6379[1]> set name kid
OK
127.0.0.1:6379[1]> keys *
1) "name"
2) "age"
127.0.0.1:6379[1]> type age # 查看当前key的类型
string
127.0.0.1:6379[1]> type name
string
2.6 五大基本数据类型
2.6.1 String字符串类型详解
######################################################################
# 追加字符
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> set k1 v1 # 设置数据
OK
127.0.0.1:6379> get k1 # 获取数据
"v1"
127.0.0.1:6379> exists k1 # 判断当前key是否存在
(integer) 1
127.0.0.1:6379> type k1 # 查看当前key对应value的类型
string
127.0.0.1:6379> append k1 " hello" # 追加字符串，当key不存在时，相当于写入数据
(integer) 8
127.0.0.1:6379> strlen k1 # 获取key对应字符串的长度
(integer) 8
127.0.0.1:6379> append k1 " kid !"
(integer) 14
127.0.0.1:6379> strlen k1
(integer) 14
127.0.0.1:6379> get k1
"v1 hello kid !"
######################################################################
# 自增、自减
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> set views 0 # 设置数据
OK
127.0.0.1:6379> incr views # 自增1
(integer) 1
127.0.0.1:6379> incr views # 自增1
(integer) 2
127.0.0.1:6379> decr views # 自减1
(integer) 1
127.0.0.1:6379> incrby views 5 # 自增 指定增量5
(integer) 6
127.0.0.1:6379> incrby views 5 # 自增 指定增量5
(integer) 11
127.0.0.1:6379> decrby views 3 # 自减 指定减量3
(integer) 8
127.0.0.1:6379> decrby views 3 # 自减 指定减量3
(integer) 5
######################################################################
# 字符串范围 range
127.0.0.1:6379> flushdb # 清空当前数据库
OK
127.0.0.1:6379> set key1 "hello kid !"
OK
127.0.0.1:6379> get key1
"hello kid !"
127.0.0.1:6379> getrange key1 0 3 # 截取字符串，getrange key start end
"hell"
127.0.0.1:6379> getrange key1 0 -1 # 查看字符串
"hello kid !"
# 替换
127.0.0.1:6379> flushdb # 清除当前数据库
OK
127.0.0.1:6379> set key1 abcdefg # 设置数据
OK
127.0.0.1:6379> setrange key1 1 xx # 替换索引[1]的值
(integer) 7
127.0.0.1:6379> get key1 # 查看
"axxdefg"
######################################################################
# setex (set with expire) # 设置过期时间
# setnx (set if not exist) # 不存在再设置（在分布式锁中常常使用）
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> setex key1 30 "kid" # 设置数据，并设置过期时间（30s）
OK
127.0.0.1:6379> ttl key1 # 查看剩余过期时间
(integer) 26
127.0.0.1:6379> keys * # 查看所有的key
1) "key1"
127.0.0.1:6379> setnx key2 v2 # 如果key2不存在设置数据，成功。
(integer) 1
127.0.0.1:6379> setnx key2 v2 # 如果key2不存在设置数据，失败。
(integer) 0
######################################################################
# mset # 批量设置
# mget # 批量获取
# msetnx # 如果不存在，同时设置多个值
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 # 批量设置数据
OK
127.0.0.1:6379> mget k1 k2 k3 # 批量获取数据
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v11 k2 v22 k3 v33 k4 v4 # msetnx 是一个原子性操作，要么一起成功，要么一起失败。
(integer) 0
127.0.0.1:6379> keys *
1) "k2"
2) "k1"
3) "k3"
# 对象
# set user:1:{name:kid,age:18} # 设置user:1对象，用json字符串来保存一个对象。
# 巧妙的设计：user:{id}:{filed}，redis也支持这种设计。
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> mset user:1:name kid user:1:age 18
OK
127.0.0.1:6379> get user:1:name
"kid"
127.0.0.1:6379> get user:1:age
"18"
127.0.0.1:6379> keys *
1) "user:1:name"
2) "user:1:age"
######################################################################
# getset 先get后set
127.0.0.1:6379> getset db redis # 如果不存在，返回nil
(nil)
127.0.0.1:6379> get db
"redis"
127.0.0.1:6379> getset db mongodb # 如果存在，返回原来的值，设置新的值
"redis"
127.0.0.1:6379> get db
"mongodb"
String类似的使用场景：value出了是字符串还可以是数字。
- 计数器
- 统计多单位的数量
- 粉丝数据
- 对象缓存存储
2.6.2 List列表类型详解
在redis我们可以把list当场栈和队列使用。
######################################################################
# lpush 往列表左侧(头部)插入数据
# rpush 往列表右侧（尾部）插入数据
127.0.0.1:6379> flushall
OK
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> lpush list one # 将一个值或多个值，插入列表的头部
(integer) 1
127.0.0.1:6379> lpush list two
(integer) 2
127.0.0.1:6379> lpush list three
(integer) 3
127.0.0.1:6379> lrange list 0 -1 # 获取列表的值
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> lrange list 0 1 # 通过区间获取列表具体的值
1) "three"
2) "two"
127.0.0.1:6379> rpush list right # 将一个值或多个值，插入列表的尾部
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"
######################################################################
# lpop # 从左侧（头部）移除
# rpop # 从右侧（尾部）移除
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"
127.0.0.1:6379> lpop list
"three"
127.0.0.1:6379> rpop list
"right"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
######################################################################
# lindex list下标
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
127.0.0.1:6379> lindex list 0 # 查看list下标为0的元素
"two"
127.0.0.1:6379> lindex list 1 # 查看list下标为1的元素
"one"
######################################################################
# llen list长度
127.0.0.1:6379> flushdb
OK
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> llen list # 查看list的长度
(integer) 2
######################################################################
# lrem 移除指定的值
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "three"
3) "two"
4) "one"
127.0.0.1:6379> lrem list 1 one # 移除list指定个数的value，精确匹配
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "three"
3) "two"
127.0.0.1:6379> lrem list 2 three # 移除list指定个数的value，精确匹配
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "two"
######################################################################
# ltrim 截取list
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> lpush mylist hello
(integer) 1
127.0.0.1:6379> lpush mylist hello1
(integer) 2
127.0.0.1:6379> lpush mylist hello2
(integer) 3
127.0.0.1:6379> lpush mylist hello3
(integer) 4
127.0.0.1:6379> ltrim mylist 1 2 # 通过下表截取指定范围的list，只剩下截取部分。
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "hello2"
2) "hello1"
######################################################################
# rpoplpush 移除右侧（尾部）一个元素，将他移动到新的列表中
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> lpush mylist hello
(integer) 1
127.0.0.1:6379> lpush mylist hello1
(integer) 2
127.0.0.1:6379> lpush mylist hello2
(integer) 3
127.0.0.1:6379> rpoplpush mylist newmylist # 移除mylist右侧（尾部）一个元素，将他移动到新的列表newmylist中
"hello"
127.0.0.1:6379> lrange mylist 0 -1
1) "hello2"
2) "hello1"
127.0.0.1:6379> lrange newmylist 0 -1
1) "hello"
######################################################################
# lset 将列表指定下标的值替换成指定的值（更新操作）
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> exists list # 判断list是否存在
(integer) 0
127.0.0.1:6379> lset list 0 item # list不存在，更新报错
(error) ERR no such key
127.0.0.1:6379> lpush list hello
(integer) 1
127.0.0.1:6379> lrange list 0 0
1) "hello"
127.0.0.1:6379> lset list 0 item # 如果list当前下标存在，更新当前下标的值
OK
127.0.0.1:6379> lrange list 0 0
1) "item"
127.0.0.1:6379> lset list 1 item1 # 如果list当前下标不存在，报错
(error) ERR index out of range
######################################################################
# linsert 将某个具体的值插入列表中某个元素的前面或后面
127.0.0.1:6379> flushdb
OK
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> linsert list before "world" "before" # 在world前插入数据
(integer) 3
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "before"
3) "world"
127.0.0.1:6379> linsert list after "world" "after" # 在world后插入数据
(integer) 4
127.0.0.1:6379> lrange list 0 -1
1) "hello"
2) "before"
3) "world"
4) "after"
小结：
- redis的list实际上是一个链表，before node after、left、right都可以插入值
- 如果key不存在，创建新的链表；如果存在，新增内容
- 如果移除了所有值，空链表，也代表不存在
- 在两边插入或改动值效率最高，中间元素，相对来说效率会低一点
消息队列（lpush rpop）栈（lpush lpop）不同的命令组合，可以模拟不同的数据结构。
2.6.3 Set集合类型详解
set无序、不重复。
######################################################################
# sadd set集合中添加元素
# smembers 查看set集合中所有元素
# sismember 判断某一个元素是不是set集合中的值
# scard 获取set集合中所有元素个数
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> sadd myset hello # set集合中添加元素
(integer) 1
127.0.0.1:6379> sadd myset world
(integer) 1
127.0.0.1:6379> smembers myset # 查看set集合中的所有元素
1) "world"
2) "hello"
127.0.0.1:6379> sismember myset world # 判断某一个元素是不是set集合中的值
(integer) 1
127.0.0.1:6379> sismember myset hello
(integer) 1
127.0.0.1:6379> scard myset # 获取set集合中的元素个数
(integer) 2
######################################################################
# srem 移除set集合中指定的元素
127.0.0.1:6379> srem myset hello # 移除set集合中的指定操作
(integer) 1
127.0.0.1:6379> scard myset
(integer) 1
127.0.0.1:6379> smembers myset
1) "world"
######################################################################
# srandmember 随机抽取元素
127.0.0.1:6379> smembers myset # 查看set集合中所有元素
1) "k3"
2) "world"
3) "k1"
4) "k2"
5) "k4"
127.0.0.1:6379> srandmember myset # 随机抽取一个元素
"k2"
127.0.0.1:6379> srandmember myset
"k3"
127.0.0.1:6379> srandmember myset
"world"
127.0.0.1:6379> srandmember myset 2 # 随机抽取两个元素
1) "world"
2) "k2"
127.0.0.1:6379> srandmember myset 2
1) "k1"
2) "k2"
######################################################################
# spop 随机删除key
127.0.0.1:6379> smembers myset
1) "k3"
2) "world"
3) "k1"
4) "k2"
5) "k4"
127.0.0.1:6379> spop myset # 随机删除一个元素
"k3"
127.0.0.1:6379> spop myset
"k2"
127.0.0.1:6379> smembers myset
1) "world"
2) "k1"
3) "k4"
######################################################################
# smove 移除一个指定元素到另一个set集合(如果集合不存在自动创建)中
127.0.0.1:6379> flushdb
OK
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 kid
(integer) 1
127.0.0.1:6379> sadd myset 1412
(integer) 1
127.0.0.1:6379> smove myset newmyset 1412
(integer) 1
127.0.0.1:6379> smembers myset
1) "kid"
2) "world"
3) "hello"
127.0.0.1:6379> smembers newmyset
1) "1412"
######################################################################
# sdiff 差集
# sinter 交集
# sunion 并集
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> sadd set1 a
(integer) 1
127.0.0.1:6379> sadd set1 b
(integer) 1
127.0.0.1:6379> sadd set1 c
(integer) 1
127.0.0.1:6379> sadd set2 c
(integer) 1
127.0.0.1:6379> sadd set2 d
(integer) 1
127.0.0.1:6379> sadd set2 e
(integer) 1
127.0.0.1:6379> sdiff set1 set2 # 差集
1) "b"
2) "a"
127.0.0.1:6379> sinter set1 set2 # 交集
1) "c"
127.0.0.1:6379> sunion set1 set2 # 并集-
1) "b"
2) "c"
3) "e"
4) "a"
5) "d"
2.6.4 Hash哈希类型详解
Map集合，key-map，这个时候value是一个集合。本质上跟String没有太大区别。
set myhash field kid
######################################################################
# hset 设置hash数据
# hget 获取hash数据
# hmset 批量设置hash数据
# hmget 批量获取hash数据
# hdel 删除指定key的hash数据
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> hset myhash field1 kid # 设置一个具体的key-value
(integer) 1
127.0.0.1:6379> hget myhash field1 # 获取一个值
"kid"
127.0.0.1:6379> hmset myhash field1 kid1 field2 kid2 field3 kid3 # 设置多个key-value
OK
127.0.0.1:6379> hmget myhash field1 field2 field3 # 获取多个值
1) "kid1"
2) "kid2"
3) "kid3"
127.0.0.1:6379> hgetall myhash # 获取全部数据
1) "field1"
2) "kid1"
3) "field2"
4) "kid2"
5) "field3"
6) "kid3"
127.0.0.1:6379> hdel myhash field1 # 删除hash指定key的键值对
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "kid2"
3) "field3"
4) "kid3"
######################################################################
# hlen 获取hash表的字段数据量
# hexists 判断hash表的某个字段是否存在
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "kid2"
3) "field3"
4) "kid3"
127.0.0.1:6379> hlen myhash # 获取hash表的字段数据量
(integer) 2
127.0.0.1:6379> hexists myhash field1 # 判断myhash的field1是否存在
(integer) 0
127.0.0.1:6379> hexists myhash field2 # 判断myhash的field2是否存在
(integer) 1
######################################################################
# hkeys 只获取所有field
# hvals 只获取所有value
127.0.0.1:6379> hkeys myhash # 获取所有的field
1) "field2"
2) "field3"
127.0.0.1:6379> hvals myhash # 获取所有的value
1) "kid2"
2) "kid3"
######################################################################
# hincrby 自增
# hsetnx 如果hash表不存在field = 指定field，设置数据
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "kid2"
3) "field3"
4) "kid3"
5) "field4"
6) "0"
127.0.0.1:6379> hincrby myhash field4 1 # 自增1
(integer) 1
127.0.0.1:6379> hincrby myhash field4 -1 # 自减 1
(integer) 0
127.0.0.1:6379> hsetnx myhash field5 1 # 如果hash表不存在field = field5，设置数据
(integer) 1
127.0.0.1:6379> hsetnx myhash field5 1 # 如果hash表不存在field = field5，设置数据，否则不设置
(integer) 0
######################################################################
# hash可以变更数据user{name, age}
# hash更适合对象的存储，String更适合存储字符串
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> hset user:1 name kid
(integer) 1
127.0.0.1:6379> hset user:1 age 18
(integer) 1
127.0.0.1:6379> hgetall user:1
1) "name"
2) "kid"
3) "age"
4) "18"
2.6.5 Zset(有序集合)详解
在set的基础上加了一个值set k1 v1，zset k1 score1 v1
######################################################################
# zadd 设置数据(可以批量设置)
# 查看所有的values值
127.0.0.1:6379> zadd myset 1 one # 添加一个数据
(integer) 1
127.0.0.1:6379> zadd myset 2 tow 3 three # 添加多个数据
(integer) 2
127.0.0.1:6379> zrange myset 0 -1 # 查看所有的values值
1) "one"
2) "tow"
3) "three"
######################################################################
# zrangebyscore 查看zset中所有的数据（附带score的限制条件）
# inf ∞
# withscores 查询结果显示score
127.0.0.1:6379> zadd salary 2500 kid1 # 添加3个数据
(integer) 1
127.0.0.1:6379> zadd salary 5000 kid2
(integer) 1
127.0.0.1:6379> zadd salary 1000 kid3
(integer) 1
127.0.0.1:6379> zrangebyscore salary -inf +inf # 查看所有的values
1) "kid3"
2) "kid1"
3) "kid2"
127.0.0.1:6379> zrangebyscore salary -inf +inf withscores # 查看所有的values和score，score在-∞和+∞之间的
1) "kid3"
2) "1000"
3) "kid1"
4) "2500"
5) "kid2"
6) "5000"
127.0.0.1:6379> zrangebyscore salary -inf +250 withscores # 查看所有的values和score，score在-∞和250之间的
(empty list or set)
127.0.0.1:6379> zrangebyscore salary -inf +2500 withscores # 查看所有的values和score，score在-∞和2500之间的
1) "kid3"
2) "1000"
3) "kid1"
4) "2500"
######################################################################
# zrem 移除zset中的元素
127.0.0.1:6379> zrange salary 0 -1
1) "kid3"
2) "kid1"
3) "kid2"
127.0.0.1:6379> zrem salary kid1 # 移除指定的元素
(integer) 1
127.0.0.1:6379> zrange salary 0 -1
1) "kid3"
2) "kid2"
######################################################################
# 查看集合中元素的个数
127.0.0.1:6379> zrange salary 0 -1
1) "kid3"
2) "kid2"
127.0.0.1:6379> zcard salary
(integer) 2
######################################################################
# zcount 获取指定区间的元素数量
127.0.0.1:6379> zrange myset 0 -1
1) "one"
2) "tow"
3) "three"
127.0.0.1:6379> zcount myset 1 2 # 获取指定区间的元素数量
(integer) 2
######################################################################
# zrevrange 倒叙排列
127.0.0.1:6379> zrange myset 0 -1
1) "one"
2) "tow"
3) "three"
127.0.0.1:6379> zrevrange myset 0 -1
1) "three"
2) "tow"
3) "one"
注：记得常看官方文档。
案例思路：
- set排序，存储学生成绩
- 权重设置，排行榜
2.7 三种特殊数据类型
2.7.1 geospatial 地理位置详解
朋友圈的定位，附近的人、打车距离计算如何实现？
Redis 的 Geo 在 Redis3.2 版本就推出了，这个功能可以推算出地理位置的信息，比如两地之间的距离，方圆指定距离内的人。
只有六个命令
######################################################################
# geoadd 添加地理位置数据
# 两极无法添加，一般下载城市数据，通过java程序导入
# 参数 key 值（维度、经度、名称）
127.0.0.1:6379> geoadd china:city 116.40 39.90 beijin
(integer) 1
127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai
(integer) 1
127.0.0.1:6379> geoadd china:city 160.50 29.53 chongqing
(integer) 1
127.0.0.1:6379> geoadd china:city 114.05 22.52 shenzhen 120.16 30.24 hangzhou 108.96 34.26 xian
(integer) 3
######################################################################
# geopos 获取指定城市的经纬度
127.0.0.1:6379> geopos china:city beijin
1) 1) "116.39999896287918091"
2) "39.90000009167092543"
127.0.0.1:6379> geopos china:city beijin xian
1) 1) "116.39999896287918091"
2) "39.90000009167092543"
2) 1) "108.96000176668167114"
2) "34.25999964418929977"
######################################################################
# geodist 两个人之间距离，如果两个人不存在，返回为空。同时可以指定单位（m-米，km-千米，mi-英里，ft-英尺）
127.0.0.1:6379> geodist china:city beijin xian # 北京到西安的直线距离（默认单位：m）
"910056.5237"
127.0.0.1:6379> geodist china:city beijin xian km
"910.0565"
######################################################################
# georadius 根据半径查询当前位置附近的定位
# 获取附近人的地址，定位（通过半径来查询）
127.0.0.1:6379> georadius china:city 110 30 1000 km # 获取当前以（110，30）为中心，寻找方圆1000km内的数据
1) "xian"
2) "shenzhen"
3) "hangzhou"
127.0.0.1:6379> georadius china:city 110 30 500 km
1) "xian"
127.0.0.1:6379> georadius china:city 110 30 500 km withdist # 查询结果附带距离
1) 1) "xian"
2) "483.8340"
127.0.0.1:6379> georadius china:city 110 30 500 km withcoord # 查询结果附带经纬度
1) 1) "xian"
2) 1) "108.96000176668167114"
2) "34.25999964418929977"
127.0.0.1:6379> georadius china:city 110 30 1000 km withcoord withdist count 1 # count限制查询结果数量
1) 1) "xian"
2) "483.8340"
3) 1) "108.96000176668167114"
2) "34.25999964418929977"
######################################################################
# 找出位于指定元素周围的其他元素
127.0.0.1:6379> georadiusbymember china:city beijin 1000 km
1) "beijin"
2) "xian"
127.0.0.1:6379> georadiusbymember china:city shanghai 400 km
1) "hangzhou"
2) "shanghai"
######################################################################
# geohash 返回一个或多个位置元素的11位的Geohash字符串
127.0.0.1:6379> geohash china:city beijin chongqing # 返回北京、重庆的经纬度对应的Geohash
1) "wx4fbxxfke0"
2) "xt4purb89n0"
注：GEO底层的实现原理其实就是Zset，我们可以使用Zset的命令操作geo
127.0.0.1:6379> zrange china:city 0 -1 # 查看geo地图中全部的元素
1) "xian"
2) "shenzhen"
3) "hangzhou"
4) "shanghai"
5) "beijin"
6) "chongqing"
127.0.0.1:6379> zrem china:city beijin # 删除geo地图中指定的元素
(integer) 1
127.0.0.1:6379> zrange china:city 0 -1
1) "xian"
2) "shenzhen"
3) "hangzhou"
4) "shanghai"
5) "chongqing"
2.7.2 Hyperloglog 基数统计
- 什么基数？
一组元素中不重复的元素个数。 - 简介：
Redis 2.8.9版本就更新了 Hyperloglog 数据结构了。
Redis Hyperloglog 基数统计的算法。
优点： 占用的内存是固定，2^64个不同元素的基数，只需要12KB内存！如果从内存角度比较的话，Hyperloglog首选。
eg： 网页的UV(一个人访问一个网站多次，但是还算作一个人！)，传统的方式，set保存用户的id，然后统计set中元素数量作为判断标准，这个方式保存大量的用户id，就比较麻烦，但是我们的目的是为了计数，不是为了统计id。
0.81% 错误率！统计UV任务，可以忽略不计。
######################################################################
# pfadd 添加 Hyperloglog 类型数据
# pfcount 统计一组元素中基数数量
# pfmerge 合并两组元素 （并集）
127.0.0.1:6379> pfadd mykey a b c d e f g h i j k # 创建第一组元素
(integer) 1
127.0.0.1:6379> pfcount mykey # 统计第一组元素基数数量
(integer) 11
127.0.0.1:6379> pfadd mykey2 i j n c v n m b
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 7
127.0.0.1:6379> pfmerge mykey3 mykey mykey2 # 合并两组 mykey mykey2 ==> mykey3 并集
OK
127.0.0.1:6379> pfcount mykey3 # 查看并集数量
(integer) 14
如果允许容错，可以使用Hyperloglog。
如果不允许容错，就是用set或者自己的数据类型即可。
2.7.3 Bitmaps 位图场景详解
- 位存储
统计用户信息：活跃、不活跃，登录、不登陆，打卡、不打卡。两个状态，都可以使用Bitmaps！
Bitmaps位图，数据结构！都是操作二进制位来进行记录，只有0和1两个状态。
######################################################################
# 用Bitmaps统计周一 - 周日打卡记录。
# 周一：1，周二：1，周三：0 ...
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 0
(integer) 0
127.0.0.1:6379> setbit sign 3 0
(integer) 0
127.0.0.1:6379> setbit sign 4 1
(integer) 0
127.0.0.1:6379> setbit sign 5 1
(integer) 0
127.0.0.1:6379> setbit sign 6 0
(integer) 0
127.0.0.1:6379> getbit sign 3 # 查看某一天是否打开
(integer) 0
127.0.0.1:6379> getbit sign 5
(integer) 1
127.0.0.1:6379> bitcount sign # 统计本周打卡记录
(integer) 4
2.8 Redis基本的事务操作
Redis事务本质：一组命令的集合，一个事务中的所有命令都会被序列化，在事务执行的过程中，会按照顺序执行。
一次性、顺序性、排他性。
---- 队列 set set set 执行 ----
== Redis事务没有隔离级别的概念 ==
所有的命令在事务中，并没有直接被执行，只有发起执行命令的时候才会执行。
== Redis单条命令是保存原子性，但是事务不保存原子性 ==。
Redis的事务：
- 开启事务（multi）
- 命令入队 （…）
- 执行事务（exec）
######################################################################
# multi 开启事务
# exec 执行事务
# discard 放弃事务
127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379> set k1 v1 # 命令入队
QUEUED
127.0.0.1:6379> set ke v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> exec # 执行事务
1) OK
2) OK
3) OK
127.0.0.1:6379> flushdb # 清空数据库
OK
127.0.0.1:6379> multi # 开启事务
OK
127.0.0.1:6379> set k1 v1
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)
- 编译型异常（代码有问题，命令有错），事务中所有的命令都不会执行
127.0.0.1:6379> flushdb # 清空数据库
OK
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> exec # 执行报错的事务
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k4 # 所有的命令都不会执行
(nil)
127.0.0.1:6379> get k1
(nil)
- 运行时异常（1 / 0），如果队列中存在语法性错误，那么执行命令的时候，其他命令可以正常执行。
127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> set k1 "v1"
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> incr k1 # 运行报错命令（字符串不能自增）
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> get k2
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) "v2"
5) "v3"
-
Java代码操作事务
public class TestTX { public static void main(String[] args) { Jedis jedis = new Jedis("127.0.0.1", 6379); jedis.flushDB(); // 清空数据库 JSONObject jsonObject = new JSONObject(); jsonObject.put("name", "kid"); jsonObject.put("age", 18); String result = jsonObject.toJSONString(); Transaction multi = jedis.multi(); // jedis.watch(result); // 监视 result，乐观锁 try { multi.set("user1", result); multi.set("user2",result); // int i = 1 / 0; // 代码抛出异常，执行失败 multi.exec(); // 执行事务 } catch (Exception e) { multi.discard(); // 放弃事务 e.printStackTrace(); } finally { System.out.printf("用户1：" + jedis.get("user1") + "; "); System.out.printf("用户2：" + jedis.get("user2")); } } }成功：
失败：
2.9 Redis实现乐观锁
悲观锁：
- 很悲观，认为什么时候都会出问题，无论做什么都会枷锁。
乐观锁：
- 很乐观，认为什么时候都不会出问题，所以不会上锁！更新数据的时候去判断一下，在此期间是否有人修改过这个数据！（加一个version字段）
Redis监控测试：
- 正常执行成功！
127.0.0.1:6379> flushdb
OK
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 10
QUEUED
127.0.0.1:6379> incrby out 10
QUEUED
127.0.0.1:6379> exec # 执行命令之前,另一个线程修改类money的值，会导致事务失败。
(nil)
# 解决：
# 1. 发现事务执行失败，先解锁
# 2. 获取最新的值，再次监视
# 3. 比对监视的值是否发生了变化，如果没有变化，那么可以执行成功，否则执行失败
127.0.0.1:6379> unwatch # 解锁
OK
127.0.0.1:6379> watch money # 剪视money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> incrby money 20
QUEUED
127.0.0.1:6379> decrby out 20
QUEUED
127.0.0.1:6379> exec
1) (integer) 908
2) (integer) 0
2.10 使用Jedis操作Redis
我们要使用Java来操作Redis。
- 什么是Jedis？
是Redis官方推荐的Java连接开发工具，是Java操作Redis中间件。如果使用Java操作redis，那么一定要对Jedis十分熟悉。
测试：
- 导入对应的依赖：
<dependencies>
<!-- jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.2.0</version>
</dependency>
<!-- fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.62</version>
</dependency>
</dependencies>
- 编码测试
（1）连接数据库
（2）操作命令
（3）断开连接
import redis.clients.jedis.Jedis;
import java.util.logging.Logger;
public class TestPing {
public static void main(String[] args) {
Logger log = Logger.getLogger(String.valueOf(TestPing.class));
// 1. new Jedis 对象
Jedis jedis = new Jedis("122.51.223.62", 6379);
// jedis所有的命令就是redis的所有命令
log.info(jedis.ping());
}
}
- 常用API
- TestPing
public class TestPing { public static void main(String[] args) { Logger log = Logger.getLogger(String.valueOf(TestPing.class)); // 1. new Jedis 对象 Jedis jedis = new Jedis("127.0.0.1", 6379); // jedis所有的命令就是redis的所有命令 log.info("测试连接：" + jedis.ping()); log.info("清空当前数据库数据：" + jedis.flushDB()); log.info("清空所有数据库数据：" + jedis.flushAll()); log.info("新增<'username','kid'>键值对：" + jedis.set("username", "kid")); log.info("新增<'password','pwd'>键值对：" + jedis.set("password", "pwd")); log.info("系统中所有的键：" + jedis.keys("*")); log.info("删除键password：" + jedis.del("password")); log.info("判断键password是否存在：" + jedis.exists("password")); log.info("查看键username所存储值的类型：" + jedis.type("username")); log.info("随机返回key空间的一个：" + jedis.randomKey()); log.info("重命名key：" + jedis.rename("username", "name")); log.info("去除改名后的key：" + jedis.get("name")); log.info("切换数据库：" + jedis.select(0)); log.info("返回当前选择数据库中key的数目：" + jedis.dbSize()); log.info("清空当前数据库数据：" + jedis.flushDB()); jedis.close(); } }- TestString
public class TestString { public static void main(String[] args) { Logger log = Logger.getLogger(String.valueOf(TestString.class)); Jedis jedis = new Jedis("127.0.0.1", 6379); jedis.flushDB(); log.info("************* 增加数据 *************"); log.info(jedis.set("k1", "v1")); log.info(jedis.set("k2", "v2")); log.info(jedis.set("k3", "v3")); log.info("删除键k2：" + jedis.del("k2")); log.info("获取键k2：" + jedis.get("k2")); log.info("修改k1的值：" + jedis.set("k1", " value changed")); log.info("在k3后面追加字符串：" + jedis.append("k3", " end")); log.info("key3的值：" + jedis.get("k3")); log.info("增加多个键值对：" + jedis.mset("k01", "v01", "k02", "v02", "k03", "v03")); log.info("获取多个键值对：" + jedis.mget("k01", "k02", "k03")); log.info("删除多个键值对：" + jedis.del("k01", "k02")); log.info("获取多个键值对：" + jedis.mget("k01", "k02", "k03")); jedis.flushDB(); log.info("************* 新增键值对防止覆盖原先值 *************"); log.info("如果不存在新增键值对：" + jedis.setnx("k1", "k1")); log.info("如果不存在新增键值对：" + jedis.setnx("k1", "k1-new")); log.info("如果不存在新增键值对" + jedis.setnx("k2", "v2")); log.info("获取k1的值：" + jedis.get("k1")); log.info("获取k5的值：" + jedis.get("k2")); log.info("************* 新增键值并设置有效时间 *************"); log.info("新增键值对并设置有效时间（s）：" + jedis.setex("k3", 2, "v3")); log.info("获取k3的值：" + jedis.get("k3")); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } log.info("获取k3的值：" + jedis.get("k3")); log.info("************* 获取原值，更新为新值 *************"); log.info("获取原来的值：" + jedis.getSet("k2", "k2-new")); log.info("获取新的值：" + jedis.get("k2")); log.info("************* 获取指定索引范围的值 *************"); log.info("获取指定索引返回内的值：" + jedis.getrange("k2", 1, 3)); jedis.close(); } }
2.11 SpringBoot整合Redis
说明： 在SpringBoot 2.x 之后原来使用的 jedis 被替换成了 lettuce
jedis：采用的是直连，多个线程操作的话，是不安全的。如果想避免，就需要使用redis pool连接池（更像BIO）。
lettuce：采用netty，实例可以在多个线程中共享，不存在线程不安全的情况（更像NIO）。
源码分析：
@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是我们经常使用的类型，所以单独提出来一个bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
测试一下：
- 导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
- 连接配置
spring.redis.host=127.0.0.1
spring.redis.port=6379
- 测试
@SpringBootTest
class RedisApplicationTests {
@Autowired
RedisTemplate redisTemplate;
@Test
void contextLoads() {
// redisTemplate.opsForValue() 操作字符串,位图场景 类似String Bitmap
// redisTemplate.opsForList() 操作列表 类似list
// redisTemplate.opsForSet() 操作集合 类似set
// redisTemplate.opsForHash() 操作Hash类型 类似Hash
// redisTemplate.opsForZSet() 操作有序集合 类似Zset
// redisTemplate.opsForHyperLogLog() 操作基数统计 类似Hyperloglog
// redisTemplate.opsForGeo() 操作地理位置 类似Geospatial
// 除了基本的操作，我们常用的方法都可以通过redisTemplate操作，比如事务、基本的CRUD
// 获取redis的连接对象
// RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
// connection.flushAll();
// connection.flushDb();
redisTemplate.opsForValue().set("k1", "v1");
System.out.println(redisTemplate.opsForValue().get("k1"));
}
}
Redis序列化分析：
2.12 自定义的RestTemplate
自定义配置：
- 配置代码
@Configuration public class RedisConfig { @Bean @SuppressWarnings("all") public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { RedisTemplate<String, Object> template = new RedisTemplate(); template.setConnectionFactory(redisConnectionFactory); // 序列化配置：自定义Json序列化 （系统默认的序列化方式:JdkSerializationRedisSerializer） Jackson2JsonRedisSerializer objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class); template.setDefaultSerializer(objectJackson2JsonRedisSerializer); ObjectMapper objectMapper = new ObjectMapper(); objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); objectJackson2JsonRedisSerializer.setObjectMapper(objectMapper); // String 的序列化 StringRedisSerializer stringRedisSerializer = new StringRedisSerializer(); // key采用String的序列化方式 template.setKeySerializer(stringRedisSerializer); // hash的key也采用String的序列化方式 template.setHashKeySerializer(stringRedisSerializer); // value序列化方式采用jackson template.setValueSerializer(objectJackson2JsonRedisSerializer); // hash的value序列化方式采用jackson template.setHashValueSerializer(objectJackson2JsonRedisSerializer); template.afterPropertiesSet(); return template; } } - 测试代码
@Autowired // @Qualifier("redisTemplate") private RedisTemplate<String, Object> redisTemplate; // 使用泛型，不然指定不到自定义的redisTemplate @Test public void test() throws JsonProcessingException { RedisConnection connection = redisTemplate.getConnectionFactory().getConnection(); connection.flushDb(); // 真正的开发一般用json传递对象 User user = new User("姓名", 18); // String jsonUser = new ObjectMapper().writeValueAsString(user); redisTemplate.opsForValue().set("user", user); System.out.println(redisTemplate.opsForValue().get("user")); } - 序列化方式，系统默认使用的是JDK序列化(JdkSerializationRedisSerializer)。
关于对象的保存：
- 一定要对对象序列化，否则就会报错
- 序列化之后，测试通过。
2.13 Redis.conf 配置文件详解
- 配置文件unit单位 对大小写不敏感
# 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. - 包含 INCLUDES (类似import)
# include /path/to/local.conf # include /path/to/other.conf - 网络 NETWORK
bind 127.0.0.1 # 绑定ip protected-mode yes # 保护模式 port 6379 # 端口 - 通用 GENERAL
daemonize yes # 一守护进程的方式运行，默认是no，我们需要自己开启为yes pidfile /var/run/redis_6379.pid # 如果以后台的方式运行，我们就需要一个pid进程文件 # 日志 # Specify the server verbosity level. # This can be one of: # debug (a lot of information, useful for development/testing) # verbose (many rarely useful info, but not a mess like the debug level) # notice (moderately verbose, what you want in production probably) # warning (only very important / critical messages are logged) loglevel notice # 日志等级 logfile "" # 日志文件位置名 databases 16 # 默认数据库数量 always-show-logo yes # 是否总是显示logo - 快照 SNAPSHOTTING
持久化，在规定时间内，执行多少次操作，则会持久化到文件.fdb.aof
redis是内存数据库，如果没有数据化，那么数据断电即失。save 900 1 # 如果900s内，如果至少有1个key进行了修改，我们进行持久化操作 save 300 10 # 如果300s内，如果至少10个key进行类修改，我们进行持久化操作 save 60 10000 # # 如果60s内，如果至少10000个key进行类修改，我们进行持久化操作 stop-writes-on-bgsave-error yes # 持久化如果出错，是否继续工作 rdbcompression yes # 是否压缩rdb文件 rdbchecksum yes # 保存rdb文件的时候，进行错误检查校验 dir ./ # rdb文件保存的目录 - 主从复制 REPLICATION，见下文。
- 安全 SECURITY
# 设置密码,通过配置文件设置 requirepass foobared # 设置密码 # 设置密码，通过命令设置 127.0.0.1:6379> ping PONG 127.0.0.1:6379> config get requirepass # 获取密码 默认为空 1) "requirepass" 2) "" 127.0.0.1:6379> config set requirepass "123456" # 设置密码 OK 127.0.0.1:6379> config get requirepass # 没有权限 (error) NOAUTH Authentication required. 127.0.0.1:6379> ping # 没有权限 (error) NOAUTH Authentication required. 127.0.0.1:6379> auth 123456 # 权限认证 OK 127.0.0.1:6379> config get requirepass # 获取密码 1) "requirepass" 2) "123456" - 客户端 CLIENTS
maxclients 10000 # 客户端的最大连接数 maxmemory <bytes> # redis 配置的最大内存容量 # 1、volatile-lru：只对设置了过期时间的key进行LRU（默认值） # 2、allkeys-lru ： 删除lru算法的key # 3、volatile-random：随机删除即将过期key # 4、allkeys-random：随机删除 # 5、volatile-ttl ： 删除即将过期的 # 6、noeviction ： 永不过期，返回错误 maxmemory-policy noeviction # 内存达到上限之后的处理策略 - aof配置 APPEND ONLY MODE
appendonly no # 默认不开启，默认使用rdb持久化，在大部分情况下，rdb够用了 appendfilename "appendonly.aof" # 持久化文件名 # appendfsync always # 每次修改都会sync，消耗性能 appendfsync everysec # 每秒执行一次sync，可能丢失这1s的数据 # appendfsync no # 不执行，这个时候操作系统自己同步数据
2.14 Redis 持久化之RDB操作
Redis是内存数据库，如果不将内存中的数据库状态保存到硬盘中，那么一旦服务器进程退出，服务器状态也会小时。所以Redis提供了持久化功能。
RDB：
- 简介
在指定的时间内，将内存中的数据集体快照写入磁盘中，也就是平时说的Snapshot快照，它恢复时是将快照文件直接读到内存里。Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写到一个临时文件，待持久化过程结束，在用这个临时文件替换上次持久化好的文件。整个过程，主进程是不进行任何IO操作的。这就确保了极高的新能。如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB比AOF方式更加高效，RDB的缺点是最后一次吃计划的数据可能会丢失。
- rdb保存的文件是dump.rdb，都是在配置文件中的 SNAPSHOTTING 中配置的。
触发机制：
（1）save的规则满足的情况下，会自动触发rdb规则
（2）执行flushall，也会触发rdb规则
（3）退出redis，也会产生rdb文件
备份自动生成一个dump.rdb
优点：
- 适合大规模的数据恢复
- 对数据完整性要求不高
缺点：
- 需要一定的时间间隔进程操作！如果reids宕机了，这个最后一次修改数据就没了。
- fork进程的时候，就一定会占用一定的空间
2.16 Redis 持久化之AOF（Append Only File）操作
将我们所有的命令都记录下拉，history，恢复的时候再把这个文件全部执行一遍。
AOF：
以日志的形式记录每个写操作，将Redis执行过的所有指令记录下来（读操作不记录），只需追加文件但不可改写文件，redis启动之初会读取该文件重新构建数据，换言之，reids重启的话就根据日志文件的内容将写指令从前到后执行一次已完成数据的恢复工作。
AOF保存的是appendonly.aof文件
如果aof文件有错误，这时候redis是启动不起来的，我们需要修复这个文件。
redis提供了一个工具redis-check-aof
redis-check-aof --fix appendonly.aof # 修复命令
如果文件正常，重启就可以直接恢复了。
优点：
- 每一次修改都会同步，文件完整性更好。
- 每秒同步一次，可能丢疫苗的数据
- 从不同步，效率最高
缺点：
- 相对于数据文件来说，aof远远大于rdb，修复数据比rdb慢
- aof运行效率比rdb慢，redis默认配置rdb持久化。
2.17 Redis 订阅发布
Redis 发布订阅（pub/sub）是一种消息通信模式：发布者（pub）发送消息，订阅者（sub）接收消息。
Redis客户端可以订阅任意数量的频道。
订阅/发布消息图：
下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：
当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：
命令
订阅端：
127.0.0.1:6379> SUBSCRIBE kid # 订阅一个频道， kid
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "kid"
3) (integer) 1
# 等待读取推送的信息
1) "message" # 消息
2) "kid" # 哪个频道的消息
3) "hello,kid" # 具体内容
1) "message"
2) "kid"
3) "hello,redis"
发送端：
127.0.0.1:6379> PUBLISH kid "hello,kid" # 发布者发布消息到频道
(integer) 1
127.0.0.1:6379> PUBLISH kid "hello,redis" # 发布者发布消息到频道
(integer) 1
原理：
Redis是使用C实现的，通过分析Redis源码里的pubsub.c文件，了解发布和订阅机制的底层实现，籍此加深对Redis的理解。
Redis通过 PUBLISH、SUBSCRIBE 和PSUBSCRIBE等命令实现发布和订阅功能。
通过SUBSCRIBE命令订阅某个频道后，redis-server里维护了一个字段，字典的键就是一个个频道，而字典的值则是一个链表，链表中保存了所有订阅这个channel的客户端。SUBSCRIBE命令的关键，就是将客户端添加到给定的channel的订阅链表中。
通过PUBLISH命令想订阅者发送该消息，redis-server会使用给定的频道作为键，在他所维护的channel字典中查找记录了订阅这个频道的所有客户端的链表，遍历这个链表，将消息发布给所有订阅者。
Pub/Sub从字面上理解就是发布（publish）和订阅（subscribe），在Redis中，你可以设定对某一个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅它的客户端都会收到响应的消息。这一功能最明显的用法就是用作实时消息系统，比如普通的即使聊天，群聊功能。
使用场景
- 实时消息系统
- 实时聊天（频道当作聊天室，将信息回显给所有人）
- 订阅、关注系统。
- 复杂场景，会使用消息中间件来做，MQ
2.18 Redis 主从复制
概念：
主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器，前者称为主节点（master/leader），后者成为从节点（slave/follower）。数据复制是单向的，只能由主节点到从节点。Master以写为主，Slave以读为主。
默认情况下，每台Redis服务器都是主节点，且一个主节点可以有多个从节点（或者没有节点），但是一个从节点只能有一个主节点。
主从复制的作用主要包括：
- 数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
- 故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复，实际上是一种服务冗余方式。
- 负载均衡：在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写Redis数据时连接主节点，读Redis数据时连接从节点），分担服务器负载，尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提供共Redis服务器的并发量。
- 高可用（集群）基石：出了上述作用之外，主从复制还是烧饼和集群能够实施的基础，因此说主从复制是Redis高可用的基础。
一般来说，要将Redis运用到工程项目中，只是用一台Redis是万万不能的（宕机）原因：
- 从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大。
- 从容量上，单个Redis服务器内存容量有限，就算一台Redis服务内存容量为256G，也不能将所有内存用作Redis存储内存。一般来说，单台Redis最大使用内存不应该超过20G。
电商网站上的商品，一般都是一次上传，无数次浏览。专业说法就是"多读少写"。
对于这种场景，我们可以使用如下架构：
环境配置：
只配置从库，不用配置主库（Redis默认是一个主库）。
127.0.0.1:6379> info replication # 查看当前库的信息
# Replication
role:master # 角色 master
connected_slaves:0 # 连接从机数
master_replid:a49093f00127f58ae31bd4a907d592fc4c1e9699
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
复制三个配置文件，修改对应的信息：
- 端口号
- pid 名称
- log 文件名称
- dump.rdb 名称（Redis默认使用RDB持久化）
port 6379
pidfile /var/run/redis_6379.pid
logfile "6379.log"
dbfilename dump-6379.rdb
daemonize yes # 记得开启守护进程，防止服务挂掉
配置好，启动服务。
一主二仆（Master：6379；Slave：6380，6381）：
Redis默认就是主配置，只需要配置从机。
- 命令配置
127.0.0.1:6380> SLAVEOF 127.0.0.1 6379 # 为从机配置主机
OK
127.0.0.1:6380> info replication # 查看从机信息
# Replication
role:slave # 角色 从机
master_host:127.0.0.1 # 主机ip
master_port:6379 # 主机 port
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:b65a7bed5ff448f072d0cd8f41568b11f2f727b6
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
127.0.0.1:6381> SLAVEOF 127.0.0.1 6379 # 为从机配置主机
OK
127.0.0.1:6381> info replication # 查看从机信息
# Replication
role:slave # 角色 从机
master_host:127.0.0.1 # 主机 ip
master_port:6379 # 主机 port
master_link_status:up
master_last_io_seconds_ago:2
master_sync_in_progress:0
slave_repl_offset:84
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:b65a7bed5ff448f072d0cd8f41568b11f2f727b6
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:84
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:57
repl_backlog_histlen:28
127.0.0.1:6379> info replication # 查看主机信息
# Replication
role:master # 角色 主机
connected_slaves:2 # 连接的从机数 2
slave0:ip=127.0.0.1,port=6380,state=online,offset=140,lag=1 # 从机信息
slave1:ip=127.0.0.1,port=6381,state=online,offset=140,lag=1 # 从机信息
master_replid:b65a7bed5ff448f072d0cd8f41568b11f2f727b6
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:140
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:140
**注：**真实的配置是在配置文件中配置，这样是永久性的，上述配置是使用的命令操作（暂时的）。
- 配置文件配置
replicaof <masterip> <masterport> # 为从机配置主机的ip，port
masterauth <master-password> # 如果主机有密码，配置密码
测试
- 主机可以读写，从机只能读。
#### 操作主机
127.0.0.1:6379> keys * # 查看所有的key
(empty list or set)
127.0.0.1:6379> set k1 v1 # 写入数据
OK
127.0.0.1:6379> get k1 # 读取数据
"v1"
#### 操作从机
127.0.0.1:6380> get k1 # 读取数据
"v1"
127.0.0.1:6380>
127.0.0.1:6380> set k2 v2 # 写入数据失败
(error) READONLY You can't write against a read only replica.
- 主机挂掉之后，从机依然可以获取存储在redis上的数据。主机恢复之后，设置新的数据，从机依然可以获取新的数据。
#### 操作主机
127.0.0.1:6379> shutdown
not connected> exit
#### 操作从机
127.0.0.1:6380> get k1
"v1"
#### 操作主机
[root@VM-0-3-centos bin]# redis-server myconfig/redis-6379.conf
[root@VM-0-3-centos bin]# redis-cli -p 6379
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> set k3 v3
OK
#### 操作从机
127.0.0.1:6380> get k3
"v3"
- 如果是命令配置的主从复制，从机挂掉重启之后，自动变为主机。
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:6
master_sync_in_progress:0
slave_repl_offset:682
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:5ded83fba87e32e7ab24a9a5a4d967fd777df2b1
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:682
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:682
127.0.0.1:6380> SHUTDOWN # 关闭从机服务
not connected> exit # 退出
[root@VM-0-3-centos bin]# redis-server myconfig/redis-6380.conf # 启动redis服务
[root@VM-0-3-centos bin]# redis-cli -p 6380 # 启动客户端
127.0.0.1:6380> info replication # 查看从机信息
# Replication
role:master # 角色，变为主机
connected_slaves:0
master_replid:fbde80a8bb7e87a30a7198d80ca8a561b7a0ef47
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
复制原理：
Slave启动成功连接到master后会发送一个sync同步命令。
Master 接到命令，启动后台的存盘进程，同时收集所有接收到用于修改数据集命令，在后台进程执行完毕之后，master将传送整个数据文件到slave，并完成一次完全同步。
全量复制：Slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。
增量复制：Master继续将新的所有收集到的修改命令一次传给slave，完成同步。
但是只要从新连接master，一次完全同步（全量复制）将自动执行。
宕机后手动配置主机
如果入籍断开了连接，我们可以使用SLAVEOF no one让自己变为主机。
127.0.0.1:6381> SLAVEOF 127.0.0.1 6379 # 为从机配置主机
OK
127.0.0.1:6381> info replication # 查看从机信息
# Replication
role:slave # 角色
master_host:127.0.0.1 # 主机ip
master_port:6379 # 主机端口
master_link_status:up
master_last_io_seconds_ago:5
master_sync_in_progress:0
slave_repl_offset:366582
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:5ded83fba87e32e7ab24a9a5a4d967fd777df2b1
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:366582
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:366569
repl_backlog_histlen:14
127.0.0.1:6381> SLAVEOF no one # 解除从机的主机配置，自己变为主机
OK
127.0.0.1:6381> info replication # 查看信息
# Replication
role:master # 角色，主机
connected_slaves:0
master_replid:3886404ba505a720102979d1b36d53539d4ba83c
master_replid2:5ded83fba87e32e7ab24a9a5a4d967fd777df2b1
master_repl_offset:366596
second_repl_offset:366597
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:366569
repl_backlog_histlen:28
2.19 哨兵模式
概述
主从切换技术的方法是，当主服务器宕机后，需要手动把一台从服务器却换成主服务器，这需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。Redis从2.8开始正式提供了Sentinel（哨兵）架构来解决这个问题。
哨兵模式需要能够后台监控主机是否故障，如果故障了根据投票数自动将从库切换成主库。
哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行，其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控过多个Redis实例。
这里哨兵的作用：
- 通过命令，让Redis服务器返回监控器运行状态，包括主服务器和从服务器。
- 当哨兵检测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换从机。
然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各哨兵之间还会进行监控，这样就形成了多哨兵模式。
假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象称为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定的值时，那么哨兵之间就会进行一次投票，投票结果有一个哨兵发起，进行failover【故障转移】操作。切换成功后，会通过订阅发布模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程称为客观下线。
测试
目前服务状态一主（6379）二仆（6380，6381）
-
配置哨兵配置文件
# sentinel monitor host port sentinel monitor myredis 127.0.0.1 6379 1后面的这个数字1，代表主机挂了，slave投票看让谁接替称为主机，票数最多的，就会称为主机。
-
启动哨兵
[root@VM-0-3-centos bin]# redis-sentinel myconfig/sentinel.conf 10093:X 30 Aug 2020 15:09:29.902 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo 10093:X 30 Aug 2020 15:09:29.902 # Redis version=5.0.7, bits=64, commit=00000000, modified=0, pid=10093, just started 10093:X 30 Aug 2020 15:09:29.902 # Configuration loaded _._ _.-``__ ''-._ _.-`` `. `_. ''-._ Redis 5.0.7 (00000000/0) 64 bit .-`` .-```. ```\/ _.,_ ''-._ ( ' , .-` | `, ) Running in sentinel mode |`-._`-...-` __...-.``-._|'` _.-'| Port: 26379 | `-._ `._ / _.-' | PID: 10093 `-._ `-._ `-./ _.-' _.-' |`-._`-._ `-.__.-' _.-'_.-'| | `-._`-._ _.-'_.-' | http://redis.io `-._ `-._`-.__.-'_.-' _.-' |`-._`-._ `-.__.-' _.-'_.-'| | `-._`-._ _.-'_.-' | `-._ `-._`-.__.-'_.-' _.-' `-._ `-.__.-' _.-' `-._ _.-' `-.__.-' 10093:X 30 Aug 2020 15:09:29.903 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128. 10093:X 30 Aug 2020 15:09:29.916 # Sentinel ID is 1b28d8339b6e3aae90ff663f35677ff17de30b4e 10093:X 30 Aug 2020 15:09:29.916 # +monitor master myredis 127.0.0.1 6379 quorum 1 10093:X 30 Aug 2020 15:09:29.917 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:09:29.927 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379如果Master节点断开之后，这时候会从从机中选出一个服务。
10093:X 30 Aug 2020 15:13:17.595 # +sdown master myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:17.595 # +odown master myredis 127.0.0.1 6379 #quorum 1/1 10093:X 30 Aug 2020 15:13:17.595 # +new-epoch 1 10093:X 30 Aug 2020 15:13:17.595 # +try-failover master myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:17.602 # +vote-for-leader 1b28d8339b6e3aae90ff663f35677ff17de30b4e 1 10093:X 30 Aug 2020 15:13:17.602 # +elected-leader master myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:17.602 # +failover-state-select-slave master myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:17.679 # +selected-slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:17.679 * +failover-state-send-slaveof-noone slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:17.741 * +failover-state-wait-promotion slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:18.543 # +promoted-slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:18.543 # +failover-state-reconf-slaves master myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:18.590 * +slave-reconf-sent slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:19.629 * +slave-reconf-inprog slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:19.629 * +slave-reconf-done slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:19.694 # +failover-end master myredis 127.0.0.1 6379 10093:X 30 Aug 2020 15:13:19.694 # +switch-master myredis 127.0.0.1 6379 127.0.0.1 6381 10093:X 30 Aug 2020 15:13:19.694 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6381 10093:X 30 Aug 2020 15:13:19.694 * +slave slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6381当断掉的从机从新恢复服务，只能归并到新的主机下，当作从机，这就是哨兵模式的规则。
10093:X 30 Aug 2020 15:18:00.662 # -sdown slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6381 10093:X 30 Aug 2020 15:18:10.632 * +convert-to-slave slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6381
优点、缺点
优点：
- 哨兵集群，基于主从复制模式，所有的主从配置优点，它都有。
- 主从可以切换，故障可以以转移，系统可用行就会更好。
- 哨兵模式就是主从模式的升级，手动到自动，更加健壮。
缺点：
- Redis不好在线扩容，集群容量一旦达到上限，在线扩容就十分麻烦。
- 实现哨兵模式的配置起始十分麻烦，里面有很多选择。
哨兵模式的全部配置
# Example sentinel.conf
# 哨兵sentinel实例运行的短空 默认26379
port 26379
# 守护进程
daemonize yes
# 进程文件目录
pidfile /var/run/redis-sentinel.pid
# 日志文件目录
logfile /var/log/sentinel.log
# 哨兵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 myredis 127.0.0.1 6379 2
# 当Redis实例中开启requirepass foobared 授权密码 这样所有连接Redis的客户端都要提供密码
# 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster MYSUPER--secret-0123password
# 指定多少毫秒之后，主机节点没有应答哨兵sentinel此时 哨兵主管上任务主节点下线 默认30s
# 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实例的主观失效和客观失效等），将会去掉这个脚本，这时这个脚本应该通过邮件，SM5等方式去通知系统管理员关于系统不正常运行的信息，调用该脚本时，将传给脚本两个参数，一个是事件的类型，不是事件的而描述，如果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-prot> <to-ip> <to-prot>
# 目前<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/reids/reconfig.sh
2.20 缓存穿透和雪崩
Redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面，但同时，它也得来了一些问题。其中最要害的问题，就是数据的一致性问题，从严格以一场来讲，这个问题无解。如果对数据的一致性要求很高，那么就不能使用缓存。
另外的一些典型问题就是，缓存穿透，缓存雪崩和缓存击穿。目前业界也有比较流行的解决方案。
缓存穿透-概念
缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据查询，发现也没有，于是本次查询失败。当用户很多时，于是都去请求持久层的数据库，这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。
缓存穿透-解决方案
布隆过滤器：
布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免对底层存储系统的查询压力。
缓存空对象：
当存储层不命中后，即时返回的空对象也将其缓存起来，同时设置一个过期时间，之后再访问这个数据会从缓存中获取，保护了服务端数据库。
但是这种方法也会存在两个问题：
- 如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能有很多的空值的键。
- 即使对空值设置了过期时间，还会存在缓存层和存储层的数据会有一段时间的不一致，对于需要保持一致性的业务会有影响。
缓存击穿-概述
这个需要注意跟缓存穿透的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就会穿透缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。
当这个key在过期的瞬间，有大量的请求并发访问，这类数据一定是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，导致数据库瞬间压力过大。
缓存击穿-解决方案
设置热点数据永不过期
从缓存层面来看，没有设置过期时间，所以不会出现热点key过期后产生的问题。
加互斥锁
分布式锁：使用分布式锁，保证对于每个key只有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待时间。这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大。
缓存雪崩-概念
缓存雪崩，是指在某一个时间端，缓存集中过期失效。
差生雪崩的原因之一，比如双十一抢购，这段时间会集中将抢购商品放入缓存，假设缓存一个小时。那么到了缓存结束时间，这批商品的缓存就过期了，而对这批商品的访问查询都落到了数据库上，对于数据库而言，就会产生周期型压力波峰。于是所有的请求都会达到存储层，存储层的调用量会暴增，早曾存储层页会挂掉。
起始集中过期，倒也不是非常致命，比较致命的缓存雪崩，是缓存服务器某个节点宕机或断网。因为自然而成的缓存雪崩，一定是在某个时间端集中创建缓存，这个时候，数据库也是可以顶住压力的，无非就是对数据库产生周期性的压力而已。而缓存服务器节点的宕机，对数据库产生的压力是不可预估的，很有可能瞬间就把数据库压垮。
缓存雪崩-解决方案
reids高可用：
这个思想是，既然redis有可能挂掉，那就多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。
限流降级：
这个解决方案的思想是，在缓存失败后，通过枷锁或者队列来控制读数据库写缓存的线程数据量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。
数据预热：
数据加热的含义就是在正式部署之前，我们先把可能的数据先预先访问一边，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效时间尽量均匀。
1810
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
