Injicera en Nest.js-tjänst från en annan modul

Att injicera en tjänst från en annan Nest.js-modul innebär några steg för att säkerställa korrekt beroendeinjicering och modulorganisation. Använd två exempelmoduler för att lära dig hur processen med att exportera och importera tjänster fungerar.

Skapa ett Nest.js-projekt

För att skapa en Nest.js-applikation måste du se till att kommandoradsgränssnittet (CLI) är installerat på ditt system. Om så inte är fallet kör du följande kommando för att konfigurera CLI:

 npm install -g @nestjs/cli

För att skapa ett nytt Nest.js-projekt med hjälp av Nest.js Command Line Interface (CLI) utför du följande steg:1. Installera Nest.js CLI genom att köra kommandot “npm install -g @nestjs/cli” eller “@yarn global add nestjs-cli”. Detta gör att du kan hantera och interagera med dina Nest.js-projekt från kommandoraden.2. Kör kommandot “nest new " för att skapa ett nytt Nest.js-projekt i den angivna katalogen. Standardkonfigurationen för det nyskapade projektet är redan konfigurerad och redo för utveckling.

 nest new <project-name>

När det angivna kommandot utförs kan man ersätta ’ ’ med en benämning som man själv väljer för att skapa en ny Nest.js-utvecklingsmiljö med den angivna titeln.

Den aktuella konfigurationen av ditt projekt bör överensstämma med den bild som illustreras i den grafiska representationen nedan:

För att förbättra dina färdigheter i att integrera tjänster mellan olika moduler är det nödvändigt att skapa två separata moduler, nämligen modul-a och modul-b, tillsammans med tillhörande service- och controllerfiler för var och en av dem.

Kör detta kommando för att generera modul-a:

 nest generate module module-a

Och kör motsvarande kommando för modul-b:

 nest generate module module-b

För att skapa de nödvändiga filerna för modul-a kör du följande kommando:

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

Och kör motsvarande kommando för modul-b:

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

Strukturen i din aktuella projektkatalog bör likna ett hierarkiskt arrangemang, med två primära underkataloger - “src/modul-a” och “src/modul-b”.

Exportera en tjänst från modul A

För att extrahera Service-A-komponenten från modul-A och göra den tillgänglig för användning på andra ställen i programmet, måste man inkludera den bland de objekt som anges under “exports” i modul-A:s modulfil (dvs. Module-A.module.ts).När man använder Nest.js Command Line Interface (CLI) finns det vanligtvis ingen fördefinierad “exports”-array som tillhandahålls med “@Module”-dekoratorn; därför skulle den resulterande modulfilen uppvisa en struktur som liknar följande:

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

För att göra module-a.service.ts tillgänglig för andra moduler som importerar module-a , bör enexports array skapas inom @Module dekoratorn och ModuleAService bör läggas till den.

På detta sätt:

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

För att utföra tester på tjänsten module-a kan du skapa en ny fil som heter module-a.service.ts i samma katalog som de andra filerna i det här projektet. Denna fil kommer att innehålla en enkel funktion som använder klassen ModuleAService och demonstrerar dess funktionalitet.

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

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

Den givna texten verkar vara skriven på ett vardagligt språk och saknar förfining. Här är ett försök att omformulera den med mer elegans:För att säkerställa att denna tjänst fungerar korrekt rekommenderar vi att du anropar den ovan nämnda funktionen i den angivna modulen (modul-b) efter injektionen av tjänst-a. Genom att göra detta kan man verifiera att integrationen av tjänsten har lyckats.

Importera en tjänst till modul B

För att en modul ska kunna importeras till en annan, måste den finnas med bland importerna i den mottagande modulens @Module dekorator. I det fall modul-a importeras av modul-b måste den därför läggas till i matrisen imports i modul-b:s dekorator @Module .

För att kunna använda de importerade modulerna i ett Nest.js-projekt måste man manuellt skapa en imports array i applikationsmodulfilen. Nest.js Command Line Interface (CLI) tillhandahåller inte denna funktionalitet som standard, vilket kräver manuell inblandning för att inkludera den.

Processen innebär att den överordnade modulen importeras från filen “module-a.module.ts” till den mottagande modulen som finns i “module-b.module.ts”. Därefter skapas ett import statement i den mottagande modulens kod och läggs till i en specifik array, varefter den önskade modulen, nämligen “ModuleAModule”, läggs till i samma 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 {}

Låt oss gå vidare till nästa steg genom att öppna filen module-b.service.ts i vårt projekt.Vi kommer att behöva importera både dekoratorn @Inject och klassen ModuleAService från två olika källor i programmets kodbas. Vi måste hämta dessa objekt från paketet @nestjs/common för det första och från en separat plats någon annanstans i vår projektstruktur för det andra.

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

Inject-dekoratorn betecknar sin parameter som en avsedd mottagare av beroendeinjektion, vilket innebär att den är en avgörande komponent i systemets funktionalitet och bör förses med nödvändiga resurser eller tjänster för att fungera effektivt.

I samband med klassen ModuleBService är det faktiskt nödvändigt att införliva det ovannämnda kodavsnittet vid en lämplig tidpunkt.

 @Inject(ModuleAService)
  private readonly moduleAService: ModuleAService;

Att ge tillgång till metoderna i ModuleAService underlättas genom det medföljande kodblocket, vilket möjliggör användning inom ModuleBService.

Man kan validera funktionaliteten hos tjänsten, ModuleAService’s “getHello” metod, genom testning.

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

Låt oss nu gå vidare och ändra innehållet i filen module-b.controller.ts genom att ersätta den befintliga koden med det medföljande kodavsnittet.

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

Det medföljande kodavsnittet etablerar en HTTP GET-förfrågningsmekanism för funktionen “getHello”, som är ansvarig för att hämta och bearbeta data relaterade till användarspecifika förfrågningar eller inmatningar.

Slutligen, kör en GET-begäran med cURL till http://localhost:3000/module-b/hello . Kommandot kommer att visa “Hej från modul A!” i konsolen.

Att lyckas injicera en tjänst i en annan modul är särskilt fördelaktigt vid utveckling av API:er inom Nest.js, som ofta involverar flera ömsesidigt beroende moduler som kräver tillgång till varandras funktioner.

Fördelar med Cross-Module Injection

Att integrera en tjänst med hjälp av direkt anrop kan verka som ett lämpligt alternativ initialt, men det resulterar ofta i en mer invecklad, svår att underhålla och begränsad arkitektur över tiden.

Implementeringen av cross-module injection främjar ett mer sammanhängande och anpassningsbart system genom att förbättra modulariteten och underlätta återanvändning av komponenter. Dessutom konsoliderar detta tillvägagångssätt beroenden, förbättrar genomförbarheten av testning och möjliggör en arkitektoniskt sund, löst kopplad design som är kapabel att hantera tillväxt.