Redis基本数据类型-内部编码与使用场景

谁践踏了优雅 2021-11-17 03:30 307阅读 0赞

### 文章目录 ###

*  字符串String
 *   *  内部编码
     *  使用场景
     *   *  1.缓存功能
         *  2.计数
         *  3.共享Session
         *  4.限速
 *  哈希Hash
 *   *  内部编码
     *  使用场景
 *  列表list
 *   *  内部编码
     *  使用场景
     *   *  1.消息队列
         *  2.文章列表
 *  集合set
 *   *  内部编码
     *  使用场景
 *  有序集合zset
 *   *  内部编码
     *  使用场景

# 字符串String #

## 内部编码 ##

字符串类型的内部编码有3种：

*  int：8个字节的长整型。
 *  embstr：小于等于39个字节的字符串。
 *  raw：大于39个字节的字符串。

Rdis会根据当前值的类型和长度决定使用哪种内部编码实现。

整数类型示例如下：

127.0.0.1:6379> set key 8653
    OK
    127.0.0.1:6379> object encoding key
    "int"

短字符串示例如下：

# 小于等于39个字节的字符串：embstr
    127.0.0.1:6379> set key "hello world"
    OK
    127.0.0.1:6379> object encoding key
    "embstr"

长字符串示例如下：

# 大于39个字节的字符串：row
    127.0.0.1:6379> set key "one string greater than 39 byte............"
    OK
    127.0.0.1:6379> object encoding key
    "raw"
    127.0.0.1:6379> strlen key
    (integer) 43

## 使用场景 ##

### 1.缓存功能 ###

比较典型的缓存使用场景是使用Redis作为缓存层，MySQL作为存储层，绝大部分请求的数据都是从Redis中获取。由于Redis基于支撑高并发的特性，所以缓存通常能起到加速读写和降低后端压力的作用。一般访问流程如下：

*  1.用户发起查询请求。
 *  2.首先从Redis获取信息。
 *  3.如果没有从Redis获取到用户信息，需要从MySQL中进行获取，并将结果回写到Redis，添加过期时间。

### 2.计数 ###

许多应用都会使用Redis作为计数的基础工具，它可以实现快速计数、查询缓存的功能，同时数据可以异步落地到其他数据源。如视频播放数可以用Redis作为计数的基础组件，用户每播放一次视频，相应的视频播放数就会自增1：

long incrVideoCounter(long id) { 
    	key = "vidio:playCount:" + id;
    	return redis.incr(key);
    }

### 3.共享Session ###

如图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70]  
一个分布式Web服务将用户的Session信息（例如用户登录信息）保存在各自服务器中，这样会造成一个问题，出于负载均衡的考虑，分布式服务会将用户的访问均衡到不同服务器上，用户刷新一次访问可能会发现需要重新登录，这个问题是用户无法容忍的。

为了解决这个问题，可以使用Redis将用户的Session进行集中管理，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 1]

### 4.限速 ###

很多应用出于安全的考虑，会在每次进行登录时，让用户输入手机验证码，从而确定是否是用户本人。但是为了短信接口不被频繁访问，会限制用户每分钟获取验证码的频率，例如一分钟不能超过5次。此功能可以使用Redis来实现，下面的伪代码给出了基本实现思路：

phoneNum = "152xxxxxxxxx";
    key = "shorMsg:limit:" + phoneNum;
    // set key value EX 60 NX
    isExists = redis.set(key,1,"EX 60","NX");
    if(isExists != null || redis.incr(key) <= 5) { 
    	// 通过
    } else { 
    	// 限速
    }

上述就是利用Redis实现了限速功能。例如一些网站限制一个IP地址不能在一秒内访问超过n次也可以采用类似的思路。

# 哈希Hash #

## 内部编码 ##

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

*  ziplist（压缩列表）：当哈希类型元素个数小于hash-max-ziplist-entries配置（默认512个）、同时所有值都小于hash-max-ziplist-value配置（默认64字节）时，Redis会使用ziplist作为哈希的内部实现，ziplist使用更加紧凑的结构实现多个元素的连续存储，所以再节省内存方面比hashtable更加优秀。
 *  hashtable（哈希表）：当哈希类型无法满足ziplist的条件时，Redis会使用hashtable作为哈希的内部实现，因为此时ziplist的读写效率会下降，而hashtable的读写时间复杂度为O(1)。

下面的示例演示了哈希类型的内部编码，以及相应的变化。

1.  当field个数比较少且没有大的value时，内部编码为ziplist；
    
        127.0.0.1:6379> hmset hashkey f1 v1 f2 v2
        OK
        127.0.0.1:6379> object encoding hashkey
        "ziplist"
2.  当有value大于64字节，内部编码会由ziplsit变为hashtable：
    
        127.0.0.1:6379> hset hashkey f3 "one string is bigger than 64 byte...忽略..."
        OK
        127.0.0.1:6379> object encoding hashkey
        "hashtable"
3.  当field个数超过512，内部编码也会由ziplist变为hashtable：
    
        127.0.0.1:6379> hmset hashkey f1 v1 f2 v2 f3 v3 ...忽略... f513 v513
        OK
        127.0.0.1:6379> object encoding hashkey
        "hashtable"

## 使用场景 ##

相比于使用字符串序列化缓存用户信息，哈希类型会更加直观，并且在更新操作上会更加便捷。可以讲每个用户的id定义为键后缀，多对field-value对应每个用户的属性，类似如下伪代码：

UserInfo getUserInfo(long id){ 
    	// 用户id作为key后缀
    	userRedisKey = "user:info:" + id;
    	// 使用hgetall获取所有用户信息映射表
    	userInfoMap = redis.hgetAll(userRedisKey);
    	UserInfo userInfo;
    	if (userInfoMap != null) { 
    		// 将映射关系装换为UserInfo
    		userInfo = transgerMapToUserInfo(userInfoMap);
    	} else { 
    		// 从MySQL中获取用户信息
    		userInfo = mysql.get(id);
    		// 将userInfo变为映射关系使用hmset保存到Redis中
    		redis.hmset(userRedisKey, transferUserInfoToMap(userInfo));
    		// 添加过期时间
    		redis.expire(userRedisKey, 3600);
    	}
    	return userInfo;
    }

需要注意哈希类型和关系型数据库有两点不同之处：

*  哈希类型是稀疏的，而关系型数据库是完全结构化的，例如哈希类型每个键可以有不同的field，而关系型数据库一旦添加新的列，所有行都要为其设置值（即使为NULL）。
 *  关系型数据库可以做复杂的关系查询，而Redis去模拟关系型复杂查询开发困难，维护成本高。

到目前为止，我们可以选择三种方法缓存用户信息，下面给出三种方案的实现方法和优缺点分析。

1.  原生字符串类型：每个属性一个键。
    
        set user:1:name tom
        set user:1:age 23
        set user:1:city beijing
    
    优点：简单直观，每个属性都支持更新操作。  
    缺点：占用过多的键，内存占用量较大，同时用户信息内聚性比较差，所以此种方案一般不会在生产环境中使用。
2.  序列化字符串类型：将用户信息序列化后用一个键保存。
    
        set user:1 serialize(userInfo)
    
    优点：简化编程，如果合理的使用序列化可以提高内存的使用效率。  
    缺点：序列化和反序列化有一定的开销，同时每次更新属性都需要把全部数据取出进行反序列化，更新后再序列化到Redis中。
3.  哈希类型：每个用户属性使用一对field-value，但是只用一个键保存。
    
        hmset user:1 name tom age 23 city hangzhou
    
    优点：简单直观，如果使用合理可以减少内存空间的使用。  
    缺点：要控制哈希在ziplist和hashtable两种内部编码的转换，hashtable会消耗更多内存。

# 列表list #

## 内部编码 ##

列表类型的内部编码有两种。

*  ziplist（压缩列表）：当列表的元素个数小于list-max-ziplist-entries配置（默认512个），同时列表中每个元素的值都小于list-max-ziplist-value配置时（默认64字节），Redis会选用ziplist来作为列表的内部实现来减少内存的使用。
 *  linkedlist（链表）：当列表类型无法满足ziplist的条件时，Redis会使用linkedlist作为列表的内部实现。

下面的示例演示了列表类型的内部编码，以及相应的变化。

1.  当元素个数较少且没有大元素时，内部编码为ziplist
    
        127.0.0.1:6379> rpush listkey e1 e2 e3
        (integer) 3
        127.0.0.1:6379> object encoding listkey
        "ziplist"
2.  当元素个数超过512个，内部编码变为linkedlist：
    
        127.0.0.1:6379> rpush listkey e4 e5 ...忽略... e512 e513
        (integer) 513
        127.0.0.1:6379> object encoding listkey
        "linkedlist"
3.  或者当某个元素超过64字节，内部编码也会变为linkedlist：
    
        127.0.0.1:6379> rpush listkey "one string is bigger than 64 byte ..................................."
        (integer) 4
        127.0.0.1:6379> object encoding listkey
        "linkedlist"

> Redis3.2 版本提供了 quicklist 内部编码，简单地说它是以一个 ziplist 为节点的 linkedlist，它结合了 ziplist 和 linkedlist 两者的优势，为列表类型提供了一种更为优秀的内部编码实现。

## 使用场景 ##

### 1.消息队列 ###

如下图，Redis的 `lpush+brpop` 命令组合即可实现阻塞队列，生产者客户端使用 `lpush` 从队列列表左侧插入元素，多个消费者客户端使用 `brpop` 命令阻塞式的“抢”列表尾部的元素，多个客户端保证了消费的负载均衡和高可用性。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 2]

### 2.文章列表 ###

每个用户有属于自己的文章列表，现需要分页展示文章列表。此时可以考虑使用列表，因为列表不但是有序的，同时支持按照索引范围获取元素。

*  1.每篇文章使用哈希结构存储，例如每篇文章有3个属性 title、timestamp、content：
    
        hmset article:1 title xx timestamp 1746123456 content xxxx
        ...
        hmset article:k title yy timestamp 1746123789 content yyyy
 *  2.向用户文章列表添加文章，`user:{id}:articles` 作为用户文章列表的键：
    
        lpush user:1:articles article:1 artcle:3
        ...
        lpush user:k:articles article:5
 *  3.分页获取用户文章列表，例如下面伪代码获取用户 id=1 的前10篇文章：
    
        articles = lrange user:1:articles 0 9
        for article in { articles}
        	hgetall { article}

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

> 实际上列表的使用场景很多，在选择时可以参考以下口诀：
> 
>  *  lpush + lpop = Stack（栈）
>  *  lpush + rpop = Queue （队列）
>  *  lpush + ltrim = Capped Collection（有限集合）
>  *  lpush + brpop = Message Queue（消息队列）

# 集合set #

## 内部编码 ##

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

*  intset（整数集合）：当集合中的元素都是整数且元素个数小于set-max-intset-entries配置（默认512个）时，Redis会选用intset来作为集合的内部实现，从而减少内存的使用。
 *  hashtable（哈希表）：当集合类型无法满足intset的条件时，Redis会使用hashtable作为集合的内部实现。

下面用示例来说明：

1.  当元素个数较少且都为整数时，内部编码为intset：
    
        127.0.0.1:6379> sadd setkey 1 2 3 4
        (integer) 4
        127.0.0.1:6379> object encoding setkey
        "intset"
2.  当元素个数超过512个，内部编码为hashtable：
    
        127.0.0.1:6379> sadd setkey 1 2 3 4 5 6 ... 512 513
        (integer) 509 # 因为前面添加了前四条，会去重
        127.0.0.1:6379> scard setkey
        (integer) 513
        127.0.0.1:6379> object encoding setkey
        "hashtable"
3.  当某个元素不为整数时，内部编码也贵变为hashtable：
    
        127.0.0.1:6379> sadd setkey a
        (integer) 1
        127.0.0.1:6379> object encoding setkey
        "hashtable"

## 使用场景 ##

集合类型比较重要的使用场景是标签（tag）。例如一个用户可能对娱乐、体育比较感兴趣，另一个用户可能对历史、新闻比较感兴趣，这些兴趣点就是标签。有了这些数据就可以得到喜欢同一个标签的人，以及用户的共同喜好的标签，这些数据对于用户体验以及增强用户粘度比较重要。例如一个电子商务的网站会对不同标签的用户做不同类型的推荐，比如对数码产品比较感兴趣的人，在各个页面或者通过邮件的形式给他们推荐最新的数码产品，通常会为网站带来更多的收益。

下面使用集合类型实现标签功能的若干功能。

*  1.给用户添加标签
    
        sadd user:1:tags tag1 tag2 tag5
        sadd user:1:tags tag2 tag3 tag5
        ...
        sadd user:k:tags tag1 tag2 tag4
        ...
 *  2.给标签添加用户
    
        sadd tag1:users user:1 user:3
        sadd tag2:users user:1 user:2 user:3
        ...
        sadd tagk:users user:1 user:2
        ...
    
    > 用户标签的关系维护应该在一个事务内执行，防止部分命令失败造成的数据不一致。
 *  3.删除用户下的标签
    
        srem user:1:tags tag1 tag5
 *  4.删除标签下的用户
    
        srem tag1:users user:1
        srem tag5:users user:1
 *  5.计算用户共同感兴趣的标签  
    可以使用sinter命令，来计算用户共同感兴趣的标签，如下代码所示：
    
        sinter user:1:tags user:2:tags

> 上面只是给出了使用Redis集合类型实现标签的基本思路，实际上一个标签系统远比这个要复杂的多，不过集合类型的应用场景通常为以下几种：
> 
>  *  sadd = Tagging（标签）
>  *  spop / srandmember = Random item （生成随机数，比如抽奖）
>  *  sadd + sinter = Social Graph（社交需求）

# 有序集合zset #

## 内部编码 ##

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

*  ziplist（压缩列表）：当有序集合的元素个数小于zset-max-ziplist-entries配置（默认128个），同时每个元素的值都小于zset-max-ziplist-value配置（默认64字节）时，Redis会用ziplist来作为有序集合的内部实现，ziplist可以有效减少内存的使用。
 *  skiplist（跳跃表）：当ziplist条件不满足时，有序集合会使用skiplist作为内部实现，因为此时ziplist的读写效率会下降。

下面用示例来说明：

1.  当元素个数较少且每个元素较小时，内部编码为ziplist：
    
        127.0.0.1:6379> zadd zsetkey 50 e1 60 e2 30 e3
        (integer) 3
        127.0.0.1:6379> object encoding zsetkey
        "ziplist"
2.  当元素个数超过128个，内部编码变为skiplist：
    
        127.0.0.1:6379> zadd zsetkey 50 e1 60 e2 30 e3 12 e4 ...忽略... 84 e129
        (integer) 129
        127.0.0.1:6379> object encoding zsetkey
        "skiplist"
3.  当某个元素大于64字节时，内部编码也会变为skiplist：
    
        127.0.0.1:6379> zadd zsetkey 20 "one string is bigger than 64 tyte .........................."
        (integer) 1
        127.0.0.1:6379> object encoding zsetkey
        "skiplist"

## 使用场景 ##

有序集合比较典型的使用场景就是排行榜系统。例如视频网站需要对用户上传的视频做排行榜，榜单的维度可能是多个方面的：按照时间、按照播放数量、按照获得赞数。这里使用赞数这个维度，记录每天用户上传食品的排行榜。主要需要实现以下4个功能。

*  1.添加用户赞数  
    例如用户mike上传了一个视频，并获得了3个赞，可以使用有序集合的zadd和zincrby功能：
    
        zadd user:ranking:2019_07_31 3 mike
    
    如果之后再获得一个赞，可以使用zincrby：
    
        zincrby user:ranking:2019_07_31 1 mike
 *  2.取消用户赞数  
    由于各种原因（例如用户注销、用户作弊）需要将用户删除，此时需要将用户从榜单中删除掉，可以使用 zrem。例如删除成员tom：
    
        zrem user:ranking:2019_07_31 tom
 *  3.展示获取赞数最多的十个用户  
    此功能使用 zrevrange 命令实现：
    
        zrevrangebyrank user:ranking:2019_07_31 0 9
 *  4.展示用户信息以及用户分数  
    此功能将用户名作为键后缀，将用户信息保存在哈希类型中，至于用户的分数和排名可以使用 zscore 和 zrank 两个功能：
    
        hgetall user:info:tom
        zscore user:ranking:2019_07_31 mike
        zrank user:ranking:2019_07_31 mike

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70]: /images/20211116/0aef3f4803f7482a9622514cc792e12a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 1]: /images/20211116/932b03a11fe94da7ad955fa0940a1310.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MDk1MDU1_size_16_color_FFFFFF_t_70 2]: /images/20211116/ce15b7cefbfe49f4ad39112b79fdb5a9.png