Menyuntikkan Layanan Nest.js Dari Modul Berbeda

Menginjeksi layanan dari modul Nest.js yang berbeda memerlukan beberapa langkah untuk memastikan injeksi ketergantungan dan pengorganisasian modul yang tepat. Dengan menggunakan dua modul contoh, pelajari cara kerja proses ekspor dan impor layanan.

Menghasilkan Proyek Nest.js

Untuk membuat proyek Nest.js, Anda perlu menginstal CLI di perangkat Anda. Jika tidak, jalankan perintah ini untuk menginstalnya:

npm install -g @nestjs/cli

Setelah CLI Nest.js terinstal, jalankan perintah ini untuk membuat proyek Nest.js baru:

nest new

Anda dapat mengganti “” dengan nama apa pun yang Anda pilih. Menjalankan perintah di atas akan menghasilkan proyek Nest.js baru dengan nama yang ditentukan.

Struktur proyek Anda saat ini akan terlihat seperti gambar di bawah ini:

Untuk berlatih memasukkan layanan dari satu modul ke modul berbeda, Anda akan membuat dua modul, modul-a dan modul-b. Anda juga akan membuat file layanan dan pengontrol yang sesuai.

Jalankan perintah ini untuk menghasilkan modul-a:

nest generate modulemodule-a

Dan jalankan perintah yang setara untuk modul-b:

nest generate modulemodule-b

Kemudian jalankan perintah ini untuk menghasilkan file layanan dan pengontrol untuk modul-a:

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

Dan jalankan perintah yang setara untuk modul-b:

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

Direktori proyek Anda saat ini akan terlihat seperti ini, dengan src/modul-a Dan src/modul-b direktori:

Mengekspor Layanan Dari Modul A

Untuk mengekspor layanan modul-a dari modul-a, Anda harus mencantumkannya sebagai ekspor di file modul modul-a (modul-a.module.ts). Secara default, CLI Nest.js tidak menyediakan ekspor susunan di @Modul dekorator, sehingga file modul yang dihasilkan akan terlihat seperti ini:

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

Untuk membuat layanan-a (modul-a.service.ts) dapat diakses oleh modul yang mengimpor modul-a, membuat ekspor susunan di @Modul dekorator dan tambahkan ModulALayanan untuk itu.

Seperti:

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

Selanjutnya, untuk tujuan pengujian, tambahkan fungsi sederhana ke file layanan modul-a Anda (modul-a.service.ts):

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

Fungsi ini mengembalikan string sampel. Untuk mengonfirmasi bahwa Anda dapat mengimpor layanan ini dengan benar, Anda akan memanggil fungsi tersebut dari modul-b setelah memasukkan layanan-a.

Mengimpor Layanan Ke Modul B

Untuk mengimpor satu modul ke modul lain, Anda harus mencantumkannya sebagai impor di file impor array modul penerima. Dalam hal ini, Anda harus menambahkan modul-a ke impor array modul-b @Modul penghias.

Seperti sebelumnya, CLI Nest.js tidak secara otomatis menghasilkan impor array, jadi Anda harus menambahkannya secara manual.

Pertama, impor modul induk (modul-a.module.ts) ke dalam modul penerima (modul-b.module.ts), buat impor susunan, dan tambahkan ModulAModule ke larik:

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

Selanjutnya, buka milik Anda modul-b.service.ts file dan impor Menyuntikkan dekorator dan ModulAServerice dari @ sarang/umum Dan ../modul-a/modul-a.service, masing-masing:

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

Itu Menyuntikkan dekorator menandai parameternya sebagai target injeksi ketergantungan.

Selanjutnya, di milik Anda ModulBLayanan kelas, tambahkan blok kode di bawah ini:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

Blok kode di atas memberi ModuleBService Anda akses ke metode yang tersedia di ModuleAService Anda.

Anda dapat menguji layanan dengan memanggil ModuleAService's dapatkan Halo metode.

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

Selanjutnya, buka milik Anda modul-b.controller.ts file dan ganti kode yang dihasilkan dengan blok kode di bawah ini:

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

Blok kode di atas menyiapkan a MENDAPATKAN pengendali rute untuk dapatkan Halo fungsi.

Akhirnya, buat permintaan GET dengan curl ke localhost: 3000/module-b/hello. Perintah tersebut harus mencetak “Halo dari Modul A!” ke konsol Anda.

Anda telah berhasil memasukkan layanan ke modul lain. Ini bisa berguna saat Anda berada membangun API dengan Nest.js yang memiliki beberapa modul yang perlu memanggil metode satu sama lain.

Manfaat Injeksi Lintas Modul

Meskipun memanggil layanan secara langsung dari modul lain mungkin tampak lebih sederhana pada awalnya, hal ini dapat menyebabkan sistem menjadi lebih kompleks, kurang dapat dipelihara, dan kurang skalabel dalam jangka panjang.

Namun, injeksi lintas modul meningkatkan modularitas dan penggunaan kembali kode, sehingga lebih mudah untuk dipelihara. Selain itu, ia memusatkan dependensi, meningkatkan kemampuan pengujian, dan mendukung arsitektur yang dapat diskalakan dan dipisahkan.