Redis编程-基础、消息队列机制

一． Redis 安装

---

Redis 官网： https://redis.io/
 

1.1. 下载 redis

直接下载目前最新的 6.0.3 版本，下载地址： http://download.redis.io/releases/redis-6.0.3.tar.gz

$ wget http://download.redis.io/releases/redis-6.0.3.tar.gz
$ tar zxvf redis-6.0.3.tar.gz

1.2. 编译安装 redis

$ cd redis-6.0.3
$ make
make 之后就编译完成了。 有时间还可以 make test
$ sudo make install

默认安装到/usr/local/bin/目录，对应的命令
redis-server 是服务器程序
redis-cli 是客户端程序

查看版本命令：
$ redis-server -v
显示： Redis server v=6.0.3 sha=00000000:0 malloc=jemalloc-5.1.0 bits=64 build=77053994c60ea3c2 

1.3. 启动 redis

直接启动

$ redis-server

以后台进程方式启动 redis
在/etc 目录创建 redis 目录

$ sudo mdkir /etc/redis
将编译目录(redis-6.0.3)下的 redis.conf 拷贝到/etc/redis 目录

$ sudo cp redis.conf /etc/redis/6379.conf

修改/etc/redis/6379.conf 文件 将
daemonize no
改为
daemonize yes

指定 6379.conf 文件启动
$ redis-server /etc/redis/6379.conf
启动后的打印

查看 redis 的进程 id， ps -ef | grep redis

设置 redis 开机自启动
(1)将 redis-6.0.3 中的启动脚本(在 redis-6.0.3/utils 目录)复制一份放到/etc/init.d 目录下

$ sudo cp utils/redis_init_script /etc/init.d/redis_6379

(2)修改文档 redis_6379
按自身的配置修改：

REDISPORT=6379
EXEC=/usr/local/bin/redis-server
CLIEXEC=/usr/local/bin/redis-cli
PIDFILE=/var/run/redis_${REDISPORT}.pid
CONF="/etc/redis/${REDISPORT}.conf"

从这里就很容易理解为什么我们 copy conf 文件的时候是以 port 为名进行命名。

(3) 添加到开机启动

$ sudo update-rc.d -f redis_6379 defaults

如果要禁止开机启动

$ sudo update-rc.d -f redis_6379 remove

(4) 验证是否加入到开机启动

$ sudo sysv-rc-conf --list redis_6379

查验结果， 出现下图所示内容，代表设置成功：

 或者

$ sudo sysv-rc-conf

看到 init.d 目录下的所有自启动。

(5) 重启验证，并查看 redis 的进程， ps -ef | grep redis

1.4 redis-cli 使用

(1)默认无权限控制

$ redis-cli -h 127.0.0.1 -p 6379

(2)服务停止

$ redis-cli -h 127.0.0.1 -p 6379 shutdown

(3)有权限控制时(加上-a 密码)

需要配置密码的话就去/etc/redis/6379.conf 的配置文件中找到 requirepass 这个参数，如下配置：

修改 redis.conf 配置文件
#指定密码 123456
requirepass 123456                 
指定密码后需要重启 redis-server

$ redis-cli -h 127.0.0.1 -p 6379 -a 123456

(4)Redis 默认启动

端口号为 127.0.0.1，端口号默认为： 6379
$ redis-cli

1.5 关于 redis 6.0 的多线程

(1) 如需开启需要修改 redis.conf 配置文件： io-threads-do-reads yes。

(2) Redis 6.0 多线程开启时，线程数如何设置？

开启多线程后，还需要设置线程数，否则是不生效的。同样修改 redis.conf 配置文件：

关于线程数的设置，官方有一个建议： 4 核的机器建议设置为 2 或 3 个线程， 8 核的建议设置为6 个线程，线程数一定要小于机器核数。

1.6 抓包分析命令

sudo tcpdump -i any dst host 127.0.0.1 and port 6379

更详细的显示加上 -XX 输出包的头部数据，会以 16 进制和 ASCII 两种方式同时输出，这样更方便
分析 redis 的协议，比如：

sudo tcpdump -i any dst host 127.0.0.1 and port 6379 -XX

分析设置命令： set teacher king
服务器返回

二．基本数据结构

---

Key: 键

 Redis 键命令用于管理 redis 的键。 基本语法：

redis 127.0.0.1:6379> COMMAND KEY_NAME

实例：

redis 127.0.0.1:6379> SET 0voice redis
OK
redis 127.0.0.1:6379> DEL 0voice
(integer) 1

Redis Keys 命令：

DEL key 该命令用于在 key 存在时删除 key。

DUMP key 序列化给定 key ，并返回被序列化的值。

EXISTS key 检查给定 key 是否存在。

EXPIRE key seconds 为给定 key 设置过期时间，以秒计。

EXPIREAT key timestamp EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置过期时间。 不同在于 EXPIREAT 命 令接受的时间参数是 UNIX 时间戳(unix timestamp)。

PEXPIRE key milliseconds 设置 key 的过期时间以毫秒计。

PEXPIREAT key milliseconds-timestamp 设置 key 过期时间的时间戳(unix timestamp) 以毫秒计

KEYS pattern 查找所有符合给定模式( pattern)的 key 。

MOVE key db 将当前数据库的 key 移动到给定的数据库 db 当中。

PERSIST key 移除 key 的过期时间， key 将持久保持。

PTTL key 以毫秒为单位返回 key 的剩余的过期时间。

TTL key 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。

RANDOMKEY 从当前数据库中随机返回一个 key 。

RENAME key newkey 修改 key 的名称

RENAMENX key newkey 仅当 newkey 不存在时，将 key 改名为 newkey 。

TYPE key 返回 key 所储存的值的类型

String: 字符串

 Redis 字符串数据类型的相关命令用于管理 redis 字符串值，基本语法如下：

redis 127.0.0.1:6379> COMMAND KEY_NAME

实例：

redis 127.0.0.1:6379> SET zerovoicekey redis
OK
redis 127.0.0.1:6379> GET zerovoicekey
"redis"

命令

SET key value 设置指定 key 的值

GET key 获取指定 key 的值。

GETRANGE key start end 返回 key 中字符串值的子字符

GETSET key value 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。

GETBIT key offset 对 key 所储存的字符串值，获取指定偏移量上的位(bit)。

MGET key1 [key2..] 获取所有(一个或多个)给定 key 的值。

SETBIT key offset value 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)。

SETEX key seconds value 将值 value 关联到 key ，并将 key 的过期时间设为 seconds (以秒为单位)。

SETNX key value 只有在 key 不存在时设置 key 的值。

SETRANGE key offset value 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始。

STRLEN key 返回 key 所储存的字符串值的长度。

MSET key value [key value ...] 同时设置一个或多个 key-value 对。

MSETNX key value [key value ...] 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。

PSETEX key milliseconds value 这个命令和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，而不是像 SETEX 命令那样，以秒为单位。

INCR key 将 key 中储存的数字值增一。

INCRBY key increment 将 key 所储存的值加上给定的增量值（increment）。

INCRBYFLOAT key increment 将 key 所储存的值加上给定的浮点增量值（increment）。

DECR key 将 key 中储存的数字值减一。

DECRBY key decrement key 所储存的值减去给定的减量值（decrement） 。

APPEND key value 如果 key 已经存在并且是一个字符串， APPEND 命令将指定的 value 追加到该 key 原 来值（value）的末尾。

应用举例

缓存热门图片

set redis-log.jpg redis-log-data

存储文章

当用户想在博客中撰写一篇新文章的时候，程序就需要把文章的标题、内容、作者、发表时间等多项信息存储起来，并在用户阅读文章的时候取出来这些信息。可以使用 mset mget msetnx 命令来进行。

文章数据存储示例：

被存储的内容	数据库中的键	键的值
文章的标题	article:10086:title	‘message’
文章的内容	article:10086:content	‘hello world’
文章的作者	article:10086:author	‘darren’
文章创建的时间戳	article:10086:create_at	‘1590216574.123456“

文章长度计数功能、文章摘要、文章计数：

文章长度： STRLEN article:10086:content
文章摘要： GETRANGE article:10086:content 0 5
文章阅读计数： INCR article:10086:count

消息 ID

即时通讯的消息 ID： INCR msgid:darren:to:king

限速器

        防止网站内容被网络爬虫疯狂抓取，限制每个 ip 地址在固定的时间段内能够访问的页面数量，比如1 分钟最多只能访问 30 个页面。

        防止用户的账号遭到暴力破解，如果同个账号连续好几次输入错误的密码，则限制账号的登录，只能等 30 分钟后再次登录，比如设置 3 次

（1） SET max:execute:times 3
（2） 密码出错时 DECR max:execute:times
（3）当 max:execute:times 的值小于 0 时则禁止登录，并可以设置
SETEX login:error:darren 1800 "Incorrect password"
然后使用 TTL login:error:darren 1800 检测对应剩余的时间

重点回顾

• 字符串的值既可以存储文字数据，又可以存储二进制数据。
• MSET/MGET 命令可以有效地减少程序的网络通信次数，从而提高程序的执行效率。
• redis 用户可以定制命名格式来提升 redis 数据的可读性并避免键名冲突。

Hash: 散列表

Redis hash 是一个 string 类型的 field 和 value 的映射表， hash 特别适合用于存储对象。 Redis 中每个hash 可以存储 232 - 1 键值对（40 多亿）。 案例如下：

127.0.0.1:6379> hmset xiaohun name "redis tutorial" likes 20 visitors 23000
OK
127.0.0.1:6379> hgetall xiaohun
1) "name"
2) "redis tutorial"
3) "likes"
4) "20"
5) "visitors"
6) "23000"

命令

HDEL key field1 [field2] 删除一个或多个哈希表字段

HEXISTS key field 查看哈希表 key 中，指定的字段是否存在。

HGET key field 获取存储在哈希表中指定字段的值。

HGETALL key 获取在哈希表中指定 key 的所有字段和值

HINCRBY key field increment 为哈希表 key 中的指定字段的整数值加上增量 increment 。

HINCRBYFLOAT key field increment 为哈希表 key 中的指定字段的浮点数值加上增量 increment 。

HKEYS key 获取所有哈希表中的字段

HLEN key 获取哈希表中字段的数量

HMGET key field1 [field2] 获取所有给定字段的值

HMSET key field1 value1 [field2 value2 ] 同时将多个 field-value (域-值)对设置到哈希表 key 中。

HSET key field value 将哈希表 key 中的字段 field 的值设为 value 。

HSETNX key field value 只有在字段 field 不存在时，设置哈希表字段的值。

HVALS key 获取哈希表中所有值

HSCAN key cursor [MATCH pattern] [COUNT count] 迭代哈希表中的键值对。

应用举例

短网址生成程序

key	field	value
http://suo.im/5SzHAw	link	https://ke.qq.com/?tuin=1b271
	count	1

 

此时我们可以根据该短链接查询到具体的源网址，并记录点击次数

使用散列表重新实现文章存储 

key	field	value
article:10086	title	‘message’
	content	‘hello world’
	author	‘darren’
	create_at	‘1590216574.123456’

散列表和字符串对比

字符串命令与类似散列的命令

字符串	散列
SET 为一个字符串键设置值	HSET 为散列的给定字段设置值
SETNX 仅在字符串键不存在的情况下为它设 置值	HSETNX 仅在不包含指定字段的情况下设置 值
GET 获取字符串键的值	HGET 从散列中获取给定字段的值
STRLEN 获取字符串值的字节长度	HSTRLEN 获取给定字段值的字节长度
INCRBY 对字符串键存储的数值进行整数加法 操作	HINCRBY 对字段存储的数值进行整数加法操 作
INCRBYFLOAT 对字符串键存储的数值进行浮 点数加法操作	HINCRBYFLOAT 对字段存储的数值进行浮点 数加法操作

散列键的优点
散列的最大优势，只需要在数据库里面创建一个键，就可以把任意多的字段和值存储到散列里面。

使用字符串键和散列键存储相同数量的数据项的区别

字符串键的优点

字符串的功能更丰富
虽然散列键命令和字符串键命令在部分功能上有重合的地方，但是字符串键命令提供的操作比散列键命令更为丰富。比如，字符串能够使用 SETRANGE 命令和 GETRANGE 命令设置或者读取字符串值的其中一部分，或者使用 APPEND 命令将新内容追加到字符串值的末尾，而散列键并不支持这些操作。

再比如我们要设置键过期时间，键过期时间是针对整个键的，用户无法为散列中的不同字段设置不同的过期时间， 所以当一个散列键过期的时候，他包含的所有字段和值都会被删除。 与此相反，如果用户使用字符串键存储信息项，就不会遇到这样的问题——用户可以为每个字符串键分别设置不同的过期时间，让它们根据实际的需要自动被删除。

字符串键和散列键的选择

比较的范畴	结果
资源占用	字符串键在数量较多的情况下，将占用大量的内存和 cpu 时间。与此相 反，将多个数据项存储到同一个散列中可以有效地减少内存和 cpu 消 耗。
支持的操作	散列键支持的所有命令，几乎都有对应的字符串键版本，但字符串键支 持的 SETRANGE、 GETRANGE、 APPEND 等操作散列并不具备。
过期时间	字符串可以为单个键单独设置过期时间，独立删除某个数据项，而散列 一旦到期，它包含的所有字段和值都会被删除。

适用场景对比：

• 如果程序需要为单个数据项单独设置过期的时间，那么使用字符串键。
• 如果程序需要对数据项执行诸如 SETRANGE、 GETRANGE 或者 APPEND 等操作，那么优先考虑使用字符串键。当然，用户也可以选择把数据存储在散列中，然后将类似 SETRANGE、 GETRANGE 这样的操作交给客户端执行。
• 如果程序需要存储的数据项比较多，并且你希望尽可能地减少存储数据所需的内存，就应该优先考虑使用散列键。
• 如果多个数据项在逻辑上属于同一组或者同一类，那么应该优先考虑使用散列键。

List: 列表

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过 40 亿个元素)。

实例：

127.0.0.1:6379> lpush listkey redis
(integer) 1
127.0.0.1:6379> lpush listkey memcached
(integer) 2
127.0.0.1:6379> lpush listkey mongodb
(integer) 3
127.0.0.1:6379> lpush listkey mysql
(integer) 4
127.0.0.1:6379> lrange listkey 0 10
1) "mysql"
2) "mongodb"
3) "memcached"
4) "redis"

命令

BLPOP key1 [key2 ] timeout 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可 弹出元素为止。

BRPOP key1 [key2 ] timeout 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现 可弹出元素为止。

BRPOPLPUSH source destination timeout 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有 元素会阻塞列表直到等待超时或发现可弹出元素为止。

LINDEX key index 通过索引获取列表中的元素

LINSERT key BEFORE|AFTER pivot value 在列表的元素前或者后插入元素

LLEN key 获取列表长度

LPOP key 移出并获取列表的第一个元素

LPUSH key value1 [value2] 将一个或多个值插入到列表头部

LPUSHX key value 将一个值插入到已存在的列表头部

LRANGE key start stop 获取列表指定范围内的元素

LREM key count value 移除列表元素

LSET key index value 通过索引设置列表元素的值

LTRIM key start stop 对一个列表进行修剪(trim)，就是说，让列表只保留指定区间内的元素，不在指定区间 之内的元素都将被删除。

RPOP key 移除列表的最后一个元素，返回值为移除的元素。

RPOPLPUSH source destination 移除列表的最后一个元素，并将该元素添加到另一个列表并返回

RPUSH key value1 [value2] 在列表中添加一个或多个值

RPUSHX key value 为已存在的列表添加值

应用举例

先进先出队列

秒杀活动， 把用户的购买操作都放入先进先出队列里面，然后以队列方式处理用户的购买操作。

分页功能

对于互联网上每一个具有一定规模的网站来说，分页程序都是必不可少的：新闻站点、博客、论坛、搜索引擎等，都会使用分页程序将数量众多的信息分割为多个页面，使得用户可以以页为单位浏览网站提供的信息，并以此来控制网站每次取出的信息数量。

比如实现简易微信朋友圈的分页：
Darkin(100)老师关注了 xiaohong， xiaoli，他们发朋友圈后，对应的消息 id 也 push 到Darkin的队列

(1) xiaohong 发朋友圈，消息 id 为 1000
LPUSH msg:{Darkin-id} 1000

(2) xiaoli 发朋友圈，消息 id 为 1010
LPUSH msg:{Darkin-id} 1010

(3) Darkin老师查看最新的朋友圈
LRANGE msg:{Darkin-id} 0 5

分页功能 数据最好是不能修改

Set: 集合

Redis 的 Set 是 String 类型的无序集合。 集合成员是唯一的，这就意味着集合中不能出现重复的数据。 Redis 中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储 40 多亿个成员)。
实例：

127.0.0.1:6379> sadd setkey redis
(integer) 1
127.0.0.1:6379> sadd setkey mongodb
(integer) 1
127.0.0.1:6379> sadd setkey mysql
(integer) 1
127.0.0.1:6379> sadd setkey memcached
(integer) 1
127.0.0.1:6379> sadd setkey memcached
(integer) 0
127.0.0.1:6379> smembers setkey 
1) "memcached"
2) "mysql"
3) "mongodb"
4) "redis"

命令 

SADD key member1 [member2] 向集合添加一个或多个成员

SCARD key 获取集合的成员数

SDIFF key1 [key2] 返回给定所有集合的差集

SDIFFSTORE destination key1 [key2] 返回给定所有集合的差集并存储在 destination 中

SINTER key1 [key2] 返回给定所有集合的交集

SINTERSTORE destination key1 [key2] 返回给定所有集合的交集并存储在 destination 中

SISMEMBER key member 判断 member 元素是否是集合 key 的成员

SMEMBERS key 返回集合中的所有成员

SMOVE source destination member 将 member 元素从 source 集合移动到 destination 集合

SPOP key 移除并返回集合中的一个随机元素

SRANDMEMBER key [count] 返回集合中一个或多个随机数

SREM key member1 [member2] 移除集合中一个或多个成员

SUNION key1 [key2] 返回所有给定集合的并集

SUNIONSTORE destination key1 [key2]

SSCAN key cursor [MATCH pattern] [COUNT count] 迭代集合中的元素

应用举例

唯一计数器

举个例子，一个网站的受欢迎程度通常可以用浏览量和用户数量这两个指标进行描述：

        浏览量记录的是网站页面被用户访问的总次数，网站的每个用户都可以重复地对同一个页面进行多次访问，而这些访问会被浏览量计数器一个不漏地记下来。用户数量记录的是访问网站的 IP 地址数量，即使同一个 IP 地址多次访问相同的页面， 用户数量计数器也只会对这个 IP 地址进行一次计数。

        网站浏览量可以使用字符串键是的计数器进行计数，但想要记录网站的用户数量，就需要构建一个新的计数器，可以用 SET 集合。

加入 IP：       SADD users:count 202.177.2.232
计算总数：      SCARD users:count

朋友圈点赞

(1)点赞
sadd like:{消息 Id} {点赞用户 Id}

(2) 取消点赞
srem like:{消息 Id} {点赞用户 Id}

(3) 检查用户是否点过赞
sismember like:{消息 Id} {点赞用户 Id}

(4) 获取点赞用户列表
smembers like:{消息 Id}

(5) 获取点赞用户数量
scard like:{消息 Id}

共同关注和推荐关注

集合操作
(1) 交集
sinter set1 set2 set3 -> {c}
(2) 并集
sunion set1 set2 set3 -> {a,b,c,d,e}
(3) 差集
sdiff set1 set2 set3 -> {a}

集合实现微博/微信关注模型
(1) Draking 关注的人
sadd DrakingSet xiaohong lee king
(2) xiaohong 关注的人
sadd xiaohongSet Draking ting lee king
(3) king 关注的人
sadd kingSet xiaohong Draking ting buding
(4) 我和 xiaohong 共同关注（交集）：
sinter DrakingSet xiaohongSet - {lee,king}
(5) 我关注的人是否也关注他(king)
sismember xiaohongSet king
(6) 我可能认识的人(钉钉 脉脉)：
sdiff xiaohongSet DrakingSet - {Draking, ting}

投票

问答网站、文章推荐网站、论坛这类注重内容质量的网站上通常都会提供投票功能，用户可以通过投票来支持一项内容或者反对一项内容：

• 一项内容获得的支持票数越多，就会被网站安排到越明显的位置，使得网站的用户可以更快速地浏览到高质量的内容。
• 与此相反，一项内容获得的反对票数越多，它就会被网站安排到越不明显的位置，甚至被当作广告或者无用内容隐藏起来，使得用户可以忽略这些低质量的内容。

赞同的时候将用户 SADD 到赞同集合，并将用户从反对集合删除 SREM。

抽奖

微信抽奖小程序：
(1) 点击参与抽奖加入集合
sadd key {userId}
(2) 查看参与抽奖所有用户;
smembers key
(3) 抽取 n 名中奖者
srandmember key [n]
或 spop key [n]

Sorted Set(zset): 有序集合

有序集合，目的是排序功能
        Redis 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联一个 double 类型的分数。 redis 正是通过分数来为集合中的成员进行从小到大的排序。有序集合的成员是唯一的,但分数(score)却可以重复。集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是 O(1)。 集合中最大的成员数为 2^32 - 1 (4294967295, 每个集合可存储 40多亿个成员)。

实例

127.0.0.1:6379> zadd zerokey 1 redis
(integer) 1
127.0.0.1:6379> zadd zerokey 2 mongodb
(integer) 1
127.0.0.1:6379> zadd zerokey 3 memcached
(integer) 1
127.0.0.1:6379> zrange zerokey 0 10
1) "redis"
2) "mongodb"
3) "memcached"
127.0.0.1:6379> zadd zerokey 4 mysql
(integer) 1
127.0.0.1:6379> zrange zerokey 0 10 withscores
1) "redis"
2) "1"
3) "mongodb"
4) "2"
5) "memcached"
6) "3"
7) "mysql"
8) "4"

命令

ZADD key score1 member1 [score2 member2] 向有序集合添加一个或多个成员，或者更新已存在成员的分数

ZCARD key 获取有序集合的成员数

ZCOUNT key min max 计算在有序集合中指定区间分数的成员数

ZINCRBY key increment member 有序集合中对指定成员的分数加上增量 increment

ZINTERSTORE destination numkeys key [key ...] 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中

ZLEXCOUNT key min max 在有序集合中计算指定字典区间内成员数量

ZRANGE key start stop [WITHSCORES] 通过索引区间返回有序集合成指定区间内的成员

ZRANGEBYLEX key min max [LIMIT offset count] 通过字典区间返回有序集合的成员

ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT] 通过分数返回有序集合指定区间内的成员

ZRANK key member 返回有序集合中指定成员的索引

ZREM key member [member ...] 移除有序集合中的一个或多个成员

ZREMRANGEBYLEX key min max 移除有序集合中给定的字典区间的所有成员

ZREMRANGEBYRANK key start stop 移除有序集合中给定的排名区间的所有成员

ZREMRANGEBYSCORE key min max 移除有序集合中给定的分数区间的所有成员

ZREVRANGE key start stop [WITHSCORES] 返回有序集中指定区间内的成员，通过索引，分数从高到底

ZREVRANGEBYSCORE key max min [WITHSCORES] 返回有序集中指定分数区间内的成员，分数从高到低排序

ZREVRANK key member 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序

ZSCORE key member 返回有序集中， 成员的分数值

ZUNIONSTORE destination numkeys key [key ...] 计算给定的一个或多个有序集的并集，并存储在新的 key 中

ZSCAN key cursor [MATCH pattern] [COUNT count] 迭代有序集合中的元素（包括元素成员和元素分值）

应用举例

排行榜，实现微博热搜

(1) 点击新闻（今天热搜）
zincrby hotNews:20190802 1 NASA
(2) 展示当日前 10
zrevrange hotNews:20190802 0 9 WITHSCORES
(3) 三天热搜榜单统计
zunionstore hotNews:20190731-20190802 3 hotNews:20190731 hotNews:20190801 hotNews:20190802
(4) 展示三天排行前 10
zrevrange hotNews:20190731-20190802 0 10 WITHSCORES

时间线

在互联网上，有很多网站都会根据内容的发布时间来对内容进行排序，比如：

• 博客系统会按照文章发布时间的先后，把最近发布的文章放在前面，而发布时间较早的文章则放在后面，这样访客在浏览博客的时候，就可以先阅读最新的文章，然后再阅读较早的文章。
• 新闻网站会按照新闻的发布时间，把最近发生的新闻放在网站的前面，而早前发生的新闻则放在网站的后面，这样当用户访问该网站的时候，就可以第一时间查看到最新的新闻报道。
• 诸如微博和 Twitter 这样的微博客都会把用户最新发布的消息放在页面的前面，而稍早之前发布的消息则放在页面的后面，这样用户就可以通过向后滚动网页，查看最近一段时间自己关注的人都发表了哪些动态。

三． 操作命令

---

Redis HyperLogLog

        Redis 在 2.8.9 版本添加了 HyperLogLog 结构。 Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的并且是很小的。在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。但是，因为 HyperLogLog 只会根据输入元素来计算基数， 而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。

实例：

127.0.0.1:6379> pfadd kingpfkey "redis"
(integer) 1
127.0.0.1:6379> pfadd kingpfkey "mongodb"
(integer) 1
127.0.0.1:6379> pfadd kingpfkey "mysql"
(integer) 1
127.0.0.1:6379> pfcount kingpfkey
(integer) 3

命令：

PFADD key element [element ...] 添加指定元素到 HyperLogLog 中。

PFCOUNT key [key ...] 返回给定 HyperLogLog 的基数估算值。

PFMERGE destkey sourcekey [sourcekey ...] 将多个 HyperLogLog 合并为一个 HyperLogLog

Redis 发布订阅

        Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。 Redis 客户端可以订阅任意数量的频道。下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

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

 

实例

实例中我们创建了订阅频道名为 redisChat

Subscribe 客户端 1

127.0.0.1:6379> subscribe redisChat
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1
1) "message"
2) "redisChat"
3) "Redis is a great caching technique"
1) "message"
2) "redisChat"
3) "Think you"

另外开启一个 redis 客户端， Subscribe 客户端 2

127.0.0.1:6379> subscribe redisChat
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1
1) "message"
2) "redisChat"
3) "Think you"

开启 Publish 客户端

127.0.0.1:6379> publish redisChat "Redis is a great caching technique"
(integer) 1
127.0.0.1:6379> publish redisChat "Think you"
(integer) 2
127.0.0.1:6379>

命令

PSUBSCRIBE pattern [pattern ...] 订阅一个或多个符合给定模式的频道。

PUBSUB subcommand [argument [argument ...]] 查看订阅与发布系统状态。

PUBLISH channel message 将信息发送到指定的频道。

PUNSUBSCRIBE [pattern [pattern ...]] 退订所有给定模式的频道。

SUBSCRIBE channel [channel ...] 订阅给定的一个或多个频道的信息。

UNSUBSCRIBE [channel [channel ...]] 指退订给定的频道。

和 list 消息队列的区别

• list 通过 key 队列方式实现，取出就删掉了，其他进程也取不到，阻塞进程。订阅发布可以支持多客户端获取同一个频道发布的消息。
• list 消息不处理会缓存在列表，发布订阅不处理的话消息就丢失了。
   

Redis 事务

Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：

• 批量操作在发送 EXEC 命令前被放入队列缓存。
• 收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
• 在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

一个事务从开始到执行会经历以下三个阶段：

1.  开始事务。
2.  命令入队。
3.  执行事务。

实例

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set bookname "mastering c++"
QUEUED
127.0.0.1:6379> set bookname "redis class"
QUEUED
127.0.0.1:6379> get bookname
QUEUED
127.0.0.1:6379> sadd tag "c++" "Programming" "Mastering Serires"
QUEUED
127.0.0.1:6379> smembers tag
QUEUED
127.0.0.1:6379> exec
1) OK
2) OK
3) "redis class"
4) (integer) 3
5)  1) "c++"
    2) "Mastering Serires"
    3) "Programming"
127.0.0.1:6379>

命令

DISCARD 取消事务，放弃执行事务块内的所有命令。

EXEC 执行所有事务块内的命令。

MULTI 标记一个事务块的开始。

UNWATCH 取消 WATCH 命令对所有 key 的监视。

WATCH key [key ...] 监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动， 那么事务将被打断。

事务对服务器的影响

因为事务在执行时会独占服务器，所以用户应该避免在事务中执行过多命令，更不要将一些需要进行大量计算的命令放入事务中，以免造成服务器阻塞。

Redis 脚本

        Redis 脚本使用 Lua 解释器来执行脚本。 Redis 2.6 版本通过内嵌支持 Lua 环境。执行脚本的常用命令为 EVAL。

redis 127.0.0.1:6379> EVAL script numkeys key [key ...] arg [arg ...]

实例

redis 127.0.0.1:6379> EVAL "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 first second

1) "key1"
2) "key2"
3) "first"
4) "second"

命令

EVAL script numkeys key [key ...] arg [arg ...] 执行 Lua 脚本。

EVALSHA sha1 numkeys key [key ...] arg [arg ...] 执行 Lua 脚本。

SCRIPT EXISTS script [script ...] 查看指定的脚本是否已经被保存在缓存当中。

SCRIPT FLUSH 从脚本缓存中移除所有脚本。

SCRIPT KILL 杀死当前正在运行的 Lua 脚本。

SCRIPT LOAD script 将脚本 script 添加到脚本缓存中，但并不立即执行这个脚本。

Redis 安全

        我们可以通过 redis 的配置文件设置密码参数，这样客户端连接到 redis 服务就需要密码验证，这样可以让你的 redis 服务更安全。通过以下命令查看是否设置了密码验证：

127.0.0.1:6379> CONFIG get requirepass
1) "requirepass"
2) ""

        默认情况下 requirepass 参数是空的，这就意味着你无需通过密码验证就可以连接到 redis 服务。通过以下命令来修改该参数：

127.0.0.1:6379> CONFIG set requirepass "123456"
OK
127.0.0.1:6379> CONFIG get requirepass
1) "requirepass"
2) "123456"

        设置密码后，客户端连接 redis 服务就需要密码验证，否则无法执行命令。AUTH 命令基本语法格式如下：

127.0.0.1:6379> AUTH password
127.0.0.1:6379> AUTH "123456"
OK
127.0.0.1:6379> SET mykey "Test value"
OK
127.0.0.1:6379> GET mykey
"Test value"

Redis 数据备份与恢复

两种方式：RDB 和 AOF

SAVE 阻塞方式创建 RDB

Redis SAVE 命令用于创建当前数据库的备份。redis Save 命令基本语法如下：
 

127.0.0.1:6379> SAVE

实例

127.0.0.1:6379> SAVE
OK

        该命令将在 redis 安装目录中创建 dump.rdb 文件（具体目录执行命令： CONFIG GET dir 获取）。接收到 SAVE 命令的 Redis 服务器将遍历数据库包含的所有数据库，并将各个数据库包含的键值对全部记录到 RDB 文件中。在 SAVE 命令执行期间， Redis 服务器将阻塞，直到 RDB 文件创建完毕为止。如果 Redis 服务器在执行 SAVE 命令时已经拥有了相应的 RDB 文件，那么服务器将使用新创建的 RDB 文件代替已有的 RDB 文件。

恢复数据

如果需要恢复数据，只需将备份文件 (dump.rdb) 移动到 redis 安装目录并启动服务即可。获取redis 目录可以使用 CONFIG 命令，如下所示：

127.0.0.1:6379> CONFIG GET dir
1) "dir"
2) "/usr/local/redis/bin"

Bgsave 非阻塞方式创建 RDB

创建 redis 备份文件也可以使用命令 BGSAVE，该命令在后台执行。

127.0.0.1:6379> BGSAVE
Background saving started

通过配置选项自动创建 RDB 文件

用户除了可以使用 SAVE 命令和 BGSAVE 命令手动创建 RDB 文件之外，还可以通过在配置文件中设置 save 选项，让 Redis 服务器在满足指定条件时自动执行 BGSAVE 命令：

save <seconds> <changes>

save 选项接受 seconds 和 changes 两个参数，前者用于指定触发持久化操作所需的时长，而后者则用于指定触发持久化操作所需的修改次数。简单来说，如果服务器在 seconds 秒之内，对其包含的各个数据库总共执行了至少 changes 次修改，那么服务器将自动执行一次 BGSAVE 命令。
比如，如果我们向服务器提供以下选项：

save 60 10000

那么当“服务器在 60s 秒之内至少执行了 10000 次修改”这一条件被满足时，服务器就会自动执行一次 BGSAVE 命令。

同时使用多个 save 选项
        Redis 允许用户同时向服务器提供多个 save 选项，当给定选项中的任意一个条件被满足时，服务器就会执行一次 BGSAVE。比如，如果我们向服务器提供以下选项：
save 6000 1
save 600 100
save 60 10000

那么当以下任意一个条件被满足时，服务器就会执行一次 BGSAVE 命令：

• 在 6000s（100min）之内，服务器对数据库执行了至少 1 次修改。
• 在 600s（10min）之内，服务器对数据库执行了至少 100 次修改。
• 在 60s（1min）之内，服务器对数据库执行了至少 10000 次修改。

        注意，为了避免由于同时使用多个触发条件而导致服务器过于频繁地执行 BGSAVE 命令， Redis 服务器在每次成功创建 RDB 文件之后，负责自动触发 BGSAVE 命令的时间计数器以及修改次数计数器都会被清零并重新开始计数：无论这个 RDB 文件是由自动触发的 BGSAVE 命令创建的，还是由用户执行的 SAVE 命令或 BGSAVE 命令创建的，都是如此。

默认设置
RDB 持久化是 Redis 默认使用的持久化方式，如果用户在启动 Redis 服务器时，既没有显式地关闭RDB 持久化功能，也没有启用 AOF 持久化功能，那么 Redis 默认将使用以下 save 选项进行 RDB 持久化：

save 60 10000
save 300 100
save 3600 1

SAVE 命令和 BGSAVE 命令的选择

        因为 SAVE 命令在创建 RDB 文件期间会阻塞 Redis 服务器，所以如果我们需要在创建 RDB 文件的同时让 Redis 服务器继续为其他客户端服务，那么就只能使用 BGSAVE 命令来创建 RDB 文件。
        因为 SAVE 命令无须创建子进程，它不会因为创建子进程而消耗额外的内存，所以在维护离线的Redis 服务器时，使用 SAVE 命令能够比使用 BGSAVE 命令更快地完成创建 RDB 文件的工作。

AOF持久化

        AOF持久化是通过保存Redis服务器所执行的写命令来记录数据库状态，也就是每当 Redis 执行一个改变数命令时（比如 SET）， 这个命令就会被追加到 AOF 文件的末尾据集的。

开启AOF持久化

修改redis.conf配置文件，默认是appendonly no（关闭状态），将no改为yes即可

appendonly yes

也可以在客户端输入如下命令，但是Redis服务器重启后会失效

192.168.17.101:6379> config set appendonly yes
OK

实现

AOF持久化功能的实现可以分为命令追加（append）、文件写入和文件同步（sync）三个步骤。下面就是三个步骤的整个过程。在Redis客户端输入如下命令：

192.168.17.101:6379> set redis testAOF
OK

appendonly.aof文件会增加如下内容

*2
$6
SELECT
$1
0
*3
$3
set
$10
redis
$7
testAOF

命令追加

        AOF持久化功能开启时，服务器在执行完一个写命令之后，会以协议格式将被执行的写命令追加到服务器状态的aof_buf缓冲区的末尾。此时缓冲区的记录还没有写入到appendonly.aof文件中。

文件的写入和同步

配置文件中提供了一个appendfsync参数，这个参数控制着文件写入和同步的行为。关于文件的写入和同步的资料如下:

        因为为了提高文件的写入效率，在现代操作系统中，当用户调用write函数，将一些数据写入到文件的时候，os通常会将写入数据暂时保存在一个内存缓冲区里面（例如，unix系统实现在内核中设有缓冲区高速缓存或页高速缓存，当我们向文件写入数据时，内核通常先将数据复制到缓冲区中，然后排入队列，晚些时候再写入磁盘），这种方式称为延迟写，等到缓冲区的空间被填满，或者超过了指定的时限，或者内核需要重用缓冲区存放其它磁盘块数据时，才会真正将缓冲区中的所有数据写入到磁盘里面。

概括的意思就是：

文件写入：只是写入到了内存缓冲区，可能还没有写到文件所拥有的磁盘数据块上
文件同步：将缓冲区中的内容冲洗到磁盘上

appendfsync参数： 

appendfsync选项的值	效果
always	每次有新命令时，就将缓冲区数据写入并同步到 AOF 文件
everysec（默认）	每秒将缓冲区的数据写入并同步到 AOF 文件
no	将缓冲区数据写入AOF 文件，但是同步操作到交给操作系统来处理

载入与数据还原:

读取AOF文件并还原数据库的步骤如下

1. 创建一个不带网络连接的伪客户端
2. 从AOF文件中分析并读取出一条写命令
3. 使用伪客户端执行被读出的写命令
4. 一直执行步骤2、3，知道AOF文件中的所有写命令都被处理完毕为止

        这时可能会出现一个问题。服务器可能在程序正在对 AOF 文件进行写入时停机，造成了AOF 文件出错，那么 Redis 在重启时会拒绝载入这个 AOF 文件，从而确保数据的一致性不会被破坏，当发生这种情况时， 可以用以下方法来修复出错的 AOF 文件：

• 在还原之前为AOF 文件创建一个备份。
• 使用 Redis 附带的 redis-check-aof 程序，对原来的 AOF 文件进行修复: redis-check-aof –fix
• （可选）使用 diff -u 对比修复后的 AOF 文件和原始 AOF 文件的备份，查看两个文件之间的不同之处。
• 重启 Redis 服务器，等待服务器载入修复后的 AOF 文件，并进行数据恢复。

另外redis.conf配置文件中还提供了一个参数来控制是否忽略最后一条可能存在问题的指令，如下：

aof-load-truncated yes

重写

        由于AOF 持久化是通过不断地将命令追加到文件的末尾来记录数据库状态的， 所以随着写入命令的不断增加， AOF 文件的体积也会变得越来越大。 且有些命令是改变同一数据，是可以合并成一条命令的。就好比对一个计数器调用了 100 次 INCR，AOF就会存入100 条记录，其实存入一条数据就可以了。为了处理这种情况，Redis提供了AOF重写机制。

AOF重写机制的触发有两种机制，一个是通过调用命令BGREWRITEAOF

192.168.17.101:6379> BGREWRITEAOF
Background append only file rewriting started

另一种是根据配置文件中的参数触发，参数如下

auto-aof-rewrite-percentage 100 #当前AOF文件大小和上一次重写时AOF文件大小的比值
auto-aof-rewrite-min-size 64mb  #文件的最小体积

服务端会出现如下信息：

1349:M 30 Jul 17:19:25.311 * Background append only file rewriting started by pid 1392
1349:M 30 Jul 17:19:25.379 * AOF rewrite child asks to stop sending diffs.
1392:C 30 Jul 17:19:25.379 * Parent agreed to stop sending diffs. Finalizing AOF...
1392:C 30 Jul 17:19:25.380 * Concatenating 0.00 MB of AOF diff received from parent.
1392:C 30 Jul 17:19:25.380 * SYNC append only file rewrite performed
1392:C 30 Jul 17:19:25.381 * AOF rewrite: 4 MB of memory used by copy-on-write
1349:M 30 Jul 17:19:25.466 * Background AOF rewrite terminated with success
1349:M 30 Jul 17:19:25.467 * Residual parent diff successfully flushed to the rewritten AOF (0.00 MB)
1349:M 30 Jul 17:19:25.467 * Background AOF rewrite finished successfully

重写步骤：

1. 创建子进程进行AOF重写
2. 将客户端的写命令追加到AOF重写缓冲区
3. 子进程完成AOF重写工作后，会向父进程发送一个信号
4. 父进程接收到信号后，将AOF重写缓冲区的所有内容写入到新AOF文件中
5. 对新的AOF文件进行改名，原子的覆盖现有的AOF文件

注：AOF重写不需要对现有的AOF文件进行任何读取、分析和写入操作。

配置

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

# 是否开启AOF功能
appendonly no

# AOF文件件名称
appendfilename "appendonly.aof"

# 写入AOF文件的三种方式
# appendfsync always
appendfsync everysec
# appendfsync no

# 重写AOF时，是否继续写AOF文件
no-appendfsync-on-rewrite no

# 自动重写AOF文件的条件
auto-aof-rewrite-percentage 100 #百分比
auto-aof-rewrite-min-size 64mb #大小

# 是否忽略最后一条可能存在问题的指令
aof-load-truncated yes

优点

• 使用AOF 会让你的Redis更加持久化
• AOF文件是一个只进行追加的日志文件，不需要在写入时读取文件。
• Redis 可以在 AOF 文件体积变得过大时，自动地在后台对 AOF 进行重写 。
• AOF文件可读性高，分析容易

缺点

• 对于相同的数据来说，AOF 文件大小通常要大于 RDB 文件
• 根据所使用的 fsync 策略，AOF 的速度可能会慢于 RDB

RDB和AOF都是在启动时加载的，AOF开启时，会优先从AOF文件从恢复数据 ，AOF关闭时才会从RDB文件恢复数据。

Redis 性能测试

Redis 性能测试是通过同时执行多个命令实现的。redis 性能测试的基本命令如下：

redis-benchmark [option] [option value]

注意：该命令是在 redis 的目录下执行的，而不是 redis 客户端的内部指令。

以下实例同时执行 10000 个请求来检测性能：

$ ./redis-benchmark -n 10000 -q
PING_INLINE: 78740.16 requests per second
PING_BULK: 76335.88 requests per second
SET: 77519.38 requests per second
GET: 83333.34 requests per second
INCR: 84033.61 requests per second
LPUSH: 70422.53 requests per second
RPUSH: 80000.00 requests per second
LPOP: 76923.08 requests per second
RPOP: 85470.09 requests per second
SADD: 78125.00 requests per second
HSET: 86206.90 requests per second
SPOP: 80000.00 requests per second
LPUSH (needed to benchmark LRANGE): 78740.16 requests per second
LRANGE_100 (first 100 elements): 71942.45 requests per second
LRANGE_300 (first 300 elements): 81967.21 requests per second
LRANGE_500 (first 450 elements): 83333.34 requests per second
LRANGE_600 (first 600 elements): 83333.34 requests per second
MSET (10 keys): 64102.56 requests per second

参数

-h	指定服务器主机名	127.0.0.1
-p	指定服务器端口	6379
-s	指定服务器 socket
-c	指定并发连接数	50
-n	指定请求数	10000
-d	以字节的形式指定 SET/GET 值的数据大小	2
-k	1=keep alive 0=reconnect	1
-r	SET/GET/INCR 使用随机 key, SADD 使用随机值
-P	通过管道传输 <numreq> 请求	1
-q	强制退出 redis。仅显示 query/sec 值
--csv	以 CSV 格式输出
-l	生成循环，永久执行测试
-t	仅运行以逗号分隔的测试命令列表
-I	Idle 模式。仅打开 N 个 idle 连接并等待。

以下实例我们使用了多个参数来测试 redis 性能：

$ redis-benchmark -h 127.0.0.1 -p 6379 -t set,lpush -n 10000 -q
SET: 146198.83 requests per second
LPUSH: 145560.41 requests per second

以上实例中主机为 127.0.0.1，端口号为 6379，执行的命令为 set,lpush，请求数为 10000，通
过 -q 参数让结果只显示每秒执行的请求数。

Redis 客户端连接

Redis 通过监听一个 TCP 端口或者 Unix socket 的方式来接收来自客户端的连接，当一个连接建立后， Redis 内部会进行以下一些操作：

1. 客户端 socket 会被设置为非阻塞模式，因为 Redis 在网络事件处理上采用的是非阻塞多路复用模型。
2. 为这个 socket 设置 TCP_NODELAY 属性，禁用 Nagle 算法
3. 创建一个可读的文件事件用于监听这个客户端 socket 的数据发送

最大连接数

在 Redis2.4 中，最大连接数是被直接硬编码在代码里面的，而在 2.6 版本中这个值变成可配置的。 maxclients 的默认值是 10000，你也可以在 redis.conf 中对这个值进行修改。

config get maxclients
1) "maxclients"
2) "10000

以下实例我们在服务启动时设置最大连接数为 100000：

redis-server --maxclients 100000

Redis 管道技术

Redis 是一种基于客户端-服务端模型以及请求/响应协议的 TCP 服务。这意味着通常情况下一个请求会遵循以下步骤：

1. 客户端向服务端发送一个查询请求，并监听 Socket 返回， 通常是以阻塞模式，等待服务端响应。
2. 服务端处理命令，并将结果返回给客户端。

Redis 管道技术可以在服务端未响应时，客户端可以继续向服务端发送请求，并最终一次性读取所有服务端的响应

实例

查看 redis 管道，只需要启动 redis 实例并输入以下命令：

$(echo -en "PING\r\n SET testkey redis\r\nGET testkey\r\nINCR visitor\r\nINCR visitor\r\nINCR visitor\r\n"; sleep 10) | nc localhost 6379
+PONG
+OK
redis
:1
:2
:3

以上实例中我们通过使用 PING 命令查看 redis 服务是否可用， 之后我们设置了 testkey的值为 redis，然后我们获取 testkey的值并使得 visitor 自增 3 次。在返回的结果中我们可以看到这些命令一次性向 redis 服务提交，并最终一次性读取所有服务端的响应

管道技术的优势

管道技术最显著的优势是提高了 redis 服务的性能。
 

Redis 分区

分区是分割数据到多个 Redis 实例的处理过程，因此每个实例只保存 key 的一个子集。

优势

• 通过利用多台计算机内存的和值，允许我们构造更大的数据库。
• 通过多核和多台计算机，允许我们扩展计算能力；通过多台计算机和网络适配器，允许我们扩展网络带宽。

不足

redis 的一些特性在分区方面表现的不是很好：

• 涉及多个 key 的操作通常是不被支持的。举例来说，当两个 set 映射到不同的 redis 实例上时，你就不能对这两个 set 执行交集操作。
• 涉及多个 key 的 redis 事务不能使用。
• 当使用分区时，数据处理较为复杂，比如你需要处理多个 rdb/aof 文件，并且从多个实例和主机备份持久化文件。
• 增加或删除容量也比较复杂。 redis 集群大多数支持在运行时增加、删除节点的透明数据平衡的能力，但是类似于客户端分区、代理等其他系统则不支持这项特性。然而，一种叫做 presharding 的技术对此是有帮助的。

分区类型

        Redis 有两种类型分区。 假设有 4 个 Redis 实例 R0， R1， R2， R3，和类似 user:1， user:2 这样的表示用户的多个 key，对既定的 key 有多种不同方式来选择这个 key 存放在哪个实例中。也就是说，有不同的系统来映射某个 key 到某个 Redis 服务。

范围分区

最简单的分区方式是按范围分区，就是映射一定范围的对象到特定的 Redis 实例。比如， ID 从 0 到 10000 的用户会保存到实例 R0， ID 从 10001 到 20000 的用户会保存到 R1，以此类推。这种方式是可行的，并且在实际中使用，不足就是要有一个区间范围到实例的映射表。这个表要管理，同时还需要各 种对象的映射表，通常对 Redis 来说并非是好的方法。

哈希分区

另外一种分区方法是 hash 分区。这对任何 key 都适用，也无需是 object_name:这种形式，像下面描述的一样简单：

• 用一个 hash 函数将 key 转换为一个数字，比如使用 crc32 hash 函数。对 key foobar 执行 crc32(foobar)会输出类似 93024922 的整数。
• 对这个整数取模，将其转化为 0-3 之间的数字，就可以将这个整数映射到 4 个 Redis 实例中的一个了。 93024922 % 4 = 2，就是说 key foobar 应该被存到 R2 实例中。注意：取模操作是取除的余数，通常在多种编程语言中用%操作符实现。

四． C 语言使用 Redis

编译 hiredis

进入 redis-6.0.3/deps/hiredis
$ make
$ sudo make install

mkdir -p /usr/local/include/hiredis /usr/local/include/hiredis/adapters /usr/local/lib
cp -pPR hiredis.h async.h read.h sds.h /usr/local/include/hiredis
cp -pPR adapters/*.h /usr/local/include/hiredis/adapters
cp -pPR libhiredis.so /usr/local/lib/libhiredis.so.0.14
cd /usr/local/lib && ln -sf libhiredis.so.0.14 libhiredis.so
cp -pPR libhiredis.a /usr/local/lib
mkdir -p /usr/local/lib/pkgconfig
cp -pPR hiredis.pc /usr/local/lib/pkgconfig

可以看到头文件、和库文件的安装目录

连接 Redis 服务

// 连接 Redis 服务
redisContext *context = redisConnect("127.0.0.1", 6379);
    if (context == NULL || context->err) {
    if (context) {
        printf("%s\n", context->errstr);
    } else {
        printf("redisConnect error\n");
    }
    exit(EXIT_FAILURE);
}

授权 Auth

redisReply *reply = redisCommand(context, "auth 0voice");
printf("type : %d\n", reply->type);

if (reply->type == REDIS_REPLY_STATUS) {
    /*SET str Hello World*/
    printf("auth ok\n");
}

freeReplyObject(reply);

redisCommand 详解

原型

void *redisCommand(redisContext *c, const char *format, ...);

参数说明

这个函数是一个带有不定参数的。可以按着 format 格式给出对应的参数，这就和 printf 函数似。
c 是一个 reidsConnect 函数返回的一个对象。 

返回值

返回值是一个 void 类型的指针，实际为指向一个 redisReply 类型的指针。
redisReply 的定义

/* This is the reply object returned by redisCommand() */
typedef struct redisReply {
    /*命令执行结果的返回类型*/
    int type; /* REDIS_REPLY_* */
    /*存储执行结果返回为整数*/
    long long integer; /* The integer when type is REDIS_REPLY_INTEGER */
    /*字符串值的长度*/
    size_t len; /* Length of string */
    /*存储命令执行结果返回是字符串*/
    char *str; /* Used for both REDIS_REPLY_ERROR and REDIS_REPLY_STRING */
    /*返回结果是数组的大小*/
    size_t elements; /* number of elements, for REDIS_REPLY_ARRAY */
    /*存储执行结果返回是数组*/
    struct redisReply **element; /* elements vector for REDIS_REPLY_ARRAY */
} redisReply;

返回结果的类型 reply->type,reply 为 redisReply* 类型。

• REDIS_REPLY_STRING == 1:返回值是字符串,字符串储存在 redis->str 当中,字符串长度为 redis->len。
• REDIS_REPLY_ARRAY == 2：返回值是数组，数组大小存在 redis->elements 里面，数组值存储在 redis->element[i]里面。数组里面存储的是指向 redisReply 的指针，数组里面的返回值可以通过 redis->element[i]->str 来访问，数组的结果里全是type==REDIS_REPLY_STRING 的 redisReply 对象指针。
• REDIS_REPLY_INTEGER == 3：返回值为整数 long long。
• REDIS_REPLY_NIL==4：返回值为空表示执行结果为空。
• REDIS_REPLY_STATUS ==5：返回命令执行的状态，比如 set foo bar 返回的状态为 OK，存储在 str 当中 reply->str == "OK"。
• REDIS_REPLY_ERROR ==6 ：命令执行错误,错误信息存放在 reply->str 当中。

Set Key Value

char *key = "str";
char *val = "Hello World";

/*SET key value */
reply = redisCommand(context, "SET %s %s", key, val);
printf("type : %d\n", reply->type);
if (reply->type == REDIS_REPLY_STATUS) {
    /*SET str Hello World*/
    printf("SET %s %s\n", key, val);
}

freeReplyObject(reply);

Get Key

reply = redisCommand(context, "GET %s", key);
if (reply->type == REDIS_REPLY_STRING) {
    /*GET str Hello World*/
    printf("GET str %s\n", reply->str);
    /*GET len 11*/
    printf("GET len %ld\n", reply->len);
}

freeReplyObject(reply);

APPEND Key Value

char *append = " I am your GOD";
reply = redisCommand(context, "APPEND %s %s", key, append);
if (reply->type == REDIS_REPLY_INTEGER) {
    printf("APPEND %s %s \n", key, append);
}
freeReplyObject(reply);

/*GET key*/
reply = redisCommand(context, "GET %s", key);
if (reply->type == REDIS_REPLY_STRING) {
    //GET Hello World I am your GOD
    printf("GET %s\n", reply->str);
}
freeReplyObject(reply);