1
// 添加元素
2
stringRedisTemplate.opsForSet().add("user:tags", "java", "redis", "spring");
3

4
// 判断元素是否存在
5
Boolean exists = stringRedisTemplate.opsForSet().isMember("user:tags", "java");
6

7
// 获取所有元素
8
Set<String> tags = stringRedisTemplate.opsForSet().members("user:tags");
9

10
// 删除元素
11
stringRedisTemplate.opsForSet().remove("user:tags", "java");
12

13
// 获取集合大小
14
Long size = stringRedisTemplate.opsForSet().size("user:tags");
15

16
// 随机获取元素
17
String randomTag = stringRedisTemplate.opsForSet().randomMember("user:tags");

1
# 添加元素
2
SADD user:tags java redis spring
3

4
# 判断元素是否存在
5
SISMEMBER user:tags java
6

7
# 获取所有元素
8
SMEMBERS user:tags
9

10
# 删除元素
11
SREM user:tags java
12

13
# 获取集合大小
14
SCARD user:tags
15

16
# 随机获取元素
17
SRANDMEMBER user:tags

1
// 交集：用户1和用户2共同的标签
2
Set<String> intersection = stringRedisTemplate.opsForSet()
3
    .intersect("user:1:tags", "user:2:tags");
4

5
// 并集：用户1和用户2所有的标签
6
Set<String> union = stringRedisTemplate.opsForSet()
7
    .union("user:1:tags", "user:2:tags");
8

9
// 差集：用户1有但用户2没有的标签
10
Set<String> difference = stringRedisTemplate.opsForSet()
11
    .difference("user:1:tags", "user:2:tags");

1
// 添加元素
2
stringRedisTemplate.opsForZSet().add("blog:liked:1001", "user123", System.currentTimeMillis());
3

4
// 批量添加
5
Set<ZSetOperations.TypedTuple<String>> tuples = new HashSet<>();
6
tuples.add(ZSetOperations.TypedTuple.of("user1", 100.0));
7
tuples.add(ZSetOperations.TypedTuple.of("user2", 90.0));
8
stringRedisTemplate.opsForZSet().add("leaderboard", tuples);
9

10
// 获取分数
11
Double score = stringRedisTemplate.opsForZSet().score("blog:liked:1001", "user123");
12

13
// 获取排名（升序，从0开始）
14
Long rank = stringRedisTemplate.opsForZSet().rank("leaderboard", "user1");
15

16
// 获取排名（降序，从0开始）
17
Long reverseRank = stringRedisTemplate.opsForZSet().reverseRank("leaderboard", "user1");
18

19
// 范围查询详解
20
// 假设leaderboard数据：user3->78分, user1->85分, user5->88分, user2->92分, user4->95分
21

22
// 1. 按排名查询（升序：从低分到高分）
23
Set<String> range = stringRedisTemplate.opsForZSet().range("leaderboard", 0, 4);
24
// 参数：(key, start排名, end排名) - 排名从0开始
25
// 结果：["user3", "user1", "user5", "user2", "user4"] (78→95分顺序)
26

27
// 2. 按排名查询（降序：从高分到低分）- 真正的排行榜前5名
28
Set<String> top5 = stringRedisTemplate.opsForZSet().reverseRange("leaderboard", 0, 4);
29
// 结果：["user4", "user2", "user5", "user1", "user3"] (95→78分顺序)
30

31
// 3. 按分数查询（升序）
32
Set<String> scoreRange = stringRedisTemplate.opsForZSet()
33
    .rangeByScore("leaderboard", 85, 95);
34
// 参数：(key, 最小分数, 最大分数)
35
// 结果：["user1", "user5", "user2", "user4"] (85→95分范围，升序)
36

37
// 4. 按分数查询（降序）
38
Set<String> highScores = stringRedisTemplate.opsForZSet()
39
    .reverseRangeByScore("leaderboard", 85, 95);
40
// 结果：["user4", "user2", "user5", "user1"] (95→85分范围，降序)
41

42
// 删除元素
43
stringRedisTemplate.opsForZSet().remove("blog:liked:1001", "user123");
44

45
// 增加分数
46
stringRedisTemplate.opsForZSet().incrementScore("leaderboard", "user1", 10.0);

1
# 添加元素
2
ZADD blog:liked:1001 1623456789123 user123
3

4
# 获取分数
5
ZSCORE blog:liked:1001 user123
6

7
# 获取排名
8
ZRANK leaderboard user1
9

10
# 范围查询
11
ZRANGE leaderboard 0 4
12
ZREVRANGE leaderboard 0 4  # 降序
13

14
# 按分数范围查询
15
ZRANGEBYSCORE leaderboard 90 100
16

17
# 删除元素
18
ZREM blog:liked:1001 user123

1
@Override
2
public Result likeBlog(Long id) {
3
    // 获取当前用户
4
    Long userId = UserHolder.getUser().getId();
5
    String key = RedisConstants.BLOG_LIKED_KEY + id;
6

7
    // 检查是否已点赞
8
    Double score = stringRedisTemplate.opsForZSet().score(key, userId.toString());
9

10
    if (score == null) {
11
        // 未点赞，执行点赞
12
        boolean isSuccess = update().setSql("liked = liked + 1").eq("id", id).update();
13
        if (isSuccess) {
14
            // 写入Redis，使用时间戳作为分数
15
            stringRedisTemplate.opsForZSet().add(key, userId.toString(), System.currentTimeMillis());
16
        }
17
    } else {
18
        // 已点赞，取消点赞
19
        boolean isSuccess = update().setSql("liked = liked - 1").eq("id", id).update();
20
        if (isSuccess) {
21
            stringRedisTemplate.opsForZSet().remove(key, userId.toString());
22
        }
23
    }
24

25
    return Result.ok();
26
}

1
@Override
2
public Result queryBlogLikes(Long id) {
3
    String key = RedisConstants.BLOG_LIKED_KEY + id;
4

5
    // 获取最早点赞的前5个用户
6
    Set<String> top5 = stringRedisTemplate.opsForZSet().range(key, 0, 4);
7

8
    if (top5 == null || top5.isEmpty()) {
9
        return Result.ok(Collections.emptyList());
10
    }
11

12
    // 类型转换和异常处理
13
    List<Long> ids = top5.stream()
14
        .map(item -> {
15
            try {
16
                return Long.valueOf(item);
17
            } catch (NumberFormatException e) {
18
                return null;
19
            }
20
        })
21
        .filter(Objects::nonNull)
22
        .collect(Collectors.toList());
23

24
    if (ids.isEmpty()) {
25
        return Result.ok(Collections.emptyList());
26
    }
27

28
    // 查询用户信息，保持顺序
29
    String orderByClause = "ORDER BY FIELD(id," +
30
        ids.stream().map(String::valueOf).collect(Collectors.joining(",")) + ")";
31

32
    List<UserDTO> userDTOS = userService.query()
33
        .in("id", ids)
34
        .last(orderByClause)
35
        .list()
36
        .stream()
37
        .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
38
        .collect(Collectors.toList());
39

40
    return Result.ok(userDTOS);
41
}

1
@Override
2
public void isBlogLiked(Blog blog) {
3
    UserDTO user = UserHolder.getUser();
4
    if (user == null) {
5
        return;
6
    }
7

8
    String key = RedisConstants.BLOG_LIKED_KEY + blog.getId();
9
    Double score = stringRedisTemplate.opsForZSet().score(key, user.getId().toString());
10
    blog.setIsLike(score != null);
11
}

1
// 使用当前时间戳，确保按点赞时间排序
2
stringRedisTemplate.opsForZSet().add(key, userId.toString(), System.currentTimeMillis());

1
// 安全的类型转换
2
List<Long> ids = top5.stream()
3
    .map(item -> {
4
        try {
5
            return Long.valueOf(item);
6
        } catch (NumberFormatException e) {
7
            log.warn("Invalid user id: {}", item);
8
            return null;
9
        }
10
    })
11
    .filter(Objects::nonNull)
12
    .collect(Collectors.toList());

1
// 使用 FIELD 函数保持Redis中的顺序
2
String orderByClause = "ORDER BY FIELD(id," +
3
    ids.stream().map(String::valueOf).collect(Collectors.joining(",")) + ")";