Home-theater-designers
Att injicera en tjänst från en annan Nest.js-modul innebär några steg för att säkerställa korrekt beroendeinjektion och modulorganisering. Använd två exempelmoduler för att lära dig hur processen att exportera och importera tjänster fungerar.
MUO Dagens video SCROLL FÖR ATT FORTSÄTTA MED INNEHÅLL
Genererar ett Nest.js-projekt
För att generera ett Nest.js-projekt måste du ha CLI installerat på din enhet. Om du inte gör det, kör det här kommandot för att installera det:
npm install -g @nestjs/cli
Med Nest.js CLI installerad kör du det här kommandot för att generera ett nytt Nest.js-projekt:
nest new <project-name>
Du kan ersätta '
Din nuvarande projektstruktur bör se ut som bilden nedan:
uppgiftshanteraren inaktiverad av administratör windows 10
För att öva på att injicera en tjänst från en modul till en annan modul, genererar du två moduler, modul-a och modul-b. Du kommer också att generera deras motsvarande tjänst- och kontrollfiler.
Kör detta kommando för att generera modul-a:
nest generate module module-a
Och kör motsvarande kommando för modul-b:
nest generate module module-b
Kör sedan det här kommandot för att generera tjänsten och styrenhetsfilerna för modul-a:
nest generate service module-a && nest generate controller module-a
Och kör motsvarande kommando för modul-b:
nest generate service module-b && nest generate controller module-b
Din nuvarande projektkatalog ska se ut så här, med src/modul-a och src/modul-b kataloger:
Exportera en tjänst från modul A
För att exportera modul-a-tjänsten från modul-a-modulen måste du lista den som en export i modul-a:s modulfil ( modul-a.modul.ts ). Som standard tillhandahåller Nest.js CLI inte en export array i @Modul decorator, så den genererade modulfilen kommer att se ut så här:
// 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 {}
Att göra tjänsten-en ( module-a.service.ts ) tillgänglig för moduler som importerar modul-a, skapar en export array i @Modul dekoratör och lägg till ModulAService till det.
Såhär:
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 {}
Därefter, för teständamål, lägg till en enkel funktion till din modul-en servicefil ( module-a.service.ts ):
import { Injectable } from '@nestjs/common';
@Injectable()
export class ModuleAService {
getHello(): string {
return 'Hello from Module A!';
}
}
Denna funktion returnerar en exempelsträng. För att bekräfta att du kan importera den här tjänsten korrekt, anropar du den funktionen från modul-b efter att ha injicerat tjänst-a.
Importera en tjänst till modul B
För att importera en modul till en annan, måste du lista den som en import i import arrayen hos den mottagande modulen. I det här fallet måste du lägga till modul-a till import array av modul-b @Modul dekoratör.
Som tidigare genererar Nest.js CLI inte automatiskt en import array, så du måste lägga till den manuellt.
Importera först den överordnade modulen ( modul-a.modul.ts ) in i den mottagande modulen ( modul-b.modul.ts ), skapa import array och lägg till ModulAModule till arrayen:
// 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 {}
Öppna sedan din modul-b.service.ts fil och importera Injicera dekoratör och ModuleAServerice från @bon/common och ../module-a/module-a.service , respektive:
import { Injectable, Inject } from '@nestjs/common';
import { ModuleAService } from '../module-a/module-a.service';
De Injicera decorator markerar sin parameter som ett mål för beroendeinjektion.
hur man väcker windows 10 från viloläge
Nästa, i din ModulBService klass, lägg till kodblocket nedan:
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
Kodblocket ovan ger din ModuleBService tillgång till de metoder som finns tillgängliga i din ModuleAService.
Du kan testa tjänsten genom att ringa ModuleAServices få Hej metod.
// 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();
}
}
Öppna sedan din modul-b.controller.ts fil och ersätt den genererade koden med kodblocket nedan:
// 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();
}
}
Kodblocket ovan ställer in en SKAFFA SIG rutthanterare för få Hej fungera.
Till sist, gör en GET-förfrågan med curl till localhost:3000/module-b/hello. Kommandot ska skriva ut 'Hej från modul A!' till din konsol.
Du har framgångsrikt injicerat en tjänst i en annan modul. Detta kan komma väl till pass när du är det bygga API:er med Nest.js som har flera moduler som behöver anropa varandras metoder.
Fördelar med Cross-Module Injection
Även om att direkt anropa en tjänst från en annan modul kan verka enklare till en början, kan det leda till ett mer komplext, mindre underhållbart och mindre skalbart system i det långa loppet.
Korsmodulinjektion främjar dock kodmodularitet och återanvändbarhet, vilket gör det lättare att underhålla. Dessutom centraliserar den beroenden, förbättrar testbarheten och stöder en skalbar, frikopplad arkitektur.