Se till att dina moduler är välorganiserade med ren, återanvändbar injektion.
Att injicera en tjänst från en annan Nest.js-modul innebär några steg för att säkerställa korrekt beroendeinjektion och modulorganisering. Använd två exempelmoduler för att lära dig hur processen att exportera och importera tjänster fungerar.
Genererar ett Nest.js-projekt
För att generera ett Nest.js-projekt måste du ha CLI installerat på din enhet. Om du inte gör det, kör det här kommandot för att installera det:
npm install -g @nestjs/cli
Med Nest.js CLI installerad kör du det här kommandot för att generera ett nytt Nest.js-projekt:
nest new
Du kan ersätta "
Din nuvarande projektstruktur bör se ut som bilden nedan:
För att öva på att injicera en tjänst från en modul till en annan modul, genererar du två moduler, modul-a och modul-b. Du kommer också att generera deras motsvarande tjänst- och kontrollfiler.
Kör detta kommando för att generera modul-a:
nest generate modulemodule-a
Och kör motsvarande kommando för modul-b:
nest generate modulemodule-b
Kör sedan det här kommandot för att generera tjänsten och styrenhetsfilerna för modul-a:
nest generate service module-a && nest generate controller module-a
Och kör motsvarande kommando för modul-b:
nest generate service module-b && nest generate controller module-b
Din nuvarande projektkatalog ska se ut så här, med src/modul-a och src/modul-b kataloger:
Exportera en tjänst från modul A
För att exportera modul-a-tjänsten från modul-a-modulen måste du lista den som en export i modul-a: s modulfil (modul-a.modul.ts). Som standard tillhandahåller Nest.js CLI inte en export array i @Modul decorator, så den genererade modulfilen kommer att se ut så här:
// 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{}
Att göra tjänsten-en (module-a.service.ts) tillgänglig för moduler som importerar modul-a, skapar en export array i @Modul dekoratör och lägg till ModulAService till det.
Såhär:
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{}
Därefter, för teständamål, lägg till en enkel funktion till din modul-en servicefil (module-a.service.ts):
import { Injectable } from'@nestjs/common';
@Injectable()
exportclassModuleAService{
getHello(): string {
return'Hello from Module A!';
}
}
Denna funktion returnerar en exempelsträng. För att bekräfta att du kan importera den här tjänsten korrekt, anropar du den funktionen från modul-b efter att ha injicerat tjänst-a.
Importera en tjänst till modul B
För att importera en modul till en annan, måste du lista den som en import i import arrayen hos den mottagande modulen. I det här fallet måste du lägga till modul-a till import array av modul-b @Modul dekoratör.
Som tidigare genererar Nest.js CLI inte automatiskt en import array, så du måste lägga till den manuellt.
Importera först den överordnade modulen (modul-a.modul.ts) in i den mottagande modulen (modul-b.modul.ts), skapa import array och lägg till ModulAModule till arrayen:
// 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{}
Öppna sedan din modul-b.service.ts fil och importera Injicera dekoratör och ModuleAServerice från @bon/common och ../module-a/module-a.service, respektive:
import { Injectable, Inject } from'@nestjs/common';
import { ModuleAService } from'../module-a/module-a.service';
De Injicera decorator markerar sin parameter som ett mål för beroendeinjektion.
Nästa, i din ModulBService klass, lägg till kodblocket nedan:
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
Kodblocket ovan ger din ModuleBService tillgång till de metoder som finns tillgängliga i din ModuleAService.
Du kan testa tjänsten genom att ringa ModuleAServices få Hej metod.
// 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();
}
}
Öppna sedan din modul-b.controller.ts fil och ersätt den genererade koden med kodblocket nedan:
// 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();
}
}
Kodblocket ovan ställer in en SKAFFA SIG rutthanterare för få Hej fungera.
Till sist, gör en GET-förfrågan med curl till localhost: 3000/module-b/hello. Kommandot ska skriva ut "Hej från modul A!" till din konsol.
Du har framgångsrikt injicerat en tjänst i en annan modul. Detta kan komma väl till pass när du är det bygga API: er med Nest.js som har flera moduler som behöver anropa varandras metoder.
Fördelar med Cross-Module Injection
Även om direktanrop av en tjänst från en annan modul kan verka enklare till en början, kan det leda till ett mer komplext, mindre underhållbart och mindre skalbart system i det långa loppet.
Korsmodulinjektion främjar dock kodmodularitet och återanvändbarhet, vilket gör det lättare att underhålla. Dessutom centraliserar den beroenden, förbättrar testbarheten och stöder en skalbar, frikopplad arkitektur.
