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.
Indholdsfortegnelse
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 <project-name>
Du kan erstatte “
Din nuværende projektstruktur skal se ud som billedet nedenfor:
For at øve dig i at injicere en service 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 module module-a
Og kør den tilsvarende kommando for modul-b:
nest generate module module-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/module-a og src/module-b mapper:
Eksport af en tjeneste fra modul A
For at eksportere modul-a-tjenesten fra modul-a-modulet, skal du angive den som eksport i modul-a’s modulfil (module-a.module.ts). Som standard leverer Nest.js CLI ikke et eksportarray i @Module-dekoratoren, så den genererede modulfil vil se sådan ud:
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 {}
For at gøre service-a (module-a.service.ts) tilgængelig for moduler, der importerer modul-a, skal du oprette et eksportarray i @Module-dekoratoren og tilføje ModuleAService 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],
})
export class ModuleAModule {}
Til testformål skal du derefter tilføje en simpel funktion til din modul-a-servicefil (module-a.service.ts):
import { Injectable } from '@nestjs/common';@Injectable()
export class ModuleAService {
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 at have indsat 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 det modtagende moduls importarray. I dette tilfælde skal du tilføje modul-a til import-arrayet for modul-b’s @Module-dekorator.
Som før genererer Nest.js CLI ikke automatisk et importarray, så du skal manuelt tilføje det.
Først skal du importere det overordnede modul (modul-a.module.ts) til det modtagende modul (modul-b.module.ts), oprette import-arrayet og tilføje ModuleAModule til arrayet:
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 {}
Åbn derefter din modul-b.service.ts-fil og importer Inject decorator og ModuleAServerice fra henholdsvis @nests/common og ../module-a/module-a.service:
import { Injectable, Inject } from '@nestjs/common';
import { ModuleAService } from '../module-a/module-a.service';
Inject-dekoratøren markerer sin parameter som et mål for afhængighedsinjektion.
Tilføj derefter kodeblokken nedenfor i din ModuleBService-klasse:
@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 getHello-metode.
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();
}
}
Åbn derefter din module-b.controller.ts-fil og erstat den genererede kode med kodeblokken nedenfor:
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();
}
}
Kodeblokken ovenfor opsætter en GET-rutehåndtering for getHello-funktionen.
Lav endelig 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 bygger 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.
