Iniezione di un servizio Nest.js da un modulo diverso

L'inserimento di un servizio da un modulo Nest.js diverso prevede alcuni passaggi per garantire l'inserimento delle dipendenze e l'organizzazione del modulo corrette. Utilizzando due moduli di esempio, scopri come funziona il processo di esportazione e importazione dei servizi.

Generazione di un progetto Nest.js

Per generare un progetto Nest.js, devi avere la CLI installata sul tuo dispositivo. In caso contrario, esegui questo comando per installarlo:

npm install -g @nestjs/cli

Con la CLI Nest.js installata, esegui questo comando per generare un nuovo progetto Nest.js:

nest new

Puoi sostituire “" con qualsiasi nome tu scelga. L'esecuzione del comando precedente genererà un nuovo progetto Nest.js con il nome specificato.

La struttura attuale del tuo progetto dovrebbe assomigliare all'immagine seguente:

Per esercitarti nell'inserire un servizio da un modulo a un modulo diverso, genererai due moduli, modulo-a e modulo-b. Genererai anche i file di servizio e controller corrispondenti.

Esegui questo comando per generare module-a:

nest generate modulemodule-a

Ed esegui il comando equivalente per module-b:

nest generate modulemodule-b

Quindi esegui questo comando per generare i file del servizio e del controller per module-a:

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

Ed esegui il comando equivalente per module-b:

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

La directory del tuo progetto attuale dovrebbe assomigliare a questa, con src/modulo-a E src/modulo-b directory:

Esportazione di un servizio dal modulo A

Per esportare il servizio module-a dal modulo module-a, devi elencarlo come un'esportazione nel file del modulo module-a (modulo-a.modulo.ts). Per impostazione predefinita, la CLI Nest.js non fornisce un file esportazioni matrice in @Modulo decoratore, quindi il file del modulo generato sarà simile a questo:

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

Per effettuare il servizio-a (module-a.service.ts) accessibile ai moduli che importano module-a, creano un esportazioni matrice in @Modulo decoratore e aggiungi ModuloAService ad esso.

Così:

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

Successivamente, a scopo di test, aggiungi una semplice funzione al tuo modulo: un file di servizio (module-a.service.ts):

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

Questa funzione restituisce una stringa di esempio. Per confermare che puoi importare correttamente questo servizio, chiamerai quella funzione dal modulo-b dopo aver inserito il servizio-a.

Importare un servizio nel modulo B

Per importare un modulo in un altro, devi elencarlo come importato nel file importazioni array del modulo ricevente. In questo caso, devi aggiungere module-a al file importazioni array di moduli b @Modulo decoratore.

Come prima, la CLI Nest.js non genera automaticamente un file importazioni array, quindi è necessario aggiungerlo manualmente.

Innanzitutto, importa il modulo genitore (modulo-a.modulo.ts) nel modulo ricevente (modulo-b.modulo.ts), creare il file importazioni array e aggiungi ModuloAModulo alla 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{}

Quindi, apri il tuo module-b.service.ts archiviare e importare il file Iniettare decoratore e ModuloAServerice da @nidi/comune E ../module-a/module-a.service, rispettivamente:

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

IL Iniettare decoratore contrassegna il proprio parametro come destinazione per l'inserimento delle dipendenze.

Successivamente, nel tuo ModuloBService class, aggiungi il blocco di codice seguente:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Il blocco di codice sopra fornisce al tuo ModuleBService l'accesso ai metodi disponibili nel tuo ModuleAService.

Puoi testare il servizio chiamando ModuleAService riceviCiao metodo.

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

Quindi, apri il tuo modulo-b.controller.ts file e sostituisci il codice generato con il blocco di codice seguente:

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

Il blocco di codice sopra imposta a OTTENERE gestore del percorso per il riceviCiao funzione.

Finalmente, effettuare una richiesta GET con curl a localhost: 3000/modulo-b/ciao. Il comando dovrebbe stampare "Ciao dal modulo A!" alla tua console.

Hai inserito con successo un servizio in un altro modulo. Questo può tornare utile quando lo sei creare API con Nest.js che hanno più moduli che devono chiamare i metodi l'uno dell'altro.

Vantaggi dell'iniezione tra moduli

Sebbene chiamare direttamente un servizio da un altro modulo possa sembrare più semplice all'inizio, a lungo termine può portare a un sistema più complesso, meno gestibile e meno scalabile.

Tuttavia, l'iniezione tra moduli promuove la modularità e la riusabilità del codice, facilitandone la manutenzione. Inoltre, centralizza le dipendenze, migliora la testabilità e supporta un'architettura scalabile e disaccoppiata.