准备

Redis安装

不在赘述、各种环境各种版本网上随便一搜都可以

启动

1
redis-server redis.windows.conf

Redis 命令行客户端

1
redis-cli -h IP -p port

入门

常用命令

  • 获得符合规则的键名列表

    1
    KEYS pattern

  • 判断一个键是否存在

    1
    EXISTS key

  • 删除键

    1
    DEL key [key ....]

  • 获取键值得数据类型

    1
    TYPE key

字符串类型

Redis 中最基本的数据类型，他能存储任何形式的字符串，最大容量512M

命令

  • 赋值与取值

    1
    2
    SET key value
    GET key

  • 递增数字

    1
    INCR key

  • 增加指定的整数

    1
    INCRBY key increment

  • 减少指定的整数

    1
    2
    DECR key
    DECRBY key decrement

  • 增加指定浮点数

    1
    INCRBYFLOAT key increment

  • 向尾部追加值

    1
    APPEND key value

  • 获取字符串长度

    1
    STRLEN key

  • 同时获得/设置多个键值

    1
    2
    MGET key [key ...]
    MSET key value [key value ...]

  • 位操作

    1
    2
    3
    4
    GETBIT key offset
    SETBIT key offset value 
    BITCOUNT key [start] [end]
    BITOP operation destkey key [key ...]

实践

命名（推荐）：对象类型：对象ID：对象属性（例：user:1:friends）

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
redis 127.0.0.1:6379> set baidu http://www.baidu
OK
redis 127.0.0.1:6379> append baidu .com
(integer) 20
redis 127.0.0.1:6379> get baidu
"http://www.baidu.com"
redis 127.0.0.1:6379> set visitors 0
OK
redis 127.0.0.1:6379> incr visitors
(integer) 1
redis 127.0.0.1:6379> incr visitors
(integer) 2
redis 127.0.0.1:6379> get visitors
"2"
redis 127.0.0.1:6379> incrby visitors 100
(integer) 102
redis 127.0.0.1:6379> get visitors
"102"
redis 127.0.0.1:6379> type baidu
string
redis 127.0.0.1:6379> type visitors
string
redis 127.0.0.1:6379> ttl baidu
(integer) -1
redis 127.0.0.1:6379> rename baidu baidu-site
OK
redis 127.0.0.1:6379> get baidu
(nil)
redis 127.0.0.1:6379> get baidu-site
"http://www.baidu.com"

散列类型（字典，哈希表）

Redis采用字典结构以键值对的形式存储数据的，散列类型的键值也是一种字典结构，其存储了字段和字段值得映射，一个散列类型键可以包含2的32次-1个字段

命令

  • 赋值与取值

    1
    2
    3
    4
    5
    HSET key field value 
    HGET key field 
    HMSET key field value [field value ...]
    HMGET key field [field ...]
    HGETALL key

  • HSET 不区分插入和更新，修改数据是不必判断字段是否存在

  • 判断字段是否存在

    1
    HEXISTS key field

  • 当字段不存在时赋值

    1
    HSETNX key field value

  • 增加数字

    1
    HINCRBY key field increment

  • 删除字段

    1
    HDEL key field [field ...]

  • 只取字段名或字段值

    1
    2
    HKEYS key
    HVALS key

  • 获得字段数量

    1
    HLEN key

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
127.0.0.1:6379> hset person name jack
(integer) 1
127.0.0.1:6379> hset person age 20
(integer) 1
127.0.0.1:6379> hset person sex famale
(integer) 1
127.0.0.1:6379> hgetall person
1) "name"
2) "jack"
3) "age"
4) "20"
5) "sex"
6) "famale"
127.0.0.1:6379> hkeys person
1) "name"
2) "age"
3) "sex"
127.0.0.1:6379> hvals person
1) "jack"
2) "20"
3) "famale"

列表类型

可以存储一个有序的字符串列表，常用的操作是向列表良多添加元素，或者获得列表中的某一段

命令

  • 向列表两端添加元素

    1
    2
    LPUSH key value [value ...]
    RPUSH key value [value ...]

  • 从列表两端弹出元素

    1
    2
    LPOP key 
    RPOP key

  • 获取列表中元素的个数

    1
    LLEN key

  • 获得列表片段

    1
    LRANGE key start stop

  • 删除列表中指定的值

    1
    LREM key count value

  • 获得/设置指定索引的元素值

    1
    2
    LINDEX key index
    LSET key index value

  • 只保留列表指定片段

    1
    LTRIM key start end

  • 向列表中插入元素

    1
    LINSERT key BEFORE|AETER pivot value

  • 将元素从一个列表转移到另一个列表

    1
    RPOPLPUSH source destination

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
redis 127.0.0.1:6379> lpush list1 redis
(integer) 1
redis 127.0.0.1:6379> lpush list1 hello
(integer) 2
redis 127.0.0.1:6379> rpush list1 world
(integer) 3
redis 127.0.0.1:6379> llen list1
(integer) 3
redis 127.0.0.1:6379> lrange list1 0 3
1) "hello"
2) "redis"
3) "world"
redis 127.0.0.1:6379> lpop list1
"hello"
redis 127.0.0.1:6379> rpop list1
"world"
redis 127.0.0.1:6379> lrange list1 0 3
1) "redis"

集合

可以理解为一堆值不重复的列表，类似数学领域中的集合概念，且Redis也提供了针对集合的求交集、并集、差集等操作。
set 的内部实现是一个 value永远为null的HashMap，实际就是通过计算hash的方式来快速排重的，这也是set能提供判断一个成员是否在集合内的原因。

命令

  • 添加一个或者多个元素到集合(set)里

    1
    2
    SADD
    SADD key member [member ...]

  • 获取集合里面的元素数量

    1
    2
    SACRD
    SCARD key

  • 获得队列不存在的元素

    1
    2
    SDIFF
    SDIFF key [key ...]

  • 获得队列不存在的元素，并存储在一个关键的结果集

    1
    2
    SDIFFSTORE
    SDIFFSTORE destination key [key ...]

  • 获得两个集合的交集

    1
    2
    SINTER
    SINTER key [key ...]

  • 获得两个集合的交集，并存储在一个集合中

    1
    2
    SINTERSTORE
    SINTERSTORE destination key [key ...]

  • 确定一个给定的值是一个集合的成员

    1
    2
    SISMEMBER
    SISMEMBER key member

  • 获取集合里面的所有key

    1
    2
    SMEMBERS
    SMEMBERS key

  • 移动集合里面的一个key到另一个集合

    1
    2
    SMOVE
    SMOVE source destination member

  • 获取并删除一个集合里面的元素

    1
    2
    SPOP
    SPOP key [count]

  • 从集合里面随机获取一个元素

    1
    2
    SRANDMEMBER
    SRANDMEMBER key [count]

  • 从集合里删除一个或多个元素，不存在的元素会被忽略

    1
    2
    SREM
    SREM key member [member ...]

  • 添加多个set元素

    1
    2
    SUNION
    SUNION key [key ...]

  • 合并set元素，并将结果存入新的set里面

    1
    2
    SUNIONSTORE
    SUNIONSTORE destination key [key ...]

  • 迭代set里面的元素

    1
    2
    SSCAN
    SSCAN key cursor [MATCH pattern] [COUNT count]

有序集合

一个有序集合的每个成员带有分数，用于进行排序。
Redis有序集合添加、删除和测试的时间复杂度均为O(1)(固定时间，无论里面包含的元素集合的数量)
Redis sorted set的内部使用HashMap和跳跃表(SkipList)来保证数据的存储和有序，HashMap里放的是成员到score的映射，而跳跃表里存放的是所有的成员，排序依据是HashMap里存的score,使用跳跃表的结构可以获得比较高的查找效率，并且在实现上比较简单。

使用场景

用户的积分排行榜需求就可以通过有序集合实现。还有上面介绍的使用List实现轻量级的消息队列，其实也可以通过Sorted Set实现有优先级或按权重的队列。

命令

  • 添加一个或多个成员到有序集合，或者如果它已经存在更新其分数

    1
    2
    ZADD
    ZADD key score1 member1 [score2 member2]

  • 得到的有序集合成员的数量

    1
    2
    ZCARD
    ZCARD key

  • 计算一个有序集合成员与给定值范围内的分数

    1
    2
    ZCOUNT
    ZCOUNT key min max

  • 在有序集合增加成员的分数

    1
    2
    ZINCRBY
    ZINCRBY key increment member

  • 多重交叉排序集合，并存储生成一个新的键有序集合。

    1
    2
    ZINTERSTORE
    ZINTERSTORE destination numkeys key [key ...]

  • 计算一个给定的字典范围之间的有序集合成员的数量

    1
    2
    ZLEXCOUNT
    ZLEXCOUNT key min max

  • 由索引返回一个成员范围的有序集合（从低到高）

    1
    2
    ZRANGE
    ZRANGE key start stop [WITHSCORES]

  • 返回一个成员范围的有序集合（由字典范围）

    1
    2
    ZRANGEBYLEX
    ZRANGEBYLEX key min max [LIMIT offset count]

  • 返回有序集key中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员，有序集成员按 score 值递增(从小到大)次序排列

    1
    2
    ZRANGEBYSCORE
    ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT]

  • 确定成员的索引中有序集合

    1
    2
    ZRANK
    ZRANK key member

  • 从有序集合中删除一个或多个成员，不存在的成员将被忽略

    1
    2
    ZREM
    ZREM key member [member ...]

  • 删除所有成员在给定的字典范围之间的有序集合

    1
    2
    ZREMRANGEBYLEX
    ZREMRANGEBYLEX key min max

  • 在给定的索引之内删除所有成员的有序集合

    1
    2
    ZREMRANGEBYRANK
    ZREMRANGEBYRANK key start stop

  • 在给定的分数之内删除所有成员的有序集合

    1
    2
    ZREMRANGEBYSCORE
    ZREMRANGEBYSCORE key min max

  • 返回一个成员范围的有序集合，通过索引，以分数排序，从高分到低分

    1
    2
    ZREVRANGE
    ZREVRANGE key start stop [WITHSCORES]

  • 返回一个成员范围的有序集合，以socre排序从高到低

    1
    2
    ZREVRANGEBYSCORE
    ZREVRANGEBYSCORE key max min [WITHSCORES]

  • 确定一个有序集合成员的索引，以分数排序，从高分到低分

    1
    2
    ZREVRANK
    ZREVRANK key member

  • 获取给定成员相关联的分数在一个有序集合

    1
    2
    ZSCORE
    ZSCORE key member

  • 添加多个集排序，所得排序集合存储在一个新的键

    1
    2
    ZUNIONSTORE
    ZUNIONSTORE destination numkeys key [key ...]

  • 增量迭代排序元素集和相关的分数

    1
    2
    ZSCAN
    ZSCAN key cursor [MATCH pattern] [COUNT count]

使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
redis 127.0.0.1:6379> zadd dbs 100 redis
(integer) 1
redis 127.0.0.1:6379> zadd dbs 98 memcached
(integer) 1
redis 127.0.0.1:6379> zadd dbs 99 mongodb
(integer) 1
redis 127.0.0.1:6379> zadd dbs 99 leveldb
(integer) 1
redis 127.0.0.1:6379> zcard dbs
(integer) 4
redis 127.0.0.1:6379> zcount dbs 10 99
(integer) 3
redis 127.0.0.1:6379> zrank dbs leveldb
(integer) 1
redis 127.0.0.1:6379> zrank dbs other
(nil)
redis 127.0.0.1:6379> zrangebyscore dbs 98 100
1) "memcached"
2) "leveldb"
3) "mongodb"
4) "redis"
Reference

事务

概述：

Redis中的事务十一组命令的集合 将属于一个事物的命令先送给Redis，然后再让Redis一次执行这些命令

使用示例

1
2
3
4
5
6
7
8
9
127.0.0.1:6789> MULTI
OK
127.0.0.1:6789> SADD "user:1:following" 2
QUEUED
127.0.0.1:6789> SADD "user:2:followers" 1
QUEUED
127.0.0.1:6789> EXEC
1) (integer) 0
2) (integer) 0

错误处理

  • 语法错误：不存在或参数不对
    • 执行EXEC命令后Redis就直接返回错误，正确的命令也不会执行
  • 运行错误:使用不同类型命令
    • 错误命令之前命令不执行 之后命令会执行
    • Redis 无回滚

watch 命令介绍

概述：watch 命令可以监控一个或多个键，一点其中有一个键被修改（或删除），之后的事务就不会执行。监控一直持续到EXEC命令（事务中的命令是在EXEC之后才执行的，所以在MULTI命令后可以修改WATCH监控的键值）

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
127.0.0.1:6789> SET demo 1
OK
127.0.0.1:6789> watch demo
OK
127.0.0.1:6789> set demo 2
OK
127.0.0.1:6789> MULTI
OK
127.0.0.1:6789> set demo 3
QUEUED
127.0.0.1:6789> EXEC -
(nil)
127.0.0.1:6789> get key
"2"

过期时间

  • 设置过期时间

    1
    2
    EXPIRE
    EXPIRE key sconds

  • 查看过期时间(不存在返回-2，键没有过期时间-1)

    1
    2
    TTL
    TTL foo

实现访问频率限制之一

示例：

1
2
3
4
5
6
7
8
9
10
$isKeyExists = EXISTS rete.limiting:$IP
if $isKeyExists is 1 
	$times = INCR rate.limiting:$IP
	if $times > 100 
		print 访问超限 稍后重试
else 
	MULTL
	INCR rate.limiting:$IP
	EXPIRE $keyName, 60
	EXEC

实现访问频率限制之二

示例：

1
2
3
4
5
6
7
8
9
10
11
12
$listLength = L:EN rate.limiting:$IP
if $listLength < 10
	LPUSH rate.limitingL$IP, now()
else 
	$time = LINDEX rate.limiting:$IP, -1
	if now() - $time < 60 
		print 超过限制
	else 
		LPUSH rate.limiting:$IP, now()
		LTRIM rate.limiting:$IP, 0, 9

// now() 获得当前Unix时间
 Previous

数据结构

Copyright © Ywnline 版权所有 冀ICP备20005992号-1