टाइपप्रति के लिए आईओसी

मैं एक आईओसी कंटेनर प्रासंगिक बाइंडिंग जैसे उन्नत निर्भरता इंजेक्शन सुविधाओं के साथ InversifyJS कहा जाता है विकसित किया है।

आप पालन करने की आवश्यकता 3 बुनियादी कदम के लिए इसका इस्तेमाल करने के लिए:

1. टिप्पणियां जोड़ें

एनोटेशन एपीआई कोणीय 2.0 पर आधारित है:

import { injectable, inject } from "inversify";

@injectable()
class Katana implements IKatana {
    public hit() {
        return "cut!";
    }
}

@injectable()
class Shuriken implements IShuriken {
    public throw() {
        return "hit!";
    }
}

@injectable()
class Ninja implements INinja {

    private _katana: IKatana;
    private _shuriken: IShuriken;

    public constructor(
        @inject("IKatana") katana: IKatana,
        @inject("IShuriken") shuriken: IShuriken
    ) {
        this._katana = katana;
        this._shuriken = shuriken;
    }

    public fight() { return this._katana.hit(); };
    public sneak() { return this._shuriken.throw(); };

}

2. प्रचार बाइंडिंग

बाध्यकारी एपीआई Ninject पर आधारित है:

import { Kernel } from "inversify";

import { Ninja } from "./entities/ninja";
import { Katana } from "./entities/katana";
import { Shuriken} from "./entities/shuriken";

var kernel = new Kernel();
kernel.bind<INinja>("INinja").to(Ninja);
kernel.bind<IKatana>("IKatana").to(Katana);
kernel.bind<IShuriken>("IShuriken").to(Shuriken);

export default kernel;

3. हल ​​निर्भरता

संकल्प एपीआई Ninject पर आधारित है:

import kernel = from "./inversify.config";

var ninja = kernel.get<INinja>("INinja");

expect(ninja.fight()).eql("cut!"); // true
expect(ninja.sneak()).eql("hit!"); // true

नवीनतम रिलीज (2.0.0) कई उपयोग के मामलों का समर्थन करता है:

• कर्नेल मॉड्यूल
• कर्नेल मिडलवेयर
• निर्भरता पहचानकर्ता के रूप में कक्षाएं, स्ट्रिंग शाब्दिक या प्रतीकों का उपयोग
• निरंतर मूल्यों इंजेक्शन
• वर्ग कंस्ट्रक्टर्स इंजेक्शन
• कारखानों के इंजेक्शन
• ऑटो कारखाना
• प्रदाताओं के इंजेक्शन (async कारखाना)
• सक्रियण संचालकों (प्रॉक्सी इंजेक्षन करते थे)
• मल्टी इंजेक्शन
• टैग की गईं बाइंडिंग
• कस्टम टैग सज्जाकार
• नामांकित बाइंडिंग
• प्रासंगिक बाइंडिंग
• अनुकूल अपवाद (जैसे सर्कुलर निर्भरता)

आपको कम से इसके बारे में अधिक सीख सकते हैं https://github.com/inversify/InversifyJS

मैं टाइपप्रति के लिए डि पुस्तकालय बनाया है - huject

https://github.com/asvetliakov/huject

उदाहरण:

import {Container, FactoryMethod, ConstructorInject, Inject} from 'huject';
class FirstService {
   public constructor(param: number) {}
}
class SecondService {
}

@ConstructorInject
class MyController {
    @Inject
    public service: FirstService;

    public second: SecondService;
    public constructor(service: SecondService) {
        this.second = service;
    }
    ...
}
container.setAllowUnregisteredResolving(true);
container.register(FirstService, [10]); // Register constructor arguments

// FirstService and SecondService will be resolved for container instance
let controller = container.resolve(MyController);

वहाँ टाइपप्रति इंटरफेस के साथ एक समस्या यह है, लेकिन मैं 2 समाधान (इंटरफेस के रूप में सार या साधारण वर्ग का उपयोग करें) है

अभी के लिए, आप आईओसी हिस्सा बिना जावास्क्रिप्ट में निर्भरता इंजेक्शन का उपयोग कर सकते हैं। यह है कि क्या आप एक "मैन्युअल" रिसोल्वर या कारखानों, या जो कुछ भी डि पैटर्न आप पसंद करते हैं लिखने आप पर निर्भर है।

जब ECMAScript 6 मानक को अपनाया है, यह जावास्क्रिप्ट में संभव आईओसी की अवधारणा कर सकते हैं।

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

http://blog.coolmuse.com/2012/11/11/a-simple-javascript-dependency-injection-container/

यह विन्यास का एक समूह की आवश्यकता के बिना निर्भरता संबंधों को परिभाषित करने के लिए बिल्कुल स्पष्ट है, और requirejs के समान सर्कुलर निर्भरता संकल्प का समर्थन करता है।

यहाँ एक सरल उदाहरण है:

// create the kernel
var kernel = new ServiceKernel();

// define service1
kernel.define("service1", function() {

    // service1 has a function named foo
    return {
        foo: function () { return "foo"; }
    }

});

// define service2, which depends on service1
kernel.define("service2", ["service1"], function(service1) {

    // service2 has a function named foobar
    return {
        foobar : function() { return service1.foo() + "bar"; }
    }

});

// get service2 instance 
var service2 = kernel.require("service2");
service2.foobar();  // returns "foobar"

// get both service1 and service2 instances
kernel.require(["service1", "service2"], function(service1, service2) {

    alert(service1.foo() + service2.foobar()); // displays foofoobar

});

वैकल्पिक रूप से आप बस कोई ढांचे का उपयोग और गुण के रूप में वस्तु कारखानों के साथ कंटेनर के रूप में वर्ग का उपयोग कर सकते हैं। फिर आप परीक्षण और परिवर्तन कारखानों में इस वर्ग के वारिस कर सकते हैं। यह दृष्टिकोण सुरक्षित टाइप करें और किसी भी सज्जाकार, बस वर्गों के पंजीकरण की आवश्यकता नहीं है।

class B {
    echo() {
        alert('test');
    }   
}

class A {
    constructor(private b: B) {
        b.echo();
    }
}

class Container {
    A = () => new A(this.B());
    B = singleton(() => new B()); 
}

var c = new Container();
var a = c.A();

// singleton helper:

function memoize<T>(factory: () => T): () => T  {
    var memo: T = null;
    return function () {
        if(!memo) {
            memo = factory();
        }
        return memo;
    };
}

var singleton = memoize;

चेकआउट https://github.com/typestack/typedi

कुछ इस तरह संभव है:

import "reflect-metadata";
import {Service, Container} from "typedi";

@Service()
class SomeClass {

    someMethod() {
    }

}

let someClass = Container.get(SomeClass);
someClass.someMethod();