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

Můžete nahradit „“ s libovolným jménem. 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 modulemodule-a

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

nest generate modulemodule-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 src/module-a a src/modul-b adresáře:

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 (modul-a.modul.ts). Ve výchozím nastavení Nest.js CLI neposkytuje exportů pole v @Modul dekorátor, takže vygenerovaný soubor modulu bude vypadat takto:

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

Aby služba-a (modul-a.service.ts) přístupné modulům, které importují modul-a, vytvoří soubor exportů pole v @Modul dekoratér a přidat ModuleAService k tomu.

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],
})
exportclassModuleAModule{}

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

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

Tato funkce vrací ukázkový řetězec. Chcete-li potvrdit, že můžete tuto službu importovat správně, zavoláte tuto funkci z modulu-b po zavedení 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 dovozy pole přijímacího modulu. V tomto případě musíte přidat modul-a do dovozy pole modulů b @Modul dekoratér.

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

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

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

Dále otevřete svůj modul-b.service.ts soubor a importujte Injekce dekoratér a ModulAServerice z @hnízda/společné a ../module-a/module-a.service, respektive:

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

The Injekce dekorátor označí svůj parametr jako cíl pro vložení závislosti.

Dále ve vašem ModuleBService třídy, 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 zavoláním na ModuleAService getHello metoda.

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

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

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

Výše uvedený blok kódu nastavuje a DOSTAT obsluhovač trasy pro getHello funkce.

Konečně, vytvořit 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ž jste vytváření API pomocí 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.