一篇博客通关Redis技术栈

记录菌

已于 2022-08-03 15:12:04 修改

阅读量596

点赞数

分类专栏： Redis 文章标签：大数据

于 2022-08-03 15:00:18 首次发布

本文链接：https://blog.csdn.net/qq_47959003/article/details/125599918

版权

Redis 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

写在前面：本篇博客详细的记录本人学习redis的全过程，从redis演变到基础，在到进阶，最后运维级别的学习。整理的内容非常详细，在供个人复习的同时，也希望能帮助到更多的朋友。学习的过程中并不是一帆风顺的，很多步骤、配置等等问题，都需要花费大量的时间搜索，才能找到解决方法，所以我也将此类整理进了博客，少走些弯路。非常感谢UP主遇见狂神说，提供这么好的视频资源。

学习视频传送门：36、小结及拓展_哔哩哔哩_bilibili

11.1 RDN（Redis DataBase）

11.2 AOF（Append Only File）

15、Redis缓存穿透和雪崩（面试高频）

15.1 缓存穿透（查不到导致）

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

15.3 缓存雪崩

1. Nosql概述

1. 单机Mysql的年代

90年代，一个基本的网站访问量不会太大，单个数据库完全足够。更多的去访问静态网页，服务器根本没有太大的压力。

问题：整个网站的瓶颈是什么？

1. 数据量太大，一个机器放不下了；

2. 数据的索引（B + Tree）,一个机器内存也放不下；

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

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

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

发展过程：优化数据结构和索引-->文件缓存（IO）-->Memcached（当时最热门的技术）

3. 分库分离 + 水平拆分 +Mysql集群

技术和业务在发展的同时，对人的要求也越来越高了；

本质：数据库（读 | 写）

早些年MyISAM : 表锁 ,十分影响效率，高并发就会出现严重的锁问题；

早些年Innodb：行锁

慢慢的就开始使用分库分表来解决分库分表来解决写的压力；

Mysql 的集群：很好地解决了那个年代的问题需求；

4. 如今最近的年代

Mysql 等关系型数据库就不够用了，数据量很多，变化很多；需要将文件、图片、用一种专门的数据库来存储这种数据。

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

6. 为什么要用NoSQL

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

这时候就要用Nosql数据库，可以很好地处理以上问题；

2. 什么是NoSQL

1. NoSQL

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

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

泛指非关系型数据库，随着web2.0互联网的诞生，传统的关系型数据库很难对付web2.0时代，尤其是超大规模的并发的社区，Nosql在当今大数据环境下发展十分迅速，Redis也是必须掌握的。

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

NoSQL特点

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

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

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

4. 传统的RDBMS 和NoSql

传统的RDBMS

- 结构化组织

- SQL

- 数据和关系都存在单独的表中

- 严格的一致性

- 基础的事务

。。。。。。

NoSql

- 不仅仅是数据

- 没有固定的查询语言

- 键值对存储，列存储，文档存储，图型数据库（社交关系）

- 最终一致性

- CAP定理和 BASE （异地多活）

- 高性能、高可用、高可扩

。。。。。

3. 阿里巴巴演进分析

1. 商品的基本信息

名称、价格、商家信息等；

关系型数据库就可以解决，淘宝内部的mysql不是平常用的mysql

2. 商品的描述、评论（文字比较多）

文档型数据库中：MongoDB

3. 图片

分布式文件系统： FastDFS

- 淘宝自己的： TFS

- Google的： GFS

- Hadoop : HDFS

-阿里云： oss

4. 商品的关键字（搜索）

- 搜索引擎 solr elasticsearch

- Iserach : 多隆（阿里）

5. 商品热门的波段信息

- 内存数据库

- Redis Tair 、Memache....

6. 商品的交易，外部支付接口（三方应用）

大型互联网应用问题：

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

解决方案：

4. Reids 入门

4.1 概述

Redis 是什么？

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

当下最热门的Nosql的技术之一，也被称为结构化数据库。

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

下面是官方的bench-mark数据（性能）：

测试完成了50个并发执行100000个请求。
设置和获取的值是一个256字节字符串。
Linux box是运行Linux 2.6,这是X3320 Xeon 2.5 ghz。
文本执行使用loopback接口(127.0.0.1)。
结果:读的速度是110000次/s,写的速度是81000次/s 。

Redis 可以干什么？

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

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

3、发布订阅系统；

4、地图信息分析；

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

特性

1、多样的数据类型；

2、持久化；

3、集群；

4、事务；

5、不区分大小写；

学习中需要用到的东西：

1、遇见狂神说

2、官网：https://redis.io/

3、中文网：http://www.redis.cn/

注意：Windows 在GitHub上下载（停更很久了），建议在LInux服务器搭建；

官网：Redis命令中心（Redis commands） -- Redis中国用户组（CRUG）http://www.redis.cn/commands.html

4.2 Linux安装

1. 下载安装包 Download | Redis

2. 解压Redis的安装包，程序一般放在/opt目录下

mv redis-7.0.2.tar.gz /opt
tar -zxvf redis-7.0.2.tar.gz

解压完成：

3. 进去解压后的文件。可以看到我们Redis的配置文件

4. 基本的环境安装

安装：yum install gcc-c++
查看：gcc -v
全部需要的配置：make命令（下的东西多慢）

再次执行make（快），

再次执行：make install

5. Redis的默认安装路径：‘usr/local/bin’

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

以后就用拷贝后的文件进行启动，这样就不会影响到原来的文件。

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

vim redis.config
将daemonize 改为yes,允许后台启动

8. 启动redis服务

命令：redis-server 目录/redis.conf

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

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

11. 如何关闭redis服务？shutdown

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

4.3 性能测试

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

测试命令：

测试：100个并发连接 10万个请求

redis-benchmark -h localhost -p 6379 -c 100 -n 100000

4.4 redis基础知识

redis默认有十六个数据库，默认使用第0个

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

清除当前数据库flushdb：

127.0.0.1:6379[3]> flushdb
OK
127.0.0.1:6379[3]> keys *
(empty array)

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

Redis是单线程的

Redis是基于内存操作的，CPU不是Redis的性能瓶颈，Redis的瓶颈是根据机器的内存和网络带宽，既然可以使用单线程来实现，就使用单线程了。

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

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

2. 误区二：多线程（CPU上下文会切换）一定比单线程效率高；

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

5. 五大数据类型

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

5.1 Redis-Key

keys * 查看所有的key

set name liusir 设置key-value

exists name 判断key = name是否存在

move name 移除key = name

expire name 10 设置key = name的过期时长，单位是 s

ttl name 查看key = name 的剩余时间

type key 查看当前key的类型

命令查询官网：Redis命令中心（Redis commands） -- Redis中国用户组（CRUG）

5.2 String

append key "hello" 给key的值追加字符串“hello”，前提是key存在

strlen key 获取key中值的长度

#设置自增（i++）或步长（ i += ）

set views 0 // 设置key值，初始值为0

incr views // 相当于views++

decr views // views--

incrby views 10 // views += 10

decrby views 10 // views -= 10

#字符串范围 range

getrange key 0 3 //获取key的值下标从 0 到 3

#替换指定位置的字符串

setrange key 1 xx //替换从1开始（包含）后的xx.length个字符串

setex (set with expire) //设置过期时长

setnx（set if not exist） //不存在设置（在分布式锁中会常常使用，防止覆盖原先值）

#批量设置值

mset //mset k1 v1 k2 v2 同时设置多个值

mget // mget k1 k2 同时获取多个值

msetnx // msetnx k1 v1 k4 v4 原子性的操作，要么一起成功，要么一起失败！

#对象

//设置一个user:1 对象值为 json字符来保存一个对象，这里的key很巧妙 user:{id}:{filed}

set user:1{name:zhangsan,age:3}

eg:

> mset user:1:name zhangsan user :1:age 2

>ok

>mget user:1:name user:1:age

1) "zhangsan"

2) "2"

#getset //先 get 然后再set

> getset db redis //如果不存在值，返回nil

>(nil)

>get db

>"redis"

>getset db mongodb //如果存在值，获取原来的值，并设置新的值

> "redis"

> get db

> "mongodb"

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

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

5.3 List

基本的数据类型，列表。在redis里面，我们可以把list做成栈、队列、阻塞队列；

lpush/lrange/rpush

127.0.0.1:6379[2]> lpush list one #lpush将一个值或多个值插入到列表的头部(左)
(integer) 1
127.0.0.1:6379[2]> lpush list two
(integer) 2
127.0.0.1:6379[2]> lpush list three
(integer) 3

127.0.0.1:6379[2]> lrange list 0 -1 #lrange获取list中的值
1) "three"
2) "two"
3) "one"
127.0.0.1:6379[2]> lrange list 0 1
1) "three"
2) "two"

127.0.0.1:6379[2]> rpush list right #lpush将一个值或多个值插入到列表的头部(右)
(integer) 1
(integer) 4
127.0.0.1:6379[2]> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"

ps:

列表类似于双端队列，两头可插
0到-1代表全体数据
取数据只有lrange,这个l不是左端的意思，而是list的意思，没有rrange。并且取数据，取得是左端开始的数据（类似栈顶）。

移除：lpop rpop

127.0.0.1:6379[2]> lrange list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"
127.0.0.1:6379[2]> lpop list #移除列表的第一个元素
"three"
127.0.0.1:6379[2]> rpop list #移除列表的最后一个元素
"right"

通过下标获取值：lindex

127.0.0.1:6379[2]> lindex list 0
"two"
127.0.0.1:6379[2]> lindex list 1
"one"

获取列表的长度：llen /LLEN
127.0.0.1:6379[2]> llen list
(integer) 3

移除指定的值：lrem/Lrem 列表数量值

127.0.0.1:6379[2]> lrem list 1 one #移除1个one
(integer) 1
127.0.0.1:6379[2]> lrange list 0 -1
1) "three"
2) "two"
127.0.0.1:6379[2]> lpush list three
(integer) 3
127.0.0.1:6379[2]> lrange list 0 -1
1) "three"
2) "three"
3) "two"
127.0.0.1:6379[2]> lrem list 2 three #移除2个three
(integer) 2
127.0.0.1:6379[2]> lrange list 0 -1
1) "two"

trim 修剪： ltrim :截断

127.0.0.1:6379[2]> rpush mylist "hello"
(integer) 1
127.0.0.1:6379[2]> rpush mylist "hello1"
(integer) 2
127.0.0.1:6379[2]> rpush mylist "hello2"
(integer) 3
127.0.0.1:6379[2]> rpush mylist "hello3"
(integer) 4
127.0.0.1:6379[2]> ltrim mylist 1 2 #通过下标截断从 1到2，这个list已经被改变了
OK
127.0.0.1:6379[2]> lrange mylist 0 -1
1) "hello1"
2) "hello2"

rpoplpush #移除列表的最后一个元素，并移动到新的列表中。

127.0.0.1:6379[2]> rpush mylist "hello"
(integer) 1
127.0.0.1:6379[2]> rpush mylist "hello1"
(integer) 2
127.0.0.1:6379[2]> rpush mylist "hello12"
(integer) 3
127.0.0.1:6379[2]> rpoplpush mylsit myotherlist
(nil)
127.0.0.1:6379[2]> rpoplpush mylist myotherlist
"hello12"
127.0.0.1:6379[2]> lrange mylist 0 -1 #查看原来的列表
1) "hello"
2) "hello1"
127.0.0.1:6379[2]> lrange myotherlist 0 -1 #查看目标列表，确实存在值！
1) "hello12"

lset 将列表中指定下标的值替换为另外一个值，相当于更新操作！

127.0.0.1:6379[2]> exists list #判断这个列表是否存在
(integer) 0
127.0.0.1:6379[2]> lset list 0 item # 如果不存在则会报错
(error) ERR no such key
127.0.0.1:6379[2]> lpush list value1
(integer) 1
127.0.0.1:6379[2]> lrange list 0 0
1) "value1"
127.0.0.1:6379[2]> lset list 0 item 如故存在，更新下标值
OK
127.0.0.1:6379[2]> lrange list 0 0
1) "item"
127.0.0.1:6379[2]> lset list 1 orher # 如果不存在，则会报错！
(error) ERR index out of range

linsert:将某个具体的值拆入到列表中某个值的前面或者后面

127.0.0.1:6379[2]> rpush mylist hello
(integer) 1
127.0.0.1:6379[2]> rpush mylist world
(integer) 2
127.0.0.1:6379[2]> linsert mylist before world other
(integer) 3
127.0.0.1:6379[2]> lrange mylist 0 -1
1) "hello"
2) "other"
3) "world"
127.0.0.1:6379[2]> linsert mylist after world new
(integer) 4
127.0.0.1:6379[2]> lrange mylist 0 -1
1) "hello"
2) "other"
3) "world"
4) "new"

小结

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

5.4 Set（集合）

set中的值是不能重复的

127.0.0.1:6379[2]> sadd myset liustudy #set集合中添加值
(integer) 1
127.0.0.1:6379[2]> sadd myset study
(integer) 1
127.0.0.1:6379[2]> smembers myset # 查看指定set的所有值
1) "liustudy"
2) "study"
127.0.0.1:6379[2]> sismember myset study # 判断某个值是不是在set集合中
(integer) 1
127.0.0.1:6379[2]> sismember myset world
(integer) 0

srem 移除set集合中某个元素

127.0.0.1:6379[2]> smembers myset
1) "study"
2) "liustudy"
127.0.0.1:6379[2]> srem myset study #移除set集合中的内容元素个数
(integer) 1
127.0.0.1:6379[2]> scard myset #查看当前元素个数
(integer) 1
127.0.0.1:6379[2]> smembers myset
1) "liustudy"

SRANDMEMBER 无序不重复集合，抽随机

127.0.0.1:6379[2]> SRANDMEMBER myset
"liustudy3"
127.0.0.1:6379[2]> SRANDMEMBER myset #随机抽一个元素
"liustudy2"

127.0.0.1:6379[2]> SRANDMEMBER myset 2 #随机抽选指定个数的元素
1) "liustudy"
2) "liustudy3"

127.0.0.1:6379[2]> SRANDMEMBER myset 2
1) "liustudy"
2) "liustudy2"

spop 删除指定的key | 随机删除key

127.0.0.1:6379[2]> smembers myset
1) "liustudy2"
2) "liustudy"
3) "liustudy3"
127.0.0.1:6379[2]> spop myset #随机删除一些set集合中的元素
"liustudy3"
127.0.0.1:6379[2]> spop myset
"liustudy2"
127.0.0.1:6379[2]> smembers myset
1) "liustudy"

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

127.0.0.1:6379[2]> sadd myset hello
(integer) 1
127.0.0.1:6379[2]> sadd myset liustudy
(integer) 1
127.0.0.1:6379[2]> sadd myset study
(integer) 1
127.0.0.1:6379[2]> sadd myset2 set2
(integer) 1
127.0.0.1:6379[2]> smove myset myset2 liustudy #将一个指定的值移动到另一个集合中
(integer) 1
127.0.0.1:6379[2]> smembers myset2
1) "liustudy"
2) "set2"

数字集合类：

- 差集 sdiff

- 交集 sinter

- 并集 sunion

应用场景：B站共同关注（并集）等！

127.0.0.1:6379[2]> smembers key1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379[2]> smembers key2
1) "d"
2) "e"
3) "c"
127.0.0.1:6379[2]> sdiff key1 key2 #差集 key1-key2
1) "b"
2) "a"

127.0.0.1:6379[2]> sinter key1 key2 # 交集
1) "c"
127.0.0.1:6379[2]> sunion key1 key2 # 并集
1) "b"
2) "c"
3) "a"
4) "d"
5) "e"

5.5 Hash（哈希）

Map集合，key-map 时候这个值是一个map集合。

#set一个具体的key-value

127.0.0.1:6379[2]> hset myhash field liusir
(integer) 1
127.0.0.1:6379[2]> hget myhash field
"liusir"
#set 多个具体的key-value
127.0.0.1:6379[2]> hmset myhash field hello field2 world
OK

127.0.0.1:6379[2]> hmget myhash field field2 #获取多个字段值
1) "hello"
2) "world"

#获取全部的值
127.0.0.1:6379[2]> hgetall myhash
1) "field"
2) "hello"
3) "field2"
4) "world"

#删除hash指定的key字段，对应的key-value也就消失了

127.0.0.1:6379[2]> hdel myhash field
(integer) 1
127.0.0.1:6379[2]> hgetall myhash
1) "field2"
2) "world"

#hlen 获取hash字段数量

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

127.0.0.1:6379[2]> hexists myhash field2
(integer) 1
127.0.0.1:6379[2]> hexists myhash field3
(integer) 0

#只获取所有的field

#只获取所哟的value

127.0.0.1:6379[2]> hkeys myhash
1) "field2"
127.0.0.1:6379[2]> hvals myhash
1) "world"

# incr incrby

127.0.0.1:6379[2]> hset myhash field3 5 #指定增量
(integer) 1
127.0.0.1:6379[2]> HINCRBY myhash field3 1
(integer) 6
127.0.0.1:6379[2]> HINCRBY myhash field3 -1 #负数做减法
(integer) 5
127.0.0.1:6379[2]> hdecrby myhash field3 1
(error) ERR unknown command 'hdecrby', with args beginning with: 'myhash' 'field3' '1'

ps:这里在实际操作中发现，在hash中，hincr 和 hdecr用不了，hincrby可以用，但是hdecrby却用不了。所以要做加减，hincrby 1或 hincrby -1。

#如果不存在则可以设置，如果存在则不能设置（hsetnx）

127.0.0.1:6379[2]> hsetnx myhash field4 hello
(integer) 1
127.0.0.1:6379[2]> hsetnx myhash field4 world
(integer) 0

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

5.6 Zset

在set基础上，增加了一个值，set k1 v1 zset k1 score1 vi，简而言之就是在set的基础上增加了一个计数位。

#添加一个值

127.0.0.1:6379[2]> zadd myset 1 one
(integer) 1

#添加多个值
127.0.0.1:6379[2]> zadd myset 2 two 3 three
(integer) 2
127.0.0.1:6379[2]> zrange myset 0 -1
1) "one"
2) "two"
3) "three"

排序的实现

#添加用户

127.0.0.1:6379[2]> zadd salary 2500 zhangsan
(integer) 1
127.0.0.1:6379[2]> zadd salary 5000 xioahong
(integer) 1
127.0.0.1:6379[2]> zadd salary 500 liusir

(integer) 1

#显示全部的用户，从小到大

127.0.0.1:6379[2]> zrangebyscore salary -inf +inf
1) "liusir"
2) "zhangsan"
3) "xioahong"

#从大到小进行排序
127.0.0.1:6379[2]> zrangebyscore salary 0 -1（这个写法是错误的）
(empty array)

127.0.0.1:6379[2]> zrevrange salary 0 -1（正确写法）
1) "zhangsan"
2) "liusir"

#显示全部的用户并且附带薪水
127.0.0.1:6379[2]> zrangebyscore salary -inf +inf withscores
1) "liusir"
2) "500"
3) "zhangsan"
4) "2500"
5) "xioahong"
6) "5000"

#查询工资小于2500员工的升序排序

127.0.0.1:6379[2]> zrangebyscore salary -inf 2500 withscores
1) "liusir"
2) "500"
3) "zhangsan"
4) "2500"

#移除rem中的元素

127.0.0.1:6379[2]> zrange salary 0 -1
1) "liusir"
2) "zhangsan"
3) "xioahong"
127.0.0.1:6379[2]> zrem salary xioahong
(integer) 1

#获取有序集合中的个数

127.0.0.1:6379[2]> zcard salary
(integer) 2
127.0.0.1:6379[2]>

127.0.0.1:6379[2]> zadd myset 1 hello
(integer) 1
127.0.0.1:6379[2]> zadd myset 2 word 3 liusir
(integer) 2

#获取指定区间的数量
127.0.0.1:6379[2]> zcount myset 1 3
(integer) 3
127.0.0.1:6379[2]> zcount myset 1 2
(integer) 2

6. 三种特殊的数据类型

6.1 geospatital

朋友的定位，附近的人，打车距离计算等等；
经纬度地址查询https://map.jiqrxx.com/jingweidu/

# getadd 添加地理位置

# 规则：两级无法直接添加，我们一般会下载城市数据，直接通过java程序一次性导入

# 参数：经度、纬度、名称

有效的经度从-180度到180度。
有效的纬度从-85.05112878度到85.05112878度

127.0.0.1:6379[2]> geoadd china:city 116.23128 40.22077 beijing
(integer) 1
127.0.0.1:6379[2]> geoadd china:city 108.93425 34.23053 xian
(integer) 1
127.0.0.1:6379[2]> geoadd china:city 121.48941 31.40527 shanghai
(integer) 1
127.0.0.1:6379[2]> geoadd china:city 113.88308 22.55329 shenzhen
(integer) 1
127.0.0.1:6379[2]> geoadd china:city 104.10194 30.65984 chengdu

#geopos

#获取指定城市的经度和纬度

127.0.0.1:6379[2]> geopos china:city beijing
1) 1) "116.23128265142440796"
   2) "40.22076905438526495"

127.0.0.1:6379[2]> geopos china:city beijing xian
1) 1) "116.23128265142440796"
   2) "40.22076905438526495"
2) 1) "108.93425256013870239"
   2) "34.23053097599082406"

#geodist

返回两个给定位置之间的距离。

如果两个位置之间的其中一个不存在，那么命令返回空值。

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

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

如果用户没有显式地指定单位参数，那么 GEODIST 默认使用米作为单位。

GEODIST 命令在计算距离时会假设地球为完美的球形，在极限情况下，这一假设最大会造成 0.5% 的误差。

#查看上海到北京的距离（直线）

127.0.0.1:6379[2]> geodist china:city beijing shanghai
"1088644.3544"
127.0.0.1:6379[2]> geodist china:city beijing shanghai km
"1088.6444"

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

附近的人：获得附近的人的地址，定位，通过半径来查询！

获得指定数量的人：count

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

# 以110,30这个·经纬度为中心，寻找方圆1000km内的城市

127.0.0.1:6379[2]> georadius china:city 110 30 1000km
(error) ERR wrong number of arguments for 'georadius' command
127.0.0.1:6379[2]> georadius china:city 110 30 1000 km
1) "chengdu"
2) "xian"
3) "shenzhen"
127.0.0.1:6379[2]> georadius china:city 110 30 500 km
1) "xian"

#显示到中间距离的位置
127.0.0.1:6379[2]> georadius china:city 110 30 500 km withdist
1) 1) "xian"
   2) "481.1278"

#显示他人定位信息
127.0.0.1:6379[2]> georadius china:city 110 30 500 km withcoord
1) 1) "xian"
   2) 1) "108.93425256013870239"
      2) "34.23053097599082406"

#筛选出指定的信息
127.0.0.1:6379[2]> georadius china:city 110 30 500 km withdist withcoord count 1
1) 1) "xian"
   2) "481.1278"
   3) 1) "108.93425256013870239"
      2) "34.23053097599082406"

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

zrange china:city 0 -1

zrem china:city beijing

6.2 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;

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

测试使用

#创建第一组元素 mykey

127.0.0.1:6379[3]> pfadd mykey a b c d e f g h i j
(integer) 1

#统计mykey元素的基数数量
127.0.0.1:6379[3]> pfcount mykey
(integer) 10

#创建第二组
127.0.0.1:6379[3]> pfadd mykey2 i j k l m n v b
(integer) 1
127.0.0.1:6379[3]> pfcount mykey2
(integer) 8

#合并两组 mykey 和 mykey2 到mykey3并集
127.0.0.1:6379[3]> pfmerge mykey3 mykey mykey2
OK

#查看合并的数量
127.0.0.1:6379[3]> pfcount mykey3
(integer) 15

如果可以容错，就可以使用Hyperloglog,如果不允许容错，就使用set或自己的数据类型。

6.3 Bitmap

位运算

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

365 天 = 365 ，1字节 = 8bit,46个字节左右

测试

使用bitmap来记录周一到周日的打卡：

# 查看某一天是否有打卡

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

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

127.0.0.1:6379[3]> bitcount sign
(integer) 3

应用场景：适合只有两种结果的，要么是，要么不是的。

7. 事务

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

Redis事务的本质：一切命令的集合，一个事务中的所有命令都会被序列化，在事务执行的过程中，会按照顺序执行。一次性、顺序性、排他性来执行一些列的命令。

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

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

redis事务：

开启事务（multi）
命令入队（）
执行事务（）

正常执行事务

#开启事务

127.0.0.1:6379> multi
OK

#命令入队
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED

#执行事务
127.0.0.1:6379(TX)> exec
1) OK
2) OK
3) "v2"
4) OK

放弃事务

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k4 v4
QUEUED

#取消事务，事务中的命令都不会被执行
127.0.0.1:6379(TX)> discard
OK
127.0.0.1:6379> get k4
(nil)

编译型异常（代码有问题，命令有错），事务中的所有命令都不会被执行！

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> getset k3
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.

运行时异常（1/0），如果事务队列中存在语法性，那么执行命令的时候，其他命令是可以正常执行的，错误命令抛出异常。

127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 "v1"
QUEUED

#会执行失败
127.0.0.1:6379(TX)> incr k1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k3
QUEUED
127.0.0.1:6379(TX)> exec
1) OK

#虽然有一条命令报错了，但是依旧正常执行成功了
2) (error) ERR value is not an integer or out of range
3) OK
4) "v3"

监控（watch）面试常问

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

乐观锁：

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

Redis的监视测试

正常执行成功！

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK

#监视money对象
127.0.0.1:6379> watch money
OK

#事务正常执行结束，数据期间没有发生变动，这个时候就正常执行成功。
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> decrby money 20
QUEUED
127.0.0.1:6379(TX)> incrby out 20
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 80
2) (integer) 20

测试多线程修改值，使用watch可以当做redis乐观锁操作

线程1操作：

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 10
OK
127.0.0.1:6379> watch money #监视线程 money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> decrby money 10
QUEUED
127.0.0.1:6379(TX)> incrby out 10
QUEUED

线程二操作：

127.0.0.1:6379> get money
"100"
127.0.0.1:6379> set money 1000
OK

线程一提交事务：

# 执行之前，另外一个线程，修改了我们的值，就会导致事务执行失败。

127.0.0.1:6379(TX)> exec
(nil)

#如果发现事务执行失败，就先解锁

127.0.0.1:6379> unwatch
OK

#获取最新的值，再次监视 select version
127.0.0.1:6379> watch money
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> decrby money 10
QUEUED
127.0.0.1:6379(TX)> incrby out 10
QUEUED

#对比监视的值是否发生了变化，如果没有变化，那么可以执行成功，否则执行失败
127.0.0.1:6379(TX)> exec
1) (integer) 990
2) (integer) 20

8. Jedis

我们要使用 java 来操作Redis

Jedis是Redis官方推荐的java连接开发工具，使用java操作redis中间件。如果要使用java操作redis，那么一定要对jredis十分的属性。

测试

1.导入对应的依赖

<!--      jeris-->
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>3.2.0</version>
</dependency>

<!--      fastjson-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.60</version>
</dependency>

2. 编码测试

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

小提示：idea中 ctrl + alt + t 可以快速召唤环绕方式！

3.idea代码测试

public class TestTX {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("本地/远程ip",6379);
        System.out.println(jedis.ping());
        jedis.flushDB();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello","world");
        jsonObject.put("name","liusir");

        //开启事务
        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();//关闭连接
        }
        jedis.close();
    }
}

远程ip连接需要注意：

在Linux当中配置redis的配置文件redis.conf

    1.使用指令vim 配置文件路径进入到配置文件
    2.注释掉bind=127.xxxx，否则redis只能接受本机请求
    3.将protected-mode设置为no，关闭保护模式
    4.:wq将以上内容保存
    5.redis-server 配置文件路径使用你修改的配置文件在后台启用redis服务
    6.防火墙相关设置，如果关闭防火墙可跳过
        firewall-cmd --zone=public --add-port=6379/tcp --permanent启用redis需要使用的6379端口
        firewall-cmd -reload重载防火墙
    7.在阿里云服务器控制台中配置防火墙，端口号也是6379

小贴士：

find / -name redis.conf 查找到文件位置
vim中查找某个配置位置，命令行模式下,例如：/bind，/或？为查找符
shutdown save可以强制关闭 redis，退出记得 exit
启动redis-server 路径/redis.conf
连接redis-cli -p 6379

9. SpringBoot整合

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

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

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

源码分析：

 @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}//我们可以自己定义一个redisTemplate 来替换默认的
    )
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)

//默认的redisTemplate 没有过多的设置，redis对象都是需要序列化。

//两个泛型都是object类型，后面使用都需要强制转换
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

//由于string 类型是redis中最常用的类型，所以单独提出来一个bean.

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return new StringRedisTemplate(redisConnectionFactory);
    }

整合测试

1.导入依赖

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

2.配置连接（application.properties）

#配置redis
spring.redis.host= localhost/远程ip
spring.redis.port=6379

ps: jedis底层已经被移除了，应该使用lettuce

3.测试

@SpringBootTest
class Redis02SpringbootApplicationTests {
    @Autowired
    @Qualifier("redisTemplate")
    private RedisTemplate redisTemplate;
    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("name","liusir");
        System.out.println(redisTemplate.opsForValue().get("name"));
    }
}

解决中文乱码问题（使用json序列化解决）

1. 查看底层序列化配置

2.查看底层默认序列化

3.使用json来存储数据

 @Test
    public void test() throws JsonProcessingException {
        //真实的开发都使用json来传递对象
        User user = new User("刘sir", 18);
        String jsonUser = new ObjectMapper().writeValueAsString(user);
        redisTemplate.opsForValue().set("user",jsonUser);
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

关于对象的保存

直接存储对象：

@Test
    public void test1() throws JsonProcessingException {
        //真实的开发都使用json来传递对象
        User user = new User("刘sir", 18);
        redisTemplate.opsForValue().set("user",user);
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

解决办法：

在User类中加上： implements Serializable 实现序列化！

在企业中，所有的pojo都会序列化，都不会使用原生的方式去编写。

@Component
@AllArgsConstructor
@NoArgsConstructor
@Data
public class User implements Serializable {
    private String name;
    private Integer age;
}

编写一个自己的redisTemplate序列化配置:(可以作为配置模板使用)，可以看作为一个RedisUtils工具类来使用。

@Configuration
public class RedisConfig {
    //编写我们自己template
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        //自己定义了RedisTemplate
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //String类型序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //hsah也采用String序列化的方式
        template.setHashKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value序列化也采用Jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

在测试引用自己的Redisemplate时，记得将泛型加上，否则识别不到自定义的，走默认原版的了。

     @Autowired
    private RedisTemplate<String, Object> redisTemplate;

RedisUtil工具类完整版

package cn.wideth.util.other;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@component
public class RedisUtils {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static double size = Math.pow(2, 32);


    /**
     * 写入缓存
     * @param key
     * @param offset 位 8Bit=1Byte
     * @return
     */
    public boolean setBit(String key, long offset, boolean isShow) {
        boolean result = false;
        try {
            ValueOperations<String, Object> operations = redisTemplate.opsForValue();
            operations.setBit(key, offset, isShow);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param offset
     * @return
     */
    public boolean getBit(String key, long offset) {
        boolean result = false;
        try {
            ValueOperations<String, Object> operations = redisTemplate.opsForValue();
            result = operations.getBit(key, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<String, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    

    /**
     * 写入缓存设置失效时间
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<String, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }


    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<String, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        redisTemplate.opsForValue();
        return zset.rangeByScore(key, scoure, scoure1);
    }


    //第一次加载的时候将数据加载到redis中
    public void saveDataToRedis(String name) {
        double index = Math.abs(name.hashCode() % size);
        long indexLong = new Double(index).longValue();
        boolean availableUsers = setBit("availableUsers", indexLong, true);
    }

    //第一次加载的时候将数据加载到redis中
    public boolean getDataToRedis(String name) {

        double index = Math.abs(name.hashCode() % size);
        long indexLong = new Double(index).longValue();
        return getBit("availableUsers", indexLong);
    }

    /**
     * 有序集合获取排名
     * @param key 集合名称
     * @param value 值
     */
    public Long zRank(String key, Object value) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rank(key,value);
    }


    /**
     * 有序集合获取排名
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start,long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key,start,end);
        return ret;
    }

    /**
     * 有序集合添加
     * @param key
     * @param value
     */
    public Double zSetScore(String key, Object value) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.score(key,value);
    }


    /**
     * 有序集合添加分数
     * @param key
     * @param value
     * @param scoure
     */
    public void incrementScore(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.incrementScore(key, value, scoure);
    }


    /**
     * 有序集合获取排名
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start,long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key,start,end);
        return ret;
    }

    /**
     * 有序集合获取排名
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
        return ret;
    }

    
}

测试应用：

     @Autowired
    private RedisUtils redisUtils;

     @Test
    public void test2() throws JsonProcessingException {
        redisUtils.set("name","liusir");
        System.out.println(redisUtils.get("name"));
    }

10. Redis.conf详解

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

单位

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

包含

include可以包含别的文件，就好比我们学习spring中的import标签,可以把多个配置文件组合成一个。

网络

bind 127.0.0.1 //绑定的ip

protected-mode no //是否受到保护

port 6379 //设置端口

通用（GENERAL）

#以守护进程的方式运行，默认是no，这里需要我们自己开启

daemonize yes

#如果以后台方式运行，我们就需要指定一个pid文件。

pidfile /var/run/redis_6379.pid

#日志

# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)//生产环境
# warning (only very important / critical messages are logged)
loglevel notice

#日志的文件位置名

logfile ""
#数据库的数量默认是16个

databases 16

#是否总是显示logo
always-show-logo no

快照

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

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

# 如果多少秒内，有一个key进行了修改，我们就进行持久化操作。

save <seconds> <changes> [<seconds> <changes> ...]

# 如果 900s 内，如果至少有1 个 key 进行了修改，我们就进行持久化操作。

save 900 1

# 如果 300s 内，如果至少有10 个 key 进行了修改，我们就进行持久化操作。

save 300 10

# 如果 60s 内，如果至少有10000 个 key 进行了修改，我们就进行持久化操作。

save 60 10000

#持久化如果出错，是否还需要继续工作

stop-writes-on-bgsave-error yes

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

rdbcompression yes

#保存rdb文件的时候，进行错误的校验

rdbchecksum yes

# rdb 文件保存的目录

dir ./

REPLICATION（复制）主从复制会用到

SECURITY（安全）

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

#默认没有密码

requirepass foobared

#设置密码
config set requirepass "123456"

#登录验证
auth 123456

限制 CLIENTS

#设置能连接上redis最大客户端数量

maxclients 10000

#redis配置最大内存容量

maxmemory <bytes>

#redis到达上限后的处理策略

maxmemory-policy noeviction

volatile-lru：只对设置了过期时间的key进行LRU（默认值）
allkeys-lru ：删除lru算法的key
volatile-random：随机删除即将过期key
allkeys-random：随机删除
volatile-ttl ：删除即将过期的
noeviction ：永不过期，返回错误

APPEND ONLY MODE 模式 aof配置

# 默认是不开启aof模式，默认是使用rdb方式持久化的，在大部分情况下，rdb完全够用
appendonly no

# 持久化文件的名字
appendfilename "appendonly.aof"

# appendfsync always // 每次修改都会sync,消耗性能
appendfsync everysec // 每秒执行一次sync,可能会丢失者1s的数据
# appendfsync no // 不执行 sync,这个时候操作系统自己同步数据，速度最快。

11. Redis持久化

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

11.1 RDN（Redis DataBase）

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

rdb 保存的文件是dump.rdb

触发机制

save 的规则满足的情况下，会自动触发rdb规则
执行flushall命令，也会触发我们的rdb规则
退出redis，也会产生rdb文件
备份就会自动生成一个dump.rdb文件

如果恢复rdb文件

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

2、需要查看存在的位置

config get dir

1) "dir"

2）"/usr/local/bin" # 如果在这个目录下存在 dump.rdb文件，启动就会自动恢复其中的数据

优点：

适合大规模的数据恢复，dump.rdb
对数据完整性要求不高

缺点：

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

11.2 AOF（Append Only File）

将所有命令都记录下来，相当于history，恢复的时候就把这个文件全部都再执行一遍。

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

Aof保存的是appendonly.aof文件

append

默认是不开启的，需要手动配置，改为yes就开启了aof.。

如果aof配置文件有错误，这个时候redis是启动不起来的，我们需要修复这个aof文件,redis给我们提供了一个工具 redis-check-aof -- fix appendonly.aof

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

重写规则说明

aof默认的是文件的无限追加，会越来越大。

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

优缺点

优点：

每次修改都同步，文件的完整性更好；
从不同步，效率最高

缺点：

相对于数据文件来说，aof远远大于rdb,回复的速度也比rdb慢；
Aof运行的效率也比rdb慢，所以我们redis默认的配置就是rdb持久化。

扩展

1、RDB持久化方式能够在指定的时间间隔内对你的数据进行快照存储。
2、AOF 持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据,，AOF命令以Redis协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不至于过大。
3、只做缓存，如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何持久化
4、同时开启两种持久化方式
在这种情况下，当redis重启的时候会优先载入AOF文件来恢复原始的数据，因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整。
RDB的数据不实时，同时使用两者时服务器重启也只会找AOF文件，那要不要只使用AOF呢？作者建议不要，因为RDB更适合用于备份数据库( AOF在不断变化不好备份)，快速重启，而且不会有AOF可能潜在的Bug，留着作为一个万一的手段。
5、性能建议
因为RDB文件只用作后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟备份一次就够了，只保留 save 900 1 这条规则。
如果Enable AOF，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持续的IO，二是AOF rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值。
如果不Enable AOF，仅靠Master-Slave Repllcation实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果Master/Slave 同时挂掉，会丢失十几分钟的数据，启动脚本也要比较两个Master/Slave中的RDB文件，载入较新的那个，微博就是这种架构。

12. Redis发布订阅

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

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

订阅/发布消息图：

命令

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

测试

订阅端：

#订阅 liusir频道

127.0.0.1:6379> SUBSCRIBE liusir
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "liusir"
3) (integer) 1
1) "message"
2) "liusir"
3) "wansong shabi"
1) "message"
2) "liusir"
3) "hello redis"

发送端：

# 发送消息到频道liusir

127.0.0.1:6379> publish liusir "wansong shabi"
(integer) 1
127.0.0.1:6379> publish liusir "hello redis"
(integer) 1

原理

1、Redis是使用C实现的，通过分析Redis源码里面的pubsub.c文件，了解发布和订阅机制的底层实现，即此加深对Redis的理解。

2、Redis通过 PUBLISH、SUBSCRIBE 和 PSUBSCRIBE 等命令实现发布和订阅功能。

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

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

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

13. Redis主从复制

13.1 概念

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

默认情况下，每台Redis服务器都是主节点;且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。主从复制的作用主要包括:

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

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

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

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

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

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

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

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

13.2 环境配置

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

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

复制3个配置文件（redis.conf），然后修改对应的信息。

端口
pid名字
log文件名
dump.rdb名字

修改完毕后，启动三个redis服务，查看服务状态：

13.3 一主二从

默认情况下，每台redis服务器都是主节点，我们一般只用配置从机就可以了。

一主（79）二从（80和81）

# 在从机中进行配置 slaveof 主机端口

127.0.0.1:6380> slaveof 127.0.0.1 6379
OK
127.0.0.1:6380> info replication
# Replication
role:slave #当前角色
master_host:127.0.0.1
master_port:6379
master_link_status:up
master_last_io_seconds_ago:6
master_sync_in_progress:0
slave_read_repl_offset:14
slave_repl_offset:14
slave_priority:100
slave_read_only:1
replica_announced:1
connected_slaves:0
master_failover_state:no-failover
master_replid:b07d233f401cf00971b0b14c006b10ac115257ab
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:14
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:15
repl_backlog_histlen:0

ps：

如果一时大意，可以在从机中使用slaveof no one来取消从机，然后从新绑定主机。
版本要求：REPLICAOF命令从Redis 5.0.0版本开始可用。SLAVEOF命令从1.0.0版本开始可用，但从5.0.0版本开始逐渐废弃。

详情可以参考此篇博客：

Redis 中的复制（主从复制） REPLICAOF：将服务器设置为从服务器通过配置选项设置从服务器取消复制http://t.csdn.cn/OpuYA

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

细节

主机可以写，从机不写能只能读。主机中的所有数据都会自动被从机保存。
主机写：

从机只读不能写：

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

复制原理

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

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

全量复制︰而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。
增量复制:Master继续将新的所有收集到的修改命令依次传给slave，完成同步。

但是只要是重新连接master，一次完全同步（全量复制)将被自动执行。

层层链路

上一个主机M连接下一个从节点S，这个从节点再次连接下一个从节点S。虽然所有节点都可以共享数据，但是只有最初的主节点，才能写入数据。（实际开发不会用到）

14. 哨兵模式

概述

        主从切换技术的方法是∶当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。Redis从2.8开始正式提供了Sentinel (哨兵）架构来解决这个问题。
        谋朝篡位的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。
        哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

这里的哨兵有两个作用：

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

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

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

测试

配置哨兵配置文件

#sentinel monitor 被监控的名称 host 端口号 1
sentinel monitor myredis 127.0.0.1 6379 1

后面这个数字一代表主机挂了，从机投票看让谁接替成为主机。
2. 启动哨兵

[root@liustudy bin]# redis-sentinel liuconfig/sentinel.conf 
28271:X 03 Aug 2022 10:57:27.981 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
28271:X 03 Aug 2022 10:57:27.981 # Redis version=7.0.2, bits=64, commit=00000000, modified=0, pid=28271, just started
28271:X 03 Aug 2022 10:57:27.981 # Configuration loaded
28271:X 03 Aug 2022 10:57:27.982 * monotonic clock: POSIX clock_gettime
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 7.0.2 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                  
 (    '      ,       .-`  | `,    )     Running in sentinel mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 26379
 |    `-._   `._    /     _.-'    |     PID: 28271
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           https://redis.io       
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

28271:X 03 Aug 2022 10:57:27.983 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
28271:X 03 Aug 2022 10:57:27.985 * Sentinel new configuration saved on disk
28271:X 03 Aug 2022 10:57:27.985 # Sentinel ID is cbfe8f20303e6b936fddf8061ccbfe2ccba476b6
28271:X 03 Aug 2022 10:57:27.985 # +monitor master myredis 127.0.0.1 6379 quorum 1
28271:X 03 Aug 2022 10:57:27.986 * +slave slave 127.0.0.1:6380 127.0.0.1 6380 @ myredis 127.0.0.1 6379
28271:X 03 Aug 2022 10:57:27.988 * Sentinel new configuration saved on disk
28271:X 03 Aug 2022 10:57:27.988 * +slave slave 127.0.0.1:6381 127.0.0.1 6381 @ myredis 127.0.0.1 6379
28271:X 03 Aug 2022 10:57:27.991 * Sentinel new configuration saved on disk

如果master主节点宕机了，这个时候就会在从机中随机选择一个服务器。（投票算法）
哨兵日志：

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

哨兵模式

优点：

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

缺点：

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

哨兵模式全部配置

详细配置传送门如下：

http://t.csdn.cn/FS5W2http://t.csdn.cn/FS5W2

15、Redis缓存穿透和雪崩（面试高频）

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

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

15.1 缓存穿透（查不到导致）

概念

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

解决方案

布隆过滤器

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

缓存空对象

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

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

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

概述

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

解决方案

设置热点数据永不过期

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

互斥加锁

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

15.3 缓存雪崩

概念

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

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

解决方案

redis高可用
        这个思想的含义是，既然redis有可能挂掉，那就多增设几台redis，这样一台挂掉之后其他的还可以正常工作，其实就是搭建集群。
限流降级
        这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。
数据预热
        数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

记录菌

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
一篇博客通关Redis技术栈

本篇博客详细的记录本人学习redis的全过程，从redis演变到基础，在到进阶，最后运维级别的学习。整理的内容非常详细，在供个人复习的同时，也希望能帮助到更多的朋友。学习的过程中并不是一帆风顺的，很多步骤、配置等等问题，都需要花费大量的时间搜索，才能找到解决方法，所以我也将此类整理进了博客，少走些弯路。非常感谢UP主遇见狂神说，提供这么好的视频资源。......
复制链接

扫一扫