Injicere en Nest.js-tjeneste fra et andet modul

Injektion af en tjeneste fra et andet Nest.js-modul involverer et par trin for at sikre korrekt afhængighedsinjektion og modulorganisering. Brug to eksempelmoduler til at lære, hvordan processen med at eksportere og importere tjenester fungerer.

Generering af et Nest.js-projekt

For at generere et Nest.js-projekt skal du have CLI installeret på din enhed. Hvis du ikke gør det, skal du køre denne kommando for at installere den:

npm install -g @nestjs/cli

Med Nest.js CLI installeret, kør denne kommando for at generere et nyt Nest.js-projekt:

nest new

Du kan erstatte "” med et hvilket som helst navn, du vælger. Hvis du kører kommandoen ovenfor, genereres et nyt Nest.js-projekt med det angivne navn.

Din nuværende projektstruktur skal se ud som billedet nedenfor:

For at øve dig i at injicere en tjeneste fra et modul til et andet modul, skal du generere to moduler, modul-a og modul-b. Du vil også generere deres tilsvarende service- og controllerfiler.

Kør denne kommando for at generere modul-a:

nest generate modulemodule-a

Og kør den tilsvarende kommando for modul-b:

nest generate modulemodule-b

Kør derefter denne kommando for at generere service- og controllerfilerne til modul-a:

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

Og kør den tilsvarende kommando for modul-b:

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

Din nuværende projektmappe skulle se sådan ud, med src/modul-a og src/modul-b mapper:

Eksport af en tjeneste fra modul A

For at eksportere modul-a-tjenesten fra modul-a-modulet, skal du angive den som en eksport i modul-a's modulfil (modul-a.modul.ts). Som standard giver Nest.js CLI ikke en eksport række i @Modul dekorator, så den genererede modulfil vil se sådan ud:

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

At gøre service-en (modul-a.service.ts) tilgængelig for moduler, der importerer modul-a, opretter en eksport række i @Modul dekoratør og tilføj ModulAService til det.

Ligesom:

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

Dernæst, til testformål, tilføj en simpel funktion til dit modul-en servicefil (modul-a.service.ts):

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

Denne funktion returnerer en prøvestreng. For at bekræfte, at du kan importere denne tjeneste korrekt, kalder du den funktion fra modul-b efter indsprøjtning af service-a.

Import af en tjeneste til modul B

For at importere et modul til et andet, skal du angive det som en import i import array af det modtagende modul. I dette tilfælde skal du tilføje modul-a til import række af modul-b'er @Modul dekoratør.

Som før genererer Nest.js CLI ikke automatisk en import array, så du skal manuelt tilføje det.

Først skal du importere det overordnede modul (modul-a.modul.ts) ind i det modtagende modul (modul-b.modul.ts), opret import array, og tilføj ModulAModule til arrayet:

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

Åbn derefter din modul-b.service.ts fil og importer Indsprøjte dekoratør og ModuleAServerice fra @reder/fælles og ../modul-a/modul-a.service, henholdsvis:

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

Det Indsprøjte decorator markerer sin parameter som et mål for afhængighedsinjektion.

Dernæst i din ModulBService klasse, tilføj kodeblokken nedenfor:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Kodeblokken ovenfor giver din ModuleBService adgang til de metoder, der er tilgængelige i din ModuleAService.

Du kan teste tjenesten ved at ringe til ModuleAService's goddag metode.

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

Åbn derefter din modul-b.controller.ts fil og erstat den genererede kode med kodeblokken nedenfor:

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

Kodeblokken ovenfor opretter en FÅ rutehandler for goddag fungere.

Endelig, lav en GET-anmodning med curl til localhost: 3000/module-b/hello. Kommandoen skal udskrive "Hej fra modul A!" til din konsol.

Du har med succes injiceret en service i et andet modul. Dette kan være nyttigt, når du er det opbygning af API'er med Nest.js der har flere moduler, der skal kalde hinandens metoder.

Fordele ved Cross-Module Injection

Selvom direkte opkald til en tjeneste fra et andet modul kan virke enklere i starten, kan det føre til et mere komplekst, mindre vedligeholdeligt og mindre skalerbart system i det lange løb.

Men indsprøjtning på tværs af moduler fremmer kodemodularitet og genbrugelighed, hvilket gør det nemmere at vedligeholde. Derudover centraliserer den afhængigheder, forbedrer testbarheden og understøtter en skalerbar, afkoblet arkitektur.