likes
comments
collection
share

Redis场景实战：各种排行榜与评分系统都给你写好了

作者站长头像
站长
· 阅读数 29

Redis场景实战：各种排行榜与评分系统

使用有序集合（ZSet）实现排行榜

有序集合（ZSet）的基本概念

有序集合（ZSet）是Redis中的一种数据结构，它不仅存储了元素的值，还为每个元素关联了一个分数（score）。有序集合中的元素是按照分数进行排序的。

定义

有序集合是一个包含唯一字符串成员的集合，每个成员都有一个与之相关的分数。成员在集合中的排序是基于分数的，从最低到最高。

常见操作命令

  • ZADD：向有序集合添加一个或多个成员，或者更新已存在成员的分数。
  • ZREM：移除有序集合中的一个或多个成员。
  • ZRANGE：返回有序集合中指定区间内的成员。
  • ZRANGEBYSCORE：返回有序集合中指定分数范围内的成员。
  • ZSCORE：返回有序集合中指定成员的分数。

实现排行榜

排行榜的基本需求和设计

一个典型的排行榜需要支持以下基本功能：

  • 添加用户及其分数
  • 删除用户
  • 查询用户的排名及分数
  • 获取前N名用户

封装Leaderboard类

为了更好地管理排行榜，我们可以封装一个Leaderboard类。以下是实现代码：

import { Redis as RedisClient } from "ioredis";
import { CacheSortedSet } from "../TSRedisCacheKit/SortedSet";

export class Leaderboard {
  private redis: RedisClient;
  private leaderboard: CacheSortedSet;

  /**
   * 构造函数
   * @param {RedisClient} redis - Redis客户端实例
   * @param {string} leaderboardKey - 排行榜的键
   */
  constructor(redis: RedisClient, leaderboardKey: string) {
    this.redis = redis;
    this.leaderboard = new CacheSortedSet(
      leaderboardKey,
      { appName: "app", funcName: "leaderboard" },
      redis
    );
  }

  /**
   * 添加用户及其分数
   * @param {string} userId - 用户ID
   * @param {number} score - 用户分数
   */
  async addUser(userId: string, score: number) {
    await this.leaderboard.add(score, userId);
  }

  /**
   * 删除用户
   * @param {string} userId - 用户ID
   */
  async removeUser(userId: string) {
    await this.leaderboard.remove(userId);
  }

  /**
   * 获取用户排名及分数
   * @param {string} userId - 用户ID
   * @returns {Promise<{rank: number, score: number}>} 用户的排名和分数
   */
  async getUserRank(userId: string) {
    const rank = await this.redis.zrevrank(
      this.leaderboard.createKey(),
      userId
    );
    const score = await this.leaderboard.score(userId);
    return { rank, score };
  }

  /**
   * 获取前N名用户
   * @param {number} n - 要获取的用户数量
   * @returns {Promise<Array<{member: string, score: number}>>} 前N名用户及其分数
   */
  async getTopUsers(n: number) {
    return await this.leaderboard.rangeWithScores(0, n - 1);
  }

  /**
   * 实时更新用户分数
   * @param {string} userId - 用户ID
   * @param {number} score - 新增的分数
   */
  async updateScore(userId: string, score: number) {
    await this.leaderboard.incrementBy(userId, score);
  }
}

实践案例

游戏积分排行榜

在游戏中，玩家的积分是动态变化的，通过有序集合可以方便地管理和查询玩家的积分排名。以下是一个示例代码，展示如何使用封装的 Leaderboard 类来实现游戏积分排行榜：

import { Redis as RedisClient } from "ioredis";
import { Leaderboard } from './leaderboard'; 

(async () => {
  const redis = new RedisClient({ host: 'localhost', port: 6379 });
  const leaderboard = new Leaderboard(redis, 'game:leaderboard');

  // 添加玩家及其积分
  await leaderboard.addUser('player1', 100);
  await leaderboard.addUser('player2', 200);
  await leaderboard.addUser('player3', 150);

  // 获取前3名玩家
  console.log(await leaderboard.getTopUsers(3));

  // 获取指定玩家的排名及积分
  console.log(await leaderboard.getUserRank('player1'));

  // 实时更新玩家积分
  await leaderboard.updateScore('player1', 10);

  // 获取更新后的前3名玩家
  console.log(await leaderboard.getTopUsers(3));

  redis.quit();
})();

在这个示例中，我们创建了一个游戏积分排行榜，并添加了三名玩家及其积分。通过 getTopUsers 方法，我们可以获取前3名玩家的排名和积分。通过 getUserRank 方法，我们可以获取指定玩家的排名和积分。通过 updateScore 方法，我们可以实时更新玩家的积分，并再次获取更新后的前3名玩家。

销售排行榜

在电商平台上，可以使用有序集合来管理商品的销售数据，并生成实时的销售排行榜。以下是一个示例代码，展示如何使用封装的 Leaderboard 类来实现销售排行榜：

import { Redis as RedisClient } from "ioredis";
import { Leaderboard } from './leaderboard';

(async () => {
  const redis = new RedisClient({ host: 'localhost', port: 6379 });
  const leaderboard = new Leaderboard(redis, 'sales:leaderboard');

  // 添加商品及其销售数据
  await leaderboard.addUser('product1', 500);
  await leaderboard.addUser('product2', 800);
  await leaderboard.addUser('product3', 600);

  // 获取前3名商品
  console.log(await leaderboard.getTopUsers(3));

  // 获取指定商品的排名及销售数据
  console.log(await leaderboard.getUserRank('product1'));

  // 实时更新商品销售数据
  await leaderboard.updateScore('product1', 100);

  // 获取更新后的前3名商品
  console.log(await leaderboard.getTopUsers(3));

  redis.quit();
})();

在这个示例中，我们创建了一个销售排行榜，并添加了三件商品及其销售数据。通过 getTopUsers 方法，我们可以获取前3名商品的排名和销售数据。通过 getUserRank 方法，我们可以获取指定商品的排名和销售数据。通过 updateScore 方法，我们可以实时更新商品的销售数据，并再次获取更新后的前3名商品。

通过这些示例，我们可以看到如何使用封装好的 Leaderboard 类来实现动态更新的游戏积分排行榜和销售排行榜。这种方法不仅高效，而且易于扩展和维护。希望这些示例代码能为您在实际开发中提供有价值的参考。

评分系统的设计与实现

评分系统的基本概念

评分系统广泛应用于电影、产品等各种评价场景中。通过评分系统，可以对用户的评价进行统计和分析。

评分的定义和用途

评分系统的核心是对项目（如电影、产品）进行评分，并根据评分进行排序和查询。

常见操作命令

  • ZINCRBY：增加有序集合中成员的分数。
  • ZSCORE：返回有序集合中指定成员的分数。
  • ZRANK：返回有序集合中指定成员的排名（从低到高）。
  • ZREVRANK：返回有序集合中指定成员的排名（从高到低）。

封装RatingSystem类

为了更好地管理评分系统，我们可以封装一个RatingSystem类。以下是实现代码：

import { Redis as RedisClient } from "ioredis";
import { CacheSortedSet } from "../TSRedisCacheKit/SortedSet";

export class RatingSystem {
  private redis: RedisClient;
  private rating: CacheSortedSet;

  /**
   * 构造函数
   * @param {RedisClient} redis - Redis客户端实例
   * @param {string} ratingKey - 评分系统的键
   */
  constructor(redis: RedisClient, ratingKey: string) {
    this.redis = redis;
    this.rating = new CacheSortedSet(
      ratingKey,
      { appName: "app", funcName: "rating" },
      redis
    );
  }

  /**
   * 添加评分
   * @param {string} itemId - 项目ID
   * @param {number} score - 评分
   */
  async addRating(itemId: string, score: number) {
    await this.rating.incrementBy(itemId, score);
  }

  /**
   * 获取评分
   * @param {string} itemId - 项目ID
   * @returns {Promise<number>} 评分
   */
  async getRating(itemId: string) {
    return await this.rating.score(itemId);
  }

  /**
   * 获取排名
   * @param {string} itemId - 项目ID
   * @returns {Promise<number | null>} 排名，若没有找到则返回null
   */
  async getRatingRank(itemId: string) {
    const rank = await this.redis.zrevrank(this.rating.createKey(), itemId);
    return rank;
  }

  /**
   * 实时更新评分
   * @param {string} itemId - 项目ID
   * @param {number} score - 新增的评分
   */
  async updateRating(itemId: string, score: number) {
    await this.rating.incrementBy(itemId, score);
  }
}

实践案例

电影评分系统

在电影评分系统中，用户可以对电影进行评分，通过有序集合可以方便地管理和查询电影的评分及排名。以下是一个示例代码，展示如何使用封装的 RatingSystem 类来实现电影评分系统：

import { Redis as RedisClient } from "ioredis";
import { RatingSystem } from './ratingSystem'; 

(async () => {
  const redis = new RedisClient({ host: 'localhost', port: 6379 });
  const ratingSystem = new RatingSystem(redis, 'movie:ratings');

  // 添加电影评分
  await ratingSystem.addRating('movie1', 5);
  await ratingSystem.addRating('movie2', 3);
  await ratingSystem.addRating('movie3', 4);

  // 获取指定电影的评分
  console.log(await ratingSystem.getRating('movie1'));

  // 获取指定电影的排名
  console.log(await ratingSystem.getRatingRank('movie1'));

  // 实时更新电影评分
  await ratingSystem.updateRating('movie1', 2);

  // 获取更新后的电影评分
  console.log(await ratingSystem.getRating('movie1'));

  redis.quit();
})();

在这个示例中，我们创建了一个电影评分系统，并添加了三部电影及其评分。通过 getRating 方法，我们可以获取指定电影的评分。通过 getRatingRank 方法，我们可以获取指定电影的排名。通过 updateRating 方法，我们可以实时更新电影的评分，并再次获取更新后的电影评分。

产品评分系统

在电商平台上，可以使用有序集合来管理产品的评分数据，并生成实时的产品评分排行榜。以下是一个示例代码，展示如何使用封装的 RatingSystem 类来实现产品评分系统：

import { Redis as RedisClient } from "ioredis";
import { RatingSystem } from './ratingSystem'; 

(async () => {
  const redis = new RedisClient({ host: 'localhost', port: 6379 });
  const ratingSystem = new RatingSystem(redis, 'product:ratings');

  // 添加产品评分
  await ratingSystem.addRating('product1', 4.5);
  await ratingSystem.addRating('product2', 3.8);
  await ratingSystem.addRating('product3', 4.0);

  // 获取指定产品的评分
  console.log(await ratingSystem.getRating('product1'));

  // 获取指定产品的排名
  console.log(await ratingSystem.getRatingRank('product1'));

  // 实时更新产品评分
  await ratingSystem.updateRating('product1', 0.5);

  // 获取更新后的产品评分
  console.log(await ratingSystem.getRating('product1'));

  redis.quit();
})();

在这个示例中，我们创建了一个产品评分系统，并添加了三款产品及其评分。通过 getRating 方法，我们可以获取指定产品的评分。通过 getRatingRank 方法，我们可以获取指定产品的排名。通过 updateRating 方法，我们可以实时更新产品的评分，并再次获取更新后的产品评分。

通过这些示例，我们可以看到如何使用封装好的 RatingSystem 类来实现动态更新的电影评分系统和产品评分系统。这种方法不仅高效，而且易于扩展和维护。希望这些示例代码能为您在实际开发中提供有价值的参考。

动态更新的排行榜和评分系统

动态更新排行榜

实现实时更新排行榜数据的需求

在一些实时性要求较高的场景中，如竞赛排名、实时积分榜，需要对排行榜进行实时更新。

实践代码

以下是如何使用封装的Leaderboard类来实现动态更新排行榜的示例代码：

import { Redis as RedisClient } from "ioredis";
import { Leaderboard } from './leaderboard'; 

(async () => {
  const redis = new RedisClient({ host: 'localhost', port: 6379 });
  const leaderboard = new Leaderboard(redis, 'game:leaderboard');
  await leaderboard.addUser('user1', 100);
  await leaderboard.addUser('user2', 200);
  await leaderboard.addUser('user3', 150);
  console.log(await leaderboard.getTopUsers(3)); // 获取前3名用户
  console.log(await leaderboard.getUserRank('user1')); // 获取user1的排名及分数
  await leaderboard.updateScore('user1', 10); // 实时更新user1的分数
  console.log(await leaderboard.getTopUsers(3)); // 获取前3名用户
  redis.quit();
})();

动态更新评分系统

实现实时更新评分数据的需求

在一些实时性要求较高的场景中，如实时电影评分、实时产品评分，需要对评分系统进行实时更新。

实践代码

以下是如何使用封装的RatingSystem类来实现动态更新评分系统的示例代码：

import { Redis as RedisClient } from "ioredis";
import { RatingSystem } from './ratingSystem'; 

(async () => {
  const redis = new RedisClient({ host: 'localhost', port: 6379 });
  const ratingSystem = new RatingSystem(redis, 'movie:ratings');
  await ratingSystem.addRating('movie1', 5);
  await ratingSystem.addRating('movie2', 3);
  await ratingSystem.addRating('movie1', 2); // 更新movie1的评分
  console.log(await ratingSystem.getRating('movie1')); // 获取movie1的评分
  console.log(await ratingSystem.getRatingRank('movie1')); // 获取movie1的排名
  await ratingSystem.updateRating('movie1', 1); // 实时更新movie1的评分
  console.log(await ratingSystem.getRating('movie1')); // 获取movie1的评分
  redis.quit();
})();

高级应用

多维度排行榜

实现基于多个维度的排行榜

在一些复杂场景中，需要基于多个维度进行排序和查询。

实践代码

以下是如何使用封装的Leaderboard类来实现多维度排行榜的示例代码：

import { Redis as RedisClient } from "ioredis";
import { Leaderboard } from './leaderboard'; // 假设封装类存于 ./leaderboard

const multiDimensionalKey = 'game:multi_dimensional_leaderboard';

class MultiDimensionalLeaderboard {
  private redis: RedisClient;
  private leaderboards: { [dimension: string]: Leaderboard };

  constructor(redis: RedisClient) {
    this.redis = redis;
    this.leaderboards = {};
  }

  // 添加综合评分
  async addCompositeScore(userId: string, score: number, dimension: string) {
    if (!this.leaderboards[dimension]) {
      this.leaderboards[dimension] = new Leaderboard(this.redis, `${multiDimensionalKey}:${dimension}`);
    }
    await this.leaderboards[dimension].addUser(userId, score);
  }

  // 获取综合排名
  async getCompositeRank(userId: string, dimension: string) {
    if (!this.leaderboards[dimension]) {
      this.leaderboards[dimension] = new Leaderboard(this.redis, `${multiDimensionalKey}:${dimension}`);
    }
    return await this.leaderboards[dimension].getUserRank(userId);
  }
}

// 示例：添加、查询综合评分数据
(async () => {
  const redis = new RedisClient({ host: 'localhost', port: 6379 });
  const leaderboard = new MultiDimensionalLeaderboard(redis);

  await leaderboard.addCompositeScore('user1', 100, 'level');
  await leaderboard.addCompositeScore('user1', 50, 'speed');
  console.log(await leaderboard.getCompositeRank('user1', 'level')); // 获取user1在level维度的排名
  redis.quit();
})();

主要逻辑

  1. 定义常量：

    • 定义一个基础键前缀 multiDimensionalKey，用于标识多维度排行榜的键。

  2. 定义 MultiDimensionalLeaderboard 类：

    • 包含一个 Redis 客户端实例和一个存储不同维度的排行榜实例的对象。
    • 提供了两个主要方法：
      • addCompositeScore：向指定维度的排行榜中添加用户的分数。
      • getCompositeRank：获取用户在指定维度的排行榜中的排名。

  3. 示例代码：

    • 创建 Redis 客户端实例，连接到本地 Redis 服务器。
    • 创建 MultiDimensionalLeaderboard 实例。
    • 向 level 和 speed 维度的排行榜中添加用户 user1 的分数。
    • 获取并打印用户 user1 在 level 维度中的排名。
    • 关闭 Redis 连接。

代码执行流程

  1. 初始化：

    • 创建 Redis 客户端和 MultiDimensionalLeaderboard 实例。

  2. 添加分数：

    • 检查指定维度的排行榜实例是否存在，不存在则创建。
    • 向指定维度的排行榜中添加用户及其分数。

  3. 获取排名：

    • 检查指定维度的排行榜实例是否存在，不存在则创建。
    • 获取并返回用户在该维度排行榜中的排名。

通过这些步骤，代码实现了一个多维度的排行榜系统，可以管理和查询用户在不同维度上的表现。

实践案例：自走棋某一局的棋子贡献榜单

在自走棋游戏中，每个棋子在一局中的表现可以通过多个维度来衡量，如击杀数、助攻数和伤害输出等。我们可以使用 Leaderboard 类来实现这些维度的排行榜，并根据这些维度生成综合评分。

代码实现

import { Redis as RedisClient } from "ioredis";
import { Leaderboard } from './leaderboard'; // 假设封装类存于 ./leaderboard

const multiDimensionalKey = 'autochess:match:contribution';

class ChessPieceContributionLeaderboard {
  private redis: RedisClient;
  private leaderboards: { [dimension: string]: Leaderboard };

  constructor(redis: RedisClient) {
    this.redis = redis;
    this.leaderboards = {};
  }

  private getLeaderboardKey(baseKey: string, dimension: string) {
    return `${baseKey}:${dimension}`;
  }

  private getLeaderboard(baseKey: string, dimension: string) {
    const key = this.getLeaderboardKey(baseKey, dimension);
    if (!this.leaderboards[dimension]) {
      this.leaderboards[dimension] = new Leaderboard(this.redis, key);
    }
    return this.leaderboards[dimension];
  }

  // 添加棋子的击杀数
  async addKills(pieceId: string, kills: number, matchId: string) {
    const leaderboard = this.getLeaderboard(`${multiDimensionalKey}:${matchId}`, 'kills');
    await leaderboard.addUser(pieceId, kills);
  }

  // 添加棋子的助攻数
  async addAssists(pieceId: string, assists: number, matchId: string) {
    const leaderboard = this.getLeaderboard(`${multiDimensionalKey}:${matchId}`, 'assists');
    await leaderboard.addUser(pieceId, assists);
  }

  // 添加棋子的伤害输出
  async addDamage(pieceId: string, damage: number, matchId: string) {
    const leaderboard = this.getLeaderboard(`${multiDimensionalKey}:${matchId}`, 'damage');
    await leaderboard.addUser(pieceId, damage);
  }

  // 获取棋子在某一维度的排名
  async getRank(pieceId: string, dimension: string, matchId: string) {
    const leaderboard = this.getLeaderboard(`${multiDimensionalKey}:${matchId}`, dimension);
    return await leaderboard.getUserRank(pieceId);
  }

  // 获取棋子在某一维度的分数
  async getScore(pieceId: string, dimension: string, matchId: string) {
    const leaderboard = this.getLeaderboard(`${multiDimensionalKey}:${matchId}`, dimension);
    return await leaderboard.getUserRank(pieceId);
  }

  // 获取棋子的综合排名（简单加权平均）
  async getCompositeRank(pieceId: string, matchId: string) {
    const kills = await this.getScore(pieceId, 'kills', matchId);
    const assists = await this.getScore(pieceId, 'assists', matchId);
    const damage = await this.getScore(pieceId, 'damage', matchId);

    // 计算综合评分，这里简单地将三个维度的分数加权平均
    const compositeScore = (kills * 0.5) + (assists * 0.3) + (damage * 0.2);

    return compositeScore;
  }
}

// 示例：添加、查询棋子贡献数据
(async () => {
  const redis = new RedisClient({ host: 'localhost', port: 6379 });
  const leaderboard = new ChessPieceContributionLeaderboard(redis);

  const matchId = 'match1';

  // 添加棋子贡献数据
  await leaderboard.addKills('piece1', 10, matchId);
  await leaderboard.addAssists('piece1', 5, matchId);
  await leaderboard.addDamage('piece1', 2000, matchId);

  await leaderboard.addKills('piece2', 8, matchId);
  await leaderboard.addAssists('piece2', 7, matchId);
  await leaderboard.addDamage('piece2', 1800, matchId);

  // 获取棋子在各维度的排名
  console.log(await leaderboard.getRank('piece1', 'kills', matchId)); // 获取piece1的击杀排名
  console.log(await leaderboard.getRank('piece1', 'assists', matchId)); // 获取piece1的助攻排名
  console.log(await leaderboard.getRank('piece1', 'damage', matchId)); // 获取piece1的伤害排名

  // 获取棋子的综合排名（综合评分）
  console.log(await leaderboard.getCompositeRank('piece1', matchId)); // 获取piece1的综合评分
  console.log(await leaderboard.getCompositeRank('piece2', matchId)); // 获取piece2的综合评分

  redis.quit();
})();

代码说明

  1. 类 ChessPieceContributionLeaderboard：

    • 封装了处理棋子贡献数据的逻辑，包括添加击杀数、助攻数和伤害输出，以及获取这些维度的排名和分数。
    • 提供了一个方法 getCompositeRank 来计算棋子的综合评分，这里简单地将三个维度的分数加权平均。

  2. 示例代码：

    • 创建了一个 ChessPieceContributionLeaderboard 实例，并添加了两枚棋子的贡献数据。
    • 获取了棋子在各维度的排名和综合评分。

通过这个示例，我们可以看到如何使用封装好的 Leaderboard 类来实现自走棋某一局的棋子贡献榜单。这种方法不仅高效，而且易于扩展和维护。希望这些示例代码能为您在实际开发中提供有价值的参考。

时间范围排行榜

实现基于时间范围的排行榜

在一些应用场景中，需要基于时间范围（如每日、每周、每月）进行排序和查询。

实践代码

以下是如何使用封装的Leaderboard类来实现时间范围排行榜的示例代码：

import { Redis as RedisClient } from "ioredis";
import { Leaderboard } from './leaderboard'; 

const dailyKey = 'game:daily_leaderboard';
const weeklyKey = 'game:weekly_leaderboard';
const monthlyKey = 'game:monthly_leaderboard';

class TimeBasedLeaderboard {
  private redis: RedisClient;
  private leaderboards: { [key: string]: Leaderboard };

  constructor(redis: RedisClient) {
    this.redis = redis;
    this.leaderboards = {};
  }

  private getLeaderboardKey(baseKey: string, period: string) {
    return `${baseKey}:${period}`;
  }

  private getLeaderboard(baseKey: string, period: string) {
    const key = this.getLeaderboardKey(baseKey, period);
    if (!this.leaderboards[key]) {
      this.leaderboards[key] = new Leaderboard(this.redis, key);
    }
    return this.leaderboards[key];
  }

  // 添加每日积分
  async addDailyScore(userId: string, score: number, date: string) {
    const leaderboard = this.getLeaderboard(dailyKey, date);
    await leaderboard.addUser(userId, score);
  }

  // 获取每日排名
  async getDailyRank(userId: string, date: string) {
    const leaderboard = this.getLeaderboard(dailyKey, date);
    return await leaderboard.getUserRank(userId);
  }

  // 添加每周销售数据
  async addWeeklySales(itemId: string, sales: number, week: string) {
    const leaderboard = this.getLeaderboard(weeklyKey, week);
    await leaderboard.addUser(itemId, sales);
  }

  // 获取每周排名
  async getWeeklyRank(itemId: string, week: string) {
    const leaderboard = this.getLeaderboard(weeklyKey, week);
    return await leaderboard.getUserRank(itemId);
  }

  // 添加每月销售数据
  async addMonthlySales(itemId: string, sales: number, month: string) {
    const leaderboard = this.getLeaderboard(monthlyKey, month);
    await leaderboard.addUser(itemId, sales);
  }

  // 获取每月排名
  async getMonthlyRank(itemId: string, month: string) {
    const leaderboard = this.getLeaderboard(monthlyKey, month);
    return await leaderboard.getUserRank(itemId);
  }
}

// 示例：添加、查询每日积分数据
(async () => {
  const redis = new RedisClient({ host: 'localhost', port: 6379 });
  const leaderboard = new TimeBasedLeaderboard(redis);

  // 添加每日积分
  await leaderboard.addDailyScore('user1', 100, '2024-07-22');
  await leaderboard.addDailyScore('user2', 200, '2024-07-22');
  console.log(await leaderboard.getDailyRank('user1', '2024-07-22')); // 获取user1在2024-07-22的排名及分数

  // 添加每周销售数据
  await leaderboard.addWeeklySales('item1', 500, '2024-W30');
  await leaderboard.addWeeklySales('item2', 800, '2024-W30');
  console.log(await leaderboard.getWeeklyRank('item1', '2024-W30')); // 获取item1在2024-W30的排名及销售数据

  // 添加每月销售数据
  await leaderboard.addMonthlySales('item1', 1500, '2024-07');
  await leaderboard.addMonthlySales('item2', 1800, '2024-07');
  console.log(await leaderboard.getMonthlyRank('item1', '2024-07')); // 获取item1在2024-07的排名及销售数据

  redis.quit();
})();

通过Redis的有序集合（ZSet），我们可以方便地管理和查询每日、每周、每月的积分和销售数据，并生成相应的排行榜。这种方法不仅高效，而且易于扩展和维护。希望以上示例代码能为您在实际开发中提供有价值的参考。

Redis场景实战：各种排行榜与评分系统都给你写好了

需求分析

  1. 综合文章榜单：

    • 需要一个综合评分系统，综合多维度数据生成评分。
    • 支持添加和更新用户的积分和评分。
    • 支持获取用户的综合排名和前 N 名用户的综合评分。

  2. 维度：

    • 积分维度：如阅读量、点赞数、评论数等。
    • 评分维度：如用户评分、专家评分等。

  3. 功能：

    • 添加和更新用户的积分和评分。
    • 获取用户的综合排名。
    • 获取前 N 名用户的综合排名。

设计实现

  1. CompositeLeaderboard 类：

    • 管理多个维度的排行榜和评分系统。
    • 提供方法添加和更新用户的积分和评分。
    • 提供方法获取用户的综合排名和前 N 名用户的综合评分。

  2. 综合评分计算：

    • 可以根据不同维度的权重计算综合评分。
    • 综合评分计算公式：综合评分 = 积分 * 权重1 + 评分 * 权重2

代码实现

关键注释

1. CompositeLeaderboard 类

  • 管理多个维度的排行榜和评分系统：

    • CompositeLeaderboard 类通过 leaderboards 和 ratingSystems 属性分别管理多个排行榜和评分系统实例。
    • 这些实例是通过 getLeaderboard 和 getRatingSystem 方法动态创建和缓存的。

  • 提供方法 addScore 和 addRating 添加用户的积分和评分：

    • addScore(userId: string, score: number, date: string) 方法用于在指定日期为用户添加积分。
    • addRating(itemId: string, score: number, date: string) 方法用于在指定日期为项目（如文章）添加评分。

  • 提供方法 getCompositeRank 获取用户的综合排名：

    • getCompositeRank(userId: string, date: string) 方法计算并返回用户在指定日期的综合排名和综合评分。

  • 提供方法 getTopCompositeUsers 获取前 N 名用户及其综合评分：

    • getTopCompositeUsers(n: number, date: string) 方法返回指定日期前 N 名用户及其综合评分，并按综合评分排序。

2. 综合评分计算

  • 综合评分 = 积分 * 0.7 + 评分 * 0.3：
    • 综合评分的计算公式是通过给积分和评分赋予不同的权重来实现的。
    • 当前的权重设置为积分占 70%，评分占 30%。这个比例可以根据具体需求进行调整。

3. 示例代码

  • 创建 Redis 客户端和 CompositeLeaderboard 实例：

    • 示例代码通过 new RedisClient({ host: "localhost", port: 6379 }) 创建 Redis 客户端实例。
    • 然后通过 new CompositeLeaderboard(redis, "composite:leaderboard") 创建 CompositeLeaderboard 实例。

  • 添加用户的每日积分和评分：

    • 示例代码遍历 articles 数组，分别调用 addScore 和 addRating 方法为每篇文章添加积分和评分。

  • 获取用户在指定日期的综合排名及分数：

    • 示例代码通过调用 getCompositeRank 方法获取用户在指定日期的综合排名和综合评分。

  • 获取指定日期的前 N 名用户及其综合评分：

    • 示例代码通过调用 getTopCompositeUsers 方法获取指定日期前 10 名用户及其综合评分，并打印结果。

运行效果

总结

Redis在排行榜和评分系统中的应用非常广泛，通过有序集合（ZSet）可以方便地实现各种排序和查询需求。本文详细介绍了如何使用封装好的Redis工具类来实现这些功能，并展示了其在实际应用中的重要性和实用性。希望本文能为开发者提供有价值的参考和帮助。

转载自:https://juejin.cn/post/7395145769731194917
评论
请登录