Injectarea unui serviciu Nest.js dintr-un modul diferit

Injectarea unui serviciu dintr-un alt modul Nest.js implică câțiva pași pentru a asigura injecția adecvată a dependenței și organizarea modulelor. Folosind două exemple de module, aflați cum funcționează procesul de export și import de servicii.

Generarea unui proiect Nest.js

Pentru a genera un proiect Nest.js, trebuie să aveți CLI-ul instalat pe dispozitiv. Dacă nu, rulați această comandă pentru a o instala:

npm install -g @nestjs/cli

Cu CLI Nest.js instalat, rulați această comandă pentru a genera un nou proiect Nest.js:

nest new

Puteți înlocui „” cu orice nume alegi. Rularea comenzii de mai sus va genera un nou proiect Nest.js cu numele specificat.

Structura actuală a proiectului ar trebui să arate ca imaginea de mai jos:

Pentru a exersa injectarea unui serviciu de la un modul într-un alt modul, veți genera două module, modulul-a și modulul-b. De asemenea, veți genera fișierele de serviciu și controler corespunzătoare.

Rulați această comandă pentru a genera modulul-a:

nest generate modulemodule-a

Și rulați comanda echivalentă pentru modulul-b:

nest generate modulemodule-b

Apoi rulați această comandă pentru a genera fișierele de serviciu și controler pentru modulul-a:

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

Și rulați comanda echivalentă pentru modulul-b:

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

Directorul actual al proiectului ar trebui să arate așa, cu src/modul-a și src/modul-b directoare:

Exportarea unui serviciu din modulul A

Pentru a exporta serviciul module-a din modulul module-a, trebuie să-l listați ca export în fișierul modulului module-a (modul-a.modul.ts). În mod implicit, CLI Nest.js nu oferă un exporturi matrice în @Modul decorator, deci fișierul modul generat va arăta astfel:

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

Pentru a face service-a (modul-a.service.ts) accesibil modulelor care importă modul-a, creează un exporturi matrice în @Modul decorator si adauga ModuleAService la el.

Ca astfel:

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

Apoi, în scopuri de testare, adăugați o funcție simplă la modulul dvs. - un fișier de serviciu (modul-a.service.ts):

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

Această funcție returnează un șir de probă. Pentru a confirma că puteți importa acest serviciu corect, veți apela acea funcție din modulul-b după injectarea serviciului-a.

Importarea unui serviciu în modulul B

Pentru a importa un modul în altul, trebuie să-l enumerați ca import în importurilor matricea modulului receptor. În acest caz, trebuie să adăugați modul-a la importurilor matrice de module-b @Modul decorator.

Ca și înainte, CLI-ul Nest.js nu generează automat un importurilor matrice, deci trebuie să-l adăugați manual.

Mai întâi, importați modulul părinte (modul-a.modul.ts) în modulul de recepție (modul-b.modul.ts), creați importurilor matrice și adăugați ModululModulul la matrice:

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

Apoi, deschideți modul-b.service.ts fișier și importați fișierul Injecta decorator şi ModuleAServiciu din @cuiburi/comun și ../modul-a/modul-a.serviciu, respectiv:

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

The Injecta decorator își marchează parametrul ca țintă pentru injectarea dependenței.

În continuare, în dvs ModuleBService clasa, adăugați blocul de cod de mai jos:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Blocul de cod de mai sus vă oferă ModuleBService acces la metodele disponibile în ModuleAService.

Puteți testa serviciul apelând la ModuleAService ia salut metodă.

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

Apoi, deschideți modul-b.controller.ts fișier și înlocuiți codul generat cu blocul de cod de mai jos:

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

Blocul de cod de mai sus stabilește a OBȚINE handler de rută pentru ia salut funcţie.

In cele din urma, faceți o cerere GET cu curl către localhost: 3000/modul-b/hello. Comanda ar trebui să afișeze „Salut de la Modulul A!” la consola ta.

Ați injectat cu succes un serviciu într-un alt modul. Acest lucru poate fi util atunci când ești construirea de API-uri cu Nest.js care au mai multe module care trebuie să apeleze reciproc metodele.

Beneficiile injectării cu module încrucișate

În timp ce apelarea directă a unui serviciu de la alt modul poate părea mai simplă la început, poate duce la un sistem mai complex, mai puțin întreținut și mai puțin scalabil pe termen lung.

Cu toate acestea, injecția între module promovează modularitatea și reutilizarea codului, făcându-l mai ușor de întreținut. În plus, centralizează dependențele, îmbunătățește testabilitatea și acceptă o arhitectură scalabilă, decuplată.