javascript - injector - Angular2 DI en Typescript. ¿Podemos usarlo en proyectos node.js/no angulares?

injectiontoken angular

Question

¿El contenedor de inyección de dependencia angular2 fue diseñado para uso independiente, y es posible usarlo para aplicaciones de servidor de mecanografía / javascript?

Abrí un problema el 16 de octubre ( https://github.com/angular/di.js/issues/108 ) sobre el proyecto di, que supongo supongo que debería pasar a v2. Aparentemente esto no fue posible. ¿Qué pasa con el nuevo angular2 di? ¿Puedo usarlo de forma independiente con proyectos js / es6 / ts?

Answer 1

A partir de Angular 2 RC.5, DI es una parte del paquete @angular/core . Para usos no angulares, Minko Gechev, miembro del equipo Angular, lo extrajo recientemente en el paquete de injection-js j.

Aquí hay un breve ES6, un ejemplo amigable con el nodo:

// may not be needed for injection-js and recent @angular/core versions
// if ES5-flavoured `Class` helper isn''t used
require(''reflect-metadata'');

const { Inject, Injector, ReflectiveInjector, OpaqueToken } = require(''@angular/core'');
// or ... = require(''injection-js'');

const bread = new OpaqueToken;
const cutlet = new OpaqueToken;

class Sandwich {
    constructor(bread, cutlet, injector) {
        const anotherBread = injector.get(''bread'');

        injector === rootInjector;
        bread === ''bread'';
        anotherBread === ''bread'';
        cutlet === ''cutlet'';
    }
}

Sandwich.parameters = [
    new Inject(bread),
    new Inject(cutlet),
    new Inject(Injector)
];

const rootInjector = ReflectiveInjector.resolveAndCreate([
    { provide: ''bread'', useValue: ''bread'' },
    { provide: bread, useValue: ''bread'' },
    { provide: cutlet, useValue: ''cutlet'' },
    Sandwich
]);

const sandwich = rootInjector.get(Sandwich);

Answer 2

Checkout ubiquits sources - de alguna manera integró DI de angular 2 en el back-end.

Si quieres una herramienta de inyección de dependencia sencilla pero poderosa e indolora para typedi mecanografiado y node.js. Funciona muy bien con interfaces angulares también. También revise otros repositorios de este autor, hay muchos componentes que lo ayudarán a crear aplicaciones de nodo utilizando TypeScript.

Answer 3

Hay un impresionante puerto de Angular DI: https://github.com/mgechev/injection-js

Answer 4

Lo dudo, no parece que haya sido extraído en un componente . Es un poco triste que los principales frameworks como Angular todavía tengan este enfoque monolítico. Me gustaría ver frameworks orientados a componentes como Symfony , pero JavaScript aún no está ahí.

Mientras tanto, tienes InversifyJS que no se ve mal.

Answer 5

Parece que alguien ha extraído la inyección de dependencia de Angular2 recientemente (enero de 2017), lo que le permite usarlo fuera del marco.

https://github.com/mgechev/injection-js

Answer 6

Por el momento, el código DI Angular 2.0 no parece estar listo para ser consumido por otras bibliotecas.

Me gustaría sugerir una alternativa. He desarrollado un contenedor IoC llamado InversifyJS con funciones avanzadas de inyección de dependencias, como enlaces contextuales. Funciona tanto en el nodo como en los navegadores y algunas partes de su API se basan en la Angular 2 DI API.

Debe seguir 3 pasos básicos para usarlo:

1. Agregue anotaciones

La API de anotación está basada en Angular 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. Declarar enlaces

La API de enlace se basa en 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. Resolver dependencias

La API de resolución se basa en Ninject:

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

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

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

La última versión (2.0.0) admite muchos casos de uso:

• JavaScript universal (funciona en Node.js y navegadores)
• Módulos Kernel
• Kernel middleware
• Use clases, cadenas literales o símbolos como identificadores de dependencia
• Inyección de valores constantes
• Inyección de constructores de clase
• Inyección de fábricas
• Auto fábrica
• Inyección de proveedores (fábrica asíncrona)
• Controladores de activación (utilizados para inyectar proxies)
• Inyecciones múltiples
• Encuadernaciones etiquetadas
• Decoradores de etiquetas personalizadas
• Enlaces nombrados
• Enlaces contextuales
• Excepciones amistosas (por ejemplo, dependencias circulares)

Puede obtener más información al respecto en InversifyJS