Pag-iniksyon ng Serbisyo ng Nest.js Mula sa Ibang Module

Ang mga mambabasang tulad mo ay tumutulong sa pagsuporta sa MUO. Kapag bumili ka gamit ang mga link sa aming site, maaari kaming makakuha ng isang affiliate na komisyon. Magbasa pa.

Ang pag-iniksyon ng serbisyo mula sa ibang Nest.js module ay may kasamang ilang hakbang para matiyak ang wastong dependency injection at module na organisasyon. Gamit ang dalawang sample na module, alamin kung paano gumagana ang proseso ng pag-export at pag-import ng mga serbisyo.

MUO Video ng araw MAG-SCROLL PARA MAGPATULOY SA NILALAMAN

Pagbuo ng Nest.js Project

Para makabuo ng proyekto ng Nest.js, kailangan mong i-install ang CLI sa iyong device. Kung hindi mo gagawin, patakbuhin ang command na ito upang i-install ito:

 npm install -g @nestjs/cli

Kapag naka-install ang Nest.js CLI, patakbuhin ang command na ito para bumuo ng bagong proyekto ng Nest.js:

 nest new <project-name>

Maaari mong palitan ang '' ng anumang pangalan na pipiliin mo. Ang pagpapatakbo ng command sa itaas ay bubuo ng bagong proyekto ng Nest.js na may tinukoy na pangalan.

Ang iyong kasalukuyang istraktura ng proyekto ay dapat magmukhang sa larawan sa ibaba:

Para magsanay ng pag-inject ng serbisyo mula sa isang module patungo sa ibang module, bubuo ka ng dalawang module, module-a at module-b. Bubuo ka rin ng kanilang kaukulang serbisyo at mga file ng controller.

Patakbuhin ang command na ito upang makabuo ng module-a:

 nest generate module module-a

At patakbuhin ang katumbas na utos para sa module-b:

 nest generate module module-b

Pagkatapos ay patakbuhin ang utos na ito upang makabuo ng mga file ng serbisyo at controller para sa module-a:

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

At patakbuhin ang katumbas na utos para sa module-b:

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

Ang iyong kasalukuyang direktoryo ng proyekto ay dapat magmukhang ganito, na may src/module-a at src/module-b mga direktoryo:

Nest.js file structure na may mga nabuong module, serbisyo at controller

Pag-export ng Serbisyo Mula sa Module A

Upang i-export ang module-a service mula sa module-a module, kailangan mong ilista ito bilang export sa module file ng module-a ( module-a.module.ts ). Bilang default, ang Nest.js CLI ay hindi nagbibigay ng pag-export array sa @Modyul dekorador, kaya ang nabuong module file ay magiging ganito:

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

Upang gumawa ng serbisyo-a ( module-a.service.ts ) naa-access sa mga module na nag-i-import ng module-a, lumikha ng isang pag-export array sa @Modyul dekorador at idagdag ModuleAService dito.

Tulad nito:

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

Susunod, para sa mga layunin ng pagsubok, magdagdag ng isang simpleng function sa iyong module-isang file ng serbisyo ( module-a.service.ts ):

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

Ang function na ito ay nagbabalik ng sample string. Para kumpirmahin na mai-import mo nang tama ang serbisyong ito, tatawagan mo ang function na iyon mula sa module-b pagkatapos mag-inject ng service-a.

Pag-import ng Serbisyo sa Module B

Upang mag-import ng isang module sa isa pa, kailangan mong ilista ito bilang isang pag-import sa pag-import hanay ng pagtanggap ng module. Sa kasong ito, kailangan mong magdagdag ng module-a sa pag-import hanay ng mga module-b's @Modyul dekorador.

Tulad ng dati, ang Nest.js CLI ay hindi awtomatikong bumubuo ng isang pag-import array, kaya dapat mong idagdag ito nang manu-mano.

Una, i-import ang parent module ( module-a.module.ts ) sa pagtanggap ng module ( module-b.module.ts ), lumikha ng pag-import array, at idagdag ModuleAModul sa array:

paano ko mai-uninstall ang skype para sa negosyo

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

Susunod, buksan ang iyong module-b.service.ts file at i-import ang Mag-inject dekorador at ModuleAServerice mula sa @nests/common at ../module-a/module-a.service , ayon sa pagkakabanggit:

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

Ang Mag-inject minamarkahan ng dekorador ang parameter nito bilang target para sa dependency injection.

Susunod, sa iyong Serbisyong Module class, idagdag ang code block sa ibaba:

 @Inject(ModuleAService) 
  private readonly moduleAService: ModuleAService;

Ang bloke ng code sa itaas ay nagbibigay sa iyong ModuleBService ng access sa mga paraan na available sa iyong ModuleAService.

Maaari mong subukan ang serbisyo sa pamamagitan ng pagtawag sa ModuleAService getHello paraan.

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

Susunod, buksan ang iyong module-b.controller.ts file at palitan ang nabuong code ng code block sa ibaba:

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

Ang bloke ng code sa itaas ay nagse-set up ng a GET tagapangasiwa ng ruta para sa getHello function.

Sa wakas, gumawa ng kahilingan sa GET gamit ang curl sa localhost:3000/module-b/hello. Ang command ay dapat mag-print ng 'Hello mula sa Module A!' sa iyong console.

Matagumpay mong naipasok ang isang serbisyo sa isa pang module. Ito ay maaaring magamit kapag ikaw ay pagbuo ng mga API gamit ang Nest.js na mayroong maraming mga module na kailangang tawagan ang mga pamamaraan ng bawat isa.

Mga Benepisyo ng Cross-Module Injection

Habang ang direktang pagtawag sa isang serbisyo mula sa isa pang module ay maaaring mukhang mas simple sa simula, maaari itong humantong sa isang mas kumplikado, hindi gaanong mapanatili, at hindi gaanong nasusukat na sistema sa katagalan.

Gayunpaman, ang cross-module injection ay nagtataguyod ng code modularity at reusability, na ginagawang mas madaling mapanatili. Bukod pa rito, isinasentro nito ang mga dependency, pinapabuti ang pagiging masusubok, at sinusuportahan ang isang scalable, decoupled na arkitektura.