狂神docker 笔记狂神redis

转载

jordana 2024-01-19 22:46:22

文章标签 狂神docker 笔记 redis nosql 数据库 Redis 文章分类 Docker 云计算

文章目录

一、Nosql概述

为什么使用Nosql
什么是NoSQL
阿里巴巴演进分析
NoSQL的四大分类

四者对比!!!

二、Redis入门

概述
Windows安装
Linux安装
测试性能
基础的知识

五大数据类型

Redis-Key
String（字符串）
List（列表）
Set（集合）
Hash（哈希）
Zset（有序集合）

三大特殊数据类型

geospatial 地理位置
Hyperloglog
Bitmaps

事务
Jedis

常用的API

Springboot
自定义Redis工具类
Redis.conf
Redis持久化

RDB(Redis DataBase)
AOF(Append only File)

Redis发布订阅
Redis主从复制

环境配置
一主二从
哨兵模式

Redis缓存穿透和雪崩(面试高频，工作常用)

**缓存穿透**（查不到）
缓存击穿（量太大，缓存过期！）

缓存雪崩

一、Nosql概述

为什么使用Nosql

1、单机Mysql时代

狂神docker 笔记狂神redis_redis

90年代,一个网站的访问量一般不会太大，单个数据库完全够用。随着用户增多，网站出现以下问题

数据量增加到一定程度，单机数据库就放不下了
数据的索引（B+ Tree）,一个机器内存也存放不下
访问量变大后（读写混合），一台服务器承受不住。

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

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

狂神docker 笔记狂神redis_nosql_02

优化过程经历了以下几个过程：

优化数据库的数据结构和索引(难度大)

文件缓存，通过IO流获取比每次都访问数据库效率略高，但是流量爆炸式增长时候，IO流也承受不了

MemCache,当时最热门的技术，通过在数据库和数据库访问层之间加上一层缓存，第一次访问时查询数据库，将结果保存到缓存，后续的查询先检查缓存，若有直接拿去使用，效率显著提升。

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

狂神docker 笔记狂神redis_nosql_02

4、如今最近的年代

如今信息量井喷式增长，各种各样的数据出现（用户定位数据，图片数据等），大数据的背景下关系型数据库（RDBMS）无法满足大量数据要求。Nosql数据库就能轻松解决这些问题。

目前一个基本的互联网项目

狂神docker 笔记狂神redis_Redis_04

为什么要用NoSQL？

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

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

什么是NoSQL

NoSQL

NoSQL = Not Only SQL(不仅仅是SQL)

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

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

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

NoSQL特点

解耦

1.方便扩展（数据之间没有关系，很好扩展）

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

3.数据类型是多样性！（不需要事先设计数据库！随去随用！如果是数据库量十分大的表，很多人就无法设计了）

4.传统 RDBMS 和 NoSQL

传统的 RDBMS（关系型数据库）
- 结构化组织
- SQL
- 数据和关系都存在单独的表中 row clo
- 操作操作，数据定义
- 严格的一致性
- 基础的事务
- .....

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

了解： 3V+3高

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

海量Volume
多样Variety
实时Velocity

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

高并发
高可扩（随时水平拆分，可以扩展机器）
高性能（保证用户体验和性能）

真正在公司中的实践：NoSQL + RDBMS 一起使用才是最强的。

阿里巴巴演进分析

推荐阅读：阿里云的这群疯子https://yq.aliyun.com/articles/653511

狂神docker 笔记狂神redis_数据库_05

狂神docker 笔记狂神redis_狂神docker 笔记_06

1.商品信息
    名称、价格，商品信息
    关系型数据库就可以解决了！MySQL/Oracle（淘宝早你就去IOE了）
	淘宝内部的 MySQL不是大家用的MySQL
2.商品的描述、评论（文字比较多）
    文档型数据库中，MongoDB
3.图片    
    分布式文件系统 FastDFS
    - 淘宝自己的 TFS
    - Gooale的 GFS
    - Hadoop   HDFS
    - 阿里云的  oss
    
#4.商品的关键字（搜索）
    - 搜索引擎 solr  elasticsearch
    - ISearch  多隆
#5.商品热门的波段信息
    - 内存数据库
    - Redis  Tair Memache
#6.商品的交易、外部的支付接口
    - 三方应用

大型互联网应用问题：

数据类型太多了
数据源繁多，经常重构
数据要改造，大面积改造

解决问题

NoSQL的四大分类

KV键值对：

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

文档型数据库（bson格式和json一样）

MongoDB（一般必须要掌握）

mongo是一个基于分布式文件存储的数据库，C++编写，主要用于处理大量的文档
MongoDB是一个介于关系型数据库和非关系型数据库中间的产品！MongoDB是非关系型写数据库中功能最丰富，最像关系型数据库的！
ConthDB

列存储数据库

HBase
分布式文件系统

图形关系数据库

狂神docker 笔记狂神redis_狂神docker 笔记_07

狂神docker 笔记狂神redis_数据库_08

四者对比!!!

分类	Example举例	典型应用场景	数据模型	优点	缺点
键值对	Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB	内容缓存，主要用于大量数据的高访问负载，也用于一些日志系统等等	Key指向Value的键值对，通常用hashtable来实现	查询速度快	数据无结构化，通常只能被当作字符串或者二进制数据
列存储数据库	assandra, HBase, Riak	分布式的文件系统	以列簇式存储，将同一列数据存在一起	查找速度快，可扩展性强，更容易进行分布式扩展	功能相对局限
文档型数据库	CouchDB, MongoDb	Web应用（与Key-Value类似，Value是结构化的，不同的是数据库能够了解Value的内容）	Key-Value对应的键值对，Value为结构化数据	数据结构要求不严格，表结构可变，不需要像关系型数据库一样需要预先定义表结构	查询性能不高，而且缺乏统一的查询语法。
图形数据库	Neo4J, InfoGrid, Infinite Graph	社交网络，推荐系统等。专注于构建关系图谱	图结构	利用图结构相关算法。比如最短路径寻址，N度关系查找等	很多时候需要对整个图做计算才能得出需要的信息，而且这种结构不太好做分布式的集群

二、Redis入门

概述

Redis是什么？

Redis（Remote Dictionary Server）即远程字典服务！

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7fOs10Ph-1635168391604)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634869434635.png)]

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

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

Redis能干嘛？

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

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

3、发布订阅系统

4、地图信息分析

5、计时器、计数器（浏览量！）

6、 …

特征

1、多样的数据类型

2、持久性

3、集群

4、事务

…

环境搭建

注意：Window在Github下载（停更很久了！）

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

Windows安装

https://github.com/microsoftarchive/redis/releases/tag/win-3.2.100

1.解压安装包

狂神docker 笔记狂神redis_nosql_09

2.开启redis-server.exe

3.启动redis-cli.exe（redis客户端）测试

狂神docker 笔记狂神redis_狂神docker 笔记_10

Linux安装

1.下载安装包 5.08.tar.gz

2.解压Redis的安装包！程序/opt

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uxDgUbqq-1635168391606)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634988638356.png)]

3.进入解压后的文件，可以看到redis的配置文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KgAAkvAA-1635168391609)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634989827270.png)]

4.基本的环境安装

yum install gcc-c++

make

make install

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8xjobrmy-1635168391611)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634990106818.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZEq1kvB0-1635168391614)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634990074014.png)]

5.redis的默认安装路径usr/local/bin

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GWlmdQg1-1635168391615)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634990255958.png)]

6.将redis配置文件。复制到我们当前目录下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-08oD1qjo-1635168391615)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634990950485.png)]

7.redis默认不是后台启动的，修改配置文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3Rh93Txw-1635168391616)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634991049276.png)]

启动Redis服务（通过指定的配置文件启动服务）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kULZTulj-1635168391618)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634991207775.png)]

9.使用redis-cli 进行连接测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YGs2QXnY-1635168391619)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634991326613.png)]

keys *：查看所有的key

10.查看redis的进程是否开启

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wa50b9rb-1635168391620)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634991489953.png)]

11.如何关闭Redis服务？shutdown

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8LLzBGpG-1635168391621)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634991572400.png)]

12.再次查看进程是否存在

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JjoP3CWl-1635168391621)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634991605385.png)]

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

测试性能

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

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

redis-benchmark命令参数！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7KxnIQtV-1635168391622)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634991911767.png)]

我们来简单测试下：

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7FFBKcGY-1635168391622)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634992245382.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YY8bg5L5-1635168391623)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634992367804.png)]

基础的知识

redis默认的有16个数据库

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BCpjXFZQ-1635168391623)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634992838907.png)]

默认使用的是第0个

可以使用select进行切换

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SifbgOwZ-1635168391624)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1634993100303.png)]

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

清除当前数据库flush

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

清除全部数据库的内容flushall

127.0.0.1:6379> flushall
OK
127.0.0.1:6379> keys *
(empty list or set)

思考：为什么端口号是6379？是因为粉丝效应

Redis是单线程的

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

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

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

1、误区1：高性能的服务器一定是多线程的？

2、误区2：多线程（CPU上下文切换！）一定比单线程效率高！

先去CPU>内存>硬盘的速度有所了解！

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

五大数据类型

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

Redis-Key

在redis中无论什么数据类型，在数据库中都是以key-value形式来保存，通过进行对Redis-key的操作，来对数据库中数据的操作

下面要学的命令：

exists key：判断是否存在
del key：删除键值对
move key db：将键值对移动到指定数据库
expire key second：设置键值对的过期时间
type key：查看value的数据类型

127.0.0.1:6379> keys * #查看所有的key
(empty list or set)
127.0.0.1:6379> set name zht #set key
OK
127.0.0.1:6379> keys *
1) "name"
127.0.0.1:6379> set age 1
OK
127.0.0.1:6379> keys *
1) "age"
2) "name"
127.0.0.1:6379> exists name #判断当前的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 zht
OK
127.0.0.1:6379> keys *
1) "age"
2) "name"
127.0.0.1:6379> clear
127.0.0.1:6379> get naem
(nil)
127.0.0.1:6379> get name
"zht"
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 age #查看当前key的一个类型 
string

后面遇到不会的命令，可以在官网查看：http://www.redis.cn/commands.html

String（字符串）

普通的set、get直接略过。

命令	描述	示例
`APPEND key value`	向指定的key的value后追加字符串	127.0.0.1:6379> append key1 “hello” (integer) 7
`STRLEN key`	获取key保存值的字符串长度	127.0.0.1:6379> strlen key1 (integer) 11
`DECR/INCR key`	将指定key的value数值进行+1/-1(仅对于数字)	127.0.0.1:6379> decr views (integer) 1
`INCRBY/DECRBY key n`	按指定的步长对数值进行加减	127.0.0.1:6379> incrby views 10 (integer) 20
`GETRANGE key start end`	按起止位置获取字符串（闭区间，起止位置都取）	127.0.0.1:6379> getrange key1 1 3 "ell"
`SETRANGE key offset value`	用指定的value 替换key中 offset开始的值	127.0.0.1:6379> setrange key2 1 xx (integer) 7 “axxdefg”
`SETNX key value`	仅当key不存在时进行set	127.0.0.1:6379> setnx mykey “redis” (integer) 1
`SETEX key seconds value`	set 键值对并设置过期时间	127.0.0.1:6379> setex key3 30 "hello" OK
`MSET key1 value1 [key2 value2..]`	批量set键值对	127.0.0.1:6379> MSET k1 v1 k2 v2 k3 v3 OK
`MGET key1 [key2..]`	批量获取多个key保存的值	127.0.0.1:6379> MGET k1 k2 k3 1) “v1” 2) “v2” 3) “v3”
`MSETNX key1 value1 [key2 value2..]`	批量设置键值对，仅当参数中所有的key都不存在时执行	127.0.0.1:6379> MSETNX k1 v1 k4 v4 (integer) 0
`getset key value`	如果不存在值，则返回nil，如果存在值，获取原来的值，并设置新的值	127.0.0.1:6379> getset db mongodb “redis”

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

# 这里的key：user:{id}:{field}
127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "zhangsan"
2) "2"

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

计数器
统计多单位的数量
粉丝数
对象缓存存储

List（列表）

基本的数据类型，列表

我们的列表，可以经过规定定义将其变为队列、栈、双端队列等

狂神docker 笔记狂神redis_狂神docker 笔记_11

正如图Redis中List是可以进行双端操作的，所以命令也就分为了LXXX和RLLL两类，有时候L也表示List例如LLEN

命令	描述
`LPUSH/RPUSH key value1[value2..]`	从左边/右边向列表中PUSH值(一个或者多个)。
`LRANGE key start end`	获取list 起止元素==（索引从左往右递增）==
LPOP/RPOP key	从最左边/最右边移除值并返回
`LINDEX key index`	通过索引获取列表元素
`LLEN key`	查看列表长度
`LREM key count value`	List中是允许value重复的 `count > 0`：从头部开始搜索然后删除指定的value 至多删除count个 `count < 0`：从尾部开始搜索… `count = 0`：删除列表中所有的指定value。
`LTRIM key start end`	通过下标截取指定范围内的列表
`RPOPLPUSH source destination`	将列表的尾部(右)最后一个值弹出，并返回，然后加到另一个列表的头部
`LSET key index value`	通过索引为元素设值（更新数值）
`LINSERT key BEFORE\|AFTER pivot value`	在指定列表元素的前/后插入value

---------------------------LPUSH---RPUSH---LRANGE--------------------------------

127.0.0.1:6379> LPUSH mylist k1 # LPUSH mylist=>{1}
(integer) 1
127.0.0.1:6379> LPUSH mylist k2 # LPUSH mylist=>{2,1}
(integer) 2
127.0.0.1:6379> RPUSH mylist k3 # RPUSH mylist=>{2,1,3}
(integer) 3
127.0.0.1:6379> get mylist # 普通的get是无法获取list值的
(error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379> LRANGE mylist 0 4 # LRANGE 获取起止位置范围内的元素
1) "k2"
2) "k1"
3) "k3"
127.0.0.1:6379> LRANGE mylist 0 2
1) "k2"
2) "k1"
3) "k3"
127.0.0.1:6379> LRANGE mylist 0 1
1) "k2"
2) "k1"
127.0.0.1:6379> LRANGE mylist 0 -1 # 获取全部元素
1) "k2"
2) "k1"
3) "k3"

---------------------------LPUSHX---RPUSHX-----------------------------------

127.0.0.1:6379> LPUSHX list v1 # list不存在 LPUSHX失败
(integer) 0
127.0.0.1:6379> LPUSHX list v1 v2  
(integer) 0
127.0.0.1:6379> LPUSHX mylist k4 k5 # 向mylist中 左边 PUSH k4 k5
(integer) 5
127.0.0.1:6379> LRANGE mylist 0 -1
1) "k5"
2) "k4"
3) "k2"
4) "k1"
5) "k3"

---------------------------LINSERT--LLEN--LINDEX--LSET----------------------------

127.0.0.1:6379> LINSERT mylist after k2 ins_key1 # 在k2元素后 插入ins_key1
(integer) 6
127.0.0.1:6379> LRANGE mylist 0 -1
1) "k5"
2) "k4"
3) "k2"
4) "ins_key1"
5) "k1"
6) "k3"
127.0.0.1:6379> LLEN mylist # 查看mylist的长度
(integer) 6
127.0.0.1:6379> LINDEX mylist 3 # 获取下标为3的元素
"ins_key1"
127.0.0.1:6379> LINDEX mylist 0
"k5"
127.0.0.1:6379> LSET mylist 3 k6 # 将下标3的元素 set值为k6
OK
127.0.0.1:6379> LRANGE mylist 0 -1
1) "k5"
2) "k4"
3) "k2"
4) "k6"
5) "k1"
6) "k3"

---------------------------LPOP--RPOP--------------------------

127.0.0.1:6379> LPOP mylist # 左侧(头部)弹出
"k5"
127.0.0.1:6379> RPOP mylist # 右侧(尾部)弹出
"k3"

---------------------------RPOPLPUSH--------------------------

127.0.0.1:6379> LRANGE mylist 0 -1
1) "k4"
2) "k2"
3) "k6"
4) "k1"
127.0.0.1:6379> RPOPLPUSH mylist newlist # 将mylist的最后一个值(k1)弹出，加入到newlist的头部
"k1"
127.0.0.1:6379> LRANGE newlist 0 -1
1) "k1"
127.0.0.1:6379> LRANGE mylist 0 -1
1) "k4"
2) "k2"
3) "k6"

---------------------------LTRIM--------------------------

127.0.0.1:6379> LTRIM mylist 0 1 # 截取mylist中的 0~1部分
OK
127.0.0.1:6379> LRANGE mylist 0 -1
1) "k4"
2) "k2"

# 初始 mylist: k2,k2,k2,k2,k2,k2,k4,k2,k2,k2,k2
---------------------------LREM--------------------------

127.0.0.1:6379> LREM mylist 3 k2 # 从头部开始搜索 至多删除3个 k2
(integer) 3
# 删除后：mylist: k2,k2,k2,k4,k2,k2,k2,k2

127.0.0.1:6379> LREM mylist -2 k2 #从尾部开始搜索 至多删除2个 k2
(integer) 2
# 删除后：mylist: k2,k2,k2,k4,k2,k2


---------------------------BLPOP--BRPOP--------------------------

mylist: k2,k2,k2,k4,k2,k2
newlist: k1

127.0.0.1:6379> BLPOP newlist mylist 30 # 从newlist中弹出第一个值，mylist作为候选
1) "newlist" # 弹出
2) "k1"
127.0.0.1:6379> BLPOP newlist mylist 30
1) "mylist" # 由于newlist空了 从mylist中弹出
2) "k2"
127.0.0.1:6379> BLPOP newlist 30
(30.10s) # 超时了

127.0.0.1:6379> BLPOP newlist 30 # 我们连接另一个客户端向newlist中push了test, 阻塞被解决。
1) "newlist"
2) "test"
(12.54s)

小结

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

应用：

消息排队！消息队列（Lpush Rpop），栈（Lpush，Lpop）

Set（集合）

set是string类型的无序集合。集合是唯一的，这就意味着集合中不能出现重复的数据
Redis中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)
集合中最大的成员数为232-1（4294967295，每个集合可存储40多亿个成员）

命令	描述
`SADD key member1[member2..]`	向集合中无序增加一个/多个成员
`SMEMBERS key`	返回集合中所有的成员
`SISMEMBER key member`	查询member元素是否是集合的成员,结果是无序的
`SCARD key`	获取集合的成员数
`SREM key member1[member2..]`	移除集合中一个/多个成员
`SRANDMEMBER key [count]`	随机返回集合中count个成员，count缺省值为1
`SPOP key [count]`	随机移除并返回集合中count个成员，count缺省值为1
`SMOVE source destination member`	将source集合的成员member移动到destination集合
`SDIFF key1[key2..]`	返回所有集合的差集 key1- key2 -
`SINTER key1 [key2..]`	返回所有集合的交集
`SUNION key1 [key2..]`	返回所有集合的并集
`SUNIONSTORE destination key1 [key2..]`	在SUNION的基础上，存储结果到及和张。覆盖
`SSCAN KEY [MATCH pattern] [COUNT count]`	在大量数据环境下，使用此命令遍历集合中元素，每次遍历部分

---------------SADD--SCARD--SMEMBERS--SISMEMBER--------------------

127.0.0.1:6379> SADD myset m1 m2 m3 m4 # 向myset中增加成员 m1~m4
(integer) 4
127.0.0.1:6379> SCARD myset # 获取集合的成员数目
(integer) 4
127.0.0.1:6379> smembers myset # 获取集合中所有成员
1) "m4"
2) "m3"
3) "m2"
4) "m1"
127.0.0.1:6379> SISMEMBER myset m5 # 查询m5是否是myset的成员
(integer) 0 # 不是，返回0
127.0.0.1:6379> SISMEMBER myset m2
(integer) 1 # 是，返回1
127.0.0.1:6379> SISMEMBER myset m3
(integer) 1

---------------------SRANDMEMBER--SPOP----------------------------------

127.0.0.1:6379> SRANDMEMBER myset 3 # 随机返回3个成员
1) "m2"
2) "m3"
3) "m4"
127.0.0.1:6379> SRANDMEMBER myset # 随机返回1个成员
"m3"
127.0.0.1:6379> SPOP myset 2 # 随机移除并返回2个成员
1) "m1"
2) "m4"
# 将set还原到{m1,m2,m3,m4}

---------------------SMOVE--SREM----------------------------------------

127.0.0.1:6379> SMOVE myset newset m3 # 将myset中m3成员移动到newset集合
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "m4"
2) "m2"
3) "m1"
127.0.0.1:6379> SMEMBERS newset
1) "m3"
127.0.0.1:6379> SREM newset m3 # 从newset中移除m3元素
(integer) 1
127.0.0.1:6379> SMEMBERS newset
(empty list or set)

# 下面开始是多集合操作,多集合操作中若只有一个参数默认和自身进行运算
# setx=>{m1,m2,m4,m6}, sety=>{m2,m5,m6}, setz=>{m1,m3,m6}

-----------------------------SDIFF------------------------------------

127.0.0.1:6379> SDIFF setx sety setz # 等价于setx-sety-setz
1) "m4"
127.0.0.1:6379> SDIFF setx sety # setx - sety
1) "m4"
2) "m1"
127.0.0.1:6379> SDIFF sety setx # sety - setx
1) "m5"


-------------------------SINTER---------------------------------------
# 共同关注（交集）

127.0.0.1:6379> SINTER setx sety setz # 求 setx、sety、setx的交集
1) "m6"
127.0.0.1:6379> SINTER setx sety # 求setx sety的交集
1) "m2"
2) "m6"

-------------------------SUNION---------------------------------------

127.0.0.1:6379> SUNION setx sety setz # setx sety setz的并集
1) "m4"
2) "m6"
3) "m3"
4) "m2"
5) "m1"
6) "m5"
127.0.0.1:6379> SUNION setx sety # setx sety 并集
1) "m4"
2) "m6"
3) "m2"
4) "m1"
5) "m5"

微博，A用户将所有关注的人放在一个set集合中！将它的粉丝也放在一个集合中！

共同关注，共同爱好，二度好友，推荐好友（六度分割理论）

Hash（哈希）

hash是一个string类型的filed和value的映射表，hash特别适合用于存储对象
Set就是一种简化的Hash，只变动key，而value使用默认值填充。可以将一个Hash表作为一个对象进行存储，表中存放对象的信息

命令	描述
`HSET key field value`	将哈希表 key 中的字段 field 的值设为 value 。重复设置同一个field会覆盖,返回0
`HGET key field value`	获取存储在哈希表中指定字段的值
`HGET key field value`	获取存储在哈希表中指定字段的值
`HMGET key field1 [field2..]`	获取所有给定字段的值
`HGETALL key`	获取在哈希表key 的所有字段和值
`HDEL key field1 [field2..]`	删除哈希表key中一个/多个field字段
`HLEN key`	获取哈希表中字段的数量
`HEXISTS key field`	查看哈希表 key 中，指定的字段是否存在。
`HKEYS key`	获取哈希表key中所有的字段
`HINCRBY key field n`	为哈希表 key 中的指定字段的整数值加上增量n，并返回增量后结果一样只适用于整数型字段
`HSETNX key field value`	只有在字段 field 不存在时，设置哈希表字段的值。
`HINCRBYFLOAT key field n`	为哈希表 key 中的指定字段的浮点数值加上增量 n。
HSCAN key cursor [MATCH pattern] [COUNT count]	迭代哈希表中的键值对。

------------------------HSET--HMSET--HSETNX----------------
127.0.0.1:6379> HSET studentx name sakura # 将studentx哈希表作为一个对象，设置name为sakura
(integer) 1
127.0.0.1:6379> HSET studentx name gyc # 重复设置field进行覆盖，并返回0
(integer) 0
127.0.0.1:6379> HSET studentx age 20 # 设置studentx的age为20
(integer) 1
127.0.0.1:6379> HMSET studentx sex 1 tel 15623667886 # 设置sex为1，tel为15623667886
OK
127.0.0.1:6379> HSETNX studentx name gyc # HSETNX 设置已存在的field
(integer) 0 # 失败
127.0.0.1:6379> HSETNX studentx email 12345@qq.com
(integer) 1 # 成功

----------------------HEXISTS--------------------------------
127.0.0.1:6379> HEXISTS studentx name # name字段在studentx中是否存在
(integer) 1 # 存在
127.0.0.1:6379> HEXISTS studentx addr
(integer) 0 # 不存在

-------------------HGET--HMGET--HGETALL-----------
127.0.0.1:6379> HGET studentx name # 获取studentx中name字段的value
"gyc"
127.0.0.1:6379> HMGET studentx name age tel # 获取studentx中name、age、tel字段的value
1) "gyc"
2) "20"
3) "15623667886"
127.0.0.1:6379> HGETALL studentx # 获取studentx中所有的field及其value
 1) "name"
 2) "gyc"
 3) "age"
 4) "20"
 5) "sex"
 6) "1"
 7) "tel"
 8) "15623667886"
 9) "email"
10) "12345@qq.com"


--------------------HKEYS--HLEN--HVALS--------------
127.0.0.1:6379> HKEYS studentx # 查看studentx中所有的field
1) "name"
2) "age"
3) "sex"
4) "tel"
5) "email"
127.0.0.1:6379> HLEN studentx # 查看studentx中的字段数量
(integer) 5
127.0.0.1:6379> HVALS studentx # 查看studentx中所有的value
1) "gyc"
2) "20"
3) "1"
4) "15623667886"
5) "12345@qq.com"

-------------------------HDEL--------------------------
127.0.0.1:6379> HDEL studentx sex tel # 删除studentx 中的sex、tel字段
(integer) 2
127.0.0.1:6379> HKEYS studentx
1) "name"
2) "age"
3) "email"

-------------HINCRBY--HINCRBYFLOAT------------------------
127.0.0.1:6379> HINCRBY studentx age 1 # studentx的age字段数值+1
(integer) 21
127.0.0.1:6379> HINCRBY studentx name 1 # 非整数字型字段不可用
(error) ERR hash value is not an integer
127.0.0.1:6379> HINCRBYFLOAT studentx weight 0.6 # weight字段增加0.6
"90.8"

应用：

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

Zset（有序集合）

与set不同的是每个元素都会关联一个double类型的分数（score）。redis正是通过分数来为集合中的成员进行从小到大的排序
score相同：按字典顺序排序
有序集合的成员是唯一的，但分数（score）却可以重复

命令	描述
`ZADD key score member1 [score2 member2]`	向有序集合添加一个或多个成员，或者更新已存在成员的分数
`ZRANGEBYSCORE key min max`	通过分数返回有序集合指定区间内的成员==-inf 和 +inf分别表示最小最大值，只支持开区间()==
`ZCARD key`	获取有序集合的成员数
`ZCOUNT key min max`	计算在有序集合中指定区间score的成员数
`ZINCRBY key n member`	有序集合中对指定成员的分数加上增量 n
`ZSCORE key member`	返回有序集中，成员的分数值
`ZRANK key member`	返回有序集合中指定成员的索引
`ZRANGE key start end`	通过索引区间返回有序集合成指定区间内的成员
`ZRANGEBYLEX key min max`	通过字典区间返回有序集合的成员
`ZRANGEBYSCORE key min max`	通过分数返回有序集合指定区间内的成员==-inf 和 +inf分别表示最小最大值，只支持开区间()==
`ZLEXCOUNT key min max`	在有序集合中计算指定字典区间内成员数量
`ZREM key member1 [member2..]`	移除有序集合中一个/多个成员
`ZREMRANGEBYLEX key min max`	移除有序集合中给定的字典区间的所有成员
`ZREMRANGEBYRANK key start stop`	移除有序集合中给定的排名区间的所有成员
`ZREVRANGE key start end`	返回有序集中指定区间内的成员，通过索引，分数从高到底
`ZREVRANGEBYSCORRE key max min`	返回有序集中指定分数区间内的成员，分数从高到低排序
`ZREVRANGEBYLEX key max min`	返回有序集中指定字典区间内的成员，按字典顺序倒序
`ZREVRANK key member`	返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
`ZINTERSTORE destination numkeys key1 [key2 ..]`	计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中，numkeys：表示参与运算的集合数，将score相加作为结果的score
`ZUNIONSTORE destination numkeys key1 [key2..]`	计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中
`ZSCAN key cursor [MATCH pattern\] [COUNT count]`	迭代有序集合中的元素（包括元素成员和元素分值）

-------------------ZADD--ZCARD--ZCOUNT--------------
127.0.0.1:6379> ZADD myzset 1 m1 2 m2 3 m3 # 向有序集合myzset中添加成员m1 score=1 以及成员m2 score=2..
(integer) 2
127.0.0.1:6379> ZCARD myzset # 获取有序集合的成员数
(integer) 2
127.0.0.1:6379> ZCOUNT myzset 0 1 # 获取score在 [0,1]区间的成员数量
(integer) 1
127.0.0.1:6379> ZCOUNT myzset 0 2
(integer) 2

----------------ZINCRBY--ZSCORE--------------------------
127.0.0.1:6379> ZINCRBY myzset 5 m2 # 将成员m2的score +5
"7"
127.0.0.1:6379> ZSCORE myzset m1 # 获取成员m1的score
"1"
127.0.0.1:6379> ZSCORE myzset m2
"7"

--------------ZRANK--ZRANGE-----------------------------------
127.0.0.1:6379> ZRANK myzset m1 # 获取成员m1的索引，索引按照score排序，score相同索引值按字典顺序顺序增加
(integer) 0
127.0.0.1:6379> ZRANK myzset m2
(integer) 2
127.0.0.1:6379> ZRANGE myzset 0 1 # 获取索引在 0~1的成员
1) "m1"
2) "m3"
127.0.0.1:6379> ZRANGE myzset 0 -1 # 获取全部成员
1) "m1"
2) "m3"
3) "m2"

#testset=>{abc,add,amaze,apple,back,java,redis} score均为0
------------------ZRANGEBYLEX---------------------------------
127.0.0.1:6379> ZRANGEBYLEX testset - + # 返回所有成员
1) "abc"
2) "add"
3) "amaze"
4) "apple"
5) "back"
6) "java"
7) "redis"
127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 0 3 # 分页 按索引显示查询结果的 0,1,2条记录
1) "abc"
2) "add"
3) "amaze"
127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 3 3 # 显示 3,4,5条记录
1) "apple"
2) "back"
3) "java"
127.0.0.1:6379> ZRANGEBYLEX testset (- [apple # 显示 (-,apple] 区间内的成员
1) "abc"
2) "add"
3) "amaze"
4) "apple"
127.0.0.1:6379> ZRANGEBYLEX testset [apple [java # 显示 [apple,java]字典区间的成员
1) "apple"
2) "back"
3) "java"

-----------------------ZRANGEBYSCORE---------------------
127.0.0.1:6379> ZRANGEBYSCORE myzset 1 10 # 返回score在 [1,10]之间的的成员
1) "m1"
2) "m3"
3) "m2"
127.0.0.1:6379> ZRANGEBYSCORE myzset 1 5
1) "m1"
2) "m3"

--------------------ZLEXCOUNT-----------------------------
127.0.0.1:6379> ZLEXCOUNT testset - +
(integer) 7
127.0.0.1:6379> ZLEXCOUNT testset [apple [java
(integer) 3

------------------ZREM--ZREMRANGEBYLEX--ZREMRANGBYRANK--ZREMRANGEBYSCORE--------------------------------
127.0.0.1:6379> ZREM testset abc # 移除成员abc
(integer) 1
127.0.0.1:6379> ZREMRANGEBYLEX testset [apple [java # 移除字典区间[apple,java]中的所有成员
(integer) 3
127.0.0.1:6379> ZREMRANGEBYRANK testset 0 1 # 移除排名0~1的所有成员
(integer) 2
127.0.0.1:6379> ZREMRANGEBYSCORE myzset 0 3 # 移除score在 [0,3]的成员
(integer) 2


# testset=> {abc,add,apple,amaze,back,java,redis} score均为0
# myzset=> {(m1,1),(m2,2),(m3,3),(m4,4),(m7,7),(m9,9)}
----------------ZREVRANGE--ZREVRANGEBYSCORE--ZREVRANGEBYLEX-----------
127.0.0.1:6379> ZREVRANGE myzset 0 3 # 按score递减排序，然后按索引，返回结果的 0~3
1) "m9"
2) "m7"
3) "m4"
4) "m3"
127.0.0.1:6379> ZREVRANGE myzset 2 4 # 返回排序结果的 索引的2~4
1) "m4"
2) "m3"
3) "m2"
127.0.0.1:6379> ZREVRANGEBYSCORE myzset 6 2 # 按score递减顺序 返回集合中分数在[2,6]之间的成员
1) "m4"
2) "m3"
3) "m2"
127.0.0.1:6379> ZREVRANGEBYLEX testset [java (add # 按字典倒序 返回集合中(add,java]字典区间的成员
1) "java"
2) "back"
3) "apple"
4) "amaze"

-------------------------ZREVRANK------------------------------
127.0.0.1:6379> ZREVRANK myzset m7 # 按score递减顺序，返回成员m7索引
(integer) 1
127.0.0.1:6379> ZREVRANK myzset m2
(integer) 4


# mathscore=>{(xm,90),(xh,95),(xg,87)} 小明、小红、小刚的数学成绩
# enscore=>{(xm,70),(xh,93),(xg,90)} 小明、小红、小刚的英语成绩
-------------------ZINTERSTORE--ZUNIONSTORE-----------------------------------
127.0.0.1:6379> ZINTERSTORE sumscore 2 mathscore enscore # 将mathscore enscore进行合并 结果存放到sumscore
(integer) 3
127.0.0.1:6379> ZRANGE sumscore 0 -1 withscores # 合并后的score是之前集合中所有score的和
1) "xm"
2) "160"
3) "xg"
4) "177"
5) "xh"
6) "188"

127.0.0.1:6379> ZUNIONSTORE lowestscore 2 mathscore enscore AGGREGATE MIN # 取两个集合的成员score最小值作为结果的
(integer) 3
127.0.0.1:6379> ZRANGE lowestscore 0 -1 withscores
1) "xm"
2) "70"
3) "xg"
4) "87"
5) "xh"
6) "93"

案例思路：set 排序存储班级成绩表，工资表排序！

普通消息，1，重要消息 2，带权重进行判断

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

三大特殊数据类型

geospatial 地理位置

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

Redis对Geo在Redis3.2版本就推出了！这个功能可以推算出地理位置，两地之间的距离，方圆几里

的人！

只有6个方法

geoadd

# geoadd 添加地理位置
# 规则：两级不发天机，我们一般会下载城市数据。直接通过java程序一次性导入
#  有效的经度从-180度到180度。
# 有效的纬度从-85.05112878度到85.05112878度。
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 106.50 29.53 chongqi
(integer) 1
127.0.0.1:6379> geoadd china:city 114.05 22.52 shengzhen
(integer) 1
127.0.0.1:6379> geoadd china:city 120.16 30.24 hangzhou 108.96 34.26 xian
(integer) 2

geopos

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

127.0.0.1:6379> geopos china:city beijin chongqi #获取指定城市的经度和纬度
1) 1) "116.39999896287918091"
   2) "39.90000009167092543"
2) 1) "106.49999767541885376"
   2) "29.52999957900659211"

geodist

两人之间的距离！

单位：

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

127.0.0.1:6379> geodist china:city beijin shanghai km
"1067.3788"
127.0.0.1:6379> geodist china:city beijin chongqi km
"1464.0708"

georadius-以给定的经纬度为中心，找出某一半径内的元素

我附近的人？（获得所有附件的人的地址，定位！）通过半径来查询！

获取指定数量的人，200

所有的数据应该录入:china:city,才会让结果更加请求

127.0.0.1:6379> georadius china:city 110 30 1000 km #以110 30 这个经纬度为中心，寻找方圆1000km内的城市
1) "chongqi"
2) "xian"
3) "shengzhen"
4) "hangzhou"
127.0.0.1:6379> georadius china:city 110 30 500 km
1) "chongqi"
2) "xian"
127.0.0.1:6379> georadius china:city 110 30 500 km withdist withcoord count 1 #withdist 显示到中心距离的位置 withcoord显示他人的定位信息
1) 1) "chongqi"
   2) "341.9374"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"
127.0.0.1:6379> georadius china:city 110 30 500 km withdist withcoord count 2 #筛选出指定的结果
1) 1) "chongqi"
   2) "341.9374"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"
2) 1) "xian"
   2) "483.8340"
   3) 1) "108.96000176668167114"
      2) "34.25999964418929977"

georadiusbymember -找出指定范围内的元素，中心点是由给定的位置元素决定

# 找出位于指定元素周围的其他元素
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 -返回一个或多个位置元素的geohash表示

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

# 将二维的经纬度转换为，如果两个字符串越接近，那么则距离越近
127.0.0.1:6379> geohash china:city beijin chongqi
1) "wx4fbxxfke0"
2) "wm5xzrybty0"

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

127.0.0.1:6379> zrange china:city 0 -1 #查看地图中全部的元素
1) "chongqi"
2) "xian"
3) "shengzhen"
4) "hangzhou"
5) "shanghai"
6) "beijin"
127.0.0.1:6379> zrem china:city beijin #移除指定元素
(integer) 1
127.0.0.1:6379> zrange china:city 0 -1
1) "chongqi"
2) "xian"
3) "shengzhen"
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内存！

网页的UV（一个人访问一个网站多次，但是还是算作一个人！）

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

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

测试使用

127.0.0.1:6379> pfadd mykey a b c d e f g h i j #创建第一组元素mykey
(integer) 1
127.0.0.1:6379> pfcount mykey #统计mykey 元素的基数数量
(integer) 10
127.0.0.1:6379> pfadd mykey2 i j z x c v b n m # 创建第二组元素 mykey2
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 9
127.0.0.1:6379> pfmerge mykey3 mykey mykey2 #合并两组 mykey mykey2 =>mykey3 并集
OK
127.0.0.1:6379> pfcount mykey3 #查看并集的数量
(integer) 15

如果运行容错，那么一定可以使用Hyperloglog！

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

Bitmaps

位存储

统计用户信息，活跃，不活跃！登录，未登录！打卡，365打卡！两个状态的，都可以使用BItmaps位图，数据结构！都是操作系统二进制来进行记录，就只有0和1两个状态1

365天 =365 bit 1字节 = 8bit 46字节

测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1csjL5NV-1635168391625)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635065830612.png)]

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

周一：1 周二：0…

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TptkIBnz-1635168391625)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635065490863.png)]

查看某一个是否有打卡

127.0.0.1:6379> getbit sign 3
(integer) 1
127.0.0.1:6379> getbit sign 6
(integer) 0

统计操作，统计打卡的天数

127.0.0.1:6379> bitcount sign #统计这周打卡的天数，就可以看到是否有全勤
(integer) 3

事务

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

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

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

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

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

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

redis的事务：

开启事务(multi)
命令入队()
执行事务()

正常执行事务！

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"
127.0.0.1:6379>

监控！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
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> unwatch  # 如果发现事务执行失败，就先解锁
OK
127.0.0.1:6379> watch money # 2.获取最新的值，在次监视，select version
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby money 1
QUEUED
127.0.0.1:6379> incrby out 1
QUEUED
127.0.0.1:6379> exec # 比对监视的值是否发生了变化，如果没有变化，那么可以执行成功，如果变化执行失败
1) (integer) 999

Jedis

我们要使用Java来操作Redis

什么是Jedis 是Redis 官方推荐的Java连接开发工具
测试

1、导入对应的依赖

<dependencies>
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.6.0</version>
    </dependency>
<!--    fastjson-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.78</version>
    </dependency>
</dependencies>

2、编码测试：

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

package com.zht;

import redis.clients.jedis.Jedis;

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());
    }
}

输出：

pong

常用的API

String

List

Set

Hash

Zset

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

package com.zht;

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

public class TestTX {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);

        jedis.flushDB();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello","world");
        jsonObject.put("name","zht");
        // 开启事务
        Transaction multi = jedis.multi();
        String s = jsonObject.toJSONString();
//        jedis.watch(s);
        try {
            multi.set("user1",s);
            multi.set("user2",s);
            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

SpringBoot操作数据：Spring-data Jpa jdbc mongodb redis！

SpringData 也是和SpringBoot齐名的项目！

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

jedis：

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

源码分析：

@Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )// 我们可以定义一个redisTemplate来替换这个默认的
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        // 默认的 RedisTemplate 没有过多的设置，redis 对象都是想要序列化！Dubbo
        // 两个泛型都是Object，objext类型，后面我们需要强制转换<String,Object>
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

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

整合测试以下

导入依赖

<!--        操作redis-->
        <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

3.测试

package com.zht;

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
        // opsForHash
        // opsForGeo
        // opsForZSet
        //opsForHyperLogLog

        // 除了基本的操作，我们常用的方法都可以直接通过 redisTemplate，比如事务、基本的CRUD
//        获取redis的连接对象
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushDb();
//        connection.flushAll();
        redisTemplate.opsForValue().set("mykey","郑海韬");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }

}

redis为什么要序列化-Redis-PHP中文网

序列化配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8n6sonmj-1635168391626)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635083121228.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9ogRc9fU-1635168391627)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635083197503.png)]

关于对象的保存：
所有的对象都需要序列化序列化为了持久化对象，并且可以通过网络传输对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZR2rKFUq-1635168391628)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635085974262.png)]

我们来编写一个自己的 RedisTemplete

package com.zht.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
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;

@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);
        // 序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方法采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

void contextLoads() {

        // 再企业开发中，我们80%的情况下，都不会调用原生的方式去编写代码
        // RedisUtils

        // redisTemplate 操作不同的数据类型，api和我们的指令是一样的
        // opsForValue 操作字符串  类似String
        // opsForList 操作list 类似list
        // opsForSet
        // opsForHash
        // opsForGeo
        // opsForZSet
        //opsForHyperLogLog

        // 除了基本的操作，我们常用的方法都可以直接通过 redisTemplate，比如事务、基本的CRUD
//        获取redis的连接对象
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushDb();
//        connection.flushAll();
        redisTemplate.opsForValue().set("mykey","郑海韬");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }

自定义Redis工具类

使用RedisTemplate需要频繁调用.opForxxx然后才能进行对应的操作，这样使用起来代码效率低下，**工作中一般不会这样使用，而是将这些常用的公共API抽取出来封装成为一个工具类，然后直接使用工具类来间接操作Redis,**不但效率高并且易用。

工具类参考博客：

Redis.conf

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

单位

狂神docker 笔记狂神redis_nosql_12

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

包含

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6PfjxRjg-1635168391629)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635126068375.png)]

网络配置

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

快照

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

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

# 如果900s内，如果有一个key进行了修改，我们及进行持久化操作
save 900 1
# 如果300s内，如果有10个key进行了修改，我们及进行持久化操作
save 300 10
# 如果60s内，如果有10000个key进行了修改，我们及进行持久化操作
save 60 10000
# 我们之后学习持久化，会自己定义这个测试

stop-writes-on-bgsave-error yes #持久化出错了，是否还需要继续工作

rdbcompression yes # 是否压缩rdb文件，需要消耗一些CPU资源

rdbchecksum yes # 保存rdb文件的时候，遇到错误的检查校验

dir ./ #rdb文件保存的目录

REPLICATION 复制，后面讲解主从复制，在进行讲解
SECURITY

可以在这里设置redis的密码，默认是没有密码的

127.0.0.1:6379> ping
PONG
127.0.0.1:6379> config get requirepass # 获取redis的密码
1) "requirepass"
2) ""
127.0.0.1:6379> config set requirepass "123456" #设置redis的密码
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`
(error) ERR invalid password
127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> ping
PONG

限制 CLIENTS

maxclients 1000 # 设置能连接上Redis的最大客户端数量
maxmemory <bytes> #redis 配置最大的内存容量
maxmemory-policy noeviction #内存达到上限之后的处理策略
1、volatile-lru：只对设置了过期时间的key进行LRU（默认值） 
2、allkeys-lru ： 删除lru算法的key   
3、volatile-random：随机删除即将过期key   
4、allkeys-random：随机删除   
5、volatile-ttl ： 删除即将过期的   
6、noeviction ： 永不过期，返回错误

APPEND ONLY M

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

Redis持久化

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

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

RDB(Redis DataBase)

什么是RDB

在主从复制中，rdb就是备用了！从机上面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0KCGKQXV-1635168391629)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635130633845.png)]

在指定的时间间隔中将内存中的数据快照写入磁盘，也就是行话说的快照，它恢复时将快照文件直接读到内存里。

Redis会单独创建(fork)一个子进程来进行持久化，会将数据写入到一个临时文件，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能。如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加高效。RDB的缺点是最后一层持久化后的数据可能丢失。我们默认的就是RDB，一般情况下不需要修改这个配置！

rdb保存的文件是 dump.rdb 都是在我们配置文件中快照

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-npVSyZ4s-1635168391630)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635131856831.png)]

触发机制

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

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

3.退出redis，也会生成rdb文件

备份就自动生成dump.rdb

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BZ5yApJK-1635168391630)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635132201548.png)]

如何恢复rdb文件！

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

2.查看需要存在的位置

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

几乎默认的配置就够用了

优点：

适合大规模的数据恢复
对数据的完整性要求不高！

缺点：

需要一定的时间间隔进程操作！如果redis意外宕机了，这个最后一次修改数据就没有了
fork进程的时候，会占用一定的内存空间

AOF(Append only File)

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

是什么

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hhc6jRcx-1635168391631)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635141301955.png)]

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

Aof保存的是appendonly.aof文件

append

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hE9zEp9L-1635168391631)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635143193571.png)]

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

重启，redis就可以生效了

如果这个时候aof文件有错误，这时候redis是启动不起来的，我们需要修复这个aof文件

redis给我们提供了一个工具redis-check-aof

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qKueBVGJ-1635168391632)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635145032571.png)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UtT5Cbcy-1635168391632)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635145110469.png)]

重写规则说明

aof默认就是文件的无线增加，文件越来越大

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ARyQvjyy-1635168391633)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635145636446.png)]

如果aof 文件大于 64m，太大了！fork一个新的进程来将我们的文件进行重写

优点和缺点

优点：

每一次修改都同步，文件完整性会更加好！
每秒同步一次，可能会丢失一秒的数据
从不同步，效率最高的

缺点：

相对于数据文件来说，aop远远大于rdb，修复的速度也比rdb慢
aof运行效率也要比rdb慢，所以我们redis默认的配置是rdb而不是aof

扩展︰
1、RDB持久化方式能够在指定的时间间隔内对你的数据进行快照存储
2、AOF持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据，AOF命令以Redis 协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不至于过大。
3、只做缓存，如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何持久化
4、同时开启两种持久化方式

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

5、性能建议

·因为RDB文件只用作后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟备份一次就够了，只保留save 9001这条
规则。
如果Enable AOF，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持续的lO，二是AOF rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值。
如果不Enable AOF，仅靠Master-Slave Repllcation实现高可用性也可以，能省掉一大笔lO，也减少了rewrite时带来的系统波动。代价是如果Master/Slave同时倒掉，会丢失十几分钟的数据，启动脚本也要比较两个Master/Slave 中的RDB文件，载入较新的那个，微博就是这种架构。

Redis发布订阅

线程通信队列发送者订阅者

Redis发布订阅（psb/sub）是一种消息通信模式：发送者（pub）发送消息，订阅者（sub）接收消息。微信、微博。关注系统

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

订阅/发布消息图：

第一个：消息发送者，第二个：频道，第三个：消息订阅者！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q4JXvQc1-1635168391633)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635146737896.png)]

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

狂神docker 笔记狂神redis_redis_13

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

狂神docker 笔记狂神redis_狂神docker 笔记_14

命令

命令	描述
`PSUBSCRIBE pattern [pattern..]`	订阅一个或多个符合给定模式的频道。
pubsub subcommand [argument[argument]]	查看订阅与发布系统状态
publish channel message（消息提供者）	将信息发送到指定的频道
punsubscribe [pattern[pattern]…]	退订所有给定模式的频道
subscribe channel [channel…]（消息订阅者）	订阅给定的一个或多个频道的信息
unsubscribe channel [channel…]	指退订给定的频道

测试

订阅端：

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

发送端：

127.0.0.1:6379> publish zhtstudy "hello,zht" #发布者发步消息到频道
(integer) 1
127.0.0.1:6379> publish zhtstudy "hello,redis" #发布者发布消息到频道
(integer) 1
127.0.0.1:6379>

原理

redis是通过publish、subscribe、和psubscribe等命令实现发布和订阅功能
通过subscribe命令订阅某频道后，redis-server里维护了一个字典，字典的键就是一个个的channel（通道、频道），而字典的值则是一个链表，链表中保存了所有订阅这个channel的客户端。subscribe命令的关键，就是讲客户端添加到给定channel的订阅链表中。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hsnhs6XF-1635168391634)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635151894042.png)]

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

pub/sub在字面上理解就是发布（publish）与订阅（subscribe），在redis中，你可以设定对某个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅它的客户端都会受到相应的消息，这一功能最明显的用法就是用作实时消息系统，例如群聊等

Redis主从复制

概念

主从复制，是指一台redis服务器的数据，复制到其他的Redis服务器。前者称为主节点，后者称为从节点；数据的复制是单向的，只能由主节点到从节点。Master以写为主，slave以读为主·

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

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

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

一般来说，要将Redis运用于工程项目中，只能使用一台Redis是万万不能的（宕机，一主二从）

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

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

电商网站上的商品，一般都是一次上传，无数次浏览，说专业点就是“读多写少”

对于这种情况，我们使用以下这种架构：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HvS3By2x-1635168391634)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635152313432.png)]

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

只要在公司中，主从复制就是必须要使用的，因为在真实的项目中

环境配置

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

127.0.0.1:6379> info replication # 查看当前库的信息
# Replication
role:master #角色
connected_slaves:0 #从机的个数
master_replid:e71e0dc59630934da74a742b88873c3590fb18b9
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte

复制3个配置文件，然后修改对应的信息

1.端口

2.pid 名字

3.log 文件名字

4.dump.rdb名字

修改完毕之后吗，启动我们的3个redis服务器，可以通过进程信息查看

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B7wlRKMR-1635168391635)(C:\Users\User\AppData\Roaming\Typora\typora-user-images\1635155154287.png)]

一主二从

默认情况下，每台Redis服务器都是有主节点；我们一般情况下只用配置从机就好了

认老大！一主（79）二从（80、81）

127.0.0.1:6380> SLAVEOF 127.0.0.1 6379   #  SLAVEOF host 6379  找谁当自己的老大！
OK
127.0.0.1:6380> info replication 
# Replication
role:slave  # 当前角色是从机
master_host:127.0.0.1   # 可以的看到主机的信息 
master_port:6379 
master_link_status:up 
master_last_io_seconds_ago:3 
master_sync_in_progress:0 
slave_repl_offset:14 
slave_priority:100 
slave_read_only:1 
connected_slaves:0 master_replid:a81be8dd257636b2d3e7a9f595e69d73ff03774e
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:6379> info replication
# Replication 
role:master connected_slaves:1  # 多了从机的配置
slave0:ip=127.0.0.1,port=6380,state=online,offset=42,lag=1    # 多了从机的配置
master_replid:a81be8dd257636b2d3e7a9f595e69d73ff03774e
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:42
second_repl_offset:-1 
repl_backlog_active:1 
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1 
repl_backlog_histlen:42

如果两个都配置完了，就是有两个从机的

狂神docker 笔记狂神redis_数据库_15

真实的从主配置应该在配置文件中配置，这样的话是永久的，我们这里用的是命令，暂时的

细节

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

狂神docker 笔记狂神redis_狂神docker 笔记_16

从机只能读取内容！

狂神docker 笔记狂神redis_狂神docker 笔记_17

测试：主机断开连接，从机依旧连接到主机的，但是没有写操作，这个时候，主机如果回来了，从机依旧可以直接获取到主机写的信息！

如果是使用命令行，来配置主从，这个时候如果重启了，就会变回主机！只有变为从机，才能立马从主机中获取值！

复制原理

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

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

**全量复制：**而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。

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

但是只要是重新连接master，一次完全同步（全量复制）将被自动执行！我们的数据一定可以在从机中看到！

层层链路

上一个M链接下一个 S！

狂神docker 笔记狂神redis_redis_18

这时候也可以完成我们的主从复制！80无法写入

如果没有老大了，这个时候能不能选择一个老大出来呢？手动！

谋朝篡位
如果主机断开了连接，我们可以使用 SLAVEOF no one 让自己变成主机！其他的节点就可以手动连接到最新的这个主节点（手动）！如果这个时候老大修复了，那就重新连接！

哨兵模式

（自动选举老大的模式）

概述

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

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

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

狂神docker 笔记狂神redis_redis_19

这里的哨兵有两个作用

通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。

当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让他们切换主机

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

狂神docker 笔记狂神redis_数据库_20

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

测试

我们目前的状态是一主二从！

配置哨兵配置文件sentinel.cof

#sentinel monitor 被监控的名称 host port 1
sentinel monitor myredis 127.0.0.1 6379 1

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

2.启动哨兵！

[root@kuangshen bin]# redis-sentinel kconfig/sentinel.conf
26607:X 31 Mar 2020 21:13:10.027 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
26607:X 31 Mar 2020 21:13:10.027 # Redis version=5.0.8, bits=64,
commit=00000000, modified=0, pid=26607, just started
26607:X 31 Mar 2020 21:13:10.027 # Configuration loaded

                _._
            _.-``__ ''-._
        _.-`` `. `_. ''-._       Redis 5.0.8 (00000000/0) 64 bit
    .-`` .-```. ```\/ _.,_ ''-._
    ( ' , .-` | `, )` _.-'|         Running in sentinel mode
    |`-._`-...-` __...-.``-._|'        Port: 26379
    | `-._ `._ / _.-' |             PID: 26607
    `-._ `-._ `-./ _.-' _.-'
    |`-._`-._ `-.__.-' _.-'_.-'|
    | `-._`-._ _.-'_.-' |            http://redis.io
    `-._ `-._`-.__.-'_.-' _.-'
    |`-._`-._ `-.__.-' _.-'_.-'|
    | `-._`-._ _.-'_.-' |
    `-._ `-._`-.__.-'_.-' _.-'

26607:X 31 Mar 2020 21:13:10.029 # WARNING: The TCP backlog setting of 511
cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value
of 128.
26607:X 31 Mar 2020 21:13:10.031 # Sentinel ID is
4c780da7e22d2aebe3bc20c333746f202ce72996
26607:X 31 Mar 2020 21:13:10.031 # +monitor master myredis 127.0.0.1 6379 quorum
1
26607:X 31 Mar 2020 21:13:10.031 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @
myredis 127.0.0.1 6379
26607:X 31 Mar 2020 21:13:10.033 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @
myredis 127.0.0.1 6379

如果Master 节点断开了，这个时候就会从从机中随机选择一个服务器！（这里面有一个投票算法！）

狂神docker 笔记狂神redis_狂神docker 笔记_21

哨兵日志！

狂神docker 笔记狂神redis_狂神docker 笔记_22

如果主机此时回来了，只能归并到新的主机下，当做从机，这就是哨兵模式的规则！

哨兵模式

优点：

哨兵集群，基于主从复制模式，所有主从配置优点，它会有
主从可以切换，故障可以转移，系统的可用性就会更好
哨兵模式就是主从模式的升级，手动到自动，更加健壮！

缺点：

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

哨兵模式的全部配置

# Example sentinel.conf
# 哨兵sentinel实例运行的端口 默认26379
port 26379
# 哨兵sentinel的工作目录
dir /tmp
# 哨兵sentinel监控的redis主节点的 ip port
# master-name 可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。
# quorum 配置多少个sentinel哨兵统一认为master主节点失联 那么这时客观上认为主节点失联了
# sentinel monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor mymaster 127.0.0.1 6379 2
# 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供
密码
# 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
# 指定多少毫秒之后 主节点没有应答哨兵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
# SCRIPTS EXECUTION
#配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知
相关人员。
#对于脚本的运行结果有以下规则：
#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
#若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
#一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
#通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），
将会去调用这个脚本，这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信
息。调用该脚本时，将传给脚本两个参数，一个是事件的类型，一个是事件的描述。如果sentinel.conf配
置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无
法正常启动成功。
#通知脚本
# shell编程
# sentinel notification-script <master-name> <script-path>
sentinel notification-script mymaster /var/redis/notify.sh
# 客户端重新配置主节点参数脚本
# 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已
经发生改变的信息。
# 以下参数将会在调用脚本时传给脚本:
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
# 目前<state>总是“failover”,
# <role>是“leader”或者“observer”中的一个。
# 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通
信的
# 这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentinel client-reconfig-script <master-name> <script-path>
sentinel client-reconfig-script mymaster /var/redis/reconfig.sh # 一般都是由运维来配
置！

Redis缓存穿透和雪崩(面试高频，工作常用)

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

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

狂神docker 笔记狂神redis_数据库_23

缓存穿透（查不到）

概念

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

解决方案

布隆过滤器

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

狂神docker 笔记狂神redis_Redis_24

缓存空对象

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

狂神docker 笔记狂神redis_Redis_25

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

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

缓存击穿（量太大，缓存过期！）

概念

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

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

解决方案

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

加互斥锁

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

狂神docker 笔记狂神redis_Redis_26

缓存雪崩

概念

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

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

狂神docker 笔记狂神redis_nosql_27

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

解决方案

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

限流降级（在SpringCloud讲解过！）

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

数据预热

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

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：Flutter Android 名字 flutter 应用

下一篇：android网络上下行速率显示 wifi上下行速率对等不

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯