Een Nest.js-service injecteren vanuit een andere module

Voor het injecteren van een service uit een andere Nest.js-module zijn een paar stappen nodig om een ​​goede afhankelijkheidsinjectie en module-organisatie te garanderen. Leer aan de hand van twee voorbeeldmodules hoe het proces van het exporteren en importeren van services werkt.

Een Nest.js-project genereren

Als u een Nest.js-project wilt genereren, moet de CLI op uw apparaat zijn geïnstalleerd. Als u dit niet doet, voert u deze opdracht uit om het te installeren:

npm install -g @nestjs/cli

Terwijl de Nest.js CLI is geïnstalleerd, voert u deze opdracht uit om een ​​nieuw Nest.js-project te genereren:

nest new

U kunt vervangen “' met elke naam die u kiest. Als u de bovenstaande opdracht uitvoert, wordt er een nieuw Nest.js-project met de opgegeven naam gegenereerd.

Uw huidige projectstructuur zou er als volgt uit moeten zien:

Om te oefenen met het injecteren van een service van de ene module naar een andere module, genereert u twee modules, module-a en module-b. Je genereert ook de bijbehorende service- en controllerbestanden.

Voer deze opdracht uit om module-a te genereren:

nest generate modulemodule-a

En voer het equivalente commando uit voor module-b:

nest generate modulemodule-b

Voer vervolgens deze opdracht uit om de service- en controllerbestanden voor module-a te genereren:

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

En voer het equivalente commando uit voor module-b:

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

Uw huidige projectmap zou er zo uit moeten zien, met src/module-a En src/module-b mappen:

Een service exporteren uit module A

Om de module-a-service uit de module-a-module te exporteren, moet u deze als export vermelden in het modulebestand van module-a (module-a.module.ts). Standaard biedt de CLI van Nest.js geen export array in de @Module decorateur, dus het gegenereerde modulebestand ziet er als volgt uit:

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

Om service-a te maken (module-a.service.ts) toegankelijk voor modules die module-a importeren, maak een export array in de @Module decorateur en toevoegen ModuleAService ernaar.

Zo:

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

Voeg vervolgens voor testdoeleinden een eenvoudige functie toe aan uw module: een servicebestand (module-a.service.ts):

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

Deze functie retourneert een voorbeeldtekenreeks. Om te bevestigen dat u deze service correct kunt importeren, roept u die functie aan vanuit module-b nadat u service-a heeft geïnjecteerd.

Een service importeren in module B

Om de ene module in de andere te importeren, moet u deze als import in de importeert array van de ontvangende module. In dit geval moet u module-a toevoegen aan het importeert reeks module-b's @Module decorateur.

Net als voorheen genereert de Nest.js CLI niet automatisch een importeert array, dus u moet deze handmatig toevoegen.

Importeer eerst de bovenliggende module (module-a.module.ts) in de ontvangstmodule (module-b.module.ts), maak de importeert array en voeg toe ModuleAModule naar de array:

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

Open vervolgens uw module-b.service.ts bestand en importeer het Injecteren decorateur en ModuleAServerice van @nesten/gemeenschappelijk En ../module-a/module-a.servicerespectievelijk:

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

De Injecteren decorateur markeert zijn parameter als doelwit voor afhankelijkheidsinjectie.

Vervolgens in uw ModuleBService klasse, voeg het onderstaande codeblok toe:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Het bovenstaande codeblok geeft uw ModuleBService toegang tot de methoden die beschikbaar zijn in uw ModuleAService.

U kunt de service testen door de ModuleAService's te bellen ontvangHallo methode.

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

Open vervolgens uw module-b.controller.ts bestand en vervang de gegenereerde code door het onderstaande codeblok:

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

Het bovenstaande codeblok stelt a KRIJGEN routebegeleider voor de ontvangHallo functie.

Eindelijk, maak een GET-verzoek met curl naar localhost: 3000/module-b/hello. De opdracht zou “Hallo van Module A!” moeten afdrukken. naar uw console.

U hebt met succes een dienst in een andere module geïnjecteerd. Dit kan van pas komen als je dat bent API's bouwen met Nest.js die meerdere modules hebben die elkaars methoden moeten aanroepen.

Voordelen van cross-module injectie

Hoewel het direct aanroepen van een service vanuit een andere module in eerste instantie misschien eenvoudiger lijkt, kan dit op de lange termijn leiden tot een complexer, minder onderhoudbaar en minder schaalbaar systeem.

Cross-module-injectie bevordert echter de modulariteit en herbruikbaarheid van de code, waardoor het onderhoud eenvoudiger wordt. Bovendien centraliseert het de afhankelijkheden, verbetert het de testbaarheid en ondersteunt het een schaalbare, ontkoppelde architectuur.