1、Redis 概述

远程字典服务器（Remote Dictionary Server，Redis)：一个开源的、高性能的、轻量级、使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，通过提供多种键值数据类型来试音不同场景下的缓存和存储需求，是跨平台的非关系型数据库。

2、Redis 特性

（1）存储结构

Redis 以字典结构存储数据，允许其他应用通过TCP协议读写字典中的内容。同大多数脚本语言中的字典一样，Redis字典中的键值除了可以是字符串，还可以是其他数据类型。到目前为止Redis支持的键值数据类型：STRING(字符串类型)、LIST(列表类型)、SET(集合类型)、HASH(散列类型)、ZSET(有序集合类型)。

（2）内存存储与持久化

Redis数据库中的所有数据都存储在内存中。由于内存的读写速度远快于硬盘，因此Redis在性能上对比其他基于硬盘存储的数据库有非常明显的优势。

将数据存储在内存中也有问题，比如程序退出后内存中的数据会丢失。不过 Redis提供了对持久化的支持，即可以将内存中的数据异步写入到硬盘中，同时不影响继续提供服务。

Redis 持久化方法有两种：第一种持久化方法为时间点转储( point-in-timedump )，转储操作既可以在“指定时间段内有指定数量的写操作执行”这一条件被满足时执行，又可以通过调用两条转储到硬盘( dump-to-disk)命令中的任何一条来执行；第二种持久化方法将所有修改了数据库的命令都写入一个只追加( append-only )文件里面，用户可以根据数据的重要程度，将只追加写人设置为从不同步( sync)、每秒同步一次或者每写入一个命令就同步一次。

（3）主从复制

执行复制的从服务器会连接上主服务器，接收主服务器发送的整个数据库的初始副本( copy )；之后主服务器执行的写命令，都会被发送给所有连接着的从服务器去执行，从而实时地更新从服务器的数据集。

因为从服务器包含的数据会不断地进行更新，所以客户端可以向任意一个从服务器发送读请求，以此来避免对主服务器进行集中式的访问。

（4）多数据库

Redis实例提供多个存储数据的字典，客户端可以指定将数据存储在哪个字典中, 可以将字典理解为数据库。Redis默认链接16个数据库，每个数据库对外都是一个从0开始的递增数字命名，可通过databases参数修改连接数，默认选择0号数据库，可通过SELECT命令更换redis > SELECT 1。

Redis 不支持自定义数据库名称，也不支持为每个数据库设置不同的访问密码。Redis 数据库之间并非完全隔离，如使用FLUSHALL 可以清空一个Redis 实例的所有数据。不同的应用应该使用不同的Redis实例里存储数据，同一实例的多个数据库可用于存储同一应用的不同环境的数据。

3、Redis 数据结构

4、Redis 底层实现

Redis并没有直接使用上述的高级数据结构进行存储，而是根据数据的特性和大小，选择最合适的内部编码方式。

Redis 通过精巧的数据结构和编码方式，实现了高性能的数据存储和操作。其底层实现不仅考虑了内存的使用效率，还充分考虑了数据操作的性能。这使得Redis能够在处理大量数据和并发请求时，依然保持出色的性能表现。对于开发者而言，理解Redis的数据结构和底层实现，有助于更好地使用和优化Redis，从而提升应用的整体性能。

4.1 字符串的底层实现：简单动态字符串（SDS）

Redis的字符串类型并不是直接使用C语言中的原生字符串（以空字符\0结尾的字符数组）进行存储，而是使用了一个称为简单动态字符串（Simple Dynamic String，SDS）的数据结构。这种设计选择为Redis带来了许多优势，尤其是在性能和灵活性方面。

（1）SDS结构

SDS的数据结构定义大致如下（可能根据Redis版本有所不同）：

struct sdshdr { 
    int len;      // 记录buf数组中已使用字节的数量，等于SDS所保存字符串的长度 
    int free;     // 记录buf数组中未使用字节的数量 
    char buf[];   // 字节数组，用于保存字符串。注意这里并没有指明数组的长度，这是一个柔性数组（flexible array member） 
};

（2）优势分析

• 预分配：SDS会为buf分配额外的未使用空间（通过free字段记录），这意味着当向一个SDS字符串追加内容时，如果未使用空间足够，Redis就不需要重新分配内存。这减少了内存分配次数，从而提高了性能。
• 常数时间复杂度获取字符串长度：由于SDS结构内部维护了一个len字段来记录字符串的当前长度，获取字符串长度的操作可以在常数时间复杂度O(1)内完成，而不需要像C语言的原生字符串那样遍历整个字符串。
• 二进制安全：SDS可以存储任意二进制数据，包括空字符\0。C语言的原生字符串以空字符作为结束标志，这限制了它们不能包含空字符。而SDS则通过len字段来明确字符串的长度，因此不受此限制。
• 兼容C语言字符串函数：尽管SDS提供了自己的一套API来进行字符串操作，但它的buf字段实际上就是一个普通的C字符串（以\0结尾），这意味着在必要时，可以直接使用标准的C语言字符串处理函数来操作buf字段（尽管通常不推荐这样做，因为可能会破坏SDS结构的完整性）。

（3）操作优化

SDS提供了一组API来进行字符串的创建、修改、拼接等操作。这些API在内部会处理内存分配、长度更新等细节，使得用户在使用时无需关心底层实现。

例如，当使用sdscat函数向一个SDS字符串追加内容时，该函数会首先检查未使用空间是否足够，如果不够，则会重新分配更大的内存空间，并将原有数据复制到新位置，然后再追加新内容。所有这些操作对用户都是透明的。

小结：通过使用SDS作为字符串的底层实现，Redis实现了字符串操作的高效性和灵活性，为上层提供了丰富的数据操作接口，同时保证了内部数据的一致性和稳定性。这种设计使得Redis在处理大量字符串数据时能够保持出色的性能。

4.2 列表的底层实现：压缩列表和双向链表

（1）压缩列表

当列表的元素数量较少且元素较小时，Redis会使用压缩列表（ziplist）作为底层实现来节省内存。压缩列表是一个紧凑的、连续的内存块，它按顺序存储了列表中的元素。

压缩列表的结构大致如下：

±-------±-------±-------±-----+
| ZLBYTE | LEN | ‘one’ | ‘two’| …
±-------±-------±-------±-----+

• ZLBYTE： 压缩列表的头部信息，包含了特殊编码和压缩列表的长度信息。
• LEN： 每个元素前的长度字段，用于记录该元素的长度或前一个元素到当前元素的偏移量。
• ‘one’, ‘two’： 实际的列表元素，它们被连续地存储在压缩列表中。

使用压缩列表的优势在于：

• 内存利用率高，因为元素是连续存储的，没有额外的指针开销。
• 对于小列表，操作速度可以很快，因为所有数据都在一个连续的内存块中。

操作优化：

Redis的列表实现提供了一组API来进行列表的创建、修改、遍历等操作。这些API在内部会根据列表的大小和元素的特性选择合适的底层数据结构，并且在必要时进行数据结构之间的转换。

例如，当向一个使用压缩列表实现的列表中添加一个新元素时，如果添加后的列表仍然满足压缩列表的使用条件（即元素数量和大小都没有超过预设的阈值），那么Redis会直接在压缩列表的末尾添加新元素。否则，Redis会将压缩列表转换为双向链表，并在链表的尾部添加新元素。

（2）双向链表

当列表的元素数量较多或者元素较大时，Redis会选择使用双向链表作为底层实现。双向链表中的每个节点都保存了前一个节点和后一个节点的指针，这使得在列表的任何位置插入或删除元素都变得相对容易。

双向链表的结构大致如下：

typedef struct listNode { 
    struct listNode *prev;  // 指向前一个节点的指针 
    struct listNode *next;  // 指向后一个节点的指针 
    void *value;            // 节点保存的数据 
} listNode; 
   
typedef struct list { 
    listNode *head;         // 指向链表头部的指针 
    listNode *tail;         // 指向链表尾部的指针 
    unsigned long len;      // 链表的长度 
    // ... 可能还有其他字段，如复制函数、比较函数等 
} list;

使用双向链表的优势在于：

• 可以在O(1)时间复杂度内完成在列表头部或尾部的元素插入和删除。
• 当需要遍历列表时，可以从头部或尾部开始，沿着节点的指针依次访问。

通过使用双向链表和压缩列表作为底层实现，Redis的列表数据类型能够在不同的使用场景下提供高效的操作性能。这种灵活的设计使得Redis能够处理各种大小和复杂度的列表数据，同时保持内存的低消耗和操作的快速性。

4.3 哈希的底层实现：压缩列表和字典

Redis的哈希（Hash）类型允许用户在单个键中存储多个字段和对应的值。为了高效地支持这种数据结构，Redis在底层使用了两种主要的数据结构来实现哈希：压缩列表和字典（也称为哈希表）。

（1）压缩列表

当哈希中的字段和值较少且较小时，Redis会使用压缩列表作为底层实现来节省内存。压缩列表是一种紧凑的、连续的内存块，它按顺序存储了哈希中的字段和值对。

压缩列表的结构大致如下：

±-------±-------±-------±-------+
| ZLBYTE | LEN1 | FIELD1 | LEN2 | VALUE2 | …
±-------±-------±-------±-------+

• ZLBYTE：压缩列表的头部信息。
• LEN1、FIELD1：第一个字段的长度和字段本身。
• LEN2、VALUE2：第一个字段对应的值的长度和值本身。
• 以此类推，后续的字段和值对也是按照这个格式存储的。

使用压缩列表的优势在于：

• 内存利用率高，因为字段和值是连续存储的，没有额外的指针和元数据开销。
• 对于小哈希，操作速度可以很快，因为所有数据都在一个连续的内存块中。

操作优化:

-Redis的哈希实现提供了一组API来进行哈希的创建、修改、查找等操作。这些API在内部会根据哈希的大小和字段的特性选择合适的底层数据结构，并且在必要时进行数据结构之间的转换。

例如，当向一个使用压缩列表实现的哈希中添加一个新的字段和值时，如果添加后的哈希仍然满足压缩列表的使用条件（即字段和值的数量和大小都没有超过预设的阈值），那么Redis会直接在压缩列表的末尾添加新的字段和值。否则，Redis会将压缩列表转换为字典，并在字典中插入新的字段和值。

（2）字典（哈希表）

当哈希中的字段和值较多或者较大时，Redis会选择使用字典作为底层实现。字典是一种通过键（在Redis哈希中是字段）来直接访问值的数据结构，它能够在平均情况下提供O(1)时间复杂度的查找、插入和删除操作。

Redis的字典实现通常包含两个哈希表，用于处理哈希表扩容时的数据迁移。每个哈希表节点保存了字段的哈希值、字段本身和对应的值。结构大致如下：

typedef struct dictEntry { 
    void *key;                // 字段 
    union { 
        void *val; 
        uint64_t u64; 
        int64_t s64; 
        // ... 其他可能的值类型 
    } v;                      // 值 
    struct dictEntry *next;   // 指向下一个节点的指针，用于解决哈希冲突 
} dictEntry; 
   
typedef struct dict { 
    dictEntry **table;        // 哈希表数组 
    unsigned long size;       // 哈希表大小 
    unsigned long sizemask;   // 用于计算索引的掩码 
    unsigned long used;       // 已使用的节点数量 
    // ... 可能还有其他字段，如哈希函数、复制函数等 
} dict;

使用字典的优势在于：

• 提供了快速的字段查找、插入和删除操作。
• 哈希表的扩容机制可以保持较低的哈希冲突率，从而保证操作的效率。

通过使用字典和压缩列表作为底层实现，Redis的哈希数据类型能够在不同的使用场景下提供高效的操作性能。这种灵活的设计使得Redis能够处理各种大小和复杂度的哈希数据，同时保持内存的低消耗和操作的快速性。

4.4 集合的底层实现：整数集合和字典

Redis的集合（Set）是一个无序的、元素不重复的集合。为了高效地支持这种数据结构及其操作，Redis在底层使用了两种主要的数据结构：整数集合（intset）和字典（hashtable）。

（1）整数集合（intset）

当集合中的元素都是整数，并且元素数量较少时，Redis会选择使用整数集合作为底层实现。整数集合是一个紧凑的数组，数组中的每个元素都是集合中的一个整数。

整数集合的优势在于：

• 内存利用率高：整数集合将整数紧密地存储在一个连续的内存块中，没有额外的指针或元数据开销。
• 操作速度快：对于整数集合中的元素，Redis可以直接通过数组索引访问，这使得查找、添加和删除整数的操作非常快速。 然而，整数集合也有其局限性。由于它要求集合中的元素必须是整数，并且元素数量较少，因此在处理非整数元素或大量元素时，整数集合可能不是最优的选择。

（2）字典（hashtable）

当集合中的元素不满足整数集合的条件（即元素不是整数或元素数量较多）时，Redis会使用字典作为底层实现。字典是一种哈希表，它通过哈希函数将元素的哈希值映射到相应的桶（bucket）中，以支持快速的查找、插入和删除操作。

字典的优势在于：

• 灵活性高：字典可以存储任意类型的元素，而不仅仅是整数。
• 操作效率高：通过哈希函数，字典可以在平均情况下提供O(1)时间复杂度的查找、插入和删除操作。

然而，字典也有一定的开销。每个字典元素都需要额外的空间来存储哈希值、指针等元数据。此外，当哈希表发生哈希冲突时，可能需要通过链表或其他方式解决冲突，这可能会降低操作的效率。

（3）操作优化和转换

Redis的集合实现提供了一组API来进行集合的创建、修改、查找等操作。这些API在内部会根据集合的大小和元素的特性选择合适的底层数据结构，并且在必要时进行数据结构之间的转换。

例如，当向一个使用整数集合实现的集合中添加一个新的整数元素时，如果添加后的集合仍然满足整数集合的使用条件（即元素数量没有超过预设的阈值），那么Redis会直接在整数集合的末尾添加新的元素。否则，Redis会将整数集合转换为字典，并在字典中插入新的元素。

小结：Redis的集合在底层使用了整数集合和字典两种数据结构来实现。整数集合适用于元素较少且都是整数的场景，而字典适用于元素数量较多或元素类型不限的场景。通过这种灵活的设计，Redis能够在不同的使用场景下提供高效的操作性能，同时保持内存的低消耗和操作的快速性。

4.5 有序集合的底层实现：压缩列表和跳表

Redis的有序集合（Sorted Set）是一个有序的、元素不重复的集合，其中每个元素都关联了一个分数（score）。为了实现这种数据结构及其相关操作的高效性，Redis在底层主要使用了两种数据结构：压缩列表（ziplist）和跳表（skiplist）。

（1）跳表（skiplist）

当有序集合的元素数量较多或元素的大小较大时，Redis会使用跳表作为底层实现。跳表是一种多层的有序链表，它通过维护多个层次的指针来加快查找、插入和删除操作的速度。

跳表的优势在于：

• 查找效率高：通过维护多个层次的指针，跳表可以在平均情况下提供O(log N)时间复杂度的查找操作，其中N是元素的数量。
• 插入和删除操作快速：跳表的插入和删除操作只需要局部地调整指针，而不需要移动大量的数据。
• 支持范围查询：跳表可以方便地支持按照分数范围查询元素的操作

然而，跳表也有一定的开销。每个元素在跳表中都有多个指向前驱和后继的指针，这些指针会占用额外的内存空间。

操作优化和转换：

Redis的有序集合实现提供了一组API来进行集合的创建、修改、查找等操作。这些API在内部会根据集合的大小和元素的特性选择合适的底层数据结构，并且在必要时进行数据结构之间的转换。

例如，当向一个使用压缩列表实现的有序集合中添加一个新的元素时，如果添加后的集合仍然满足压缩列表的使用条件（即元素数量没有超过预设的阈值），那么Redis会直接在压缩列表的末尾添加新的元素。否则，Redis会将压缩列表转换为跳表，并在跳表中插入新的元素。

小结：Redis的有序集合在底层使用了压缩列表和跳表两种数据结构来实现。压缩列表适用于元素较少且大小较小的场景，而跳表适用于元素数量较多或元素大小较大的场景。通过这种灵活的设计，Redis能够在不同的使用场景下提供高效的操作性能，同时保持内存的低消耗和操作的快速性。有序集合的实现使得Redis能够支持按照分数排序、范围查询等复杂操作，满足了业务上的多样化需求。

5、Redis 客户端常用命令

5.1 KEY

5.2 String

5.3 List

5.4 Set

5.5 Hash

5.6 HyperLogLog

6、Reids 可执行文件

6.2 redis-cli

（1）连接 Redis 服务器

• 第一种：交互式方式

  $redis-cli -h 127.0.0.1 -p 6379 -a redis_password
  127.0.0.1：6379>set hello world
  OK
  127.0.0.1：6379>get hello
  "world"
  

• 第二种方式：命令方式

  $redis-cli -h 127.0.0.1 -p 6379 get hello
  "world"
  

（2）常用参数

# 命令查询参数
[appuser@localhost app]$ redis-cli -help
redis-cli 6.x.x  
Usage: redis-cli [OPTIONS] [cmd [arg [arg ...]]]  
  -h <hostname>      Server hostname (default: 127.0.0.1).  
  -p <port>          Server port (default: 6379).  
  -s <socket>        Server socket (overrides hostname and port).  
  -a <password>      Password to use when connecting to the server.  
  -r <repeat>        Execute specified command N times.  
  -i <interval>      When -r is used, waits <interval> seconds per command.  
  -n <db>            Database number.  
  -x                 Read last argument from STDIN.  
  -d <delimiter>     Delimiter to be used by -x when reading from STDIN.  
  --raw              Use raw formatting for replies (default when STDOUT is not a tty).  
  --no-raw           Force formatted output (default when STDOUT is a tty).  
  --csv              Output in CSV format.  
  --scan             SCAN command for keys with patterns.  
  --pattern <pat>    Pattern to match.  
  --bigkeys          Sample random keys to understand memory distribution.  
  --eval <script>    Execute Lua script, keys must be passed next to script as args.  
  --latency          Sample latency in milliseconds.  
  --latency-history  Sample latency with histogram.  
  --latency-dist     Sample latency distribution.  
  --slaveof <host:port> Turn the server into a replica of another instance.  
  --cluster <command> Run a cluster command (check, create, fix, reshard, call, etc.).  
  --pipe             Read commands from STDIN and send them to the server.  
  --bigkeys-summary  Only show summary stats in --bigkeys mode.  
  -v                 Verbose mode. Warning: use with care as it may show sensitive information.  
  --help             Show this help message and exit.  
  --version          Show version.  
  
Examples:  
  redis-cli ping  
  echo "SET foo bar" | redis-cli  
  redis-cli -r 100 -i 1 info  
  redis-cli --eval myscript.lua key1,key2 , arg1 arg2 arg3  
  redis-cli --scan --pattern '*'

（3）集群客户端命令

• 集群
  • cluster info ：打印集群的信息
  • cluster nodes ：列出集群当前已知的所有节点（ node），以及这些节点的相关信息。
• 节点
  • cluster meet ：将 ip 和 port 所指定的节点添加到集群当中，让它成为集群的一份子。
  • cluster forget <node_id> ：从集群中移除 node_id 指定的节点。
  • cluster replicate <node_id> ：将当前节点设置为 node_id 指定的节点的从节点。
  • cluster saveconfig ：将节点的配置文件保存到硬盘里面。
• 槽(slot)
  • cluster addslots [slot …] ：将一个或多个槽（ slot）指派（ assign）给当前节点。
  • cluster delslots [slot …] ：移除一个或多个槽对当前节点的指派。
  • cluster flushslots ：移除指派给当前节点的所有槽，让当前节点变成一个没有指派任何槽的节点。
  • cluster setslot node <node_id> ：将槽 slot 指派给 node_id 指定的节点，如果槽已经指派给另一个节点，那么先让另一个节点删除该槽>，然后再进行指派。
  • cluster setslot migrating <node_id> ：将本节点的槽 slot 迁移到 node_id 指定的节点中。
  • cluster setslot importing <node_id> ：从 node_id 指定的节点中导入槽 slot 到本节点。
  • cluster setslot stable ：取消对槽 slot 的导入（ import）或者迁移（ migrate）。
• 键
  • cluster keyslot ：计算键 key 应该被放置在哪个槽上。
  • cluster countkeysinslot ：返回槽 slot 目前包含的键值对数量。
  • cluster getkeysinslot ：返回 count 个 slot 槽中的键

[appuser@localhost app]$ redis-cli --cluster help
Cluster Manager Commands:
  create         host1:port1 ... hostN:portN   #创建集群
                 --cluster-replicas <arg>      #从节点个数
  check          host:port                     #检查集群
                 --cluster-search-multiple-owners #检查是否有槽同时被分配给了多个节点
  info           host:port                     #查看集群状态
  fix            host:port                     #修复集群
                 --cluster-search-multiple-owners #修复槽的重复分配问题
  reshard        host:port                     #指定集群的任意一节点进行迁移slot，重新分slots
                 --cluster-from <arg>          #需要从哪些源节点上迁移slot，可从多个源节点完成迁移，以逗号隔开，传递的是节点的node id，还可以直接传递--from all，这样源节点就是集群的所有节点，不传递该参数的话，则会在迁移过程中提示用户输入
                 --cluster-to <arg>            #slot需要迁移的目的节点的node id，目的节点只能填写一个，不传递该参数的话，则会在迁移过程中提示用户输入
                 --cluster-slots <arg>         #需要迁移的slot数量，不传递该参数的话，则会在迁移过程中提示用户输入。
                 --cluster-yes                 #指定迁移时的确认输入
                 --cluster-timeout <arg>       #设置migrate命令的超时时间
                 --cluster-pipeline <arg>      #定义cluster getkeysinslot命令一次取出的key数量，不传的话使用默认值为10
                 --cluster-replace             #是否直接replace到目标节点
  rebalance      host:port                                      #指定集群的任意一节点进行平衡集群节点slot数量 
                 --cluster-weight <node1=w1...nodeN=wN>         #指定集群节点的权重
                 --cluster-use-empty-masters                    #设置可以让没有分配slot的主节点参与，默认不允许
                 --cluster-timeout <arg>                        #设置migrate命令的超时时间
                 --cluster-simulate                             #模拟rebalance操作，不会真正执行迁移操作
                 --cluster-pipeline <arg>                       #定义cluster getkeysinslot命令一次取出的key数量，默认值为10
                 --cluster-threshold <arg>                      #迁移的slot阈值超过threshold，执行rebalance操作
                 --cluster-replace                              #是否直接replace到目标节点
  add-node       new_host:new_port existing_host:existing_port  #添加节点，把新节点加入到指定的集群，默认添加主节点
                 --cluster-slave                                #新节点作为从节点，默认随机一个主节点
                 --cluster-master-id <arg>                      #给新节点指定主节点
  del-node       host:port node_id                              #删除给定的一个节点，成功后关闭该节点服务
  call           host:port command arg arg .. arg               #在集群的所有节点执行相关命令
  set-timeout    host:port milliseconds                         #设置cluster-node-timeout
  import         host:port                                      #将外部redis数据导入集群
                 --cluster-from <arg>                           #将指定实例的数据导入到集群
                 --cluster-copy                                 #migrate时指定copy
                 --cluster-replace                              #migrate时指定replace
  help           

For check, fix, reshard, del-node, set-timeout you can specify the host and port of any working node in the cluster.

示例：

• 创建集群主节点

  ./redis-cli --cluster create host1:port1 host2:port2 host3:port3
  

• 创建集群主从节点

  # 说明：--cluster-replicas 参数为数字，1表示每个主节点需要1个从节点
  ./redis-cli --cluster create host1:port1 host2:port2 host3:port3 host4:port4 host5:port5 host6:port6 --cluster-replicas 1 -a 123456
  

• 添加集群主节点

  # 新节点：host1:port1   集群中任意一节点：host2:port2
  ./redis-cli --cluster add-node host1:port1 host2:port2
  

• 添加集群从节点

  ./redis-cli --cluster add-node host1:port1 host2:port2 --cluster-slave --cluster-master-id master_node_id
  # 新节点：host1:port1   
  # 集群中任意一节点：host2:port2
  # 指定新节点的主节点的节点ID：master_node_id，不指定将随机分配给某个主节点
  

• 删除节点

  #指定IP、端口和node_id 来删除一个节点，从节点可以直接删除，有slot分配的主节点不能直接删除
  ./redis-cli --cluster del-node target_host:target_port target_node_id
  

• 检查集群

  # host:port：集群中任意节点
  ./redis-cli --cluster check host:port --cluster-search-multiple-owners
  

• 查看集群信息 key、slots、从节点个数的分配情况

  ./redis-cli --cluster info host:port
  

• 修复集群和槽的重复分配问题

  ./redis-cli --cluster fix host:port --cluster-search-multiple-owners
  

• 设置集群的超时时间

  ./redis-cli --cluster set-timeout host:port 10000
  

• 集群中执行相关命令

  # 连接到集群的任意一节点来对整个集群的所有节点进行设置
  redis-cli --cluster call 192.168.163.132:6381 config set requirepass cc
  redis-cli -a cc --cluster call 192.168.163.132:6381 config set masterauth cc
  redis-cli -a cc --cluster call 192.168.163.132:6381 config rewrite
  

• 集群伸缩：
  • 根据提示迁移：

    ./redis-cli -a cc --cluster reshard host:port
    

  • 根据参数迁移

    # 连接到集群的任意一节点来对指定节点指定数量的slot进行迁移到指定的节点
    ./redis-cli -a cc --cluster reshard host1:port1 --cluster-from node_id1 --cluster-to node_id2 --cluster-slots 10 --cluster-yes --cluster-timeout 5000 --cluster-pipeline 10 --cluster-replace
    

• 平衡（rebalance）slot ：
  • 平衡集群中各个节点的slot数量

    ./redis-cli -a cc --cluster rebalance host:port
    

  • 根据集群中各个节点设置的权重等平衡slot数量（不执行，只模拟）

    ./redis-cli -a cc --cluster rebalance --cluster-weight node_id1=5 node_id2=4 node_id3=3 --cluster-simulate host:port
    

• 导入集群

  # 外部Redis实例（host2:port2）导入到集群中的任意一节点
  ./redis-cli --cluster import host1:port1 --cluster-from host2:port2 --cluster-replace
  

  注意：测试下来发现参数–cluster-replace没有用，如果集群中已经包含了某个key，在导入的时候会失败，不会覆盖，只有清空集群key才能导入。

  *** Importing 97847 keys from DB 0
  Migrating 9223372011174675807 to 192.168.163.132:6381: Source 192.168.163.132:9021 replied with error:
  ERR Target instance replied with error: BUSYKEY Target key name already exists
  

  如果集群设置了密码，也会导入失败，需要设置集群密码为空才能进行导入（call）
  通过monitor（9021）的时候发现，在migrate的时候需要密码进行auth认证。

7、事务

Redis 事务：https://zhuanlan.zhihu.com/p/135241403

Redis watch命令：http://c.biancheng.net/view/4544.html

8、时间空间

Redis 过期时间：https://www.cnblogs.com/xiaoxiongcanguan/p/9937433.html

Redis 限制访问频率：https://blog.csdn.net/weixin_44922018/article/details/100181454

Redis 数据淘汰策略：https://blog.csdn.net/qq_37286668/article/details/110631680

9、排序

https://www.cnblogs.com/-wenli/p/13034628.html

10、消息通知

https://blog.csdn.net/men_wen/article/details/62237970

11、管道

https://www.cnblogs.com/xiaoxiongcanguan/p/9954254.html

12、脚本

Redis在2.6版推出了脚本功能，允许开发者使用Lua语言编写脚本传到Redis中执行，在Lua脚本中可以调用大部分的Redis命令。使用脚本的好处：

• 减少网络开销：使用脚本功能完成的操作只需要发送一个请求即可，减少了网络往返时延。

• 原子操作：Redis会将整个脚本作为一个整体执行，中间不会被其他命令插入。换句话说在编写脚本的过程中无需担心会出现竞态条件，也就无需使用事务。事务可以完成的所有功能都可以用脚本来实现。

• 复用：客户端发送的脚本会永久存储在 Redis 中，这就意味着其他客户端（可以是其他语言开发的项目）可以复用这一脚本而不需要使用代码完成同样的逻辑。

Redis中使用Lua脚本：https://zhuanlan.zhihu.com/p/77484377

Redis Lua脚本入门：https://www.cnblogs.com/felordcn/p/13838321.html

Lua 教程：https://www.w3cschool.cn/lua/

13、持久化

Redis 的强劲性能很大程度上是由于其将所有数据都存储在了内存中，然而当Redis重启后，所有存储在内存中的数据就会丢失。在一些情况下，我们会希望 Redis在重启后能够保证数据不丢失，例如：

• 将Redis 作为数据库使用时。
• 将Redis作为缓存服务器，但缓存被穿透后会对性能造成较大影响，所有缓存同时失效会导致缓存雪崩，从而使服务无法响应。

这时我们希望Redis能将数据从内存中以某种形式同步到硬盘中，使得重启后可以根据硬盘中的记录恢复数据。这一过程就是持久化。

Redis支持两种方式的持久化：

• RDB方式：根据指定的规则“定时”将内存中的数据存储在硬盘上
• AOF 方式：在每次执行命令后将命令本身记录下来。

两种持久化方式可以单独使用其中一种，但更多情况下是将二者结合使用。

Redis 持久化详解：https://blog.csdn.net/qq_45722267/article/details/124525345

14、管理

（1）安全

• 可信的环境
• 数据库密码
• 命令命令

（2）通信协议

• 简单协议
• 统一请求协议

（3）管理工具

• redis-cli
• phpRedisAdmin
• Rdbtools

15、节省时间

（1）精简键名和键值

精简键名和键值是最直观的减少内存占用的方式，如将键名 very.important.person:20改成VIP:20。当然精简键名一定要把握好尺度，不能单纯为了节约空间而使用不易理解的键名（比如将VIP:20修改为V:20，这样既不易维护，还容易造成命名冲突)。又比如一个存储用户性别的字符串类型键的取值是male和 female，我们可以将其修改成m和f来为每条记录节约几个字节的空间（更好的方法是使用0和1来表示性别)。

（2）内部编码优化

https://blog.csdn.net/sinat_33087001/article/details/110387844

16、性能问题

• Master AOF持久化，Master调用BGREWRITEAOF重写AOF文件，AOF在重写的时候会占大量的CPU和内存资源，导致服务load过高，出现短暂服务暂停现象。如果不重写AOF文件，这个持久化方式对性能的影响是最小的，但是AOF文件会不断增大，AOF文件过大会影响Master重启的恢复速度
• Master写内存快照，save命令调度rdbSave函数，会阻塞主线程的工作，当快照比较大时对性能影响是非常大的，会间断性暂停服务，所以Master最好不要写内存快照
• Master最好不要做任何持久化工作，包括内存快照和AOF日志文件，特别是不要启用内存快照做持久化
• 如果数据比较关键，某个Slave开启AOF备份数据，策略为每秒同步一次
• Redis主从复制的性能问题：为了主从复制的速度和连接的稳定性，Master和Slave最好在同一个局域网内
• 尽量避免在压力很大的主库上增加从库
• 主从复制不要用图状结构，用单向链表结构更为稳定，即：Master ⬅ Slave1 ⬅ Slave2 ⬅Slave3 …
  这样的结构方便解决单点故障问题，实现Slave对Master的替换。如果Master挂了，可以立刻启用Slave1做Master，其他不变。

17、适合的场景

    Redis 适合所有数据in-momory的场景，虽然Redis也提供持久化功能，但实际更多的是一个disk-backed的功能

• 会话缓存（Session Cache）
  Redis提供持久化，当维护一个不是严格要求一致性的缓存时，避免用户数据丢失
• 全页缓存（FPC）
  即使重启了Redis实例，因为有磁盘的持久化，用户也不会看到页面加载速度的下降，这是一个极大改进
• 队列
  Reids 提供 list 和 set 操作，这使得Redis能作为一个很好的消息队列平台来使用
• 排行榜/计数器
  Redis在内存中对数字进行递增或递减的操作实现的非常好。集合（Set）和有序集合（Sorted Set）执行这些操作的时候变的非常简单，Redis只是正好提供了这两种数据结构
• 发布/订阅

18、SpringBoot 集成Redis + Redisson

Jedis 作为 Redis客户端的 java版实现实现了绝大部分的Redis原生功能，但是却没有对分布式线程控制做很好的支持。而Redisson是Redis官方推荐的支持分布式操作的Redis Java版客户端，但它却不支持一些基础的Redis原生功能。所以Jedis和Redisson只有整合到一起使用，才能更好的满足用户的需求。

19、集群

（3）Redis-Cluster 投票容错机制

（4）集群扩容

https://cloud.tencent.com/developer/article/1534189

（5）集群缩容

https://blog.csdn.net/JSWANGCHANG/article/details/118724170

（6）卡槽分配

获取与插槽对应的节点：

（7）故障恢复

实践：挂掉（kill）一个主节点（如7002），查看集群状态，再重启集群，查看集群状态

20、参考资料

• Redis数据结构与底层实现
• redis cli 常用命令
• Redis Command
• Redis 教程
• Redis 入门指南 - 李子骅
• redis集群搭建
• redis cluster 搭建实践
• Redis 5.0 redis-cli --cluster help说明
• Redis数据备份与恢复
• Redis 数据备份与恢复(持久化)
• 常用的redis客户端Jedis 、Lettuce 、Redisson 介绍以及对比
• Springboot集成Jedis + Redisson