InversifyJS: TypeScript ऐप्स के लिए IoC कंटेनर - पूर्ण गाइड

InversifyJS: TypeScript के लिए शक्तिशाली IoC कंटेनर

InversifyJS TypeScript और JavaScript एप्लिकेशन के लिए एक हल्का लेकिन बेहद शक्तिशाली IoC (Inversion of Control) कंटेनर है। यह Dependency Injection (DI) पैटर्न को लागू करता है, जिससे डेवलपर्स कम-कपल, टेस्ट करने योग्य और स्केलेबल सिस्टम बना सकते हैं। यह लाइब्रेरी TypeScript की क्षमताओं (डेकोरेटर, टाइप्स) का सक्रिय रूप से उपयोग करती है ताकि सख्त टाइपिंग और डेवलपमेंट में आसानी सुनिश्चित हो सके।

InversifyJS Node.js पर सर्वर-साइड एप्लिकेशन और Angular, React या Vue जैसे फ्रेमवर्क वाले क्लाइंट प्रोजेक्ट्स के लिए आदर्श है। इस गाइड में हम मुख्य अवधारणाओं को समझेंगे और दिखाएंगे कि कैसे जल्दी से शुरुआत करें।

InversifyJS की मुख्य अवधारणाएं

कोड लिखने से पहले, लाइब्रेरी की तीन मुख्य संस्थाओं को समझना महत्वपूर्ण है:

• कंटेनर (Container) — केंद्रीय ऑब्जेक्ट जो सभी डिपेंडेंसी को मैनेज करता है। आप इसमें एब्स्ट्रैक्शन और उनके इम्प्लीमेंटेशन को रजिस्टर करते हैं।
• सर्विस आइडेंटिफायर (Service Identifiers) — यूनिक कीज़ जिनके द्वारा कंटेनर सही इम्प्लीमेंटेशन ढूंढता है। ये स्ट्रिंग, सिंबल या क्लास हो सकते हैं।
• डेकोरेटर — @injectable() और @inject() — TypeScript को बताते हैं कि क्लास को इंजेक्ट किया जा सकता है और उसे किन डिपेंडेंसी की आवश्यकता है।

इंस्टॉलेशन और सेटअप

शुरुआत करने के लिए InversifyJS और इसकी टाइपोग्राफिक डिपेंडेंसी इंस्टॉल करें:

npm install inversify reflect-metadata --save
npm install --save-dev @types/node

फिर tsconfig.json में दो अनिवार्य विकल्प जोड़ें:

{
  "compilerOptions": {
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true,
    "types": ["reflect-metadata"]
  }
}

इसके बाद, अपने मुख्य एप्लिकेशन फ़ाइल (आमतौर पर index.ts या main.ts) में reflect-metadata को इम्पोर्ट करें:

import "reflect-metadata";

पहला उदाहरण: एक सरल सर्विस

एक इंटरफ़ेस और उसका इम्प्लीमेंटेशन बनाएं। @injectable() डेकोरेटर पर ध्यान दें:

// interfaces/IWarrior.ts
export interface IWarrior {
    fight(): string;
}

// entities/Warrior.ts
import { injectable } from "inversify";

@injectable()
export class Warrior implements IWarrior {
    fight(): string {
        return "योद्धा तलवार से हमला करता है!";
    }
}

अब इस संबंध को कंटेनर में रजिस्टर करें और एक इंस्टेंस प्राप्त करें:

import { Container } from "inversify";
import { IWarrior } from "./interfaces/IWarrior";
import { Warrior } from "./entities/Warrior";

const container = new Container();

// एब्स्ट्रैक्शन को उसके इम्प्लीमेंटेशन के साथ रजिस्टर करें
container.bind<IWarrior>("IWarrior").to(Warrior);

// इंस्टेंस प्राप्त करें
const warrior = container.get<IWarrior>("IWarrior");
console.log(warrior.fight()); // "योद्धा तलवार से हमला करता है!"

कंस्ट्रक्टर के माध्यम से डिपेंडेंसी इंजेक्शन

DI की असली ताकत तब सामने आती है जब एक क्लास दूसरे पर निर्भर होती है। @inject() डेकोरेटर का उपयोग करें:

// interfaces/IWeapon.ts
export interface IWeapon {
    use(): string;
}

// entities/Sword.ts
import { injectable } from "inversify";

@injectable()
export class Sword implements IWeapon {
    use(): string {
        return "तलवार चलाओ!";
    }
}

// entities/Knight.ts
import { injectable, inject } from "inversify";
import { IWarrior } from "../interfaces/IWarrior";
import { IWeapon } from "../interfaces/IWeapon";

@injectable()
export class Knight implements IWarrior {
    private _weapon: IWeapon;

    constructor(@inject("IWeapon") weapon: IWeapon) {
        this._weapon = weapon;
    }

    fight(): string {
        return this._weapon.use() + " नाइट लड़ता है!";
    }
}

दोनों डिपेंडेंसी को रजिस्टर करें और इंजेक्टेड हथियार के साथ तैयार ऑब्जेक्ट प्राप्त करें:

container.bind<IWeapon>("IWeapon").to(Sword);
container.bind<IWarrior>("IWarrior").to(Knight);

const knight = container.get<IWarrior>("IWarrior");
console.log(knight.fight()); // "तलवार चलाओ! नाइट लड़ता है!"