Nest.js-palvelun lisääminen eri moduulista

Palvelun lisääminen toisesta Nest.js-moduulista sisältää muutaman vaiheen, joilla varmistetaan riippuvuuden lisääminen ja moduulin organisointi. Opi kahden mallimoduulin avulla, miten palveluiden vienti- ja tuontiprosessi toimii.

Nest.js-projektin luominen

Jotta voit luoda Nest.js-projektin, sinun on oltava CLI asennettuna laitteellesi. Jos et, asenna se suorittamalla tämä komento:

npm install -g @nestjs/cli

Kun Nest.js CLI on asennettu, luo uusi Nest.js-projekti suorittamalla tämä komento:

nest new

Voit korvata "” millä tahansa valitsemallasi nimellä. Yllä olevan komennon suorittaminen luo uuden Nest.js-projektin määritetyllä nimellä.

Nykyisen projektisi rakenteen pitäisi näyttää alla olevan kuvan kaltaisesta:

Voit harjoitella palvelun lisäämistä moduulista toiseen luomalla kaksi moduulia, moduuli-a ja moduuli-b. Luot myös niitä vastaavat palvelu- ja ohjaintiedostot.

Suorita tämä komento luodaksesi moduuli-a:

nest generate modulemodule-a

Ja suorita vastaava komento moduulille-b:

nest generate modulemodule-b

Suorita sitten tämä komento luodaksesi palvelu- ja ohjaintiedostot moduulille a:

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

Ja suorita vastaava komento moduulille-b:

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

Nykyisen projektihakemistosi pitäisi näyttää tältä src/module-a ja src/module-b hakemistot:

Palvelun vieminen moduulista A

Jos haluat viedä palvelun moduuli-a moduulista a, sinun on lueteltava se vientinä moduulin a moduulitiedostoon (module-a.module.ts). Oletuksena Nest.js CLI ei tarjoa vientiä joukko sisällä @Moduuli sisustaja, joten luotu moduulitiedosto näyttää tältä:

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

Palvelun tekeminen (module-a.service.ts) käytettävissä moduuleille, jotka tuovat moduulin-a, luovat an vientiä joukko sisällä @Moduuli sisustaja ja lisää ModuleAService siihen.

Niin kuin:

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

Lisää seuraavaksi yksinkertainen toiminto moduuliisi -palvelutiedostoon testausta varten (module-a.service.ts):

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

Tämä funktio palauttaa mallimerkkijonon. Varmistaaksesi, että pystyt tuomaan tämän palvelun oikein, kutsut kyseistä toimintoa moduulista-b, kun olet lisännyt palvelun-a.

Palvelun tuominen moduuliin B

Jos haluat tuoda yhden moduulin toiseen, sinun on lueteltava se tuontina tuonti vastaanottomoduulin joukko. Tässä tapauksessa sinun on lisättävä moduuli-a tuonti joukko moduuli-b: itä @Moduuli sisustusarkkitehti.

Kuten aiemmin, Nest.js CLI ei luo automaattisesti tuonti taulukko, joten sinun on lisättävä se manuaalisesti.

Tuo ensin päämoduuli (module-a.module.ts) vastaanottomoduuliin (module-b.module.ts), luo tuonti joukko ja lisää ModuuliAModuli taulukkoon:

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

Avaa seuraavaksi oma module-b.service.ts tiedosto ja tuo Pistää sisustaja ja ModuleAServerice alkaen @pesät/yleinen ja ../module-a/module-a.service, vastaavasti:

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

The Pistää decorator merkitsee parametrinsa riippuvuuden lisäyksen kohteeksi.

Seuraavaksi sinun ModuuliBService luokka, lisää alla oleva koodilohko:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Yllä oleva koodilohko antaa ModuleBServicellesi pääsyn ModuleAServicessäsi oleviin menetelmiin.

Voit testata palvelua soittamalla ModuleAServiceen saa hei menetelmä.

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

Avaa seuraavaksi oma module-b.controller.ts tiedosto ja korvaa luotu koodi alla olevalla koodilohkolla:

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

Yllä oleva koodilohko määrittää a SAADA reitinkäsittelijä varten saa hei toiminto.

Lopuksi, tee GET-pyyntö curlilla localhostille: 3000/moduuli-b/hei. Komennon pitäisi tulostaa "Hei moduulista A!" konsoliisi.

Olet onnistuneesti lisännyt palvelun toiseen moduuliin. Tämä voi olla hyödyllistä, kun olet sovellusliittymien rakentaminen Nest.js: n avulla joissa on useita moduuleja, joiden on kutsuttava toistensa menetelmiä.

Cross-Module Injection edut

Vaikka palvelun soittaminen suoraan toisesta moduulista saattaa aluksi tuntua yksinkertaisemmalta, se voi johtaa monimutkaisempaan, vähemmän ylläpidettävään ja vähemmän skaalautuvaan järjestelmään pitkällä aikavälillä.

Kuitenkin moduulien välinen injektio edistää koodin modulaarisuutta ja uudelleenkäytettävyyttä, mikä helpottaa sen ylläpitoa. Lisäksi se keskittää riippuvuudet, parantaa testattavuutta ja tukee skaalautuvaa, irrotettua arkkitehtuuria.