Vstavljanje storitve Nest.js iz drugega modula

Vstavljanje storitve iz drugega modula Nest.js vključuje nekaj korakov za zagotovitev ustreznega vstavljanja odvisnosti in organizacije modula. Z uporabo dveh vzorčnih modulov se naučite, kako poteka postopek izvoza in uvoza storitev.

Ustvarjanje projekta Nest.js

Če želite ustvariti projekt Nest.js, morate imeti v napravi nameščen CLI. Če tega ne storite, zaženite ta ukaz, da ga namestite:

npm install -g @nestjs/cli

Ko je nameščen Nest.js CLI, zaženite ta ukaz, da ustvarite nov projekt Nest.js:

nest new

Lahko zamenjate "” s poljubnim imenom. Zagon zgornjega ukaza bo ustvaril nov projekt Nest.js z navedenim imenom.

Vaša trenutna struktura projekta bi morala izgledati kot spodnja slika:

Če želite vaditi vbrizgavanje storitve iz enega modula v drug modul, boste ustvarili dva modula, modul-a in modul-b. Ustvarili boste tudi njihove ustrezne datoteke storitev in krmilnikov.

Zaženite ta ukaz, da ustvarite modul-a:

nest generate modulemodule-a

In zaženite enakovreden ukaz za modul-b:

nest generate modulemodule-b

Nato zaženite ta ukaz, da ustvarite storitvene in krmilne datoteke za modul-a:

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

In zaženite enakovreden ukaz za modul-b:

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

Vaš trenutni projektni imenik bi moral izgledati takole, z src/modul-a in src/modul-b imeniki:

Izvoz storitve iz modula A

Če želite izvoziti storitev modula-a iz modula modula-a, jo morate navesti kot izvoz v datoteki modula modula-a (modul-a.module.ts). Nest.js CLI privzeto ne zagotavlja izvoz niz v @Modul dekorator, tako da bo ustvarjena datoteka modula videti takole:

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

Narediti servis-a (modul-a.service.ts) dostopen modulom, ki uvažajo modul-a, ustvarijo izvoz niz v @Modul dekorater in dodajte ModuleAService temu.

takole:

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

Nato za namene testiranja svojemu modulu dodajte preprosto funkcijo - storitveno datoteko (modul-a.service.ts):

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

Ta funkcija vrne vzorčni niz. Če želite potrditi, da lahko pravilno uvozite to storitev, boste poklicali to funkcijo iz modula-b po vstavitvi storitve-a.

Uvoz storitve v modul B

Če želite uvoziti en modul v drugega, ga morate navesti kot uvoz v uvoz polje sprejemnega modula. V tem primeru morate dodati modul-a v uvoz niz modulov-b @Modul dekorater.

Kot prej CLI Nest.js ne ustvari samodejno uvoz matriko, zato jo morate dodati ročno.

Najprej uvozite nadrejeni modul (modul-a.module.ts) v sprejemni modul (modul-b.module.ts), ustvarite uvoz matriko in dodajte ModulAModul na niz:

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

Nato odprite svoj modul-b.service.ts datoteko in uvozite Vbrizgajte dekorater in ModuleAServerice od @gnezda/skupno in ../modul-a/modul-a.serviceoziroma:

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

The Vbrizgajte dekorater označi svoj parameter kot cilj za vstavljanje odvisnosti.

Naprej, v vašem ModuleBService razreda dodajte blok kode spodaj:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Zgornji blok kode daje vašemu ModuleBService dostop do metod, ki so na voljo v vašem ModuleAService.

Storitev lahko preizkusite tako, da pokličete ModuleAService getHello metoda.

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

Nato odprite svoj modul-b.controller.ts datoteko in zamenjajte ustvarjeno kodo s spodnjim blokom kode:

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

Zgornji blok kode nastavi a DOBITI upravljalnik poti za getHello funkcijo.

končno, naredite zahtevo GET s curl lokalnemu gostitelju: 3000/modul-b/zdravo. Ukaz bi moral natisniti »Pozdravljeni iz modula A!« na vašo konzolo.

Uspešno ste vnesli storitev v drug modul. To vam lahko pride prav, ko ste gradnjo API-jev z Nest.js ki imajo več modulov, ki morajo klicati metode drug drugega.

Prednosti vbrizgavanja med moduli

Medtem ko se lahko neposredno klicanje storitve iz drugega modula sprva zdi enostavnejše, lahko na dolgi rok vodi do bolj zapletenega, manj vzdrževanega in manj razširljivega sistema.

Vendar pa vstavljanje med moduli spodbuja modularnost in ponovno uporabnost kode, kar olajša vzdrževanje. Poleg tega centralizira odvisnosti, izboljša preizkušljivost in podpira razširljivo, ločeno arhitekturo.