Home-theater-designers
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.
MUO Video af dagen RUL FOR AT FORTSÆTTE MED INDHOLD
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 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 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/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],
})
export class ModuleAModule {}
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],
})
export class ModuleAModule {}
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()
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 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],
})
export class ModuleBModule {}
Å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()
export class ModuleBService {
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
getHello(): string {
return this.moduleAService.getHello();
}
}
Åbn derefter din modul-b.controller.ts fil og erstat den genererede kode med kodeblokken nedenfor:
hvordan bruger du portrættilstand på iphone 7
// 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();
}
}
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.