Certifique-se de que seus módulos estejam bem organizados com injeção limpa e reutilizável.
Injetar um serviço de um módulo Nest.js diferente envolve algumas etapas para garantir a injeção de dependência adequada e a organização do módulo. Usando dois módulos de amostra, aprenda como funciona o processo de exportação e importação de serviços.
Gerando um projeto Nest.js
Para gerar um projeto Nest.js, você precisa ter a CLI instalada em seu dispositivo. Caso contrário, execute este comando para instalá-lo:
npm install -g @nestjs/cli
Com a CLI Nest.js instalada, execute este comando para gerar um novo projeto Nest.js:
nest new
Você pode substituir “
A estrutura atual do seu projeto deve ser semelhante à imagem abaixo:
Para praticar a injeção de um serviço de um módulo em um módulo diferente, você gerará dois módulos, módulo-a e módulo-b. Você também gerará seus arquivos de serviço e controlador correspondentes.
Execute este comando para gerar o módulo-a:
nest generate modulemodule-a
E execute o comando equivalente para o módulo-b:
nest generate modulemodule-b
Em seguida, execute este comando para gerar os arquivos de serviço e controlador para o módulo-a:
nest generate service module-a && nest generate controller module-a
E execute o comando equivalente para o módulo-b:
nest generate service module-b && nest generate controller module-b
O diretório do seu projeto atual deve ficar assim, com src/módulo-a e src/módulo-b diretórios:
Exportando um serviço do Módulo A
Para exportar o serviço module-a do módulo module-a, você deve listá-lo como uma exportação no arquivo do módulo module-a (módulo-a.module.ts). Por padrão, a CLI Nest.js não fornece um exportações matriz no @Módulo decorador, então o arquivo do módulo gerado ficará assim:
// module-a.module.ts
import { Module } from'@nestjs/common';
import { ModuleAService } from'./module-a.service';
import { ModuleAController } from'./module-a.controller';@Module({
providers: [ModuleAService],
controllers: [ModuleAController],
})
exportclassModuleAModule{}
Para fazer o serviço-a (módulo-a.service.ts) acessível a módulos que importam o módulo-a, crie um exportações matriz no @Módulo decorador e adicionar MóduloAServiço para isso.
Igual a:
import { Module } from'@nestjs/common';
import { ModuleAService } from'./module-a.service';
import { ModuleAController } from'./module-a.controller';@Module({
providers: [ModuleAService],
controllers: [ModuleAController],
exports: [ModuleAService],
})
exportclassModuleAModule{}
Em seguida, para fins de teste, adicione uma função simples ao seu módulo - um arquivo de serviço (módulo-a.service.ts):
import { Injectable } from'@nestjs/common';
@Injectable()
exportclassModuleAService{
getHello(): string {
return'Hello from Module A!';
}
}
Esta função retorna uma string de amostra. Para confirmar se você pode importar este serviço corretamente, você chamará essa função do módulo-b após injetar o serviço-a.
Importando um serviço para o módulo B
Para importar um módulo para outro, você deve listá-lo como uma importação no importações matriz do módulo receptor. Neste caso, você deve adicionar module-a ao importações matriz de módulo-b's @Módulo decorador.
Como antes, a CLI Nest.js não gera automaticamente um importações array, então você deve adicioná-lo manualmente.
Primeiro, importe o módulo pai (módulo-a.module.ts) no módulo receptor (módulo-b.module.ts), crie o importações matriz e adicione MóduloAMódulo para a matriz:
// module-b.module.ts
import { Module } from'@nestjs/common';
import { ModuleBController } from'./module-b.controller';
import { ModuleBService } from'./module-b.service';
import { ModuleAModule } from'../module-a/module-a.module';@Module({
imports: [ModuleAModule],
controllers: [ModuleBController],
providers: [ModuleBService],
})
exportclassModuleBModule{}
A seguir, abra seu módulo-b.service.ts arquivo e importe o Injetar decorador e MóduloAServiço de @ninhos/comum e ../module-a/module-a.service, respectivamente:
import { Injectable, Inject } from'@nestjs/common';
import { ModuleAService } from'../module-a/module-a.service';
O Injetar decorador marca seu parâmetro como alvo para injeção de dependência.
A seguir, em seu MóduloBServiço class, adicione o bloco de código abaixo:
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
O bloco de código acima dá ao seu ModuleBService acesso aos métodos disponíveis no seu ModuleAService.
Você pode testar o serviço ligando para o módulo ModuleAService getOlá método.
// module-b.service.ts
import { Injectable, Inject } from'@nestjs/common';
import { ModuleAService } from'src/module-a/module-a.service';@Injectable()
exportclassModuleBService{
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
getHello(): string {
returnthis.moduleAService.getHello();
}
}
A seguir, abra seu módulo-b.controller.ts arquivo e substitua o código gerado pelo bloco de código abaixo:
// module-b.controller.ts
import { Controller, Get } from'@nestjs/common';
import { ModuleBService } from'./module-b.service';@Controller('module-b')
exportclassModuleBController{
constructor(private readonly moduleBService: ModuleBService) {}
@Get('/hello')
getHello(): string {
returnthis.moduleBService.getHello();
}
}
O bloco de código acima configura um PEGAR manipulador de rota para o getOlá função.
Finalmente, faça uma solicitação GET com curl para localhost: 3000/module-b/hello. O comando deve imprimir “Olá do Módulo A!” para o seu console.
Você injetou com sucesso um serviço em outro módulo. Isso pode ser útil quando você estiver construindo APIs com Nest.js que possuem vários módulos que precisam chamar os métodos uns dos outros.
Benefícios da injeção entre módulos
Embora chamar diretamente um serviço de outro módulo possa parecer mais simples no início, isso pode levar a um sistema mais complexo, menos sustentável e menos escalável no longo prazo.
No entanto, a injeção entre módulos promove a modularidade e a reutilização do código, facilitando sua manutenção. Além disso, centraliza dependências, melhora a testabilidade e oferece suporte a uma arquitetura escalonável e desacoplada.