单例模式管理 Redis 连接

class RedisConnection {
  private static instance: Redis | null = null;

  static async getInstance(): Promise<Redis> {
    if (!this.instance) {
      this.instance = new Redis({
        host: process.env.REDIS_HOST || 'localhost',
        port: Number(process.env.REDIS_PORT) || 6379,
        password: process.env.REDIS_PASSWORD,
        maxRetriesPerRequest: 3,
        retryStrategy: (times) => Math.min(times * 50, 2000),
      });

      // 连接成功日志
      this.instance.on('connect', () => {
        console.log('Redis connected');
      });

      // 连接错误处理
      this.instance.on('error', (err) => {
        console.error('Redis error:', err);
      });
    }

    return this.instance;
  }
}

const redisConfig = {
  host: process.env.REDIS_HOST,
  port: Number(process.env.REDIS_PORT),

  // 连接超时：根据网络环境调整
  connectTimeout: 10000,

  // 命令超时：防止慢查询阻塞
  commandTimeout: 5000,

  // 重试策略：指数退避
  retryStrategy: (times) => {
    if (times > 10) {
      // 重试 10 次后放弃
      return null;
    }
    // 第一次 50ms，第二次 100ms，第三次 150ms...
    return Math.min(times * 50, 2000);
  },

  // 重连策略：连接断开后如何重连
  reconnectOnError: (err) => {
    const targetError = 'READONLY';
    if (err.message.includes(targetError)) {
      // 遇到只读错误时重连
      return true;
    }
    return false;
  },
};

class RedisManager {
  private client: Redis | null = null;
  private isConnecting = false;

  async getClient(): Promise<Redis> {
    if (this.client && this.client.status === 'ready') {
      return this.client;
    }

    if (this.isConnecting) {
      // 避免并发初始化
      await this.waitForConnection();
      return this.client!;
    }

    try {
      this.isConnecting = true;
      this.client = await this.createConnection();
      return this.client;
    } catch (error) {
      console.error('Failed to connect to Redis:', error);

      // 降级策略：返回内存缓存？抛出错误？
      throw new Error('Redis unavailable');
    } finally {
      this.isConnecting = false;
    }
  }

  private async createConnection(): Promise<Redis> {
    const client = new Redis({
      host: process.env.REDIS_HOST,
      retryStrategy: (times) => {
        if (times > 5) {
          console.error('Redis connection failed after 5 retries');
          return null;
        }
        return Math.min(times * 100, 3000);
      },
    });

    return new Promise((resolve, reject) => {
      client.on('ready', () => resolve(client));
      client.on('error', (err) => reject(err));

      // 设置超时
      setTimeout(() => {
        reject(new Error('Connection timeout'));
      }, 10000);
    });
  }
}

// 启动时初始化
async function bootstrap() {
  const redis = await RedisConnection.getInstance();
  console.log('Redis ready');

  const app = createApp();
  app.listen(3000);
}

// 按需初始化
async function handleRequest(req, res) {
  try {
    const redis = await RedisConnection.getInstance();
    const data = await redis.get('key');
    res.json({ data });
  } catch (error) {
    // 降级处理
    res.status(503).json({ error: 'Service temporarily unavailable' });
  }
}

class RedisHealthCheck {
  private client: Redis;
  private checkInterval: NodeJS.Timer | null = null;

  constructor(client: Redis) {
    this.client = client;
  }

  startHealthCheck(intervalMs = 30000) {
    this.checkInterval = setInterval(async () => {
      try {
        const result = await this.client.ping();
        if (result !== 'PONG') {
          console.error('Redis health check failed: unexpected response');
          this.handleUnhealthy();
        }
      } catch (error) {
        console.error('Redis health check failed:', error);
        this.handleUnhealthy();
      }
    }, intervalMs);
  }

  stopHealthCheck() {
    if (this.checkInterval) {
      clearInterval(this.checkInterval);
    }
  }

  private async handleUnhealthy() {
    // 记录告警
    console.error('Redis connection unhealthy, attempting reconnection');

    // 触发重连
    try {
      await this.client.disconnect();
      await this.client.connect();
    } catch (error) {
      console.error('Reconnection failed:', error);
    }
  }
}

class Application {
  private redis: Redis;

  async start() {
    this.redis = await RedisConnection.getInstance();

    // 注册关闭信号处理
    process.on('SIGTERM', () => this.shutdown());
    process.on('SIGINT', () => this.shutdown());
  }

  async shutdown() {
    console.log('Shutting down gracefully...');

    try {
      // 等待当前操作完成
      await this.waitForPendingOperations();

      // 关闭 Redis 连接
      await this.redis.quit();
      console.log('Redis connection closed');

      // 退出进程
      process.exit(0);
    } catch (error) {
      console.error('Error during shutdown:', error);
      process.exit(1);
    }
  }

  private async waitForPendingOperations() {
    // 实现取决于你的应用逻辑
    // 可能需要等待 [[bullmq-queue|队列]]清空、请求完成等
  }
}