NoSql之Redis详细笔记

分手后的思念是犯贱 2022-09-03 10:25 203阅读 0赞

>  所有牛逼的人都有一段苦逼的岁月，但是你只要像傻逼一样的去坚持，终将牛逼

# NoSQL #

## NoSQL ##

### 什么是NoSQl ###

> #### NoSQL ####

NoSQL = Not Only SQL （不仅仅是SQL）

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

反之非关系型数据库的，随着web2.0互联网的诞生！传统的关系型数据库很难对付web2.0时代！尤其是超大规模的高并发的社区！暴露出来很多难以克服的问题，NoSQL在当今大数据环境下发展的十分迅速，Redis是发展最快的，而且是我们当下必须掌握的一个技术

> #### 为什么要用NoSQL ####

用户的个人信息，社交网络，地理位置。用户自己产生的数据，用户日志等等爆发式增长

这时候我们就需要使用NoSQL数据库，NoSQL可以很好地处理以上的情况！

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

> #### NoSQL特点 ####

1.  方便扩展（数据之间没有关系，很好扩展！）
2.  大数据量高性能（Redis一秒写8万次，读取11万次，NoSQL的缓存记录级，是一种细粒度的缓存，性能较高）
3.  数据类型是多样型的！（不需要事先设计数据库！随取随用！如果是数据库量十分大的一些表，很多人就无法设计了）
4.  传统的 RDBMS 和 NoSQL

传统的RDBMS
    - 结构化阻止
    - SQL
    - 数据可关系都存在单独的表中
    - 操作语言，数据定义语言
    - 严格的一致性（ACID原则）
    - 基础的事务
    - ……

NoSQL
    - 不仅仅是数据
    - 没有固定的查询语言
    - 键值对存储，列存储，文档存储，图形数据库（社交关系）
    - 最终一致性
    - CAP定理 和BASE 理论 （异地多活！）初级架构师
    - 高性能，高可用，高扩展
    - ……

> #### 了解： 3V + 3高 ####

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

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

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

1.  高并发
2.  高可拓（随时水平拆分，机器不够了，可以扩展机器来结局）
3.  高性能（保证用户体验和性能！）

真正在公司中的实践：NoSQL + RDBMS 一起使用才是最强的，阿里巴巴架构演进！

### 阿里巴巴演进分析 ###

开源才是技术的王道！

任何一家互联网的公司，都不可能只是简简单单让用户能用就好了

大量公司做的都是相同的业务；（竞品协议）

随着这样的竞争，业务是越来越完善，然后对开发者的要求也是越来越高！

高中，大一开始就应该是认真的学习了！

![image-20200402131447566][]

如果你未来相当一个架构师：没有什么是加一层解决不了的

# 1、商品的基本信息
        名称、价格、商家信息；
        关系型数据库就可以解决了！MySQL / Oracle （淘宝早年就去IOE了！-王坚：推荐文章：阿里云的这群疯子）
        淘宝内部的MySQL 不是大家用的 MySQL
        
    # 2、商品的描述、评论（文字较多）
    	文档型数据库中，MongoDB
    	
    # 3、图片
        分布式文件系统 FastDFS
        - 淘宝自己的 TFS
        - Google的 GFS
        - Hadoop HDFS
        - 阿里云的 OSS
        
    # 4、商品的关键字（搜索）
    	- 搜索引擎 solr elasticsearch
    	- ISerach：多隆
    
    # 5、商品热门的波段信息(秒杀)
    	- 内存数据库
    	- Redis Tair Memacahe
    	
    # 6、商品的交易，外部的支付接口
    	- 三方应用

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

大型互联网应用问题：

*  数据类型过多！
 *  数据源繁多，经常重构！
 *  数据要改造，就需要大面积改造

数据层解决方案：

![image-20200402190721284][]

数据层热点缓存设计：

![image-20200402190904970][]

--------------------

这以上都是NoSQL入门概述，不仅能够提高大家的知识，还可以帮助大家了解大厂的工作内容！

--------------------

### NoSQL的四大分类 ###

**KV键值对：**

*  新浪：Redis
 *  美团：Redis + Tair
 *  阿里、百度：Redis + Memecache

**文档型数据库(bson格式和json一样)：**

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

**列存储数据库：**

*  HBase
 *  分布式文件系统

**图关系数据库：**

![image-20200402191949463][]

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

> #### 四者对比！ ####

![image-20200402193637280][]

# Redis入门 #

### 概述 ###

> #### Redis 是什么？ ####

Redis(Remote Dictionary Server)，即远程字典服务

是一个开源的使用ANSI [C语言][C]编写、支持网络、可基于内存亦可持久化的日志型、Key-Value[数据库][Link 1]，并提供多种语言的API。

![image-20200402195250646][]

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

Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

> #### Redis 能干什么？ ####

1.  内存存储、持久化，内存是断电即失，所以说持久化很重要(RDB、AOF)
2.  效率高，可以用于高速缓存
3.  发布订阅系统(简单的消息队列)
4.  地图信息分析
5.  计时器、计数器(浏览量！)
6.  ……

> #### 特性 ####

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

> #### 学习中需要用到的东西 ####

1.  官网：https://redis.io
2.  中文网：https://redis.cn
3.  下载地址：

![image-20200402195855846][]

注意：Windows在GitHub上下载(但官方不推荐，支持Linux下载)

### Windows安装 ###

1.  下载地址：https://github.com/MicrosoftArchive/redis/releases
2.  解压到本地环境!![image-20200402201609864][]
3.  开启Redis，双击运行服务即可![image-20200402201543037][]![image-20200402201451838][]
4.  使用Redis客户端来连接Redis![image-20200402201631638][]![image-20200402201643405][]
5.  使用Redis客户端来连接Redis![image-20200402202020844][]

Windows下使用确实简单，但是Redis推荐我们使用Linux去进行开发

![image-20200402202247813][]

### Linux安装 ###

1.  下载安装包 *redis-5.0.8.tar.gz*
2.  解压Redis的安装包![image-20200402203403332][]
3.  进入解压后的文件，可以看到我们Redis的配置文件![image-20200402203522749][]
4.  基本的环境安装
    
        yum install gcc-c++
        make
    
    ![image-20200402204426009][]
5.  Redis的默认安装路径 `usr/local/bin`![image-20200402205104784][]
6.  将Redis配置文件复制到我们当前目录下
    
    ![image-20200402205355432][]
7.  Redis默认不是后台启动的![image-20200402205550679][]
8.  启动Redis服务
    
    ![image-20200402205755325][]
9.  使用redis-cli进行连接测试
    
    ![image-20200402210127468][]
10. 查看Redis的进程是否开启![image-20200402210326257][]
11. 如何关闭Redis服务？![image-20200402210510440][]
12. 再次查看进程是否存在![image-20200402210544518][]
13. 后面我们会使用单机多Redis启动集群测试

### 测试性能 ###

**redis-benchmark**是一个压力测试工具！

官方自带的性能测试工具！

redis-benchmark 命令参数

![image-20200402210921482][]

我们来简单测试下

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

测试结果：

![image-20200402211455515][]

查看分析

![image-20200402211937356][]

### 基础的知识 ###

Redis默认有16个数据库

![image-20200402212210411][]

默认使用第0个

可以使用select进行数据库切换

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

![image-20200402212530494][]

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

清除当前数据库 `flushdb`

清空全部数据库的内容 `flushall`

127.0.0.1:6379[3]> flushdb	
    OK
    127.0.0.1:6379[3]> keys *
    (empty list or set)

> #### Redis是单线程的 ####

明白Redis是很快的，官方表示，Redis是基于内存操作的，CPU不是Redis性能瓶颈，Redis的瓶颈是根据及其的带宽，既然可以使用单线程来实现，就是用单线程了！所以就使用了单线程

Redis是C语言写的，官方提供的数据为 10W+ 的QPS，完全不必同样是使用key-value的Memecache差！

**Redis为什么单线程还这么块？**

1.  误区1：高性能的服务器一定是多线程的？
2.  误区2：多线程(CPU上下文会切换！)一定比单线程效率高？
    
    线程速度：CPU > 内存 > 硬盘

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

# 五大数据类型 #

> #### 官方文档 ####

![image-20200403110953549][]

**全段翻译：**

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

> #### 所有命令一定要全部记住，后面使用SpringBoot，Jedis，所有的方法就是这些命令 ####

## Redis-Key ##

127.0.0.1:6379> keys *	# 查看所有的key
    (empty list or set)
    127.0.0.1:6379> set name zhuangb1	# set key
    OK
    127.0.0.1:6379> set age 1
    OK
    127.0.0.1:6379> keys *
    1) "age"
    2) "name"
    127.0.0.1:6379> exists name	# 判断当前的key是否存在
    (integer) 1
    127.0.0.1:6379> exists name1
    (integer) 0
    127.0.0.1:6379> move name 1	# 移除当前的key
    (integer) 1
    127.0.0.1:6379> keys *
    1) "age"
    127.0.0.1:6379> set name zhuangb1
    OK
    127.0.0.1:6379> keys *
    1) "age"
    2) "name"
    127.0.0.1:6379> get name
    "zhuangb1"
    127.0.0.1:6379> 
    127.0.0.1:6379> expire name 10	# 设置key的过期时间---单点登录
    (integer) 1
    127.0.0.1:6379> ttl name	# 查看当前key的剩余时间
    (integer) 3
    127.0.0.1:6379> ttl name
    (integer) -2
    127.0.0.1:6379> ttl name
    (integer) -2
    127.0.0.1:6379> get name
    (nil)
    127.0.0.1:6379> type name	# 查看当前key的类型
    string
    127.0.0.1:6379> type age
    string

后面如果遇到不会的命令，可以在官网查看帮助文档

![image-20200403112450309][]

## String ##

90% 的Java程序员使用Redis只会使用一个String类型！

#######################################################################
    127.0.0.1:6379> set key1 v1	# 设置值
    OK
    127.0.0.1:6379> get key1	# 获得值
    "v1"
    127.0.0.1:6379> keys *		# 获取所有的可以
    1) "key1"
    127.0.0.1:6379> exists key1		# 查看某一个key是否存在
    (integer) 1
    127.0.0.1:6379> append key1 "hello"	# 追加字符串 如果当前key不存在，就相当于set key
    (integer) 7
    127.0.0.1:6379> get key1	
    "v1hello"
    127.0.0.1:6379> strlen key1	# 获取字符串长度
    (integer) 7
    127.0.0.1:6379> append key1 ",zhuangb1"
    (integer) 16
    127.0.0.1:6379> get key1
    "v1hello,zhuangb1"
    
    #######################################################################
    # 步长 i +=
    127.0.0.1:6379> set views 0	# 设置初始值为0
    OK
    127.0.0.1:6379> get views
    "0"
    127.0.0.1:6379> incr views	# 自增1
    (integer) 1
    127.0.0.1:6379> incr views
    (integer) 2
    127.0.0.1:6379> get views
    "2"
    127.0.0.1:6379> decr views	# 自减1
    (integer) 1
    127.0.0.1:6379> decr views
    (integer) 0
    127.0.0.1:6379> decr views
    (integer) -1
    127.0.0.1:6379> get views
    "-1"
    127.0.0.1:6379> incrby views 10	# 设置步长 指定增量
    (integer) 9
    127.0.0.1:6379> incrby views 10
    (integer) 19
    127.0.0.1:6379> decrby views 5	# 设置步长 指定减量
    (integer) 14
    
    #######################################################################
    # 字符串 range
    127.0.0.1:6379> set key1 "hello,zhuangb1"	# 设置key1的值
    OK
    127.0.0.1:6379> get key1
    "hello,zhuangb1"
    127.0.0.1:6379> getrange key1 0 3	# 截取字符串(substring)
    "hell"
    127.0.0.1:6379> getrange key1 0 -1	# 获取全部的字符串
    "hello,zhuangb1"
    
    # 替换
    127.0.0.1:6379> set key2 abcdefg
    OK
    127.0.0.1:6379> get key2
    "abcdefg"
    127.0.0.1:6379> setrange key2 1 xx	# 替换指定位置开始的字符串
    (integer) 7
    127.0.0.1:6379> get key2
    "axxdefg"
    
    
    #######################################################################
    # setex(set with expire) # 设置过期时间 
    # setnx(set if not exists) # 不存在再设置(分布式锁中会常用)
    
    127.0.0.1:6379> setex key3 30 "hello"	# 设置key3 的值为hello，30秒后过期
    OK
    127.0.0.1:6379> ttl key3
    (integer) 26
    127.0.0.1:6379> get key3
    "hello"
    127.0.0.1:6379> setnx mykey redis	# 如果不存在，创建mykey
    (integer) 1
    127.0.0.1:6379> keys *
    1) "key2"
    2) "key1"
    3) "mykey"
    127.0.0.1:6379> ttl key3
    (integer) -2
    127.0.0.1:6379> setnx mykey "MongoDB"	# 如果mykey存在，则创建失败
    (integer) 0
    127.0.0.1:6379> get mykey
    "redis"
    
    #######################################################################
    # 批量插入 mset
    # 批量获取 mget
    127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3	# 同时设置多个值
    OK
    127.0.0.1:6379> keys *
    1) "k3"
    2) "k2"
    3) "k1"
    127.0.0.1:6379> mget k1 k2 k3	# 同时获取多个值
    1) "v1"
    2) "v2"
    3) "v3"
    127.0.0.1:6379> msetnx k1 v1 k4 v4	# msetnx 是一个原子性的操作
    (integer) 0
    127.0.0.1:6379> get k4
    (nil)
    
    # 对象
    set user:1{ name:zhangsan,age:3}	# 设置一个user:1 对象 值为一个json 来保存一个对象
    
    # 这里的key是一个巧妙地设置 user:{id}:{filed}，如此设置在Redis是完全可以的
    
    127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
    OK
    127.0.0.1:6379> mget user:1:name user:1:age
    1) "zhangsan"
    2) "2"
    
    #######################################################################
    getset # 先get然后再set
    
    127.0.0.1:6379> getset db redis	# 如果不存在值，则返回null
    (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除了是字符串还可以是数字

*  计数器
 *  统计多单位数量
 *  对象缓存存储
 *  【点赞关注】

## List ##

基本的数据类型，列表

![image-20200403115921930][]

在Redis里面，我们可以把list当做：栈、队列、阻塞队列！

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

Redis命令不区分大小写

#######################################################################
    127.0.0.1:6379> lpush list one	# 将一个或多个值插入到列表的头部
    (integer) 1
    127.0.0.1:6379> lpush list two
    (integer) 2
    127.0.0.1:6379> lpush list three
    (integer) 3
    127.0.0.1:6379> lrange list 0 -1	# 获取list中所有的值
    1) "three"
    2) "two"
    3) "one"
    127.0.0.1:6379> lrange list 0 1		# 通过区间获取具体的值
    1) "three"
    2) "two"
    127.0.0.1:6379> lrange list 0 0
    1) "three"
    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	# 移除list的第一个元素
    "three"
    127.0.0.1:6379> rpop list	# 移除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 1
    "one"
    127.0.0.1:6379> lindex list 0
    "two"
    
    #######################################################################
    # llen 返回指定列表的长度
    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> llen list
    (integer) 3
    
    #######################################################################
    # 移除指定的值 取关
    # 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 1 three
    (integer) 1
    127.0.0.1:6379> lrange list 0 -1
    1) "three"
    2) "two"
    127.0.0.1:6379> lpush list three
    (integer) 3
    127.0.0.1:6379> lrem list 2 three
    (integer) 2
    127.0.0.1:6379> lrange list 0 -1
    1) "two"
    127.0.0.1:6379> 
    
    #######################################################################
    # trim去除两边空格 list截断
    127.0.0.1:6379> keys *
    (empty list or set)
    127.0.0.1:6379> rpush mylist "hello"
    (integer) 1
    127.0.0.1:6379> rpush mylist "hello1"
    (integer) 2
    127.0.0.1:6379> rpush mylist "hello2"
    (integer) 3
    127.0.0.1:6379> rpush 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) "hello1"
    2) "hello2"
    
    #######################################################################
    # rpoplpush 移除列表的最后一个元素并将它移动到新的列表中
    127.0.0.1:6379> rpush mylist "hello"
    (integer) 1
    127.0.0.1:6379> rpush mylist "hello1"
    (integer) 2
    127.0.0.1:6379> rpush mylist "hello2"
    (integer) 3
    127.0.0.1:6379> rpoplpush mylist myotherlist
    "hello2"
    127.0.0.1:6379> lrange mylist 0 -1	# 查看原来的列表
    1) "hello"
    2) "hello1"
    127.0.0.1:6379> lrange myotherlist 0 -1	# 查看目标列表，确实存在该值
    1) "hello2"
    
    #######################################################################
    # lset 将列表中指定下标的值替换为另外一个值(update)
    127.0.0.1:6379> exists list	# 判断该列表是否存在
    (integer) 0
    127.0.0.1:6379> lset list 0 item	# 如果不存在该列表依然去更新就会报错
    (error) ERR no such key
    127.0.0.1:6379> lpush list value1
    (integer) 1
    127.0.0.1:6379> lrange list 0 0
    1) "value1"
    127.0.0.1:6379> lset list 0 item	# 如果存在，更新当前下标的值
    OK
    127.0.0.1:6379> lrange list 0 0
    1) "item"
    127.0.0.1:6379> lset list 1 ohter	# 如果不存在则会报错
    (error) ERR index out of range
    
    #######################################################################
    # linsert 将某个具体的value 插入到列表中某个元素的前面或者后面
    127.0.0.1:6379> rpush mylist "hello"
    (integer) 1
    127.0.0.1:6379> rpush mylist "world"
    (integer) 2
    127.0.0.1:6379> linsert mylist before "world" "other"
    (integer) 3
    127.0.0.1:6379> lrange mylist 0 -1
    1) "hello"
    2) "other"
    3) "world"
    127.0.0.1:6379> linsert mylist after world new
    (integer) 4
    127.0.0.1:6379> lrange mylist 0 -1
    1) "hello"
    2) "other"
    3) "world"
    4) "new"

> #### 小结 ####

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

消息排队！消息队列！队列(lpush rpop) 栈(lpush lpop)

## Set ##

**set中的值不能重复**

#######################################################################
    127.0.0.1:6379> sadd myset hello	# set集合中添加元素
    (integer) 1
    127.0.0.1:6379> sadd myset zhuangb1
    (integer) 1
    127.0.0.1:6379> sadd myset lovezhuangb1
    (integer) 1
    127.0.0.1:6379> smembers myset	# 查看指定set的所有值
    1) "lovezhuangb1"
    2) "zhuangb1"
    3) "hello"
    127.0.0.1:6379> sismember myset hello	# 判断某一个值是否在set中
    (integer) 1
    127.0.0.1:6379> sismember myset world
    (integer) 0
    
    #######################################################################
    # scard
    127.0.0.1:6379> scard myset	# 获取set集合中的内容元素个数
    (integer) 4
    
    #######################################################################
    # 移除set中的某个元素 rem
    127.0.0.1:6379> srem myset hello
    (integer) 1
    127.0.0.1:6379> scard myset
    (integer) 3
    127.0.0.1:6379> smembers myset
    1) "lovezhuangb1"
    2) "zhuangb1"
    3) "lovezhuangb2"
    127.0.0.1:6379> 
    
    #######################################################################
    # set 无需不重复集合：抽随机！
    127.0.0.1:6379> SRANDMEMBER myset	# 随机抽选出一个元素
    "lovezhuangb1"
    127.0.0.1:6379> SRANDMEMBER myset
    "lovezhuangb1"
    127.0.0.1:6379> SRANDMEMBER myset
    "lovezhuangb2"
    127.0.0.1:6379> SRANDMEMBER myset 2	# 随机抽选出指定个数的元素
    1) "zhuangb1"
    2) "lovezhuangb1"
    
    #######################################################################
    # 删除指定的key，随机删除
    127.0.0.1:6379> SMEMBERS myset
    1) "lovezhuangb1"
    2) "zhuangb1"
    3) "lovezhuangb2"
    127.0.0.1:6379> spop myset	# 随机删除set中的某个元素
    "zhuangb1"
    127.0.0.1:6379> spop myset
    "lovezhuangb2"
    127.0.0.1:6379> spop myset
    "lovezhuangb1"
    127.0.0.1:6379> 
    
    #######################################################################
    # 将一个指定的值，移动到另一个set集合！
    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 zhuangb1
    (integer) 1
    127.0.0.1:6379> sadd myset2 set2
    (integer) 1
    127.0.0.1:6379> smove myset myset2 zhuangb1	# 将一个指定的值，移动到另一个set集合中
    (integer) 1
    127.0.0.1:6379> SMEMBERS myset
    1) "world"
    2) "hello"
    127.0.0.1:6379> SMEMBERS myset2
    1) "zhuangb1"
    2) "set2"
    
    #######################################################################
    # 微博，B站，共同关注(并集)
    # 数字集合类：
    # - 差集
    # - 并集
    # - 交集
    127.0.0.1:6379> sadd key1 a
    (integer) 1
    127.0.0.1:6379> sadd key1 b
    (integer) 1
    127.0.0.1:6379> sadd key1 c
    (integer) 1
    127.0.0.1:6379> sadd key2 c
    (integer) 1
    127.0.0.1:6379> sadd key2 d
    (integer) 1
    127.0.0.1:6379> sadd key2 e
    (integer) 1
    127.0.0.1:6379> SDIFF key1 key2	# 差集
    1) "a"
    2) "b"
    127.0.0.1:6379> SINTER key1 key2	# 交集 共同好友
    1) "c"
    127.0.0.1:6379> SUNION key1 key2	# 并集
    1) "a"
    2) "b"
    3) "c"
    4) "d"
    5) "e"

共同关注，共同爱好，二度好友，推荐好友！(六度分割理论)

## Hash ##

Map集合，key-map！这个值是一个map集合！本质和String类型没有太大区别，还是一个简单的key-value！

set myhash field zhuangb1

127.0.0.1:6379> HSET myhash field1 zhaungb1	# set一个具体 key-value
    (integer) 1
    127.0.0.1:6379> HGET myhash field1	# 获取一个字段值
    "zhaungb1"
    127.0.0.1:6379> HMSET myhash field1 hello field2 world	# set 多个 key-value
    OK
    127.0.0.1:6379> HMGET myhash field1 field2	# 获取多个字段值
    1) "hello"
    2) "world"
    127.0.0.1:6379> HGETALL myhash	# 获取全部的数据
    1) "field1"
    2) "hello"
    3) "field2"
    4) "world"
    127.0.0.1:6379> HDEL myhash field1	# 删除hash指定key字段！对应的value值也就消失了
    (integer) 1
    127.0.0.1:6379> HGETALL myhash
    1) "field2"
    2) "world"
    
    #######################################################################
    # hlen
    127.0.0.1:6379> HMSET myhash field1 hello field2 world
    OK
    127.0.0.1:6379> HGETALL myhash
    1) "field2"
    2) "world"
    3) "field1"
    4) "hello"
    127.0.0.1:6379> HLEN myhash	# 获取hash表的字段数量
    (integer) 2
    
    #######################################################################
    127.0.0.1:6379> HEXISTS myhash field1	# 判断hash中指定字段是否存在
    (integer) 1
    127.0.0.1:6379> HEXISTS myhash field3
    (integer) 0
    
    #######################################################################
    # 只获得所有的key
    # 只获得所有的value
    127.0.0.1:6379> HKEYS myhash
    1) "field2"
    2) "field1"
    127.0.0.1:6379> HVALS myhash
    1) "world"
    2) "hello"
    
    #######################################################################
    127.0.0.1:6379> HSET myhash field3 5
    (integer) 1
    127.0.0.1:6379> HINCRBY myhash field3 1	# 指定增量
    (integer) 6
    127.0.0.1:6379> HINCRBY myhash field3 -1
    (integer) 5
    127.0.0.1:6379> HSETNX myhash field4 hello	# 判断是否存在，如果存在则可以设置
    (integer) 1
    127.0.0.1:6379> HSETNX myhash field4 world
    (integer) 0

哈希更适合对象存储，String更加适合字符串存储

## Zset ##

在set的基础上，增加了一个值

127.0.0.1:6379> ZADD myset 1 one	# 添加一个值
    (integer) 1
    127.0.0.1:6379> ZADD myset 2 two 3 three	# 添加多个值
    (integer) 2
    127.0.0.1:6379> ZRANGE myset 0 -1
    1) "one"
    2) "two"
    3) "three"
    
    #######################################################################
    127.0.0.1:6379> ZADD salary 2500 xiaohong 	# 添加两个用户 
    (integer) 1
    127.0.0.1:6379> ZADD salary 5000 zhangsan
    (integer) 1
    127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf	# 显示全部的用户，后面参数由负无穷到正无穷从小到大排序
    1) "xiaohong"
    2) "zhangsan"
    127.0.0.1:6379> ZREVRANGE salary 0 -1	# 将上面的结果反过来
    1) "zhangsan"
    127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores	# 显示全部的用户并附带成绩
    1) "xiaohong"
    2) "2500"
    3) "zhangsan"
    4) "5000"
    127.0.0.1:6379> ZRANGEBYSCORE salary -inf 3000  withscores	# 显示工资小于300的员工，升序排列
    1) "xiaohong"
    2) "2500"
    
    #######################################################################
    移除rem中的元素
    127.0.0.1:6379> ZRANGE salary 0 -1
    1) "xiaohong"
    2) "zhangsan"
    127.0.0.1:6379> ZREM salary xiaohong	# 移除有序集合中的指定元素
    (integer) 1
    127.0.0.1:6379> ZRANGE salary 0 -1
    1) "zhangsan"
    127.0.0.1:6379> ZCARD salary	# 获取zset中的个数
    (integer) 1
    
    #######################################################################
    127.0.0.1:6379> ZADD myset 1 hello
    (integer) 1
    127.0.0.1:6379> ZADD myset 2 world 3 zhuangb1
    (integer) 2
    127.0.0.1:6379> ZCOUNT myset 1 3	# 获取指定区间的成员数量
    (integer) 3

# 三种特殊数据类型 #

## geospatial地理位置 ##

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

Redis的GEO 可以推算地理位置的信息，两地之间的距离，方圆几里的人

只有六个命令

![image-20200403205908072][]

**官方文档：https://www.redis.net.cn/order/3685.html**

> #### GEOADD 命令 - 将指定的地理空间位置（纬度、经度、名称）添加到指定的key中 ####

# geoadd 添加地理位置
    # 规则：两级无法直接添加，我们一般会下载城市数据，通过java程序导入
    # 参数 key 值(维度、经度、名称)
    ## 有效的经度从-180度到180度。
    ## 有效的纬度从-85.05112878度到85.05112878度。
    ## 当坐标位置超出上述指定范围时，该命令将会返回一个错误。
    127.0.0.1:6379> geoadd china:city 116.405285 39.904989 beijing
    (integer) 1
    127.0.0.1:6379> geoadd china:city 121.472644 31.231706 shanghai
    (integer) 1
    127.0.0.1:6379> geoadd china:city 106.504962 29.533155 chongqing
    (integer) 1
    127.0.0.1:6379> geoadd china:city 114.085947 22.547 shenzhen
    (integer) 1
    127.0.0.1:6379> geoadd china:city 120.153576 30.287459 hangzhou 108.948024 34.263161 xiaan
    (integer) 2

> #### GEOPOS 命令 - 从key里返回所有给定位置元素的位置（经度和纬度） ####

获得当前定位：一定是一个坐标值

127.0.0.1:6379> GEOPOS china:city beijing	# 获取指定城市经纬度
    1) 1) "116.40528291463851929"
       2) "39.9049884229125027"
    127.0.0.1:6379> GEOPOS china:city chongqing
    1) 1) "106.50495976209640503"
       2) "29.53315530684997015"

> #### GEODIST 命令 - 返回两个给定位置之间的距离 ####

两人之间距离

指定单位的参数 unit 必须是以下单位的其中一个：

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

127.0.0.1:6379> GEODIST china:city beijing shanghai km	# 查看直线距离 单位 km
    "1067.5980"
    127.0.0.1:6379> GEODIST china:city beijing chongqing km
    "1464.2210"

> #### GEORADIUS 命令 - 以给定的经纬度为中心， 找出某一半径内的元素 ####

附近的人？(获取所有附近人的地址，定位！)通过半径来查询

所有数据都应该录入china:city，才会让结果更加清晰

127.0.0.1:6379> GEORADIUS china:city 110 30 1000 km	# 以110 30 为中心，寻找房源 1000km内的城市
    1) "chongqing"
    2) "xiaan"
    3) "shenzhen"
    4) "hangzhou"
    127.0.0.1:6379> GEORADIUS china:city 110 30 500 km
    1) "chongqing"
    2) "xiaan"
    127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist	# 显示到中间距离的位置
    1) 1) "chongqing"
       2) "341.4052"
    2) 1) "xiaan"
       2) "484.4073"
    127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withcoord	# 显示他人的位置信息
    1) 1) "chongqing"
       2) 1) "106.50495976209640503"
          2) "29.53315530684997015"
    2) 1) "xiaan"
       2) 1) "108.94802302122116089"
          2) "34.2631604414749944"
    127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist withcoord count 1	# 筛选出指定的结果
    1) 1) "chongqing"
       2) "341.4052"
       3) 1) "106.50495976209640503"
          2) "29.53315530684997015"

> #### GEORADIUSBYMEMBER 命令 - 找出位于指定范围内的元素，中心点是由给定的位置元素决定 ####

127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijing 1000 km
    1) "beijing"
    2) "xiaan"
    127.0.0.1:6379> GEORADIUSBYMEMBER china:city shanghai 400 km
    1) "hangzhou"
    2) "shanghai"

> #### GEOHASH 命令 - 返回一个或多个位置元素的 Geohash 表示 ####

该命令将返回11个字符的Geohash字符串

# 将二维的经纬度转换成一维的字符串，两个字符串越接近，距离越相近
    127.0.0.1:6379> GEOHASH china:city beijing chongqing
    1) "wx4g0b7xrt0"
    2) "wm78p86e170"

> #### GEO底层的实现原理起始就是Zset，我们可以使用Zset的命令来操作GEO ####

127.0.0.1:6379> ZRANGE china:city 0 -1	# 查看地图中的全部元素
    1) "chongqing"
    2) "xiaan"
    3) "shenzhen"
    4) "hangzhou"
    5) "shanghai"
    6) "beijing"
    127.0.0.1:6379> ZREM china:city beijing	# 移除一个元素
    (integer) 1
    127.0.0.1:6379> ZRANGE china:city 0 -1
    1) "chongqing"
    2) "xiaan"
    3) "shenzhen"
    4) "hangzhou"
    5) "shanghai"

## hyperloglog ##

> #### 什么是基数？ ####

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

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

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

> #### 简介 ####

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 make a b c d e f g h i j 	# 创建第一组元素 make
    (integer) 1
    127.0.0.1:6379> PFCOUNT make	# 统计元素基数数量
    (integer) 10
    127.0.0.1:6379> PFADD make2 i j z x c v b n m	# 创建make2
    (integer) 1
    127.0.0.1:6379> PFCOUNT make2
    (integer) 9
    127.0.0.1:6379> PFMERGE make3 make make2	# 合并 make make2 => make3
    OK
    127.0.0.1:6379> PFCOUNT make3
    (integer) 15

如果允许容错，name一定可以使用Hyperloglog

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

## Bitmap ##

> #### 位存储 ####

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

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

365天 = 365bit

> #### 测试 ####

使用Bitmaps记录周一到周日的打卡！

127.0.0.1:6379> SETBIT sign 0 1
    (integer) 0
    127.0.0.1:6379> SETBIT sign 1 0
    (integer) 0
    127.0.0.1:6379> SETBIT sign 2 0
    (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 0
    (integer) 0
    127.0.0.1:6379> SETBIT sign 6 0
    (integer) 0
    
    # 查看某一天是否有打卡
    127.0.0.1:6379> GETBIT sign 3	# 查看周四
    (integer) 1
    127.0.0.1:6379> GETBIT sign 6	# 查看周日
    (integer) 0
    
    # 统计操作，统计本周打卡的天数(值为1的)
    127.0.0.1:6379> BITCOUNT sign
    (integer) 3

这些在生活中或者开发中，都有十分多的应用场景，多学多思多想法

--------------------

# 事务 #

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

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

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

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

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

Redis单条命令保证原子性，但是Redis事务不保证原子性！

### Redis事务 ###

*  开启事务(MULTI)
 *  命令入队(……)
 *  执行事务(EXEC)

> #### 正常执行事务！ ####

127.0.0.1:6379> MULTI	# 开启事务
    OK
    # ———————————命令入队———————————
    127.0.0.1:6379> set k1 v1
    QUEUED
    127.0.0.1:6379> set k2 v2
    QUEUED
    127.0.0.1:6379> get k2
    QUEUED
    127.0.0.1:6379> set k3 v3
    QUEUED
    # ———————————执行事务———————————
    127.0.0.1:6379> EXEC
    1) OK
    2) OK
    3) "v2"
    4) OK

> #### 放弃事务 ####

127.0.0.1:6379> MULTI	# 开启事务
    OK
    127.0.0.1:6379> set k1 v1
    QUEUED
    127.0.0.1:6379> set k2 v2
    QUEUED
    127.0.0.1:6379> set k4 v4
    QUEUED
    127.0.0.1:6379> DISCARD	# 取消事务
    OK
    127.0.0.1:6379> get k4	# 事务队列中的命令都不会被执行
    (nil)

> #### 编译型异常 ####

代码有错/命令有错，事务中所有的命令都不会被执行

127.0.0.1:6379> MULTI
    OK
    127.0.0.1:6379> set k1 v1
    QUEUED
    127.0.0.1:6379> set k2 v2
    QUEUED
    127.0.0.1:6379> set k3 v3
    QUEUED
    127.0.0.1:6379> getset k3	# 执行一条错误命令
    (error) ERR wrong number of arguments for 'getset' command
    127.0.0.1:6379> set k4 v4
    QUEUED
    127.0.0.1:6379> set k5 v5
    QUEUED
    127.0.0.1:6379> EXEC	# 执行事务报错
    (error) EXECABORT Transaction discarded because of previous errors.
    127.0.0.1:6379> get k5	# 所有的命令都不会执行
    (nil)

> #### 运行时异常 ####

1/0，如果事务队列中存在语法型错误，那么执行命令时，错误命令会抛出异常，其他命令可以正常执行

127.0.0.1:6379> set k1 "v1"
    OK
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379> incr k1	# 字符串自增会在执行时失败
    QUEUED
    127.0.0.1:6379> set k2 v2
    QUEUED
    127.0.0.1:6379> set k3 v3
    QUEUED
    127.0.0.1:6379> get k3
    QUEUED
    127.0.0.1:6379> EXEC
    1) (error) ERR value is not an integer or out of range	# 自增命令报错，但其他命令依旧正常执行成功
    2) OK
    3) OK
    4) "v3"
    127.0.0.1:6379> get k2
    "v2"
    127.0.0.1:6379> get k3
    "v3"

> #### 监控！watch(设计秒杀，面试常问) ####

**悲观锁：**

*  很悲观，认为什么时候都会出问题，所以做什么都会加锁！

**乐观锁：**

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

> #### Redis监视测试 ####

正常执行成功

127.0.0.1:6379> set money 100
    OK
    127.0.0.1:6379> set out 0
    OK
    127.0.0.1:6379> WATCH money	# 监视money对象
    OK
    127.0.0.1:6379> MULTI	
    OK
    127.0.0.1:6379> DECRBY money 20
    QUEUED
    127.0.0.1:6379> INCRBY out 20
    QUEUED
    127.0.0.1:6379> EXEC	# 事务正常结束，数据没有发生变动，这个时候正常执行成功
    1) (integer) 80
    2) (integer) 20

模拟多线程修改值，使用watch可以当做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	# 执行之前，另外一个线程，修改了值，这个时候就会导致事务执行失败
    (nil)
    
    ######################################
    # 模拟线程插队
    # 127.0.0.1:6379> get money
    # "80"
    # 127.0.0.1:6379> set money 1000
    # OK
    ######################################

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

127.0.0.1:6379> UNWATCH		# 如果发现事物执行失败，就先解锁
    OK
    127.0.0.1:6379> WATCH money 	# 获取最新的值，再次监视
    OK
    127.0.0.1:6379> multi
    OK
    127.0.0.1:6379> DECRBY money 10
    QUEUED
    127.0.0.1:6379> INCRBY money 10
    QUEUED
    127.0.0.1:6379> exec	# 比对监视的值是否发生了变化，如果没有变化，name可以执行成功，如果发生改变就失败
    1) (integer) 990
    2) (integer) 1000

# Jedis #

使用Java来操作Redis

> #### 什么是Jedis ####

是Redis官方推荐的Java连接开发工具！是使用Java操作Redis的中间件！如果要是用Java操作Redis，那么一定要对Jedis十分熟悉！

> 测试

1、导入对应依赖

<dependencies>
        <dependency>
            
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>
    
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.60</version>
        </dependency>
    </dependencies>

2、编码测试

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

package com.zhuangb1;
    
    import redis.clients.jedis.Jedis;
    
    /**
     * by zhuangb1 2020 - 04 -04 - 13:08
     */
    public class TestPing { 
        public static void main(String[] args) { 
            //  1、new 一个 Jedis对象
            Jedis jedis = new Jedis("127.0.0.1",6379);
            //  Jedis 所有的命令就是我们之前学习的所有指令
            System.out.println("jedis.ping() = " + jedis.ping());
        }
    }

输出：

![1585993967269][]

## 常用的API ##

String

List

Set

Hash

Zset

> 所有的API命令，全部对应上面学习的指令，没有任何改变

package com.zhuangb1;
    
    import com.alibaba.fastjson.JSONObject;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.Transaction;
    
    /** * by zhuangb1 2020 - 04 - 2020/4/4 - 18:03 */
    public class TestTx { 
        public static void main(String[] args) { 
            Jedis jedis = new Jedis("127.0.0.1", 6379,10000);
            jedis.flushDB();
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("hello","world");
            jsonObject.put("name","zhuangb1");
            // 开启事务
            Transaction multi = jedis.multi();
            String result = jsonObject.toJSONString();
            jedis.watch(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.println(jedis.get("user1"));
                System.out.println(jedis.get("user2"));
                jedis.close();  // 关闭连接
            }
    
        }
    }

# SpringBoot整合 #

说明：在SpringBoot2.x之后，原来使用的Jedis被替换成了lettuce

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

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

源码分析：

@Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(RedisOperations.class)
    @EnableConfigurationProperties(RedisProperties.class)
    @Import({  LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
    public class RedisAutoConfiguration { 
    
    	@Bean
    	@ConditionalOnMissingBean(name = "redisTemplate")	// 我们可以自定义一个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 中最常使用的类型，所以单独提出来
    	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>
 *  配置连接
    
        # 配置redis
        spring.redis.host=127.0.0.1
        spring.redis.port=6379
 *  运行测试
    
        package com.zhuangb1;
        
        import org.junit.jupiter.api.Test;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.boot.test.context.SpringBootTest;
        import org.springframework.data.redis.connection.RedisConnection;
        import org.springframework.data.redis.core.RedisTemplate;
        
        @SpringBootTest
        class Redis02SpringbootApplicationTests { 
        
            @Autowired
            private RedisTemplate redisTemplate;
            @Test
            void contextLoads() { 
                // redisTemplate 操作不同的数据类型，api和命令一致
                // opsForValue 操作字符串，类似String
                // opsForList 操作list 类似list
                // opsForSet 操作Set 类似Set
                // ……
        
                // 除了基本的操作，我们常用的方法可以直接通过 redisTemplate 操作，比如事务和基本的CRUD
                /*RedisConnection connection = redisTemplate.getConnectionFactory().getConnection(); connection.flushDb(); connection.flushAll();*/
        
                redisTemplate.opsForValue().set("mykey","常国柱");
                Object mykey = redisTemplate.opsForValue().get("mykey");
                System.out.println("mykey = " + mykey);
            }
        
        }

序列化配置：

![1585997421949][]

![1585997476801][]

关于对象的保存：

![1585998079158][]

编写自己的RedisTemplate 自定义序列化规则

package com.zhuangb1.config;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.net.UnknownHostException;
    
    /** * by zhuangb1 2020 - 04 - 2020/4/4 - 18:51 */
    @Configuration
    public class RedisConfig { 
    
        // 编写我们自己的redisTemplate 这个固定模板可以拿来即用
        @Bean
        @SuppressWarnings("all")
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
                throws UnknownHostException { 
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(redisConnectionFactory);
    
            // 序列化配置
            // 使用json去解析任意对象
            Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
            // 通过ObjectMapper进行转义
            ObjectMapper om = new ObjectMapper();
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
    
            serializer.setObjectMapper(om);
            // String的序列化
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    
            // 配置具体的实体类序列化方式
            // key采用String的序列化方式
            template.setKeySerializer(stringRedisSerializer);
            // hash的key也采用String的序列化方式
            template.setHashKeySerializer(stringRedisSerializer);
            // value序列化方式采用Jackson
            template.setValueSerializer(serializer);
            // hash的value序列化方式采用Jackson
            template.setHashValueSerializer(serializer);
    
            template.afterPropertiesSet();
            return template;
        }
    }

**所有的Redis操作，其实对于Java开发者来说十分的简单更重要的是去理解redis的思想和每一种数据结构的用处和作用场景！**

# Redis.conf详解 #

启动的时候，就通过配置文件来启动！

> 单位

![1586051334538][]

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

> 包含 incloud

![1586051432164][]

> 网络配置

bind 127.0.0.1	# 绑定的IP
    protected-mode yes	# 保护模式
    port 6379	# 端口配置

> 通用配置

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 "" # 日志的文件位置名
    
    # 默认的数据库数量是16个
    databases 16
    
    
    always-show-logo yes	# 是否显示logo

> 快照

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

redis是内存数据库，如果没有持久化，那么数据断电即失！

# 如果900秒内，至少有一个key进行了修改，我们就进行持久化操作
    save 900 1
    # 如果300秒内，至少有10个key进行了修改，我们就会进行持久化操作
    save 300 10		
    # 如果60秒内，至少有10000个key进行了修改，我们就会进行持久化操作
    save 60 10000	
    # 下一章会自定义这些数据
    
    stop-writes-on-bgsave-error yes	# 持久化如果出错，是否还需要继续工作！
    
    rdbcompression yes	# 是否压缩rdb文件，需要消耗一些CPU资源！
    
    rdbchecksum yes	# 保存rdb文件时，进行错误校验
    
    dir ./	# rdb文件保存的目录

> 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> 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 设置能连接上redis的最大客户端数量
    
    # maxmemory <bytes> redis配置最大的内存容量
    
    # maxmemory-policy noeviction 内存达到上限后的处理策略
    	# 移除一些过期的key
    	# 报错
    	# ……

**maxmemory-policy六种处理策略**

1.  noeviction：当内存不足以容纳新写入数据时，新写入操作会报错。
2.  allkeys-lru：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key。
3.  allkeys-random：当内存不足以容纳新写入数据时，在键空间中，随机移除某个key。
4.  volatile-lru：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，移除最近最少使用的key。
5.  volatile-random：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，随机移除某个key。
6.  volatile-ttl：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，有更早过期时间的key优先移除。

> APPEND ONLY 模式 aof配置

appendonly no	# 默认是不开起aof模式的，默认使用rdb方式持久化，在大部分的情况下 rdb完全够用！
    
    appendfilename "appendonly.aof"	# 持久化的文件的名字
    
    # appendfsync always # 每次修改完都会 sync 消耗性能
    appendfsync everysec	# 每秒执行一次 sync，可能会丢失这1s的数据
    # appendfsync no # 不执行 sync这个时候操作系统自己同步数据，速度最快

# Redis持久化 #

面试和工作，持久化都是重点！

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

## RDB(Redis DataBase) ##

> 什么是RDB

![1586053618389][]

`RDB`是一种快照存储持久化方式，具体就是将`Redis`某一时刻的内存数据保存到硬盘的文件当中，默认保存的文件名为`dump.rdb`，而在`Redis`服务器启动时，会重新加载`dump.rdb`文件的数据到内存当中恢复数据。 默认的状态就是RDB，一般情况下不需要修改这个配置！

rdb保存的文件名为dump.rbd

![1586054044131][]

![1586054184478][]

### 触发机制 ###

> 触发机制

1.  save的规则满足的情况下会自动触发rdb规则
2.  执行FLUSHDB 、FLUSHALL命令也会触发rdb规则
3.  退出redis，也会产生rdb文件

备份就会自动生成一个dump.rbd

![1586054606506][]

### 恢复rdb文件 ###

> 恢复rdb文件

1.  只需要将rdb文件放在redis启动目录下即可，redis启动的时候会自动检查dump.rdb恢复其中的数据
2.  查看需要存在的位置
    
        127.0.0.1:6379> config get dir
        1) "dir"
        2) "/usr/local/bin"	# 如果在这个目录下存在dump.rdb文件，启动就会自动恢复其中的数据

**几乎他自己默认的配置就够用了，但是我们还是需要去学习**

### RDB的几个优点 ###

1.  与AOF方式相比，通过rdb文件恢复数据比较快。适合大规模的数据恢复
2.  rdb文件非常紧凑，适合于数据备份。对数据的完整性要求不高
3.  通过RDB进行数据备，由于使用子进程生成，所以对Redis服务器性能影响较小。

### RDB的几个缺点 ###

1.  如果服务器宕机的话，采用`RDB`的方式会造成某个时段内数据的丢失，比如我们设置10分钟同步一次或5分钟达到1000次写入就同步一次，那么如果还没达到触发条件服务器就死机了，那么这个时间段的数据会丢失。
2.  使用save命令会造成服务器阻塞，直接数据同步完成才能接收后续请求。
3.  使用bgsave命令在forks子进程时，如果数据量太大，forks的过程也会发生阻塞，另外，forks子进程会耗费内存。

## AOF(Append Only File) ##

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

### 是什么 ###

> AOF是什么

![1586055224861][]

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

**AOF保存的是appendonly.aof文件**

### 开启AOF ###

默认是不开启的，我们需要手动进行配置！只需要将appendonly改为yes就开启了

appendonly yes

重启Redis服务使其生效，就会在目录中看到appendonly.aof文件

如果aof文件有错误，redis将无法启动，我们需要手动修复这个aof文件

redis给我们提供的工具为 `redis-checkaof --fix`

**手动修复.aof：**

![1586056041167][]

如果文件正常，重启就可以直接修复了

### AOF的优缺点 ###

#### AOF的优点 ####

1.  AOF只是追加日志文件，因此对服务器性能影响较小，速度比RDB要快，消耗的内存较少。
2.  每秒同步一次，可能会丢失一秒的数据

#### AOF的缺点 ####

1.  AOF方式生成的日志文件太大，即使通过AFO重写，文件体积仍然很大。
2.  恢复数据的速度比RDB慢。

### 重写规则 ###

如果aof文件大于60M，就会fork一个新的进程来将文件进行重写

aof默认是文件的无限追加

文件会越来越大

# Redis发布订阅 #

Redis发布订阅(pub/sub)是一种**消息通信模式**：发布者(pub)发送消息，订阅者(sub)接收消息。

Redis客户端可以订阅任意数量的频道

**订阅/发布消息图：**

![1586056747595][]

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

![1586056794690][]

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

![1586056805442][]

> 命令

![1586057162608][]

> 测试

订阅端：

127.0.0.1:6379> SUBSCRIBE zhuangb1	# 订阅一个频道
    Reading messages... (press Ctrl-C to quit)
    1) "subscribe"
    2) "zhuangb1"
    3) (integer) 1
    # 等待读取推送的信息
    1) "message"	# 消息
    2) "zhuangb1"	# 发布的频道
    3) "hello zhuangb1"	# 消息的具体内容
    1) "message"
    2) "zhuangb1"
    3) "hello redis"

发送端：

127.0.0.1:6379> PUBLISH zhuangb1 "hello zhuangb1"	# 发布者发布消息到频道
    (integer) 1
    127.0.0.1:6379> PUBLISH zhuangb1 "hello redis"
    (integer) 1

### 使用场景 ###

1.  实时消息系统
2.  实时聊天系统
3.  关注系统

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

# Redis主从复制 #

## 概念 ##

主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master)，后者称为从节点(slave)；数据的复制是单向的，只能由主节点到从节点。

默认情况下，每台Redis服务器都是主节点；且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。

**主从复制的作用**

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

1.  数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
2.  故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复；实际上是一种服务的冗余。
3.  负载均衡：在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载；尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。
4.  高可用基石：除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是Redis高可用的基础。

一般来说，要将Redis运用于工程项目中，只是用一台Redis是万万不能的，原因是：

1.  从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大；
2.  从容量上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有内存用作Redis存储内存

电商网站上的商品，一般都是依次上传，无数次浏览的，也就是说的"多读少写"

对于这种场景，我们可以使用如下架构

![1586058113981][]

在企业级开发中，主从复制就是必须要使用的，因为在真实的项目中不可能使用单机Redis

## 环境配置 ##

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

### 查看信息 ###

127.0.0.1:6379> INFO replication	# 查看当前库的信息
    # Replication
    role:master		# 角色 master
    connected_slaves:0	# 从机数量：0
    master_replid:a7d3fc3ed3ba93785128260edb7e117d3f7c3758
    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

### 配置从机 ###

将配置文件赋值三份

[root@iZ8vbd2xw0u0dvoyzpqhg6Z zhuangb1Conf]# cp redis.conf redis79.conf
    [root@iZ8vbd2xw0u0dvoyzpqhg6Z zhuangb1Conf]# cp redis.conf redis80.conf
    [root@iZ8vbd2xw0u0dvoyzpqhg6Z zhuangb1Conf]# cp redis.conf redis81.conf
    [root@iZ8vbd2xw0u0dvoyzpqhg6Z zhuangb1Conf]# ls
    redis79.conf  redis80.conf  redis81.conf  redis.conf

然后修改对应信息：

1.  端口
2.  PID名
3.  log文件名
4.  dump.rdb名

修改完毕之后启动三个服务并查看集群环境

![1586066730339][]

### 一主二从 ###

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

**我们一般情况下只需要配置从机**

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

127.0.0.1:6380> SLAVEOF 127.0.0.1 6379	# SLAVEOF host port 找哪个服务器上的当老大
    OK
    127.0.0.1:6380> info replication
    # Replication
    role:slave	# 当前角色：从机
    master_host:127.0.0.1	# 可以看到主机的信息
    master_port:6379
    master_link_status:up
    master_last_io_seconds_ago:2
    master_sync_in_progress:0
    slave_repl_offset:0
    slave_priority:100
    slave_read_only:1
    connected_slaves:0
    master_replid:ae691a5d71000625358a1105ecc75cb95e7b57ca
    master_replid2:0000000000000000000000000000000000000000
    master_repl_offset:0
    second_repl_offset:-1
    repl_backlog_active:1
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:1
    repl_backlog_histlen:0
    
    # 在主机中查看
    127.0.0.1:6379> INFO replication
    # Replication
    role:master
    connected_slaves:1	# 多了从机的配置
    slave0:ip=127.0.0.1,port=6380,state=online,offset=28,lag=1	# 从机的配置
    master_replid:ae691a5d71000625358a1105ecc75cb95e7b57ca
    master_replid2:0000000000000000000000000000000000000000
    master_repl_offset:28
    second_repl_offset:-1
    repl_backlog_active:1
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:1
    repl_backlog_histlen:28
    
    
    
    
    # 已配置好两个从机
    127.0.0.1:6379> INFO replication
    # Replication
    role:master
    connected_slaves:2
    slave0:ip=127.0.0.1,port=6380,state=online,offset=266,lag=0
    slave1:ip=127.0.0.1,port=6381,state=online,offset=266,lag=1
    master_replid:ae691a5d71000625358a1105ecc75cb95e7b57ca
    master_replid2:0000000000000000000000000000000000000000
    master_repl_offset:266
    second_repl_offset:-1
    repl_backlog_active:1
    repl_backlog_size:1048576
    repl_backlog_first_byte_offset:1
    repl_backlog_histlen:266

**真实的主从配置应该在配置文件中配置，这样的话是永久的，此处使用命令则表示是暂时的**

打开redis配置文件，在图中标记出填写配置

![1586067536516][]

> 细节

主机可以写，从机只能读！主机中的所有信息和数据，都会自动被从机保存

**主机可以进行读写操作**

127.0.0.1:6379> set k1 v1
    OK
    127.0.0.1:6379> get k1
    "v1"

**从机只能读取**

127.0.0.1:6381> get k1
    "v1"
    127.0.0.1:6381> set k2 v2
    (error) READONLY You can't write against a read only replica.	# 从机只能读，不可以进行写入

> 测试

主机断开连接，从机依旧连接到主机，但是没有写操作，如果主机重新复活，从机依旧可以直接获取到主机的写操作，保证了高可用

如果是使用命令行配置的主从，此时从机重启后就会变回主机

只要变回了从机，就可以立刻从主机中获取值

> 复制原理

Slave启动成功连接到master后会发送一个sync同步命令

Master接到命令，启动后台的存盘进程，同时手机所有接收到的用于修改数据集命令，在后台执行完毕之后，Master将传送整个数据到Slave，并完成一次完全同步。

全量赋值：而Slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。

增量复制：Master继续将新的所有收集到的修改命令依次传给S拉个，完成同步

但是只要重新连接Master，一次完全同步(全量赋值)奖杯自动执行！我们的数据一定会在从机中看到

> 层层链路

上一个M连接下一个S

这时候也可以完成主从复制

> 如果主节点失效如何重新选取主节点

如果主机断开了连接，我们可以使用`SLAVEOF NO ONE`命令让自己变成主机

其他的节点就可以手动连接到最新的主节点

## 哨兵模式 ##

[推荐参阅][Link 2]

Redis-Sentinel是官方推荐的高可用解决方案，当redis在做master-slave的高可用方案时，假如master宕机了，redis本身（以及其很多客户端）都没有实现自动进行主备切换，而redis-sentinel本身也是独立运行的进程，可以部署在其他与redis集群可通讯的机器中监控redis集群。

能够后台监控主机是否故障，如果故障了根据投票数自动将从库转为主库。

哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是**哨兵通过发送命令，等待Redis服务器响应，从而监控运行多个Redis示例**。

![1586069954625][]

这里的哨兵有两个作用

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

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

![1586070231667][]

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

> 测试

我们目前是一主二从。

1.  匹配值哨兵配置文件 sentinel.conf
    
        sentinel monitor myredis 127.0.0.1 6379 1
        # 哨兵 监视 哨兵名字 IP 端口 用于投票
2.  启动哨兵
    
        [root@iZ8vbd2xw0u0dvoyzpqhg6Z bin]# redis-sentinel zhuangb1Conf/sentinel.conf 
        8788:X 05 Apr 2020 15:14:28.854 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
        8788:X 05 Apr 2020 15:14:28.854 # Redis version=5.0.8, bits=64, commit=00000000, modified=0, pid=8788, just started
        8788:X 05 Apr 2020 15:14:28.854 # Configuration loaded
                        _._                                                  
                   _.-``__ ''-._ _.-`` `.  `_. ''-._ Redis 5.0.8 (00000000/0) 64 bit .-`` .-```. ```\/ _.,_ ''-._ ( ' , .-`  | `, ) Running in sentinel mode |`-._`-...-` __...-.``-._|'` _.-'| Port: 26379 | `-._ `._ / _.-'    |     PID: 8788
          `-._ `-._  `-./ _.-' _.-' |`-._`-._ `-.__.-' _.-'_.-'| | `-._`-._ _.-'_.-' | http://redis.io `-._ `-._`-.__.-'_.-' _.-' |`-._`-._ `-.__.-'    _.-'_.-'|                                  
         |    `-._`-._        _.-'_.-'    |                                  
          `-._ `-._`-.__.-'_.-' _.-' `-._    `-.__.-' _.-' `-._        _.-'                                           
                      `-.__.-'                                               
        
        8788:X 05 Apr 2020 15:14:28.855 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
        8788:X 05 Apr 2020 15:14:28.857 # Sentinel ID is 3084fce24e14b9e38395a00aa34cba1051e00447
        8788:X 05 Apr 2020 15:14:28.857 # +monitor master myredis 127.0.0.1 6379 quorum 1
        8788:X 05 Apr 2020 15:14:28.858 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
        8788:X 05 Apr 2020 15:14:28.859 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379

如果主节点断开，这时候就会从主机中投票选取出一个主机(通过投票算法实现)

哨兵日志：

![1586071171217][]

如果主机再次回归，只能归并到新的主机下，当做从机

> 哨兵模式

优点：

1.  哨兵集群，基于主从复制模式，所有的主从配置有点，它全有
2.  主从可以切换，故障可以转移，系统的可用性更高
3.  哨兵模式就是主从模式的升级，由手动转全自动，更加健壮

缺点：

1.  Redis不好在线扩容了，集群容量一旦达到上限，在线扩容就十分麻烦！
2.  实现哨兵模式的配置非常麻烦，里面有很多选择！

> 哨兵模式的全部配置

# 哨兵sentinel实例运行的端口，默认26379 
    port 26379
    # 哨兵sentinel的工作目录
    dir ./
    
    # 哨兵sentinel监控的redis主节点的 
    ## ip：主机ip地址
    ## port：哨兵端口号
    ## master-name：可以自己命名的主节点名字（只能由字母A-z、数字0-9 、这三个字符".-_"组成。）
    ## quorum：当这些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 auth-pass <master-name> <password> 
    sentinel auth-pass mymaster 123456  
    
    # 指定主节点应答哨兵sentinel的最大时间间隔，超过这个时间，哨兵主观上认为主节点下线，默认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
    
    # 当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本。一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
    # 对于脚本的运行结果有以下规则： 
    ## 1. 若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10。
    ## 2. 若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。 
    ## 3. 如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
    # sentinel notification-script <master-name> <script-path> 
    sentinel notification-script mymaster /var/redis/notify.sh
    
    # 这个脚本应该是通用的，能被多次调用，不是针对性的。
    # sentinel client-reconfig-script <master-name> <script-path>
    sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

# Redis缓存穿透和雪崩 #

> 本质上是研究服务器高可用问题

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

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

![1586072802410][]

## 缓存穿透(查询失败导致) ##

> 概念

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

> 解决方案

**布隆过滤器**

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

![1586072964876][]

**缓存空对象**

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

![1586073009238][]

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

1.  如果空值能够被缓存起来,这就意味着缓存需要更多的空间存储更多的键,因为这当中可能会有很多的空值的键;
2.  即使对空值设置了过期时间,还是会存在缓存层和存储层的数据会有一段时间窗口的不一致,这对于需要保持一致性的业务会有影响。

## 缓存击穿(查询量过高，缓存过期) ##

> 概述

这里需要注意和缓存击穿的区别,缓存击穿,是指一个key非常热点 ,在不停的扛着大并发,大并发集中对这一个点进行访问, 当这个key在失效的瞬间,持续的大并发就穿破缓存,直接请求数据库,就像在一个屏障上凿开了一个洞。  
当某个key在过期的瞬间,有大量的请求并发访问,这类数据一般是热点数据,由于缓存过期,会同时访问数据库来查询最新数据,并且回写缓存,会导使数据库瞬间压力过大。

> 解决方案

**设置热点数据永不过期**

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

**加互斥锁**

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

## 缓存雪崩 ##

> 概念

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

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

![1586073768416][]

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

> 解决方案

**redis高可用**

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

**限流降级**

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

**数据预热**

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

r时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来同步数据了

# sentinel failover-timeout #

sentinel failover-timeout mymaster 180000

# 当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本。一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。 #

# 对于脚本的运行结果有以下规则： #

## 1. 若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10。 ##

## 2. 若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。 ##

## 3. 如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。 ##

# sentinel notification-script #

sentinel notification-script mymaster /var/redis/notify.sh

# 这个脚本应该是通用的，能被多次调用，不是针对性的。 #

# sentinel client-reconfig-script #

sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

# Redis缓存穿透和雪崩
    
    > 本质上是研究服务器高可用问题
    
    Redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。但同时，它也带来了一些问题。其中，最要害的问题就是数据的一致性问题，从严格意义上讲，这个问题无解。如果对数据的一致性要求很高，那么就不能使用缓存。
    
    另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前业界也都有比较流行的解决方案。
    
    [外链图片转存中...(img-ibB0cZvy-1628256623494)]
    
    ## 缓存穿透(查询失败导致)
    
    > 概念
    
    
    
    缓存穿透的概念很简单,用户想要查询一个数据,发现redis内存数据库没有,也就是缓存没有命中,于是向持久层数据库查询。发现也没有,于是本次查询失败。当用户很多的时候,缓存都没有命中,于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力,这时候就相当于出现了缓存穿透。
    
    
    
    > 解决方案
    
    
    
    **布隆过滤器**
    
    布隆过滤器是-种数据结构,对所有可能查询的参数以hash形式存储,在控制层先进行校验,不符合则丢弃,从而避免了对底层存储系统的查询压力;
    
    [外链图片转存中...(img-yZyKXCSm-1628256623497)]
    
    
    
    **缓存空对象**
    
    当存储层不命中后,即使返回的空对象也将其缓存起来,同时会设置-一个过期时间,之后再访问这个数据将会从缓存中获取,保护了后端数据源;
    
    
    
    
    
    [外链图片转存中...(img-LUsf6tF2-1628256623499)]
    
    但是这种方法会存在两个问题:
    
    1. 如果空值能够被缓存起来,这就意味着缓存需要更多的空间存储更多的键,因为这当中可能会有很多的空值的键;
    
    2. 即使对空值设置了过期时间,还是会存在缓存层和存储层的数据会有一段时间窗口的不一致,这对于需要保持一致性的业务会有影响。
    
    
    
    ## 缓存击穿(查询量过高，缓存过期)
    
    
    
    > 概述
    
    这里需要注意和缓存击穿的区别,缓存击穿,是指一个key非常热点 ,在不停的扛着大并发,大并发集中对这一个点进行访问, 当这个key在失效的瞬间,持续的大并发就穿破缓存,直接请求数据库,就像在一个屏障上凿开了一个洞。
    当某个key在过期的瞬间,有大量的请求并发访问,这类数据一般是热点数据,由于缓存过期,会同时访问数据库来查询最新数据,并且回写缓存,会导使数据库瞬间压力过大。
    
    
    
    > 解决方案
    
    **设置热点数据永不过期**
    
    从缓存层面来看,没有设置过期时间,所以不会出现热点key过期后产生的问题。
    
    **加互斥锁**
    
    分布式锁:使用分布式锁,保证对于每个key同时只有一个线程去查询后端服务 ,其他线程没有获得分布式锁的权限,因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁,因此对分布式锁的考验很大。
    
    
    
    ## 缓存雪崩
    
    > 概念
    
    
    
    缓存雪崩,是指在某一个时间段，缓存集中过期失效。
    
    产生雪崩的原因之一,比如在写本文的时候,马上就要到双十二零点,很快就会迎来-波抢购,这波商品时间比较集中的放入了缓存，假设缓存一个小时。那么到了凌晨一点钟的时候,这批商品的缓存就都过期了。而对这批商品的访问查询,都落到了数据库上,对于数据库而言,就会产生周期性的压力波峰。于是所有的请求都会达到存储层,存储层的调用量会暴增,造成存储层也会挂掉的情况。
    
    [外链图片转存中...(img-6rMPURVZ-1628256623502)]
    
    
    
    其实集中过期,倒不是非常致命,比较致命的缓存雪崩,是缓存服务器某个节点宕机或断网。I因为自然形成的缓存雪崩, 一定是在某个时间段集中创建缓存,这个时候, 数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机,对数据库服务器造成的压力是不可预知的,很有可能瞬间就把数据库压垮。
    
    
    
    > 解决方案
    
    
    
    **redis高可用**
    
    这个思想的含义是,既然redis有可能挂掉,那我多增设几台redis ,这样一台挂掉之后其他的还可以继续工作,其实就是搭建的集群。(异地多活！)
    
    **限流降级**
    
    这个解决方案的思想是,在缓存失效后,通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存,其他线程等待。
    
    **数据预热**
    
    数据加热的含义就是在正式部署之前,我先把可能的数据先预先访问一遍,这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key ,设置不同的过期时间,让缓存失效的时间点尽量均匀。

[image-20200402131447566]: /images/20220829/6b10311ce5894fe79b5931544302c8c4.png
[image-20200402190721284]: /images/20220829/7c22ed4a5e8642bfb8175ec29c7e690e.png
[image-20200402190904970]: /images/20220829/41ffc892c00a41288ff6f042c947cefd.png
[image-20200402191949463]: /images/20220829/3404d3c7cb754718b849f5509e2793eb.png
[image-20200402193637280]: /images/20220829/f3866fc7300b43bfa23ea34991761298.png
[C]: https://baike.baidu.com/item/C%E8%AF%AD%E8%A8%80
[Link 1]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E5%BA%93/103728
[image-20200402195250646]: /images/20220829/7e81344644d34494862e4dba8453bc24.png
[image-20200402195855846]: /images/20220829/fce901c0281a49f6a6b010f16f24ba5e.png
[image-20200402201609864]: /images/20220829/e2921e80c0084053ab906de36ed27c8c.png
[image-20200402201543037]: https://img-blog.csdnimg.cn/img_convert/2702f8fd35426c88dd19786baa8b392e.png
[image-20200402201451838]: /images/20220829/3193b612d353467f85ffb91cf6b7c93b.png
[image-20200402201631638]: https://img-blog.csdnimg.cn/img_convert/caf997ac1dee3917b0a670ece023ebe1.png
[image-20200402201643405]: /images/20220829/77e124528f42416aa1c05c12f3bdd2d4.png
[image-20200402202020844]: /images/20220829/99c4a133f6c04a1c9f77b4629c3233a9.png
[image-20200402202247813]: /images/20220829/28d45a65a58f4ded923e47a420870c4e.png
[image-20200402203403332]: /images/20220829/fa3bc7d135214c6ca8b6c0e4760f69fd.png
[image-20200402203522749]: /images/20220829/746b532f8e5a45b6a2605a98e25123de.png
[image-20200402204426009]: /images/20220829/1b39d24936234d5eb37ca5d785d93931.png
[image-20200402205104784]: /images/20220829/f89e55ee5b7a4f10baad001727481327.png
[image-20200402205355432]: /images/20220829/aba03e5484e84bb5a84473ed5ae0a0ad.png
[image-20200402205550679]: /images/20220829/cce4d109967c49b0b06b323902dad9a2.png
[image-20200402205755325]: /images/20220829/ea96744bb48f4985acb5e6889ee8a9c4.png
[image-20200402210127468]: /images/20220829/fa5597feeebe4572ad6e5f55711fb2af.png
[image-20200402210326257]: /images/20220829/847a2ad6c1ee476c9c04708d101937d1.png
[image-20200402210510440]: /images/20220829/66f10efdc23a43fea10d414dae233ebb.png
[image-20200402210544518]: /images/20220829/22897ebe7a6d4ba1aef5a0cfeda35fdd.png
[image-20200402210921482]: /images/20220829/c79faf0ad8f945f3b5da6ad12ad48735.png
[image-20200402211455515]: /images/20220829/58a9580c7ebc436ea94ee3d79d2c63e2.png
[image-20200402211937356]: /images/20220829/a33b2ccc440b4a6fb2a4eddde703857e.png
[image-20200402212210411]: /images/20220829/bb8870f4abcc4cee89c610e8d5564ff2.png
[image-20200402212530494]: /images/20220829/ab39195c9591460b8b37b4ef7434e8ed.png
[image-20200403110953549]: /images/20220829/f933d517a14d4090a1d2433015a37732.png
[strings]: http://redis.cn/topics/data-types-intro.html#strings
[hashes]: http://redis.cn/topics/data-types-intro.html#hashes
[lists]: http://redis.cn/topics/data-types-intro.html#lists
[sets]: http://redis.cn/topics/data-types-intro.html#sets
[sorted sets]: http://redis.cn/topics/data-types-intro.html#sorted-sets
[bitmaps]: http://redis.cn/topics/data-types-intro.html#bitmaps
[hyperloglogs]: http://redis.cn/topics/data-types-intro.html#hyperloglogs
[geospatial]: http://redis.cn/commands/geoadd.html
[replication]: http://redis.cn/topics/replication.html
[LUA_Lua scripting]: http://redis.cn/commands/eval.html
[LRU_LRU eviction]: http://redis.cn/topics/lru-cache.html
[transactions]: http://redis.cn/topics/transactions.html
[persistence]: http://redis.cn/topics/persistence.html
[Redis_Sentinel]: http://redis.cn/topics/sentinel.html
[Cluster]: http://redis.cn/topics/cluster-tutorial.html
[image-20200403112450309]: /images/20220829/01857ae872624c7095f79310e73387f7.png
[image-20200403115921930]: /images/20220829/fd633113f5214b26b18de04e4a3568b9.png
[image-20200403205908072]: /images/20220829/24c4322925b44b8ab60077275bad21f3.png
[1585993967269]: /images/20220829/f4c822b297ee4f7685ac988bf8adcfd4.png
[1585997421949]: /images/20220829/1fa0a378515e47f7aa6777ae6e179ab2.png
[1585997476801]: /images/20220829/822e413652b74727923e87214034b588.png
[1585998079158]: /images/20220829/028ec1d1787a4b009223e71a29d302d5.png
[1586051334538]: /images/20220829/f63ef6c16ff5476aa991eef9ffda647a.png
[1586051432164]: /images/20220829/e179907d59c74107869a468585f1018b.png
[1586053618389]: /images/20220829/e1114981969d4247a300b679caf9819b.png
[1586054044131]: /images/20220829/1ab46f2d4add4181b5a5c13ae9757df6.png
[1586054184478]: /images/20220829/d6f0477e8a3e4e0bb61e37d09cf8afc7.png
[1586054606506]: /images/20220829/90bc7ced597345498a35e61614a5591a.png
[1586055224861]: /images/20220829/d836bb91a32b4ab68c03337417f33522.png
[1586056041167]: /images/20220829/8e5c31f7e9024a7c9cddd069e6fe1dea.png
[1586056747595]: /images/20220829/6efb8376ec9f4131b99acbe486dfac45.png
[1586056794690]: /images/20220829/d13ebfdbc6fc4f82879764c75643f0d2.png
[1586056805442]: /images/20220829/a88eaeb8f7de445ab228198a7853393d.png
[1586057162608]: /images/20220829/212a3abbedf2478aac9be341a6b15e80.png
[1586058113981]: /images/20220829/f405bf396fcd433484c9ac0bd6e1157a.png
[1586066730339]: /images/20220829/c4b90da7edc342e0b037005e812839c0.png
[1586067536516]: /images/20220829/8466388e2eba4768ab8cc6a3a2b40485.png
[Link 2]: https://juejin.im/post/5b7d226a6fb9a01a1e01ff64
[1586069954625]: /images/20220829/67fb2db9925943d6a4de09b2b0954c27.png
[1586070231667]: /images/20220829/1011f774470447f0b6857ec9870e5d57.png
[1586071171217]: /images/20220829/f2f436488c5c472886ab5e2ed91acaf2.png
[1586072802410]: /images/20220829/f0efdabf21844652b890b8a42f5261da.png
[1586072964876]: /images/20220829/76e867ee1a0c4c3f841b6de1e3046f3c.png
[1586073009238]: /images/20220829/1b9601345d6f4cb097deaa6a48a50e80.png
[1586073768416]: /images/20220829/42601136d894476595e1624323552745.png