Injisere en Nest.js-tjeneste fra en annen modul

Å injisere en tjeneste fra en annen Nest.js-modul innebærer noen få trinn for å sikre riktig avhengighetsinjeksjon og modulorganisering. Ved å bruke to eksempelmoduler kan du lære hvordan prosessen med å eksportere og importere tjenester fungerer.

Genererer et Nest.js-prosjekt

For å generere et Nest.js-prosjekt må du ha CLI installert på enheten din. Hvis du ikke gjør det, kjør denne kommandoen for å installere den:

 npm install -g @nestjs/cli

Med Nest.js CLI installert, kjør denne kommandoen for å generere et nytt Nest.js-prosjekt:

 nest new <project-name>

Du kan erstatte «» med et hvilket som helst navn du velger. Å kjøre kommandoen ovenfor vil generere et nytt Nest.js-prosjekt med det angitte navnet.

Din nåværende prosjektstruktur skal se ut som bildet nedenfor:

For å øve på å injisere en tjeneste fra en modul til en annen modul, genererer du to moduler, modul-a og modul-b. Du vil også generere deres tilsvarende tjeneste- og kontrollerfiler.

Kjør denne kommandoen for å generere modul-a:

 nest generate module module-a

Og kjør den tilsvarende kommandoen for modul-b:

 nest generate module module-b

Kjør deretter denne kommandoen for å generere tjeneste- og kontrollerfilene for modul-a:

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

Og kjør den tilsvarende kommandoen for modul-b:

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

Din nåværende prosjektkatalog skal se slik ut, med src/module-a og src/module-b kataloger:

Eksportere en tjeneste fra modul A

For å eksportere modul-a-tjenesten fra modul-a-modulen, må du liste den som en eksport i modul-as modulfil (module-a.module.ts). Som standard gir ikke Nest.js CLI en eksportmatrise i @Module-dekoratoren, så den genererte modulfilen vil se slik ut:

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

For å gjøre service-a (module-a.service.ts) tilgjengelig for moduler som importerer modul-a, oppretter du en eksportarray i @Module-dekoratoren og legger til ModuleAService til den.

Som så:

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

Deretter, for testformål, legg til en enkel funksjon til din modul-a-tjenestefil (module-a.service.ts):

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

Denne funksjonen returnerer en prøvestreng. For å bekrefte at du kan importere denne tjenesten riktig, kaller du opp funksjonen fra modul-b etter å ha injisert tjeneste-a.

Importere en tjeneste til modul B

For å importere en modul til en annen, må du oppgi den som en import i importarrayen til mottaksmodulen. I dette tilfellet må du legge til modul-a til importarrayen til modul-b’s @Module-dekorator.

Som før genererer ikke Nest.js CLI automatisk en importmatrise, så du må legge den til manuelt.

Først importerer du den overordnede modulen (module-a.module.ts) til mottaksmodulen (module-b.module.ts), oppretter importmatrisen og legger til ModuleAModule til matrisen:

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

Deretter åpner du module-b.service.ts-filen og importerer Inject decorator og ModuleAServerice fra henholdsvis @nests/common og ../module-a/module-a.service:

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

Inject-dekoratoren markerer parameteren som et mål for avhengighetsinjeksjon.

Deretter legger du til kodeblokken nedenfor i ModuleBService-klassen din:

 @Inject(ModuleAService)
  private readonly moduleAService: ModuleAService;

Kodeblokken ovenfor gir din ModuleBService tilgang til metodene som er tilgjengelige i din ModuleAService.

Du kan teste tjenesten ved å ringe ModuleAServices getHello-metode.

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

Deretter åpner du module-b.controller.ts-filen og erstatter den genererte koden med kodeblokken nedenfor:

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

Kodeblokken ovenfor setter opp en GET-rutebehandler for getHello-funksjonen.

Til slutt, foreta en GET-forespørsel med curl til localhost:3000/module-b/hello. Kommandoen skal skrive ut «Hei fra modul A!» til konsollen din.

Du har injisert en tjeneste i en annen modul. Dette kan være nyttig når du bygger APIer med Nest.js som har flere moduler som må kalle hverandres metoder.

Fordeler med kryssmodulinjeksjon

Selv om det kan virke enklere i begynnelsen å ringe en tjeneste direkte fra en annen modul, kan det føre til et mer komplekst, mindre vedlikeholdbart og mindre skalerbart system i det lange løp.

Imidlertid fremmer kryssmodulinjeksjon kodemodularitet og gjenbrukbarhet, noe som gjør det enklere å vedlikeholde. I tillegg sentraliserer den avhengigheter, forbedrer testbarheten og støtter en skalerbar, frakoblet arkitektur.