ΔΟΕ για την γραφομηχανή

Έχω αναπτύξει ένα δοχείο ΔΟΕ κάλεσε InversifyJS με προηγμένα χαρακτηριστικά ένεση εξάρτηση, όπως συμφραζόμενα συνδέσεις.

Θα χρειαστεί να ακολουθήσετε 3 βασικά βήματα για να το χρησιμοποιήσετε:

1. Προσθέστε σχολιασμούς

Ο σχολιασμός API βασίζεται σε Γωνιακή 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. δέστρες αναγνωρίσει

Η API δεσμευτική βασίζεται σε 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. εξαρτήσεις Επίλυση

Το API ανάλυση βασίζεται σε 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) υποστηρίζει πολλές περιπτώσεις χρήσης:

• modules του πυρήνα
• πυρήνα middleware
• Χρησιμοποιήστε τις κατηγορίες, κατεξοχήν συμβολοσειρά ή σύμβολα, όπως αναγνωριστικά εξάρτηση
• Ένεση σταθερές τιμές
• Ένεση της κατηγορίας κατασκευαστών
• Ένεση εργοστάσια
• Auto εργοστάσιο
• Ένεση των παρόχων (εργοστασίου async)
• χειριστές ενεργοποίησης (που χρησιμοποιείται για την ένεση proxies)
• πολλαπλών ενέσεων
• Tagged δέστρες
• διακοσμητές Προσαρμοσμένη ετικέτα
• Το όνομά δέστρες
• συμφραζόμενα συνδέσεις
• Φιλικό εξαιρέσεις (π.χ. Εγκύκλιος εξαρτήσεις)

Μπορείτε να μάθετε περισσότερα γι 'αυτό στο https://github.com/inversify/InversifyJS

Έχω δημιουργήσει βιβλιοθήκη DI για γραφομηχανή - 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 λύσεις (χρήση αφηρημένη ή απλή κλάση ως διεπαφή)

Προς το παρόν, μπορείτε να χρησιμοποιήσετε εξαρτήσεων ένεση σε JavaScript, χωρίς το τμήμα της ΔΟΕ. Είναι στο χέρι σας αν μπορείτε να γράψετε ένα «εγχειρίδιο» αναλυτή, ή εργοστάσια, ή ό, τι DI σχέδιο που προτιμάτε.

Όταν εγκριθεί η τυπική ECMAScript 6, μπορεί να κάνει η έννοια της ΔΟΕ είναι δυνατόν σε JavaScript.

Έχουμε χρησιμοποιώντας ένα απλό δοχείο ψεκασμού εξάρτηση που χρησιμοποιεί AMD ορίζουν / απαιτούν - όπως η σύνταξη. Η αρχική εφαρμογή είναι στη γραφομηχανή, αν και η δημοσίευση στο blog κάτω από αυτό παρουσιάζει σε απλή παλιά JavaScript.

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;

checkout https://github.com/typestack/typedi

κάτι τέτοιο είναι δυνατό:

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

@Service()
class SomeClass {

    someMethod() {
    }

}

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