typedi 强大的javascript以及typescript 依赖注入框架

鹿海

typedi 是typestack团队提供的依赖注入解决方案，对于typescript 我们可以使用注解的开发方式，官方的文档也比较详细

javascript 使用

• 基于函数的服务注入

var Service = require("typedi").Service;

var Container = require("typedi").Container;

​

var PostRepository = Service(() => ({

    getName() {

        return "hello from post repository";

    }

}));

​

var PostManager = Service(() => ({

    getId() {

        return "some post id";

    }

}));

​

class PostQueryBuilder {

    build() {

        return "SUPER * QUERY";

    }

}

​

var PostController = Service([

    PostManager,

    PostRepository,

    PostQueryBuilder

], (manager, repository, queryBuilder) => {

    return {

        id: manager.getId(),

        name: repository.getName(),

        query: queryBuilder.build()

    };

});

​

var postController = Container.get(PostController);

console.log(postController);

 

 

• 基于名称的注入

var Container = require("typedi").Container;

class BeanFactory {

    constructor(container){}

    create() {

      console.log("BeanFactory")

    }

}

​

class SugarFactor {

    constructor(container){}

    create() {

        console.log("SugarFactory")

    }

}

​

class WaterFactory{

    constructor(container){}

    create() {

        console.log("WaterFactory")

    }

}

​

class CoffeeMaker {

​

    constructor(container) {

        this.beanFactory = container.get("bean.factory");

        this.sugarFactory = container.get("sugar.factory");

        this.waterFactory = container.get("water.factory");

    }

​

    make() {

        this.beanFactory.create();

        this.sugarFactory.create();

        this.waterFactory.create();

    }

​

}

​

Container.set("bean.factory", new BeanFactory(Container));

Container.set("sugar.factory", new SugarFactory(Container));

Container.set("water.factory", new WaterFactory(Container));

Container.set("coffee.maker", new CoffeeMaker(Container));

​

var coffeeMaker = Container.get("coffee.maker");

coffeeMaker.make();

 

 

typescript 使用

对于typescript 的使用我们可以利用ts提供的强大类型能力,以及注解可以编写强大的功能

• 简单service注解
  项目结构

 

ts

└── service

    ├── SomeClass.ts

    └── demo.ts

 

 

demo.ts

import {Container} from "typedi";

import {SomeClass } from "./SomeClass"

let someClass = Container.get(SomeClass);

someClass.someMethod();

 

 

SomeClass.ts

import "reflect-metadata";

import {Service} from "typedi";

​

@Service()

class SomeClass {

​

    someMethod() {

        console.log("call from service")

    }

​

}

​

export default SomeClass

export {

    SomeClass

}

 

 

• 基于属性的注入

import "reflect-metadata"

​

import {Container, Inject, Service} from "typedi";

​

@Service()

class BeanFactory {

    create() {

        console.log("BeanFactory")

    }

}

​

@Service()

class SugarFactory {

    create() {

        console.log("SugarFactory")

    }

}

​

@Service()

class WaterFactory {

    create() {

        console.log("WaterFactory")

    }

}

​

@Service()

class CoffeeMaker {

​

    @Inject()

    beanFactory: BeanFactory;

​

    @Inject()

    sugarFactory: SugarFactory;

​

    @Inject()

    waterFactory: WaterFactory;

​

    make() {

        this.beanFactory.create();

        this.sugarFactory.create();

        this.waterFactory.create();

    }

​

}

​

let coffeeMaker = Container.get(CoffeeMaker);

coffeeMaker.make();

 

 

• 基于服务名的注入

import "reflect-metadata"

import {Container, Service, Inject} from "typedi";

interface Factory {

    create(): void;

}

​

@Service("bean.factory")

class BeanFactory implements Factory {

    create() {

        console.log("BeanFactory")

    }

}

​

@Service("sugar.factory")

class SugarFactory implements Factory {

    create() {

        console.log("SugarFactory")

    }

}

​

@Service("water.factory")

class WaterFactory implements Factory {

    create() {

        console.log("WaterFactory")

    }

}

​

@Service("coffee.maker")

class CoffeeMaker {

​

    beanFactory: Factory;

    sugarFactory: Factory;

​

    @Inject("water.factory")

    waterFactory: Factory;

​

    constructor(@Inject("bean.factory") beanFactory: BeanFactory,

                @Inject("sugar.factory") sugarFactory: SugarFactory) {

        this.beanFactory = beanFactory;

        this.sugarFactory = sugarFactory;

    }

​

    make() {

        this.beanFactory.create();

        this.sugarFactory.create();

        this.waterFactory.create();

    }

​

}

​

let coffeeMaker = Container.get<CoffeeMaker>("coffee.maker");

coffeeMaker.make();

 

 

• 循环依赖的处理
  对于循环依赖我们需要指定类型，如下：

 

// Car.ts

@Service()

export class Car {

    @Inject()

    engine: Engine;

}

​

// Engine.ts

@Service()

export class Engine {

    @Inject()

    car: Car;

}

​

应该为:

// Car.ts

@Service()

export class Car {

    @Inject(type => Engine)

    engine: Engine;

}

​

// Engine.ts

@Service()

export class Engine {

    @Inject(type => Car)

    car: Car;

}

 

 

• 注入继承

// Car.ts

@Service()

export abstract class Car {

​

    @Inject()

    engine: Engine;

​

}

​

// Engine.ts

@Service()

export class Bus extends Car {

​

    // you can call this.engine in this class

}

 

 

• 服务组
  方便组合依赖的服务

 

// Factory.ts

import "reflect-metadata"

import {Container, Service,Token} from "typedi";

​

export interface Factory {

    create(): any;

}

​

// FactoryToken.ts

export const FactoryToken = new Token<Factory>("factories");

​

// BeanFactory.ts

@Service({ id: FactoryToken, multiple: true })

export class BeanFactory implements Factory {

​

    create() {

        console.log("bean created");

    }

​

}

​

// SugarFactory.ts

@Service({ id: FactoryToken, multiple: true })

export class SugarFactory implements Factory {

​

    create() {

        console.log("sugar created");

    }

​

}

​

// WaterFactory.ts

@Service({ id: FactoryToken, multiple: true })

export class WaterFactory implements Factory {

​

    create() {

        console.log("water created");

    }

​

}

​

// app.ts

// now you can get all factories in a single array

Container.import([

    BeanFactory,

    SugarFactory,

    WaterFactory,

]);

const factories = Container.getMany(FactoryToken); // factories is Factory[]

factories.forEach(factory => factory.create());

 

说明

typedi 功能还是很强大，是web开发中的一个利器

参考资料

https://github.com/typestack/typedi
https://github.com/rongfengliang/typedi-learning

来源：https://www.cnblogs.com/rongfengliang/p/11637595.html