IOC for TypeScript [英] IOC for TypeScript

问题描述

现在使用TypeScript，我们在JavaScript中有静态分析和许多OOP功能。
因此，现在也是时候在客户端逻辑中进行更好的单元测试了，同时我们需要IOC容器进行依赖注入，以使代码更易于测试...

那么，有人已经体验过这个主题，或者可能知道可以移植到TypeScript的打字稿或JavaScript框架的库吗？

解决方案

我开发了一个名为InversifyJS的IoC容器，它具有高级依赖注入功能，如上下文绑定。

您需要按照 3个基本步骤来使用它：

1。添加注释

注释API基于Angular 2.0：

 从inversify导入{injectable，inject}; 
 
 @injectable（）
类Katana实施IKatana {
 public hit（）{
 returncut！; 
} 
} 
 
 @injectable（）
类Shuriken实施IShuriken {
 public throw（）{
 returnhit！; 
} 
} 
 
 @injectable（）
类Ninja实现INinja {
 
 private _katana：IKatana; 
 private _shuriken：IShuriken; 
 
公共构造函数（
 @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来自inversify的{Kernel};来自./entities/ninja的
 
 import {Ninja}; 
 import {Katana}来自./entities/katana;来自./entities/shuriken的
 import {Shuriken}; 
 
 var kernel = new Kernel（）; 
 kernel.bind< INinja>（INinja）。to（Ninja）; 
 kernel.bind< IKatana>（IKatana）。to（Katana）; 
 kernel.bind< IShuriken>（IShuriken）。to（Shuriken）; 
 
导出默认内核; 
  

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）支持许多用例：

• 内核模块


• 内核中间件


• 使用类，字符串文字或符号作为依赖标识符


• 注入常量值


• 类构造函数的注入


• 注入工厂


• 自动出厂


• 注入提供商（异步工厂）


• 激活处理程序（用于注入代理）


• 多次注射


• 标记绑定


• 自定义标签装饰器


• 命名绑定


• 上下文绑定


• 友好例外（例如循环依赖）

您可以在 https://github.com/inversify/InversifyJS 了解更多信息。 / p>

With TypeScript now we have static analyze and many OOP features in JavaScript. So it's also time to have better unit tests in client side logic and as well we need IOC container for dependency injections to make code more testable...

So, have someone already experienced it this subject or maybe know libraries for typescript or JavaScript frameworks that can be porting to TypeScript?

解决方案

I have developed an IoC container called InversifyJS with advanced dependency injection features like contextual bindings.

You need to follow 3 basic steps to use it:

1. Add annotations

The annotation API is based on 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. Declare bindings

The binding API is based on 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. Resolve dependencies

The resolution API is based on Ninject:

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

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

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

The latest release (2.0.0) supports many use cases:

• Kernel modules
• Kernel middleware
• Use classes, string literals or Symbols as dependency identifiers
• Injection of constant values
• Injection of class constructors
• Injection of factories
• Auto factory
• Injection of providers (async factory)
• Activation handlers (used to inject proxies)
• Multi injections
• Tagged bindings
• Custom tag decorators
• Named bindings
• Contextual bindings
• Friendly exceptions (e.g. Circular dependencies)

You can learn more about it at https://github.com/inversify/InversifyJS

这篇关于IOC for TypeScript的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！