सुनिश्चित करें कि आपके मॉड्यूल स्वच्छ, पुन: प्रयोज्य इंजेक्शन के साथ अच्छी तरह व्यवस्थित हैं।

किसी भिन्न Nest.js मॉड्यूल से किसी सेवा को इंजेक्ट करने में उचित निर्भरता इंजेक्शन और मॉड्यूल संगठन सुनिश्चित करने के लिए कुछ चरण शामिल होते हैं। दो नमूना मॉड्यूल का उपयोग करके जानें कि सेवाओं के निर्यात और आयात की प्रक्रिया कैसे काम करती है।

एक Nest.js प्रोजेक्ट तैयार करना

Nest.js प्रोजेक्ट जेनरेट करने के लिए, आपको अपने डिवाइस पर CLI इंस्टॉल करना होगा। यदि आप नहीं करते हैं, तो इसे स्थापित करने के लिए यह कमांड चलाएँ:

npm install -g @nestjs/cli

Nest.js CLI स्थापित होने पर, एक नया Nest.js प्रोजेक्ट बनाने के लिए यह कमांड चलाएँ:

nest new

आप प्रतिस्थापित कर सकते हैं "आपके द्वारा चुने गए किसी भी नाम के साथ। उपरोक्त आदेश चलाने से निर्दिष्ट नाम के साथ एक नया Nest.js प्रोजेक्ट उत्पन्न होगा।

आपकी वर्तमान परियोजना संरचना नीचे दी गई छवि की तरह दिखनी चाहिए:

किसी सेवा को एक मॉड्यूल से दूसरे मॉड्यूल में इंजेक्ट करने का अभ्यास करने के लिए, आप दो मॉड्यूल, मॉड्यूल-ए और मॉड्यूल-बी उत्पन्न करेंगे। आप उनकी संगत सेवा और नियंत्रक फ़ाइलें भी उत्पन्न करेंगे।

instagram viewer

मॉड्यूल-ए उत्पन्न करने के लिए यह कमांड चलाएँ:

nest generate modulemodule-a

और मॉड्यूल-बी के लिए समतुल्य कमांड चलाएँ:

nest generate modulemodule-b

फिर मॉड्यूल-ए के लिए सेवा और नियंत्रक फ़ाइलें उत्पन्न करने के लिए इस कमांड को चलाएँ:

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

और मॉड्यूल-बी के लिए समतुल्य कमांड चलाएँ:

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

आपकी वर्तमान प्रोजेक्ट निर्देशिका इस तरह दिखनी चाहिए स्रोत/मॉड्यूल-ए और स्रोत/मॉड्यूल-बी निर्देशिकाएँ:

मॉड्यूल ए से एक सेवा निर्यात करना

मॉड्यूल-ए मॉड्यूल से मॉड्यूल-ए सेवा को निर्यात करने के लिए, आपको इसे मॉड्यूल-ए के मॉड्यूल फ़ाइल में निर्यात के रूप में सूचीबद्ध करना होगा (मॉड्यूल-a.module.ts). डिफ़ॉल्ट रूप से, Nest.js CLI कोई प्रदान नहीं करता है निर्यात में सरणी @मापांक डेकोरेटर, इसलिए जेनरेट की गई मॉड्यूल फ़ाइल इस तरह दिखेगी:

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

सेवा-ए बनाने के लिए (मॉड्यूल-a.service.ts) उन मॉड्यूल के लिए सुलभ है जो मॉड्यूल-ए आयात करते हैं, एक बनाते हैं निर्यात में सरणी @मापांक डेकोरेटर और जोड़ें मॉड्यूलएसेवा इसे.

जैसे इतना:

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

इसके बाद, परीक्षण उद्देश्यों के लिए, अपने मॉड्यूल में एक सरल फ़ंक्शन जोड़ें- एक सेवा फ़ाइल (मॉड्यूल-a.service.ts):

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

यह फ़ंक्शन एक नमूना स्ट्रिंग लौटाता है। यह पुष्टि करने के लिए कि आप इस सेवा को सही ढंग से आयात कर सकते हैं, आप सेवा-ए इंजेक्ट करने के बाद मॉड्यूल-बी से उस फ़ंक्शन को कॉल करेंगे।

मॉड्यूल बी में एक सेवा आयात करना

एक मॉड्यूल को दूसरे में आयात करने के लिए, आपको इसे आयात के रूप में सूचीबद्ध करना होगा आयात प्राप्तकर्ता मॉड्यूल की सरणी। इस स्थिति में, आपको इसमें मॉड्यूल-ए जोड़ना होगा आयात मॉड्यूल-बी की सरणी @मापांक डेकोरेटर.

पहले की तरह, Nest.js CLI स्वचालित रूप से उत्पन्न नहीं होता है आयात सरणी, इसलिए आपको इसे मैन्युअल रूप से जोड़ना होगा।

सबसे पहले, मूल मॉड्यूल आयात करें (मॉड्यूल-a.module.ts) प्राप्तकर्ता मॉड्यूल में (मॉड्यूल-b.module.ts), बनाएँ आयात सरणी, और जोड़ें मॉड्यूलएमॉड्यूल सरणी के लिए:

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

इसके बाद, अपना खोलें मॉड्यूल-b.service.ts फ़ाइल करें और आयात करें इंजेक्षन डेकोरेटर और मॉड्यूलAServerice से @घोंसले/आम और ../मॉड्यूल-ए/मॉड्यूल-ए.सेवा, क्रमश:

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

इंजेक्षन डेकोरेटर अपने पैरामीटर को निर्भरता इंजेक्शन के लक्ष्य के रूप में चिह्नित करता है।

अगला, आपके में मॉड्यूलबीसेवा क्लास, नीचे कोड ब्लॉक जोड़ें:

@Inject(ModuleAService)
private readonly moduleAService: ModuleAService;

उपरोक्त कोड ब्लॉक आपके ModuleBService को आपके ModuleAService में उपलब्ध तरीकों तक पहुंच प्रदान करता है।

आप ModuleAService को कॉल करके सेवा का परीक्षण कर सकते हैं नमस्कार प्राप्त करें तरीका।

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

इसके बाद, अपना खोलें मॉड्यूल-बी.कंट्रोलर.टीएस फ़ाइल करें और जनरेट किए गए कोड को नीचे दिए गए कोड ब्लॉक से बदलें:

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

उपरोक्त कोड ब्लॉक एक सेट करता है पाना के लिए रूट हैंडलर नमस्कार प्राप्त करें समारोह।

अंत में, कर्ल के साथ GET अनुरोध करें लोकलहोस्ट के लिए: 3000/मॉड्यूल-बी/हैलो। कमांड को "मॉड्यूल ए से हैलो!" प्रिंट करना चाहिए आपके कंसोल पर.

आपने एक सेवा को दूसरे मॉड्यूल में सफलतापूर्वक इंजेक्ट कर दिया है। यह तब काम आ सकता है जब आप हों Nest.js के साथ API बनाना इसमें कई मॉड्यूल हैं जिन्हें एक-दूसरे के तरीकों को कॉल करने की आवश्यकता होती है।

क्रॉस-मॉड्यूल इंजेक्शन के लाभ

हालाँकि किसी सेवा को सीधे किसी अन्य मॉड्यूल से कॉल करना पहले आसान लग सकता है, लेकिन लंबे समय में यह अधिक जटिल, कम रखरखाव योग्य और कम स्केलेबल सिस्टम का कारण बन सकता है।

हालाँकि, क्रॉस-मॉड्यूल इंजेक्शन कोड मॉड्यूलरिटी और पुन: प्रयोज्यता को बढ़ावा देता है, जिससे इसे बनाए रखना आसान हो जाता है। इसके अतिरिक्त, यह निर्भरता को केंद्रीकृत करता है, परीक्षण क्षमता में सुधार करता है, और एक स्केलेबल, डिकॉउल्ड आर्किटेक्चर का समर्थन करता है।