Инжектиране на услуга Nest.js от различен модул

Инжектирането на услуга от различен модул Nest.js включва няколко стъпки, за да се осигури правилно инжектиране на зависимости и организация на модула. Използвайки два примерни модула, научете как работи процесът на експортиране и импортиране на услуги.

Генериране на проект Nest.js

За да генерирате проект Nest.js, трябва да имате инсталиран CLI на вашето устройство. Ако не го направите, изпълнете тази команда, за да го инсталирате:

 npm install -g @nestjs/cli

С инсталиран Nest.js CLI, изпълнете тази команда, за да генерирате нов Nest.js проект:

 nest new <project-name>

Можете да замените „<име-на-проект>“ с всяко име, което изберете. Изпълнението на командата по-горе ще генерира нов проект Nest.js с посоченото име.

Вашата текуща структура на проекта трябва да изглежда като изображението по-долу:

За да практикувате инжектиране на услуга от един модул в друг модул, ще генерирате два модула, module-a и module-b. Освен това ще генерирате съответните им файлове за услуга и контролер.

Изпълнете тази команда, за да генерирате modul-a:

 nest generate module module-a

И изпълнете еквивалентната команда за module-b:

 nest generate module module-b

След това изпълнете тази команда, за да генерирате файловете на услугата и контролера за module-a:

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

И изпълнете еквивалентната команда за module-b:

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

Вашата текуща директория на проекта трябва да изглежда така, с директории src/module-a и src/module-b:

Експортиране на услуга от модул A

За да експортирате услугата module-a от модула module-a, трябва да я посочите като експорт в модулния файл на module-a (module-a.module.ts). По подразбиране Nest.js CLI не предоставя масив за експортиране в декоратора @Module, така че генерираният модулен файл ще изглежда така:

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

За да направите service-a (module-a.service.ts) достъпен за модули, които импортират module-a, създайте масив за експортиране в декоратора @Module и добавете ModuleAService към него.

Така:

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

След това, за целите на тестването, добавете проста функция към вашия модул-а сервизен файл (module-a.service.ts):

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

Тази функция връща примерен низ. За да потвърдите, че можете да импортирате тази услуга правилно, ще извикате тази функция от module-b след инжектиране на service-a.

Импортиране на услуга в модул B

За да импортирате един модул в друг, трябва да го посочите като импортиран в масива за импортиране на получаващия модул. В този случай трябва да добавите module-a към масива за импортиране на декоратора @Module на module-b.

Както и преди, Nest.js CLI не генерира автоматично масив за импортиране, така че трябва да го добавите ръчно.

Първо импортирайте родителския модул (module-a.module.ts) в получаващия модул (module-b.module.ts), създайте масива за импортиране и добавете ModuleAModule към масива:

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

След това отворете вашия файл module-b.service.ts и импортирайте декоратора на Inject и ModuleAServerice съответно от @nests/common и ../module-a/module-a.service:

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

Декораторът Inject маркира своя параметър като цел за инжектиране на зависимост.

След това във вашия клас ModuleBService добавете кодовия блок по-долу:

 @Inject(ModuleAService)
  private readonly moduleAService: ModuleAService;

Кодовият блок по-горе дава на вашия ModuleBService достъп до методите, налични във вашия ModuleAService.

Можете да тествате услугата, като извикате метода getHello на 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();
  }
}
 

След това отворете вашия файл 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();
  }
}
 

Кодовият блок по-горе настройва манипулатор на GET маршрут за функцията getHello.

И накрая, направете GET заявка с curl до localhost:3000/module-b/hello. Командата трябва да отпечата „Здравейте от модул A!“ към вашата конзола.

Успешно сте инжектирали услуга в друг модул. Това може да бъде полезно, когато изграждате API с Nest.js, които имат множество модули, които трябва да извикват методи на другия.

Предимства на кръстосано модулно инжектиране

Докато директното извикване на услуга от друг модул може да изглежда по-просто в началото, това може да доведе до по-сложна, по-малко поддържаема и по-малко мащабируема система в дългосрочен план.

Въпреки това, инжектирането на кръстосани модули насърчава модулността на кода и повторната употреба, което го прави по-лесен за поддръжка. Освен това централизира зависимостите, подобрява възможността за тестване и поддържа мащабируема, отделена архитектура.