为什么您应该多缓存少查询

作者头像东城·2026-01-31 23:53:04·
还在一次又一次地调用相同的API吗？
这不仅效率低下——而且成本高昂。性能缓慢、成本更高，用户体验更差。
让我们停止这种做法——从这篇文章开始。:D
首先您需要了解Redis，简单来说，它是一个超快速的内存键值存储——非常适合缓存和减少后端负载。
有几种方式可以开始。
如果您正在开发，我建议使用Docker。
为此，您可以在CLI中运行：
  1. docker run -d --name redis-stack-server -p 6379:6379 redis/redis-stack-server:latest
这将启动Redis服务器。但查看实际存储的内容同样重要。为此，使用带有浏览器UI的完整Redis Stack：
  1. docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
现在，如果您访问 http://localhost:8001/redis-stack/browser
您会找到一个方便的控制面板，可以在其中可视化地存储、浏览和管理您的Redis数据：
要开始，安装redis包：
  1. npm i redis // 或 yarn, npm
现在，让我们设置一些类型和接口来保持代码的整洁和可扩展性。
我们将从一个用于标准化响应的通用枚举开始：
我们的枚举如下：
  1. # generic.interface.ts
  2. export enum StatusEnum {
  3. SUCCESS = 'success',
  4. ERROR = 'error'
  5. }
然后，为我们的缓存逻辑定义类型和结构：
  1. # cache.interface.ts
  2. import { StatusEnum } from './generic.interface';

  4. export type CacheCallbackType = Promise<{
  5. status: StatusEnum;
  6. data: any;
  7. error?: any;
  8. }>;

  10. export interface CacheInterface {
  11. key: string;
  12. callback: () => CacheCallbackType;
  13. configs?: {
  14. expirationInSeconds?: number;
  15. useUserId?: boolean;
  16. };
  17. }

  19. interface CacheReturnInterface {
  20. status: StatusEnum;
  21. data: any;
  22. }

  24. export type CacheReturnType = Promise<CacheReturnInterface>;
这些接口将帮助保持我们的代码类型化、一致且易于维护，随着项目的增长。
接下来，让我们设置一个辅助类来以整洁和可重用的方式处理Redis操作。
  1. import { createClient } from 'redis';

  3. export default class RedisHelper {
  4. private static client = createClient({
  5. username: 'default',
  6. password: process.env.REDIS_PASSWORD,
  7. socket: {
  8. host: process.env.REDIS_URL,
  9. port: parseInt(process.env.REDIS_PORT)
  10. }
  11. });

  13. static async connect() {
  14. if (!this.client.isOpen) {
  15. await this.client.connect();
  16. }

  18. return this;
  19. }

  21. static async get(key: string) {
  22. await this.connect();
  23. const value = await this.client.get(key);

  25. if (!value) {
  26. return value;
  27. }

  29. return value;
  30. }

  32. static async set(
  33. key: string,
  34. value: any,
  35. expirationInSeconds: number = 3600
  36. ) {
  37. await this.connect();
  38. await this.client.json.set(key, '
    39. , value);
  39. await this.client.expire(key, expirationInSeconds);

  41. return this;
  42. }

  44. static async del(key: string) {
  45. await this.connect();
  46. await this.client.del(key);
  47. }

  49. static async quit() {
  50. if (this.client.isOpen) {
  51. await this.client.quit();
  52. }
  53. }
  54. }
我们使用Redis的JSON命令（例如.json.set）来更直观地存储结构化数据。这比纯字符串给我们更多的灵活性——特别是在处理嵌套对象或数组时。
有了这个辅助类，我们可以：
仅在需要时连接到Redis（延迟连接）
设置带过期时间的值
轻松获取缓存数据
删除键
优雅地关闭连接
这个辅助类将处理任何类型请求的缓存——只要请求成功。它使用我们创建的RedisHelper与Redis通信。
在我的情况下，我通过将用户ID附加到缓存键来包含基于用户的缓存支持。在您的情况下，请随意调整此逻辑以适应您的需求。
  1. import {
  2. CacheInterface,
  3. CacheReturnType
  4. } from '../../interfaces/cache.interface';
  5. import { StatusEnum } from '../../interfaces/generic.interface';
  6. // import getUserId from '../default/userId';
  7. import RedisHelper from './RedisHelper';

  9. function getUserId () {
  10. return Math.random(); // 在这里使用您的逻辑！
  11. }

  13. export default class CacheHelper {
  14. // 检查缓存是否为空
  15. // 然后运行回调函数
  16. // 并用结果设置缓存
  17. static async checkCache({
  18. key,
  19. callback,
  20. configs
  21. }: CacheInterface): CacheReturnType {
  22. const cache = await RedisHelper.get(key);
  23. const expirationInSeconds = configs?.expirationInSeconds || 3600;

  25. // 仅在configs中指定时才在键中使用userId
  26. if (configs?.useUserId) {
  27. const userId = getUserId();
  28. key = `${key}:${userId}`;
  29. }

  31. if (cache) {
  32. return {
  33. status: StatusEnum.SUCCESS,
  34. data: cache
  35. };
  36. }

  38. try {
  39. const result = await callback();

  41. if (result.status === StatusEnum.ERROR) {
  42. return {
  43. status: StatusEnum.ERROR,
  44. data: result.data
  45. };
  46. }

  48. await RedisHelper.set(key, result.data, expirationInSeconds);

  50. return {
  51. status: StatusEnum.SUCCESS,
  52. data: result.data
  53. };
  54. } catch (error) {
  55. console.error('Error in checkCache:', error);

  57. return {
  58. status: StatusEnum.ERROR,
  59. data: null
  60. };
  61. }
  62. }

  64. // 辅助函数，始终在键中使用userId
  65. static async checkCacheWithId({
  66. key,
  67. callback,
  68. configs
  69. }: CacheInterface): CacheReturnType {
  70. return this.checkCache({
  71. key,
  72. callback,
  73. configs: {
  74. ...configs,
  75. useUserId: true
  76. }
  77. });
  78. }

  80. static async deleteCache(
  81. key: string,
  82. configs?: {
  83. useUserId?: boolean;
  84. }
  85. ): Promise<void> {
  86. if (configs?.useUserId) {
  87. const userId = getUserId();
  88. key = `${key}:${userId}`;
  89. }

  91. if (!key) {
  92. throw new Error('Key is required to delete cache');
  93. }

  95. try {
  96. await RedisHelper.del(key);
  97. } catch (error) {
  98. console.error('Error deleting cache:', error);
  99. throw error;
  100. }
  101. }

  103. static async deleteUserCache(key: string): Promise<void> {
  104. return this.deleteCache(key, { useUserId: true });
  105. }
  106. }
这个实用工具让您完全控制：
从缓存读取
如果需要，写入缓存
处理带或不带用户标识符的缓存键
轻松删除缓存条目
哦，redis中的标签看起来像这样：
  1. movies:user_123
  2. user:123:profile
  3. user:123:posts
  4. user:123:notifications
现在一切都设置好了，使用缓存变得简单而整洁。
以下是如何基于用户ID缓存/categories API请求的示例：
  1. import CacheHelper from './helpers/cache/CacheHelper';
  2. import { StatusEnum } from './interfaces/generic.interface';

  4. api.post('/categories', async (_req, res) => {
  5. const data = await CacheHelper.checkCacheWithId({
  6. key: 'categories',
  7. callback: async (): CacheCallbackType => {
  8. const data = await Categories();

  10. if (data.error) {
  11. return {
  12. status: StatusEnum.ERROR,
  13. data: data.error
  14. };
  15. }

  17. return {
  18. status: StatusEnum.SUCCESS,
  19. data
  20. };
  21. }
  22. });

  24. if (data.status === StatusEnum.ERROR) {
  25. return res.status(500).send({ error: data.data });
  26. }

  28. return res.status(200).send(data.data);
  29. });
✅ 这里发生了什么？
checkCacheWithId检查是否已经为该特定用户缓存了响应版本。
如果没有缓存，它运行回调（Categories()），保存结果并返回。
如果回调中有错误，它不会被缓存——而是返回错误。
结果快速而整洁地返回给客户端。
想要更进一步？您可以将此抽象为中间件或使用装饰器（如果您正在使用像NestJS这样的框架）。
如果您需要下一步的帮助，请告诉我！