Vložení služby Nest.js z jiného modulu

Vložení služby z jiného modulu Nest.js zahrnuje několik kroků k zajištění správného vkládání závislostí a organizace modulu. Pomocí dvou ukázkových modulů se dozvíte, jak funguje proces exportu a importu služeb.

Generování projektu Nest.js

Chcete-li vygenerovat projekt Nest.js, musíte mít na svém zařízení nainstalované rozhraní CLI. Pokud ne, spusťte tento příkaz a nainstalujte jej:

 npm install -g @nestjs/cli

S nainstalovaným rozhraním CLI Nest.js spusťte tento příkaz a vygenerujte nový projekt Nest.js:

 nest new <project-name>

„“ můžete nahradit libovolným názvem. Spuštěním výše uvedeného příkazu se vygeneruje nový projekt Nest.js se zadaným názvem.

Struktura vašeho aktuálního projektu by měla vypadat jako na obrázku níže:

Chcete-li si vyzkoušet vkládání služby z jednoho modulu do jiného modulu, vygenerujete dva moduly, modul-a a modul-b. Vygenerujete také jejich odpovídající servisní a řídicí soubory.

Spuštěním tohoto příkazu vygenerujete modul-a:

 nest generate module module-a

A spusťte ekvivalentní příkaz pro modul-b:

 nest generate module module-b

Poté spusťte tento příkaz a vygenerujte soubory služby a řadiče pro modul-a:

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

A spusťte ekvivalentní příkaz pro modul-b:

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

Váš aktuální adresář projektu by měl vypadat takto, s adresáři src/module-a a src/module-b:

Export služby z modulu A

Chcete-li exportovat službu module-a z modulu module-a, musíte ji uvést jako export v souboru modulu modulu-a (module-a.module.ts). Ve výchozím nastavení Nest.js CLI neposkytuje pole exportů v dekorátoru @Module, takže vygenerovaný soubor modulu bude vypadat takto:

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

Chcete-li službu-a (module-a.service.ts) zpřístupnit modulům, které importují modul-a, vytvořte pole exportů v dekorátoru @Module a přidejte do něj ModuleAService.

Jako tak:

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

Dále pro účely testování přidejte do svého modulu – soubor služeb (module-a.service.ts) jednoduchou funkci:

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

Tato funkce vrací ukázkový řetězec. Chcete-li potvrdit, že můžete správně importovat tuto službu, zavoláte tuto funkci z modulu-b po vložení služby-a.

Import služby do modulu B

Chcete-li importovat jeden modul do druhého, musíte jej uvést jako import v poli imports přijímajícího modulu. V tomto případě musíte přidat modul-a do pole importů dekorátoru @Module modulu-b.

Stejně jako dříve Nest.js CLI automaticky negeneruje pole importů, takže jej musíte přidat ručně.

Nejprve importujte nadřazený modul (module-a.module.ts) do přijímacího modulu (module-b.module.ts), vytvořte pole imports a přidejte ModuleAModule do pole:

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

Dále otevřete svůj soubor module-b.service.ts a importujte dekorátor Inject a ModuleAServerice z @nests/common a ../module-a/module-a.service, v tomto pořadí:

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

Dekorátor Inject označí svůj parametr jako cíl pro vložení závislosti.

Dále do své třídy ModuleBService přidejte níže uvedený blok kódu:

 @Inject(ModuleAService)
  private readonly moduleAService: ModuleAService;

Blok kódu výše poskytuje vašemu ModuleBService přístup k metodám dostupným ve vašem ModuleAService.

Službu můžete otestovat voláním metody getHello modulu ModuleAService.

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

Dále otevřete svůj soubor module-b.controller.ts a nahraďte vygenerovaný kód blokem kódu níže:

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

Výše uvedený blok kódu nastavuje obslužnou rutinu trasy GET pro funkci getHello.

Nakonec proveďte požadavek GET s curl na localhost:3000/module-b/hello. Příkaz by měl vypsat „Ahoj z modulu A!“ do vaší konzole.

Úspěšně jste vložili službu do jiného modulu. To se může hodit, když vytváříte rozhraní API s Nest.js, která mají více modulů, které si musí navzájem volat své metody.

Výhody vstřikování napříč moduly

I když se přímé volání služby z jiného modulu může na první pohled zdát jednodušší, z dlouhodobého hlediska může vést ke složitějšímu, méně udržovatelnému a méně škálovatelnému systému.

Vkládání mezi moduly však podporuje modularitu kódu a opětovnou použitelnost, což usnadňuje jeho údržbu. Kromě toho centralizuje závislosti, zlepšuje testovatelnost a podporuje škálovatelnou, oddělenou architekturu.