Home-theater-designers
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.
MUO Videoclipul zilei Derulați PENTRU A CONTINUA CU CONȚINUT
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:
cum să vezi cine te-a blocat pe instagram
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],
})
export class ModuleAModule {}
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],
})
export class ModuleAModule {}
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()
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 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:
cum să introduci iPhone-ul în modul de recuperare
// 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],
})
export class ModuleBModule {}
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.
aplicație pentru a pune fețe pe imagini
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()
export class ModuleBService {
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
getHello(): string {
return this.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')
export class ModuleBController {
constructor(private readonly moduleBService: ModuleBService) {}
@Get('/hello')
getHello(): string {
return this.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/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 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ă.