如何在NestJS依赖注入系统中使用工厂提供类实现？

针对你需要根据配置动态选择抽象服务实现的场景，下面是几种实用方案，按推荐优先级排序：

1. useClass + 配置映射（推荐，静态配置场景） #

如果你的配置可以直接通过process.env获取（比如启动时就确定的环境变量），这种方式最省心——Nest会自动帮你处理实现类的依赖注入，不需要手动实例化对象。

示例代码：

import { Module, Injectable } from '@nestjs/common';
import { Logger } from '@nestjs/common';

// 抽象服务
abstract class PaymentService {
  abstract process(amount: number): void;
}

// 具体实现1
@Injectable()
class StripeService implements PaymentService {
  constructor(private readonly logger: Logger) {}
  
  process(amount: number) {
    this.logger.log(`Stripe 支付: ${amount}元`);
  }
}

// 具体实现2
@Injectable()
class PayPalService implements PaymentService {
  process(amount: number) {
    console.log(`PayPal 支付: ${amount}元`);
  }
}

// 配置与实现类的映射
const PAYMENT_PROVIDER_MAP = {
  stripe: StripeService,
  paypal: PayPalService,
};

@Module({
  providers: [
    Logger,
    {
      provide: PaymentService,
      // 根据环境变量选择实现类，默认用Stripe
      useClass: PAYMENT_PROVIDER_MAP[process.env.PAYMENT_PROVIDER] || StripeService,
    },
    // 提前注册所有实现类，让Nest管理其依赖
    StripeService,
    PayPalService,
  ],
  exports: [PaymentService],
})
export class PaymentModule {}

这种方式的优势是完全利用Nest的DI系统，后续给实现类加依赖时，只需要在构造函数里声明，不需要手动修改实例化逻辑。

2. useFactory + 依赖注入（适合动态/复杂配置场景） #

如果你的配置需要从ConfigService获取（比如异步加载的配置、数据库存储的配置），或者需要复杂的选择逻辑，用useFactory是更灵活的选择。你可以在工厂函数中注入所需的依赖（比如ConfigService），再根据配置返回对应的实现类实例——实现类的依赖也能通过工厂函数注入传递。

示例代码：

import { Module, Injectable, Provider } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { Logger } from '@nestjs/common';

// 抽象服务、实现类定义同上面示例

const paymentServiceProvider: Provider = {
  provide: PaymentService,
  useFactory: (configService: ConfigService, logger: Logger) => {
    const provider = configService.get<string>('PAYMENT_PROVIDER');
    // 根据配置选择实现，同时传递依赖
    switch (provider) {
      case 'paypal':
        return new PayPalService();
      case 'stripe':
        return new StripeService(logger);
      default:
        throw new Error(`不支持的支付服务商: ${provider}`);
    }
  },
  // 声明工厂函数需要注入的依赖，Nest会自动传入
  inject: [ConfigService, Logger],
};

@Module({
  imports: [ConfigModule.forRoot()],
  providers: [paymentServiceProvider, Logger, StripeService, PayPalService],
  exports: [paymentServiceProvider],
})
export class PaymentModule {}

这种方式虽然需要手动传递实现类的依赖，但胜在灵活，能处理动态配置和复杂的选择逻辑。

3. 动态模块（适合模块化复用场景） #

如果这个抽象服务的实现选择需要在不同模块中复用，或者需要在模块注册时明确指定实现，可以用动态模块的方式：

示例代码：

import { Module, DynamicModule } from '@nestjs/common';
import { Logger } from '@nestjs/common';

// 抽象服务、实现类定义同上面示例

@Module({})
export class PaymentModule {
  static register(provider: 'stripe' | 'paypal'): DynamicModule {
    const providerClass = provider === 'stripe' ? StripeService : PayPalService;
    return {
      module: PaymentModule,
      providers: [
        {
          provide: PaymentService,
          useClass: providerClass,
        },
        providerClass,
        Logger,
      ],
      exports: [PaymentService],
    };
  }
}

// 在AppModule中导入时指定实现
@Module({
  imports: [PaymentModule.register(process.env.PAYMENT_PROVIDER as 'stripe' | 'paypal')],
})
export class AppModule {}

这种方式适合封装可复用的模块，让调用方明确指定实现类，同时Nest依然会自动处理依赖注入。

总结 #

• 静态配置（直接读process.env）：优先用useClass+映射对象，无需手动管理依赖。
• 动态/复杂配置：用useFactory+依赖注入，灵活处理配置逻辑。
• Nest没有内置所谓的useClassFactory，但useFactory已经能满足动态返回实现类的需求，且能结合DI系统管理依赖。

内容的提问来源于stack exchange，提问作者Валерий Герасимов