Skip to content

键管理

单个键管理

针对单个键的命令，前面已经介绍了 type、del、object、exists、expire 等，下面介绍剩余的几个重要命令

键重命名

rename key nwekey

例如现有一个键值对，键为 python，值为 jedis: 

1
2
127.0.0.1:6379> get python
"jedis"

下面操作将键 python 命令为 java 

1
2
3
4
5
6
127.0.0.1:6379> rename python java
OK
127.0.0.1:6379> get python
(nil)
127.0.0.1:6379> get java
"jedis"

如果在 rename 之前，键 java 已经存在，那么它的值也将被覆盖 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
127.0.0.1:6379> set a b
OK
127.0.0.1:6379> set c d
OK
127.0.0.1:6379> rename a c
OK
127.0.0.1:6379> get a
(nil)
127.0.0.1:6379> get c
"b"

为了防止被强行 rename，Redis 提供了 renamenx 命令，确保只有 newKey 不存在时才被覆盖，例如下面操作 renamenx 时，newkey=python 已经存在，返回结果是 0 代表没有完成重命名，所以键 java 和 python 的值没变 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
127.0.0.1:6379> set java jedis
OK
127.0.0.1:6379> set python redis-py
OK
127.0.0.1:6379> renamenx java python
(integer) 0
127.0.0.1:6379> get java
"jedis"
127.0.0.1:6379> get python
"redis-py"

在使用重命名命令时，有两点需要注意:

(1) 由于重命名期间会执行 del 命令删除旧的键，如果键对应的值比较大，会存在阻塞 Redis 的可能性，这点不要忽视
(2) 如果 rename 和 renamenx 中的 key 和 newkey 是相同的，在 Redis3.2 和之前版本返回结果略有不同
Redis3.2 中会返回 OK，Redis3.2 之前的版本会提示错误

随机返回一个键

randomkey 

1
2
3
4
5
6
127.0.0.1:6379> dbsize
(integer) 9
127.0.0.1:6379> randomkey
"user:ranking"
127.0.0.1:6379> randomkey
"c"

键过期

键过期在许多应用场景都非常有帮助。
除了 expire、ttl 命令以外，Redis 还提供了 exprieat、pexpire、pexpireat、pttl、persist 等一系列命令:

  • expire key seconds: 键在 seconds 秒后过期
  • expireat key timestamp: 键在秒级时间戳 timestamp 后过期

下面为键 hello 设置了 10 秒的过期时间，然后通过 ttl 观察它的过期剩余时间(单位: 秒)，随着时间的推移，ttl 逐渐变小，最终变为 -2: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> expire hello 10
(integer) 1
127.0.0.1:6379> ttl hello
(integer) 8
127.0.0.1:6379> ttl hello
(integer) 2
127.0.0.1:6379> ttl hello
(integer) -2
127.0.0.1:6379> ttl htllo
(integer) -2
127.0.0.1:6379> ttl htllo
(integer) -2

返回结果为 -2，说明键 hello 已经被删除

ttl 命令和 pttl 都可以查询键的剩余过期时间，但是 pttl 精度更高可以达到毫秒级别，有 3 种返回值:

  • 大于等于 0 的整数: 键剩余的过期时间(ttl是秒，pttl是毫秒)
  • -1: 键没有设置过期时间
  • -2: 键不存在

expireat 命令可以设置键的秒级过期时间，例如如果需要将键 hello 在 2016-08-01 00:00:00(秒级时间戳为 1469980800)过期，可以执行如下操作: 

1
expireat hello 1469980800

除此之外，Redis2.6 版本后提供了毫秒级的过期方案:

  • pexpire key milliseconds: 键在 milliseconds 毫秒后过期
  • pexpireat key milliseconds-timestamp 键在毫秒级时间戳 timestamp 后过期

但无论是使用过期时间还是时间戳，秒级还是毫秒级，在 Redis 内部最终使用的都是 pexpireat

在使用 Redis 相关过期命令时，需要注意以下几点:

(1) 如果 expire key 的键不存在，返回结果为 0

1
2
127.0.0.1:6379> expire not_exist_key 30
(integer) 0

(2) 如果过期时间为负值，键会立即被删除，犹如使用 del 命令一样: 

1
2
3
4
5
6
127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> expire hello -2
(integer) 1
127.0.0.1:6379> get hello
(nil)

(3) persist 命令可以将键的过期时间清除 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
127.0.0.1:6379> hset key f1 v1
(integer) 1
127.0.0.1:6379> expire key 50
(integer) 1
127.0.0.1:6379> ttl key
(integer) 49
127.0.0.1:6379> persist key
(integer) 1
127.0.0.1:6379> ttl key
(integer) -1

(4) 对于字符串类型键，执行 set 命令会去掉过期时间，这个问题很容易在开发中被忽视 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> expire hello 50
(integer) 1
127.0.0.1:6379> ttl hello
(integer) 44
127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> ttl hello
(integer) -1

(5) Redis 不支持二级数据结构(例如哈希、列表)内部元素的过期功能，例如不能对列表类型的一个元素做过期时间设置

(6) setex 命令作为 set+expire 的组合，不但是原子执行，同时减少了一次网络通讯的时间

迁移键

迁移键功能非常重要，因为有时候我们只想把部分数据由一个 Redis 迁移到另一个 Redis(例如从生产环境迁移到测试环境)，Redis 发展历程中提供了 move、dump+restore、migrate 三组迁移键的方法，它们的实现方式以及使用的场景不太相同

(1) move

move key db

move 命令用于在 Redis 内部进行数据迁移，Redis 内部可以有多个数据库，由于多个数据库功能后面会介绍，这里只需要知道 Redis 内部可以有多个数据库，彼此在数据上是相互隔离的，move key db 就是把指定的键从源数据库移动到目标数据库中，但多数数据库功能不建议在生产环境使用，所以这个命令知道即可

(2) dump+restore 

1
2
dump key
restore key ttl value

dump + restore 可以实现在不同的 Redis 实例之间进行数据迁移的功能，整个迁移的过程分为两步:

在源 Redis 上，dump 命令会将键值序列化，格式采用的是 RDB 格式

在目标 Redis 上，restore 命令将上面序列化的值进行复原，其中 ttl 参数代表过期时间，如果 ttl=0 代表没有过期时间

有关 dump+restore 有两点需要注意:
第一，整个迁移过程并非原子性的，而是通过客户端分步完成的。
第二，迁移过程是开启了两个客户端连接，所以 dump 的结果不是在源 Redis 和目标 Redis 之间传输

下面用一个例子演示完整过程:

在源 Redis 上执行 dump: 

1
2
3
4
127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> dump hello
"\x00\x05world\t\x00\xc9#mH\x84/\x11s"

在目标 Redis 上执行 restore: 

1
2
3
4
5
6
7
8
127.0.0.1:6385> get hello
(nil)
127.0.0.1:6385> restore hello 0 "\x00\x05world\t\x00\xc9#mH\x84/\x11s"
OK
127.0.0.1:6385> get heloo
(nil)
127.0.0.1:6385> get hello
"world"

(3) migrate

migrate host port key | "" destination-db timeout [copy] [replace] [keys key [key...]]

migrate 命令也是用于在 Redis 实例间进行数据迁移的，实际上 migrate 命令就是将 dump、restore、del 三个命令进行组合，从而简化了操作流程。
migrate 命令具有原子性，而且从 Redis3.0.6 版本以后已经支持迁移多个键的功能，有效地提高了迁移效率

整个过程如下:
第一，整个过程是原子执行的，不要在多个 Redis 实例上开启客户端的，只需要在源 Redis 上执行 migrate 命令即可。
第二，migrate 命令的数据传输直接在源 Redis 和目标 Redis 上完成的。
第三，目标 Redis 完成 restore 后会发送 OK 给源 Redis，源 Redis 接收后会根据 migrate 对应的选项来决定是否在源 Redis 上删除对应的键

下面对 migrate 的参数进行逐个说明:

  • host: 目标 Redis 的 IP 地址
  • port: 目标 Redis 的端口
  • key | "": 在 Redis3.0.6 版本之前，migrate 只支持迁移一个键，所以此处是要迁移的键，但 Redis3.0.6 版本之后支持迁移多个键，如果当前需要迁移多个键，此处为空字符
  • destination-db: 目标 Redis 的数据库索引，例如要迁移到 0 号数据库，这里就写 0
  • timeout: 迁移的超时时间(单位为毫秒)
  • [copy]: 如果添加此选项，迁移后并不删除源键
  • [replace]: 如果添加此选项，migrate 不管目标 Redis 是否存在该键都会正常迁移进行数据覆盖
  • [keys key[key...]]: 迁移多个键，例如要迁移 key1、key2、key3，此处填写 "keys key1 key2 key3"

下面用示例演示 migrate 命令，为了方便演示源 Redis 使用 6379 端口，目标 Redis 使用 6385 端口，现要将源 Redis 的键 hello 迁移到目标 Redis 中，会分为如下几种情况:

情况1: 源 Redis 有键 hello，目标 Redis 没有 

1
2
3
4
5
6
127.0.0.1:6379> get hello
"world"
127.0.0.1:6379> migrate 127.0.0.1 6385 hello 0 1000
OK
127.0.0.1:6379> get hello
(nil)

情况2: 源 Redis 和目标 Redis 都有键 hello: 

1
2
3
4
5
127.0.0.1:6379> get hello
"world"

127.0.0.1:6385> get hello
"redis"

如果 migrate 命令没有加 replace 选项会收到错误提示，如果加了 replace 会返回 OK 表示迁移成功: 

1
2
3
4
127.0.0.1:6379> migrate 127.0.0.1 6385 hello 0 1000
(error) ERR Target instance replied with error: BUSYKEY Target key name already exists.
127.0.0.1:6379> migrate 127.0.0.1 6385 hello 0 1000 replace
OK

情况3: 源 Redis 没有键 hello。如下所示，此种情况会收到 nokey 的提示：

··· 127.0.0.1:6379> get hello (nil) 127.0.0.1:6379> migrate 127.0.0.1 6385 hello 0 1000 NOKEY ···

下面演示一下 Redis3.0.6 版本以后迁移多个键的功能:

源 Redis 批量添加多个键: 

1
2
3
4
5
6
127.0.0.1:6379> mset key1 value1 key2 value2 key3 value3
OK
127.0.0.1:6379> migrate 127.0.0.1 6385 "" 0 5000 keys key1 key2 key3
OK
127.0.0.1:6379> get key1
(nil)

遍历键

全量遍历键

keys pattern

例如向一个空的 Redis 插入 4 个字符串类型的键值对 

1
2
3
4
127.0.0.1:6379> dbsize
(integer) 0
127.0.0.1:6379> mset hello world redis best jedis best hill high
OK

如果要获取所有的键，可以使用 keys pattern 命令:

1
2
3
4
5
127.0.0.1:6379> keys *
1) "jedis"
2) "hill"
3) "redis"
4) "hello"

上面为了遍历所有的键，pattern 直接使用星号，这是因为 pattern 使用的是 glob 风格的通配符:

  • * 代表匹配任意字符
  • ? 代表匹配一个字符
  • [] 代表匹配部分字符，例如 [1, 3] 代表匹配 1,3，[1-10]代表匹配 1 到 10 的任意数字
  • \x 用来做转义，例如要匹配星号、问号需要进行转义

下面操作匹配以 j, r 开头、紧跟 edis 字符串的所有键 

1
2
3
127.0.0.1:6379> keys [j,r]edis
1) "jedis"
2) "redis"

例如下面操作匹配到 hello 和 hill 这两个键: 

1
2
3
127.0.0.1:6379> keys h?ll*
1) "hill"
2) "hello"

当需要遍历所有键时(例如检测过期或闲置时间、寻找大对象等)，keys 是一个很有帮助的命令，例如想删除所有以 video 字符串开头的键，可以执行如下操作: 

1
redis-cli keys video* | xargs redis-cli del

但是如果考虑到 Redis 的单线程架构就不那么美妙了，如果 Redis 包含了大量的键，执行 keys 命令很可能会造成 Redis 阻塞，所以一般建议不要在生产环境下使用 keys 命令。
但有时候确实有遍历键的需求该怎么办，可以在以下三种情况使用：

  • 在一个不对外提供服务的 Redis 从节点上执行，这样不会阻塞到客户端的请求，但是会影响到主从复制
  • 如果确认键值总数比较少，可以执行该命令
  • 使用下面介绍的 scan 命令渐进式的遍历所有键，可以有效防止阻塞

渐进式遍历

Redis 从 2.8 版本后，提供了一个新的命令 scan，它能有效的解决 keys 命令存在的问题。
和 keys 命令执行时会遍历所有键不同，scan 采用渐进式遍历的方式来解决 keys 命令可能带来的阻塞问题，每次 scan 命令的时间复杂度是 O(1)，但是要真正实现 keys 的功能，需要执行多次 scan。

Redis 存储键值对实际使用的是 hashtable 的数据结构

那么每次执行 scan，可以想象成只扫描一个字典中的一部分键，直到将字典中的所有键遍历完毕。scan 的使用方法如下: 

1
scan cursor [match pattern] [count number]
  • cursor 是必需参数，实际上 cursor 是一个游标，第一次遍历从 0 开始，每次 scan 遍历完都会返回当前游标的值，直到游标值为 0，表示遍历结束
  • match pattern 是可选参数，它的作用是做模式的匹配，这点和 keys 的模式匹配很像
  • count number 是可选参数，它的作用是表明每次要遍历的键的个数，默认值是 10，此参数可以适当增大

现有一个 Redis 有 26 个键(英文 26 个字母)，现在要遍历所有的键，使用 scan 命令效果的操作如下。 

1
2
127.0.0.1:6379> dbsize
(integer) 26

第一次执行 scan 0，返回结果分为两个部分: 第一个部分 6 就是下次 scan 需要的 cursor，第二个部分是 10 个键 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
127.0.0.1:6379> scan 0
1) "6"
2)  1) "k"
    2) "e"
    3) "h"
    4) "c"
    5) "s"
    6) "t"
    7) "o"
    8) "q"
    9) "f"
   10) "d"

使用新的 cursor="6"，执行 scan 6

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
127.0.0.1:6379> scan 6
1) "23"
2)  1) "i"
    2) "z"
    3) "x"
    4) "y"
    5) "l"
    6) "n"
    7) "b"
    8) "j"
    9) "u"
   10) "w"
   11) "r"

这次得到的 cursor="23"，继续执行 scan 23 得到结果 cursor 变为 0，说明所有的键已经被遍历过了

1
2
3
4
5
6
7
127.0.0.1:6379> scan 23
1) "0"
2) 1) "v"
   2) "g"
   3) "a"
   4) "p"
   5) "m"

除了 scan 以外，Redis 提供了面向哈希类型、集合类型、有序集合的扫描遍历命令，解决注入 hgetall、smembers、zrange 可能产生的阻塞问题，对应的命令分别是 hscan、sscan、zscan，它们的用法和 scan 基本类似，
下面以 sscan 为例子进行说明，当前集合有两种类型的元素，例如分别以 old:user 和 new:user 开头，先需要将 old:user 开头的元素全部删除，可以参考如下伪代码: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
String key = "myset";
// 定义 pattern
String pattern = "old:user*";
// 游标每次从 0 开始
STring cursor = "0";
while (true) {
    // 获取扫描结果
    ScanResult scanResult = redis.sscan(key, cursor, pattern);
    List elements = scanResult.getResult();
    if (elements != null && elements.size() > 0) {
        // 批量删除
        redis.srem(key, elements);
    }
    // 获取新的游标
    cursor = scanResult.getStringCursor();
    // 如果游标为 0 表示遍历结束
    if ("0".equals(cursor)) {
        break;
    }
}

渐进式遍历可以有效的解决 keys 命令可能产生的阻塞问题，但是 scan 并非完美无瑕，如果在 scan 的过程中如果有键的变化(增加、删除、修改)，那么遍历效果可能会碰到如下问题:
新增的键可能没有遍历到，遍历出了重复的键等情况，也就是说 scan 并不能保证完整的遍历出来所有的键，这些是我们在开发时需要考虑的

数据库管理

Redis 提供了几个面向 Redis 数据库的操作，它们分别是 dbsize、select、fushdb、flushall 命令

切换数据库

select dbIndex

许多关系型数据库，例如 MySQL 支持在一个实例下有多个数据库存在的，但是与关系型数据库用字符来区分不同数据库名不同，Redis 只是用数字作为多个数据库的实现。
Redis 默认配置中是有 16 个数据库:

databases 16

假设 databases=16，select0 操作将切换到第一个数据库，select 15 选择最后一个数据库，但是 0 号数据库和 15 号数据库之间的数据没有任何关联，甚至可以存在相同的键: 

1
2
3
4
5
6
7
8
set hello world # 默认进到 0 号数据库
OK
127.0.0.1:6379> get hello
"world"
127.0.0.1:6379> select 15   # 切换到 15 号数据库
OK
127.0.0.1:6379[15]> get hello # 因为 15 号数据库和 0 号数据库是隔离的，所以 get hello 为空
(nil)

那么能不能像使用测试数据库和正式数据库一样，把正式的数据放在 0 号数据库，测试的数据库放在 1 号数据库，那么两者在数据上就不会彼此受影响了。事实真有那么好吗？

Redis3.0 中应逐渐弱化这个功能，例如 Redis 的分布式实现 Redis Cluster 只允许使用 0 号数据库，只不过为了向下兼容老版本的数据库功能，该功能没有完全废弃掉，下面分析以下为什么要废弃掉这个“优秀”的功能呢？
总结起来有三点:

  • Redis 是单线程的。如果使用多个数据库，那么这些数据库仍然是使用一个 CPU，彼此之间还是会受到影响的
  • 多数据库的使用方式，会让调试和运维不同业务的数据库变的困难，假如有一个慢查询存在，依然会影响其他数据库，这样会使得别的业务方定位问题非常的困难。
  • 部分 Redis 的客户端根本就不支持这种方式。即使支持，在开发的时候来回切换数字形式的数据库，很容易弄乱

如果要使用多个数据库功能，完全可以在一台机器上部署多个 Redis 实例，彼此用端口来做区分，因为现代计算机或者服务器通常是有多个 CPU 的。
这样既保证了业务之间不会受到影响，又合理地使用了 CPU 资源

flushdb/flushall

flushdb/flushall 命令用于清除数据库，两者的区别的是 flushdb 只清除当前数据库，flushall 会清除所有数据库

flushdb/flushall 命令可以非常方便的清理数据，但是也带来两个问题:

  • flushdb/flushall 命令会将所有数据清除，一旦误操作后果不堪设想
  • 如果当前数据库键值数量比较多，flushdb/flushall 存在阻塞 Redis 的可能性

所以在使用 flushdb/flushall 一定要小心谨慎