Spring Boot 3 整合 Redis：五种核心数据结构实战详解

Redis 的列表还支持阻塞操作，如 BLPOP 和 BRPOP。当列表为空时，这些命令可以阻塞等待，直到有元素被插入到列表中。这种阻塞操作使得列表非常适合用于实现消息队列等场景。

典型的应用场景 之一是作为消息队列。可以使用 LPUSH 将消息放入队列的头部，使用 RPOP 或 BRPOP 从队列的尾部弹出消息进行处理。这种方式实现的消息队列简单高效，适用于各种异步处理场景。另一个应用场景是任务调度，在异步任务分发系统中，可以将任务放入列表中，由多个消费者去消费任务，实现任务的并行处理。

列表采用双向链表（quicklist）实现。对于较短的列表，Redis 会使用压缩列表（ziplist）来节省内存。压缩列表是一种紧凑的内存数据结构，可以在一定程度上减少内存占用。但是，当列表长度增加时，为了保证操作的时间复杂度，Redis 会自动将其转换为真正的双向链表。这样可以在不同的场景下平衡内存使用和操作效率。

2. 代码示例

（1）左侧插入元素

以下方法将一个元素插入到指定列表的左侧。使用 redisTemplate.opsForList() 获取针对列表类型的操作对象，调用 leftPush 方法，传入键和要插入的元素值。随着元素不断插入，列表的头部不断变化，最先插入的元素会逐渐移向列表的尾部。

public void leftPush(String key, Object value) {
    redisTemplate.opsForList().leftPush(key, value);
}

（2）依次向 list 中存入元素 aaa，bbb，ccc，aaa，ddd：

@PostMapping("/leftPush")
public void leftPush() {
    String aaa = "aaa", bbb = "bbb", ccc = "ccc", ddd = "ddd";
    userService.leftPush(aaa);
    userService.leftPush(bbb);
    userService.leftPush(ccc);
    userService.leftPush(aaa);
    userService.leftPush(ddd);
}

（3）可以看到 redis 中，先存储的在右侧（底部），后存储的在左侧（上部）：

（4）右侧插入元素

该方法是从列表右侧插入元素：

public void rightPush(String key, Object value) {
    redisTemplate.opsForList().rightPush(key, value);
}

@PostMapping("/rightPush")
public void rightPush() {
    String eee = "eee", fff = "fff";
    userService.rightPush(eee);
    userService.rightPush(fff);
}

查看 redis 中的元素，eee 和 fff 是从列表右侧插入：

（5）从列表左侧和右侧取出元素

可以从列表左侧或者右侧取出（删除）一个元素。即使用 leftPop 和 rightPop 方法，从列表的左侧或右侧移除并返回一个元素。如果列表为空，将返回 null。

/* * 从左侧取出一个元素 */
public Object leftPop(String key) {
    return redisTemplate.opsForList().leftPop(key);
}

/* * 从右侧取出一个元素 */
public Object rightPop(String key) {
    return redisTemplate.opsForList().rightPop(key);
}

从左侧取出了元素 ddd，从右侧取出了元素 fff：

（6）获取列表长度

// 获取列表长度
public Long listLength(String key) {
    return redisTemplate.opsForList().size(key);
}

请求结果为 5：

（7）获取列表指定范围的元素

以下方法的作用是获取指定键对应列表中从 start 索引到 end 索引范围内的元素。它通过调用 redisTemplate.opsForList().range(key, start, end) 实现，可用于获取列表的一部分进行处理或展示，其中列表的第一个元素从 0 开始。

// 获取列表指定范围的元素
public List<Object> range(String key, long start, long end) {
    return redisTemplate.opsForList().range(key, start, end);
}

Redis 列表的原数据如下图所示：

比如获取列表从索引 1（第二个元素）开始至索引 4：

/* * 获取列表指定范围元素 */
@GetMapping("range")
public List<Object> range(String key) {
    return userService.range(key, 1, 4);
}

得出如下结果：

获取整个列表，输入起始位置为 0：

/* * 获取列表指定元素 */
@GetMapping("range")
public List<Object> range(String key) {
    return userService.range(key, 0, -1);
}

（三）无序集合（Set）

1. Redis Set 简介

Redis 的集合（Set）是一个无序的、唯一的元素集合。这意味着集合中的元素是唯一的，不会有重复元素。集合提供了类似于数学集合的操作，支持交集（SINTER）、并集（SUNION）、差集（SDIFF）等。

常见的 Redis 操作 包括 SADD 用于向集合中添加元素、SREM 用于从集合中删除元素、SISMEMBER 用于判断一个元素是否在集合中、SMEMBERS 用于获取集合中的所有元素等。

典型的应用场景 之一是标签系统。可以将用户标签存储为集合，每个集合代表一个用户群体。通过集合的交集、并集和差集等操作，可以方便地找出同时拥有某几个标签的用户，或者找出具有特定标签组合的用户群体。另一个应用场景是去重功能。在某些场景下，比如热门搜索词、访问日志的去重等，可以通过集合的唯一性特性来避免重复数据的存储和处理。

集合在小集合时使用整数集合（intset）来存储元素。整数集合是一种紧凑的整数存储结构，可以节省内存。当集合中的元素数量增加或者元素类型不是整数时，会自动转换为哈希表（hashtable）实现。通过哈希表的快速查找特性，可以实现 O(1) 的时间复杂度来判断元素是否存在于集合中。

2. 代码示例

Redis Util 工具类的各个方法对应 Redis 集合的不同操作：

package com.jsglxx.redis;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class CacheUtil {
    private final RedisTemplate<String, Object> redisTemplate;

    public CacheUtil(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // 向集合中添加元素
    public void addToSet(String key, Object value) {
        redisTemplate.opsForSet().add(key, value);
    }

    // 从集合中移除元素
    public void removeFromSet(String key, Object value) {
        redisTemplate.opsForSet().remove(key, value);
    }

    // 判断元素是否在集合中
    public boolean isMemberOfSet(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    // 获取集合中的所有元素
    public Set<Object> getSetMembers(String key) {
        return redisTemplate.opsForSet().members(key);
    }
}

• addToSet 方法使用 redisTemplate.opsForSet().add(key, value) 向指定键对应的集合中添加元素。
• removeFromSet 方法使用 redisTemplate.opsForSet().remove(key, value) 从集合中移除指定元素。
• isMemberOfSet 方法使用 redisTemplate.opsForSet().isMember(key, value) 判断给定元素是否在集合中。
• getSetMembers 方法使用 redisTemplate.opsForSet().members(key) 获取集合中的所有元素。

3. 测试方法

在以下测试方法中，首先向两个集合中添加元素，然后分别测试各个方法，输出结果以验证方法的正确性。

public void testSet() {
    String setKey1 = "set1";
    String setKey2 = "set2";
    // 向集合 1 添加元素
    cacheUtil.addToSet(setKey1, "element1");
    cacheUtil.addToSet(setKey1, "element2");
    cacheUtil.addToSet(setKey1, "element3");
    // 向集合 2 添加元素
    cacheUtil.addToSet(setKey2, "element2");
    cacheUtil.addToSet(setKey2, "element3");
    cacheUtil.addToSet(setKey2, "element4");
    // 判断元素是否在集合中
    boolean isMember = cacheUtil.isMemberOfSet(setKey1, "element2");
    System.out.println("【元素 element2】在【集合 set1】中吗？" + isMember);
    // 获取集合中的所有元素
    Set<Object> setMembers1 = cacheUtil.getSetMembers(setKey1);
    System.out.println("【集合 set1】中的所有元素：" + setMembers1);
    Set<Object> setMembers2 = cacheUtil.getSetMembers(setKey2);
    System.out.println("【集合 set2】中的所有元素：" + setMembers2);
}

4. 结果输出

【元素 element2】在【集合 set1】中吗？true 【集合 set1】中的所有元素:[element1, element2, element3] 【集合 set2】中的所有元素:[element2, element3, element4]

（四）Hash

1. Redis 哈希介绍

Redis 的哈希（Hash）是一个键值对集合，非常适合用于存储对象。每个键可以有多个字段，每个字段都对应一个值。这种结构使得可以将一个复杂的对象拆分成多个字段进行存储，方便进行管理和查询。

常用的 Redis 操作 包括 HSET 用于设置字段的值、HGET 用于获取字段的值、HDEL 用于删除特定字段等。这些操作使得对哈希的管理非常方便，可以根据需要快速地添加、修改和删除字段。

典型的应用场景 之一是存储用户信息。可以将用户 ID 作为键，用户的各种属性（如姓名、年龄、性别等）作为字段，存储在哈希中。这样可以避免将整个用户对象序列化成字符串进行存储，在查询和更新用户信息时更加高效。另一个应用场景是配置项管理，将不同的配置项存储在哈希中，方便根据字段名快速访问和更新某个特定的配置。

哈希使用了两种底层数据结构。在小数据量时，使用压缩列表（ziplist）来存储哈希。压缩列表是一种紧凑的内存数据结构，可以节省内存空间。但是，随着哈希表的增长，当数据量达到一定程度时，会自动转换为哈希表（hashtable）。哈希表具有更高的查询效率，可以保证在大数据量时仍然能够快速地进行字段的查找和操作。

2. Redis 工具类代码示例

package com.jsglxx.redis;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class CacheUtil {
    private final RedisTemplate<String, Object> redisTemplate;

    public CacheUtil(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // 设置哈希字段的值
    public void setHashField(String key, String field, Object value) {
        redisTemplate.opsForHash().put(key, field, value);
    }

    // 获取哈希字段的值
    public Object getHashField(String key, String field) {
        return redisTemplate.opsForHash().get(key, field);
    }

    // 删除哈希字段
    public void deleteHashField(String key, String... fields) {
        redisTemplate.opsForHash().delete(key, fields);
    }

    // 获取哈希的所有字段名
    public Set<Object> getHashKeys(String key) {
        return redisTemplate.opsForHash().keys(key);
    }

    // 获取哈希的所有值
    public List<Object> getHashValues(String key) {
        return redisTemplate.opsForHash().values(key);
    }

    // 获取哈希的所有字段和值
    public Map<Object, Object> getHashAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }
}

• setHashField 方法使用 redisTemplate.opsForHash().put(key, field, value) 将指定的值设置到哈希表中给定的字段。
• getHashField 方法使用 redisTemplate.opsForHash().get(key, field) 获取哈希表中指定字段的值。
• deleteHashField 方法使用 redisTemplate.opsForHash().delete(key, fields) 删除哈希表中的一个或多个字段。
• getHashKeys 方法使用 redisTemplate.opsForHash().keys(key) 获取哈希表中的所有字段名。
• getHashValues 方法使用 redisTemplate.opsForHash().values(key) 获取哈希表中的所有值。
• getHashAll 方法使用 redisTemplate.opsForHash().entries(key) 获取哈希表中的所有字段和值，以一个 Map 的形式返回。

3. 测试类代码

在测试类中，首先设置哈希表的字段值，然后分别测试各个方法，输出结果以验证方法的正确性。

public void testHash() {
    String hashKey = "myHash";
    // 设置哈希字段的值
    cacheUtil.setHashField(hashKey, "field1", "value1");
    cacheUtil.setHashField(hashKey, "field2", "value2");
    cacheUtil.setHashField(hashKey, "field3", "value3");
    // 获取哈希字段的值
    Object value = cacheUtil.getHashField(hashKey, "field2");
    System.out.println("field2 的值为：" + value);
    // 删除哈希字段
    cacheUtil.deleteHashField(hashKey, "field1");
    // 获取哈希的所有字段名
    Set<Object> keys = cacheUtil.getHashKeys(hashKey);
    System.out.println("Hash 表中的所有键：" + keys);
    // 获取哈希的所有值
    List<Object> values = cacheUtil.getHashValues(hashKey);
    System.out.println("Hash 表中的所有值：" + values);
    // 获取哈希的所有字段和值
    Map<Object, Object> allEntries = cacheUtil.getHashAll(hashKey);
    System.out.println("hash 表中的所有键值对：" + allEntries);
}

4. 输出结果

field2 的值为：value2 Hash 表中的所有键:[field2, field3]Hash 表中的所有值:[value2, value3] hash 表中的所有键值对:{field2=value2, field3=value3}

（五）有序集合（Zset）

1. Redis Zset 简介

Redis 的有序集合是一种特殊的集合，其中每个元素都关联一个分数。集合中的元素会按照分数排序。支持的操作包括 ZADD 用于向有序集合中添加元素并指定分数、ZRANGE 和 ZREVRANGE 分别用于按照分数从小到大和从大到小获取元素、ZCOUNT 用于统计分数范围内的元素数量等。

典型的应用场景 之一是排行榜。比如在游戏中，可以将玩家的分数作为有序集合的元素分数，玩家 ID 作为元素，通过 ZADD 添加玩家及其分数。然后可以使用 ZRANGE 或 ZREVRANGE 获取排名靠前的玩家。另一个应用场景是延迟任务。可以通过设置元素的分数为任务执行的时间，将任务存储在有序集合中。然后按照时间从集合中取出需要执行的任务进行处理。

有序集合底层使用的是跳表（Skiplist）和哈希表相结合的数据结构。跳表是一种高效的有序数据结构，它使有序集合支持快速的范围查询和插入操作，时间复杂度为 O(log n)。而哈希表则保证了元素的快速定位，使得可以在 O(1) 的时间复杂度内判断元素是否存在于有序集合中。这种结合的方式既保证了查询效率，又能够有效地管理元素的顺序。

2. Redis 工具类代码示例

package com.jsglxx.redis;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class CacheUtil {
    private final RedisTemplate<String, Object> redisTemplate;

    public CacheUtil(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // 添加成员到有序集合
    public void addToSortedSet(String key, double score, Object member) {
        redisTemplate.opsForZSet().add(key, member, score);
    }

    // 从有序集合中移除成员
    public void removeFromSortedSet(String key, Object... members) {
        redisTemplate.opsForZSet().remove(key, members);
    }

    // 获取成员的分值
    public Double getScore(String key, Object member) {
        return redisTemplate.opsForZSet().score(key, member);
    }

    // 获取有序集合指定范围的成员（从小到大排序）
    public Set<Object> getRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().range(key, start, end);
    }

    // 获取有序集合指定范围的成员（从大到小排序）
    public Set<Object> getReverseRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    // 获取分值范围内的成员（从小到大排序）
    public Set<Object> getRangeByScore(String key, double minScore, double maxScore) {
        return redisTemplate.opsForZSet().rangeByScore(key, minScore, maxScore);
    }

    // 获取分值范围内的成员（从大到小排序）
    public Set<Object> getReverseRangeByScore(String key, double maxScore, double minScore) {
        return redisTemplate.opsForZSet().reverseRangeByScore(key, maxScore, minScore);
    }

    // 获取有序集合的成员数量
    public Long getCardinality(String key) {
        return redisTemplate.opsForZSet().zCard(key);
    }

    // 获取分值范围内的成员数量
    public Long getCountByScore(String key, double minScore, double maxScore) {
        return redisTemplate.opsForZSet().count(key, minScore, maxScore);
    }
}

• addToSortedSet 方法使用 redisTemplate.opsForZSet().add(key, member, score) 向有序集合添加成员和分值。
• removeFromSortedSet 方法使用 redisTemplate.opsForZSet().remove(key, members) 从有序集合中移除指定成员。
• getScore 方法使用 redisTemplate.opsForZSet().score(key, member) 获取指定成员的分值。
• getRange 和 getReverseRange 方法分别用于获取有序集合指定范围的成员，按照分值从小到大和从大到小排序。
• getRangeByScore 和 getReverseRangeByScore 方法用于获取分值范围内的成员，同样按照分值从小到大和从大到小排序。
• getCardinality 方法使用 redisTemplate.opsForZSet().zCard(key) 获取有序集合的成员数量。
• getCountByScore 方法使用 redisTemplate.opsForZSet().count(key, minScore, maxScore) 获取分值范围内的成员数量。

3. 测试类代码

在测试类中，首先向有序集合添加成员，然后分别测试各个方法，输出结果以验证方法的正确性。最后，从有序集合中移除一个成员。

public void testSortedSetOperations() {
    String sortedSetKey = "mySortedSet";
    // 添加成员到有序集合
    cacheUtil.addToSortedSet(sortedSetKey, 10.0, "member1");
    cacheUtil.addToSortedSet(sortedSetKey, 20.0, "member2");
    cacheUtil.addToSortedSet(sortedSetKey, 15.0, "member3");
    // 获取成员的分值
    Double score = cacheUtil.getScore(sortedSetKey, "member2");
    System.out.println("member2 的分值：" + score);
    // 获取有序集合指定范围的成员（从小到大排序）
    Set<Object> range = cacheUtil.getRange(sortedSetKey, 0, 1);
    System.out.println("有序集合 ascending（0-1）的成员从小到大排序：" + range);
    // 获取有序集合指定范围的成员（从大到小排序）
    Set<Object> reverseRange = cacheUtil.getReverseRange(sortedSetKey, 0, 1);
    System.out.println("有序集合 ascending（0-1）的成员从大到小排序：" + reverseRange);
    // 获取分值范围内的成员（从小到大排序）
    Set<Object> rangeByScore = cacheUtil.getRangeByScore(sortedSetKey, 12.0, 18.0);
    System.out.println("ascending 集合内分值在 12.0 - 18.0 之间的成员：" + rangeByScore);
    // 获取分值范围内的成员（从大到小排序）
    Set<Object> reverseRangeByScore = cacheUtil.getReverseRangeByScore(sortedSetKey, 12.0, 18.0);
    System.out.println("分值 12.0 - 18.0 之间的成员从大到小排序：" + reverseRangeByScore);
    // 获取有序集合的成员数量
    Long cardinality = cacheUtil.getCardinality(sortedSetKey);
    System.out.println("集合内成员数量：" + cardinality);
    // 获取分值范围内的成员数量
    Long countByScore = cacheUtil.getCountByScore(sortedSetKey, 10.0, 20.0);
    System.out.println("10.0-20.0 分值范围内的成员数量：" + countByScore);
    // 从有序集合中移除成员
    cacheUtil.removeFromSortedSet(sortedSetKey, "member1");
}

4. 输出结果

member2 的分值:20.0 有序集合 ascending（0-1）的成员从小到大排序:[member1, member3] 有序集合 ascending（0-1）的成员从大到小排序:[member2, member3] ascending 集合内分值在 12.0-18.0 之间的成员:[member3] 分值 12.0-18.0 之间的成员从大到小排序:[member3] 集合内成员数量:310.0-20.0 分值范围内的成员数量:3

三、结尾

总之，Spring Boot 3 与 Redis 的整合为开发者提供了强大的数据存储和处理能力。通过对 Redis 的五种数据结构的熟练操作，我们可以根据不同的业务需求选择合适的数据结构，实现高效的数据管理和快速的访问。无论是缓存数据、构建消息队列、存储用户信息还是进行复杂的排序操作，Redis 都能在 Spring Boot 3 应用中发挥重要作用。不断探索和优化 Redis 的使用，将有助于我们构建更加健壮、高效的应用程序，满足不断变化的业务需求。