Redis使用

官网命令大全

查看Redis版本

redis-server -v 命令

1
2
3

[root@node1 redis-6.2.7]# redis-server -v
Redis server v=6.2.7 sha=00000000:0 malloc=libc bits=64 build=66f054e0ef6e61fa

redis-cli进去后info

[root@node1 redis-6.2.7]# src/redis-cli
127.0.0.1:6379> info
# Server
redis_version:6.2.7
redis_git_sha1:00000000

Redis通用命令

Redis一些通用命令，比如删除一个键、计算数据库的大小、设置键的过期时间等，这些命令有很多，这里主要介绍7个，完整的命令可以参考官方文档

查看数据的类型

type key

127.0.0.1:6379> type name
none
127.0.0.1:6379> type zs
hash
127.0.0.1:6379> type name
string

重命名key

1 2	127.0.0.1:6379> rename user:001 user01 OK

查看key

基本语法:

查找所有符合给定模式pattern的key
**返回值: ** 符合给定模式的key列表。

KEYS [pattern]
# * 表示任意的key
# ? 一位占位符
# 查询所有的key
127.0.0.1:6379> keys *
1) "name"

模糊匹配

key *

# 特殊匹配
KEYS h?llo          匹配hello、hallo等key。
KEYS h*llo          匹配hllo和haaaaaallo等key。
KEYS h[abe]llo  匹配hallo、hbllo和hello。

时间复杂度为**O(N)**，
- N为数据库中Key的数量。
- 这个命令由于时间复杂度为O(N)所以一般生产环境不使用，

Scan命令

语法:

SCAN cursor [MATCH pattern] [COUNT count]
cursor - 游标。
pattern - 匹配的模式。
count - 指定从数据集里返回多少元素，默认值为 10 。

相比于keys命令，scan命令有两个比较明显的优势:

scan命令的时间复杂度虽然也是O(N)，但它是分次进行的，不会阻塞线程。

scan命令提供了limit参数，可以控制每次返回结果的最大条数。

127.0.0.1:6379> keys *
1) "db_number"
2) "key1"
3) "myKey"
127.0.0.1:6379> scan 0 MATCH * COUNT 1
1) "2"
2) 1) "db_number"
127.0.0.1:6379> scan 2 MATCH * COUNT 1
1) "1"
2) 1) "myKey"
127.0.0.1:6379> scan 1 MATCH * COUNT 1
1) "3"
2) 1) "key1"
127.0.0.1:6379> scan 3 MATCH * COUNT 1
1) "0"
2) (empty list or set)

我们的Redis中有3个key，我们每次只遍历一个一维数组中的元素。如上所示，SCAN命令的遍历顺序是
- 0->2->1->3
- 这个顺序看起来有些奇怪。我们把它转换成二进制就好理解一些了。
- 00->10->01->11
- 我们发现每次这个序列是高位加1的。普通二进制的加法，是从右往左相加、进位。而这个序列是从左往右相加、进位的。这一点我们在redis的源码中也得到印证。
  - 在dict.c文件的dictScan函数中对游标进行了如下处理
    1
    2
    3
    4
    v = rev(v);
    v++;
    v = rev(v);
    # 意思是，将游标倒置，加一后，再倒置，也就是我们所说的“高位加1”的操作。

查找当前数据库的`key`的数量。

返回值: 返回当前数据库的key的数量

127.0.0.1:6379> DBSIZE
(integer) 3
127.0.0.1:6379> set new_key 5
OK
127.0.0.1:6379> DBSIZE
(integer) 4

时间复杂度为**O(1)**，计算的时候不是扫描整个表，因为Redis有个计数器，实时更新Key总数。

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

返回值: 若key 存在返回1，不存在返回0。
1
EXISTS key

时间复杂度为**O(1)**。

127.0.0.1:6379> scan 0
1) "0"
2) 1) "new_key"
   2) "age"
   3) "name"
   4) "address"
127.0.0.1:6379> exists name
(integer) 1

删除指定的一个或者多个`key`

不存在的key会被忽略。
**返回值: ** 被删除的key的数量.
1
DEL key [key ...]
时间复杂度为**O(N)**，N为被删除的key的数量，其中删除单个字符串类型的key，时间复杂度为O(1)；删除单个列表、集合、有序集合或哈希表类型的key，时间复杂度为O(M)，M为以上数据结构内的元素数量。
1
2
3
4
5
6
7
8
9
10
11
127.0.0.1:6379> scan 0
1) "0"
2) 1) "new_key"
2) "age"
3) "name"
4) "address"
127.0.0.1:6379> del name age
(integer) 2
127.0.0.1:6379> keys *
1) "new_key"
2) "address"

给key 设置过期时间

为给定的key设置生存时间，当key过期时，它会被自动删除。这里设置的时间单位是秒
**返回值: ** 设置成功返回1，当key不存在或者设置失败的时候返回0。

时间复杂度为**O(1)**。

1
2
3

PEXPIRE key milliseconds	生存时间设置单位为: 毫秒
EXPIRE key seconds		设置key的生存时间（单位: 秒）key在多少秒后会自动删除
PERSIST key				清除生存时间

示例

127.0.0.1:6379> set name sun
OK
127.0.0.1:6379> expire name 10
# 清除生存时间
127.0.0.1:6379> persist name
(integer) 0

查看key的剩余时间

以秒为单位，返回给定key的剩余生存时间（TTL，time to live）。
**返回值: **
- 当key不存在时，返回-2代表删除，
- 当key存在但是没有设置生存时间时，返回-1永久有效，否则返回key的剩余生存时间。

时间复杂度**O(1)**。

127.0.0.1:6379> set name sun
OK
127.0.0.1:6379> ttl name
(integer) -1
127.0.0.1:6379> expire name 5
(integer) 1
127.0.0.1:6379> ttl name
(integer) 3
127.0.0.1:6379> ttl name
(integer) -2

Redis数据类型

对于Redis来说，每一种数据结构都有着自己的内部编码，而且是多种实现的，这样Redis会在合适的场景选择合适的内部编码，通过OBJECT ENCODING [key]可以参看指定key的内部编码。
**这样做的好处: **
- 改进内部编码，对外的数据结构和命令没有影响，对用户提供黑箱模型。
- 多种内部编码可在不同场景下发挥各自的优势。如: ziplist比较节约内存，但是元素比较多的时候，性能会有所下降，此时Redis会将编码自动转换为linkedlist，性能会有所改善。

string类型

命令

### exist 判断key存在, 返回true / false, 1/0
exists key

#### 新增
# 添加键值对
set <key><value> [EX seconds|PX milliseconds|KEEPTTL] [NX|XX] | 
    # NX：当数据库中 key 不存在时，可以将 key-value 添加数据库
    # XX：当数据库中 key 存在时，可以将 key-value 添加数据库，与 NX 参数互斥 
    # EX：key 的超时秒数
    # PX：key 的超时毫秒数，与 EX 互斥
psetex key EXPIRY_IN_MILLISECONDS value     # 以毫秒为单位设置 key 的生存时间。          
setnx <key><value>                          # 只有在 key 不存在时设置 key 的值           
mset key1 value1 [key2 value2...]           # 批量创建kv，已存在的会被更新               
msetnx key1 value1 [key2 value2...]         # 批量创建kv，所有key不存在才会创建 
### 查询
keys PATTERN       # 符合给定模式的 key 列表 (Array)。 KEYS * 查所有         
get <key>          # 查询对应键值                                 
getset <key><value>  # 以新换旧，设置了新值同时获得旧值             
getrange <key><起始位置><结束位置> # 获得值的范围，类似 java 中的 substring，[start,end],从0开始 |
mget <key1><key2><key3> .....   # 同时获取一个或多个 value                     
strlen <key>         # 获得值的长度       

### 修改
set <key><value>             #  如果对同一个key进行set即可更新该数据            
getset <key><value>        #    以新换旧，设置了新值同时获得旧值，下次再get的时候查到的就是新的value
setrange <key><起始位置><value>  # 用 <value> 覆写<key>所储存的字符串值，从<起始位置>开始(索引从 0 开始)
append <key><value>           # 将给定的 <value> 追加到原值的末尾               
mset <key1><value1><key2><value2> .....   # 同时设置一个或多个 key-value 对                 
msetnx <key1><value1><key2><value2> ..... # 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存，有一个失败则都失败
# mset MSETNX 是原子性的，，所有字段要么全被设置，要么全不被设置

### 计数
incr <key> # 将 key 中储存的数字值增 1(原子操作)只能对数字值操作 如果key不存在，其初始值为0，在incr之后其值为1 如果value的值不能转为整型，如hello，该操作将执行失败并返回相应的错误信息
decr <key> # 将 key 中储存的数字值减 1(原子操作)只能对数字值操作 如果key不存在，其初始值为0，在decr之后其值为-1 如果value的值不能转为整型，如hello，该操作将执行失败并返回相应的错误信息 
incrby / decrby <key><步长> # 将 key 中储存的数字值增减。自定义步长(原子操作)    
incrbyfloat                # 效果与incrby类似，此方法支持传浮点型的值，正数为增，负数为减 |

赋值和取值

# 赋值
set key value
# 取值
get key
# 取值并赋值
getset key value
# 赋值多个值
mset k1 v1 k2 v2
# 获取多个值
mget k1 k2

使用del命令删除数据，可批量可单个删除：
1
del key1 [key2 key3...]

数值增减

# 值和增量都不是指数符号
redis> SET mykey 10.50
OK
redis> INCRBYFLOAT mykey 0.1
"10.6"

# 值和增量都是指数符号
redis> SET mykey 314e-2
OK
redis> GET mykey                # 用 SET 设置的值可以是指数符号
"314e-2"

redis> INCRBYFLOAT mykey 0      # 但执行 INCRBYFLOAT 之后格式会被改成非指数符号
"3.14"


# 可以对整数类型执行
redis> SET mykey 3
OK
redis> INCRBYFLOAT mykey 1.1
"4.1"


# INCRBYFLOAT 后跟无用的 0 会被移除
redis> SET mykey 3.0
OK
redis> GET mykey                                    # SET 设置的值小数部分可以是 0
"3.0"
redis> INCRBYFLOAT mykey 1.000000000000000000000    # 但 INCRBYFLOAT 会将无用的 0 忽略掉，有需要的话，将浮点变为整数
"4"
redis> GET mykey
"4"

其他命令

# 追加数值,返回长度
append key value
# 获取长度
strlen key

---

127.0.0.1:6379> get k1
"111"
127.0.0.1:6379> append k1 abab
(integer) 7
127.0.0.1:6379> get k1
"111abab"
127.0.0.1:6379> strlen k1
(integer) 7

hash类型

散列类型,支持扩展key，提供字段属性，字段和字段值之间实现映射。
字段值只支持string类型。

设置和获取值(hset设置值不区分插入和更新,0代表更新,1代表插入)

hset:一次只能设置一个字段
hmset :一次可以设置多个字段值
hsetnx:有该key则不赋值,没有则赋值相当于hset
hget: 一次只能取一个字段值
HMGET key field [field ...] : 一次可以获取多个字段值
hgetall key:

# 设置值
192.168.2.101:6379> HSET user:001 name zs
(integer) 1
# 更新值
192.168.2.101:6379> HSET user:001 name ls
(integer) 0
# 获取值
192.168.2.101:6379> HGET user:001 name
"ls"
# 设置多个字段属性值
192.168.2.101:6379> HMSET user:001 name zs age 12
OK
# 获取多个字段的值
192.168.2.101:6379> HMGET user:001 name age
1) "zs"
2) "12"

# 有该key则不赋值,没有则赋值
192.168.2.101:6379> HSETNX user:001 name ww
(integer) 0
# 获取所有的字段和值
192.168.2.101:6379> HGETALL user:001
1) "name"
2) "zs"
3) "age"
4) "12"

删除 hdel
1
hdel key

增加数字

# hincrby key field increment
192.168.2.101:6379> hset user:001 age 15
(integer) 1

192.168.2.101:6379> hgetall user:001
1) "name"
2) "zs"
3) "age"
4) "15"
# 设置增长数
192.168.2.101:6379> hincrby user:001 age 3
(integer) 18
192.168.2.101:6379> hgetall user:001
1) "name"
2) "zs"
3) "age"
4) "18"

其他

# 判断是否存在字段 0 不存在 ， 1 存在
192.168.2.101:6379> HEXISTS user:001 sex
(integer) 0
192.168.2.101:6379> HEXISTS user:001 name
(integer) 1
# 判断key是否存在
192.168.2.101:6379> EXISTS user:001
(integer) 1
# 获取key的类型
192.168.2.101:6379> TYPE user:001
hash
192.168.2.101:6379> TYPE k1
string
# 获取key所有的属性
192.168.2.101:6379> HKEYS user:001
1) "name"
2) "age"
# 获取key所有的属性值
192.168.2.101:6379> HVALS user:001
1) "zs"
2) "15"
# 获取key的属性长度
192.168.2.101:6379> HLEN user:001
(integer) 2

使用场景：存储对象信息(用户,商品信息等)

# 存储商品信息
# 商品字段 : 【商品id、商品名称、商品描述、商品库存、商品好评】
# 商品1001的信息在 Redis中的key为：[items:1001]
192.168.101.3:7003> HMSET items:1001 id 3 name apple price 999.9
OK
# 获取商品信息
192.168.101.3:7003> HGET items:1001 id
"3"
192.168.101.3:7003> HGETALL items:1001
1) "id"
2) "3"
3) "name"
4) "apple"
5) "price"
6) "999.9"

list类型

列表类型, list采用链表存储,操作从两端操作。
从两端添加数据
- lpush key value : 向列表的左边增加元素
- rpush key value: 向列表的右边增加元素
1
2
3
4
192.168.2.101:6379> LPUSH list1 a b c
(integer) 3
192.168.2.101:6379> RPUSH list1 d e f
(integer) 6
查看列表
- lrange命令,获取列表中的某一片段，将返回start、stop之间的所有元素（包含两端的元素），索引从0开始。索引可以是负数，如：“-1”代表最后边的一个元素。
1
2
3
4
5
6
7
8
# lrange key start stop,index:从0开始,-1代表最后一位
192.168.2.101:6379> LRANGE list1 0 -1
1) "c"
2) "b"
3) "a"
4) "d"
5) "e"
6) "f"
从两端弹出值
- LPOP命令从列表左边弹出一个元素，会分两步完成：第一步是将列表左边的元素从列表中移除第二步是返回被移除的元素值。
1
2
3
4
192.168.2.101:6379> LPOP list1
"c"
192.168.2.101:6379> RPOP list1
"f"

查看list长度

1 2	192.168.2.101:6379> llen list1 (integer) 4

删除指定的数据

LREM命令会删除列表中前count个值为value的元素，返回实际删除的元素个数。根据count值的不同，该命令的执行方式会有所不同：
当count>0时， LREM会从列表左边开始删除。
当count<0时， LREM会从列表后边开始删除。
当count=0时， LREM删除所有值为value的元素。

# lrem key count value
192.168.2.101:6379> lpush list2 a b c d c b a
(integer) 7
# 删除所有的a
192.168.2.101:6379> lrem list2 0 a
(integer) 2
192.168.2.101:6379> LRANGE list2 0 -1
1) "b"
2) "c"
3) "d"
4) "c"
5) "b"
# 从左往右 删除第一个C值
192.168.2.101:6379> lrem list2 1 c
(integer) 1
192.168.2.101:6379> LRANGE list2 0 -1
1) "b"
2) "d"
3) "c"
4) "b"
# 从右往左 删除第一个b值
192.168.2.101:6379> lrem list2 -1 b
(integer) 1
192.168.2.101:6379> LRANGE list2 0 -1
1) "b"
2) "d"
3) "c"

查看指定索引的值

# lindex key index
192.168.2.101:6379> LRANGE list1 0 -1

1. "e"
2. "d"
3. "e"
4. "e"

192.168.2.101:6379> LINDEX list1 0
   "e"
   
192.168.2.101:6379> LINDEX list1 -3
   "d"

保留片段

# LTRIM key start stop
192.168.2.101:6379> LTRIM list2 0 1
OK
127.0.0.1:6379> LRANGE list2 0 -1
1) "b"
2) "d"

插入指定位置
- 该命令首先会在列表中从左到右查找值为pivot的元素，然后根据第二个参数是BEFORE还是AFTER来决定将value插入到该元素的前面还是后面。
1
2
3
4
5
6
7
# LINSERT key BEFORE|AFTER pivot value
127.0.0.1:6379> LINSERT list2 after b a
(integer) 2
127.0.0.1:6379> LRANGE list2 0 -1
1) "b"
2) "a"
3) "d"

移动列表

# rpoplpush source destination
127.0.0.1:6379> RPOPLPUSH list2 list3
"d"
127.0.0.1:6379> lrange list3 0 -1
1) "d"
127.0.0.1:6379> LRANGE list2 0 -1
1) "b"
2) "a"

使用场景：用于商品评论


商品评论列表
思路：
在Redis中创建商品评论列表
用户发布商品评论，将评论信息转成json存储到list中。
用户在页面查询评论列表，从redis中取出json数据展示到页面。

定义商品评论列表key：
商品编号为1001的商品评论key【items: comment:1001】
192.168.101.3:7001> LPUSH items:comment:1001 '{"id":1,"name":"商品不错，很好！！","date":1430295077289}'

set

无序，不重复

添加和删除元素

# 添加元素  sadd key member [member ...]
192.168.2.101:6379> SADD set1 a b c
(integer) 3
192.168.2.101:6379> SADD set1 a
(integer) 0
192.168.2.101:6379> SADD set1 d
(integer) 1
# 删除元素  srem key member [member ...]
192.168.2.101:6379> SREM set1 d
(integer) 1

查看所有元素

# smembers key
127.0.0.1:6379> smembers set1
1) "c"
2) "d"
3) "b"
4) "a"

判断是否存在

1
2
3

# SISMEMBER key member
127.0.0.1:6379> SISMEMBER set1 a
(integer) 1

运算

192.168.2.101:6379> sadd set2 c b
# 取并集
192.168.2.101:6379> SUNION set1 set2
1) "c"
2) "b"
3) "d"
4) "a"
# 取交集
192.168.2.101:6379> SINTER set1 set2
1) "c"
2) "b"
# 取差集
192.168.2.101:6379> SDIFF set1 set2
1) "d"
2) "a"
127.0.0.1:6379> SDIFF set2 set1
(empty list or set)

其他

注意：由于集合是无序的，所有SPOP命令会从集合中随机选择一个元素弹出

#查看长度 scard key
127.0.0.1:6379> scard  set1
(integer) 4
#弹出元素 spop:无序,随便弹(相当于删除一个元素)
127.0.0.1:6379> spop set2
"c"
127.0.0.1:6379> spop set2
"b"

sortedset

又名zset,唯一且可排序。
Sortedset和set的不同之处，是会给set中的元素添加一个分数，然后通过这个分数进行排序，根据分数实现排序。
添加元素 ZADD key [NX|XX] [CH] [INCR] score member [score member ...]
- 元素已经存在则会用新的分数替换原有的分数。
- 返回值是新加入到集合中的元素个数，不包含之前已经存在的元素。
1
2
127.0.0.1:6379> ZADD zset1 80 zs 90 ls 70 ww
(integer) 3

添加元素和分数

如果该元素存在则修改分数并返回0;
如果不存在返回1

127.0.0.1:6379>  ZADD zset1 80 zs 90 ls 75 ww
(integer) 0
127.0.0.1:6379> ZADD zset1 80 zs 90 ls 75 ww 59 zl
(integer) 1

查看分数
1
2
127.0.0.1:6379> ZSCORE zset1 zs
"80"

删除元素

1 2	127.0.0.1:6379> ZREM zset1 zl (integer) 1

顺序输出

#zrange key start stop [WITHSCORES]
127.0.0.1:6379> ZRANGE zset1 0 -1 withscores
1) "ww"
2) "75"
3) "zs"
4) "80"
5) "ls"
6) "90"
# 不带分数排序
127.0.0.1:6379> ZRANGE zset1 0 -1
1) "ww"
2) "zs"
3) "ls"

倒序输出

127.0.0.1:6379> ZREVRANGE zset1 0 -1 withscores
1) "ls"
2) "90"
3) "zs"
4) "80"
5) "ww"
6) "75"
127.0.0.1:6379> ZREVRANGE zset1 0 -1
1) "ls"
2) "zs"
3) "ww"

排名0开始，zrank key member,按照升序排序
- 从小到大: 语法zrank key member
- 从大到小:语法zrevrank key member
1
2
3
4
127.0.0.1:6379> ZRANK zset1 ww
(integer) 0
127.0.0.1:6379> zrank zset1 ls
(integer) 2

指定分数范围排序 ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

# 最小分数  最大分数  offset length
127.0.0.1:6379> ZRANGEBYSCORE zset1 80 90 withscores
1) "zs"
2) "80"
3) "ls"
4) "90"
127.0.0.1:6379> ZRANGEBYSCORE zset1 80 90 withscores limit 1 1
1) "ls"
2) "90"

增加某个成员分数

1
2
3

# ZINCRBY key increment member
127.0.0.1:6379> ZINCRBY zset1 5 ww
"80"

查看元素个数

1
2
3

# zcard key
127.0.0.1:6379> zcard zset1
(integer) 3

统计范围内的元素个数

zrange按照元素分数从大到小的顺序返回索引从start到stop之间的所有元素（包含两端的元素）
倒序输出 zrevrange key start stop [withscores]

# zrange key  start stop [withscores] 
127.0.0.1:6379> zrange zset1 0 -1 withscores
1) "ww"
2) "80"
3) "zs"
4) "80"
5) "ls"
6) "90"

# ZCOUNT key min max 闭合区间
127.0.0.1:6379> ZCOUNT zset1 80 90
(integer) 3

192.168.2.101:6379> ZREVRANGE zset1 0 -1
1. "ww"
2. "ls"
3. "zl"

192.168.2.101:6379> ZREVRANGE zset1 0 -1 withscores
4. "ww"
5. "100"
6. "ls"
7. "90"
8. "zl"
9. "75"

根据排名删除范围内元素

127.0.0.1:6379> ZRANGE zset1 0 -1 withscores
1) "ww"
2) "80"
3) "zs"
4) "85"
5) "ls"
6) "90"
# 根据排名范围删除
# ZREMRANGEBYRANK key start stop
127.0.0.1:6379> zremrangebyrank zset1 2 2
(integer) 1
127.0.0.1:6379> ZRANGE zset1 0 -1 withscores
1) "ww"
2) "80"
3) "zs"
4) "85"

根据分数删除范围内元素

# ZREMRANGEBYSCORE key start stop 闭合区间
127.0.0.1:6379> zremrangebyscore zset1 80 85
(integer) 2
127.0.0.1:6379> ZRANGE zset1 0 -1 withscores
(empty list or set)

应用场景：排行榜

需求：根据商品销售量对商品进行排行显示
思路：定义商品销售排行榜（sorted set集合），Key为items:sellsort，分数为商品销售量。

写入商品销售量：
商品编号1001的销量是9，商品编号1002的销量是10
192.168.101.3:7007> ZADD items:sellsort 9 1001 10 1002

商品编号1001的销量加1
192.168.101.3:7001> ZINCRBY items:sellsort 1 1001

商品销量前10名：
192.168.101.3:7001> ZRANGE items:sellsort 0 9 withscores