NestJS中如何为继承BaseService的ServiceA注入Injectable依赖？

1. 定义抽象基类 #

首先创建抽象类BaseService，统一所有业务服务的接口：

// base.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export abstract class BaseService {
  // 定义统一的消息处理方法
  abstract handleMessage(message: Record<string, any>): Promise<void>;
}

2. 实现具体业务服务并注入依赖 #

以ServiceA为例，注入自定义的OtherService作为依赖，ServiceB同理：

// service-a.service.ts
import { Injectable } from '@nestjs/common';
import { BaseService } from './base.service';
import { OtherService } from './other.service';

@Injectable()
export class ServiceA extends BaseService {
  // 构造函数中注入依赖，Nest会自动处理实例化
  constructor(private readonly otherService: OtherService) {
    super();
  }

  async handleMessage(message: Record<string, any>): Promise<void> {
    console.log('ServiceA处理消息:', message);
    // 使用注入的依赖处理业务逻辑
    await this.otherService.processData(message);
  }
}

// service-b.service.ts
import { Injectable } from '@nestjs/common';
import { BaseService } from './base.service';

@Injectable()
export class ServiceB extends BaseService {
  async handleMessage(message: Record<string, any>): Promise<void> {
    console.log('ServiceB处理消息:', message);
  }
}

3. 注册服务并创建动态获取工厂 #

在模块中注册所有业务服务，同时创建一个工厂提供者，用于根据消息type返回对应的服务实例：

// app.module.ts
import { Module } from '@nestjs/common';
import { BaseService } from './base.service';
import { ServiceA } from './service-a.service';
import { ServiceB } from './service-b.service';
import { QueueConsumerService } from './queue-consumer.service';
import { OtherService } from './other.service';

@Module({
  providers: [
    // 注册依赖服务
    OtherService,
    // 注册业务服务
    ServiceA,
    ServiceB,
    // 创建服务工厂：根据type返回对应服务实例
    {
      provide: 'SERVICE_FACTORY',
      useFactory: (serviceA: ServiceA, serviceB: ServiceB) => {
        return (type: string): BaseService => {
          switch (type) {
            case 'A':
              return serviceA;
            case 'B':
              return serviceB;
            default:
              throw new Error(`未知服务类型: ${type}`);
          }
        };
      },
      // 注入所有业务服务实例，Nest会自动解析依赖
      inject: [ServiceA, ServiceB],
    },
    QueueConsumerService,
  ],
})
export class AppModule {}

如果业务服务较多，推荐使用反射+装饰器的方式自动收集服务，避免手动维护switch分支：

步骤3.1 创建服务类型装饰器

// service-type.decorator.ts
export const ServiceType = (type: string) => Reflect.metadata('serviceType', type);

步骤3.2 给业务服务标记类型

// service-a.service.ts
@Injectable()
@ServiceType('A') // 标记服务类型为A
export class ServiceA extends BaseService { ... }

// service-b.service.ts
@Injectable()
@ServiceType('B') // 标记服务类型为B
export class ServiceB extends BaseService { ... }

步骤3.3 自动收集服务的工厂实现

// app.module.ts
import { Module, Provider } from '@nestjs/common';
import { BaseService } from './base.service';
import { ServiceA } from './service-a.service';
import { ServiceB } from './service-b.service';
import { QueueConsumerService } from './queue-consumer.service';
import { OtherService } from './other.service';
import { ServiceType } from './service-type.decorator';

// 收集所有BaseService的实现
const serviceProviders: Provider[] = [ServiceA, ServiceB];

@Module({
  providers: [
    OtherService,
    ...serviceProviders,
    {
      provide: 'SERVICE_FACTORY',
      useFactory: (...services: BaseService[]) => {
        const serviceMap = new Map<string, BaseService>();
        // 通过反射获取服务类型并建立映射
        services.forEach(service => {
          const type = Reflect.getMetadata('serviceType', service.constructor);
          if (type) {
            serviceMap.set(type, service);
          }
        });
        return (type: string): BaseService => {
          const service = serviceMap.get(type);
          if (!service) {
            throw new Error(`未知服务类型: ${type}`);
          }
          return service;
        };
      },
      inject: serviceProviders,
    },
    QueueConsumerService,
  ],
})
export class AppModule {}

4. 在队列消费服务中使用工厂 #

在消费服务中注入工厂，根据消息的type获取对应服务并处理：

// queue-consumer.service.ts
import { Inject, Injectable } from '@nestjs/common';
import { BaseService } from './base.service';

@Injectable()
export class QueueConsumerService {
  constructor(
    @Inject('SERVICE_FACTORY') private readonly serviceFactory: (type: string) => BaseService
  ) {}

  async consumeMessage(message: { type: string }) {
    // 根据消息type获取对应服务
    const service = this.serviceFactory(message.type);
    // 调用服务的消息处理方法
    await service.handleMessage(message);
  }
}

关键说明 #

• 所有业务服务都用@Injectable()装饰，Nest会自动管理它们的依赖注入，包括ServiceA中的OtherService。
• 服务工厂通过Nest的DI容器获取已实例化的服务，确保所有依赖都已正确注入。
• 使用反射+装饰器的方式可以避免手动维护服务映射，新增服务时只需添加@ServiceType装饰器即可。

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