Wstrzykiwanie usługi Nest.js z innego modułu

Wstrzykiwanie usługi z innego modułu Nest.js obejmuje kilka kroków w celu zapewnienia prawidłowego wstrzykiwania zależności i organizacji modułów. Korzystając z dwóch przykładowych modułów, dowiesz się, jak działa proces eksportowania i importowania usług.

Generowanie projektu Nest.js

Aby utworzyć aplikację Nest.js, upewnij się, że interfejs wiersza poleceń (CLI) jest zainstalowany w systemie. Jeśli tak nie jest, wykonaj następujące polecenie, aby skonfigurować CLI:

 npm install -g @nestjs/cli

Aby utworzyć nowy projekt Nest.js przy użyciu interfejsu wiersza poleceń Nest.js (CLI), wykonaj następujące kroki:1. Zainstaluj Nest.js CLI, uruchamiając polecenie “npm install -g @nestjs/cli” lub “@yarn global add nestjs-cli”. Umożliwi to zarządzanie projektami Nest.js i interakcję z nimi z poziomu wiersza poleceń.2. Uruchom polecenie “nest new “, aby wygenerować nowy projekt Nest.js w określonym katalogu. Domyślna konfiguracja dla nowo utworzonego projektu jest już skonfigurowana i gotowa do rozwoju.

 nest new <project-name>

Po wykonaniu podanego polecenia można zastąpić " " własną nazwą, aby utworzyć nowe środowisko programistyczne Nest.js noszące wskazany tytuł.

Obecna konfiguracja projektu powinna być zgodna z obrazem przedstawionym na poniższej grafice:

Aby doskonalić swoje umiejętności w zakresie integracji usług w różnych modułach, konieczne jest utworzenie dwóch oddzielnych modułów, a mianowicie modułu-a i modułu-b, wraz z towarzyszącymi im plikami usług i kontrolerów dla każdego z nich.

Uruchom to polecenie, aby wygenerować moduł-a:

 nest generate module module-a

I uruchom równoważne polecenie dla modułu-b:

 nest generate module module-b

Aby utworzyć niezbędne pliki dla modułu-a, wykonaj następujące polecenie:

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

I uruchom równoważne polecenie dla modułu-b:

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

Struktura bieżącego katalogu projektu powinna przypominać układ hierarchiczny, składający się z dwóch głównych podkatalogów - “src/moduł-a” i “src/moduł-b”.

Eksportowanie usługi z modułu A

Aby wyodrębnić komponent Service-A z modułu A i udostępnić go do użytku w innym miejscu aplikacji, należy umieścić go wśród elementów wymienionych w sekcji “eksport” w pliku modułu A (tj. Module-A.module.ts).Zazwyczaj podczas korzystania z interfejsu wiersza poleceń Nest.js (CLI) nie ma predefiniowanej tablicy “eksportów” dostarczanej z dekoratorem “@Module”; dlatego wynikowy plik modułu miałby strukturę podobną do poniższej:

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

Aby umożliwić dostęp do module-a.service.ts przez inne moduły, które importują module-a , należy utworzyć tablicęexports w dekoratorze @Module i dodać do niej ModuleAService .

W ten sposób:

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

Aby przeprowadzić testy usługi module-a , można utworzyć nowy plik o nazwie module-a.service.ts w tym samym katalogu, co inne pliki w tym projekcie. Plik ten będzie zawierał prostą funkcję, która wykorzystuje klasę ModuleAService i demonstruje jej funkcjonalność.

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

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

Podany tekst wydaje się być napisany językiem potocznym i brakuje mu dopracowania. Oto próba przeformułowania go z większą elegancją: Aby zapewnić prawidłowe działanie tej usługi, zalecamy wywołanie wspomnianej funkcji w określonym module (module-b) po wstrzyknięciu usługi-a. W ten sposób można zweryfikować pomyślną integrację wspomnianej usługi.

Importowanie usługi do modułu B

Aby jeden moduł mógł zostać zaimportowany do innego, musi być wymieniony wśród importów dekoratora @Module modułu odbierającego. Dlatego w przypadku, gdy moduł-a jest importowany przez moduł-b, musi on zostać dodany do tablicy imports w dekoratorze @Module modułu-b.

Aby wykorzystać zaimportowane moduły w projekcie Nest.js, należy ręcznie utworzyć tablicę imports w pliku modułu aplikacji. Interfejs wiersza poleceń (CLI) Nest.js nie zapewnia domyślnie tej funkcjonalności, co wymaga ręcznej interwencji w celu jej włączenia.

W rzeczywistości proces ten polega na zaimportowaniu modułu nadrzędnego z pliku “module-a.module.ts” do modułu odbiorczego znajdującego się w “module-b.module.ts”. Następnie instrukcja importu jest tworzona w kodzie modułu odbierającego i dodawana do określonej tablicy, po czym żądany moduł, a mianowicie “ModuleAModule”, jest dołączany do tej samej tablicy.

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

Rzeczywiście, przejdźmy do następnego kroku, otwierając plik module-b.service.ts w naszym projekcie.Będziemy musieli zaimportować zarówno dekorator @Inject , jak i klasę ModuleAService z dwóch różnych źródeł w bazie kodu naszej aplikacji. W szczególności musimy uzyskać te elementy z pakietu @nestjs/common dla pierwszego i oddzielnej lokalizacji w innym miejscu w strukturze naszego projektu dla drugiego.

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

Dekorator Inject wyznacza swój parametr jako zamierzonego odbiorcę wstrzykiwania zależności, co oznacza, że jest on kluczowym komponentem funkcjonalności systemu i powinien mieć zapewnione niezbędne zasoby lub usługi do efektywnego działania.

Rzeczywiście, w kontekście klasy ModuleBService konieczne jest włączenie wspomnianego fragmentu kodu w odpowiednim momencie.

 @Inject(ModuleAService)
  private readonly moduleAService: ModuleAService;

Udzielanie dostępu do metod ModuleAService jest ułatwione dzięki dostarczonemu blokowi kodu, umożliwiając w ten sposób wykorzystanie w ModuleBService.

Można zweryfikować funkcjonalność usługi, metody “getHello” usługi ModuleAService, poprzez testowanie.

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

Rzeczywiście, przejdźmy teraz do modyfikacji zawartości pliku module-b.controller.ts, zastępując istniejący kod dostarczonym fragmentem kodu.

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

Podany fragment kodu ustanawia mechanizm obsługi żądań HTTP GET dla funkcji “getHello”, która jest odpowiedzialna za pobieranie i przetwarzanie danych związanych z żądaniami lub danymi wejściowymi specyficznymi dla użytkownika.

Ostatecznie wykonaj żądanie GET przy użyciu cURL do http://localhost:3000/module-b/hello . Polecenie wyświetli “Hello from Module A!” w konsoli.

Pomyślne wstrzyknięcie usługi do innego modułu jest szczególnie korzystne podczas tworzenia interfejsów API w Nest.js, które często obejmują wiele współzależnych modułów wymagających dostępu do swoich funkcji.

Korzyści z wstrzykiwania między modułami

Włączenie usługi za pomocą bezpośredniego wywołania może początkowo wydawać się korzystną opcją; jednak często skutkuje to bardziej skomplikowaną, trudną w utrzymaniu i ograniczoną w czasie architekturą.

Rzeczywiście, implementacja wstrzykiwania międzymodułowego sprzyja bardziej spójnemu i elastycznemu systemowi poprzez zwiększenie modułowości i ułatwienie ponownego użycia komponentów. Co więcej, takie podejście konsoliduje zależności, zwiększa wykonalność testowania i umożliwia stworzenie solidnego architektonicznie, luźno powiązanego projektu, który jest w stanie dostosować się do wzrostu.