Home-theater-designers
Menyuntik perkhidmatan daripada modul Nest.js yang berbeza melibatkan beberapa langkah untuk memastikan penyuntikan pergantungan dan organisasi modul yang betul. Menggunakan dua modul sampel, ketahui cara proses mengeksport dan mengimport perkhidmatan berfungsi.
Video MUO pada hari itu SCROLL UNTUK MENERUSKAN KANDUNGAN
Menjana Projek Nest.js
Untuk menjana projek Nest.js, anda perlu memasang CLI pada peranti anda. Jika anda tidak, jalankan arahan ini untuk memasangnya:
npm install -g @nestjs/cli
Dengan Nest.js CLI dipasang, jalankan arahan ini untuk menjana projek Nest.js baharu:
nest new <project-name>
Anda boleh menggantikan '
Struktur projek semasa anda sepatutnya kelihatan seperti imej di bawah:
Untuk berlatih menyuntik perkhidmatan daripada satu modul ke modul yang berbeza, anda akan menjana dua modul, modul-a dan modul-b. Anda juga akan menjana fail perkhidmatan dan pengawal mereka yang sepadan.
Jalankan arahan ini untuk menghasilkan modul-a:
nest generate module module-a
Dan jalankan arahan yang setara untuk modul-b:
nest generate module module-b
Kemudian jalankan arahan ini untuk menjana fail perkhidmatan dan pengawal untuk modul-a:
nest generate service module-a && nest generate controller module-a
Dan jalankan arahan yang setara untuk modul-b:
nest generate service module-b && nest generate controller module-b
Direktori projek semasa anda sepatutnya kelihatan seperti ini, dengan src/modul-a dan src/modul-b direktori:
Mengeksport Perkhidmatan Daripada Modul A
Untuk mengeksport perkhidmatan modul-a daripada modul-modul, anda perlu menyenaraikannya sebagai eksport dalam fail modul modul-a ( modul-a.module.ts ). Secara lalai, Nest.js CLI tidak menyediakan eksport tatasusunan dalam @Modul penghias, jadi fail modul yang dihasilkan akan kelihatan 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],
})
export class ModuleAModule {}
Untuk membuat perkhidmatan-a ( modul-a.service.ts ) boleh diakses kepada modul yang mengimport modul-a, buat an eksport tatasusunan dalam @Modul penghias dan menambah ModuleAService kepadanya.
Seperti itu:
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 {}
Seterusnya, untuk tujuan ujian, tambahkan fungsi mudah pada modul anda-fail perkhidmatan ( modul-a.service.ts ):
import { Injectable } from '@nestjs/common';
@Injectable()
export class ModuleAService {
getHello(): string {
return 'Hello from Module A!';
}
}
Fungsi ini mengembalikan rentetan sampel. Untuk mengesahkan bahawa anda boleh mengimport perkhidmatan ini dengan betul, anda akan memanggil fungsi itu daripada modul-b selepas menyuntik perkhidmatan-a.
Mengimport Perkhidmatan Ke Modul B
Untuk mengimport satu modul ke yang lain, anda perlu menyenaraikannya sebagai import dalam import tatasusunan modul penerima. Dalam kes ini, anda perlu menambah modul-a pada import tatasusunan modul-b @Modul penghias.
Seperti sebelum ini, CLI Nest.js tidak menjana secara automatik import array, jadi anda mesti menambahnya secara manual.
Pertama, import modul induk ( modul-a.module.ts ) ke dalam modul penerima ( modul-b.module.ts ), cipta import tatasusunan, dan tambah ModuleAModul kepada tatasusunan:
cara bermain permainan windows di chromebook
// 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 {}
Seterusnya, buka anda modul-b.service.ts fail dan import Menyuntik penghias dan ModuleAServerice daripada @sarang/biasa dan ../module-a/module-a.service , masing-masing:
import { Injectable, Inject } from '@nestjs/common';
import { ModuleAService } from '../module-a/module-a.service';
The Menyuntik penghias menandakan parameternya sebagai sasaran untuk suntikan pergantungan.
Seterusnya, dalam anda ModuleBService kelas, tambahkan blok kod di bawah:
@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;
Blok kod di atas memberikan ModuleBService anda akses kepada kaedah yang tersedia dalam ModuleAService anda.
Anda boleh menguji perkhidmatan dengan menghubungi ModuleAService getHello kaedah.
// 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();
}
}
Seterusnya, buka anda modul-b.controller.ts fail dan gantikan kod yang dihasilkan dengan blok kod di bawah:
// 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();
}
}
Blok kod di atas menyediakan a DAPATKAN pengendali laluan untuk getHello fungsi.
Akhirnya, buat permintaan GET dengan curl kepada localhost:3000/module-b/hello. Perintah harus mencetak 'Hello dari Modul A!' ke konsol anda.
Anda telah berjaya menyuntik perkhidmatan ke dalam modul lain. Ini boleh berguna apabila anda berada membina API dengan Nest.js yang mempunyai berbilang modul yang perlu memanggil kaedah satu sama lain.
Faedah Suntikan Cross-Modul
Walaupun memanggil perkhidmatan secara langsung daripada modul lain mungkin kelihatan lebih mudah pada mulanya, ia boleh membawa kepada sistem yang lebih kompleks, kurang boleh diselenggara dan kurang berskala dalam jangka masa panjang.
Walau bagaimanapun, suntikan silang modul menggalakkan modulariti kod dan kebolehgunaan semula, menjadikannya lebih mudah untuk diselenggara. Selain itu, ia memusatkan kebergantungan, meningkatkan kebolehujian dan menyokong seni bina berskala yang dipisahkan.