Loopback 4应用遇外部数据源故障崩溃，如何避免？

以下是几种可行的方案，帮你避免外部数据源不可用时服务崩溃：

1. 全局错误拦截器捕获连接异常 #

LoopBack 4允许通过全局错误处理器捕获未处理的异常，你可以针对SQL Server的连接错误做特殊处理，阻止异常扩散导致服务崩溃。

创建一个全局错误处理Provider：

import {Provider, inject} from '@loopback/core';
import {ErrorHandler, Request, Response, RestBindings} from '@loopback/rest';
import {ConnectionError} from 'mssql'; // 根据使用的SQL Server驱动调整

export class GlobalErrorHandlerProvider implements Provider<ErrorHandler> {
  constructor(@inject(RestBindings.Http.REQUEST) private req: Request) {}

  value(): ErrorHandler {
    return (err: Error, req: Request, res: Response) => {
      // 识别SQL Server连接错误
      if (err instanceof ConnectionError) {
        res.status(503).json({
          message: '外部数据源暂时不可用，请稍后重试',
          code: 'DATASOURCE_UNAVAILABLE'
        });
        return;
      }
      // 其他错误按默认逻辑处理
      res.status(500).json({
        message: '服务器内部错误',
        error: process.env.NODE_ENV === 'production' ? undefined : err.stack
      });
    };
  }
}

然后在application.ts里注册这个Provider：

this.bind(RestBindings.ERROR_HANDLER).toProvider(GlobalErrorHandlerProvider);

2. 在数据源操作层添加局部异常捕获 #

在调用外部数据源的Repository或Service方法中，手动用try/catch包裹所有数据库操作，直接在业务层处理连接失败的情况，不让异常向上冒泡。

示例（Service中的处理）：

import {inject} from '@loopback/core';
import {repository} from '@loopback/repository';
import {ExternalUserRepository} from '../repositories';
import {ConnectionError} from 'mssql';

export class ExternalUserService {
  constructor(
    @repository(ExternalUserRepository)
    public externalUserRepository: ExternalUserRepository,
  ) {}

  async getExternalUser(id: string) {
    try {
      return await this.externalUserRepository.findById(id);
    } catch (err) {
      if (err instanceof ConnectionError) {
        throw new Error('外部用户数据源不可用'); // 抛出的错误会被全局处理器捕获，或直接返回降级响应
      }
      throw err; // 其他错误正常抛出
    }
  }
}

3. 配置数据源的重试与超时机制 #

在外部数据源的配置中添加连接重试和超时参数，减少单次连接失败直接导致的异常，同时避免长时间阻塞请求。

修改datasources/external-ds.json：

{
  "name": "ExternalSQLServer",
  "connector": "mssql",
  "host": "external-db-host",
  "port": 1433,
  "database": "external-db",
  "lazyConnect": true,
  "options": {
    "connectTimeout": 5000, // 连接超时5秒
    "requestTimeout": 10000, // 请求超时10秒
    "retry": {
      "max": 3, // 最多重试3次
      "delay": 1000 // 每次重试间隔1秒
    }
  }
}

4. 实现健康检查与熔断降级 #

通过LoopBack的健康检查组件定期检测外部数据源状态，当数据源连续不可用时，触发熔断逻辑，后续请求直接返回降级响应，不再尝试连接。

1. 首先安装健康检查组件：

npm install @loopback/health

2. 创建自定义健康检查器：

import {HealthChecker, HealthStatus} from '@loopback/health';
import {inject} from '@loopback/core';
import {ExternalSQLServerDataSource} from '../datasources';

export class ExternalDBHealthChecker {
  constructor(
    @inject('datasources.ExternalSQLServer')
    private dataSource: ExternalSQLServerDataSource,
  ) {}

  async check(): Promise<HealthStatus> {
    try {
      await this.dataSource.ping();
      return {status: 'UP'};
    } catch (err) {
      return {status: 'DOWN', error: err.message};
    }
  }
}

3. 在应用中注册健康检查，并维护熔断开关：

import {HealthComponent} from '@loopback/health';

// 在application.ts的constructor中
this.component(HealthComponent);
this.bind('health.checkers.external-db').toClass(ExternalDBHealthChecker);

// 维护全局熔断状态
let externalDBFused = false;
// 每30秒检查一次数据源健康状态
setInterval(async () => {
  const healthChecker = await this.get<HealthChecker>('health.checker');
  const result = await healthChecker.check();
  const externalDBStatus = result.status.find(s => s.name === 'external-db');
  externalDBFused = externalDBStatus?.status === 'DOWN';
}, 30000);

4. 在Service中使用熔断开关：

async getExternalUser(id: string) {
  if (externalDBFused) {
    return {message: '外部数据源暂时不可用，已触发熔断'}; // 返回降级响应
  }
  try {
    return await this.externalUserRepository.findById(id);
  } catch (err) {
    externalDBFused = true; // 捕获错误后触发熔断
    throw new Error('外部用户数据源不可用');
  }
}

内容的提问来源于stack exchange，提问作者V2V Factory