一，概述和安装
-
Redis是一个开源的key-value存储系统。
-
和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。
-
这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。
-
在此基础上，Redis支持各种不同方式的排序。
-
与memcached一样，为了保证效率，数据都是缓存在内存中。
-
区别的是Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件。
-
并且在此基础上实现了master-slave(主从)同步。
适用场景：
-
高频次，热门访问的数据，降低数据库IO
-
分布式架构，做session共享
安装
1.安装wget命令 & lszrz 命令
yum -y install wget
# 使用wget下载单个文件
## 从网络下载一个文件并保存在当前目录
wget https://download.redis.io/releases/redis-6.2.7.tar.gz
## 使用wget-o下载并以不同的文件名保存
wget -O redis627.tar.gz https://download.redis.io/releases/redis-6.2.7.tar.gz
## 使用wget -limit -rate 限速下载(执行wget时，默认会占用全部可能的带宽下载，当准备下载一个大文件，而你还需要下载其他文件时就有必要限速了)
wget --limit-rate=300K https://download.redis.io/releases/redis-6.2.7.tar.gz
# ----------------------------------
yum install -y lrzsz
2.需要c语言环境
yum -y install gcc gcc-c++ kernel-devel
#测试gcc版本
[root@iZ2zeizrxxn52st7yye6vuZ ~]# gcc --version
gcc (GCC) 8.5.0 20210514 (Red Hat 8.5.0-4)
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.3.解压及启动
[root@iZ2zeizrxxn52st7yye6vuZ opt]# tar -xzvf redis-6.2.7.tar.gz [root@iZ2zeizrxxn52st7yye6vuZ bin]# ./redis-server 前台启动，命令行窗口不能关闭，否则服务器停止
后台启动
拷贝一份redis.conf 到其他目录，如/myredis
[root@iZ2zeizrxxn52st7yye6vuZ /]# cp /opt/redis-6.2.7/redis.conf /myredis/后台启动设置daemonize no 改为 yes 后台启动
[root@iZ2zeizrxxn52st7yye6vuZ bin]# ./redis-server /myredis/redis.conf用户端访问链接
[root@iZ2zeizrxxn52st7yye6vuZ bin]# ./redis-cli ##（-p 指定端口）常用
-
端口号：6379
-
默认16个数据库，类似数组下标从0开始，初始默认使用0号库
-
使用命令 select <dbid>来切换数据库。如: select 8
-
统一密码管理，所有库同样密码
-
dbsize查看当前数据库的key的数量
-
flushdb清空当前库
-
flushall通杀全部库
-
Redis是单线程+多路IO复用技术，多路复用是指使用一个线程来检查多个文件描述符（Socket）的就绪状态，比如调用select和poll函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回，否则阻塞直到超时。得到就绪状态后进行真正的操作可以在同一个线程里执行，也可以启动线程执行（比如使用线程池）。
二，常用五大数据类型
1、键（key）
常用命令
# 为了演示下面的key操作，暂时用一下set命令存储一些key，value
127.0.0.1:6379> set k1 lucy
OK
127.0.0.1:6379> set k2 mary
OK
127.0.0.1:6379> set k3 jack
OK
# keys *查看当前库所有key (匹配：keys *1)
127.0.0.1:6379> keys *
1) "k2"
2) "k1"
3) "k3"
# exists key判断某个key是否存在
127.0.0.1:6379> exists k1
(integer) 1
# type key 查看你的key是什么类型
127.0.0.1:6379> type k1
string
# del key 删除指定的key数据
127.0.0.1:6379> del k3
(integer) 1
# unlink key 根据value选择非阻塞删除
127.0.0.1:6379> unlink k4
(integer) 1
# 仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作（也就是执行命令告诉用户删除用户，实际上是后台异步删除）。
# expire key 10 10秒钟：为给定的key设置过期时间
127.0.0.1:6379> expire k1 10
(integer) 1
127.0.0.1:6379> keys *
1) "k2"
2) "k1"
# ttl key 查看还有多少秒过期，-1表示永不过期，-2表示已过期
127.0.0.1:6379> ttl k1
(integer) -2 # 已过期
127.0.0.1:6379> ttl k2
(integer) -1 # 永不过期
# select命令切换数据库
127.0.0.1:6379> select 2
OK
# dbsize查看当前数据库的key的数量
127.0.0.1:6379> dbsize
(integer) 1
# flushdb清空当前库(慎用-删除数据库数据)
# flushall通杀全部库（慎用—删除所有数据库数据）
2.Redis字符串(String)
概述
-
String是Redis最基本的类型，你可以理解成与Memcached（本质上就是一个内存key-value缓存）一模一样的类型，一个key对应一个value。
-
String类型是二进制（只要内容能用字符串表示）安全的。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象。
-
String类型是Redis最基本的数据类型，一个Redis中字符串value最多可以是512M
常用命令
# set <key> <value> 添加键值对
127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> set k2 v2
OK
127.0.0.1:6379> keys *
1) "k2"
2) "k1"
# 如果设置的key之前就有，会替换到之前的key的值
127.0.0.1:6379> set k1 v111
OK
127.0.0.1:6379> get k1
"v111"
# -----------------------------------------------------------------------
# get <key> 查询对应键值
127.0.0.1:6379> get k1
"v1"
127.0.0.1:6379> get k2
"v2"
# -----------------------------------------------------------------------
# append <key><value>将给定的<value> 追加到原值的末尾
127.0.0.1:6379> append k1 renzhe
(integer) 11
127.0.0.1:6379> get k1
"v111renzhe"
# -----------------------------------------------------------------------
# strlen <key>获得值的长度
127.0.0.1:6379> strlen k1
(integer) 11
# -----------------------------------------------------------------------
#setnx <key> <value>只有在 key 不存在时 设置 key 的值(也就是不能做覆盖)
127.0.0.1:6379> setnx k1 vv1
(integer) 0 # 0 表示设置失败，因为之前有k1的key
127.0.0.1:6379> get k1
"v111renzhe"
# -----------------------------------------------------------------------
# incr <key>
# 将 key 中储存的数字值增1
# 只能对数字值操作，如果为空，新增值为1
127.0.0.1:6379> set k4 500
OK
127.0.0.1:6379> incr k4
(integer) 501
127.0.0.1:6379> get k4
"501"
# -----------------------------------------------------------------------
# decr <key>
# 将 key 中储存的数字值减1
# 只能对数字值操作，如果为空，新增值为-1
127.0.0.1:6379> decr k4
(integer) 500
127.0.0.1:6379> get k4
"500"
# -----------------------------------------------------------------------
# incrby / decrby <key><步长>将 key 中储存的数字值增减。自定义步长。
127.0.0.1:6379> incrby k4 20
(integer) 520
127.0.0.1:6379> get k4
"520"
127.0.0.1:6379> decrby k4 80
(integer) 440
127.0.0.1:6379> get k4
"440"
# -----------------------------------------------------------------------
# incr key，对存储在指定key的数值进行原子的操作，所谓原子操作是指不会被线程调度机制打断的操作；这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。
#（1）在单线程中， 能够在单条指令中完成的操作都可以认为是"原子操作"，因为中断只能发生于指令之间。
#（2）在多线程中，不能被其它进程（线程）打断的操作就叫原子操作。
# Redis单命令的原子性主要得益于Redis的单线程。
# -----------------------------------------------------------------------
# mset <key1><value1><key2><value2> ..... 同时设置一个或多个 key-value对
127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3
OK
127.0.0.1:6379> keys *
1) "k2"
2) "k1"
3) "k3"
# -----------------------------------------------------------------------
# mget <key1><key2><key3> ..... 同时获取一个或多个 value
127.0.0.1:6379> mget k1 k3
1) "v1"
2) "v3"
# -----------------------------------------------------------------------
# msetnx <key1><value1><key2><value2> ..... 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在（有一个存在都不行）。
127.0.0.1:6379> msetnx k1 v11 k2 v22
(integer) 0
127.0.0.1:6379> msetnx k1 v11 k222 v222
(integer) 0
# -----------------------------------------------------------------------
# getrange <key> <起始位置> <结束位置> 获得值的范围，类似java中的substring，前包，后包(索引从0开始)。
127.0.0.1:6379> set name lucymary
OK
127.0.0.1:6379> getrange name 0 3
"lucy"
# -----------------------------------------------------------------------
# setrange <key><起始位置><value> 用 <value> 覆写<key>所储存的字符串值，从<起始位置>开始(索引从0开始)。
127.0.0.1:6379> setrange name 3 xxx
(integer) 8
127.0.0.1:6379> get name
"lucxxxry"
# -----------------------------------------------------------------------
# setex <key><过期时间><value> 设置键值的同时，设置过期时间，单位秒
127.0.0.1:6379> setex age 10 33
OK
127.0.0.1:6379> ttl age
(integer) 7
127.0.0.1:6379> get age
"33"
127.0.0.1:6379> get age
"33"
127.0.0.1:6379> ttl age
(integer) -2
127.0.0.1:6379> get age
(nil)
# -----------------------------------------------------------------------
# getset <key><value> 以新换旧，设置了新值同时获得旧值。
127.0.0.1:6379> getset name xxx
"lucxxxry"
127.0.0.1:6379> get name
"xxx"
结构
-
String的数据结构为简单动态字符串(Simple Dynamic String,缩写SDS)。是可以修改的字符串，内部结构实现上类似于Java的ArrayList，采用预分配冗余空间的方式来减少内存的频繁分配。
-
-
如图中所示，内部为当前字符串实际分配的空间capacity一般要高于实际字符串长度len。当字符串长度小于1M时，扩容都是加倍现有的空间，如果超过1M，扩容时一次只会多扩1M的空间。需要注意的是字符串最大长度为512M。
3.Redis列表(List)
概述
-
单键多值
-
Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。
-
它的底层实际是个双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差。
常用命令
# lpush/rpush <key><value1><value2><value3> .... 从左边/右边插入一个或多个值。可以重复 127.0.0.1:6379> flushdb OK 127.0.0.1:6379> lpush k1 v1 v2 v3 (integer) 3 127.0.0.1:6379> lrange k1 0 -1 # # 特点：结果显示最后加进去的是在最前面 1) "v3" 2) "v2" 3) "v1" # ----------------------------------------------------------------------------- 127.0.0.1:6379> rpush k2 v1 v2 v3 v4 v5 (integer) 5 127.0.0.1:6379> lrange k2 0 -1 1) "v1" 2) "v2" 3) "v3" 4) "v4" 5) "v5" # lpop/rpop <key>从左边/右边吐出一个值。值在键在，值无键亡。 127.0.0.1:6379> lpop k1 "v3" 127.0.0.1:6379> lpop k1 "v2" 127.0.0.1:6379> lpop k1 "v1" # rpoplpush <key1><key2>从<key1>列表右边吐出一个值，插到<key2>列表左边。 127.0.0.1:6379> flushdb OK 127.0.0.1:6379> lpush k1 v1 v2 v3 (integer) 3 127.0.0.1:6379> rpush k2 v11 v22 v33 (integer) 3 127.0.0.1:6379> rpoplpush k1 k2 "v1" 127.0.0.1:6379> lrange k2 0 -1 1) "v1" 2) "v11" 3) "v22" 4) "v33" # lrange <key><start><stop>按照索引下标获得元素(从左到右) # lrange mylist 0 -1 0左边第一个，-1右边第一个，（0-1表示获取所有） # lindex <key><index>按照索引下标获得元素(从左到右) 127.0.0.1:6379> lrange k2 0 -1 1) "v1" 2) "v11" 3) "v22" 4) "v33" 127.0.0.1:6379> lindex k2 0 "v1" 127.0.0.1:6379> lindex k2 1 "v11" # llen <key>获得列表长度 127.0.0.1:6379> llen k2 (integer) 4 # linsert <key> before <value><newvalue>在<value>的后面插入<newvalue>插入值 127.0.0.1:6379> lrange k2 0 -1 1) "v1" 2) "v11" 3) "v22" 4) "v33" 127.0.0.1:6379> linsert k2 after "v11" "v11-new" (integer) 5 127.0.0.1:6379> lrange k2 0 -1 1) "v1" 2) "v11" 3) "v11-new" 4) "v22" 5) "v33" # lrem <key><n><value>从左边删除n个value(从左到右) 127.0.0.1:6379> linsert k2 before "v11" "v11-new" (integer) 6 127.0.0.1:6379> lrange k2 0 -1 1) "v1" 2) "v11-new" 3) "v11" 4) "v11-new" 5) "v22" 6) "v33" 127.0.0.1:6379> lrem k2 2 "v11-new" (integer) 2 127.0.0.1:6379> lrange k2 0 -1 1) "v1" 2) "v11" 3) "v22" 4) "v33" # lset<key><index><value>将列表key下标为index的值替换成value 127.0.0.1:6379> lset k2 1 renzhe OK 127.0.0.1:6379> lrange k2 0 -1 1) "v1" 2) "renzhe" 3) "v22" 4) "v33"结构
-
List的数据结构为快速链表quickList。
-
首先在列表元素较少的情况下会使用一块连续的内存存储，这个结构是ziplist，也即是压缩列表。
-
它将所有的元素紧挨着一起存储，分配的是一块连续的内存。
-
当数据量比较多的时候才会改成quicklist。
-
因为普通的链表需要的附加指针空间太大，会比较浪费空间。比如这个列表里存的只是int类型的数据，结构上还需要两个额外的指针prev和next。
-
2.4、Redis集合(Set)
2.4.1、介绍
-
Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。
-
Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)。
-
一个算法，随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变。
2.4.2、常用命令
# sadd <key><value1><value2> ..... 将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略 127.0.0.1:6379> sadd k1 v1 v2 v3 (integer) 3 # smembers <key>取出该集合的所有值。 127.0.0.1:6379> smembers k1 1) "v3" 2) "v1" 3) "v2" # sismember <key><value>判断集合<key>是否为含有该<value>值，有1，没有0 127.0.0.1:6379> sismember k1 v2 (integer) 1 127.0.0.1:6379> sismember k1 v22 (integer) 0 # scard<key>返回该集合的元素个数。 127.0.0.1:6379> scard k1 (integer) 3 # srem <key><value1><value2> .... 删除集合中的某个元素。 127.0.0.1:6379> srem k1 v1 (integer) 1 127.0.0.1:6379> smembers k1 1) "v3" 2) "v2" # spop <key>随机从该集合中吐出一个值。 127.0.0.1:6379> sadd k2 v1 v2 v3 v4 (integer) 4 127.0.0.1:6379> spop k2 "v1" 127.0.0.1:6379> spop k2 "v4" 127.0.0.1:6379> spop k2 "v3" 127.0.0.1:6379> spop k2 "v2" 127.0.0.1:6379> spop k2 (nil) # srandmember <key><n>随机从该集合中取出n个值。不会从集合中删除 。 127.0.0.1:6379> sadd k2 v1 v2 v3 v4 v5 (integer) 5 127.0.0.1:6379> srandmember k2 2 1) "v5" 2) "v4" 127.0.0.1:6379> srandmember k2 2 1) "v3" 2) "v4" 127.0.0.1:6379> srandmember k2 2 1) "v2" 2) "v4" # smove <source><destination>value把集合中一个值从一个集合移动到另一个集合 127.0.0.1:6379> sadd k1 v1 v2 v3 v4 v5 (integer) 5 127.0.0.1:6379> sadd k2 v11 v22 v33 v44 v55 (integer) 5 127.0.0.1:6379> smove k1 k2 v3 (integer) 1 127.0.0.1:6379> smembers k2 1) "v22" 2) "v44" 3) "v33" 4) "v3" 5) "v11" 6) "v55" # sinter <key1><key2>返回两个集合的交集元素。 127.0.0.1:6379> sadd k1 v3 (integer) 1 127.0.0.1:6379> sinter k1 k2 1) "v3" # sunion <key1><key2>返回两个集合的并集元素。 127.0.0.1:6379> sunion k1 k2 1) "v5" 2) "v3" 3) "v1" 4) "v4" 5) "v2" 6) "v44" 7) "v11" 8) "v55" 9) "v22" 10) "v33" # sdiff <key1><key2>返回两个集合的差集元素(key1中的，不包含key2中的) 127.0.0.1:6379> sdiff k1 k2 1) "v1" 2) "v5" 3) "v2" 4) "v4"
2.4.3、数据结构
-
Set数据结构是dict字典，字典是用哈希表实现的。
-
Java中HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。Redis的set结构也是一样，它的内部也使用hash结构，所有的value都指向同一个内部值。
2.5、 Redis哈希(Hash)
2.5.1、介绍
-
Redis hash 是一个键值对集合。
-
Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。
-
类似Java里面的Map<String,Object>
-
用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息，如果用普通的key/value结构来存储
-
主要有以下2种存储方式：
2.5.2、常用命令
# hset <key><field><value>给<key>集合中的 <field>键赋值<value> 127.0.0.1:6379> flushdb OK 127.0.0.1:6379> hset user:101 id 1 (integer) 1 127.0.0.1:6379> hset user:101 name zhangsan (integer) 1 # hget <key1><field>从<key1>集合<field>取出 value 127.0.0.1:6379> hget user:101 name "zhangsan" # hmset <key1><field1><value1><field2><value2>... 批量设置hash的值 127.0.0.1:6379> hmset user:1002 id 1 name renzhe age 30 OK 127.0.0.1:6379> hget user:1002 name "renzhe" # hexists<key1><field>查看哈希表 key 中，给定域 field 是否存在。 127.0.0.1:6379> hexists user:1002 id (integer) 1 127.0.0.1:6379> hexists user:1002 idd (integer) 0 # hkeys <key>列出该hash集合的所有field 127.0.0.1:6379> hkeys user:1002 1) "id" 2) "name" 3) "age" # hvals <key>列出该hash集合的所有value 127.0.0.1:6379> hvals user:1002 1) "1" 2) "renzhe" 3) "30" # hincrby <key><field><increment>为哈希表 key 中的域 field 的值加上增量 1 -1 127.0.0.1:6379> hincrby user:1002 age 2 (integer) 32 # hsetnx <key><field><value>将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在 127.0.0.1:6379> hsetnx user:1002 age 333 (integer) 0 # 有field不能添加 127.0.0.1:6379> hsetnx user:1002 gender '1' (integer) 1 # 没有field可以添加 127.0.0.1:6379> hkeys user:1002 1) "id" 2) "name" 3) "age" 4) "gender"
2.5.3、数据结构
Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable。
2.6、Redis有序集合Zset
2.6.1、介绍
-
Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。
-
不同之处是有序集合的每个成员都关联了一个评分（**score）**,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的，但是评分可以是重复了 。
-
因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。
-
访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。
2.6.2、常用命令
# zadd <key><score1><value1><score2><value2>… # 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。 127.0.0.1:6379> zadd topn 200 java 300 c++ 320 mysql 430 php # 计划计算评分 (integer) 4 # zrange <key><start><stop> [WITHSCORES] 返回有序集 key 中，下标在<start><stop>之间的元素带WITHSCORES，可以让分数一起和值返回到结果集。 127.0.0.1:6379> zrange topn 0 -1 # 默认从小到大排序（根据score） 1) "java" 2) "c++" 3) "mysql" 4) "php" # ------------------- 127.0.0.1:6379> zrange topn 0 -1 withscores 1) "python" 2) "10" 3) "java" 4) "200" 5) "c++" 6) "300" 7) "mysql" 8) "320" 9) "php" 10) "430" # zrangebyscore key minmax [withscores] [limit offset count] 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。 127.0.0.1:6379> zrangebyscore topn 300 500 1) "c++" 2) "mysql" 3) "php" 127.0.0.1:6379> zrangebyscore topn 300 500 withscores 1) "c++" 2) "300" 3) "mysql" 4) "320" 5) "php" 6) "430" # zrevrangebyscore key maxmin [withscores] [limit offset count] 同上，改为从大到小排列。 127.0.0.1:6379> zrevrangebyscore topn 500 200 1) "php" 2) "mysql" 3) "c++" 4) "java" # zincrby <key><increment><value> 为元素的score加上增量 127.0.0.1:6379> zincrby topn 50 java "250" # zrem <key><value>删除该集合下，指定值的元素 127.0.0.1:6379> zrem topn php (integer) 1 # zcount <key><min><max>统计该集合，分数区间内的元素个数 127.0.0.1:6379> zcount topn 200 300 (integer) 2 # zrank <key><value>返回该值在集合中的排名，从0开始。 127.0.0.1:6379> zrange topn 0 -1 withscores 1) "python" 2) "10" 3) "java" 4) "250" 5) "c++" 6) "300" 7) "mysql" 8) "320" 127.0.0.1:6379> zrank topn java (integer) 1 # 案例：如何利用zset实现一个文章访问量的排行榜？ 127.0.0.1:6379> zadd topnum 1000 v1 1233 v2 234 v3 98 v4 24234 v5 (integer) 5 127.0.0.1:6379> zrevrange topnum 0 -1 withscores 1) "v5" 2) "24234" 3) "v2" 4) "1233" 5) "v1" 6) "1000" 7) "v3" 8) "234" 9) "v4" 10) "98"
2.6.3、数据结构
-
SortedSet(zset)是Redis提供的一个非常特别的数据结构，一方面它等价于Java的数据结构Map<String, Double>，可以给每一个元素value赋予一个权重score，另一方面它又类似于TreeSet，内部的元素会按照权重score进行排序，可以得到每个元素的名次，还可以通过score的范围来获取元素的列表。
-
zset底层使用了两个数据结构
-
hash，hash的作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值。
-
跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表。
-
三、Redis6配置文件详解
-
自定义目录：/myredis/redis.conf
3.1、Units 单位
配置大小单位,开头定义了一些基本的度量单位，只支持bytes，不支持bit，大小写不敏感。
# ./redis-server /path/to/redis.conf # Note on units: when memory size is needed, it is possible to specify # it in the usual form of 1k 5GB 4M and so forth: # # 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.
3.2、INCLUDES包含
类似jsp中的include，多实例的情况可以把公用的配置文件提取出来
22 # Include one or more other config files here. This is useful if you 23 # have a standard template that goes to all Redis servers but also need 24 # to customize a few per-server settings. Include files can include 25 # other files, so use this wisely. 26 # 27 # Note that option "include" won't be rewritten by command "CONFIG REWRITE" 28 # from admin or Redis Sentinel. Since Redis always uses the last processed 29 # line as value of a configuration directive, you'd better put includes 30 # at the beginning of this file to avoid overwriting config change at runtime. 31 # 32 # If instead you are interested in using includes to override configuration 33 # options, it is better to use include as the last line. 34 # 35 # include /path/to/local.conf 36 # include /path/to/other.conf
3.3、网络相关配置
3.3.1、bind
72 # IF YOU ARE SURE YOU WANT YOUR INSTANCE TO LISTEN TO ALL THE INTERFACES 73 # JUST COMMENT OUT THE FOLLOWING LINE. 74 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 75 bind 127.0.0.1 -::1
-
默认情况bind=127.0.0.1只能接受本机的访问请求
-
不写的情况下，无限制接受任何ip地址的访问
-
生产环境肯定要写你应用服务器的地址；服务器是需要远程访问的，所以需要将其注释掉
-
如果开启了protected-mode，那么在没有设定bind ip且没有设密码的情况下，Redis只允许接受本机的响应
3.3.2、protected-mode
90 # By default protected mode is enabled. You should disable it only if 91 # you are sure you want clients from other hosts to connect to Redis 92 # even if no authentication is configured, nor a specific set of interfaces 93 # are explicitly listed using the "bind" directive. 94 protected-mode yes
-
yes表示只能本机访问，no表示支持远程访问
3.3.3、port
96 # Accept connections on the specified port, default is 6379 (IANA #815344). 97 # If port 0 is specified Redis will not listen on a TCP socket. 98 port 6379
3.3.4、tcp-backlog
100 # TCP listen() backlog. 101 # 102 # In high requests-per-second environments you need a high backlog in order 103 # to avoid slow clients connection issues. Note that the Linux kernel 104 # will silently truncate it to the value of /proc/sys/net/core/somaxconn so 105 # make sure to raise both the value of somaxconn and tcp_max_syn_backlog 106 # in order to get the desired effect. 107 tcp-backlog 511
-
设置tcp的backlog，backlog其实是一个连接队列，backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列。
-
在高并发环境下你需要一个高backlog值来避免慢客户端连接问题。
-
注意Linux内核会将这个值减小到/proc/sys/net/core/somaxconn的值（128），所以需要确认增大/proc/sys/net/core/somaxconn和/proc/sys/net/ipv4/tcp_max_syn_backlog（128）两个值来达到想要的效果
3.3.5、timeout
一个空闲的客户端维持多少秒会关闭，0表示关闭该功能。即永不关闭。
118 # Close the connection after a client is idle for N seconds (0 to disable) 119 timeout 0
3.3.6、tcp-keepalive
-
对访问客户端的一种心跳检测，每隔n秒检测一次。
-
单位为秒，如果设置为0，则不会进行Keepalive检测，建议设置成60
121 # TCP keepalive. 122 # 123 # If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence 124 # of communication. This is useful for two reasons: 125 # 126 # 1) Detect dead peers. 127 # 2) Force network equipment in the middle to consider the connection to be 128 # alive. 129 # 130 # On Linux, the specified value (in seconds) is the period used to send ACKs. 131 # Note that to close the connection the double of the time is needed. 132 # On other kernels the period depends on the kernel configuration. 133 # 134 # A reasonable value for this option is 300 seconds, which is the new 135 # Redis default starting with Redis 3.2.1. 136 tcp-keepalive 300
3.4、GENERAL通用
3.4.1、daemonize
-
是否为后台进程，设置为yes（守护进程，后台启动）
254 ################################# GENERAL ##################################### 255 256 # By default Redis does not run as a daemon. Use 'yes' if you need it. 257 # Note that Redis will write a pid file in /var/run/redis.pid when daemonized. 258 # When Redis is supervised by upstart or systemd, this parameter has no impact. 259 daemonize yes
3.4.2、pidfile
279 # If a pid file is specified, Redis writes it where specified at startup 280 # and removes it at exit. 281 # 282 # When the server runs non daemonized, no pid file is created if none is 283 # specified in the configuration. When the server is daemonized, the pid file 284 # is used even if not specified, defaulting to "/var/run/redis.pid". 285 # 286 # Creating a pid file is best effort: if Redis is not able to create it 287 # nothing bad happens, the server will start and run normally. 288 # 289 # Note that on modern Linux systems "/run/redis.pid" is more conforming 290 # and should be used instead. 291 pidfile /var/run/redis_6379.pid
-
存放pid文件的位置，每个实例会产生一个不同的pid文件
3.4.3、loglevel
-
指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为notice
-
四个级别根据使用阶段来选择，生产环境选择notice 或者warning
293 # Specify the server verbosity level. 294 # This can be one of: 295 # debug (a lot of information, useful for development/testing) 296 # verbose (many rarely useful info, but not a mess like the debug level) 297 # notice (moderately verbose, what you want in production probably) 298 # warning (only very important / critical messages are logged) 299 loglevel notice
3.4.4、logfile
-
日志文件名称
301 # Specify the log file name. Also the empty string can be used to force 302 # Redis to log on the standard output. Note that if you use standard 303 # output for logging but daemonize, logs will be sent to /dev/null 304 logfile ""
3.4.5、databases 16
-
设定库的数量 默认16，默认数据库为0，可以使用SELECT 数据库ID 命令在连接上指定数据库id
326 # Set the number of databases. The default database is DB 0, you can select 327 # a different one on a per-connection basis using SELECT <dbid> where 328 # dbid is a number between 0 and 'databases'-1 329 databases 16
3.5、SECURITY安全
3.5.1、设置密码
894 # IMPORTANT NOTE: starting with Redis 6 "requirepass" is just a compatibility 895 # layer on top of the new ACL system. The option effect will be just setting 896 # the password for the default user. Clients will still authenticate using 897 # AUTH <password> as usually, or more explicitly with AUTH default <password> 898 # if they follow the new protocol: both will work. 899 # 900 # The requirepass is not compatable with aclfile option and the ACL LOAD 901 # command, these will cause requirepass to be ignored. 902 # 903 # requirepass foobared
3.6、LIMITS限制
3.6.1、maxclients
-
设置redis同时可以与多少个客户端进行连接。
-
默认情况下为10000个客户端。
-
如果达到了此限制，redis则会拒绝新的连接请求，并且向这些连接请求方发出“max number of clients reached”以作回应。
962 # IMPORTANT: When Redis Cluster is used, the max number of connections is also 963 # shared with the cluster bus: every node in the cluster will use two 964 # connections, one incoming and another outgoing. It is important to size the 965 # limit accordingly in case of very large clusters. 966 # 967 # maxclients 10000
3.6.2、maxmemory(特别重要)
990 # In short... if you have replicas attached it is suggested that you set a lower 991 # limit for maxmemory so that there is some free RAM on the system for replica 992 # output buffers (but this is not needed if the policy is 'noeviction'). 993 # 994 # maxmemory <bytes>
-
建议必须设置，否则，将内存占满，造成服务器宕机
-
设置redis可以使用的内存量。一旦到达内存使用上限，redis将会试图移除内部数据，移除规则可以通过maxmemory-policy来指定。
-
如果redis无法根据移除规则来移除内存中的数据，或者设置了“不允许移除”，那么redis则会针对那些需要申请内存的指令返回错误信息，比如SET、LPUSH等。
-
但是对于无内存申请的指令，仍然会正常响应，比如GET等。如果你的redis是主redis（说明你的redis有从redis），那么在设置内存使用上限时，需要在系统中留出一些内存空间给同步队列缓存，只有在你设置的是“不移除”的情况下，才不用考虑这个因素。
3.6.3、maxmemory-policy
1014 # Note: with any of the above policies, when there are no suitable keys for 1015 # eviction, Redis will return an error on write operations that require 1016 # more memory. These are usually commands that create new keys, add data or 1017 # modify existing keys. A few examples are: SET, INCR, HSET, LPUSH, SUNIONSTORE, 1018 # SORT (due to the STORE argument), and EXEC (if the transaction includes any 1019 # command that requires memory). 1020 # 1021 # The default is: 1022 # 1023 # maxmemory-policy noeviction
-
volatile-lru：使用LRU算法移除key，只对设置了过期时间的键；（最近最少使用）
-
allkeys-lru：在所有集合key中，使用LRU算法移除key
-
volatile-random：在过期集合中移除随机的key，只对设置了过期时间的键
-
allkeys-random：在所有集合key中，移除随机的key
-
volatile-ttl：移除那些TTL值最小的key，即那些最近要过期的key
-
noeviction：不进行移除。针对写操作，只是返回错误信息
3.6.4、maxmemory-samples
1025 # LRU, LFU and minimal TTL algorithms are not precise algorithms but approximated 1026 # algorithms (in order to save memory), so you can tune it for speed or 1027 # accuracy. By default Redis will check five keys and pick the one that was 1028 # used least recently, you can change the sample size using the following 1029 # configuration directive. 1030 # 1031 # The default of 5 produces good enough results. 10 Approximates very closely 1032 # true LRU but costs more CPU. 3 is faster but not very accurate. 1033 # 1034 # maxmemory-samples 5
-
设置样本数量，LRU算法和最小TTL算法都并非是精确的算法，而是估算值，所以你可以设置样本的大小，redis默认会检查这么多个key并选择其中LRU的那个。
-
一般设置3到7的数字，数值越小样本越不准确，但性能消耗越小。
四，Redis6的发布和订阅
概述
-
Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。
-
Redis 客户端可以订阅任意数量的频道。
-
客户端可以订阅频道如下图
-
-
当给这个频道发布消息后，消息就会发送给订阅的客户端
命令实现
打开一个客户端订阅renzhe
127.0.0.1:6379> subscribe renzhe
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "renzhe"
3) (integer) 1
1) "message"
2) "renzhe"打开另一个客户端，给chenxin发布消息hello
127.0.0.1:6379> publish chenxin hello
(integer) 1 # 返回的1是订阅者数量打开第一个客户端可以看到发送的消息
127.0.0.1:6379> subscribe renzhe
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "renzhe"
3) (integer) 1
1) "message"
2) "renzhe"
3) "hello"发布的消息没有持久化，在订阅的客户端收不到hello，只能收到订阅后发布的消息
五，Redis6新数据类型
1.Bitmaps
1.概述
现代计算机用二进制（位） 作为信息的基础单位， 1个字节等于8位， 例如“abc”字符串是由3个字节组成， 但实际在计算机存储时将其用二进制表示， “abc”分别对应的ASCII码分别是97、 98、 99， 对应的二进制分别是01100001、 01100010和01100011
合理地使用操作位能够有效地提高内存使用率和开发效率。
-
Redis提供了Bitmaps这个“数据类型”可以实现对位的操作：
-
Bitmaps本身不是一种数据类型， 实际上它就是字符串（key-value） ， 但是它可以对字符串的位进行操作。
-
Bitmaps单独提供了一套命令， 所以在Redis中使用Bitmaps和使用字符串的方法不太相同。 可以把Bitmaps想象成一个以位为单位的数组， 数组的每个单元只能存储0和1， 数组的下标在Bitmaps中叫做偏移量。
-
2.命令
1.setbit
# setbit<key><offset><value>设置Bitmaps中某个偏移量的值（0或1），offset:偏移量从0开始每个独立用户是否访问过网站存放在Bitmaps中， 将访问的用户记做1， 没有访问的用户记做0， 用偏移量作为用户的id。设置键的第offset个位的值（从0算起） ， 假设现在有20个用户，userid=1， 6， 11， 15， 19的用户对网站进行了访问， 那么当前Bitmaps初始化结果如图：
注意：很多应用的用户id以一个指定数字（例如10000） 开头， 直接将用户id和Bitmaps的偏移量对应势必会造成一定的浪费， 通常的做法是每次做setbit操作时将用户id减去这个指定数字。在第一次初始化Bitmaps时， 假如偏移量非常大， 那么整个初始化过程执行会比较慢， 可能会造成Redis的阻塞。
2.getbit
# getbit<key><offset>获取Bitmaps中某个偏移量的值3.bitcount
统计字符串被设置为1的bit数。一般情况下，给定的整个字符串都会被进行计数，通过指定额外的 start 或 end 参数，可以让计数只在特定的位上进行。start 和 end 参数的设置，都可以使用负数值：比如 -1 表示最后一个位，而 -2 表示倒数第二个位，start、end 是指bit组的字节的下标数，二者皆包含。
bitcount<key>[start end] 统计字符串从start字节到end字节比特值为1的数量4.bitop
bitop是一个复合操作， 它可以做多个Bitmaps的and（交集） 、 or（并集） 、 not（非） 、 xor（异或） 操作并将结果保存在destkey中。
# bitop and(or/not/xor) <destkey> [key…]
2.Bitmaps与set对比
假设网站有1亿用户， 每天独立访问的用户有5千万， 如果每天用集合类型和Bitmaps分别存储活跃用户可以得到表
很明显， 这种情况下使用Bitmaps能节省很多的内存空间， 尤其是随着时间推移节省的内存还是非常可观的
但Bitmaps并不是万金油， 假如该网站每天的独立访问用户很少， 例如只有10万（大量的僵尸用户） ， 那么两者的对比如下表所示， 很显然， 这时候使用Bitmaps就不太合适了， 因为基本上大部分位都是0。
2.HyperLogLog
1.概述
在工作当中，我们经常会遇到与统计相关的功能需求，比如统计网站PV（PageView页面访问量）,可以使用Redis的incr、incrby轻松实现。
但像UV（UniqueVisitor，独立访客）、独立IP数、搜索记录数等需要去重和计数的问题如何解决？这种求集合中不重复元素个数的问题称为基数问题。
解决基数问题有很多种方案：
-
第一种：数据存储在MySQL表中，使用distinct count计算不重复个数
-
第二种：使用Redis提供的hash、set、bitmaps等数据结构来处理
以上的方案结果精确，但随着数据不断增加，导致占用空间越来越大，对于非常大的数据集是不切实际的。
-
那么，能否能够降低一定的精度来平衡存储空间？Redis推出了HyperLogLog，Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。
-
在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。
-
但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。
什么是基数？
-
比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数。
2.命令
pfadd
将所有元素添加到指定HyperLogLog数据结构中。如果执行命令后HLL估计的近似基数发生变化，则返回1，否则返回0。
# 格式：pfadd <key>< element> [element ...] 添加指定元素到 HyperLogLog 中
# 例子：
127.0.0.1:6379> pfadd hlll "redis"
(integer) 1
127.0.0.1:6379> pfadd hlll "mysql"
(integer) 1
127.0.0.1:6379> pfadd hlll "redis"
(integer) 0
127.0.0.1:6379> pfadd hlll "python"
(integer) 1pfcount
# 格式：pfcount<key> [key ...] 计算HLL的近似基数，可以计算多个HLL，比如用HLL存储每天的UV，计算一周的UV可以使用7天的UV合并计算即可
# 例子：
127.0.0.1:6379> pfcount hlll hll2
(integer) 4pfmerge
# 格式：pfmerge<destkey><sourcekey> [sourcekey ...] 将一个或多个HLL合并后的结果存储在另一个HLL中，比如每月活跃用户可以使用每天的活跃用户来合并计算可得
# 例子：
127.0.0.1:6379> pfmerge hll3 hlll hll2
OK
127.0.0.1:6379> pfcount hll3
(integer) 43.Geospatial
1.概述
GEO，Geographic，地理信息的缩写。该类型，就是元素的2维坐标，在地图上就是经纬度。redis基于该类型，提供了经纬度设置，查询，范围查询，距离查询，经纬度Hash等常见操作。
2.命令
geoadd
#格式：geoadd<key>< longitude><latitude><member> [longitude latitude member...] 添加地理位置（经度，纬度，名称）
#例子：
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 116.38 39.90 beijing
(integer) 3
127.0.0.1:6379> geoadd china:city 112.56 37.80 taiyuan
(integer) 1
127.0.0.1:6379> geoadd china:city 112.62 37.81 jinfengdijing
(integer) 1注意：
-
两极无法直接添加，一般会下载城市数据，直接通过 Java 程序一次性导入。
-
有效的经度从 -180 度到 180 度。有效的纬度从 -85.05112878 度到 85.05112878 度。
-
当坐标位置超出指定范围时，该命令将会返回一个错误。
-
已经添加的数据，是无法再次往里面添加的。
geopos
# 格式：geopos <key><member> [member...] 获得指定地区的坐标值
# 例子：
127.0.0.1:6379> geopos china:city jinfengdijing
1) 1) "112.61999934911727905"
2) "37.81000082918030358"
127.0.0.1:6379> geopos china:city taiyuan
1) 1) "112.55999833345413208"
2) "37.79999881948555895"geodist
# 格式：geodist<key><member1><member2> [m|km|ft|mi ] 获取两个位置之间的直线距离
# 例子：
127.0.0.1:6379> geodist china:city taiyuanqianfeng jinfengdijing km
"5.3890"
127.0.0.1:6379> geodist china:city taiyuanqianfeng jinfengdijing
"5388.9730"注意/单位：
-
m 表示单位为米[默认值]
-
km 表示单位为千米
-
mi 表示单位为英里
-
ft 表示单位为英尺
georadius
# 格式：georadius<key>< longitude><latitude>radius m|km|ft|mi 以给定的经纬度为中心，找出某一半径内的元素
127.0.0.1:6379> georadius china:city 112.620583 37.810131 10 km
1) "jinfengdijing"
2) "taiyuan"六，Jedis操作Redis6
Linux系统下需要操作
-
禁用Linux的防火墙：Linux(CentOS7)里执行命令
-
redis.conf中注释掉bind 127.0.0.1
-
protected-mode no
1.为什么使用jedis
Jedis 是一个 Java 客户端，用于与 Redis 数据库进行交互。在 Redis 6 中，引入了一些新的功能和改进，使用 Jedis 操作 Redis 6 可以享受到以下好处：
-
支持新的数据结构：Redis 6 引入了新的数据结构，如布隆过滤器（Bloom Filter）、懒惰释放（Lazy Free）等。使用 Jedis 可以方便地操作这些新的数据结构，从而充分利用 Redis 6 的功能。
-
支持新的命令：Redis 6 引入了一些新的命令，如
ACL命令用于访问控制列表、XADD命令用于操作 Stream 数据结构等。使用 Jedis 可以直接调用这些新的命令，而不需要等待 Jedis 更新版本。 -
支持新的特性：Redis 6 引入了一些新的特性，如客户端缓存（Client-side Caching）、多线程 I/O（MTIO）等。使用 Jedis 可以充分利用这些新特性，提升应用程序的性能和效率。
-
兼容性和稳定性：Jedis 是 Redis 的官方 Java 客户端，与 Redis 数据库的版本保持同步更新。因此，使用 Jedis 可以确保与 Redis 6 的兼容性和稳定性。
总而言之，使用 Jedis 操作 Redis 6 可以方便地使用新的功能、命令和特性，同时保持与 Redis 数据库的兼容性和稳定性。
2.添加依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.9.0</version>
</dependency>
</dependencies>3.测试程序
import redis.clients.jedis.Jedis;
public class Tetxxx {
public static void main(String[] args) {
try {
Jedis jedis = new Jedis("123.56.18.35",6379);
jedis.auth("123456");
String pong = jedis.ping();
System.out.println("连接状态：" + pong);
jedis.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
// ---------- 如果能够看到如下的内容输出表示我们通过Java程序已经连接上了服务器上的Redis ---------------
连接状态：PONG七，Redis6与Spring Boot整合
1.添加依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- SpringBoot 和 Redis的整合启动场景 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- spring2.X集成redis所需common-pool2-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>2.配置文件
#Redis服务器地址
spring.redis.host=123.56.18.35
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码
spring.redis.password=123456
#Redis数据库索引（默认为0）
spring.redis.database= 0
#连接超时时间（毫秒）
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=03.添加配置类 （固定）
package com.springboot.redis.springboot_redis.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
template.setConnectionFactory(factory);
//key序列化方式
template.setKeySerializer(redisSerializer);
//value序列化
template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
template.setHashValueSerializer(jackson2JsonRedisSerializer);
return template;
}
@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//解决查询缓存转换异常的问题
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置序列化（解决乱码的问题）,过期时间600秒
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofSeconds(600))
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
.disableCachingNullValues();
RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
.cacheDefaults(config)
.build();
return cacheManager;
}
}4.创建示例控制器
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@Slf4j
public class RedisTestController {
@Autowired
private RedisTemplate redisTemplate;
@GetMapping("/redistest")
public String testRedis() {
//设置值到redis
redisTemplate.opsForValue().set("name", "lucy");
//从redis获取值
String name = (String) redisTemplate.opsForValue().get("name");
log.info("Redis中的值{}",name);
return name;
}
}八，Redis-事务-锁机制-秒杀
1.事务简述
-
Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
-
Redis事务的主要作用就是串联多个命令防止别的命令插队。
2.事务操作Multi、Exec、discard
1.简述
-
从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。
-
组队的过程中可以通过discard来放弃组队。
例子：
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v33
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) OK
3) OK
# 组队成功，批量提交成功2.出错时
- 组队中某个命令出现了报告错误，执行时整个的所有队列都会被取消。
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set m1 v1
QUEUED
127.0.0.1:6379(TX)> set m2 v2
QUEUED
127.0.0.1:6379(TX)> set m3
(error) ERR wrong number of arguments for 'set' command
127.0.0.1:6379(TX)> set m4 v4
QUEUED
127.0.0.1:6379(TX)> exec
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get m1
(nil)
# 组队阶段报错，提交失败- 如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚。
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> set m1 v1
QUEUED
127.0.0.1:6379(TX)> set m2 v2
QUEUED
127.0.0.1:6379(TX)> incr m2
QUEUED
127.0.0.1:6379(TX)> exec
1) OK
2) OK
3) (error) ERR value is not an integer or out of range
127.0.0.1:6379> get m1
"v1"
127.0.0.1:6379> get m2
"v2"
# 组队成功，提交有成功有失败情况3.事务冲突
1.悲观锁
悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。
- 悲观锁假设在整个数据访问过程中，会发生并发冲突，因此在访问数据之前会先对数据进行加锁，确保其他线程无法同时访问。
- 悲观锁常见的实现方式是使用数据库的行级锁或表级锁，或者使用 synchronized 关键字、ReentrantLock 类等锁机制。
- 悲观锁会导致其他线程在访问被锁定资源时出现阻塞，从而降低了并发性能。
悲观锁适用于并发冲突的概率较高的场景，可以保证数据的一致性和安全性，但并发性能较差。
2.乐观锁
乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的。
- 乐观锁假设在整个数据访问过程中，不会发生并发冲突，因此在访问数据之前不会加锁，而是在更新数据时进行冲突检测。
- 乐观锁常见的实现方式是使用版本号或时间戳等机制，在更新数据时比较版本号或时间戳，如果发现冲突，则放弃当前操作。
- 乐观锁不会导致其他线程阻塞，因此并发性能较高，但需要处理冲突的情况。
乐观锁适用于并发冲突的概率较低的场景，可以提高并发性能，但需要处理冲突的情况。
4.事务特性
-
单独的隔离操作
事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
-
没有隔离级别的概念
队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行
-
不保证原子性
事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚。即，如果在组队阶段有一个命令失败了，那么后面的都不会成功。但是组队中没有失败，后面执行中有一个失败那么其他正确的还可以继续执行，不会回滚。
九，Redis6持久化之RDB
1.概述
两种持久化方式：RDB (Redis Database)，AOF（Append Only File）
RDB（Redis数据库）：RDB持久性以指定的时间间隔执行数据集的时间点快照。
AOF（Append Only File）：AOF持久性记录服务器接收到的每个写入操作，这些操作将在服务器启动时再次加载，从而重建原始数据集。命令使用与Redis协议本身相同的格式记录，仅以附加方式记录。当日志变得太大时，Redis可以在后台重写日志。
RDB用来做数据备份的时候，使用场景就是做恢复。而AOF是将所有的写入操作都拼接到了文件的末尾，使用场景是保证数据尽可能的最新。
2.RDB（Redis Database）
1.概述
在指定的时间间隔内（每隔多久）将内存中的数据集快照写入磁盘， 也就是数据集的快照（Snapshot），它恢复时是将快照文件直接读到内存里。
2.如何执行
Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到 一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。 整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能 如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失（因为最后一个key加入以后，要重新计算持久化时间，但是当持久化时间还没有到服务器就挂了，此时就会把最后一次的数据丢失）。
fork
-
Fork的作用是复制一个与当前进程一样的进程。新进程的所有数据（变量、环境变量、程序计数器等） 数值都和原进程一致，但是是一个全新的进程，并作为原进程的子进程。
-
在Linux程序中，fork()会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，Linux中引入了“写时复制技术（先将数据写入到 一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件）”。
-
一般情况父进程和子进程会共用同一段物理内存，只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。
在redis.conf中配置文件名称，默认为dump.rdb
432 # The filename where to dump the DB
433 dbfilename dump.rdbrdb文件配置位置可以修改
455 # Note that you must specify a directory here, not a file name.
456 dir ./3.触发RDB快照
配置文件中默认的快照配置
376 # Unless specified otherwise, by default Redis will save the DB:
377 # * After 3600 seconds (an hour) if at least 1 key changed（3600秒（一小时）后，如果至少更换了一把钥匙）
378 # * After 300 seconds (5 minutes) if at least 100 keys changed（300秒（5分钟）后，如果至少更换了100把钥匙）
379 # * After 60 seconds if at least 10000 keys changed（60秒后，如果至少更改了10000个钥匙）
380 #
381 # You can set these explicitly by uncommenting the three following lines.（您可以通过取消注释以下三行来明确设置这些值。）
382 #
383 save 3600 1
384 save 300 100
385 save 60 10000命令save VS bgsave
-
save ：save时只管保存，其它不管，全部阻塞。手动保存。不建议。
-
bgsave：Redis会在后台异步进行快照操作， 快照同时还可以响应客户端请求。
可以通过lastsave 命令获取最后一次成功执行快照的时间
flushall命令
执行flushall命令，也会产生dump.rdb文件，但里面是空的，无意义
save
-
格式：save 秒钟写操作次数
-
RDB是整个内存的压缩过的Snapshot，RDB的数据结构，可以配置复合的快照触发条件，默认是3600 秒一个key发生了变化，或5分钟内100 key发生了变化，或60秒内10000key发生了变化做持久化操作。
-
禁用，不设置save指令，或者给save传入空字符串
364 # Save the DB to disk.
365 #
366 # save <seconds> <changes>
367 #
368 # Redis will save the DB if both the given number of seconds and the given
369 # number of write operations against the DB occurred.
370 #
371 # Snapshotting can be completely disabled with a single empty string argument
372 # as in following example:
373 #
374 # save ""
375 #
376 # Unless specified otherwise, by default Redis will save the DB:
377 # * After 3600 seconds (an hour) if at least 1 key changed
378 # * After 300 seconds (5 minutes) if at least 100 keys changed
379 # * After 60 seconds if at least 10000 keys changed
380 #
381 # You can set these explicitly by uncommenting the three following lines.
382 #
383 save 3600 1 # an hour至少有1个key发生变化做持久化
384 save 300 100 # 5 minutes至少有100个key发生变化做持久化
385 save 60 10000 设置之后需要重启redis
stop-writes-on-bgsave-error
396 # However if you have setup your proper monitoring of the Redis server
397 # and persistence, you may want to disable this feature so that Redis will
398 # continue to work as usual even if there are problems with disk,
399 # permissions, and so forth.
400 stop-writes-on-bgsave-error yes
# 译文：如果您已经设置了对Redis服务器和持久性的正确监视，您可能希望禁用此功能，以便即使磁盘、权限等出现问题，Redis也能继续正常工作。当Redis无法写入磁盘的话，直接关掉Redis的写操作。推荐yes.
rdbcompression 压缩文件
402 # Compress string objects using LZF when dump .rdb databases?
403 # By default compression is enabled as it's almost always a win.
404 # If you want to save some CPU in the saving child set it to 'no' but
405 # the dataset will likely be bigger if you have compressible values or keys.
406 rdbcompression yes-
对于存储到磁盘中的快照，可以设置是否进行压缩存储。如果是的话，redis会采用LZF算法进行压缩。
-
如果你不想消耗CPU来进行压缩的话，可以设置为关闭此功能。推荐yes.
rdbchecksum 检查完整性
413 # RDB files created with checksum disabled have a checksum of zero that will
414 # tell the loading code to skip the check.
415 rdbchecksum yes在存储快照后，还可以让redis使用CRC64算法来进行数据校验，但是这样做会增加大约10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能，推荐yes.
RDB的备份
-
先通过config get dir 查询rdb文件的目录将*.rdb的文件拷贝到别的地方
-
RDB的恢复
-
关闭Redis
-
先把备份的文件拷贝到工作目录下 cp dump2.rdb dump.rdb
-
启动Redis, 备份数据会直接加载
-
3.优劣势总结
优势：
-
适合大规模的数据恢复
-
对数据完整性和一致性要求不高更适合使用（最后一次持久化可能造成数据丢失）
-
节省磁盘空间
-
恢复速度快
劣势：
-
Fork的时候，内存中的数据被克隆了一份，大致2倍的膨胀性需要考虑
-
虽然Redis在fork时使用了写时拷贝技术,但是如果数据庞大时还是比较消耗性能。
-
在备份周期在一定间隔时间做一次备份，所以如果Redis意外down掉的话，就会丢失最后一次快照后的所有修改。
动态停止RDB：redis-cli config set save ""#save后给空值，表示禁用保存策略
总结：
-
RDB是一个非常紧凑的文件
-
RDB在保存RDB文件时父进程唯一需要做的就是fork出一个子进程，接下来的工作全部由子进程来做，父进程不需要再做其他IO操作，所以RDB持久化方式可以最大化使用redis的性能。
-
与AOF相比，在恢复大的数据集的时候，RDB方式会快一些。
-
数据丢失风险大
-
RDB需要经常fork子进程来保存数据集到硬盘上，当数据集比较大的时候，fork的过程是非常耗时的，可能会导致Redis在一些毫秒级不能响应客户端的请求。
十，Redis6持久化之AOF
1、AOF（Append Only File）
概述
以日志的形式来记录每个写操作（增量保存），将Redis执行过的所有写指令记录下来(读操作不记录)， 只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis 重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。
2.AOF持久化流程
-
客户端的请求写命令会被append追加到AOF缓冲区内；
-
AOF缓冲区根据AOF持久化策略[always,everysec,no]将操作sync同步到磁盘的AOF文件中；
-
AOF文件大小超过重写策略或手动重写时，会对AOF文件rewrite重写，压缩AOF文件容量；
-
Redis服务重启时，会重新load加载AOF文件中的写操作达到数据恢复的目的；
3.AOF默认没开启
-
可以在redis.conf中配置文件名称，默认为 appendonly.aof
-
AOF文件的保存路径，同RDB的路径一致。
-
演示如何开启：
1254 appendonly no #把这个值改成yes 1255 1256 # The name of the append only file (default: "appendonly.aof") 1257 1258 appendfilename "appendonly.aof"
-
重启Redis，查看启动目录
[root@iZ2ze2rikqlh3ql1n2cw61Z bin]# ll total 24756 -rw-r--r-- 1 root root 0 Oct 17 22:52 appendonly.aof # AOF文件，注意：文件大小是0，为什么？ -rw-r--r-- 1 root root 127 Oct 17 22:39 dump.rdb
4.AOF和RDB同时开启，redis听谁的？
AOF和RDB同时开启，系统默认取AOF的数据（数据不会存在丢失）
5.AOF启动/修复/恢复
-
AOF的备份机制和性能虽然和RDB不同, 但是备份和恢复的操作同RDB一样，都是拷贝备份文件，需要恢复时再拷贝到Redis工作目录下，启动系统即加载。
-
正常恢复
-
修改默认的appendonly no，改为yes
-
将有数据的aof文件复制一份保存到对应目录(查看目录：config get dir)
-
恢复：重启redis然后重新加载
-
-
异常恢复
-
修改默认的appendonly no，改为yes
-
如遇到AOF文件损坏，通过/usr/local/bin/redis-check-aof--fix appendonly.aof进行恢复
-
备份被写坏的AOF文件
-
恢复：重启redis，然后重新加载
-
6.AOF同步频率设置
- appendfsync always：始终同步，每次Redis的写入都会立刻记入日志；性能较差但数据完整性比较好
-
appendfsync everysec：每秒同步，每秒记入日志一次，如果宕机，本秒的数据可能丢失。
-
appendfsync no：redis不主动进行同步，把同步时机交给操作系统。
7.Rewrite压缩
-
是什么：AOF采用文件追加方式，文件会越来越大为避免出现此种情况，新增了重写机制, 当AOF文件的大小超过所设定的阈值时，Redis就会启动AOF文件的内容压缩， 只保留可以恢复数据的最小指令集.可以使用命令bgrewriteaof
-
重写原理，如何实现重写：AOF文件持续增长而过大时，会fork出一条新进程来将文件重写(也是先写临时文件最后再rename)，redis4.0版本后的重写，是指上就是把rdb 的快照，以二级制的形式附在新的aof头部，作为已有的历史数据，替换掉原来的流水账操作。
-
no-appendfsync-on-rewrite
-
如果 no-appendfsync-on-rewrite=yes ,不写入aof文件只写入缓存，用户请求不会阻塞，但是在这段时间如果宕机会丢失这段时间的缓存数据。（降低数据安全性，提高性能）
-
如果 no-appendfsync-on-rewrite=no, 还是会把数据往磁盘里刷，但是遇到重写操作，可能会发生阻塞。（数据安全，但是性能降低）
-
触发机制，何时重写？Redis会记录上次重写时的AOF大小，默认配置是当AOF文件大小是上次rewrite后大小的一倍且文件大于64M时触发
-
重写虽然可以节约大量磁盘空间，减少恢复时间。但是每次重写还是有一定的负担的，因此设定Redis要满足一定条件才会进行重写。
-
-
auto-aof-rewrite-percentage：设置重写的基准值，文件达到100%时开始重写（文件是原来重写后文件的2倍时触发）
-
auto-aof-rewrite-min-size：设置重写的基准值，最小文件64MB。达到这个值开始重写。例如：文件达到70MB开始重写，降到50MB，下次什么时候开始重写？100MB系统载入时或者上次重写完毕时，Redis会记录此时AOF大小，设为base_size,如果Redis的AOF当前大小>= base_size +base_size*100% (默认)且当前大小>=64mb(默认)的情况下，Redis会对AOF进行重写。
-
-
重写流程
-
bgrewriteaof触发重写，判断是否当前有bgsave或bgrewriteaof在运行，如果有，则等待该命令结束后再继续执行。
-
主进程fork出子进程执行重写操作，保证主进程不会阻塞。
-
子进程遍历redis内存中数据到临时文件，客户端的写请求同时写入aof_buf缓冲区和aof_rewrite_buf重写缓冲区保证原AOF文件完整以及新AOF文件生成期间的新的数据修改动作不会丢失。
-
子进程写完新的AOF文件后，向主进程发信号，父进程更新统计信息。主进程把aof_rewrite_buf中的数据写入到新的AOF文件。
-
使用新的AOF文件覆盖旧的AOF文件，完成AOF重写。
-
8.优劣势总结
优势：
-
备份机制更稳健，丢失数据概率更低。
-
可读的日志文本，通过操作AOF稳健，可以处理误操作。
劣势：
-
比起RDB占用更多的磁盘空间。
-
恢复备份速度要慢。
-
每次读写都同步的话，有一定的性能压力。
-
存在个别Bug，造成恢复不能。
总结：
-
AOF文件是一个只进行追加的日志文件
-
Redis可以在AOF文件体积变的过大的时候自动在后台对AOF进行重写
-
AOF文件有序地保存了对数据库执行的所有写的操作，这些写入操作以Redis协议的格式保存，因此AOF文件的内容非常容易被人读懂，对文件进行分析也很轻松。
-
对于相同的数据集来说，AOF文件的体积通常要大于RDB文件的体积
-
根据所使用的fsync策略，AOF的速度可能会慢于RDB
9.具体使用
-
官方推荐两个都启用。
-
如果对数据不敏感，可以选单独用RDB。
-
不建议单独用 AOF，因为可能会出现Bug。
-
如果只是做纯内存缓存，可以都不用。
总结：
-
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这条规则。
-
如果使用AOF，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了。
-
代价,一是带来了持续的IO，二是AOF rewrite的最后将rewrite过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。
-
只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上。
-
默认超过原大小100%大小时重写可以改到适当的数值。
-
十一，Redis6的主从复制
主机数据更新后根据配置和策略， 自动同步到备机的master/slaver机制，Master以写为主，Slave以读为主
1.作用
-
读写分离，性能扩展
-
容灾快速恢复
-
在主机上写，在从机上可以读取数据
-
在从机上写数据报错
-
主机挂掉，从机可以继续得到数据，重启就行，一切如初
-
从机重启需重设：slaveof 127.0.0.1 6379（可以将配置增加到文件中。永久生效）
2.配置
# slaveof <ip><port> 成为某个实例的从服务器
info replication（执行后查看是否成功）
3.常用模式
1.一主二仆
-
如果主服务器挂掉了以后会怎么样？
-
主服务器挂掉后，从服务器不会上位，还是会认之前的是大哥。
-
-
如果主服务器重新启动后会怎么样？
-
主服务器重启之后还是主服务器，也就是还是当大哥。
-
2.薪火相传
-
上一个Slave可以是下一个slave的Master，Slave同样可以接收其他 slaves的连接和同步请求，那么该slave作为了链条中下一个的master, 可以有效减轻master的写压力,去中心化降低风险。
-
用 slaveof <ip><port>
-
中途变更转向:会清除之前的数据，重新建立拷贝最新的
-
风险是一旦某个slave宕机，后面的slave都没法备份
-
主机挂了，从机还是从机，无法写数据了
3.反客为主
-
须在薪火相传的基础上
-
当一个master宕机后，后面的slave可以立刻升为master，其后面的slave不用做任何修改。
-
用 slaveof no one 将从机变为主机。
-
测试当主服务器挂掉后，从服务器上位
4.主从原理
-
Slave启动成功连接到master后会给主服务器发送一个sync（同步）命令（这一步是从服务器主动做的）
-
主服务器接到从服务器发送过来的同步消息，把主服务器数据进行持久化到rdb文件了，把rdb文件发送给从服务器，从服务器拿到rdb进行获取（这一步是主服务器主动做的）
-
每次主服务器进行写操作之后，和从服务器会进行数据同步（这一步是主服务器主动做的）
-
全量复制：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。
-
增量复制：Master继续将新的所有收集到的修改命令依次传给slave,完成同步
-
但是只要是重新连接master,一次完全同步（全量复制)将被自动执行
5.哨兵模式(sentinel)—反客为主自动版
反客为主的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。
1.具体操作
1.自定义的/myredis目录下新建sentinel.conf文件，（名字绝不能错）
2.配置哨兵,填写内容
sentinel monitor mymaster 127.0.0.1 6379 1
#其中mymaster为监控对象起的服务器名称， 1 为至少有多少个哨兵同意迁移的数量。
3.重启redis
4.当主机挂掉，从机中选举产生新的主机
-
哪个从机会被选举为主机呢？根据优先级别：slave-priority
-
原主机重启后会变为从机。
2.缺点：
由于所有的写操作都是先在Master上操作，然后同步更新到Slave上，所以从Master同步到Slave机器有一定的延迟，当系统很繁忙的时候，延迟问题会更加严重，Slave机器数量的增加也会使这个问题更加严重。
3.故障修复
-
新主登基：从所有的从服务挑选一个作为主服务，将其变为主服务，选择的条件依次是：
-
选择优先级靠前的（slave-priority 100，值越小优先级越高）
-
选择偏移量最大的（看所有从服务器中谁同步主服务器的数据量最接近就选谁）
-
选择runid最小的从服务（如果所有从服务器同步的值的数量一样多，那么就用这个方式选择）
-
-
群仆俯首：挑选出新的主服务之后sentinel向原主服务的从服务发送slaveof新主服务的命令，复制新的master
-
旧主俯首：当已下线的服务重新上线的时候，sentinel会向其发送slaveof命令，让其称为新主的从
-
优先级在redis.conf中默认：slave-priority 100（R670），值越小优先级越高
-
偏移量是指获得原主机数据最全的
-
每个redis实例启动后都会随机生成一个40位的runid
十二，Redis6应用问题解决
1.缓存穿透
key对应的数据在数据源并不存在，每次针对此key的请求从缓存获取不到，请求都会压到数据源，从而可能压垮数据源。比如用一个不存在的用户id获取用户信息，不论缓存还是数据库都没有，若黑客利用此漏洞进行攻击可能压垮数据库。
解决办法
-
一个一定不存在缓存及查询不到的数据，由于缓存是不命中时被动写的，并且出于容错考虑，如果从存储层查不到数据则不写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。
-
解决办法
-
对空值缓存：如果一个查询返回的数据为空（不管是数据是否不存在），我们仍然把这个空结果（null）进行缓存，设置空结果的过期时间会很短，最长不超过五分钟
-
设置可访问的名单（白名单）：使用bitmaps类型定义一个可以访问的名单，名单id作为bitmaps的偏移量，每次访问和bitmap里面的id进行比较，如果访问id不在bitmaps里面，进行拦截，不允许访问。
-
采用布隆过滤器：(布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量(位图)和一系列随机映射函数（哈希函数）。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。)。将所有可能存在的数据哈希到一个足够大的bitmaps中，一个一定不存在的数据会被 这个bitmaps拦截掉，从而避免了对底层存储系统的查询压力。
-
进行实时监控：当发现Redis的命中率开始急速降低，需要排查访问对象和访问的数据，和运维人员配合，可以设置黑名单限制服务
-
2.缓存击穿（指的是某个key）
key对应的数据存在，但在redis中过期，此时若有大量并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。
解决办法
-
key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：缓存被“击穿”的问题。
-
解决问题：
-
预先设置热门数据：在redis高峰访问之前，把一些热门数据提前存入到redis里面，加大这些热门数据key的时长
-
实时调整：现场监控哪些数据热门，实时调整key的过期时长
-
使用锁：
-
就是在缓存失效的时候（判断拿出来的值为空），不是立即去load db。
-
先使用缓存工具的某些带成功操作返回值的操作（比如Redis的SETNX）去set一个mutex key
-
当操作返回成功时，再进行load db的操作，并回设缓存,最后删除mutex key；
-
当操作返回失败，证明有线程在load db，当前线程睡眠一段时间再重试整个get缓存的方法。
-
-
3.缓存雪崩
-
key对应的数据存在，但在redis中过期，此时若有大量并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。
-
缓存雪崩与缓存击穿的区别在于这里针对很多key缓存，前者则是某一个key。
正常访问
缓冲失败
解决办法
-
缓存失效时的雪崩效应对底层系统的冲击非常可怕！
-
解决办法：
-
构建多级缓存架构：nginx缓存 + redis缓存 +其他缓存（ehcache等）
-
使用锁或队列：用加锁或者队列的方式保证来保证不会有大量的线程对数据库一次性进行读写，从而避免失效时大量的并发请求落到底层存储系统上。不适用高并发情况
-
设置过期标志更新缓存：记录缓存数据是否过期（设置提前量），如果过期会触发通知另外的线程在后台去更新实际key的缓存。
-
将缓存失效时间分散开：比如我们可以在原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。
-
2635
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
