Nest.js szolgáltatás beszúrása egy másik modulból

Egy másik Nest.js modulból származó szolgáltatás beillesztése néhány lépést foglal magában a megfelelő függőségi beillesztés és a modulszervezés biztosítása érdekében. Két mintamodul segítségével ismerje meg a szolgáltatások exportálásának és importálásának folyamatát.

Nest.js projekt létrehozása

Nest.js projekt létrehozásához telepítenie kell a CLI-t az eszközére. Ha nem, futtassa ezt a parancsot a telepítéshez:

npm install -g @nestjs/cli

Ha telepítve van a Nest.js parancssori felület, futtassa ezt a parancsot egy új Nest.js projekt létrehozásához:

nest new

helyettesítheti a "” tetszőleges névvel. A fenti parancs futtatásával új Nest.js projekt jön létre a megadott néven.

A jelenlegi projekt felépítése az alábbi képen látható:

A szolgáltatás egyik modulból egy másik modulba történő beillesztésének gyakorlásához két modult kell létrehoznia, az a modult és a b modult. Ezenkívül létrehozza a megfelelő szolgáltatás- és vezérlőfájljaikat.

Futtassa ezt a parancsot a modul-a generálásához:

nest generate modulemodule-a

És futtassa az egyenértékű parancsot a modul-b számára:

nest generate modulemodule-b

Ezután futtassa ezt a parancsot a szolgáltatás- és vezérlőfájlok létrehozásához az a modulhoz:

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

És futtassa az egyenértékű parancsot a modul-b számára:

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

A jelenlegi projektkönyvtárának így kell kinéznie, -val src/module-a és src/module-b könyvtárak:

Szolgáltatás exportálása az A modulból

A modul-a szolgáltatás exportálásához a modul-a modulból exportálásként kell feltüntetni az a modul modul fájljában (modul-a.module.ts). Alapértelmezés szerint a Nest.js parancssori felület nem biztosít egy export tömb a @Modul dekorátor, így a generált modulfájl így fog kinézni:

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

A szolgáltatás elkészítéséhez (modul-a.service.ts) elérhető olyan modulok számára, amelyek az a modult importálják, létrehoznak egy export tömb a @Modul díszítő és add hozzá ModuleAService hozzá.

Például így:

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

Ezután tesztelési célból adjon hozzá egy egyszerű függvényt a modulhoz - egy szolgáltatásfájlt (modul-a.service.ts):

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

Ez a függvény egy minta karakterláncot ad vissza. A szolgáltatás helyes importálásának megerősítéséhez hívja meg ezt a funkciót a-b modulból az a szolgáltatás beillesztése után.

Szolgáltatás importálása a B modulba

Ahhoz, hogy egy modult egy másikba importáljon, importálásként kell listáznia a listában behozatal a fogadó modul tömbje. Ebben az esetben hozzá kell adni az a modult a behozatal b modulok tömbje @Modul lakberendező.

Mint korábban, a Nest.js parancssori felület nem hoz létre automatikusan egy behozatal tömböt, ezért manuálisan kell hozzáadnia.

Először importálja a szülő modult (modul-a.module.ts) a fogadó modulba (modul-b.module.ts), hozza létre a behozatal tömböt, és add hozzá ModuleAModule a tömbhöz:

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

Ezután nyissa meg a sajátját modul-b.service.ts fájlt, és importálja a Injekciós lakberendező és ModuleAServerice tól től @fészkek/közös és ../modul-a/module-a.service, illetve:

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

A Injekciós dekorátor megjelöli a paraméterét a függőségi injekció célpontjaként.

Következő, a tiédben ModulBService osztályba, adja hozzá az alábbi kódblokkot:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

A fenti kódblokk hozzáférést biztosít a ModuleBService számára a ModuleAService-ben elérhető metódusokhoz.

A szolgáltatást tesztelheti a ModuleAService hívásával getHello módszer.

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

Ezután nyissa meg a sajátját modul-b.controller.ts fájlba, és cserélje ki a generált kódot az alábbi kódblokkra:

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

A fenti kódblokk beállítja a KAP útvonalkezelő a getHello funkció.

Végül, göndörítéssel kérjen GET-et a localhostnak: 3000/modul-b/hello. A parancsnak ki kell írnia: „Hello from Module A!” a konzolodhoz.

Sikeresen beillesztett egy szolgáltatást egy másik modulba. Ez jól jöhet, ha van API-k létrehozása a Nest.js segítségével amelyeknek több modulja van, amelyeknek egymás metódusait kell meghívniuk.

A keresztmodulos befecskendezés előnyei

Bár egy szolgáltatás közvetlen meghívása egy másik modulból elsőre egyszerűbbnek tűnhet, hosszú távon bonyolultabb, kevésbé karbantartható és kevésbé skálázható rendszerhez vezethet.

A modulok közötti befecskendezés azonban elősegíti a kód modularitását és újrafelhasználhatóságát, megkönnyítve a karbantartást. Ezenkívül központosítja a függőségeket, javítja a tesztelhetőséget, és támogatja a méretezhető, szétválasztott architektúrát.