CIO dattiloscritto

Ho sviluppato un contenitore CIO chiamato InversifyJS con funzionalità avanzate di iniezione dipendenza come attacchi contestuali.

È necessario seguire 3 passi fondamentali per usarlo:

1. Aggiungere annotazioni

L'API di annotazione si basa su angolare 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. Dichiarare attacchi

L'API vincolante si riferiscono al 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. Risolvi dipendenze

L'API risoluzione si riferiscono al Ninject:

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

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

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

L'ultima versione (2.0.0) supporta molti casi di utilizzo:

• I moduli del kernel
• kernel middleware
• Utilizzare le classi, stringhe letterali o simboli come identificatori di dipendenza
• Iniezione di valori costanti
• Iniezione di costruttori della classe
• Iniezione di fabbriche
• fabbrica Auto
• Iniezione di fornitori (asincrona di fabbrica)
• gestori di attivazione (utilizzato per iniettare proxy)
• iniezioni multiple
• attacchi Tagged
• decoratori tag personalizzato
• attacchi Named
• attacchi contestuali
• Friendly eccezioni (ad esempio le dipendenze circolari)

Si può imparare di più riguardo a https://github.com/inversify/InversifyJS

Ho creato biblioteca DI per dattiloscritto - huject

https://github.com/asvetliakov/huject

Esempio:

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);

C'è un problema con le interfacce Carattere tipografico, però, ma ho 2 soluzioni (utilizzare la classe astratta o semplice come interfaccia)

Per il momento, è possibile utilizzare l'iniezione di dipendenza in JavaScript senza la parte del CIO. Spetta a voi se si scrive un resolver "manuale", o fabbriche, o qualunque modello DI preferite.

Quando viene adottato lo standard ECMAScript 6, può rendere il concetto di CIO possibile in JavaScript.

Abbiamo usato un semplice contenitore iniezione di dipendenza che utilizza AMD definiscono / richiedere - come sintassi. L'implementazione originale è a macchina, anche se il post sul blog di seguito presenta in pianura vecchio JavaScript.

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

E 'abbastanza semplice per definire le relazioni di dipendenza senza richiedere un po' di configurazione e supporta la risoluzione dipendenza circolare simile a requirejs.

Ecco un semplice esempio:

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

});

In alternativa si può semplicemente utilizzare alcun quadro e utilizzare classe come contenitore con le fabbriche oggetto come proprietà. È quindi possibile ereditare questa classe in test e di cambiamento fabbriche. Questo approccio è di tipo sicuro e non richiede alcuna decoratori, solo la registrazione di classi.

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

qualcosa di simile a questo è possibile:

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

@Service()
class SomeClass {

    someMethod() {
    }

}

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