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.
Cuprins
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 <project-name>
Puteți înlocui „
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 module module-a
Și rulați comanda echivalentă pentru modulul-b:
nest generate module module-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 astfel, cu directoarele src/module-a și src/module-b:
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 (module-a.module.ts). În mod implicit, CLI Nest.js nu furnizează o matrice de exporturi în decoratorul @Module, astfel încât fișierul modul generat va arăta astfel:
import { Module } from '@nestjs/common';
import { ModuleAService } from './module-a.service';
import { ModuleAController } from './module-a.controller';@Module({
providers: [ModuleAService],
controllers: [ModuleAController],
})export class ModuleAModule {}
Pentru a face service-a (module-a.service.ts) accesibil modulelor care importă modulul-a, creați o matrice de exporturi în decoratorul @Module și adăugați ModuleAService la acesta.
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],
})
export class ModuleAModule {}
Apoi, în scopuri de testare, adăugați o funcție simplă la modulul dvs.-un fișier de serviciu (module-a.service.ts):
import { Injectable } from '@nestjs/common';@Injectable()
export class ModuleAService {
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 listați ca import în matricea de importuri a modulului de primire. În acest caz, trebuie să adăugați module-a la matricea de importuri a decoratorului @Module al modulului-b.
Ca și înainte, CLI-ul Nest.js nu generează automat o matrice de importuri, așa că trebuie să o adăugați manual.
Mai întâi, importați modulul părinte (module-a.module.ts) în modulul de primire (module-b.module.ts), creați matricea de importuri și adăugați ModuleAModule la matrice:
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],
})export class ModuleBModule {}
Apoi, deschideți fișierul module-b.service.ts și importați decoratorul Inject și ModuleAServerice din @nests/common și, respectiv, ../module-a/module-a.service:
import { Injectable, Inject } from '@nestjs/common';
import { ModuleAService } from '../module-a/module-a.service';
Decoratorul Inject își marchează parametrul ca țintă pentru injectarea dependenței.
Apoi, în clasa ModuleBService, 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 metoda getHello a ModuleAService.
import { Injectable, Inject } from '@nestjs/common';
import { ModuleAService } from 'src/module-a/module-a.service';@Injectable()
export class ModuleBService {
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;getHello(): string {
return this.moduleAService.getHello();
}
}
Apoi, deschideți fișierul module-b.controller.ts și înlocuiți codul generat cu blocul de cod de mai jos:
import { Controller, Get } from '@nestjs/common';
import { ModuleBService } from './module-b.service';@Controller('module-b')
export class ModuleBController {
constructor(private readonly moduleBService: ModuleBService) {}@Get('/hello')
getHello(): string {
return this.moduleBService.getHello();
}
}
Blocul de cod de mai sus setează un handler de rută GET pentru funcția getHello.
În cele din urmă, faceți o solicitare GET cu curl către localhost:3000/module-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 construiți 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ă.