Injisere en Nest.js-tjeneste fra en annen modul

Å injisere en tjeneste fra en annen Nest.js-modul innebærer noen få trinn for å sikre riktig avhengighetsinjeksjon og modulorganisering. Ved å bruke to eksempelmoduler kan du lære hvordan prosessen med å eksportere og importere tjenester fungerer.

Genererer et Nest.js-prosjekt

For å generere et Nest.js-prosjekt må du ha CLI installert på enheten din. Hvis du ikke gjør det, kjør denne kommandoen for å installere den:

npm install -g @nestjs/cli

Med Nest.js CLI installert, kjør denne kommandoen for å generere et nytt Nest.js-prosjekt:

nest new

Du kan erstatte "" med hvilket som helst navn du velger. Å kjøre kommandoen ovenfor vil generere et nytt Nest.js-prosjekt med det angitte navnet.

Din nåværende prosjektstruktur skal se ut som bildet nedenfor:

For å øve på å injisere en tjeneste fra en modul til en annen modul, genererer du to moduler, modul-a og modul-b. Du vil også generere deres tilsvarende tjeneste- og kontrollerfiler.

Kjør denne kommandoen for å generere modul-a:

nest generate modulemodule-a

Og kjør den tilsvarende kommandoen for modul-b:

nest generate modulemodule-b

Kjør deretter denne kommandoen for å generere tjeneste- og kontrollerfilene for modul-a:

nest generate service module-a && nest generate controller module-a

Og kjør den tilsvarende kommandoen for modul-b:

nest generate service module-b && nest generate controller module-b

Din nåværende prosjektkatalog skal se slik ut, med src/modul-a og src/modul-b kataloger:

Eksportere en tjeneste fra modul A

For å eksportere modul-a-tjenesten fra modul-a-modulen, må du liste den som en eksport i modul-as modulfil (modul-a.modul.ts). Som standard gir ikke Nest.js CLI en eksport rekke i @Modul dekorator, så den genererte modulfilen vil se slik ut:

// 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{}

For å gjøre tjeneste-en (module-a.service.ts) tilgjengelig for moduler som importerer modul-a, oppretter en eksport rekke i @Modul dekoratør og legg til ModulAService til det.

Som så:

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{}

Deretter, for testformål, legg til en enkel funksjon til modulen din - en tjenestefil (module-a.service.ts):

import { Injectable } from'@nestjs/common';
@Injectable()
exportclassModuleAService{
 getHello(): string {
return'Hello from Module A!';
 }
}

Denne funksjonen returnerer en prøvestreng. For å bekrefte at du kan importere denne tjenesten riktig, kaller du den funksjonen fra modul-b etter å ha injisert tjeneste-a.

Importere en tjeneste til modul B

For å importere en modul til en annen, må du liste den som en import i import rekke av mottaksmodulen. I dette tilfellet må du legge til modul-a til import rekke modul-b-er @Modul dekoratør.

Som før genererer ikke Nest.js CLI automatisk en import array, så du må legge den til manuelt.

Først importerer du den overordnede modulen (modul-a.modul.ts) inn i mottaksmodulen (modul-b.modul.ts), opprette import array, og legg til ModulAModule til 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{}

Deretter åpner du din modul-b.service.ts fil og importer Injiser dekoratør og ModuleAServerice fra @nest/common og ../module-a/module-a.service, henholdsvis:

import { Injectable, Inject } from'@nestjs/common';
import { ModuleAService } from'../module-a/module-a.service';

De Injiser dekorator markerer parameteren som et mål for avhengighetsinjeksjon.

Neste, i din ModuleBService klasse, legg til kodeblokken nedenfor:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Kodeblokken ovenfor gir din ModuleBService tilgang til metodene som er tilgjengelige i din ModuleAService.

Du kan teste tjenesten ved å ringe ModuleAService fåHallo metode.

// 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();
 }
}

Deretter åpner du din modul-b.kontroller.ts fil og erstatt den genererte koden med kodeblokken nedenfor:

// 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();
 }
}

Kodeblokken ovenfor setter opp en FÅ rutebehandler for fåHallo funksjon.

Endelig, foreta en GET-forespørsel med krøll til localhost: 3000/module-b/hallo. Kommandoen skal skrive ut "Hei fra modul A!" til konsollen din.

Du har injisert en tjeneste i en annen modul. Dette kan komme godt med når du er det bygge APIer med Nest.js som har flere moduler som må kalle hverandres metoder.

Fordeler med kryssmodulinjeksjon

Selv om det kan virke enklere i begynnelsen å ringe en tjeneste direkte fra en annen modul, kan det føre til et mer komplekst, mindre vedlikeholdbart og mindre skalerbart system i det lange løp.

Imidlertid fremmer kryssmodulinjeksjon kodemodularitet og gjenbrukbarhet, noe som gjør det enklere å vedlikeholde. I tillegg sentraliserer den avhengigheter, forbedrer testbarheten og støtter en skalerbar, frakoblet arkitektur.