Nest.js pakalpojuma ievadīšana no cita moduļa

Pakalpojuma ievadīšana no cita Nest.js moduļa ietver dažas darbības, lai nodrošinātu pareizu atkarības ievadīšanu un moduļa organizēšanu. Izmantojot divus paraugus moduļus, uzziniet, kā darbojas pakalpojumu eksportēšanas un importēšanas process.

Nest.js projekta ģenerēšana

Lai ģenerētu Nest.js projektu, jūsu ierīcē ir jābūt instalētai CLI. Ja nē, palaidiet šo komandu, lai to instalētu:

npm install -g @nestjs/cli

Kad ir instalēts Nest.js CLI, palaidiet šo komandu, lai ģenerētu jaunu Nest.js projektu:

nest new

Jūs varat aizstāt "” ar jebkuru jūsu izvēlēto vārdu. Palaižot iepriekš norādīto komandu, tiks ģenerēts jauns Nest.js projekts ar norādīto nosaukumu.

Jūsu pašreizējai projekta struktūrai vajadzētu izskatīties šādi:

Lai praktizētu pakalpojuma ievadīšanu no viena moduļa uz citu moduli, jums ir jāģenerē divi moduļi – modulis-a un modulis-b. Jūs arī ģenerēsit to atbilstošos pakalpojumu un kontroliera failus.

Palaidiet šo komandu, lai ģenerētu moduli-a:

nest generate modulemodule-a

Un palaidiet līdzvērtīgu komandu modulim-b:

nest generate modulemodule-b

Pēc tam palaidiet šo komandu, lai ģenerētu pakalpojuma un kontrollera failus modulim-a:

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

Un palaidiet līdzvērtīgu komandu modulim-b:

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

Jūsu pašreizējam projektu direktorijam vajadzētu izskatīties šādi, ar src/module-a un src/module-b katalogi:

Pakalpojuma eksportēšana no A moduļa

Lai eksportētu pakalpojumu modulis-a no moduļa-a moduļa, tas ir jānorāda kā eksportēšana moduļa-a moduļa failā (modulis-a.module.ts). Pēc noklusējuma Nest.js CLI nenodrošina eksportu masīvs sadaļā @Modulis dekorators, tāpēc ģenerētais moduļa fails izskatīsies šādi:

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

Lai veiktu pakalpojumu (modulis-a.service.ts) pieejams moduļiem, kas importē moduli-a, izveido an eksportu masīvs sadaļā @Modulis dekorators un pievienot ModuleAService uz to.

Tā kā:

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

Pēc tam testēšanas nolūkos pievienojiet modulim vienkāršu funkciju — pakalpojuma failam (modulis-a.service.ts):

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

Šī funkcija atgriež parauga virkni. Lai apstiprinātu, ka varat pareizi importēt šo pakalpojumu, pēc pakalpojuma-a ievadīšanas izsauciet šo funkciju no moduļa-b.

Pakalpojuma importēšana B modulī

Lai importētu vienu moduli citā, tas ir jānorāda kā importēšana sarakstā imports saņemošā moduļa masīvs. Šajā gadījumā jums ir jāpievieno modulis-a imports b moduļu masīvs @Modulis dekorators.

Tāpat kā iepriekš, Nest.js CLI automātiski neģenerē imports masīvs, tāpēc jums tas ir jāpievieno manuāli.

Vispirms importējiet vecāku moduli (modulis-a.module.ts) saņemšanas modulī (modulis-b.module.ts), izveidojiet imports masīvs un pievienojiet ModulisAModulis uz masīvu:

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

Pēc tam atveriet savu modulis-b.service.ts failu un importēt Injicēt dekorators un ModuleAServerice no @ligzdas/kopīgs un ../module-a/module-a.service, attiecīgi:

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

The Injicēt dekorators atzīmē savu parametru kā mērķi atkarības injekcijai.

Tālāk, jūsu ModulisBpakalpojums klasē, pievienojiet zemāk esošo koda bloku:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Iepriekš minētais koda bloks nodrošina jūsu ModuleBService piekļuvi metodēm, kas pieejamas jūsu ModuleAService.

Pakalpojumu var pārbaudīt, zvanot uz ModuleAService get Sveiki metodi.

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

Pēc tam atveriet savu modulis-b.controller.ts failu un aizstāt ģenerēto kodu ar tālāk norādīto koda bloku:

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

Iepriekš minētais koda bloks iestata a GŪT maršruta apstrādātājs get Sveiki funkciju.

Visbeidzot, veikt GET pieprasījumu ar čokurošanās vietējam resursdatoram: 3000/modulis-b/labdien. Komandai jādrukā "Sveiki no A moduļa!" uz jūsu konsoli.

Jūs esat veiksmīgi ievietojis pakalpojumu citā modulī. Tas var noderēt, kad esat API izveide, izmantojot Nest.js kuriem ir vairāki moduļi, kuriem jāizsauc vienam otra metodes.

Šķērsmoduļu iesmidzināšanas priekšrocības

Lai gan sākotnēji tieša pakalpojuma izsaukšana no cita moduļa varētu šķist vienkāršāka, ilgtermiņā tā var radīt sarežģītāku, mazāk uzturējamu un mazāk mērogojamu sistēmu.

Tomēr vairāku moduļu iesmidzināšana veicina koda modularitāti un atkārtotu izmantošanu, padarot to vieglāk apkopi. Turklāt tas centralizē atkarības, uzlabo testējamību un atbalsta mērogojamu, atsaistītu arhitektūru.