Redis API 介绍和使用（上）

预备知识

    1.全局命令

    1.1 查看所有键

        keys  *  命令将所有的键输出。该命令会遍历所有键，所以它的时间复杂度是 O(n)，当 Redis 保存了大量的键时，线上环境禁止使用。

    1.2 键总数

        dbsize 命令会返回当前数据库中键的总数。该命令在计算键总数时不会遍历所有的键，而是直接获取 Redis 内置的键总数变量，所以 dbsize 命令的事件复杂度是 O(1)。

    1.3 检查键是否存在

        exists key  如果键存在就返回 1，反之则返回 0.

    1.4 删除键

        del key  [ key ... ]  这是一个通用命令，无论值是什么数据类型结构，都可以将其删除，而且支持删除多个键。返回结果为成功删除的键的个数，假设删除一个不存在的键，则返回 0。

    1.5 键过期

        expire key seconds  对键添加过期时间，当超过过期时间后，会自动删除键。添加成功返回 1.

        ttl  key  查看键的剩余过期时间，它有 3 种返回值：

            # 大于等于 0 的整数：键剩余的过期时间

            # -1 ：键没设置过期时间

            # -2 ：键不存在

    1.6 键的数据结构类型

        type key  键存在就返回键的数据结构类型，否则返回 none。

    2.数据结构与内部编码

        type 命令时间返回的就是当前键的数据结构类型，但是这些只是 Redis 对外的数据结构。实际上每种数据结构都有自己底层的内部编码实现，可以通过 object encoding key 命令查询键的内部编码。

            # string ：raw、int、embstr

            # hash ：hashtable、ziplist

            # list ： linkedlist、ziplist

            # set ：hashtable、intset

            # zset ：skiplist、ziplist

        Redis 这样设计有两个好处：一是，可以改进内部编码，而对外的数据结构和命令没有影响。例如 Redis 3.2 提供了 quicklist ，结合了ziplist 和 linkedlist 两者的优势，为列表类型提供了一种更优秀的内部编码实现，而对外部用户来说基本感知不到。二是，多种内部编码实现可以在不同场景下发挥各自的优势，例如 ziplist 比较节省内存，但是在列表元素比较多的情况下，性能会有所下降，这时候Redis 会更具配置选项将列表类型的内部实现转为 linkedlist。

    3.单线程架构

        Redis 使用了单线程架构和 I/O 多路复用模型来实现高性能的内存数据库服务。Redis 客户端调用都经历了发送命令、执行命令、返回结果三个过程，执行命令是 Redis 服务端负责的，因为是单线程来处理命令，当多个客户端调用，每条命令到达服务端都会进入一个队列中，然后逐个执行。

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

            第一，纯内存访问，内存的响应时长大约为 100 纳秒，这是Redis 达到每秒万级别访问的重要基础。

            第二，非阻塞 I/O，Redis 使用 epoll 作为 I/O 多路复用技术的实现，再加上 Redis 自身的事件处理模型将 epoll 中的连接、读写、关闭都转换为事件，不在网络 I/O 上浪费过多的时间。

            第三，单线程避免了线程切换和竞态产生的消耗。

        单线程带来的两个好处：一是，可以简化数据结构和算法的实现；二是，避免了线程切换和竞态产生的消耗，对于服务端开发来说，锁和线程切换通常是性能杀手。

        单线程也有一个问题：对于每个命令的执行时间是有要求的。 如果某个命令执行时间过长（如上文查看所有键的情况），会造成其他命令的阻塞，对于 Redis 这种高性能的服务来说是致命的，所以 Redis 是面向快速执行场景的数据库。

字符串

        字符串是Redis 最基础的数据结构，首先键都是字符串类型，而且其他几种数据结构都是在字符串类型基础上构建的。字符串类型的值可以是字符串（简单的字符串、复杂的字符串（如JSON、XML））、数字（整数、浮点数），甚至是二进制（图片、音频、视频），但是值最大不能超过512 MB。

    1.命令

    1.1 设置值

    set key value [ex seconds]  [px milliseconds]  [nx|xx]

        以上可知set 命令有几个选项：

            # ex seconds ：为键设置秒级过期时间；

            # px milliseconds ：为键设置毫秒级过期时间；

            # nx ：键必须不存在才可以设置成功，用于添加；

            # xx ：与 nx 相反，键必须存在才可以设置成功，用于更新；

        Redis 还提供了以下两个命令：

    setex key seconds value

    setnx key value

        set 命令设置成功返回 OK ；setex 命令成功返回 OK；setnx 命令成功返回1，失败返回0。由于 Redis 的单线程命令处理机制，如果有多个客户端执行setnx 命令，setnx 可以作为分布式锁的一种实现方式。

    1.2 获取值

    get key   如果键不存在就返回 nil

    1.3 批量设置值

    mset key value [ key value ... ]    设置成功返回 OK

    1.4 批量获取值

    mget key [ key ... ]   如果有些键不存在，它的返回值为 nil ，结果是按照传入键的顺序返回的

        批量操作可以有效地提高开发效率，减少网络延时。但是要注意每次批量操作所发送的命令数不是无节制的，如果数量过多可能造成 Redis 阻塞或者网络拥塞。

    1.5 计数

        incr key  自增

        decr key  自减

        incrby key  自增指定数字

        decrby key  自减指定数字

        incrbyfloat key  自增浮点数 

        用于对值做自增操作，返回结果分为三种情况：

            # 值不是整数，返回错误；

            # 值是整数，返回自增后的结果；

            # 键不存在，按照值为0自增，返回结果为 1；

    以上都是一些常用的命令，还有一些不常用命令如下：

    1.6 追加值

        append  key  value   向字符串尾部追加值，操作成功返回字符串长度

    1.7 字符串长度

        strlen  key   返回字符串长度，注意一个中文占用三个字节

    1.8 设置并返回原值

        getset  key  value   如果key 不存在就返回 nil ，存在就返回原来的 value

    1.9 设置指定位置的字符

        setrange  key  offeset  value   把指定位置的字符替换，返回字符串长度；偏移量从0开始；

    1.10 获取部分字符串

        getrange  key  start  end  返回指定偏移量之间的字符，偏移量从 0 开始计算；如果end 小于 start 返回 “” ，end 允许大于字符串长度，start 大于 字符串长度返回 ""

    2.内部编码

        字符串类型的内部编码有3 种，Redis 会根据当前值的类型和长度决定使用哪种内部编码实现。

            # int：8个字节的长整型；

            # embstr：小于等于39个字节的字符串；

            # raw：大于39个字节的字符串；

    3.典型使用场景

    3.1 缓存功能

        作为web 端和数据库之间的缓存层，由于 Redis 具有支撑高并发的特性，所以缓存通常能起到加速读写和降低后端压力的作用。

        对于键名的设置，比较推荐的方式是使用 “业务名：对象名：id：[属性]”，分号也可以换成其他的符号，在能描述键名含义的前提下适当减少键的长度，从而减少由于键过长的内存浪费。

    3.2 计数

        Redis 可以实现快速计数、查询缓存的功能，同时数据可以异步落地到其他数据源。如视频系统的用户播放次数。

    3.3 共享 Session

        在一个分布式 web 服务应用中，出于负载均衡的考虑，用户的访问可能会路由到不同的服务器上，用户刷新一次访问可能会发现需要重新登录，这是无法容忍的。使用 Redis 将用户的 Session 进行集中管理，只要保证 Redis 是高可用和可扩展的，每次用户更新或者查询登录信息直接从Redis 中直接获取。

    3.4 限速

        为了应用的某些接口不被频繁访问，会限制用户或某个IP某个时间段里的访问次数，可以通过键过期和自增命令来实现。

哈希

        几乎所有的编程语言都提供了hash 类型，它们的叫法可能是哈希、字典、关联数组。在 Redis 中，哈希类型是指键值本身又是一个键值对结构。

    1.命令

    1.1 设置值

        hset  key  field  value   设置成功返回 1 ，反之会返回 0；此外 Redis 提供了 hsetnx 命令 ，但作用域为 field

    1.2 获取值

        hget  key  field   如果键不存在，会返回 nil

    1.3 删除 field

        hdel  key  field  [ field  ... ]   会删除一个或多个field，返回结果为成功删除 field 的个数

    1.4 计算 field 的个数

        hlen  key    如果键不存在，返回 0

    1.5 批量设置或获取 field-value

        hmget  key  field  [ field ... ]   不存在返回 nil ，存在返回结果顺序和 field 顺序一致

        hmset  key  field  value  [ field  value  ... ]  成功添加返回 OK

    1.6 判断 field 是否存在

        hexists  key  field     当key 包含 field 返回 1，否则返回 0；

    1.7 获取所有 field 

        hkeys  key   键不存在时返回 (empty list or set)

    1.8 获取所有 value 

        hvals  key   键不存在时返回 (empty list or set)

    1.9 获取所有的 field-value

        hgetall  key   键不存在时返回 (empty list or set)

        如果哈希元素个数比较多，该命令会存在阻塞 Redis 的可能。如果只需要获取部分 field，可以使用 hmget，如果一定要获取全部 field-value，可以使用 hscan 命令，该命令会渐进式遍历哈希类型。

    1.10 计数

        hincrby  key  field

        hincrbyfloat  key  field 

    1.11 计算 value 的字符串长度

        hstrlen  key  field   需要 Redis 3.2 以上

    2.内部编码 

        哈希类型有两种内部编码：

            # ziplist：压缩列表，当哈希类型元素个数小于 hash-max-ziplist-entries 配置（默认是 512个），同时所有值都小于 hash-max-ziplist-value 配置（默认是 64字节）时，Redis 会使用 ziplist 作为哈希的内部实现，ziplist 使用更加紧凑的结构实现多个元素的连续存储，所以在节省内存方面比 hashtable 更加优秀。

            # hashtable：哈希表，当哈希类型无法满足ziplist 的条件时， Redis 会使用 hashtable 作为哈希的内部实现，因为此时 ziplist 的读写效率会下降，而 hashtable 的读写时间复杂度为 O(1)。

    3.使用场景

        在缓存一些对象信息时，使用哈希类型相比于使用字符串序列化对象信息，更加直观，并且在更新操作上更加便捷。对象信息总的来说有三种方式来存储，下面比较一下优缺点：

            # 原生字符串类型：每个属性一个键，优点：简单直观，每个属性都支持更新操作；缺点：占用过多的键，内存占用量大，同时对象信息内聚性较差，一般不会再生产环境使用。

            # 序列化字符串类型：将对象信息序列化后用一个键保存，优点：简化编程，如果合理的使用序列化可以提高内存的使用效率；缺点：序列化和反序列化有一定的开销，同时每次更新属性都需要把全部数据进行反序列化，更新后再序列化到 Redis 中。

            # 哈希类型：每个用户属性使用一对 field-value ，但是只用一个键保存，优点：简单直观，如果使用合理可以减少内存空间的使用；缺点：要控制哈希在ziplist 和 hashtable 两种内部编码的转换，hashtable会消耗更多的内存。

列表

        列表是用来存储多个有序的字符串，一个列表最多可以存储 2的 32次方减 1 个元素。在 Redis 中，可以对列表两端插入（push）和弹出（pop），还可以获取指定范围的元素列表、获取指定索引下标的元素等。列表类型有两个特点：

            # 列表中的元素是有序的

            # 列表中的元素可以重复

    1.命令

    1.1 添加操作

        rpush  key  value  [ value ... ]    从右边插入元素，返回插入元素的个数

        lpush  key  value  [ value ... ]    从左边插入元素

        linsert  key  before | after  spelem  value   向某个元素（如：spelem）前或后插入元素，返回元素个数

    1.2 查找

         lrange  key  start  end   获取指定范围内的元素列表，经常使用 lrange  key  0  -1来查询列表所有元素。

        lindex  key  index    获取列表指定索引下标的元素

        llen  key  获取列表长度 你

        列表所有下标有两个特点：一是，索引下标从左到右分别是 0 到 N - 1，但是从右到左分别是 -1 到 -N。二是，lrange 中的 end 选项包含了自身，这和很多编程语言不包含end 不太相同。

    1.3 删除

        lpop  key   从列表左侧弹出元素

        rpop  key  从列表右侧弹出

        lrem  key  count  value   删除指定元素

        ltrim  key  start  end   按照索引范围修剪列表

        lrem  命令会从列表中找到等于value 的元素进行删除，根据 count  的不同分为三种情况：

            # count > 0：从左到右，删除多个 count  个元素；

            # count < 0：从右到左，删除最多 count  绝对值个元素；

            # count = 0：删除所有。

    1.4 修改

        lset  key  index  newValue   修改指定索引下标的元素

    1.5 阻塞操作

        blpop  key  [ key ... ]  timeout

        brpop  key  [ key ... ]  timeout

        列表为空时，如果timeout = 3，那么客户端要等到 3 秒后返回，如果 timeout = 0，那么客户端一直阻塞等下去，但在阻塞期间添加了元素，客户端立即返回。列表不为空时，客户端立即返回。

        在使用brpop 时，需要注意两点：第一，如果是多个键，那么brpop 会从左至右遍历键，一旦有一个键能弹出来元素，客户端立即返回该键和其元素；第二，如果多个客户端对同一个键执行 brpop ，那么最先执行 brpop 命令的客户端可以获取到弹出的值，其他客户端继续阻塞。

    2.内部编码

        列表类型有两种内部编码：

            # ziplist：压缩列表，当列表的元素个数小于 list-max-ziplist-entries 配置（默认 512 个），同时列表中每个元素的值都小于 list-max-ziplist-value 配置时（默认 64 个字节），Redis 会选用 ziplist减少内存的使用。

            # linkedlist：链表，当列表类型无法满足 ziplist 的条件时， Redis 会使用 linkedlist 作为列表的内部实现。

        Redis 3.2 提供了 quicklist 内部编码，简单地说它是以一个 ziplist 为节点的 linkedlist ，它结合了 ziplist 和 linkedlist 两者的优势，为列表类型提供了一种更为优秀的内部编码。经测试，元素大小不影响内部编码，都是 quicklist。

    3.使用场景

    3.1 消息队列

        Redis 的 lpop + brpop 命令组合即可实现阻塞队列，生产者客户端使用 lpush 从列表左侧插入元素，多个消费者客户端使用 brpop 命令阻塞式的 “抢” 列表尾部的元素，多个客户端保证了消费的负载均衡和高可用性。

    3.2 文章列表

        每个用户有属于自己的文章列表，现需要分页显示文章列表。此时可以考虑使用列表，因为列表不单是有序的，同时支持按照索引范围获取元素。实现思路：一，每篇文章使用哈希结构存储；二，向用户文章列表添加文章；三，分页获取用户文章列表。

        使用列表类型保存和获取文章列表会存在的两个问题。一，如果每次分页的文章个数较多，需要执行多次 hgetall 操作，此时可以考虑使用 Pipeline 批量获取，或者考虑将文章序列化为字符串类型，使用 mget 批量获取。二，分页获取文章列表时，lrange 命令在列表两端性能较好，但是如果列表较大，获取列表中间范围的元素性能会变差，此时可以考虑将列表做二级拆分，或者使用 Redis 3.2 的quicklist 内部编码实现，它获取列表中间范围的元素时也可以高效完成。

        在实际的使用场景中列表用的挺多，在选择时可以参考一下口诀：

            # lpush + lpop = Stack（栈）；

            # lpush + rpop = Queue（队列）；

            # lpush + ltrim = Capped Collection（有限集合）；

            # lpush + brpop = Message Queue（消息队列）；

集合

        集合类型也是用来保存多个字符串元素，但它不允许有重复元素，并且集合中的元素是无序的，不能通过索引下标获取元素。一个集合最多可以存储 2 的32 次方减 1 个元素。Redis 除了支持集合内的增删改查，同时还支持多个集合取交集、并集、差集。

    1.命令

    1.1 添加元素

        sadd  key  element  [ element ... ]  返回结果为成功添加的元素，重复的添加不成功，返回 0

    1.2 删除元素

        srem  key  element  [ element ... ]   返回结果为成功删除的个数，删除不存在的元素，返回 0

    1.3 计算元素个数

        scard  key      时间复杂度为 O(1)，它不会遍历集合的所有元素，而是直接用Redis 内部的变量

    1.4 判断元素是否存在集合中

        sismember  key  element   存在集合中返回 1，否则返回 0

    1.5 随机从集合返回指定个数元素

        srandmember  key  [ count ]  个数是可选参数，默认为 1

    1.6 从集合随机弹出元素

        spop  key   弹出的元素从集合中删除， 从3.2 版本开始支持 [count] 

    1.7 获取所有元素

        smembers   key   返回的结果是无序的，如果元素过多存在阻塞 Redis  的可能性

        以上都是集合内部的操作，下面是集合间的操作

    1.8 多个集合的交集

        sinter  key  [ key ... ] 

    1.9 求多个集合的并集

        sunion  key  [ key ... ]  

    1.10 求多个集合的差集

        sdiff  key  [ key ... ]   

    1.11 将交集、并集、差集的结果保存

        sinterstore  destination  key [key...]  

        sunionstore  destination  key [ key ... ]

        sdiffstore  destination  key [ key ... ]

        集合间的运算在元素较多的情况下会比较耗时，所以 Redis  提供了上面三个命令将结果保存在 destination  key 中，destination  本身也是集合类型。

    2.内部编码

        集合类型的内部编码有两种：

            # intset：整数集合，当集合中的元素都是整数且元素个数小于set-max-intset-entries 配置（默认 512 个）时，Redis 会选用 inset  来作为集合的内部实现，从而减少内存的使用。

            # hashtable：哈希表，当集合类型无法满足 inset 的条件时，Redis 会使用hashtable 作为集合的内部实现。

    3.使用场景

        集合类比较典型的使用场景是标签（tag）。例如一个用户可能对娱乐、体育等感兴趣，这些兴趣点就是标签。有了这些数据就可以得到喜欢同一个标签的人，以及用户的共同喜好的标签，这些数据对于用户体验以及增强用户黏度比较重要。

有序集合

        保留了集合不能有重复元素的特性，但不同的是有序集合中的元素可以排序，它给每个元素设置一个分数（score，不同于爱书的score 可相同）作为排序的依据。

    1.命令

    1.1 添加元素

        zadd  key  score  member [ score  member ... ]   返回结果代表成功添加的个数

        有两点需要注意：

            # Redis 3.2 为 zadd 添加了 nx、xx、ch、incr 四个选项

                nx：member 必须不存在，才可以设置成功，用添加；

                xx：member 必须存在，才可以设置成功，用于更新；

                ch：返回此操作后，有序集合元素和分数发生变化的个数；

                incr：对 score 做增加，相当于后面介绍的 zincrby。

            # 有序集合相比集合提供了排序字段，但是也产生了代价，zadd 的时间复杂度为 O(log(n))，sadd 的时间复杂度为O(1)。

    1.2 计算成员个数

        zcard  key     时间复杂度为O(1)

    1.3 计算某个成员的分数

        zscore  key  member    如果元素不存在，返回 nil

    1.4 计算成员的排名

        zrank  key  member    按分数从低到高返回排名（排名从 0 开始算）

        zrevrank  key  member   按分数从高到低返回排名

    1.5 删除成员

        zrem  key  member  [ member  ... ]     返回结果为成功删除的个数

    1.6 增加成员的分数

        zincrby  key  increment  member      

    1.7 返回指定排名范围的成员

        zrange  key  start   end  [withscores]    按照分值排名，从低到高返回元素和其分数

        zrevrange  key  start  end  [withscores]

    1.8 返回指定分数范围的成员

        zrangebyscore   key  min  max  [withscore]  [limit offset  count]    按照分数从低到高返回

        zrevrangescore   key  max  min  [withscore]  [limit  offset  count]

        withscore 选项会同时返回每个成员的分数。[limit  offset  count] 选项可以限制输出的起始位置和个数，同时min  和max  还支持开区间（小括号）和闭区间（中括号），-inf 和+inf 分别代表无限小和无限大。

    1.9 返回指定分数范围成员个数

        zcount  key  min  max 

    1.10 删除指定排名内的升序元素

        zremrangebyrank   key  start end  

    1.11 删除指定分数范围的元素

        zremrangebyscore   key  min  max    

    1.12 交集

        zinterstore  destination  numkeys  key  [ key .. ]  [ weights  weigth  [ weigth .. ] ]    [aggregate  sum|min|max ]  

        参数说明：

            # destination：交集计算结果保存到这个键；

            # numkeys：需要做交集计算键的个数；

            #  weights：每个键的权重，在做交集计算时，每个键中的每个 member 会将自己分数乘以这个权重，每个键的权重默认是1；

            # aggregate：计算交集后，分值可以按照sum、min、max做汇总，默认值是 sum。

    1.13 并集

        zunionstore  destination  numkeys   key  [ key ..]   [ weights  weigth  [ weigth .. ] ]    [aggregate  sum|min|max ]  

    2.内部编码

        有序集合类型的内部编码有两种：

            # ziplist：压缩列表，当有序集合的元素个数小于 zset-max-ziplist-entries 配置（默认 128 个），同时每个元素的值都小于 zset-max-ziplist-value 配置（默认 64 字节）时，Redis 会用 ziplist 来作为有序集合的内部实现，ziplist 可以有效减少内存的使用。

            # skiplist：当 ziplist 条件不满足时，有序集合会使用 skiplist 作为内部实现，因为此时 ziplist 的读写效率会下降。

    3.使用场景

        有序集合比较典型的使用场景就是排行榜系统。例如视频网站需要对用户上传的视频做排行榜，榜单的维度可能是多个方面的：按照时间、播放量、获得的赞数。

 

 

 

参考资料：

        《Redis 开发与运维》