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

Wstrzykiwanie usługi z innego modułu Nest.js obejmuje kilka kroków zapewniających prawidłowe wstrzykiwanie zależności i organizację modułu. Korzystając z dwóch przykładowych modułów, dowiedz się, jak wygląda proces eksportu i importu usług.

Generowanie projektu Nest.js

Aby wygenerować projekt Nest.js, musisz mieć zainstalowane CLI na swoim urządzeniu. Jeśli nie, uruchom to polecenie, aby go zainstalować:

npm install -g @nestjs/cli

Po zainstalowaniu interfejsu CLI Nest.js uruchom to polecenie, aby wygenerować nowy projekt Nest.js:

nest new

Możesz zastąpić „” z dowolną wybraną nazwą. Uruchomienie powyższego polecenia spowoduje wygenerowanie nowego projektu Nest.js o określonej nazwie.

Twoja obecna struktura projektu powinna wyglądać jak na obrazku poniżej:

Aby przećwiczyć wstrzykiwanie usługi z jednego modułu do innego modułu, wygenerujesz dwa moduły, moduł-a i moduł-b. Wygenerujesz także odpowiadające im pliki usług i kontrolerów.

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

nest generate modulemodule-a

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

nest generate modulemodule-b

Następnie uruchom tę komendę, aby wygenerować pliki usługi i kontrolera dla modułu-a:

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

Twój bieżący katalog projektu powinien wyglądać tak, z src/moduł-a I src/moduł-b katalogi:

Eksportowanie usługi z modułu A

Aby wyeksportować usługę moduł-a z modułu-moduł, musisz wyszczególnić ją jako eksport w pliku modułu modułu-a (moduł-a.moduł.ts). Domyślnie interfejs CLI Nest.js nie udostępnia pliku eksport tablica w @Moduł dekorator, więc wygenerowany plik modułu będzie wyglądał następująco:

// 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 wykonać usługę-a (moduł-a.service.ts) dostępne dla modułów importujących moduł-a, tworzących plik eksport tablica w @Moduł dekorator i dodaj ModułASerwis do tego.

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

Następnie dla celów testowych dodaj do swojego modułu prostą funkcję - plik usługi (moduł-a.service.ts):

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

Ta funkcja zwraca przykładowy ciąg. Aby potwierdzić, że możesz poprawnie zaimportować tę usługę, wywołasz tę funkcję z modułu-b po wstrzyknięciu usługi-a.

Importowanie usługi do modułu B

Aby zaimportować jeden moduł do drugiego, musisz wyszczególnić go jako import w pliku import tablica modułu odbiorczego. W takim przypadku musisz dodać moduł-a do pliku import tablica modułów-b @Moduł dekorator.

Tak jak poprzednio, interfejs CLI Nest.js nie generuje automatycznie pliku import array, więc musisz ją dodać ręcznie.

Najpierw zaimportuj moduł nadrzędny (moduł-a.moduł.ts) do modułu odbiorczego (moduł-b.moduł.ts), utwórz import tablicę i dodaj ModułAModuł do 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],
})
exportclassModuleBModule{}

Następnie otwórz plik moduł-b.service.ts plik i zaimportuj plik Wstrzykiwać dekorator i ModułAServerice z @nests/wspólne I ../moduł-a/moduł-a.usługaodpowiednio:

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

The Wstrzykiwać dekorator oznacza swój parametr jako cel wstrzyknięcia zależności.

Dalej, w twoim ModułBService class, dodaj poniższy blok kodu:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Powyższy blok kodu zapewnia Twojemu ModuleBService dostęp do metod dostępnych w ModuleAService.

Możesz przetestować usługę, dzwoniąc do ModuleAService witaj 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();
 }
}

Następnie otwórz plik moduł-b.kontroler.ts plik i zastąp wygenerowany kod poniższym blokiem kodu:

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

Powyższy blok kodu konfiguruje a DOSTAWAĆ moduł obsługi tras dla witaj funkcjonować.

Wreszcie, wykonaj żądanie GET za pomocą curl do localhost: 3000/module-b/hello. Polecenie powinno wyświetlić „Witajcie z modułu A!” do swojej konsoli.

Pomyślnie wstrzyknąłeś usługę do innego modułu. To może się przydać, gdy będziesz tworzenie interfejsów API za pomocą Nest.js które mają wiele modułów, które muszą wywoływać swoje metody.

Korzyści z wtrysku międzymodułowego

Choć bezpośrednie wywoływanie usługi z innego modułu może na początku wydawać się prostsze, w dłuższej perspektywie może prowadzić do powstania bardziej złożonego, trudniejszego w utrzymaniu i mniej skalowalnego systemu.

Jednak wstrzykiwanie między modułami promuje modułowość kodu i możliwość ponownego użycia, ułatwiając jego utrzymanie. Dodatkowo centralizuje zależności, poprawia testowalność i obsługuje skalowalną, oddzieloną architekturę.