redis学习笔记

笔记来狂神的Redis教程，附链接：

 

【狂神说Java】Redis最新超详细版教程通俗易懂_哔哩哔哩_bilibili笔记资料交流都在我们的平台：www.kuangstudy.com秦疆老师Java全栈系列课程之Redis讲解从Nosql聊起，深入redis基本类型使用，拓展特殊类型连接jedis，使用springboot集成，上手实战开发事务、配置文件详解、发布订阅、持久化机制、主从复制、哨兵模式、缓存穿透和雪崩处理给你带来最全面的Redis讲解，学Redis，这一套课就够了！狂神说Java系列，努力打造通俗易https://www.bilibili.com/video/BV1S54y1R7SB?spm_id_from=333.999.0.0&vd_source=31cd080cb3558a8bc8bd143a655db86f

目录

redis

一、nosql

NoSQL特点

3V+3高：

2.阿里巴巴架构

3.npsql数据模型

4.Nosql四大分类

KV键值对：

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

列存储数据库：

图关系数据库（存关系的，不存图）；

5.CAP

6.base

7.Redis入门

Redis能干嘛？

特性：

学习中用到的：

Redis使用安装步骤（Windows）：

Redis在Linux中安装

测试性能

 基础知识

8.五大基础类型

Redis-Key

String

List

Set（集合）

Hash

Zset（有序集合）

9.三种特殊类型

geospatial 地理位置

hyperloglog

bitmaps

10.事务操纵

11.基础API之Jedis详解

（1）导入对应依赖

（2）编码测试

常用API

12.SpringBoot集成Redis操作

（1）导入依赖

（2）配置连接

（3）测试

13.配置（Redis.conf）详解

14.持久化

RDB（Redis DataBase）

 AOF（Append Onley File）

15.实现发布订阅

Redis 发布订阅命令

 应用场景

16.主从复制

作用

配置

复制的原理

层层链路

17.哨兵模式

使用流程配置：

优点：

缺点：

全部的哨兵配置

18.缓存穿透和雪崩

缓存穿透

解决方案

缓存击穿

解决方案

 缓存雪崩

解决方案

---

redis

一、nosql

1.单机MySQL时代

2.Memcached（缓存）+ MySQL+ 垂直拆分（读写分离）

.3分库分表+水平拆分+MySQL集群

NoSQL = Not Only SQL(不仅仅是SQL)，泛指非关系型数据库。

NoSQL特点

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

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

3.数据类型是多样型的！（不需要事先设计数据库，随取随用！）

4.传统的RDBMS和NoSQL

3V+3高：

大数据时代的3V：海量、多样、实时

大数据时代的3高：高并发、高可扩、高性能

2.阿里巴巴架构

3.npsql数据模型

4.Nosql四大分类

KV键值对：

~Redis

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

~MongoDB（一般要掌握）：

        是基于分布式文件存储的诗句哭，C++编写，主要用来处理大量的文档！

        是介于关系数据库和非关系型数据库中中间的产品！MongoDB是非关系型数据库中功能最丰富的，最像段喜迎数据库

~ConthDB

列存储数据库：

~HBase

~分布式文件系统

图关系数据库（存关系的，不存图）；

5.CAP

6.base

7.Redis入门

Redis，即远程字典服务。

Redis能干嘛？

1.内存存储、持久化。（rdb，aof）

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

3.发布订阅系统

4.地图信息分析

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

......

特性：

1.多样的数据类型

2.持久化

3.集群

4.事务

......

学习中用到的：

官网：Redis

中文网：CRUG网站

Linux下载可以在官网下载。

Windows下载链接如下：Redis下载，Windows直接运行使用-Java文档类资源-优快云下载

Redis使用安装步骤（Windows）：

接下来使用客户端来链接Redis：

 

然后在窗口直接输入ping，会报错，是因为redis有密码，需要登录

 

此时输入：auth "123456"    显示OK就可以用了。

若是不想有密码就可以直接删除密码，修改方式如下：

删除这一行，就行了。

 

 

Redis在Linux中安装

下载地址，我自己用的Redis：

redis下载安装使用-Java文档类资源-优快云下载

解压安装包：到 /opt 文件下

mv redis-6.0.6.tar.gz /opt     #移动到这个目录下

tar -zxvf redis-6.0.6.tar.gz    #解压压缩包

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

基本环境安装

安装gcc

 进行 make 命令

#

#

# 如果报错，请升级gcc版本，报错的原因就是Redis6以上需要gcc版本在7以上

#第一步
sudo yum install centos-release-scl

#第二步
sudo yum install devtoolset-7-gcc*
#第三步
scl enable devtoolset-7 bash

然后 make 一下就行了。

#

#

上面的完成之后，在make一下

make install 一下

 redis的默认安装路径    ‘usr/local/bin’

 将redis配置文件，复制到当前目录下

使用 mkdir 创建一个文件夹

 以后就使用这个配置文件进行启动

默认不是后台启动的，所以要修改配置文件

daemonize    设置为yes允许后台启动

启动Redis服务，使用redis-cli测试是否连接

 

查看redis进程是否开启

 关闭服务， shutdown

此时可再次查看进程，会发现进程已经消失

测试性能

redis-benchmark   是一个压力测试工具！是官方自带的工具

redis-benchmark 命令参数

简单测试：

1.测试：100并发连接    每个并发100000个请求

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

 基础知识

有16个数据库 

默认使用的是第0个，可以使用select进行切换

[root@MiWiFi-RA70-srv bin]# redis-cli -p 6379
127.0.0.1:6379> select 3           # 切换数据库，换成第3个
OK
127.0.0.1:6379[3]> select 0           # 切换数据库，换成第0个
OK
127.0.0.1:6379> dbsize           # 查看数据库的大小
(integer) 5
127.0.0.1:6379> 

127.0.0.1:6379[2]> keys *    # 查看数据库所有的key

清除数据库

127.0.0.1:6379[2]> flushdb     # 清除当前数据库的内容
127.0.0.1:6379[2]> flushall     # 清除所有的数据库的内容

 判断这个key是否存在

127.0.0.1:6379> EXISTS name
(integer) 1

redis是单线程的！

redis是内存操作，瓶颈是根据机器的内存和网络带宽。

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

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

8.五大基础类型

Redis可以用作数据库、缓存、消息中间件MQ。支持多种类型的数据结构。

Redis-Key

127.0.0.1:6379> keys *             # 查看所有的key
1) "name"
127.0.0.1:6379> set age 1
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> EXISTS name            # 判断当前的key是否存在
(integer) 1
127.0.0.1:6379> EXISTS name1
(integer) 0
127.0.0.1:6379> 
[root@MiWiFi-RA70-srv bin]# redis-cli -p 6379
127.0.0.1:6379> move name 1            # 移除当前的key，数字表示那个数据库
(integer) 1
127.0.0.1:6379> keys *
1) "age"
127.0.0.1:6379> set name yuanhang
OK
127.0.0.1:6379> clear
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> get name
"yuanhang"
127.0.0.1:6379> EXPIRE name 10            # 设置key的过期时间，单位是秒
(integer) 1
127.0.0.1:6379> ttl name            # 查看当前key的剩余时间
(integer) 1
127.0.0.1:6379> ttl name            # -2时表示到期
(integer) -2
127.0.0.1:6379> get name
(nil)

127.0.0.1:6379> TYPE name           # 查看当前key的一个类型
string
127.0.0.1:6379> TYPE age
string

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           # 判断某一个key是否存在
(integer) 1
127.0.0.1:6379> APPEND key1 "hellow"           # 往某个可以中追加字符串。若是可以不存                                                                                   在就相当于set一个key
(integer) 8
127.0.0.1:6379> get key1
"v1hellow"
127.0.0.1:6379> STRLEN key1           # 获取字符串的长度
(integer) 8
127.0.0.1:6379> APPEND key1 "yuanhang"
(integer) 16
127.0.0.1:6379> STRLEN key1
(integer) 16
127.0.0.1:6379> get key1
"v1hellowyuanhang"

---

步长

127.0.0.1:6379> set views 0           # 初始浏览量为0
OK
127.0.0.1:6379> get views
"0"
127.0.0.1:6379> INCR views           # 自增1  浏览量变为1
(integer) 1
127.0.0.1:6379> INCR views
(integer) 2
127.0.0.1:6379> get views           # 自减1
"2"
127.0.0.1:6379> DECR views
(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> DECRBY views 5           # 指定减量
(integer) 4

---

字符串范围

127.0.0.1:6379> set key1 "hello,yuanhang"           # 设置key的值
OK
127.0.0.1:6379> GETRANGE key1 0 3           # 截取字符串，闭区间的[]
"hell"
127.0.0.1:6379> GETRANGE key1 0 -1           # 获取全部的字符串 和 get key 一样的
"hello,yuanhang"

---

替换

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

---

# setex （set with expire） # 设置过期时间

# setnx（set if not exist） # 不存在设置（在分布式锁中会常常使用）

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

---

# mset

# mget

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

#

#

#

# 对象

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

#

#这里的key是一个巧妙的设计：user:{id}:{filed}，如此设计在Redis中是ok的！

127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "zhangsan"
2) "2"

---

# get set # 先get再set

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

List

基本的数据类型。是一个列表。

所有的list命令都是用L开头的

*linux不区分大小写的命令

127.0.0.1:6379> LPUSH list one           # 将一个值或者多个值，插入到列表头部（左）
(integer) 1
127.0.0.1:6379> LPUSH list two
(integer) 2
127.0.0.1:6379> LPUSH list three
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1           # 获取list中的值
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> LRANGE list 0 1           # 通过区间来获取具体的值
1) "three"
2) "two"

127.0.0.1:6379> RPUSH list rigth           # 将一个值或者多个值，插入到列表尾部（右）
(integer) 4
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
4) "rigth"

---

# LPOP

# RPOP

127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
4) "rigth"
127.0.0.1:6379> LPOP list           # 移除list的第一个元素
"three"
127.0.0.1:6379> RPOP list           # 移除list最后一个元素
"rigth"
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"

---

# LINDEX（lindex）

127.0.0.1:6379> LINDEX list 1           # 通过下标获取list中的某一个值
"one"

---

# Llen

127.0.0.1:6379> lpush list one two three
(integer) 3
127.0.0.1:6379> LLEN list           # 获取list的长度
(integer) 3

---

移除指定的值！

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> LRANGE list 0 -1
1) "three"
2) "three"
3) "two"
127.0.0.1:6379> LREM list 2 three
(integer) 2
127.0.0.1:6379> LRANGE list 0 -1
1) "two"

---

#trim 修剪；list 截断

127.0.0.1:6379> RPUSH mylist "hello1"
(integer) 1
127.0.0.1:6379> RPUSH mylist "hello2"
(integer) 2
127.0.0.1:6379> RPUSH mylist "hello3"
(integer) 3
127.0.0.1:6379> RPUSH mylist "hello4"
(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) "hello3"

---

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

127.0.0.1:6379> rpush mylist "hello"
(integer) 1
127.0.0.1:6379> rpush mylist "hello1"
(integer) 2
127.0.0.1:6379> rpush mylist "hello2"
(integer) 3
127.0.0.1:6379> RPOPLPUSH mylist myotherlist          
"hello2"
127.0.0.1:6379> LRANGE mylist 0 -1           # 查看原来的列表
1) "hello"
2) "hello1"
127.0.0.1:6379> LRANGE myotherlist 0 -1           # 查看目标列表，确实存在值
1) "hello2"

---

# lset 将列表中指定下标的值替换为另一个值，更新操作

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> lrang list 0 0
(error) ERR unknown command `lrang`, with args beginning with: `list`, `0`, `0`, 
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 item           # 如果不存在就会报错
(error) ERR index out of range

---

# linsert 将某个具体的value插入到列表中某个元素的前面或者后面

127.0.0.1:6379> clear
127.0.0.1:6379> RPUSH mylist hello
(integer) 1
127.0.0.1:6379> RPUSH mylist ,word
(integer) 2
127.0.0.1:6379> LINSERT mylist after ,word new           # 插入元素之前
(integer) 3
127.0.0.1:6379> LINSERT mylist before ",word" "other"           # 插入元素之后
(integer) 4
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "other"
3) ",word"
4) "new"

Set（集合）

set中的值是不可以重复的

127.0.0.1:6379> sadd mysset "hello"           # set集合汇总添加元素
(integer) 1
127.0.0.1:6379> sadd mysset "yuanhang"
(integer) 1
127.0.0.1:6379> sadd mysset "shuaiqi"
(integer) 1
127.0.0.1:6379> SMEMBERS mysset           # 查看指定set的所有值
1) "yuanhang"
2) "shuaiqi"
3) "hello"
127.0.0.1:6379> sismember mysset hello           # 判断某一个值是不是在set集合中
(integer) 1

---

127.0.0.1:6379> SCARD mysset           # 获取set集合中的内容元素个数
(integer) 4

---

127.0.0.1:6379> SREM mysset hello           # 移除set中的指定元素
(integer) 1
127.0.0.1:6379> SCArd mysset
(integer) 3
127.0.0.1:6379> SMEMBERS mysset
1) "lovemyy"
2) "yuanhang"
3) "shuaiqi"

---

set是无序不重复集合。抽随机

127.0.0.1:6379> SRANDMEMBER mysset           # 随机抽选出一个元素
"yuanhang"
127.0.0.1:6379> SRANDMEMBER mysset
"shuaiqi"
127.0.0.1:6379> SRANDMEMBER mysset
"lovemyy"

127.0.0.1:6379> srandmember mysset 2           # 随机抽选出指定个数的元素
1) "lovemyy"
2) "shuaiqi"

---

移除指定的key，随机删除指定的key

127.0.0.1:6379> smembers mysset
1) "lovemyy"
2) "yuanhang"
3) "shuaiqi"
127.0.0.1:6379> spop mysset           # 随机删除set集合中的元素
"lovemyy"
127.0.0.1:6379> spop mysset
"yuanhang"
127.0.0.1:6379> smembers mysset
1) "shuaiqi"

---

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

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

---

数字集合类：差集、交集、并集

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 key1 d
(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> sadd key2 f
(integer) 1
127.0.0.1:6379> sdiff key1 key2           # 差集，查看不同的
1) "b"
2) "a"
3) "c"
127.0.0.1:6379> sinter key1 key2           # 交集，共同的
1) "d"
127.0.0.1:6379> SUNION key1 key2           # 并集
1) "b"
2) "d"
3) "a"
4) "e"
5) "f"
6) "c"

例如：微博中的共同关注

Hash

Map集合，key-map  这个时候是一个map集合。本质和String类型是没有太大区别的，就是一个简单的key-value

127.0.0.1:6379> hset myhash field1 yuanhang           # set一个具体的key-value
(integer) 1
127.0.0.1:6379> hget myhash field1           # 获取一个字段值
"yuanhang"
127.0.0.1:6379> hmset myhash field1 hello field2 world           # set多个key-value
OK
127.0.0.1:6379> hmget myhash field1 field2           # 获取多个字段值
1) "hello"
2) "world"
127.0.0.1:6379> hgetall myhash           # 获取全部的值
1) "field1"
2) "hello"
3) "field2"
4) "world"

127.0.0.1:6379> hdel myhash field1           # 删除指定的key字段，对应的value也就消失了
(integer) 1
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "world"

---

# hlen

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

---

127.0.0.1:6379> HEXISTS myhash field1           # 判断hash中指定字段是否存在
(integer) 1
127.0.0.1:6379> HEXISTS myhash field3
(integer) 0

---

# 只获得所有的field

# 只获得所有的value

127.0.0.1:6379> hkeys myhash           # 只获得所有的field
1) "field2"
2) "field1"
127.0.0.1:6379> hvals myhash           # 只获得所有的value
1) "world"
2) "hellow"

---

# incr    decr

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 word           # 如果存在则不能设置
(integer) 0

---

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

Zset（有序集合）

在set的集合上增加了一个值

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

---

# 排序   -inf负无穷    +inf正无穷

127.0.0.1:6379> zadd xin 2500 xiaohong 5000 zhangsan 500 yuanhang           # 添加三个                                                                                                                                    用户
(integer) 3
127.0.0.1:6379> ZRANGEBYSCORE xin -inf +inf           # 显示全部的用户，从小到大排序
1) "yuanhang"
2) "xiaohong"
3) "zhangsan"

127.0.0.1:6379> ZREVRANGE xin 0 -1           # 显示全部的用户，从大到小排序
1) "zhangsan"
2) "yuanhang"

127.0.0.1:6379> ZRANGEBYSCORE xin -inf +inf withscores           # 显示全部用户，并且                                                                                                                   带成绩
1) "yuanhang"
2) "500"
3) "xiaohong"
4) "2500"
5) "zhangsan"
6) "5000"
127.0.0.1:6379> ZRANGEBYSCORE xin -inf 2500 withscores           # 显示小于2500的用                                                                                                                    户，降序排列
1) "yuanhang"
2) "500"
3) "xiaohong"
4) "2500"

---

# 移除元素 zrem

127.0.0.1:6379> ZRANGE xin 0 -1
1) "yuanhang"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> zrem xin xiaohong           # 移除有序集合中的指定元素
(integer) 1
127.0.0.1:6379> ZRANGE xin 0 -1
1) "yuanhang"
2) "zhangsan"

127.0.0.1:6379> ZCARD xin           # 获取有序集合中的个数
(integer) 2

---

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

---

例如：set排序，存储班级成绩表，工资表排序；；；；；普通消息1，重要消息2  设置权重

；；；；排行榜应用实现程序，取TOP N！

9.三种特殊类型

geospatial 地理位置

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

可以推算出地理位置的信息，两地之间的距离。

只有六个命令

 geoadd：添加地理位置

规则：两级（南极北极）无法直接添加，一般来说，会下载城市数据，直接用java程序一次性导入

参数：key  值（经度，纬度，名称）

有效的经度：-180到180

有效的纬度：-85.05112878到85.05112878

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"

---

# geodist

单位：m 表示米；km 表示千米；mi 表示英里；ft 表示英尺

127.0.0.1:6379> GEODIST china:city beijing shanghai m           # 查看北京到上海的直线距                                                                                                           离 单位是米
"1067378.7564"

---

# 找附近的人

# 获得指定数量的人

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

127.0.0.1:6379> GEORADIUS china:city 110 30 500 km

                                                                                           # 获取110 30 这个经纬度为中                                                                                                      心方圆500千米内的城市（所有                                                                                                  的数据应该已经录入china:city）
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 withdist count 1

                                                                                                           # 筛选出指定个数的城市
1) 1) "chongqing"
   2) "341.9374"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"

---

# georadiusbymember

找出位于指定位置周围其他元素

127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijing 1000 km
1) "beijing"
2) "xian"
 

---

# geohash 返回一个或者多个位置元素（以hash值的方式返回）

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

---

# geo 实现原理：

就是Zset，也就是说可以使用zset命令操作

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 beijing           # 移除北京元素
(integer) 1
127.0.0.1:6379> ZRANGE china:city 0 -1
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"

hyperloglog

Redis2.8.9版本之后就更新了Hyperloglog数据结构！

基数：集合中不重复的元素的个数

是用来做基数统计的算法。

优点是：占用的内存是固定的

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           # 统计 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或者自己的数据类型即可！

bitmaps

位存储

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

记录周一到周日的打卡！

周一：1  周二：0  周三：0  周四：1  周五：1  周六：0  周日：0

127.0.0.1:6379> setbit sign 0 1
(integer) 0
127.0.0.1:6379> setbit sign 1 0
(integer) 0
127.0.0.1:6379> setbit sign 2 0
(integer) 0
127.0.0.1:6379> setbit sign 3 1
(integer) 0
127.0.0.1:6379> setbit sign 4 1
(integer) 0
127.0.0.1:6379> setbit sign 5 0
(integer) 0
127.0.0.1:6379> setbit sign 6 0
(integer) 0
 

---

查看某一天是否有打卡！

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

---

统计打卡天数

127.0.0.1:6379> bitcount sign
(integer) 3
 

10.事务操纵

事务：要么同时成功，要么同时失败！

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

一次性、顺序性、排他性！

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

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

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

Redis的事务：

开启事务（multi）

命令入队（。。。。）

执行事务（exec）

正常执行事务：

127.0.0.1:6379> MULTI           # 开启事务
OK

# 命令入队
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v1
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) "v1"
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> keys *
1) "k3"
2) "k2"
3) "k1"

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

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

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

127.0.0.1:6379> set k1 "v1"
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> INCR k1    # 在执行的时候失败
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> get k3
QUEUED
127.0.0.1:6379> EXEC
1) (error) ERR value is not an integer or out of range    # 虽然第一条命令报错了，但是依旧                                                                                             正常执行成功了
2) OK
3) OK
4) "v3"
127.0.0.1:6379> get k2
"v2"
127.0.0.1:6379> get k3
"v3"

 监控（watch）

悲观锁：

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

乐观锁：（1.获取version  2更新的时候比较version）

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

 Redis监控测试

正常执行成功

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

---

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

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)

---

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

11.基础API之Jedis详解

使用Java来操作Redis

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

（1）导入对应依赖

<!--    导入Jedis包-->
    <dependencies>
        <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.2.3</version>
        </dependency>
<!--        fastjson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>
    </dependencies>

（2）编码测试

连接数据库

此处要注意一个问题，如果是连接本机电脑就不用啦，但是连接远程的redis（云服务器、虚拟机）要首先进行修改配置：

1.关闭防火墙

systemctl stop firewalld

2.进入redis.conf文件将protected-mode yes中yes改为no   还有  bind 127.0..0.1注释掉

3.重新启动redis就好了

####

####

备注：如果此时还不行，请执行如下命令，用来开启6379 端口的防火墙，也可以先执行这个命令测试一下，先不用关闭防火墙。

/sbin/iptables -I INPUT -p tcp --dport 6379 -j ACCEPT

补充：

查看防火墙：systemctl status firewalld

开启防火墙：systemctl start firewalld

---

---

---

---

接下来是连接测试代码和结果：

public class TestPing {
    public static void main(String[] args) {
        // 1、new Jedis 对象即可
        Jedis jedis = new Jedis("172.16.9.218", 6379);
        // Jedis 所有的命令就是我们之前学的所有指令！
        System.out.println(jedis.ping());
    }
}

操作命令

断开连接

jedis.close();

常用API

所有的api命令就是上面将的命令。

12.SpringBoot集成Redis操作

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

SpringData也是和SpringBoot齐名的项目

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

jedis：采用的直连的方式，多个线程的话，操作是不安全的。如果想要避免不安全，就要使用jedis pool连接池。BIO。

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

（1）导入依赖

新建的时候选择下面几个配置

 在maven 下载配置文件。

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

（2）配置连接

在application.properties进行配置，这里的ip和端口根据自己的情况写

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

# 配置redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
# 配置连接池的时候直接用lettuce

（3）测试

在测试类中

输入一下代码进行测试：

private RedisTemplate redisTemplate; 如果爆红，不用在意，不影响使用。可以将自己的报错等级降低就好了。就不具体写过程了，直接百度搜索“Autowired创建Bean爆红”，就有很多解决方法了。

package com.yh.redis_02_springboot;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class Redis02SpringbootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;


    @Test
    void contextLoads() {

//        // redisTemplate 操作不同的数据类型
//        // opsForValue 操作字符串 类似String
//        // opsForList 操作List 类似List
//        redisTemplate.opsForValue();
//        redisTemplate.opsForList();
//
//        //除了基本的操作，我们常用的方法都可以 直接通过redisTemplate，比如事务，和基本的CRUD
//
//        //获取redis的连接对象
//        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
//        connection.flushAll();
//        connection.flushDb();

        redisTemplate.opsForValue().set("mykey", "yuiop");
        System.out.println(redisTemplate.opsForValue().get("mykey"));;
    }

}

此处，对应的value值只能是英文，如果是中文，在idea会正常显示，但是去redis中查询就会出现乱码，是因为进行了序列化操作。

 所以我们接下来要自己定义一个配置类。

 下面是自己配置的redisTemplate。（有三种）

这个地方的配置仅供参考，当然可以直接使用，但是因为redis更新等其他原因，会导致书写方式有所不同。所以如果有时间，建议查看最新版本的配置，直接搜索“redis序列化配置就好”。

//第一种
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        return redisTemplate;
    }



//第二种
    @Bean
    public RedisTemplate<Object, Object> redisTemplate() {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        //JSON格式序列化
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //key的序列化
        redisTemplate.setKeySerializer(genericJackson2JsonRedisSerializer);
        //value的序列化
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        //hash结构key的虚拟化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        //hash结构value的虚拟化
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        return redisTemplate;
    }


//第三种
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        //为了开发方便直接使用<String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate();
        template.setConnectionFactory(factory);
        
        //配置具体的序列化方式
        Jackson2JsonRedisSerializer objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        objectJackson2JsonRedisSerializer.setObjectMapper(om);
        //String序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        
        //key采用String序列化方法
        template.setKeySerializer(stringRedisSerializer);
        //hash采用String序列化方法
        template.setHashKeySerializer(stringRedisSerializer);
        //value序列化方法采用jackson
        template.setValueSerializer(objectJackson2JsonRedisSerializer);
        //hash的value序列化方法采用jackson
        template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
        
        template.afterPropertiesSet();
        return template;
    }

13.配置（Redis.conf）详解

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

单位

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

包含

 可以将多个配置文件写到这里

网络

 bind 127.0.0.1    # 绑定ip

protected-mode no    # 保护模式

port 6379    # 端口设置

 通用（GENERAL）

daemonize yes    # 以守护进程的方式运行，默认是no，需要自己改成yes，这样就可以后台                                 运行了
pidfile /var/run/redis_6379.pid    # 如果以后台方式运行，我们就需要制定一个pid文件
 

# 日志

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

logfile ""    # 日志的文件位置名，为空就是标准的输出

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

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

 快照（SNAPSHOTTING）

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

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

如果900秒内，至少有一个key进行了修改，就会进行持久化操作

save 900 1

如果300秒内，至少有十个key进行了修改，就会进行持久化操作
save 300 10

如果60秒内，至少有10000个key进行了修改，就会进行持久化操作
save 60 10000

以后学习持久化的时候，会自己定义。

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

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

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

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

复制（REPLICATION）

下面说主从复制的时候再说

安全（SECURITY）

# requirepass foobared    # 没有密码，设置为空

CONFIG GET requirepass    # 查询密码

 127.0.0.1:6379> CONFIG SET requirepass "123456"    # 设置密码
OK

注意：设置密码后建议重新启动redis，以保证能够生效

127.0.0.1:6379> CONFIG GET requirepass    # 未输入密码，需要验证
(error) NOAUTH Authentication required.  
127.0.0.1:6379> auth 123456    # 输入密码
OK
127.0.0.1:6379> CONFIG GET requirepass    # 成功查询
1) "requirepass"
2) "123456"

限制（CLIENTS）

# maxclients 10000    # 设置连接上redis的最大客户端的数量

# maxmemory <bytes>    # redis 配置最大的内存容量

maxmemory-policy noeviction    # 内存达到上限的处理策略

maxmemory-policy 的六种方式：：：：：：

1、volatile-lru：只对设置了过期时间的key进行LRU（默认值） 

2、allkeys-lru ： 删除lru算法的key   

3、volatile-random：随机删除即将过期key   

4、allkeys-random：随机删除   

5、volatile-ttl ： 删除即将过期的   

6、noeviction ： 永不过期，返回错误

APPEND ONLY MODE（模式）aof 配置

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

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

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

14.持久化

RDB（Redis DataBase）

在生产环境会将dump.rdb文件进行备份

rdb 保存的文件就是dump.rdb 都是在配置文件中的快照模块配置的

dbfilename dump.rdb    # 设置rdb保存的文件名

#########

触发机制：

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

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

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

备份就自动生成了一个dump.rdb文件

恢复rdb文件

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

---

1.查看需要存在的位置

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

所以在 Redis 中默认的配置就基本够用了。

优点：

1.适合大规模的数据恢复

2.对数据的完成性要求不高

缺点：

1.需要一定的时间间隔进行操作，如果redis意外宕机了，这个最后一次的修改数据就没有了

2.fork进行的时候会占用的一定的内容空间

 AOF（Append Onley File）

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

 appendonly no    # 默认不开启，用的时候需要手动开启

只需要改这个地方就开启了 aof

 接下里重启redis就可以生效！！！！

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

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

命令：redis-check-aof --fix appendonly.aof 

---

如果文件正常，重启就可以继续用了。

 优点：

1.每一次修改都同步，文件的完整性会更好

2.每秒通过一次，可能会丢失一面的数据

3.从不同步，效率最高

缺点：

1.相对于数据文件来说，aof远远大于rdb，修复速度也比rdb慢

3.aof运行效率也要比rdb慢，所以redis默认配置就是rdb持久化

15.实现发布订阅

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

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

订阅发布图：

消息发送者 ---- 频道 ---- 接受者

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

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

Redis 发布订阅命令

下表列出了 redis 发布订阅常用命令：

序号	命令及描述
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 ...]] 指退订给定的频道。

 应用场景

实时消息系统！

实时聊天！（把频道当做聊天室，将信息回显给所有人就好）

订阅、关注系统都是可以的！

稍微复杂的场景就会使用消息中间件（MQ）

16.主从复制

       主人--仆从

        主从复制，是用来建立一个和主数据库完全一样的数据库环境，称为从数据库。在赋值过程中，一个服务器充当主服务器，而另外一台服务器充当从服务器。
当一台从服务器连接到主服务器时，从服务器会通知主服务器从服务器的日志文件中读取最后一次成功更新的位置。然后从服务器会接收从哪个时刻起发生的任何更新，然后锁住并等到主服务器通知新的更新。

 主从复制，读写分离！80%的情况下dou是在进行读操作！可以缓解服务器的压力！架构中经常使用！一主二从（最低）！

一般来说Redis的内存不超过20G！

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

作用

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

配置

只需要配置从库！

127.0.0.1:6379> info replication    #查看当前库的信息
# Replication
role:master     # 角色
connected_slaves:0     # 从机数量，现在没有从机
master_replid:3b54deef5b7b7b7f71f2sd5xefa23be48879b4fcff
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

---

最少打开三个机器进行测试，并复制三个配置文件

---

修改：

端口

pid名字

log文件名字

dump.rdb名字

修改配置完成后进行启动，并查看一下服务是否启动，可以通过进程信息进行查看

---

一般情况下只用配置从机！（此时假设三台机器。。。。79。。。。80。。。。81）

命令：slaeof IP地址 端口号

例如：slaeof 127.0.0.1 6379    （此时在80机器上配置，使之变成79的从机）

---

 查看一下主机的信息

---

以上都是通过命令配置的（暂时性的）

真实环境中都是通过配置文件进行配置的（永久性的）

---

注：

主机可以进行读写，从机只能进行读操作

复制的原理

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

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

层层链路

上一个master连接下一个slave

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

 如果没有了主机，能不能自己选择一个主机出来？手动进行！（谋朝篡位）

执行命令：slaveof no one 可以使自己变成主机。

那么其他节点就可以连接到这个主机。如果此时原来的主机修复了，也没有从机会自动连接上去，除非再一次手动配置。-----------所以出现了一个可以自动处理这些问题的就是哨兵模式！

17.哨兵模式

简单介绍一下哨兵模式（仅是个人现阶段理解）：

在服务器主机宕机之后，整个主从模式的服务就会失效，为了能够实现自主的设置新的主机，所以这个模式出现了。

大致的工作流程就是：

一个哨兵对某个服务器进行连接，发现没有回应（此时不判断为宕机），接着其他哨兵也连接该服务器，若是都没有连接成功，则判断该服务器已经宕机。

接着所有的哨兵就会根据设定的条件进行投票，推选出新的主机，并让其他可以使用的从机进行连接。此时，一个新的服务集群就会出现了。.

使用流程配置：

新建一个 sentinel 文件（sentinel.config）

使用命令：vim sentinel

（此处简单配置）在文件里写入要监视那个服务

写入代码： sentinel monitor myredis 127.0.0.1 6379 1

#     sentinel monitor 被监控的名称（随意取名）主机的IP地址 主机的端口 1

此处数字1表示，主机宕机之后，投票看让谁成为主机，票数最多的为主机！

然后保存退出文件就好。

启动哨兵。

使用命令： redis-sentinel kconfig/sentinel.config

#    redis-sentinel 配置文件的地址

如果此时原来的主机回来的，就只能归并到新的主机之下，当做从机！

优点：

哨兵集群，基于主从复制模式，所有的主从配置优点，他都有。

主从可以切换，故障可以转移，系统的可用性就会更好。

哨兵模式就是主从模式的升级，从手动到自动，更加健壮。

缺点：

Rdies不好在线扩容，如果集群的容量一旦到达上线，在线扩容就会十分麻烦。

实现哨兵模式的配置其实是很麻烦的，里面有很多选择。

全部的哨兵配置

# Example sentinel.conf
 
# 哨兵sentinel实例运行的端口 默认26379
port 26379
 
# 哨兵sentinel的工作目录
dir /tmp
 
# 哨兵sentinel监控的redis主节点的 ip port 
# master-name  可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。
# quorum 当这些quorum个数sentinel哨兵认为master主节点失联 那么这时 客观上认为主节点失联了
# sentinel monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor mymaster 127.0.0.1 6379 1
 
# 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供密码
# 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
 
 
# 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒
# sentinel down-after-milliseconds <master-name> <milliseconds>
sentinel down-after-milliseconds mymaster 30000
 
# 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同步，
这个数字越小，完成failover所需的时间就越长，
但是如果这个数字越大，就意味着越 多的slave因为replication而不可用。
可以通过将这个值设为 1 来保证每次只有一个slave 处于不能处理命令请求的状态。
# sentinel parallel-syncs <master-name> <numslaves>
sentinel parallel-syncs mymaster 1
 
 
 
# 故障转移的超时时间 failover-timeout 可以用在以下这些方面： 
#1. 同一个sentinel对同一个master两次failover之间的间隔时间。
#2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的failover所需要的时间。  
#4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了
# 默认三分钟
# sentinel failover-timeout <master-name> <milliseconds>
sentinel failover-timeout mymaster 180000
 
# SCRIPTS EXECUTION
 
#配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
#对于脚本的运行结果有以下规则：
#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
#若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
#一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执行。
 
#通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本，
#这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，
#一个是事件的类型，
#一个是事件的描述。
#如果sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无法正常启动成功。
#通知脚本
# sentinel notification-script <master-name> <script-path>
  sentinel notification-script mymaster /var/redis/notify.sh
 
# 客户端重新配置主节点参数脚本
# 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。
# 以下参数将会在调用脚本时传给脚本:
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
# 目前<state>总是“failover”,
# <role>是“leader”或者“observer”中的一个。 
# 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
# 这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentinel client-reconfig-script <master-name> <script-path>
sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

18.缓存穿透和雪崩

缓存穿透

就是查不到数据。

        在默认情况下，用户请求数据时，会先在缓存(Redis)中查找，若没找到即缓存未命中，再在数据库中进行查找，数量少可能问题不大，可是一旦大量的请求数据（例如秒杀场景）缓存都没有命中的话，就会全部转移到数据库上，造成数据库极大的压力，就有可能导致数据库崩溃。网络安全中也有人恶意使用这种手段进行攻击被称为洪水攻击。

解决方案

（1）布隆过滤器

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

 

（2）缓存空对象

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

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

如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的控制的键。

即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致的业务会有影响。

缓存击穿

量太大了，直接打到了一个点上。

解决方案

（1）设置热点数据永不过期

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

 （2）加互斥锁

加锁保证只有一个线程进行操作。可以去学习JUC的教程。

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

 缓存雪崩

是指缓存集中过期或者Redis宕机（最致命）！

这就是服务器的高可用问题。

解决方案

（1）redis高可用

这个的意思就是多设置几台redis，一台宕机之后其他的还可以继续工作。就是建立集群的意思。

（2）限流降级

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

（3）数据预热

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