Een Nest.js-service injecteren vanuit een andere module

Het injecteren van een service vanuit een andere Nest.js-module vereist een aantal stappen om de juiste afhankelijkheidsinjectie en moduleorganisatie te garanderen. Leer aan de hand van twee voorbeeldmodules hoe het exporteren en importeren van services werkt.

Een Nest.js-project genereren

Om een Nest.js-toepassing te maken, moet u ervoor zorgen dat de Command Line Interface (CLI) op uw systeem is geïnstalleerd. Als dat niet het geval is, voer dan het volgende commando uit om de CLI in te stellen:

 npm install -g @nestjs/cli

Om een nieuw Nest.js project te maken met de Nest.js Command Line Interface (CLI), voer je de volgende stappen uit:1. Installeer de Nest.js CLI door het commando “npm install -g @nestjs/cli” of “@yarn global add nestjs-cli” uit te voeren. Dit stelt je in staat om je Nest.js projecten vanaf de commandoregel te beheren en ermee te werken.2. Voer de opdracht “nest new " uit om een nieuw Nest.js project in de opgegeven map te genereren. De standaardconfiguratie voor het nieuw aangemaakte project is al ingesteld en klaar voor ontwikkeling.

 nest new <project-name>

Na uitvoering van het gegeven commando kan ’ ’ worden vervangen door een zelfgekozen naam om een nieuwe Nest.js-ontwikkelomgeving met de aangegeven titel te maken.

De huidige configuratie van je project moet overeenkomen met de afbeelding in de onderstaande grafische weergave:

Om je vaardigheden in het integreren van services in verschillende modules aan te scherpen, is het nodig om twee afzonderlijke modules te maken, namelijk module-a en module-b, samen met de bijbehorende service- en controllerbestanden voor elk.

Voer deze opdracht uit om module-a te genereren:

 nest generate module module-a

En voer de equivalente opdracht uit voor module-b:

 nest generate module module-b

Om de benodigde bestanden voor module-a te maken, voert u de volgende opdracht uit:

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

En voer het gelijkwaardige commando uit voor module-b:

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

De structuur van je huidige projectdirectory zou moeten lijken op een hiërarchische ordening, bestaande uit twee primaire submappen, namelijk “src/module-a” en “src/module-b”.

Een service exporteren uit module A

Om de component Service-A uit module-A te halen en deze toegankelijk te maken voor gebruik elders in de toepassing, moet deze worden opgenomen onder de items die worden vermeld onder “exports” in het modulebestand van module-A (d.w.z. Module-A.module.ts).Wanneer de Nest.js Command Line Interface (CLI) wordt gebruikt, is er meestal geen voorgedefinieerde “exports” array voorzien van de “@Module” decorator; daarom zou het resulterende modulebestand een structuur hebben die lijkt op de volgende:

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

Om module-a.service.ts toegankelijk te maken voor andere modules die module-a importeren, moet een export-array worden gemaakt binnen de decorator @Module en moet ModuleAService eraan worden toegevoegd.

Op deze manier:

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

Om tests uit te voeren op de module-a service, kun je een nieuw bestand maken met de naam module-a.service.ts in dezelfde map als de andere bestanden in dit project. Dit bestand bevat een eenvoudige functie die de klasse ModuleAService gebruikt en de functionaliteit demonstreert.

 import { Injectable } from '@nestjs/common';

@Injectable()
export class ModuleAService {
  getHello(): string {
    return 'Hello from Module A!';
  }
}

De gegeven tekst lijkt in spreektaal te zijn geschreven en mist verfijning. Hier is een poging om het met meer elegantie te herformuleren:Om de juiste functionaliteit van deze service te garanderen, raden we aan om de bovengenoemde functie aan te roepen binnen de gespecificeerde module (module-b) nadat service-a is geïnjecteerd. Op deze manier kan de succesvolle integratie van deze service worden geverifieerd.

Een service importeren in module B

Om een module in een andere module te kunnen importeren, moet deze deel uitmaken van de import van de decorator @Module van de ontvangende module. Daarom moet module-a, in het geval dat deze wordt geïmporteerd door module-b, worden toegevoegd aan de reeks imports in de decorator @Module van module-b.

Om de geïmporteerde modules in een Nest.js project te gebruiken, moet er handmatig een imports array worden gemaakt in het bestand van de applicatiemodule. De Nest.js Command Line Interface (CLI) biedt deze functionaliteit standaard niet, waardoor handmatige interventie nodig is voor het opnemen ervan.

Het proces bestaat uit het importeren van de bovenliggende module uit het bestand “module-a.module.ts” in de ontvangende module die zich bevindt in “module-b.module.ts”. Vervolgens wordt er een importstatement gemaakt binnen de code van de ontvangende module en toegevoegd aan een specifieke array, waarna de gewenste module, namelijk “ModuleAModule”, wordt toegevoegd aan diezelfde 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],
})

export class ModuleBModule {}

Inderdaad, laten we doorgaan naar de volgende stap door het bestand module-b.service.ts in ons project te openen.We moeten zowel de @Inject decorator als de ModuleAService klasse importeren uit twee verschillende bronnen binnen de codebase van onze applicatie. Specifiek moeten we deze items verkrijgen uit het @nestjs/common pakket voor de eerste en een aparte locatie elders binnen onze projectstructuur voor de tweede.

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

De Inject decorator wijst zijn parameter aan als een beoogde ontvanger van afhankelijkheidsinjectie, wat betekent dat het een cruciaal onderdeel is in de functionaliteit van het systeem en moet worden voorzien van de nodige middelen of diensten om effectief te functioneren.

In de context van de klasse ModuleBService is het inderdaad noodzakelijk om het bovenstaande codefragment op een geschikt moment op te nemen.

 @Inject(ModuleAService)
  private readonly moduleAService: ModuleAService;

Het verlenen van toegang tot de methoden van ModuleAService wordt vergemakkelijkt door het meegeleverde codeblok, waardoor gebruik binnen ModuleBService mogelijk wordt.

De functionaliteit van de service, de methode “getHello” van ModuleAService, kan worden gevalideerd door deze te testen.

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

Inderdaad, laten we nu de inhoud van het bestand module-b.controller.ts wijzigen door de bestaande code te vervangen door het meegeleverde codefragment.

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

Het gegeven codefragment stelt een HTTP GET-verzoek afhandelingsmechanisme in voor de functie “getHello”, die verantwoordelijk is voor het ophalen en verwerken van gegevens met betrekking tot gebruikersspecifieke verzoeken of invoer.

Voer uiteindelijk een GET-verzoek uit met cURL naar http://localhost:3000/module-b/hello . De opdracht geeft “Hallo van module A!” weer in de console.

Het succesvol injecteren van een service in een andere module is vooral handig bij het ontwikkelen van API’s in Nest.js, waarbij vaak meerdere onderling afhankelijke modules toegang moeten hebben tot elkaars functionaliteiten.

Voordelen van module-overschrijdende injectie

Het opnemen van een service door middel van directe aanroeping lijkt in eerste instantie een handige optie, maar resulteert na verloop van tijd vaak in een ingewikkelder, moeilijker te onderhouden en beperktere architectuur.

De implementatie van module-overschrijdende injectie bevordert een meer samenhangend en aanpasbaar systeem door modulariteit te verbeteren en hergebruik van componenten te vergemakkelijken. Bovendien consolideert deze aanpak afhankelijkheden, vergroot het de haalbaarheid van testen en maakt het een architectonisch solide, losjes gekoppeld ontwerp mogelijk dat groei kan accommoderen.