Redis数据结构和常用命令

1. 基于key(键)的操作

127.0.0.1:6379> keys * # 查看当前数据库中所有的key值
(empty array)
127.0.0.1:6379> set k1 eric # 设置key值 值是string类型
OK
127.0.0.1:6379> set k2 james
OK
127.0.0.1:6379> set k3 kobe
OK
127.0.0.1:6379> keys *
1) "k1"
2) "k3"
3) "k2"
127.0.0.1:6379> type k2 # 查看指定key的数据类型
string
127.0.0.1:6379> exists k1 # 判断指定的key是否存在 存在就为1 不存在就为0
(integer) 1
127.0.0.1:6379> exists k4
(integer) 0
127.0.0.1:6379> del key k3 # 删除指定的key值
(integer) 1
127.0.0.1:6379> keys *
1) "k1"
2) "k2"
127.0.0.1:6379> expire k1 10 # 给key设置过期时间
(integer) 1
127.0.0.1:6379> ttl k1 # 查看指定key值的存活时期 不存在就为负数
(integer) 6
127.0.0.1:6379> ttl k1
(integer) -2
127.0.0.1:6379> select 0 # 切换到指定的数据库
OK
127.0.0.1:6379> dbsize # 查看当前数据库的key的数量
(integer) 1
127.0.0.1:6379> flushdb # 清空当前数据库
OK
127.0.0.1:6379> flushall # 清空所有的数据库
OK

2. string类型

• String是Redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。
• String类型是二进制安全的。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象。
• String类型是Redis最基本的数据类型，一个Redis中字符串value最多可以是512M。

常用命令

127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> set k1 eric # 给key设置String类型的值
OK
127.0.0.1:6379> set k2 kobe
OK
127.0.0.1:6379> get k1 # 根据key获取对象的value值
"eric"
127.0.0.1:6379> get k2
"kobe"
127.0.0.1:6379> set k1 james # 如果给一个已经存在的key设置值就是覆盖原来的值
OK
127.0.0.1:6379> get k1
"james"
127.0.0.1:6379> append k1 123 # 在指定key的值后面追加内容
(integer) 8 # 追加之后字符串的长度
127.0.0.1:6379> get k1
"james123"
127.0.0.1:6379> strlen k1 # 获取key的长度
(integer) 8
127.0.0.1:6379> setnx k1 miller # 当可以不存在时 value才会设置成功，否则设置不成功
(integer) 0 # 0 标识没有设置成功
127.0.0.1:6379> get k1 # k1的值没有发生变化，因为key已经存在
"james123"
127.0.0.1:6379> setnx k3 curry # k3的值设置成功，因为之前不存在key3这个键
(integer) 1 # 1 标识设置成功
127.0.0.1:6379> get k3
"curry"
127.0.0.1:6379> set num1 100
OK
127.0.0.1:6379> incr num1 # incr命令操作的值必须是数字类型 incr:对key自增1
(integer) 101
127.0.0.1:6379> get num1
"101"
127.0.0.1:6379> decr num1 # 对key进行自减操作
(integer) 100
127.0.0.1:6379> get num1
"100"
127.0.0.1:6379> incrby num1 5 # 对key进行增加 指定增加5
(integer) 105
127.0.0.1:6379> decrby num1 10 # 对key进行递减 指定减去5
(integer) 95

注意:

incr命令是原子操作。也就是指不会被线程调度机制打断的操作。这种操作一旦开始，就一直运行到结 束，中间不会有任何线程上下文切换。在单线程中， 能够在单条指令中完成的操作都可以认为是"原子操作"。

问题：

Java中的i++属于原子性操作吗? 不是

• i++; 不是原子操作
• 第一步：取值 i = 0;
• 第二步：自加操作 i++;
• 第三步：将自加的操作结果赋予给i。

redis操作string的其他命令：

127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3 # 批量设置k-v
OK
127.0.0.1:6379> mget k1 k2 k3 # 批量获取值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v11 k5 v5 # 只有所有的key都不存在，才会设置，任意一个key
存在，都不会设置值
(integer) 0
127.0.0.1:6379> msetnx k4 v4 k5 v5
(integer) 1
127.0.0.1:6379> mget k4 k5
1) "v4"
2) "v5"
127.0.0.1:6379> set name LebronJames
OK
127.0.0.1:6379> getrange name 0 6 #根据指定区间获取字符串的值 索引值从0开始
"LebronJ"
127.0.0.1:6379> getrange name 0 5
"Lebron"
127.0.0.1:6379> setrange name 0 kobe # 从指定索引值开始替换值
(integer) 11
127.0.0.1:6379> get name
"kobeonJames"
127.0.0.1:6379> setex k6 20 v6 # 设置key的值的同时，也设置过期时间
OK
127.0.0.1:6379> ttl k6
(integer) 16
127.0.0.1:6379> get name
"kobeonJames"
127.0.0.1:6379> getset name green # 使用新值替换旧值，但是返回旧值
"kobeonJames"
127.0.0.1:6379> get name
"green"

3. list类型

List列表是单键多值的列表。Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素 到列表的头部（左边）或者尾部（右边）。它的底层实际是个双向链表，对两端的操作性能很高，但是 通过索引下标操作中间的节点性能会较差。

常用命令

127.0.0.1:6379> lpush k1 v1 v2 v3 # 从列表的左边追加元素 键是k1 值是v1 v2 v3
(integer) 3
127.0.0.1:6379> lrange k1 0 -1 # 查询列表中的所有元素
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> rpush k1 v4 v5 v6 # 从列表的右边追加元素 键是k1 值是v4 v5 v6
(integer) 6
127.0.0.1:6379> lrange k1 0 -1
1) "v3"
2) "v2"
3) "v1"
4) "v4"
5) "v5"
6) "v6"
127.0.0.1:6379> lpop k1 # 从左边弹出一个值并返回
"v3"
127.0.0.1:6379> rpop k1 # 从右边弹出一个值并返回
"v6"
127.0.0.1:6379> lpush k2 s1 s2 s3 # 创建k2列表 并追加值
(integer) 3
127.0.0.1:6379> lrange k2 0 -1
1) "s3"
2) "s2"
3) "s1"
127.0.0.1:6379> lrange k1 0 -1
1) "v2"
2) "v1"
3) "v4"
4) "v5"
127.0.0.1:6379> rpoplpush k1 k2 # 将k1列表最右边的值取出来,追加到k2列表的最左边
"v5"
127.0.0.1:6379> lrange k1 0 -1 # k1最右边的元素没有了
1) "v2"
2) "v1"
3) "v4"
127.0.0.1:6379> lrange k2 0 -1 # 查看k2集合 k2元素的最左边追加了元素v5
1) "v5"
2) "s3"
3) "s2"
4) "s1"
127.0.0.1:6379> lindex k2 2 # 根据指定下标获取元素
"s2"
127.0.0.1:6379> llen k2 # 获取指定列表的长度
(integer) 4
127.0.0.1:6379> linsert k2 before s2 v2 # 在k2列表中的s2元素前面追加元素v2
(integer) 5
127.0.0.1:6379> lrange k2 0 -1
1) "v5"
2) "s3"
3) "v2"
4) "s2"
5) "s1"
127.0.0.1:6379> lrem k2 1 s2 # 从左边删除指定个数的元素s2
(integer) 1
127.0.0.1:6379> lrange k2 0 -1
1) "v5"
2) "s3"
3) "v2"
4) "s1"
127.0.0.1:6379> lset k2 2 s2 # 将指定索引位置上的元素替换(将k2列表中2号索引位置上的元素替换成s2)
OK
127.0.0.1:6379> lrange k2 0 -1
1) "v5"
2) "s3"
3) "s2"
4) "s1"

list的数据结构

4. set类型

Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动去重的，当你需要 存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的命令，这个也是list所不能提供的。

Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找 的复杂度都是 O(1)。(随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变)

常用命令

127.0.0.1:6379> sadd s1 v1 v2 v3 # 向s1中添加元素 v1 v2 v3
(integer) 3
127.0.0.1:6379> smembers s1 # 查询列表中的所有元素
1) "v2"
2) "v3"
3) "v1"
127.0.0.1:6379> sadd s1 v3 # 添加重复元素 没有添加成功
(integer) 0
127.0.0.1:6379> smembers s1
1) "v2"
2) "v3"
3) "v1"
127.0.0.1:6379> sismember s1 v1 # 判断集合是否存在某个元素 存在返回1 不存在返回0
(integer) 1
127.0.0.1:6379> sismember s1 v7
(integer) 0
127.0.0.1:6379> scard s1 # 返回集合中元素的个数
(integer) 3
127.0.0.1:6379> srem s1 v1 v2 # 删除集合中指定的元素
(integer) 2
127.0.0.1:6379> smembers s1
1) "v3"
127.0.0.1:6379> spop s1 # 随机弹出集合中的某个元素
"v4"
127.0.0.1:6379> smembers s1
1) "v2"
2) "v3"
3) "v5"
127.0.0.1:6379> srandmember s1 2 # 随机弹出指定个数的元素,但是不会从集合中删除
1) "v2"
2) "v3"
127.0.0.1:6379> smembers s1
1) "v2"
2) "v3"
3) "v5"
127.0.0.1:6379> smove s1 s2 v5 # 将s1集合中的元素s5移动到s2集合中去。
(integer) 1
127.0.0.1:6379> smembers s1
1) "v3"
127.0.0.1:6379> smembers s2
1) "v2"
2) "v3"
3) "v5"
4) "v1"
127.0.0.1:6379> sinter s1 s2 # 取集合s1 s2的交集
1) "v3"
127.0.0.1:6379> sunion s1 s2 # 取集合s1 s2的并集
1) "v2"
2) "v3"
3) "v5"
4) "v1"
127.0.0.1:6379> sdiff s2 s1 # 取s2的补集
1) "v2"
2) "v5"
3) "v1"

set的数据结构

Set数据结构是dict字典，字典是用哈希表实现的。

Java中HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。Redis的set结构

也是一样，它的内部也使用hash结构，所有的value都指向同一个内部值。

5. Hash类型

Redis hash 是一个键值对集合。Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。类似Java里面的Map<String,Object>

需求：在redis里面保存一个用户对象( {id:1001,username:"eric",age=23} )。

方案1：

将user对象转换成一个json字符串，使用string来存储这个json字符串。

缺点：每次修改这个对象里面的数据，都需要把这个字符串转换成java对象修改，修改之后再转换成 json字符串，比较麻烦，不适合频繁修改数据的场景。

方案2：

通过key和对象属性拼接的方式存储数据

key value
user:id 1001
user:username eric
user:age 23

缺点：存储的数据分散，如果对象的属性过多，在redis中的key也会非常的多。

方案3：

通过redis中的hash类型的数据保存

优点：通过 key(用户ID) + field(属性标签) 就可以操作对应属性数据了，既不需要重复存储数据，也不 会带来序列化和并发修改控制的问题

常用命令

127.0.0.1:6379> hset user id 1001 # 向hash中存储数据 key是user field是id 值是
1001
(integer) 1
127.0.0.1:6379> hget user id # 获取指定的数据
"1001"
127.0.0.1:6379> hmset user username eric age 23 # 批量向hash集合中添加数据
OK
127.0.0.1:6379> hmget user username age # 批量向hash集合中获取数据
1) "eric"
2) "23"
127.0.0.1:6379> hexists user username # 判断key中是否存在指定的field 存在返回1
不存在返回0
(integer) 1
127.0.0.1:6379> hkeys user # 获取所有的field
1) "id"
2) "username"
3) "age"
127.0.0.1:6379> hvals user # 获取所有的value值
1) "1001"
2) "eric"
3) "23"
127.0.0.1:6379> hdel user age # 删除指定的field及其对应的值
(integer) 1
127.0.0.1:6379> hget user age
(nil)
127.0.0.1:6379> hincrby user id 1 # 对指定的field的值进行自增/自减操作 1 自增
-1 递减
(integer) 1002
127.0.0.1:6379> hincrby user id -1
(integer) 1001
127.0.0.1:6379> hsetnx user age 25 # 给对应的field设置值 如果field存在设置不成功，如果field不存在，则设置成功。
(integer) 1
127.0.0.1:6379> hsetnx user username james
(integer) 0
127.0.0.1:6379> hget user age
"25"
127.0.0.1:6379> hget user username
"eric"

hash的数据结构

Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短 且个数较少时，使用ziplist，否则使用hashtable。

6. zset类型

Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。不同之处是有序集合 的每个成员都关联了一个评分（score）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的，但是评分可以是重复了。

因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。

常用命令

127.0.0.1:6379> zadd user 99 kobe 88 durant 82 curry # 添加元素到zset集合中
(integer) 3
127.0.0.1:6379> zrange user 0 -1 # 显示zset集合中的所有值(按照分数的升序排序)
1) "curry"
2) "durant"
3) "kobe"
127.0.0.1:6379> zrange user 0 -1 withscores # 显示zset集合中的所有值 包括元素对
应的分数
1) "curry"
2) "82"
3) "durant"
4) "88"
5) "kobe"
6) "99"
127.0.0.1:6379> zrangebyscore user 80 89 # 取指定区间的元素
1) "curry"
2) "durant"
127.0.0.1:6379> zrangebyscore user 80 89 withscores # 取指定区间的元素 包括元
素对应的分数
1) "curry"
2) "82"
3) "durant"
4) "88"
127.0.0.1:6379> zrevrangebyscore user 100 1 # 显示zset集合中的所有值(按照分数的降序排序)
1) "kobe"
2) "durant"
3) "curry"
127.0.0.1:6379> zincrby user 12 kobe # 给指定的元素增加分数
"111"
127.0.0.1:6379> zrange user 0 -1 withscores
1) "curry"
2) "82"
3) "durant"
4) "88"
5) "kobe"
6) "111"
127.0.0.1:6379> zrem user kobe # 删除指定的元素
(integer) 1
127.0.0.1:6379> zrange user 0 -1
1) "curry"
2) "durant"
127.0.0.1:6379> zcount user 0 100 # 统计指定分数区间的元素个数
(integer) 2
127.0.0.1:6379> zrange user 0 -1
1) "curry"
2) "durant"
127.0.0.1:6379> zrank user durant # 查询指定元素的排名
(integer) 1
127.0.0.1:6379> zrank user curry
(integer) 0

zset的数据结构

zset底层使用了两个数据结构：

1. hash，hash的作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值。
2. 跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表。

什么是跳跃表?

有序集合在生活中比较常见，例如根据成绩对学生排名，根据得分对玩家排名等。对于有序集合的底层实现，可以用数组、平衡树、链表等。数组不便元素的插入、删除；平衡树或红黑树虽然效率高但结构复杂；链表查询需要遍历所有效率低。Redis采用的是跳跃表。跳跃表效率堪比红黑树，实现远比红黑树简单。

实例：

对比有序链表和跳跃表，从链表中查询出51。

• 有序链表

要查找值为51的元素，需要从第一个元素开始依次查找、比较才能找到。共需要6次比较。

• 跳跃表

跳跃表的特点是，上一层是下一层的子集

1. 从第二层开始，找到21发现后面没元素了，就找到第一层的21继续往后找
2. 找到41发现后面的61比51大，就找第0层的41
3. 从第0层的41再往后面找，就找到了51

一共就比较查找了4次

从此可以看出跳跃表比有序链表效率要高。

7. Bitmap（位图）

现在我们来看一个场景，就是各大app都有签到的功能，大家可以思考，用户签到的功能是如何实现的。首先想到的就是设计一张签到表，将用户的签到信息持久化的保存在数据表里面。我们可以设计这么一张表：

用户一次签到，就是一条记录,然后将记录持久化的保存在数据表里面。大家设想一下这么个场景：假如 有1000万用户，平均每人每年签到次数为10次，则这张表一年的数据量为 1亿条。每签到一次需要使用（8 + 8 + 1 + 1 + 3 + 1）共22 字节的内存，一个月则最多需要600多字节。可以想象到1000万用户一年的数据量需要的内存空间该有多大。

我们如何能够简化一点呢？其实可以考虑小时候一个挺常见的方案，就是小时候，咱们准备一张小小的卡片，你只要签到就打上一个勾，我最后判断你是否签到，其实只需要到小卡片上看一看就知道了

我们可以采用类似这样的方案来实现我们的签到需求。

我们按月来统计用户签到信息，签到记录为1，未签到则记录为0.

把每一个bit位对应当月的每一天，形成了映射关系。用0和1标示业务状态，这种思路就称为位图

（BitMap）。这样我们就用极小的空间，来实现了大量数据的表示

Redis中是利用string类型数据结构实现BitMap，因此最大上限是512M，转换为bit则是 2^32个bit位。

BitMap的操作命令有：

• setbit：向指定位置（offset）存入一个0或1
• getbit：获取指定位置（offset）的bit值
• bitcount：统计BitMap中值为1的bit位的数量
• bitfield：操作（查询、修改、自增）BitMap中bit数组中的指定位置（offset）的值
• bitfield_ro：获取BitMap中bit数组，并以十进制形式返回
• bitop：将多个BitMap的结果做位运算（与 、或、异或）
• bitpos：查找bit数组中指定范围内第一个0或1出现的位置

127.0.0.1:6379> setbit bit1 0 1 # 向指定的位置存入值
(integer) 0
127.0.0.1:6379> setbit bit1 1 1
(integer) 0
127.0.0.1:6379> setbit bit1 2 1
(integer) 0
127.0.0.1:6379> setbit bit1 4 1
(integer) 0
127.0.0.1:6379> setbit bit1 6 1
(integer) 0
127.0.0.1:6379> setbit bit1 7 1
(integer) 0

最后得到的结果是:

127.0.0.1:6379> getbit bit1 1 # 从指定位置获取值
(integer) 1
127.0.0.1:6379> getbit bit1 3
(integer) 0
127.0.0.1:6379> bitcount bit1 # 统计1出现的次数(可以统计签到次数)
(integer) 6
127.0.0.1:6379> bitfield bit1 get u2 0 #从0号索引开始获取2个bit位 再转换成10进制数
据
1) (integer) 3
127.0.0.1:6379> bitfield bit1 get u3 0
1) (integer) 7
127.0.0.1:6379> bitpos bit1 0 # 统计第一个0出现的位置
(integer) 3
127.0.0.1:6379> setbit unique:users:20201104 1 1 # 2020-11-04 日访问网站的
userid=1,2,5,9。
(integer) 0
127.0.0.1:6379> setbit unique:users:20201104 2 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201104 5 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201104 9 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201103 0 1 # 2020-11-03 日访问网站的
userid=0,1,4,9。
(integer) 0
127.0.0.1:6379> setbit unique:users:20201103 1 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201103 4 1
(integer) 0
127.0.0.1:6379> setbit unique:users:20201103 9 1
(integer) 0
127.0.0.1:6379> bitop and unique:users:20201104 unique:users:20201103 # 统计
两天都访问网站的人数
(integer) 2

8. HyperLogLog

在工作当中，我们经常会遇到与统计相关的功能需求，比如统计网站PV（PageView页面访问量）,可以使用Redis的incr、incrby轻松实现。

但像UV（UniqueVisitor，独立访客）、独立IP数、搜索记录数等需要去重和计数的问题如何解决？这种求集合中不重复元素个数的问题称为基数问题。

解决基数问题有很多种方案：

1. 数据存储在MySQL表中，使用distinct count计算不重复个数
2. 使用Redis提供的hash、set、bitmaps等数据结构来处理

以上的方案结果精确，但随着数据不断增加，导致占用空间越来越大，对于非常大的数据集是不切实际的。

能否能够降低一定的精度来平衡存储空间？Redis推出了HyperLogLog

Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。

在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。

但是，因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以

HyperLogLog 不能像集合那样，返回输入的各个元素。

什么是基数?

比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数。

127.0.0.1:6379> pfadd subject java # 添加元素
(integer) 1
127.0.0.1:6379> pfadd subject php
(integer) 1
127.0.0.1:6379> pfadd subject java
(integer) 0
127.0.0.1:6379> pfadd subject mysql
(integer) 1
127.0.0.1:6379> pfadd subject html spring
(integer) 1
127.0.0.1:6379> pfcount subject # 统计元素的个数
(integer) 5
127.0.0.1:6379> pfadd program oracle springboot
(integer) 1
127.0.0.1:6379> pfcount program
(integer) 2
127.0.0.1:6379> pfmerge k1 subject program # 将两个key所属的元素合并到k1里面去。
OK
127.0.0.1:6379> pfcount k1
(integer) 7

9. Geospatial

Redis 3.2 中增加了对GEO类型的支持。GEO，Geographic，地理信息的缩写。该类型，就是元素的2维坐标，在地图上就是经纬度。redis基于该类型，提供了经纬度设置，查询，范围查询，距离查询，经纬度Hash等常见操作。

127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai #存数据
(integer) 1
127.0.0.1:6379> geoadd china:city 106.50 29.53 chongqing 114.05 22.52
shenzhen 116.38 39.90 beijing # 也可以批量存储数据
(integer) 3
127.0.0.1:6379> geopos china:city shanghai # 获取指定城市的经纬度
1) 1) "121.47000163793563843"
2) "31.22999903975783553"
127.0.0.1:6379> geopos china:city beijing
1) 1) "116.38000041246414185"
2) "39.90000009167092543"
127.0.0.1:6379> geodist china:city beijing shanghai # 显示北京到上海之间的直线距
离(米)
"1068153.5181"
127.0.0.1:6379> geodist china:city beijing shanghai km # 显示北京到上海之间的
直线距离(千米)
"1068.1535"
127.0.0.1:6379> georadius china:city 110 30 1000 km # 找出东经110度 北纬30度
1000公里半径内的城市
1) "chongqing"
2) "shenzhen"

注意：两极(南极 北极)无法直接添加，一般会下载城市数据，直接通过 Java 程序一次性导入。有效的经度从 -180 度到 180 度。有效的纬度从 -85.05112878 度到 85.05112878 度。当坐标位置超出指定范围时，该命令将会返回一个错误。已经添加的数据，是无法再次往里面添加的。