生活中各种排行榜可太多了。

比如经常有瓜的微博文娱榜：

掘金的文章榜：

作者榜：

微信的步数排行榜：

我最近订的自习室也有学习时长排行榜：

排行的依据各有不同，有的是根据学习时长，有的是根据阅读数、点赞数，有的是根据搜索次数等。

那这些排行榜是怎么实现的呢？

有的同学说，在 mysql 里加一个排序的字段，比如热度，然后根据根据这个字段来排序不就行了？

这样是能完成功能，但是效率太低了。

数据库的读写性能比 Redis 低很多，而且可能这个排序的依据只是一个临时数据，不需要存到数据库里。

一般涉及到排行榜，都是用 Redis 来做，因为它有一个专为排行榜准备的数据结构：有序集合 ZSET。

它有这些命令：

ZADD：往集合中添加成员

ZREM：从集合中删除成员

ZCARD：集合中的成员个数

ZSCORE：某个成员的分数

ZINCRBY：增加某个成员的分数

ZRANK：成员在集合中的排名

ZRANGE：打印某个范围内的成员

ZRANGESTORE：某个范围内的成员，放入新集合

ZCOUNT：集合中分数在某个返回的成员个数

ZDIFF：打印两个集合的差集

ZDIFFSTORE：两个集合的差集，放入新集合

ZINTER：打印两个集合的交集

ZINTERSTORE：两个集合的交集，放入新集合

ZINTERCARD：两个集合的交集的成员个数

ZUNION：打印两个集合的并集

ZUNIONSTORE：两个集合的并集，放回新集合

我们依次来试一下：

ZADD set1 1 mem1 2 mem2 3 mem3

在 RedisInsight 里输入命令，点击执行。

点击刷新就可以看到这个集合：

三个成员，分数分别是 1、2、3

用命令看的话就是 ZRANGE：

ZRANGE set1 0 -1

范围从 0 到 -1 就是返回全部。

默认是分数从小到大排序，也可以从大到小，加个 REV 就行：

ZRANGE set1 0 -1 REV

还可以用 ZRANGESTORE 把它存入新集合：

ZRANGESTORE rangeset set1 0 -1

查看下新集合：

ZRANGE rangeset 0 -1

删除个成员试试：

ZREM set1 mem1

再查看下：

ZRANGE set1 0 -1

用 ZCARD 查看集合的成员个数：

ZCARD set1

用 ZSCORE 查看某个成员的分数：

用 ZRANK 查看成员在集合内的排名：

ZRANK set1 mem2

然后用 ZINCRBY 给成员增加分数：

ZINCRBY set1 3 mem2

看下新排名：

ZRANGE set1 0 -1

mem2 就到下面去了。

再创建一个集合 set2：

ZADD set2 4 aaa 6 bbb

用 ZUNION 合并下：

ZUNION 2 set1 set2

还可以加上分数一起：

ZUNION 2 set1 set2 WITHSCORES

或者把合并后放到另一个集合：

ZUNIONSTORE set3 2 set1 set2


ZRANGE set3 0 -1

交集和差集的命令也差不多，就不一个个试了。

并集合并的时候相同的 key 的 score 会求和。

ZADD s1 1 aa 2 bb

ZADD s2 1 aa 3 cc

ZUNIONSTORE s3 2 s1 s2

在 s1 和 s2 集合中都有 aa，合并到 s3 之后 aa 的分数也合并了：

周榜、月榜、年榜就是这么实现的：

月榜就是对周榜的合并，然后年榜就是月榜的合并，最后就会算出一个新的排行榜。

我们用 Nest 实现下类似的排行榜功能：

nest new ranking-list-test

安装 redis 的包：

npm install --save redis

然后创建个 redis 模块：

nest g module redis
nest g service redis

在 RedisModule 创建连接 redis 的 provider，导出 RedisService，并把这个模块标记为 @Global 模块

import { Global, Module } from "@nestjs/common";
import { createClient } from "redis";
import { RedisService } from "./redis.service";

@Global()
@Module({
    providers: [
        RedisService,
        {
            provide: "REDIS_CLIENT",
            async useFactory() {
                const client = createClient({
                    socket: {
                        host: "localhost",
                        port: 6379,
                    },
                });
                await client.connect();
                return client;
            },
        },
    ],
    exports: [RedisService],
})
export class RedisModule {}

然后在 RedisService 里注入 REDIS_CLIENT，并封装一些方法：

import { Inject, Injectable } from "@nestjs/common";
import { RedisClientType } from "redis";

@Injectable()
export class RedisService {
    @Inject("REDIS_CLIENT")
    private redisClient: RedisClientType;

    async zRankingList(key: string, start: number = 0, end: number = -1) {
        const keys = await this.redisClient.zRange(key, start, end, {
            REV: true,
        });
        const rankingList = {};
        for (let i = 0; i < keys.length; i++) {
            rankingList[keys[i]] = await this.zScore(key, keys[i]);
        }
        return rankingList;
    }

    async zAdd(key: string, members: Record<string, number>) {
        const mems = [];
        for (let key in members) {
            mems.push({
                value: key,
                score: members[key],
            });
        }
        return await this.redisClient.zAdd(key, mems);
    }

    async zScore(key: string, member: string) {
        return await this.redisClient.zScore(key, member);
    }

    async zRank(key: string, member: string) {
        return await this.redisClient.zRank(key, member);
    }

    async zIncr(key: string, member: string, increment: number) {
        return await this.redisClient.zIncrBy(key, increment, member);
    }

    async zUnion(newKey: string, keys: string[]) {
        if (!keys.length) {
            return [];
        }
        if (keys.length === 1) {
            return this.zRankingList(keys[0]);
        }

        await this.redisClient.zUnionStore(newKey, keys);

        return this.zRankingList(newKey);
    }

    async keys(pattern: string) {
        return this.redisClient.keys(pattern);
    }
}

这里我们对 zset 的命令进行了封装，比如 zRange 只会返回成员名，我们顺带把分数也取出来。

暴露 zAdd、zScore、zRank、zIncr 等方法。

zUnion 要做下边界的处理，如果只传了一个 set 的名字，就染回这个 set 的内容，否则才合并。

创建一个 ranking 模块：

nest g module ranking
nest g controller ranking --no-spec
nest g service ranking --no-spec

我们就实现下自习室学习时长的月榜和年榜吧。

实现下 RankingService：

import { RedisService } from "./../redis/redis.service";
import { Inject, Injectable } from "@nestjs/common";
import * as dayjs from "dayjs";

@Injectable()
export class RankingService {
    @Inject(RedisService)
    redisService: RedisService;

    private getMonthKey() {
        const dateStr = dayjs().format("YYYY-MM");
        return `learning-ranking-month:${dateStr}`;
    }

    private getYearKey() {
        const dateStr = dayjs().format("YYYY");
        return `learning-ranking-year:${dateStr}`;
    }

    async join(name: string) {
        await this.redisService.zAdd(this.getMonthKey(), { [name]: 0 });
    }

    async addLearnTime(name: string, time: number) {
        await this.redisService.zIncr(this.getMonthKey(), name, time);
    }

    async getMonthRanking() {
        return this.redisService.zRankingList(this.getMonthKey(), 0, 10);
    }

    async getYearRanking() {
        const dateStr = dayjs().format("YYYY");
        const keys = await this.redisService.keys(
            `learning-ranking-month:${dateStr}-*`
        );

        return this.redisService.zUnion(this.getYearKey(), keys);
    }
}

这里用到了 dayjs，安装下：

npm install --save dayjs

月份的榜单是 learning-ranking-mongth:2024-01、learning-ranking-mongth:2024-02 这样的格式。

年份的榜单是 learning-ranking-mongth:2023、learning-ranking-mongth:2024 这样的格式。

我们用 dayjs 拿到当前的年份和月份，拼接出需要的 key。

年份的榜单就是拿到用 learning-ranking-month:当前年份- 开头的所有 zset，做下合并。

在 RankingController 加一下接口：

import { Controller, Get, Inject, Query } from "@nestjs/common";
import { RankingService } from "./ranking.service";

@Controller("ranking")
export class RankingController {
    @Inject(RankingService)
    rankingService: RankingService;

    @Get("join")
    async join(@Query("name") name: string) {
        await this.rankingService.join(name);
        return "success";
    }

    @Get("learn")
    async addLearnTime(
        @Query("name") name: string,
        @Query("time") time: string
    ) {
        await this.rankingService.addLearnTime(name, parseFloat(time));
        return "success";
    }

    @Get("monthRanking")
    async getMonthRanking() {
        return this.rankingService.getMonthRanking();
    }

    @Get("yearRanking")
    async getYearRanking() {
        return this.rankingService.getYearRanking();
    }
}

join 是加入自习室，learn 是增加学习时长，monthRanking 和 yearRanking 是拿到月榜和年榜。

把服务跑起来：

npm run start:dev

在 postman 里调用下：

localhost:3000/ranking/join?name=guang


localhost:3000/ranking/join?name=dong


localhost:3000/ranking/join?name=xiaohong

调用 join 接口，加入三个同学。

看下现在的月榜：

localhost:3000/ranking/monthRanking

在 RedisInsight 里看下：

然后调用 learn 接口，增加学习时长：

localhost:3000/ranking/learn?name=dong&time=1


localhost:3000/ranking/learn?name=guang&time=2


localhost:3000/ranking/learn?name=xiaohong&time=5


localhost:3000/ranking/monthRanking

我们改下本地时间（mac 和 windows 改本地时间的方式不一样）：

然后再调用 join 接口：

localhost:3000/ranking/join?name=guang


localhost:3000/ranking/join?name=dong


localhost:3000/ranking/join?name=xiaogang

之后增加学习时长：

localhost:3000/ranking/learn?name=dong&time=2


localhost:3000/ranking/learn?name=guang&time=3


localhost:3000/ranking/learn?name=xiaogang&time=4

然后看下 3 月份的月榜：

还有年榜：

可以看到，年榜是合并了所有月榜的结果。

在 RedisInsight 里看下：

每个月榜和年榜都是单独的 zset。

这样我们就实现了学习时长的排行榜。

至于用户自己的排名和时长，就用 zScore、zRank 来实现。

也就是这个我的排名功能：

案例代码上传了小册仓库

总结

生活中我们经常会见到各种排行榜，以及它们的周榜、月榜、年榜等。

这些排行榜的功能都是用 redis 的 zset 有序集合实现的。

它保存的值都有一个分数，会自动排序。

多个集合之间可以求并集、交集、差集。

通过并集的方式就能实现月榜合并成年榜的功能。

以后见到各种排行榜，你会不会想到 Redis 的 zset 呢？

上次更新:
贡献者: YNight