Vloženie služby Nest.js z iného modulu

Vloženie služby z iného modulu Nest.js zahŕňa niekoľko krokov na zabezpečenie správneho vloženia závislosti a organizácie modulov. Pomocou dvoch vzorových modulov sa dozviete, ako funguje proces exportu a importu služieb.

Generovanie projektu Nest.js

Ak chcete vygenerovať projekt Nest.js, musíte mať na svojom zariadení nainštalované CLI. Ak nie, spustite tento príkaz a nainštalujte ho:

npm install -g @nestjs/cli

S nainštalovaným Nest.js CLI spustite tento príkaz a vygenerujte nový projekt Nest.js:

nest new

Môžete nahradiť „“ s ľubovoľným menom, ktoré si vyberiete. Spustenie vyššie uvedeného príkazu vygeneruje nový projekt Nest.js so zadaným názvom.

Vaša súčasná štruktúra projektu by mala vyzerať ako na obrázku nižšie:

Ak si chcete vyskúšať vloženie služby z jedného modulu do iného modulu, vygenerujete dva moduly, modul-a a modul-b. Vygenerujete aj ich príslušné servisné a kontrolné súbory.

Spustite tento príkaz na vygenerovanie modulu-a:

nest generate modulemodule-a

A spustite ekvivalentný príkaz pre modul-b:

nest generate modulemodule-b

Potom spustite tento príkaz na vygenerovanie servisných a riadiacich súborov pre modul-a:

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

A spustite ekvivalentný príkaz pre modul-b:

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

Váš aktuálny adresár projektu by mal vyzerať takto, s src/modul-a a src/modul-b adresáre:

Export služby z modulu A

Ak chcete exportovať službu module-a z modulu module-a, musíte ju uviesť ako export v súbore modulu modulu-a (modul-a.modul.ts). V predvolenom nastavení Nest.js CLI neposkytuje exportov pole v @Modul dekoratér, takže vygenerovaný súbor modulu bude vyzerať takto:

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

Urobiť službu (modul-a.service.ts) prístupné modulom, ktoré importujú modul-a, vytvárajú súbor exportov pole v @Modul dekoratér a pridať ModuleAService k tomu.

Ako:

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

Ďalej na testovacie účely pridajte do svojho modulu jednoduchú funkciu – súbor služby (modul-a.service.ts):

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

Táto funkcia vracia vzorový reťazec. Aby ste potvrdili, že túto službu môžete importovať správne, zavoláte túto funkciu z modulu-b po zavedení služby-a.

Importovanie služby do modulu B

Ak chcete importovať jeden modul do druhého, musíte ho uviesť ako import v dovoz poľa prijímacieho modulu. V tomto prípade musíte do súboru pridať modul-a dovoz pole modulov b @Modul dekoratér.

Rovnako ako predtým, Nest.js CLI negeneruje automaticky dovoz pole, takže ho musíte pridať ručne.

Najprv importujte nadradený modul (modul-a.modul.ts) do prijímacieho modulu (modul-b.modul.ts), vytvorte dovoz pole a pridajte ModulAModule do poľa:

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

Ďalej otvorte svoj modul-b.service.ts súbor a importujte súbor Vstreknite dekoratér a ModulAServerice od @hniezda/spoločné a ../module-a/module-a.service, respektíve:

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

The Vstreknite dekorátor označí svoj parameter ako cieľ pre injekciu závislosti.

Ďalej vo vašom ModuleBService triedy, pridajte blok kódu nižšie:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Vyššie uvedený blok kódu poskytuje vášmu ModuleBService prístup k metódam dostupným vo vašom ModuleAService.

Službu môžete otestovať zavolaním na ModuleAService getHello metóda.

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

Ďalej otvorte svoj modul-b.controller.ts súbor a nahraďte vygenerovaný kód blokom kódu nižšie:

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

Vyššie uvedený blok kódu nastavuje a GET obsluhovač trasy pre getHello funkciu.

nakoniec vytvorte požiadavku GET pomocou curl na localhost: 3000/modul-b/hello. Príkaz by mal vypísať „Ahoj z modulu A!“ do vašej konzoly.

Úspešne ste vložili službu do iného modulu. To sa vám môže hodiť vytváranie API s Nest.js ktoré majú viacero modulov, ktoré si musia navzájom volať svoje metódy.

Výhody medzimodulového vstrekovania

Aj keď sa priame volanie služby z iného modulu môže na prvý pohľad zdať jednoduchšie, z dlhodobého hľadiska to môže viesť k zložitejšiemu, menej udržiavateľnému a menej škálovateľnému systému.

Vstrekovanie medzi modulmi však podporuje modularitu kódu a opätovnú použiteľnosť, čo uľahčuje jeho údržbu. Okrem toho centralizuje závislosti, zlepšuje testovateľnosť a podporuje škálovateľnú, oddelenú architektúru.