Ubacivanje usluge Nest.js iz drugog modula

Ubacivanje usluge iz drugog Nest.js modula uključuje nekoliko koraka kako bi se osiguralo ispravno ubacivanje ovisnosti i organizacija modula. Pomoću dva ogledna modula naučite kako funkcionira proces izvoza i uvoza usluga.

Generiranje Nest.js projekta

Za generiranje Nest.js projekta morate imati CLI instaliran na svom uređaju. Ako ne, pokrenite ovu naredbu da biste ga instalirali:

npm install -g @nestjs/cli

S instaliranim Nest.js CLI, pokrenite ovu naredbu za generiranje novog Nest.js projekta:

nest new

Možete zamijeniti "” s bilo kojim imenom koje odaberete. Pokretanje gornje naredbe generirat će novi Nest.js projekt s navedenim nazivom.

Vaša trenutna struktura projekta trebala bi izgledati kao na slici ispod:

Da biste vježbali ubacivanje usluge iz jednog modula u drugi modul, generirat ćete dva modula, modul-a i modul-b. Također ćete generirati njihove odgovarajuće datoteke usluga i kontrolera.

Pokrenite ovu naredbu za generiranje modula-a:

nest generate modulemodule-a

I pokrenite ekvivalentnu naredbu za modul-b:

nest generate modulemodule-b

Zatim pokrenite ovu naredbu za generiranje datoteka usluge i kontrolera za modul-a:

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

I pokrenite ekvivalentnu naredbu za modul-b:

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

Vaš trenutni direktorij projekta trebao bi izgledati ovako, sa src/modul-a i src/modul-b imenici:

Izvoz usluge iz modula A

Da biste izvezli uslugu modula-a iz modula modula, morate je navesti kao izvoz u datoteci modula modula-a (modul-a.modul.ts). Prema zadanim postavkama, Nest.js CLI ne pruža izvozi niz u @Modul dekorater, tako da će generirana datoteka modula izgledati ovako:

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

Za napraviti servis-a (modul-a.service.ts) dostupan modulima koji uvoze modul-a, kreiraju izvozi niz u @Modul dekorater i dodati ModulAService na to.

ovako:

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

Zatim, u svrhu testiranja, dodajte jednostavnu funkciju svom modulu - servisnu datoteku (modul-a.service.ts):

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

Ova funkcija vraća uzorak niza. Kako biste potvrdili da možete ispravno uvesti ovu uslugu, pozvati ćete tu funkciju iz modula-b nakon ubacivanja usluge-a.

Uvoz usluge u modul B

Da biste uvezli jedan modul u drugi, morate ga navesti kao uvoz u uvozi niz prijemnog modula. U ovom slučaju, morate dodati modul-a u uvozi niz modula-b @Modul dekorater.

Kao i prije, Nest.js CLI ne generira automatski uvozi niz, pa ga morate ručno dodati.

Prvo uvezite nadređeni modul (modul-a.modul.ts) u prijemni modul (modul-b.modul.ts), stvorite uvozi niz i dodajte ModulAModul u niz:

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

Zatim otvorite svoj modul-b.service.ts datoteku i uvoz Ubrizgati dekorater i ModulAService iz @gnijezda/zajedničko i ../modul-a/modul-a.usluga, odnosno:

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

The Ubrizgati dekorater označava svoj parametar kao cilj za uvođenje ovisnosti.

Dalje, u vašem ModulBService klase, dodajte blok koda u nastavku:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Gornji blok koda daje vašem ModuleBService pristup metodama dostupnim u vašem ModuleAServiceu.

Uslugu možete testirati pozivom na ModuleAService getHello metoda.

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

Zatim otvorite svoj modul-b.controller.ts datoteku i zamijenite generirani kod blokom koda u nastavku:

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

Gornji blok koda postavlja a DOBITI rukovatelj rutom za getHello funkcija.

Konačno, napravite GET zahtjev s curlom lokalnom hostu: 3000/modul-b/zdravo. Naredba bi trebala ispisati "Pozdrav iz modula A!" na svoju konzolu.

Uspješno ste ubacili uslugu u drugi modul. Ovo vam može dobro doći kada ste izrada API-ja s Nest.js koji imaju više modula koji moraju međusobno pozivati ​​metode.

Prednosti ubrizgavanja između modula

Iako bi se izravno pozivanje usluge iz drugog modula isprva moglo činiti jednostavnijim, to dugoročno može dovesti do složenijeg, manje održivog i manje skalabilnog sustava.

Međutim, umetanje više modula promiče modularnost koda i mogućnost ponovne upotrebe, čineći ga lakšim za održavanje. Dodatno, centralizira ovisnosti, poboljšava mogućnost testiranja i podržava skalabilnu, razdvojenu arhitekturu.