TypeORM中Redis缓存不可用时如何降级查询数据库？

你不需要立刻弃用TypeORM自带的缓存，可以先尝试配置Redis客户端的容错参数，若仍无法满足需求，再考虑自行实现缓存逻辑。

方案一：配置Redis客户端的容错策略 #

TypeORM的Redis缓存底层依赖Redis客户端，默认的连接重试策略可能导致Redis宕机时请求挂起。你可以在缓存配置中添加超时、重试限制参数，让连接失败时快速终止，避免阻塞查询：

修改app.module.ts中的TypeORM缓存配置：

TypeOrmModule.forRoot({
    type: 'mysql',
    host: process.env.DB_HOST,
    port: 3306,
    username: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME,
    autoLoadEntities: true,
    synchronize: process.env.NODE_ENV === 'development',
    cache: {
        alwaysEnabled: false,
        type: 'redis',
        options: {
            host: process.env.REDIS_HOST,
            port: process.env.REDIS_PORT,
            connectTimeout: 500, // 连接超时时间（毫秒）
            retryStrategy: (times) => {
                // 仅重试1次，之后放弃连接
                if (times > 1) return null;
                return 100;
            },
            maxRetriesPerRequest: 0, // 单个请求不重试
        },
    },
}),

配置后，当Redis不可用时，客户端会快速返回连接失败的错误，部分TypeORM版本会自动跳过缓存逻辑直接查询数据库。如果测试后仍无法 fallback到DB，可以选择方案二。

方案二：自行实现Redis缓存逻辑 #

这种方式完全可控，能确保Redis宕机时直接走数据库查询。步骤如下：

1. 安装并配置Redis客户端 #

以ioredis为例，通过@nestjs-modules/ioredis集成到NestJS项目：

// app.module.ts
import { Module } from '@nestjs/common';
import { RedisModule } from '@nestjs-modules/ioredis';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
    imports: [
        RedisModule.forRoot({
            config: {
                host: process.env.REDIS_HOST,
                port: parseInt(process.env.REDIS_PORT),
                connectTimeout: 500,
                retryStrategy: (times) => times > 1 ? null : 100,
            },
        }),
        TypeOrmModule.forRoot({
            // 原TypeORM配置（移除自带的cache配置）
            type: 'mysql',
            host: process.env.DB_HOST,
            port: 3306,
            username: process.env.DB_USER,
            password: process.env.DB_PASSWORD,
            database: process.env.DB_NAME,
            autoLoadEntities: true,
            synchronize: process.env.NODE_ENV === 'development',
        }),
        // 其他模块
    ],
})
export class AppModule {}

2. 在仓库中实现缓存逻辑 #

注入Redis客户端，手动处理缓存查询、数据库查询和缓存写入，并捕获Redis异常：

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { SomeEntity } from './some.entity';
import { InjectRedis } from '@nestjs-modules/ioredis';
import { Redis } from 'ioredis';

@Injectable()
export class SomeRepository {
    constructor(
        @InjectRepository(SomeEntity)
        private readonly roomRepository: Repository<SomeEntity>,
        @InjectRedis() private readonly redis: Redis,
    ) {}

    async read(id: string): Promise<SomeEntity | undefined> {
        const cacheKey = `entity_${id}`;
        let entity: SomeEntity | undefined;

        // 尝试从Redis读取缓存
        try {
            const cachedData = await this.redis.get(cacheKey);
            if (cachedData) {
                entity = JSON.parse(cachedData) as SomeEntity;
            }
        } catch (err) {
            console.warn('Redis不可用，直接查询数据库:', err.message);
        }

        // 缓存未命中或Redis不可用时，查询数据库
        if (!entity) {
            entity = await this.roomRepository.findOne({
                where: { id },
            });

            // 查询到结果且Redis可用时，写入缓存
            if (entity) {
                try {
                    await this.redis.set(cacheKey, JSON.stringify(entity), 'PX', 86400000);
                } catch (err) {
                    console.warn('Redis不可用，无法写入缓存:', err.message);
                }
            }
        }

        return entity;
    }
}

这种方式能确保Redis宕机时，请求不会挂起，直接从数据库获取数据，同时保留正常情况下的缓存能力。

内容的提问来源于stack exchange，提问作者michal pavlik