redis实例视频 redis精讲

转载

码农小哥 2024-01-17 22:00:29

文章标签 redis实例视频 redis nosql 缓存 java 文章分类 Redis 数据库

目录索引

nosql
阿里巴巴架构演进
nosql数据模型
Nosql四大分类
CAP
BASE
Redis入门
Redis安装（Windows & Linux）
五大基本数据类型

String
List
Set
Hash
Zset

三种特殊数据类型

geo
hyperloglong
bitmap

Redis配置详解
Redis持久化

Redis事务操作
Redis实现订阅发布
Redis主从复制
Redis哨兵模式
缓存穿透及解决方案
缓存击穿及解决方案
缓存雪崩及解决方案
基础 API 之 Jedis 详解
SpringBoot集成 Redis 操作
Redis 的实践分析

1、NoSQL概述

为什么要用NoSQL？

单机MySQL的年代

90年代，一个基本的网站访问量一般不会太大，单个数据库完全足够。

那个年代，更多的去使用静态网页 HTML，服务器根本没有太大压力。

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

数据量太大，一个机器放不下了
数据的索引（B+Tree），一个机器内存放不下
访问量，读写混合，一个服务器承受不了

开始出现以上三种情况之一，那么就必须要升级！

Memcached（缓存）+ MySQL + 垂直拆分（读写分离）
网站 80% 的情况都是在读数据，每次都要去查询数据库的话就十分麻烦，所以我们希望减轻数据的压力，我们可以使用缓存来保证效率。
发展过程：优化数据结构和索引 --> 文件缓存(IO) --> Memcached(当时最热门的技术)
分库分表 + 水平拆分 + MySQL集群
技术和业务在发展的同时，对人的能力要求也越来越高。
本质：数据库（读、写）
MyISAM引擎：表锁，十分影响效率，高并发下就会出现严重的锁问题
InnoDB引擎：行锁
逐渐使用分库分表来解决写的压力。MySQL在那个年代推出了表分区，这个并没有多少公司使用。
MySQL的集群，很好满足那个年代的所有需求。
如今最近的年代
2010~2020十年之间，世界已经发生了翻天覆地的变化；
MySQL等关系型数据库就不够用了，数据量很多，变化很快。
有时候使用MysQL来存储一些比较大的文件，博客，图片，数据库很大，效率变低。如果有一种数据库专门来处理这种数据，MySQL压力就变得很小，所以研究如何解决这些问题，如：大数据的IO压力，表几乎没法更大。
目前一个基本的互联网项目
为什么要用NoSQL
用户的个人信息，社交网络，地理位置。用户自己产生的数据，用户日志等等爆发式增长。
这时候就需要使用 NoSQL 数据库，NoSQL 数据库可以很好地处理以上的情况！

1.1、什么是NoSQL

NoSQL

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

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

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

NoSQL特点

解耦！

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

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

3、数据是多样性的（不需要要事先设计数据库，随取随用，）

4、传统的 RDBMS 和 NoSQL

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

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

了解：3V + 3高

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

海量 Velume
多样 Variety
实时 Velocity

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

高并发
高可扩
高性能

真正在公司中的实践：NoSQL + RDBMS 一起使用

1.2、阿里巴巴技术演进分析

# 1、商品的基本信息
	名称、价格、商家信息；
	关系型数据库可以解决，MySQL/Oracle（淘宝早年就去IOE了 - 王坚：推荐文章：阿里云的这群疯子）
	去IOE：它是阿里巴巴造出的概念。其本意是，在阿里巴巴的IT架构中，去掉IBM的小型机、Oracle数据库、EMC存储设备，代之以自己在开源软件基础上开发的系统
	淘宝内部的 MySQL 不是我们常用的MySQL
	
# 2、商品的描述、评论（文字比价多）
	文档型数据库，MongoDB
	
# 3、图片
	分布式文件系统 FastDFS
	- 淘宝自己的		TFS
	- Goole的	   	GFS
	- 阿里云的		OSS
	
# 4、商品的关键字（搜索）
	- 搜索引擎 solr、elasticSearch
	- ISearch：多隆
	
# 5、商品热门的波段信息
	- 内存数据库
	- Redis、Tair、Mamcache...
	
# 6、商品的交易、外部的支付接口
	- 三方应用

1.3、NoSQL的四大分类

KV键值对

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

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

MongoDB（一般必须要掌握）

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

CouchDB

列存储数据库

HBase
分布式文件系统

图关系数据库

他不是存图形，存的是关系，比如朋友圈社交网络
Neo4j、InfoGrid

四者对比

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

2、Redis入门

2.1、概述

Redis是什么
Redis（Remote Dictionary Server），即远程字典服务。
是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
免费和开源，是当下最热门的 NoSQL 技术之一，也被成为结构化数据库。
Redis能干什么
1、内存存储，持久化。内存中是断电即失，所以持久化很重要（rdb、aof）
2、效率高，可以用于高速缓存
3、发布订阅系统（简单消息队列）
4、地图信息分析
5、计时器、计数器（浏览量）
6、…
特性
1、多样的数据类型
2、持久化
3、集群
4、事务
5、…
学习网站
1、官网：https://redis.io/
2、中文网：http://www.redis.cn/
3、下载：建议官网下载，windows建议去GitHub下载（停更很久，因为官方不建议在Windows上搭建，推荐在Linux上搭建）

2.2、Windows安装

下载安装包：https://github.com/tporadowski/redis/releases
解压压缩包
开启Redis，双击 redis-server.exe 运行服务即可
使用Redis客户端连接Redis
双击 redis-cli.exe 。键入命令 ping，测试连接。
set基本值 key value。get key 获取值

Windows下使用确实非常简单，但是Redis推荐使用Linux环境开发，官网原话：

redis实例视频 redis精讲_缓存

2.3、Linux安装

下载安装包 redis-6.0.6.tar.gz
将压缩包上传至 Linux 的 /opt 目录下（程序建议都在opt目录下），命令tar -zxvf解压
进入解压后的文件夹，可以看到配置文件
基本的安装环境
期间make失败，降版本到5.0.8，版本列表：http://download.redis.io/releases/
make：管理员用它通过命令行来编译和安装很多开源的工具，程序员用它来管理他们大型复杂的项目编译问题
可以使用make install命令验证

[root@localhost redis-5.0.8]# yum install gcc-c++

[root@localhost redis-5.0.8]# make

[root@localhost redis-5.0.8]# make install

redis实例视频 redis精讲_redis实例视频_02

redis实例视频 redis精讲_redis实例视频_03

Redis默认安装路径/usr/local/bin
将Redis的配置文件，复制到当前目录/usr/local/bin，之后就用这个配置文件进行启动
Redis默认不是后台启动的，修改配置文件
修改配置文件中的daemonize yes

daemonize是用来指定redis是否要用守护线程的方式启动。

当我们采用yes时，redis会在后台运行，此时redis将一直运行，除非手动kill该进程。同时将进程pid号写入至redis.conf选项pidfile设置的文件中，默认会生成在/var/run/redis.pid，也可以通过pidfile来指定pid文件生成的位置

而采用no时，当前界面将进入redis的命令行界面，exit强制退出或者关闭连接工具(putty,xshell等)都会导致redis进程退出。

redis实例视频 redis精讲_nosql_04

启动Redis服务，后面指定启动的配置
使用redis-cli进行连接测试，后缀-p可以指定端口，也可以-h指定IP
查看Redis的进程是否开启，再开一个连接，查看命令ps -ef | grep redis
关闭Redis服务，shutdown：关闭Redis；exit：退出客户端
再次查看进程，关闭成功
后面会使用单机多 Redis 启动集群测试

2.4、测试性能

redis-benchmark是一个压力测试工具（官方自带的性能测试工具），redis-benchmark命令参数：

序号	选项	描述	默认值
1	-h	指定服务器主机名	127.0.0.1
2	-p	指定服务器端口	6379
3	-s	指定服务器 socket
4	-c	指定并发连接数	50
5	-n	指定请求数	10000
6	-d	以字节的形式指定 SET/GET 值的数据大小	2
7	-k	1=keep alive 0=reconnect	1
8	-r	SET/GET/INCR 使用随机 key, SADD 使用随机值
9	-P	通过管道传输请求	1
10	-q	强制退出 redis。仅显示 query/sec 值
11	–csv	以 CSV 格式输出
12	**-l（L 的小写字母）**	生成循环，永久执行测试
13	-t	仅运行以逗号分隔的测试命令列表。
14	**-I（i 的大写字母）**	Idle 模式。仅打开 N 个 idle 连接并等待。

简单测试：

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

截取一段进行分析：

redis实例视频 redis精讲_缓存_05

2.5、基础知识

Redis默认有16个数据库
可以使用 select 进行切换，并使用 dbsize 查看DB大小
查看数据库所有的key

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

清除当前数据库 flushdb清除所有数据的内容 flushall

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

思考：为什么端口是 6379（百度了解）

2.6、Redis是单线程的

最新的 Redis 是多线程

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

Redis 是 C语言写的，官方提供的数据为 100000+ 的QPS（每秒查询率，Query Per Second ），完全不比同样使用 key-value 的Memcache性能差。

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

误区1：高性能的服务器一定是多线程的？
误区2：多线程（CPU上下文切换）一定比单线程效率高？

速度：CPU > 内存 > 硬盘

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

3、五大数据类型

官网介绍

redis实例视频 redis精讲_nosql_06

3.1、Redis-Key

127.0.0.1:6379[1]> keys *			# 查看所有的key
(empty list or set)
127.0.0.1:6379[1]> set name crater
OK
127.0.0.1:6379[1]> keys *
1) "name"
127.0.0.1:6379[1]> set age 18
OK
127.0.0.1:6379[1]> keys *
1) "name"
2) "age"
127.0.0.1:6379[1]> exists name		# 判断当前的key是否存在
(integer) 1
127.0.0.1:6379[1]> exists name1
(integer) 0
127.0.0.1:6379[1]> move name 0		# 移除当前的key，后缀的数字代表哪个数据库
(integer) 1
127.0.0.1:6379[1]> keys *
1) "age"
127.0.0.1:6379[1]> set name feng
OK
127.0.0.1:6379[1]> expire name 10	# 设置过期时间，单位（秒）
(integer) 1
127.0.0.1:6379[1]> ttl name			# 查看当前key的剩余时间
(integer) 6
127.0.0.1:6379[1]> ttl name
(integer) -2
127.0.0.1:6379[1]> get name
(nil)

127.0.0.1:6379[1]> keys *
1) "name"
2) "age"
127.0.0.1:6379[1]> type name		# 查看当前key的类型
string
127.0.0.1:6379[1]> type age
string

3.2、String

90%情况下的 java程序员使用 Redis 只会使用一个 String 类型

基本操作

127.0.0.1:6379> set key1 v1					# 设置值
OK
127.0.0.1:6379> get key1					# 获得值
"v1"
127.0.0.1:6379> keys *						# 获得所有的key
1) "key1"
127.0.0.1:6379> exists key1					# 判断某一个值是否存在
(integer) 1
127.0.0.1:6379> append key1 "hello"			# 追加字符串，如果当前key不存在，就相当于 set key
(integer) 7
127.0.0.1:6379> get key1
"v1hello"
127.0.0.1:6379> strlen key1					# 获取字符串长度
(integer) 7
127.0.0.1:6379> append key1 ",xiaofeng"
(integer) 16
127.0.0.1:6379> strlen key1
(integer) 16
127.0.0.1:6379> get key1
"v1hello,xiaofeng"

自增：i++；步长：i+=

127.0.0.1:6379> set views 0
OK
127.0.0.1:6379> get views
"0"
127.0.0.1:6379> incr views					# 自增1
(integer) 1
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> get views
"2"
127.0.0.1:6379> decr views					# 自减1
(integer) 1
127.0.0.1:6379> decr views
(integer) 0
127.0.0.1:6379> decr views
(integer) -1
127.0.0.1:6379> get views
"-1"
127.0.0.1:6379> incrby views 10				# 设置步长，指定增量
(integer) 9
127.0.0.1:6379> incrby views 10
(integer) 19
127.0.0.1:6379> decrby views 5
(integer) 14

getrange / setrange

# getrange
# 字符串范围 range
127.0.0.1:6379> set key1 "hello,xiaofeng"	# 设置key1的值
OK
127.0.0.1:6379> get key1
"hello,xiaofeng"
127.0.0.1:6379> getrange key1 0 4			# 截取字符串[0,3]
"hello"
127.0.0.1:6379> getrange key1 0 -1			# 获取全部字符串，和 get key1 是一样的
"hello,xiaofeng"

# setrange
# 替换
127.0.0.1:6379> set key2 abcdefg
OK
127.0.0.1:6379> get key2
"abcdefg"
127.0.0.1:6379> setrange key2 1 xx			# 替换指定位置开始的字符串
(integer) 7
127.0.0.1:6379> get key2
"axxdefg"

setex / setnx

# setex
# 将值 value 关联到 key ，并将 key 的生存时间设为 seconds (以秒为单位)。
# 如果 key 已经存在， SETEX 命令将覆写旧值。


# setnx（set if Not eXists，在分布式锁中常用）
# 将 key 的值设为 value ，当且仅当 key 不存在。
# 若给定的 key 已经存在，则 SETNX 不做任何动作。

127.0.0.1:6379> setex key3 30 "hello"		# 设置key3的值为 hello，30秒后过期
OK
127.0.0.1:6379> ttl key3
(integer) 24
127.0.0.1:6379> setnx mykey "redis"			# 如果 mykey 不存在，创建 mykey
(integer) 1
127.0.0.1:6379> keys *
1) "mykey"
2) "key2"
3) "key1"
127.0.0.1:6379> ttl key3
(integer) -2
127.0.0.1:6379> setnx mykey "MongoDB"		# 如果 mykey 存在，创建失败
(integer) 0
127.0.0.1:6379> get mykey
"redis"

mset、mget、msetnx、getset

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3		# 同时设置多个值
OK
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"
127.0.0.1:6379> mget k1 k2 k3				# 同时获取多个值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v1 k4 v4			# msetnx是原子性的操作，要么一起成功，要么一起失败
(integer) 0
127.0.0.1:6379> get k4
(nil)

# 对象
127.0.0.1:6379> set user:1 {name:zhangsan,age:3}		# 设置一个user:1对象，值为json字符串,再取出解析
OK
127.0.0.1:6379> get user:1
"{name:zhangsan,age:3}"
127.0.0.1:6379> mset user:2:name zhangsan user:2:age 19	# 这里的key是一个巧妙设计 user:{id}:{field}
OK
127.0.0.1:6379> mget user:2:name user:2:age
1) "zhangsan"
2) "19"

# getset
127.0.0.1:6379> getset db redis				# 如果不存在值，则返回nil
(nil)
127.0.0.1:6379> get db
"redis"
127.0.0.1:6379> getset db mongodb			# 如果存在值，获取原来的值，并设置新的值
"redis"
127.0.0.1:6379> get db
"mongodb"

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

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

3.3、List

基本数据类型，列表

在 Redis 里，可以把 List 玩成，栈、队列、阻塞队列

lpush / rpush

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

lpop / rpop

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

lindex

127.0.0.1:6379> lrange list 0 -1	# 通过下标获得list中的某一个值
1) "two"
2) "one"
127.0.0.1:6379> lindex list 0
"two"
127.0.0.1:6379> lindex list 1
"one"

llen

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> lpush list one
(integer) 1
127.0.0.1:6379> lpush list two
(integer) 2
127.0.0.1:6379> lpush list three
(integer) 3
127.0.0.1:6379> llen list			# 返回列表的长度
(integer) 3

lrem

127.0.0.1:6379> lpush list three
(integer) 4
127.0.0.1:6379> lrange list 0 -1	
1) "three"
2) "three"
3) "two"
4) "one"
127.0.0.1:6379> lrem list 1 one		# 移除list集合中指定个数的value，精确匹配
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "three"
3) "two"
127.0.0.1:6379> lrem list 1 three
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "two"
127.0.0.1:6379> lpush list three
(integer) 3
127.0.0.1:6379> lrem list 2 three
(integer) 2
127.0.0.1:6379> lrange list 0 -1
1) "two"

ltrim，list截断

127.0.0.1:6379> lpush mylist hello
(integer) 1
127.0.0.1:6379> lpush mylist hello1
(integer) 2
127.0.0.1:6379> lpush mylist hello2
(integer) 3
127.0.0.1:6379> lpush mylist hello3
(integer) 4
127.0.0.1:6379> ltrim mylist 1 2		# 通过下标截取指定的长度，这个list已经被截断了
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "hello2"
2) "hello1"

rpoplpush，移除最后一个元素，将它移动到新的列表中

127.0.0.1:6379> rpush mylist one
(integer) 1
127.0.0.1:6379> rpush mylist two
(integer) 2
127.0.0.1:6379> rpush mylist three
(integer) 3
127.0.0.1:6379> rpoplpush mylist myotherlist	# 移除最后一个元素，将它移动到新的列表中
"three"
127.0.0.1:6379> lrange mylist 0 -1
1) "one"
2) "two"
127.0.0.1:6379> lrange myotherlist 0 -1
1) "three"

lset,将列表指定下标的值替换

127.0.0.1:6379> exists list			# 判断是否存在
(integer) 0
127.0.0.1:6379> lset list 0 item	# 不存在报错
(error) ERR no such key
127.0.0.1:6379> lpush list value1
(integer) 1
127.0.0.1:6379> lrange list 0 0
1) "value1"
127.0.0.1:6379> lset list 0 item	# 存在，更新当前下标的值
OK
127.0.0.1:6379> lrange list 0 0
1) "item"
127.0.0.1:6379> lset list 1 other	# 如果不存在，则会报错
(error) ERR index out of range

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

127.0.0.1:6379> rpush mylist hello
(integer) 1
127.0.0.1:6379> rpush mylist world
(integer) 2
127.0.0.1:6379> linsert mylist before "world" "big"
(integer) 3
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "big"
3) "world"
127.0.0.1:6379> linsert mylist after "world" "!"
(integer) 4
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "big"
3) "world"
4) "!"

小结
List 实际是一个链表，可以前插、后插
如果 key 不存在，创建新的链表
如果 key存在，新增内容
如果移除了所有值，即空链表，也不存在
在两边插入或者改动效率高，中间操作效率相对低

3.4、Set

Set的中值不能重复

基本

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

#####################################################################################################

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

#####################################################################################################

127.0.0.1:6379> srem myset "hello"			# 移除set集合中的元素
(integer) 1
127.0.0.1:6379> scard myset
(integer) 2
127.0.0.1:6379> smembers myset
1) "feng"
2) "crater"

#####################################################################################################

127.0.0.1:6379> srandmember myset			# 随机抽选出一个元素
"crater"
127.0.0.1:6379> srandmember myset
"crater"
127.0.0.1:6379> srandmember myset
"feng"
127.0.0.1:6379> srandmember myset 2			# 随机抽选出指定个数的元素
1) "crater"
2) "feng"

#####################################################################################################

127.0.0.1:6379> smembers myset				
1) "feng"
2) "crater"
3) "xin"
127.0.0.1:6379> spop myset					# 随机删除一些set集合中的元素
"crater"
127.0.0.1:6379> spop myset
"xin"
127.0.0.1:6379> smembers myset
1) "feng"

#####################################################################################################

127.0.0.1:6379> sadd myset "hello"
(integer) 1
127.0.0.1:6379> sadd myset "world"
(integer) 1
127.0.0.1:6379> sadd myset "crater"
(integer) 1
127.0.0.1:6379> smove myset myset2 "crater"	# 将指定的值，移动到另外一个set集合
(integer) 1
127.0.0.1:6379> smembers myset
1) "world"
2) "hello"
127.0.0.1:6379> smembers myset2
1) "crater"

#####################################################################################################

127.0.0.1:6379> sadd key1 a
(integer) 1
127.0.0.1:6379> sadd key1 b
(integer) 1
127.0.0.1:6379> sadd key1 c
(integer) 1
127.0.0.1:6379> sadd key2 c
(integer) 1
127.0.0.1:6379> sadd key2 d
(integer) 1
127.0.0.1:6379> sadd key2 e
(integer) 1
127.0.0.1:6379> sdiff key1 key2		# 差集
1) "b"
2) "a"
127.0.0.1:6379> sinter key1 key2	# 交集（共同好友）
1) "c"
127.0.0.1:6379> sunion key1 key2	# 并集
1) "a"
2) "c"
3) "b"
4) "e"
5) "d"

3.5、Hash

Key-Map，他的值是一个Map集合

操作

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

#####################################################################################################

127.0.0.1:6379> hmset myhash field hello field2 world
OK
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "world"
3) "field"
4) "hello"
127.0.0.1:6379> hlen myhash								# 获取hash表的字段数量
(integer) 2

#####################################################################################################

127.0.0.1:6379> hexists myhash field					# 判断 hash 指定的字段是否存在
(integer) 1
127.0.0.1:6379> hexists myhash field3
(integer) 0

#####################################################################################################

127.0.0.1:6379> hkeys myhash							# 获取所有的 field
1) "field2"
2) "field"
127.0.0.1:6379> hvals myhash							# 获取所有的 value
1) "world"
2) "hello"

#####################################################################################################

127.0.0.1:6379> hset myhash field3 5
(integer) 1
127.0.0.1:6379> hincrby myhash field3 1					# 指定增量
(integer) 6
127.0.0.1:6379> hincrby myhash field3 -1
(integer) 5
127.0.0.1:6379> hsetnx myhash field4 hello				# 如果不存在，可以设置
(integer) 1
127.0.0.1:6379> hsetnx myhash field4 world				# 如果存在，不可以设置
(integer) 0

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

127.0.0.1:6379> hset user:1 name feng
(integer) 1
127.0.0.1:6379> hget user:1 name
"feng"

3.6、Zset（有序集合）

在 set 的基础上，增加了一个值：set k1 v1 -> zset k1 score v1

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

#####################################################################################################

127.0.0.1:6379> zadd salary 2500 xiaohong
(integer) 1
127.0.0.1:6379> zadd salary 5000 zhangsan
(integer) 1
127.0.0.1:6379> zadd salary 300 crater						# 添加3个用户
(integer) 1
127.0.0.1:6379> zrangebyscore salary -inf +inf				# 负无穷~正无穷范围内，从小到大排序
1) "crater"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> zrevrange salary 0 -1						# 从大到小排序
1) "zhangsan"
2) "xiaohong"
3) "crater"
127.0.0.1:6379> zrangebyscore salary -inf +inf withscores	# 负无穷~正无穷范围内，从小到大排序，附带成绩
1) "crater"
2) "300"
3) "xiaohong"
4) "2500"
5) "zhangsan"
6) "5000"
127.0.0.1:6379> zrangebyscore salary -inf 2500 withscores	# 小于2500的，从小到大排序，附带成绩
1) "crater"
2) "300"
3) "xiaohong"
4) "2500"

#####################################################################################################

127.0.0.1:6379> zrange salary 0 -1
1) "crater"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> zrem salary xiaohong						# 移除集合中的指定元素
(integer) 1
127.0.0.1:6379> zrange salary 0 -1
1) "crater"
2) "zhangsan"
127.0.0.1:6379> zcard salary								# 获取有序集合中的个数
(integer) 2

#####################################################################################################

127.0.0.1:6379> zadd myset 1 hello
(integer) 1
127.0.0.1:6379> zadd myset 2 world
(integer) 1
127.0.0.1:6379> zadd myset 3 crater
(integer) 1
127.0.0.1:6379> zcount myset 1 3							# 获取指定区间的成员数量
(integer) 3
127.0.0.1:6379> zcount myset 1 2
(integer) 2

4、三种特殊数据类型

4.1、geospatial（地理位置）

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

geoadd：添加地理位置

# 规则：两级无法直接添加。一般会下载数据，java一次性导入
# 参数：key （经度 纬度 名称）
127.0.0.1:6379> geoadd china:city 116.40 39.90 beijing
(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 chongqing 114.05 22.52 shenzhen
(integer) 2
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 beijing			# 获取指定城市的经度和纬度
1) 1) "116.39999896287918091"
   2) "39.90000009167092543"
127.0.0.1:6379> geopos china:city beijing shanghai
1) 1) "116.39999896287918091"
   2) "39.90000009167092543"
2) 1) "121.47000163793563843"
   2) "31.22999903975783553"

geodist：
两人之间的距离
单位：

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

127.0.0.1:6379> geodist china:city beijing shanghai		# 北京到上海直线距离
"1067378.7564"
127.0.0.1:6379> geodist china:city beijing shanghai km	# 北京到上海直线距离 单位：km
"1067.3788"

georadius：
以给定的经纬度为中心，找出某一半径内的元素。
附近的人：通过半径查询获得附近的人的地址，定位。

# 以经纬度为中心
127.0.0.1:6379> georadius china:city 110 30 1000 km				# 以 100,30 经纬度中心，半径1000km查找
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
127.0.0.1:6379> georadius china:city 110 30 500 km				
1) "chongqing"
2) "xian"
127.0.0.1:6379> georadius china:city 110 30 500 km withdist		# 显示到中心的直线距离
1) 1) "chongqing"
   2) "341.9374"
2) 1) "xian"
   2) "483.8340"
127.0.0.1:6379> georadius china:city 110 30 500 km withcoord	# 显示各自的经纬度
1) 1) "chongqing"
   2) 1) "106.49999767541885376"
      2) "29.52999957900659211"
2) 1) "xian"
   2) 1) "108.96000176668167114"
      2) "34.25999964418929977"
127.0.0.1:6379> georadius china:city 110 30 500 km withcoord count 1	# 筛选个数
1) 1) "chongqing"
   2) 1) "106.49999767541885376"
      2) "29.52999957900659211"
127.0.0.1:6379> georadius china:city 110 30 500 km withcoord count 2
1) 1) "chongqing"
   2) 1) "106.49999767541885376"
      2) "29.52999957900659211"
2) 1) "xian"
   2) 1) "108.96000176668167114"
      2) "34.25999964418929977"
127.0.0.1:6379> georadius china:city 110 30 500 km withcoord count 3
1) 1) "chongqing"
   2) 1) "106.49999767541885376"
      2) "29.52999957900659211"
2) 1) "xian"
   2) 1) "108.96000176668167114"
      2) "34.25999964418929977"

# 以元素为中心
127.0.0.1:6379> georadiusbymember china:city beijing 1000 km	# 指定元素为中心的指定半径内的元素
1) "beijing"
2) "xian"
127.0.0.1:6379> georadiusbymember china:city shanghai 400 km
1) "hangzhou"
2) "shanghai"

geohash
返回一个或多个位置元素的geohash表示
将二维的经纬度转化为一维的字符串，两个字符串越接近，那么距离越近

127.0.0.1:6379> geohash china:city beijing
1) "wx4fbxxfke0"
127.0.0.1:6379> geohash china:city beijing shanghai
1) "wx4fbxxfke0"
2) "wtw3sj5zbj0"

geo 底层的实现原理就是 Zset ，可以使用 Zset 命令操作geo

127.0.0.1:6379> zrange china:city 0 -1
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
6) "beijing"
127.0.0.1:6379> zrem china:city xian
(integer) 1
127.0.0.1:6379> zrange china:city 0 -1
1) "chongqing"
2) "shenzhen"
3) "hangzhou"
4) "shanghai"
5) "beijing"

4.2、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		# 添加元素
(integer) 1
127.0.0.1:6379> pfcount mykey						# 统计基数数量
(integer) 10
127.0.0.1:6379> pfadd mykey2 i j z x c v b n m
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 9
127.0.0.1:6379> pfmerge mykey3 mykey mykey2			# 合并两组，并集
OK
127.0.0.1:6379> pfcount mykey3
(integer) 15

如果允许容错，那么一定可以使用 Hyperloglog
如果不允许容错，就使用 set 或者自己的数据类型

4.3、Bitmap（位存储）

两个状态的都可以使用 Bitmaps

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

测试

127.0.0.1:6379> setbit sign 0 1		# 记录周一到周天的打卡
(integer) 0
127.0.0.1:6379> setbit sign 1 0
(integer) 0
127.0.0.1:6379> setbit sign 2 0
(integer) 0
127.0.0.1:6379> setbit sign 3 1
(integer) 0
127.0.0.1:6379> setbit sign 4 1
(integer) 0
127.0.0.1:6379> setbit sign 5 0
(integer) 0
127.0.0.1:6379> setbit sign 6 0
(integer) 0
127.0.0.1:6379> getbit sign 4		# 查看某天是否打卡
(integer) 1
127.0.0.1:6379> getbit sign 6
(integer) 0
127.0.0.1:6379> bitcount sign 		# 统计，只有3天打卡
(integer) 3

5、事务

5.1、事务

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

一次性、循序性、排他性

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

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

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

Redis的事务：

开启事务
命令入队
执行事务

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> 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)

运行时异常：事务队列中存在语法行，执行命令的时候，其他命令可以正常执行，错误命令抛出异常

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"

5.2、监控

悲观锁：

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

乐观锁：

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

获取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

非正常

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

如果事务执行失败，要重新监视

127.0.0.1:6379> unwatch				# 如果事务执行失败，要先解锁
OK
127.0.0.1:6379> watch money			# 获取最新的值，再监视
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby money 10
QUEUED
127.0.0.1:6379> incrby out 10
QUEUED
127.0.0.1:6379> exec				# 对比监视的值是否发生了变化，如果没有变化，那么可以执行成功
1) (integer) 980
2) (integer) 40

6、Jedis

我们要使用 java 操作 Redis

Jedis 是 Redis 官方推荐的 java 连接开发工具，使用 java 操作 Redis 中间件。

导入对应的依赖

<!--导入 Jedis 依赖-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.7.0</version>
</dependency>
<!--fastjson-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.72</version>
</dependency>

编码测试

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

public class a_TestPing {
    public static void main(String[] args) {
        // 1. new Jedis 对象
        Jedis jedis = new Jedis("192.168.153.139", 6379);

        // Jedis所有的命令就是Redis里所有的指令
        System.out.println(jedis.ping());
    }
}

连接失败解决方案：

连接失败：
 	1.redis配置文件修改：
 		注释掉bind，protected-mode为no
 	2.开放端口
		查看防火墙状态
		firewall-cmd --state
		开放6379端口
		firewall-cmd --permanent --add-port=6379/tcp
		查看端口，执行
		firewall-cmd --permanent --query-port=6379/tcp
		重启防火墙
		firewall-cmd --reload
	3.重启redis
		redis-cli -p 6379 shutdown
		redis-server /opt/redis/back_config/redis.conf

源码地址： https://gitee.com/Crater/test-redis.git

7、SpringBoot整合

SpringBoot 操作数据：spring-data，jpa、jdbc、mongodb、redis

SpringData 也是和 SpringBoot 齐名的项目

说明：在SpringBoot 2.X之后，原来使用的 Jedis 被替换为了 lettuce

jedis：采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用 jedis pool 连接池，更像 BIO 模式
lettuce：采用netty，实例可以在多个线程进行共享，不存在线程不安全的情况，可以减少线程数量，更像 NIO 模式

7.1、源码分析

package org.springframework.boot.autoconfigure.data.redis;

import java.net.UnknownHostException;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;

@Configuration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    // 如果name=redisTemplate的实例不存在，则此处生效
    // 我们可以自定义一个redisTemplate来替换这个默认的
    @ConditionalOnMissingBean(name = {"redisTemplate"}) 
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        // 默认的 RedisTemplate，没有过多地设置，没有序列化。（redis对象都是需要序列化的(自己写序列化)）
        // 两个泛型都是Object，我们使用后需要强转<String, Object>
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

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

7.2、测试

导入依赖

<!-- 操作Redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置连接

# SpringBoot 所有的配置类，都有一个自动配置类：RedisAutoConfiguration
# 自动配置类都会绑定一个 properties 配置文件：RedisProperties

spring.redis.host=192.168.153.140
spring.redis.port=6379

测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class Redis02SpringbootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void contextLoads() {
        // opsForValue()    操作字符串，类似String
        // opsForList()     操作List，类似List
        // opsForSet()
        // opsForHash()
        // opsForZSet()
        // opsForGeo()
        // opsForHyperLogLog()

        // 除基本的操作，常用的方法都可以直接通过redisTemplate操作，比如事务，基本的CURD

        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushDb();
        connection.flushAll();

        redisTemplate.opsForValue().set("myKey", "crater");
        Object myKey = redisTemplate.opsForValue().get("myKey");
        System.out.println(myKey);
    }
}

以上测试如果使用中文字符串，在Redis内会有乱码

7.3、序列化

RedisTemplate 部分源码，据此可以自定义的配置类

redis实例视频 redis精讲_redis实例视频_07

用对象的保存来验证，没有序列化的后果，用ObjectMapper()处理后可以执行成功，因为这个对象序列化了
对象需要序列化才能传输成功！

将User类序列化后就可以传输成功

redis实例视频 redis精讲_java_08

但是查看控制台，还是乱码

127.0.0.1:6379> keys *
1) "\xac\xed\x00\x05t\x00\x04user"

7.4、自定义RedisConfig

固定模板

@Configuration
public class RedisConfig {

    // 自定义 redisTemplate
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 使用<String, Object>，开发便利
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // JSON序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        // 使用ObjectMapper把对象转义
        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);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

测试成功，控制台查看redis

127.0.0.1:6379> keys *
1) "user"

在java代码中，查看获取的对象类型，可以下转型为 User 对象

7.5、工具类

见源码

8、Redis.conf详解

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

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

# Redis configuration file example.
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# units are case insensitive so 1GB 1Gb 1gB are all the same.
# 单位不区分大小写，所以1GB 1GB 1GB都是一样的。

包含其他配置文件

################################## INCLUDES ###################################

# 在这里包含一个或多个配置文件
#
# include /path/to/local.conf
# include /path/to/other.conf

网络

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

# 指定侦听服务器的网络接口的连接，如果不指定，则侦听服务器上所有可用网络接口的连接
# 为了测试远程访问，可以注释掉，也可以改为 0.0.0.0
# bind 127.0.0.1

# 是否保护模式，开启状态下外部网络访问，需配置bind ip或者设置访问密码
protected-mode no

# 端口
port 6379

# 此参数确定了TCP连接中已完成队列(完成三次握手之后)的长度，
# 当然此值必须不大于Linux系统定义的/proc/sys/net/core/somaxconn值，
# 默认是511，而Linux的默认参数值是128。当系统并发量大并且客户端速度缓慢的时候，可以将这二个参数一起参考设定。
tcp-backlog 511

# 超时
timeout 0

# 
tcp-keepalive 300

通用配置

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

# 是否作为守护进程开启，默认no
daemonize yes

# 管理守护进程，不用改
supervised no

# 如果以后台方式启动（守护模式），需要指定一个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 "/usr/local/bin/myconfig/a.log"

# 数据库数量，默认16个
databases 16

# 是否显示Logo
always-show-logo yes

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

################################ SNAPSHOTTING  ################################

# Redis是内存数据库，如果没有持久化，那么断电即失 
# 如果900S内，如果至少有1个key进行了修改，则进行持久化操作
save 900 1
# 如果300S内，如果至少有10个key进行了修改，则进行持久化操作
save 300 10
# 如果60S内，如果至少有10000个key进行了修改，则进行持久化操作
save 60 10000

# 持久化出错，是否停止写入
# 当持久化出现错误时，是否依然继续进行工作，是否终止所有的客户端write请求。
# 默认设置"yes"表示终止，一旦snapshot数据保存故障，那么此server为只读服务。
# 如果为"no"，那么此次snapshot将失败，但下一次snapshot不会受到影响，不过如果出现故障,数据只能恢复到"最近一个成功点"
stop-writes-on-bgsave-error no

# 在进行数据镜像备份时，是否启用rdb文件压缩手段
# 默认为yes。压缩可能需要额外的cpu开支，不过这能够有效的减小rdb文件的大，有利于存储/备份/传输/数据恢复
rdbcompression yes

# 读取和写入时候，会损失10%性能
# 是否进行校验和，是否对rdb文件使用CRC64校验和
# 默认为"yes"，那么每个rdb文件内容的末尾都会追加CRC校验和，利于第三方校验工具检测文件完整性
rdbchecksum yes

# 镜像备份文件的文件名，默认为 dump.rdb
dbfilename dump.rdb

# 数据库镜像备份的文件rdb/AOF文件放置的路径。
dir ./

主从复制

# 后文主从复制部分详解

安全

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

# 设置客户端连接后进行任何其他指定前需要使用的密码。
# 警告：因为redis 速度相当快，所以在一台比较好的服务器下，一个外部的用户可以在一秒钟进行150K 次的密码尝试，这意味着你需# 要指定非常非常强大的密码来防止暴力破解。
requirepass foobared

一般使用命令设置密码

客户端

################################### CLIENTS ####################################

# 限制同时连接的客户数量。
maxclients 10000

内存

############################## MEMORY MANAGEMENT ################################

# redis-cache所能使用的最大内存(bytes),默认为0,表示"无限制",
# 最终由OS物理内存大小决定(如果物理内存不足,有可能会使用swap)。
maxmemory <bytes>

# 内存不足的策略
# volatile-lru：	对"过期集合"中的数据采取LRU(近期最少使用)算法
# 				 如果对key使用"expire"指令指定了过期时间,那么此key将会被添加到"过期集合"中。
#				 将已经过期/LRU的数据优先移除.如果"过期集合"中全部移除仍不能满足内存需求,将OOM.
# allkeys-lru：对所有的数据,采用LRU算法
# volatile-random：对"过期集合"中的数据采取"随即选取"算法,并移除选中的K-V,直到"内存足够"为止. 
#				  如果如果"过期集合"中全部移除全部移除仍不能满足,将OOM
# allkeys-random：对所有的数据,采取"随机选取"算法,并移除选中的K-V,直到"内存足够"为止
# volatile-ttl： 对"过期集合"中的数据采取TTL算法(最小存活时间),移除即将过期的数据.
# noeviction：   不做任何干扰操作,直接返回OOM异常
# 另外，如果数据的过期不会对"应用系统"带来异常,且系统中write操作比较密集,建议采取"allkeys-lru"
maxmemory-policy noeviction

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

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

# aof文件名字，默认为appendonly.aof
appendfilename "appendonly.aof"

# 设置对appendonly.aof 文件进行同步的频率。
# always 表示每次有写操作都进行同步，
# everysec 表示对写操作进行累积，每秒同步一次。
# no不主动fsync，由OS自己来完成。
# appendfsync always
appendfsync everysec
# appendfsync no

# 重写
# 当Aof增长超过指定比例时，fork新的进程重写，0表示不自动重写，重写是为了使aof体积保持最小，确保保存最完整的数据。
auto-aof-rewrite-percentage 100
# 触发aof rewrite的最小文件尺寸
auto-aof-rewrite-min-size 64mb

9、Redis持久化

面试和工作，都是重点

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

9.1、RDB（Redis Database）

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

Redis 会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，在用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能。

如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那 RDB方式要比 AOF方式更加的高效。RDB的缺点是最后一次持久化的数据可能丢失。

我们默认RDB，一般情况下不需要修改这个配置

RDB保存的文件是 dump.rdb

相关配置

################################ SNAPSHOTTING  ################################

# Redis是内存数据库，如果没有持久化，那么断电即失 
# 如果900S内，如果至少有1个key进行了修改，则进行持久化操作
save 900 1
# 如果300S内，如果至少有10个key进行了修改，则进行持久化操作
save 300 10
# 如果60S内，如果至少有10000个key进行了修改，则进行持久化操作
save 60 10000

# 镜像备份文件的文件名，默认为 dump.rdb
dbfilename dump.rdb

# 数据库镜像备份的文件rdb/AOF文件放置的路径。
dir ./

触发机制

save规则满足的情况下，会自动触发 rdb 规则
执行 flushall 命令，也会触发 rdb 规则
退出 redis（shutdown），也会产生 rdb 文件

恢复 rdb 文件
将 rdb 文件放在 redis配置文件指定的rdb文件目录下，redis 启动时会自动检查dump.rdb，恢复其中的数据。

优缺点

优点：

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

缺点：

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

9.2、AOF（append only file）

将所有命令都记录下来，恢复的时候把文件全部重新执行一遍

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

配置文件

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

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

只要将 appendonly 改为 yes，就开启了aof

重启redis即可生效

如果aof文件有错误，Redis 不能成功启动，需要修复这个文件
Redis 提供了一个工具 redis-check-aof --fix
如果文件正常，就可以启动 Redis

优缺点

优点

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

缺点

相对于数据文件来说，aof 远远大于 rdb，修复速度也慢
运行效率也比 rdb 慢

9.3、扩展

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

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

性能建议

因为 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 Replication 实现高可用性也可以，能省掉一大笔IO，也减少了 rewrite 时带来的系统波动。代价是如果Master/Salve 同时宕机，会丢失十几分钟的数据，启动脚本也要比较两个 Master/Slave 中的 RDB 文件，载入最新的。

10、Redis发布订阅

10.1、简介

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

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

订阅 / 发布消息图：

①消息发布者，
②频道，
③消息订阅者

redis实例视频 redis精讲_java_09

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

redis实例视频 redis精讲_redis_10

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

redis实例视频 redis精讲_nosql_11

10.2、命令

序号	命令及描述
1	[PSUBSCRIBE pattern [pattern …]] 订阅一个或多个符合给定模式的频道。
2	[PUBSUB subcommand [argument [argument …]]] 查看订阅与发布系统状态。
3	[PUBLISH channel message] 将信息发送到指定的频道。
4	[PUNSUBSCRIBE [pattern [pattern …]]] 退订所有给定模式的频道。
5	[SUBSCRIBE channel [channel …]] 订阅给定的一个或多个频道的信息。
6	[UNSUBSCRIBE [channel [channel …]]] 指退订给定的频道。

10.3、测试

启动一个客户端，订阅一个频道，频道名 “crater”

127.0.0.1:6379> subscribe crater
Reading messages... (press Ctrl-C to quit)	# 等待读取推送的消息
1) "subscribe"
2) "crater"
3) (integer) 1

再启动一个客户端，向 “crater” 频道发送一条消息

127.0.0.1:6379> publish crater "hello"
(integer) 1

查看第一个客户端，接收到了消息

1) "message"		# 接收到一条消息
2) "crater"			# 来源，crater频道
3) "hello"			# 消息内容，hello

10.3、原理

Redis 是使用C语言实现的，通过分析 Redis 源码里的 pubsub.c 文件，了解发布订阅机制的底层实现。

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

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

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

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

11、Redis 主从复制

11.1、概念

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

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

一个主节点可以有多个从节点（或者没有从节点），但一个从节点只能有一个主节点。

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

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

一般来说，要将 Redis 运用于工程项目中，只使用一台 Redis 是万万不可以的，会有宕机的风险，原因如下：

从结构上，单个 Redis 服务器会发生但点故障，并且一台服务器需要处理所有的请求负载，压力较大。
从容量上，单个 Redis 服务器内存容量有限，就算一台 Redis 服务器内存容量为256G，也不能将所有内存用作 Redis 存储内存，一般来说，单个 Redis 最大使用内存不应该超过20G。

对于 “多读少写” 场景，可以使用如下架构：

redis实例视频 redis精讲_redis_12

11.2、环境配置

只需要配置从库，不需要配置主库
查看当前库信息

127.0.0.1:6379> info replication
# Replication
role:master				# 角色
connected_slaves:0		# 从机数量
master_replid:7c9e7f4905733444f4692154a70264bb015f5211
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

复制几个配置文件

[root@VM-16-8-centos myconfig]# ll
total 216
-rw-r--r-- 1 root root  5088 Jan  3 13:30 a.log
-rw-r--r-- 1 root root 50950 Jan  3 12:08 redis.conf
-rw-r--r-- 1 root root 50950 Jan  3 13:34 redis-m.conf
-rw-r--r-- 1 root root 50950 Jan  3 13:34 redis-s01.conf
-rw-r--r-- 1 root root 50950 Jan  3 13:34 redis-s02.conf
[root@VM-16-8-centos myconfig]#

主节点配置，从节点也对应修改

# 防止文件冲突
# 端口
port 16379
# 如果以后台方式启动（守护模式），需要指定一个pid文件
pidfile /var/run/redis_6379.pid
# 日志文件位置
logfile "/usr/local/bin/myconfig/6379.log"
# 镜像备份文件的文件名，默认为 dump.rdb
dbfilename dump6379.rdb

启动3个 redis 服务，查看一下

[root@VM-16-8-centos /]# ps -ef | grep redis
root      9611     1  0 14:02 ?        00:00:00 redis-server 127.0.0.1:16379
root      9744     1  0 14:03 ?        00:00:00 redis-server 127.0.0.1:16380
root      9826     1  0 14:03 ?        00:00:00 redis-server 127.0.0.1:16381
root      9992  9843  0 14:04 pts/4    00:00:00 grep --color=auto redis
[root@VM-16-8-centos /]#

11.3、一主二从搭建（命令方式）

只需要配置从机，一主（16379）二从（16380,16381）
如果有密码，需要在配置文件配置 masterauth df1996
从节点，从节点执行 slaveof

# 指定主库
127.0.0.1:16380> slaveof 127.0.0.1 16379
OK

# 查看主从信息
127.0.0.1:16380> info replication
# Replication
role:slave						# 当前角色
master_host:127.0.0.1			# 主机的信息
master_port:16379
master_link_status:up
master_last_io_seconds_ago:3
master_sync_in_progress:0
slave_repl_offset:0
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:9013b9a853feaf4aed462c442e4072f9e2d7b977
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:0
127.0.0.1:16380>

连接主节点，查看主从信息

127.0.0.1:16379> info replication
# Replication
role:master
connected_slaves:1												# 从机数量
slave0:ip=127.0.0.1,port=16380,state=online,offset=14,lag=1		# 从机信息
master_replid:9013b9a853feaf4aed462c442e4072f9e2d7b977
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:16379>

再开启一个从节点，执行 slaveof ，查看主从信息

127.0.0.1:16381> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:16379
master_link_status:up
master_last_io_seconds_ago:6
master_sync_in_progress:0
slave_repl_offset:258916
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:9013b9a853feaf4aed462c442e4072f9e2d7b977
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:258916
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:39313
repl_backlog_histlen:219604
127.0.0.1:16381>

再次查看主节点，看到有两个从机信息

127.0.0.1:16379> info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=16380,state=online,offset=258594,lag=1
slave1:ip=127.0.0.1,port=16381,state=online,offset=258594,lag=1
master_replid:9013b9a853feaf4aed462c442e4072f9e2d7b977
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:258594
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:258594
127.0.0.1:16379>

11.4、一主二从搭建（配置方式）

命令方式是一种临时的主从关系，而在配置文件中配置就是一种永久的，redis 服务启动就实现了主从复制

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

# Master-Replica replication. Use replicaof to make a Redis instance a copy of
# another Redis server. A few things to understand ASAP about Redis replication.
#
#   +------------------+      +---------------+
#   |      Master      | ---> |    Replica    |
#   | (receive writes) |      |  (exact copy) |
#   +------------------+      +---------------+
#
# 1) Redis replication is asynchronous, but you can configure a master to
#    stop accepting writes if it appears to be not connected with at least
#    a given number of replicas.
# 2) Redis replicas are able to perform a partial resynchronization with the
#    master if the replication link is lost for a relatively small amount of
#    time. You may want to configure the replication backlog size (see the next
#    sections of this file) with a sensible value depending on your needs.
# 3) Replication is automatic and does not need user intervention. After a
#    network partition replicas automatically try to reconnect to masters
#    and resynchronize with them.
#
replicaof 127.0.0.1 16379

# If the master is password protected (using the "requirepass" configuration
# directive below) it is possible to tell the replica to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the replica request.
#
masterauth df1996

11.5、一些细节

主节点可以写，从节点只可以读不能读

主节点设置值

127.0.0.1:16379> set k1 v1
OK
127.0.0.1:16379> keys *
1) "k1"
127.0.0.1:16379> get k1
"v1"

从节点也可以读到，但是不能写

127.0.0.1:16381> keys *
1) "k1"
127.0.0.1:16381> get k1
"v1"
127.0.0.1:16381> set k2 v2
(error) READONLY You can't write against a read only replica.

注：

主节点服务停止，查看从节点的主从信息发现角色还是 role:slave ，此时我们不能向 redis 写入信息了。
再次将主节点服务启动，写入新的值，从节点还是可以同步主节点的所有信息
如果从节点服务停止，在主节点查看主从信息发现，当前主节点只有一个从节点信息了
再次启动从节点服务，发现在此期间主节点写入的信息不能同步到当前从节点，因为启动后，默认为主节点
在从节点执行 slaveof 127.0.0.1 16379 ，发现主节点的所有信息又同步到从节点了（如果配置在配置文件里，则启动就可以同步）

复制原理：

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

11.6、宕机后手动配置主节点

前面搭建的模型如图：
还有一种模型：
在 16381 节点执行命令

127.0.0.1:16381> slaveof 127.0.0.1 16380
OK

在 16380 查看主从信息

127.0.0.1:16380> info replication
# Replication
role:slave		# 角色是从节点
master_host:127.0.0.1
master_port:16379
master_link_status:up
master_last_io_seconds_ago:5
master_sync_in_progress:0
slave_repl_offset:269006
slave_priority:100
slave_read_only:1
connected_slaves:1
slave0:ip=127.0.0.1,port=16381,state=online,offset=269006,lag=0
master_replid:9013b9a853feaf4aed462c442e4072f9e2d7b977
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:269006
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:269006
127.0.0.1:16380>

在这种模型下，中间的节点依然是从节点，如图
此时主节点关闭服务，在 16380 节点执行命令 slaveof no one16380 和 16381 组成主从复制关系

127.0.0.1:16380> slaveof no one
OK
127.0.0.1:16380> info replication
# Replication
role:master			# 角色：主节点
connected_slaves:1
slave0:ip=127.0.0.1,port=16381,state=online,offset=269146,lag=1
master_replid:4302b9a0819ab8fdbaf5679349e4fc888280a858
master_replid2:9013b9a853feaf4aed462c442e4072f9e2d7b977
master_repl_offset:269146
second_repl_offset:269147
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:269146
127.0.0.1:16380>

11.7、哨兵模式

当主节点宕机后，需要手动把一个从节点切换为主节点，这需要人工干预，会造成一段时间内服务不可用。这不是不被推荐的方法，更多时候，优先考虑 **哨兵模式 ** 。

Redis 从 2.8 开始提供了 Sentinel（哨兵）架构来解决这个问题，它能够后台监控主节点是否故障，一旦主节点故障，自动将从节点转换为主节点。

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

redis实例视频 redis精讲_java_13

这里哨兵有两个作用：

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

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

redis实例视频 redis精讲_redis_14

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

将环境改回一主二从来测试

127.0.0.1:16379> info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=16380,state=online,offset=126,lag=1
slave1:ip=127.0.0.1,port=16381,state=online,offset=126,lag=1
master_replid:e70a38add4f646d77e9d58e92984892458210e1f
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:126
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:126
127.0.0.1:16379>

配置哨兵文件，sentinel.conf

# sentinel monitor 被监控的主机名 host port 1
# 数字1表示指明当有多少个sentinel认为一个master失效时，master才算真正失效。
sentinel monitor myredis 127.0.0.1 16379 1

# sentinel不能分别为master和slave设置不同的密码，因此master和slave的密码应该设置相同。
# redis没有密码可以忽略这个配置
sentinel auth-pass myredis df1996

启动哨兵
此时关掉主节点服务，选取了 16381 成为主节点
查看 16381 节点的主从信息，发现它已经成为了主节点，16380 成为了 16381 的从节点

redis实例视频 redis精讲_java_15

此时再启动 16379 节点，因为配置文件被修改，它也成为不了主节点了，哨兵把它从属在 16381 节点下
查看 16379 和 16381 的主从信息，得以验证

redis实例视频 redis精讲_nosql_16

优点：

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

缺点

Redis 不容易在线扩容，集群数量一旦达到上限，在线扩容就非常麻烦
实现哨兵模式的配置比较麻烦，全配置如下

# Example sentinel.conf

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

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

# 哨兵sentinel监控的redis主节点的 ip port
# master-name	可以自定义主节点名称，只能由字母A-z、数字0-9、".-_"组成
# quorum		配置多少个哨兵统一认为master失联，才在客观上认为主节点真正失联
# sentinel monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor myredis 127.0.0.1 16379 1

# 当在Redis实例中开启了requirepass foobared 授权密码，这样所有连接Redis实例的客户端都需要提供密码
# 设置哨兵sentinel连接主从的密码，注意密码必须给主从设置一样的验证密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass myredis df1996

# 指定主节点没有应答哨兵sentinel多少毫秒后，哨兵主管上认为主节点下线，默认30秒
# sentinel down-after-milliseconds <master-name> <milliseconds>
sentinel down-after-milliseconds myredis 30000

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

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

# 配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
# 对于脚本的运行结果有以下规则:
# 若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
# 若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
# 如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
# 一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
# 通知型脚本:当sentinel有任何警告级别的事件发生时(比如说redis实例的主观失效和客观失效等等)，将会去调用这个脚本，这时这个脚本应该通过邮件，SMS 等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，一个是事件的类型，一个是事件的描述。如果sentinel. conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无法正常启动成功。
# 通知脚本
# sentine1 notification-script <master-name> <script-path>
sentine1 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>
sentine1 client-reconfig-script mymaster /var/redis/reconfig.sh #一般都是由运维来配置!

12、缓存穿透和雪崩

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

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

12.1、缓存穿透（查不到）

概念

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

redis实例视频 redis精讲_redis_17

解决方案

布隆过滤器
布隆过滤器是一种数据结构，对所有可能查询的参数以 hash 形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储的查询压力
缓存空对象
当存储层不命中后，即使返回的空对象也将其缓存起来，同时设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源

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

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

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

概念

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

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

解决方案

设置热点数据永不过期
从缓存层面来看，没有设置过期时间，所以不会出现热点 key 过期后产生的问题。
加互斥锁
分布式锁：使用分布式锁，保证对每个 key 同时只有一个线程去查询后端服务，其他线程没有获得分布式锁的权限，因此只需要等待即可。这种方式将高并发的压力转移到分布式锁，因此对分布式锁的考验很大。

12.3、缓存雪崩

概念

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

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

redis实例视频 redis精讲_nosql_18

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

解决方案

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

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

上一篇：linux服务器如何启动R语言 linux 启动服务器

下一篇：MySQL中折磨创建布尔类型数据 mysql布尔盲注

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

发布评论

相关文章

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

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