Teenuse Nest.js süstimine teisest moodulist

Teenuse sisestamine teisest Nest.js-i moodulist hõlmab mõne sammu, et tagada õige sõltuvuse süstimine ja mooduli korraldus. Kahe näidismooduli abil saate teada, kuidas teenuste ekspordi ja importimise protsess toimib.

Nest.js projekti loomine

Nest.js projekti loomiseks peab teie seadmesse olema installitud CLI. Kui te seda ei tee, käivitage selle installimiseks see käsk:

npm install -g @nestjs/cli

Kui Nest.js CLI on installitud, käivitage see käsk uue Nest.js projekti loomiseks:

nest new

Saate asendada "” mis tahes valitud nimega. Ülaltoodud käsu käivitamine loob uue Nest.js-i projekti määratud nimega.

Teie praegune projekti struktuur peaks välja nägema alloleval pildil:

Teenuse ühest moodulist teise moodulisse sisestamise harjutamiseks loote kaks moodulit, moodul-a ja moodul-b. Samuti loote neile vastavad teenuse- ja kontrollerifailid.

Käivitage see käsk mooduli a genereerimiseks:

nest generate modulemodule-a

Ja käivitage samaväärne käsk mooduli b jaoks:

nest generate modulemodule-b

Seejärel käivitage see käsk, et luua mooduli a teenuse- ja kontrollerifailid:

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

Ja käivitage samaväärne käsk mooduli b jaoks:

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

Teie praegune projektikataloog peaks välja nägema selline, koos src/module-a ja src/module-b kataloogid:

Teenuse eksportimine moodulist A

Teenuse moodul-a eksportimiseks moodulist a tuleb see eksportida mooduli a mooduli failis (moodul-a.moodul.ts). Vaikimisi ei paku Nest.js CLI eksporti massiivi @Moodul dekoraator, nii et loodud moodulifail näeb välja selline:

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

Teeninduse tegemiseks (moodul-a.service.ts) juurdepääsetav moodulitele, mis impordivad moodulit a, loovad an eksporti massiivi @Moodul dekoraator ja lisage MoodulAService sellele.

Nagu nii:

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

Järgmisena lisage testimise eesmärgil oma moodulile lihtne funktsioon - teenusefail (moodul-a.service.ts):

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

See funktsioon tagastab näidisstringi. Kinnitamaks, et saate selle teenuse õigesti importida, helistate pärast teenuse-a sisestamist sellele funktsioonile moodulist b.

Teenuse importimine moodulisse B

Ühe mooduli teise importimiseks peate selle loendis importima import vastuvõtva mooduli massiiv. Sel juhul peate lisama mooduli a import mooduli b massiivi @Moodul dekoraator.

Nagu varemgi, ei loo Nest.js CLI automaatselt import massiivi, nii et peate selle käsitsi lisama.

Esiteks importige ülemmoodul (moodul-a.moodul.ts) vastuvõtumoodulisse (moodul-b.moodul.ts), looge import massiivi ja lisage MoodulAModul massiivi juurde:

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

Järgmisena avage oma moodul-b.service.ts faili ja importige Süstida dekoraator ja MoodulAServerice alates @pesad/tavaline ja ../moodul-a/moodul-a.teenus, vastavalt:

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

The Süstida dekoraator märgib oma parameetri sõltuvuse süstimise sihtmärgiks.

Järgmisena teie MoodulBService klass, lisage allpool olev koodiplokk:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Ülaltoodud koodiplokk annab teie ModuleBService'ile juurdepääsu teie ModuleAService'is saadaolevatele meetoditele.

Teenust saate testida helistades ModuleAService'i saada Tere meetod.

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

Järgmisena avage oma module-b.controller.ts faili ja asendage loodud kood alloleva koodiplokiga:

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

Ülaltoodud koodiplokk seadistab a SAADA marsruudi käitleja jaoks saada Tere funktsiooni.

Lõpuks tee curl'iga GET taotlus kohalikule hostile: 3000/moodul-b/tere. Käsk peaks trükkima "Tere moodulist A!" oma konsooli.

Olete edukalt sisestanud teenuse teise moodulisse. See võib olla kasulik, kui olete API-de loomine Nest.js-iga millel on mitu moodulit, mis peavad kutsuma üksteise meetodeid.

Ristmooduli süstimise eelised

Kuigi teisest moodulist teenusele otse helistamine võib alguses tunduda lihtsam, võib see pikas perspektiivis viia keerukama, vähem hooldatava ja vähem skaleeritava süsteemini.

Moodulitevaheline süstimine soodustab aga koodi modulaarsust ja korduvkasutatavust, muutes selle hooldamise lihtsamaks. Lisaks tsentraliseerib see sõltuvused, parandab testitavust ja toetab skaleeritavat lahtisidestatud arhitektuuri.