为什么不用 cache-manager 操作 Redis

# 上节我们学了在 Nest 里操作 Redis，很多同学会问，为什么不用 cache-manager 呢？

官方文档 (opens new window)里就是用的 cache-manger：

# 确实，cache-manger 有它好用的地方，但是它的缺点更多。

为什么这么说呢？

我们试一下就知道了：

nest new cache-manager-test

创建个 nest 项目。

进入项目，把它跑起来：

npm run start:dev

然后引入 cache-manager：

npm install @nestjs/cache-manager cache-manager

在 AppModule 注册下：

之后在 AppController 加几个路由：

# 注入 CacheManager，分别测试下它的 get、set、del 方法。

import { Controller, Get, Inject, Param, Query } from '@nestjs/common';
import { AppService } from './app.service';
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { Cache } from 'cache-manager';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Inject(CACHE_MANAGER)
  private cacheManager: Cache;

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }

  @Get('set')
  async set(@Query('value') value: string) {
    await this.cacheManager.set('kkk', value);
    return 'done'
  }

  @Get('get')
  async get() {
    return this.cacheManager.get('kkk');
  }

  @Get('del')
  async del() {
    await this.cacheManager.del('kkk');
    return 'done';
  }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

浏览器访问下：

首先 get 没有数据：

然后 set 设置为 111：

再次 get 就有数据了：

之后 del 删掉：

再次 get 就为空了：

这个缓存的用法很简单。

# 此外，你还可以把它加到 handler 上，自动对结果缓存。

@Get('aaa')
@UseInterceptors(CacheInterceptor)
aaa(@Query('a') a: string){
    console.log('aaa', a);
    return 'aaa';
}

1
2
3
4
5
6

参数不变的情况下，刷新几次，可以看到控制台只打印了一次：

改变参数再刷新几次：

这时候控制台再次打印了，说明 handler 又被执行了。

其余的情况，都是直接拿缓存。

有同学说，缓存数据都在哪呢？好像也没引入 redis 呀？

确实，cache-manager 默认是在内存里的。

如果想存在 redis，要这样：

# 🚀使用 cache-manager-redis-store，然后添加下连接配置：

import { Module } from "@nestjs/common";
import { AppController } from "./app.controller";
import { AppService } from "./app.service";
import { CacheModule } from "@nestjs/cache-manager";
import { redisStore } from "cache-manager-redis-store";

import { RedisClientOptions } from "redis";

@Module({
  imports: [
    CacheModule.register <
      RedisClientOptions >
      {
        // @ts-ignore
        store: async () =>
          await redisStore({
            socket: {
              host: "localhost",
              port: 6379,
            },
            database: 2,
          }),
        host: "localhost",
        port: 6379,
      },
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

这里的 cache-manager-redis-store 要安装下：

npm install cache-manager-redis-store

然后再次访问之前的 url：

这时候在 redis 里就可以看到缓存的数据：

注意，连接的时候我们指定 database 为 2，所以在 RedisInsight 里要切到 db2 才可以看到这些数据。

缓存的过期时间也是可以配置的：

# 有同学会说，这个 CacheManager 不是很好用么？

确实，只做 set、get 的话，用 CacheManager 还是可以的，而且还有 CacheInterceptor 可以对接口做缓存。

# 但是，redis 还有 list、hash、zset 等数据结构，支持非常多的命令。

# 而用 CacheManager 的话，只支持 get、set：

这时候如果你想用 list、hash、zset 等数据结构，还是要自己封装。

那何必用 CacheManager 呢？

直接自己封装下 RedisService，实现 get、set 和其它操作，不是更香么？

有同学可能会说，但它带的 CacheInterceptor 也很方便呀。

# 确实，但我们一般不会对接口做缓存，如果要做的话，自己实现也不麻烦。

就是拼接这样一个 key 就好了：

我们实现下试试：

# 先安装用到的 redis 的包。

npm install redis

# 然后在 AppModule 添加一个自定义的 provider：

{
  provide: 'REDIS_CLIENT',
  async useFactory() {
    const client = createClient({
        socket: {
            host: 'localhost',
            port: 6379
        },
        database: 2
    });
    await client.connect();
    return client;
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 然后创建一个 interceptor：

nest g interceptor my-cache --no-spec --flat

这样写：

import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { CallHandler, ExecutionContext, Inject, Injectable, NestInterceptor } from '@nestjs/common';
import { HttpAdapterHost } from '@nestjs/core';
import { RedisClientType } from 'redis';
import { of, tap } from 'rxjs';

@Injectable()
export class MyCacheInterceptor implements NestInterceptor {

  @Inject('REDIS_CLIENT')
  private redisClient: RedisClientType;

  @Inject(HttpAdapterHost)
  private httpAdapterHost: HttpAdapterHost;

  async intercept(context: ExecutionContext, next: CallHandler) {

    const request = context.switchToHttp().getRequest();

    const key = this.httpAdapterHost.httpAdapter.getRequestUrl(request);

    const value = await this.redisClient.get(key);

    if(!value) {
      return next.handle().pipe(tap((res) => {
        this.redisClient.set(key, res);
      }));
    } else {
      return of(value);
    }
  }
}