NestJS中如何重新初始化Provider以更新过期Token？

你的需求完全可行，而且不需要强制重新初始化 Provider——更高效的方式是动态更新 Token 或让 ApiClient 自动同步最新 Token，同时可以将核心逻辑封装在 npm 包中，避免多项目重复开发。以下是几种优先满足「核心代码在 npm 包」的方案：

方案一：TokenService 提供 Token 更新订阅机制（推荐） #

核心思路：在 npm 包的 TokenService 中添加事件监听能力，当 Token 刷新成功后触发事件；BFF 中的 ApiClient 订阅该事件，动态更新请求头，无需重新初始化。

1. npm 包中改造 TokenService #

// @MYIMPORTEDCOMMONMODULE/token.service.ts
import { Injectable } from '@nestjs/common';
// 可使用框架自带事件发射器，或自定义简易实现
import { EventEmitter } from 'events';

@Injectable()
export class TokenService {
  private currentToken: string;
  private readonly tokenEmitter = new EventEmitter();

  constructor() {
    // 初始化首次 Token 并启动定时刷新
    this.initTokenAndScheduleRefresh();
  }

  async getToken(): Promise<string> {
    if (!this.currentToken) {
      this.currentToken = await this.fetchNewToken();
    }
    return this.currentToken;
  }

  // 订阅 Token 更新事件
  onTokenRefresh(callback: (newToken: string) => void) {
    this.tokenEmitter.on('token-updated', callback);
  }

  // 取消订阅（可选，避免内存泄漏）
  offTokenRefresh(callback: (newToken: string) => void) {
    this.tokenEmitter.off('token-updated', callback);
  }

  private async fetchNewToken(): Promise<string> {
    // 你的 Token 接口调用逻辑
    const response = await fetch('你的Token接口地址', { method: 'POST' });
    const data = await response.json();
    return data.access_token;
  }

  private async initTokenAndScheduleRefresh() {
    this.currentToken = await this.fetchNewToken();
    // 每30分钟刷新一次
    setInterval(async () => {
      try {
        this.currentToken = await this.fetchNewToken();
        this.tokenEmitter.emit('token-updated', this.currentToken);
      } catch (err) {
        console.error('Token刷新失败:', err);
      }
    }, 30 * 60 * 1000);
  }
}

2. BFF 中使用订阅更新 ApiClient #

import { TokenService } from '@MYIMPORTEDCOMMONMODULE';
import { ApiClient } from './api';

export const apiClientProvider = {
  provide: 'ApiClient',
  useFactory: async (tokenService: TokenService) => {
    const initialToken = await tokenService.getToken();
    console.log('Initial token:', initialToken);

    const apiConfig = {
      BASE: process.env.NX_API_BASE_ENDPOINT || 'http://localhost:9096',
      HEADERS: {
        Authorization: initialToken
      }
    };

    const apiClient = new ApiClient(apiConfig);

    // 订阅 Token 更新，动态修改 ApiClient 默认请求头
    tokenService.onTokenRefresh((newToken) => {
      apiClient.defaultHeaders.Authorization = newToken;
      console.log('Token已更新，ApiClient 请求头同步完成');
    });

    return apiClient;
  },
  inject: [TokenService],
};

方案二：npm 包封装带自动 Token 同步的 ApiClient 包装器 #

核心思路：在 npm 包中直接封装一个包装类，内部持有 ApiClient 实例和 TokenService，自动处理 Token 刷新后的实例更新，BFF 只需直接使用包装后的实例。

1. npm 包中创建 ApiClientWrapper #

// @MYIMPORTEDCOMMONMODULE/api-client-wrapper.ts
import { TokenService } from './token.service';

export class ApiClientWrapper<T> {
  private clientInstance: T;

  constructor(
    private tokenService: TokenService,
    private clientClass: new (config: any) => T,
    private baseConfig: Omit<any, 'HEADERS'> // 排除请求头，由包装器处理
  ) {
    // 初始化实例并监听 Token 更新
    this.initClient();
    this.setupTokenRefreshListener();
  }

  private async initClient() {
    const token = await this.tokenService.getToken();
    this.clientInstance = new this.clientClass({
      ...this.baseConfig,
      HEADERS: { Authorization: token }
    });
  }

  private setupTokenRefreshListener() {
    this.tokenService.onTokenRefresh(() => {
      this.initClient();
    });
  }

  // 获取当前可用的 ApiClient 实例
  getClient(): T {
    return this.clientInstance;
  }
}

2. BFF 中使用包装器 #

import { TokenService, ApiClientWrapper } from '@MYIMPORTEDCOMMONMODULE';
import { ApiClient } from './api';

export const apiClientProvider = {
  provide: 'ApiClient',
  useFactory: async (tokenService: TokenService) => {
    const baseConfig = {
      BASE: process.env.NX_API_BASE_ENDPOINT || 'http://localhost:9096'
    };

    const clientWrapper = new ApiClientWrapper<ApiClient>(tokenService, ApiClient, baseConfig);
    return clientWrapper.getClient();
  },
  inject: [TokenService],
};

方案三：强制重新初始化 Provider（不推荐，仅作备选） #

如果业务场景必须重新初始化 Provider，可在 npm 包中提供动态初始化工具，配合框架的模块引用能力实现实例替换。

1. npm 包中提供初始化工具 #

// @MYIMPORTEDCOMMONMODULE/api-client-factory.ts
import { TokenService } from './token.service';

export class ApiClientFactory {
  static async createClient<T>(
    tokenService: TokenService,
    clientClass: new (config: any) => T,
    baseConfig: Omit<any, 'HEADERS'>
  ): Promise<T> {
    const token = await tokenService.getToken();
    return new clientClass({
      ...baseConfig,
      HEADERS: { Authorization: token }
    });
  }
}

2. BFF 中动态替换 Provider 实例 #

import { ModuleRef } from '@nestjs/core';
import { TokenService, ApiClientFactory } from '@MYIMPORTEDCOMMONMODULE';
import { ApiClient } from './api';

export const apiClientProvider = {
  provide: 'ApiClient',
  useFactory: async (tokenService: TokenService, moduleRef: ModuleRef) => {
    const baseConfig = {
      BASE: process.env.NX_API_BASE_ENDPOINT || 'http://localhost:9096'
    };

    const initialClient = await ApiClientFactory.createClient(tokenService, ApiClient, baseConfig);

    // 订阅 Token 更新，重新创建实例并替换
    tokenService.onTokenRefresh(async () => {
      const newClient = await ApiClientFactory.createClient(tokenService, ApiClient, baseConfig);
      // 通过 ModuleRef 动态替换 Provider 实例（需框架支持）
      moduleRef.set('ApiClient', newClient);
    });

    return initialClient;
  },
  inject: [TokenService, ModuleRef],
};

方案对比与建议 #

• 方案一：侵入性最低，无需修改 ApiClient 原有逻辑，仅通过事件监听动态更新请求头，是最优选择。
• 方案二：封装性更强，BFF 代码更简洁，但需要确保 ApiClient 实例的引用能及时获取到最新版本。
• 方案三：仅适用于必须重新初始化 Provider 的特殊场景，框架兼容性依赖较高，不推荐常规使用。

所有方案的核心逻辑均封装在 npm 包中，后续 Token 刷新逻辑调整只需更新 npm 包即可，无需修改各 BFF 项目代码。

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