Nest.js paslaugos įvedimas iš kito modulio

Įterpiant paslaugą iš kito Nest.js modulio reikia atlikti kelis veiksmus, kad būtų užtikrintas tinkamas priklausomybės įvedimas ir modulio organizavimas. Naudodami du pavyzdinius modulius sužinokite, kaip veikia paslaugų eksportavimo ir importavimo procesas.

Nest.js projekto generavimas

Norėdami sugeneruoti Nest.js projektą, įrenginyje turite turėti įdiegtą CLI. Jei ne, paleiskite šią komandą, kad ją įdiegtumėte:

npm install -g @nestjs/cli

Įdiegę Nest.js CLI paleiskite šią komandą, kad sukurtumėte naują Nest.js projektą:

nest new

Galite pakeisti "“ su bet kokiu pasirinktu vardu. Vykdant aukščiau pateiktą komandą bus sukurtas naujas Nest.js projektas nurodytu pavadinimu.

Jūsų dabartinė projekto struktūra turėtų atrodyti taip, kaip toliau pateiktame paveikslėlyje:

Norėdami praktikuoti paslaugos įtraukimą iš vieno modulio į kitą modulį, sugeneruosite du modulius – modulį-a ir modulį-b. Taip pat sugeneruosite atitinkamus paslaugų ir valdiklio failus.

Vykdykite šią komandą, kad sugeneruotumėte modulį-a:

nest generate modulemodule-a

Ir paleiskite lygiavertę komandą moduliui-b:

nest generate modulemodule-b

Tada paleiskite šią komandą, kad sugeneruotumėte modulio a paslaugų ir valdiklio failus:

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

Ir paleiskite lygiavertę komandą moduliui-b:

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

Jūsų dabartinis projekto katalogas turėtų atrodyti taip, su src/module-a ir src/module-b katalogai:

Paslaugos eksportavimas iš A modulio

Norėdami eksportuoti paslaugą modulis-a iš modulio-a modulio, turite nurodyti ją kaip eksportą modulio-a modulio faile (modulis-a.module.ts). Pagal numatytuosius nustatymus Nest.js CLI nepateikia eksportas masyvas @Modulis dekoratorius, todėl sugeneruotas modulio failas atrodys taip:

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

Norėdami atlikti paslaugą (modulis-a.service.ts) prieinama moduliams, kurie importuoja modulį-a, sukuria an eksportas masyvas @Modulis dekoratorius ir pridėkite ModulisAS paslauga prie jo.

Kaip taip:

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

Tada testavimo tikslais į savo modulį pridėkite paprastą funkciją – paslaugos failą (modulis-a.service.ts):

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

Ši funkcija grąžina pavyzdinę eilutę. Norėdami patvirtinti, kad galite tinkamai importuoti šią paslaugą, įvedę paslaugą a, iškviesite šią funkciją iš modulio-b.

Paslaugos importavimas į B modulį

Norėdami importuoti vieną modulį į kitą, turite nurodyti jį kaip importavimą importas priėmimo modulio masyvas. Tokiu atveju turite pridėti modulį-a prie importas modulių-b masyvas @Modulis dekoratorius.

Kaip ir anksčiau, Nest.js CLI automatiškai negeneruoja importas masyvas, todėl turite jį pridėti rankiniu būdu.

Pirmiausia importuokite pagrindinį modulį (modulis-a.module.ts) į priėmimo modulį (modulis-b.module.ts), sukurkite importas masyvą ir pridėkite ModulisAModulis į masyvą:

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

Tada atidarykite savo modulis-b.service.ts failą ir importuoti Suleisti dekoratorius ir ModuleAServerice iš @lizdai/bendras ir ../module-a/module-a.service, atitinkamai:

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

The Suleisti dekoratorius pažymi savo parametrą kaip priklausomybės injekcijos tikslą.

Kitas, jūsų ModulisBservice klasėje, pridėkite kodo bloką žemiau:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Aukščiau pateiktas kodo blokas suteikia jūsų ModuleBService prieigą prie metodų, galimų jūsų ModuleAService.

Išbandyti paslaugą galite paskambinę į ModuleAService gauti Sveiki metodas.

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

Tada atidarykite savo modulis-b.controller.ts failą ir pakeiskite sugeneruotą kodą toliau pateiktu kodo 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();
 }
}

Aukščiau pateiktas kodo blokas nustato a GAUTI maršruto tvarkytojas gauti Sveiki funkcija.

Pagaliau, pateikti GET užklausą su curl į localhost: 3000/module-b/hello. Komanda turėtų išspausdinti „Sveiki iš A modulio! į savo konsolę.

Sėkmingai įtraukėte paslaugą į kitą modulį. Tai gali būti naudinga, kai esate kurti API su Nest.js kurie turi kelis modulius, kurie turi iškviesti vienas kito metodus.

Kryžminio modulio įpurškimo pranašumai

Nors iš pradžių tiesiogiai iškviesti paslaugą iš kito modulio gali atrodyti paprasčiau, ilgainiui dėl to gali susidaryti sudėtingesnė, mažiau prižiūrima ir mažiau keičiamo dydžio sistema.

Tačiau kryžminio modulio įpurškimas skatina kodo moduliškumą ir pakartotinį naudojimą, todėl jį lengviau prižiūrėti. Be to, jis centralizuoja priklausomybes, pagerina testavimą ir palaiko keičiamo dydžio, atsietą architektūrą.