关于node.js:控制反转Ioc依赖注入DI如何实现的

牛顿曾说：如果说我看得比他人更远些，那是因为我站在伟人的肩膀上。

浏览优质框架库的源码，能学到不少，更有甚者基于此发明了更优良的，大抵就是如此。

midwayjs 曾经忘了是怎么意识它的了。印象中是个 nodejs 的优质框架，看了介绍，很厉害！！！

Midway – 一个面向未来的云端一体 Node.js 框架

<img src=”/img/bVcR2g3″ alt=”midwayjs”>

好不好用，用过才晓得。一边浏览应用文档，一边建个本地我的项目感受一下。用着真的是很“高效”呢。

midway 外围”依赖注入“代码写法

默认应用 egg 作为下层框架（反对是 express, koa），这么创立我的项目：

$ npm -v

# 如果是 npm v6
$ npm init midway --type=web hello_koa

# 如果是 npm v7
$ npm init midway -- --type=web hello_koa

应用：

controller/api.ts

import {Inject, Controller, Get, Provide, Query} from '@midwayjs/decorator';
import {Context} from 'egg';
import {UserService} from '../service/user';

@Provide()
@Controller('/api')
export class APIController {@Inject()
  ctx: Context;

  @Inject()
  userService: UserService;

  @Get('/get_user')
  async getUser(@Query() uid) {const user = await this.userService.getUser({ uid});
    return {success: true, message: 'OK', data: user};
  }
}

service/user.js

import {Provide} from '@midwayjs/decorator';
import {IUserOptions} from '../interface';

@Provide()
export class UserService {async getUser(options: IUserOptions) {
    return {
      uid: options.uid,
      username: 'mockedName',
      phone: '12345678901',
      email: 'xxx.xxx@xxx.com',
    };
  }
}

书写 node 我的项目，controller、service、router 这些都必不可少。然而当初只须要向下面那样，即可。很疾速的就定义好一个 get 申请了：localhost:7001/api/get_user。不再须要解决 router、controller、service 间接的绑定映射，也不须要初始化这个 Class（new），而后将实例放在须要调用的中央。

轻轻通知你，以下代码(下面的代码革新)，只有在 src 目录下，不论文件是什么名字，都能够通过 localhost:7001/api/get_user 拜访到呢。

import {Inject, Controller, Get, Provide, Query} from '@midwayjs/decorator';

@Provide()
export class UserService {async getUser(options) {
    return {
      uid: options.uid,
      username: 'mockedName',
      phone: '123456789022',
      email: 'xxx.xxx@xxx.com',
    };
  }
}

@Provide()
@Controller('/api')
export class APIController {@Inject()
  userService: UserService;

  @Get('/get_user')
  async getUser(@Query() uid: string) {const user = await this.userService.getUser({ uid});
    return {success: true, message: 'OK', data: user};
  }
}

很神奇吧。外表上看和平时写的代码不一样的中央，就只有装璜器：@Controller、@Get、@Provide,@Inject。那么是这些装璜器背地做了什么，比方轻轻实例化并进行了实例的绑定？

持续浏览文档，晓得是通过 依赖注入 实现的。依赖注入装璜器和规定如下：

依赖注入装璜器作用：

@Provide 装璜器的作用：

1. 这个 Class，被依赖注入容器托管，会主动被实例化（new）
2. 这个 Class，能够被其余在容器中的 Class 注入

而对应的 @Inject 装璜器，作用为：

1. 在依赖注入容器中，找到对应的属性名，并赋值为对应的实例化对象

@Provide 和 @Inject 装璜器是有参数的，并且他们是成对呈现。
@Inject 的类中，必须有 @Provide 才会失效。

依赖注入约定：

@Provide 和 @Inject 装璜器是有可选参数的，并且他们是成对呈现。

默认状况下：

1. @Provide 取 类名的驼峰字符串 作为依赖注入标识符
2. @Inject 依据 规定 获取 key

规定如下：

1. 如果装璜器蕴含参数，则以 参数字符串 作为 key
2. 如果没有参数，标注的 TS 类型为 Class，则将类 @Provide 的 key 作为 key
3. 如果没有参数，标注的 TS 类型为非 Class，则将 属性名 作为 key

依赖注入的代码写法，能缩小不少代码量，日常开发十分高效。那么依赖注入是如何实现的呢？值得摸索一下！

依赖注入原理。文章中提供了一篇扩大浏览的文章：[这一次，教你从零开始写一个 IoC 容器](https://mp.weixin.qq.com/s/g0…

看了下面的文档，大抵是：创立个容器，在适合的机会，扫描文件，收集有 @Provide 的类，在 @Inject 的中央进行实例化绑定。

了解依赖注入

看之前，了解下：

依赖注入解决的问题是：解耦。

<img src=”/img/bVcR2g4″ alt=”ioc”>

(图是用 excalidraw 画的，简略的图用着还是挺不便的)

如图所示，思考下：此时若 C 实例化须要一个参数，则须要从 A 始终传递到 C，造成了强耦合。而借助了 IOC 思维后，就可解耦，升高依赖。

思维就是：间接传递对象，对象的属性和办法的更改，对象的所有操作外部本人消化。内部要改对象，必须调用对象提供的办法。函数传参的时候就是这么写的。

传递的对象，如果是类，那就是实例化后的对象。在须要应用的中央能通过对象间接拜访到。如果应用的也是类，能够再将实例化的对象绑定一次。

这个过程能够有不同的实现计划：

比方 midwayjs 是通过 @Provide、@Inject 先标注模块之间的依赖关系，再通过加载程序的时候扫描 @Provide 收集模块（要用的模块 A，被应用的模块 B）最初通过 @Inject 将模块 B 实例化后绑定到模块 A 上，模块 A 就能够间接应用了。

比方 koa 的 use 就是绑定插件到 app 上，app 就能够间接应用插件了，插件的操作本人消化。可浏览从前端中的 IOC 理念了解 koa 中的 app.use()

过程中须要治理收集到的模块，就会波及到容器，用容器收集到一块，方便管理，也不便读写。

midway 依赖注入局部源码解读

偶合之下，搜文档 midwayjs 文档，找到了之前版本的 midwayjs，看到外面对于依赖注入的阐明：默认应用 injection 这个包来做依赖注入, 这个包也是 MidwayJs 团队依据业界已有的实现而产出的自研产品，它除了常见的依赖了注入之外，还满足了 Midway 本身的一些非凡需要。强烈推荐浏览文档了解。

一开始应该是这样设计的，前面把它融入到 midwayjs(2.x) 中了。大部分代码都是统一的，外围是一样的。大部分代码文件比对了解如下：

1. midwayjs/packages/core/src/context/ vs injection/src/ 的 ioc 容器

ioc 容器是实现依赖注入的要害。

IoC 容器就像是一个对象池，治理着每个对象实例的信息（Class Definition），所以用户无需关怀什么时候创立，当用户心愿拿到对象的实例 (Object Instance) 时，能够间接拿到依赖对象的实例，容器会 主动将所有依赖的对象都主动实例化。次要有以下几种，别离解决不同的逻辑。

• AppliationContext 根底容器，提供了根底的减少定义和依据定义获取对象实例的能力
• MidwayContainer 用的最多的容器，做了下层封装，通过 bind 函数可能不便的生成类定义，midway 从此类开始扩大
• RequestContext 用于申请链路上的容器，会主动销毁对象并依赖另一个容器创立实例。

其中 ApplicationContext 是基类，而 MidwayContainer、RequestContext 继承于它。

1. midwayjs/packages/core/src/definitions vs injection/src/base
   依赖注入的外围实现，加载对象的 class，同步、异步创建对象实例化，对象的属性绑定等。
2. midwayjs/packages/decorator/src/annotation vs injection/src/annotation
   蕴含装璜器 provide.ts、inject.ts 的实现，在 midwayjs 中是有一个装璜器治理类 DecoratorManager, 用来治理 midwayjs 的所有装璜器。

@provide() 的作用是简化绑定，能被 IoC 容器主动扫描，并绑定定义到容器上，对应的逻辑是 绑定对象定义(ObjectDefinition.ts)。

@inject() 的作用是将容器中的定义实例化成一个对象，并且绑定到属性中，这样，在调用的时候就能够拜访到该属性。

留神，注入的机会为结构器（new）之后，所以在构造方法 (constructor) 中是无奈获取注入的属性的，如果要获取注入的内容，能够应用 结构器注入

父类的属性应用 @inject() 装璜器装璜，子类实例会失去装璜后的属性。

其中查找类的原型应用 reflect-metadata 仓库的 OrdinaryGetPrototypeOf 办法，应用 recursiveGetPrototypeOf 办法以数组模式返回该类的所有原型。

function recursiveGetPrototypeOf(target: any): any[] {const properties = [];
  let parent = ordinaryGetPrototypeOf(target);
  while (parent !== null) {properties.push(parent);
    parent = ordinaryGetPrototypeOf(parent);
  }
  return properties;
}

1. mideayjs/packages/core/src/context/managedResolverFactory.ts vs injection/src/factory/common/managedResolverFactory.ts
   次要定义了一个解析工厂类：ManagedResolverFactory，用来创建对象（同步 create 和异步 createAsync），解析对象的参数，生命周期钩子事件，如创立单例初始化完结事件，遍历依赖树判断是否循环依赖。

其余阐明：

1. 基准测试

injection 的基准测试是用 inversify 这个比拟驰名的 ioc 容器库做测试的。而前面的 midwayjs 中曾经放弃了，间接用它本人的逻辑。

1. 作用域：

Singleton 单例，全局惟一（过程级别）
Request 默认，申请作用域，生命周期随着申请链路，在申请链路上惟一，申请完结立刻销毁
Prototype 原型作用域，每次调用都会反复创立一个新的对象。

在这三种作用域中，midway 的默认作用域为 申请作用域

基于 TypeScript 的管制反转、依赖注入了解及简略实现

了解了原理，也看了源码，实现个简略的。

只有能实现后能像利用 injection 解耦的案例一样，能通过 c.a 获取到类 A 的属性和办法，就示意示意根本实现了依赖注入。

// 应用 IoC
import {Container} from 'injection';
import {A} from './A';
import {B} from './B';
const container = new Container();
container.bind(A);
container.bind(B);

class C {constructor() {this.a = container.get('a');
    this.b = container.get('b');
  }
}

补充下前置常识，Reflect-metadata

• es7:reflect
• github:reflect-metadata

Reflect Metadata 是 ES7 的一项提案，次要用于在申明阶段增加和读取元数据，TypeScript 1.5+ 反对该性能。

元数据能够被视为无关类和类的某些属性的描述性信息，实质上不会影响类的行为，然而你能够设置一些预约义的数据到类，并依据元数据对类进行某些操作。

Reflect Metadata 的用法非常简单，首先须要装置该 reflect-metadata 库：

npm i reflect-metadata --save

而后在 tsconfig.json 的 emitDecoratorMetadata 须要中配置 true。

而后，咱们能够应用 Reflect.defineMetadata 和 定义并获取元数据 Reflect.getMetadata，例如：

import 'reflect-metadata';

const CLASS_KEY = 'ioc:key';

function ClassDecorator() {return function (target: any) {
    Reflect.defineMetadata(CLASS_KEY, {metaData: 'metaData',}, target);

    return target;
  }
}

@ClassDecorator()
class D {constructor(){}}

console.log(Reflect.getMetadata(ClASS_KEY, D)); // => {metaData: 'metaData'}

应用 Reflect，咱们能够标记任何类，并将非凡操作利用于标记化的类。

应用：

src/ioc/demo/a.ts

import {Provider} from "../provider"; // 需实现
import {Inject} from "../inject"; // 需实现
import B from './b'
import C from './c'

@Provider('a')
export default class A {@Inject()
  private b: B

  @Inject()
  c: C

  print () {this.c.print()
  }
}

src/ioc/demo/b.ts

import {Provider} from '../provider' // 需实现

@Provider('b', [10])
export default class B {
  n: number
  constructor (n: number) {this.n = n}
}

src/ioc/demo/c.ts

import {Provider} from '../provider' // 需实现

@Provider()
export default class C {print () {console.log('hello')
  }
}

应用就可和 midwayjs 统一。能够看到不再有手动实例化，且能够主动解决要注册的类，且要注入的属性。而且实例都由类自身保护，更改的话，不须要改其余文件。

src/ioc/index.ts

import {Container} from './container' // 治理 元信息
import {load} from './load' // 程序加载，负责扫描，@Provide、@Inject 相应的实例化及绑定解决

export default function () {const container = new Container()
  const path = './src/ioc/demo'
  load(container, path)

  const a:any = container.get('a')
  console.log(a); // A => {b: B {n: 10}}
  a.c.print() // hello}

因为简略版的并未将容器和路由绑定，所以这么拜访了

实现：

因为在程序启动时，须要晓得哪些类须要注册到容器中，所以须要在定义的类的元数据后附加一些非凡标记，这样就能够通过扫描辨认进去。用装璜器 Provider 来对须要注册的类进行标记，被标记的类能被其余类应用。

src/ioc/provider.ts

import 'reflect-metadata'
import * as camelcase from 'camelcase'
export const class_key = 'ioc:tagged_class'

// Provider 装璜的类，表明是要注册到 Ioc 容器中
export function Provider (identifier?: string, args?: Array<any>) {return function (target: any) {
    // 驼峰命名，这个的目标是，注解的时候退出不传，就用类名的驼峰式
    identifier = identifier ?? camelcase(target.name)

    Reflect.defineMetadata(class_key, {
      id: identifier, // key，用来注册 Ioc 容器
      args: args || [] // 实例化所需参数}, target)
    return target
  }
}

须要晓得类的哪些属性须要被注入，因而定义 Inject 装璜器来标记。

src/ioc/inject.ts

// 将绑定的类注入到什么中央
import 'reflect-metadata'

export const props_key = 'ioc:inject_props'

export function Inject () {return function (target: any, targetKey: string) {
    // 注入对象
    const annotationTarget = target.constructor
    let props = {}
    // 同一个类，多个属性注入类
    if (Reflect.hasOwnMetadata(props_key, annotationTarget)) {props = Reflect.getMetadata(props_key, annotationTarget)
    }

    props[targetKey] = {value: targetKey}

    Reflect.defineMetadata(props_key, props, annotationTarget)
  }
}

容器必须具备两个性能，即注册实例并获取它们。很天然会想到 Map，可用于实现一个简略的容器：

src/ioc/container.ts

import 'reflect-metadata'
import {props_key} from './inject'

export class Container {bindMap = new Map()

  // 绑定类信息
  bind(identifier: string, registerClass: any, constructorArgs: any[]) {this.bindMap.set(identifier, {registerClass, constructorArgs})
  }

  // 获取实例，将实例绑定到须要注入的对象上
  get<T>(identifier: string): T {const target = this.bindMap.get(identifier)
    if (target) {const { registerClass, constructorArgs} = target
      // 等价于 const instance = new A([...constructorArgs]) // 假如 registerClass 为定义的类 A
      // 对象实例化的另一种形式，new 前面须要跟大写的类名，而上面的形式能够不必，能够把一个类赋值给一个变量，通过变量实例化类
      const instance = Reflect.construct(registerClass, constructorArgs)

      const props = Reflect.getMetadata(props_key, registerClass)
      for (let prop in props) {const identifier = props[prop].value
        // 递归获取 injected object
        instance[prop] = this.get(identifier)
      }
      return instance
    }
  }
}

对于 Reflect.construct(target, args, newTarget): 办法的行为有点像 new 操作符 构造函数，相当于运行 new target(…args)。

var obj = new Foo(...args);
var obj = Reflect.construct(Foo, args);

在启动时扫描所有文件，获取文件导出的所有类，而后依据元数据进行绑定。假如没有嵌套目录，实现如下：

src/ioc/load.ts

import * as fs from 'fs'
import {resolve} from 'path'
import {class_key} from './provider'

// 启动时扫描所有文件，获取定义的类，依据元数据进行绑定
/**
 * 单层目录扫描实现
 * @param container: the global Ioc container
 */
export function load(container, path) {const list = fs.readdirSync(path)
  for (const file of list) {if (/\.ts$/.test(file)) {const exports = require(resolve(path, file))

      for (const m in exports) {const module = exports[m]
        if (typeof module === 'function') {const metadata = Reflect.getMetadata(class_key, module)
          // register
          if (metadata) {container.bind(metadata.id, module, metadata.args)
          }
        }
      }
    }
  }
}

在下面的简略版的根底上，实现 api-get 解决

能像一开始介绍的 midwayjs 应用形式统一。

次要是减少装璜器 @Controller、@Get、@Query，及相应的解决，具体看上面实现。

应用

src/reqIoc/demo/a.ts

import {Provider} from "../provider";
import {Inject} from "../inject";
import {Controller} from '../Controller'
import {Get, Query} from '../request'
import B from './b'

@Provider()
@Controller('/api')
export class A {@Inject()
  b: B;

  @Get('/b')
  printB(@Query() id, @Query() name) {const bProps:any = this.b.getProps(id, name);
    bProps.className = 'b'
    return {success: true, message: 'OK', data: bProps};
  }

  @Get('/c')
  printC(@Query() id) {const bProps:any = this.b.getProps(id);
    bProps.className = 'c'
    return {success: true, message: 'OK', data: bProps};
  }
}

src/reqIoc/demo/b.ts

import {Provider} from '../provider'

@Provider()
export default class B {getProps (id?: string, name?: string) {
    return {
      id: id || 'mock',
      name: name || 'mock',
    };
  }
}

能通过浏览器 http://localhost:3000/api/b?id=12&name=n 看到以下数据

{
  success: true,
  message: "OK",
  data: {
    id: "12",
    name: "n",
    className: "b"
  }
}

和下面的简略版统一，须要初始化扫描，进行数据的解决。不一样的是，没有了数据的获取响应，只有扫描。数据的获取响应通过接口方式出现。

reqIoc/frame.ts

import {Container} from './container'
import {load} from './load'

export default function (ctx) {const container = new Container()
  const path = './src/reqIoc/demo'
  load(container, path, ctx)
}

实现

在根底版上，次要减少了三个装璜器 @Controller、@Get、@Query，原有装璜器@Provider、@Inject 代码逻辑不变。

对于实现，想看源码的可参考：

• @Controller: midwayjs/packages/decorator/web/controller.ts
• @Get: midwayjs/packages/decorator/web/paramMapping.ts
• @Query: midwayjs/packages/decorator/web/requestMapping.ts

src/reqIoc/controller.ts

import 'reflect-metadata'
export const class_key = 'ioc:controller_class'

export function Controller (prefix = '/') {return function (target: any) {

    const props = {prefix}

    Reflect.defineMetadata(class_key, props, target)
    return target
  }
}

次要就是存一下前缀，比方/api

src/reqIoc/request.ts

// 将绑定的类注入到什么中央
import 'reflect-metadata'

export const props_key = 'ioc:request_method'
export const params_key = 'ioc:request_method_params'

// 装璜的是类办法，target：类，targetKey: 类的办法名
export function Get (path?: string) {return function (target: any, targetKey: string) {
    // 注入对象
    const annotationTarget = target.constructor

    let props = []
    // 同一个类，多个办法
    if (Reflect.hasOwnMetadata(props_key, annotationTarget)) {props = Reflect.getMetadata(props_key, annotationTarget)
    }

    const routerName = path ?? ''

    props.push({
      method: 'GET',
      routerName,
      fn: targetKey
    })

    Reflect.defineMetadata(props_key, props, annotationTarget)
  }
}

// 装璜的是类办法的入参，index 代表第几个参数
export function Query () {return function (target: any, targetKey: string, index: number) {
    // 注入对象
    const annotationTarget = target.constructor

    const fn = target[targetKey]
    // 函数的参数
    const args = getParamNames(fn)
    // 拿到绑定的参数名；index
    let paramName = ''
    if (fn.length === args.length && index < fn.length) {paramName = args[index]
    }

    let props = {}
    // 同一个类，多个办法
    if (Reflect.hasOwnMetadata(params_key, annotationTarget)) {props = Reflect.getMetadata(params_key, annotationTarget)
    }

    // 同一办法，多个参数
    const paramNames = props[targetKey] || []
    paramNames.push({type: 'query', index, paramName})

    props[targetKey] = paramNames

    Reflect.defineMetadata(params_key, props, annotationTarget)
  }
}

const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
/**
 * get parameter from function
 * @param func 
 */
export function getParamNames(func): string[] {const fnStr = func.toString().replace(STRIP_COMMENTS)
  let result = fnStr.slice(fnStr.indexOf('(') + 1, fnStr.indexOf(')')).split(',').map(content => content.trim().replace(/\s?=.*$/, ''))

  if (result.length === 1 && result[0] === '') {result = []
  }
  return result
}

reqIoc/container.ts

bindReq(key: string, list: any) {this.bindMap.set(key, list)
}

getReq(key: string) {return this.bindMap.get(key)
}

在原有代码中减少以上办法。

load.ts

import * as fs from 'fs'
import {resolve} from 'path'
import {class_key} from './provider'
import {class_key as controller_class_key} from './controller'
import {props_key, params_key} from './request'

const req_mthods_key = 'req_methods'
const joinSymbol = '_|_'

// 启动时扫描所有文件，获取定义的类，依据元数据进行绑定
/**
 * 单层目录扫描实现
 * @param container: the global Ioc container
 * @param path: 扫描门路
 * @param ctx: 上下文，没有用框架，所以 ctx = {req, res}。而 req、res 是 server.on('request', function (req, res) {}
 */
export function load(container, path, ctx) {const list = fs.readdirSync(path)
  for (const file of list) {if (/\.ts$/.test(file)) {const exports = require(resolve(path, file))

      for (const m in exports) {const module = exports[m]
        if (typeof module === 'function') {const metadata = Reflect.getMetadata(class_key, module)
          // register
          if (metadata) {container.bind(metadata.id, module, metadata.args)

            // 下面的代码逻辑是根底版，上面的是新增的

            // 先收集 Controller 上的 prefix 信息，申请办法的绑定函数 Get，函数对应的参数 Query
            const controllerMetadata = Reflect.getMetadata(controller_class_key, module)
            if (controllerMetadata) {const reqMethodMetadata = Reflect.getMetadata(props_key, module)

              if (reqMethodMetadata) {
                // 只须要存储信息，不须要额定的操作。简略起见，把所有申请信息都放到一个对象中了，不便后续依据接口申请及入参进行判断响应
                const methods = container.getReq(req_mthods_key) || {};
                const reqMethodParamsMetadata = Reflect.getMetadata(params_key, module)

                // 将收集到的信息整顿放到容器中
                reqMethodMetadata.forEach(item => {
                  // 残缺的申请门路
                  const path = controllerMetadata.prefix + item.routerName
                  // 用申请办法和残缺门路作为 key
                  methods[item.method + joinSymbol + path] = {
                    id: metadata.id, // Controll 类
                    fn: item.fn, // Get 办法
                    args: reqMethodParamsMetadata ? reqMethodParamsMetadata[item.fn] || [] : [] // Get 办法 Query 参数
                  }
                })

                container.bindReq(req_mthods_key, methods)
              }
            }
          }
        }
      }
    }
  }

  // 将所有申请数据拿进去，依据申请办法及入参进行解决响应
  const reqMethods = container.getReq(req_mthods_key)
  if (reqMethods) {
    // ctx.req.url /api/c?id=12
    const [urlPath, query] = ctx.req.url.split('?')
    // key: 申请办法 + 门路
    const methodUrl = ctx.req.method + joinSymbol + urlPath
    // 依据 key 取出数据
    const reqMethodData = reqMethods[methodUrl]
    if (reqMethodData) {const {id, fn, args} = reqMethodData
      let fnQueryParams = []
      // 办法有参数
      if (args.length) {
        // 将查问字符串转换为对象
        const queryObj = queryParams(query)
        // 这儿先依据参数在函数中的地位进行排序，这儿只解决了 Query 的状况，再依据参数名从查问对象中取出数据
        fnQueryParams = args.sort((a, b) => a.index - b.index).filter(item => item.type === 'query').map(item => queryObj[item.paramName])
      }

      // 调用办法，获取数据，进行响应
      const res = container.get(id)[fn](...fnQueryParams)
      ctx.res.end(JSON.stringify(res))
    }
  }
}

function queryParams (searchStr: string = '') {const reg = /([^?&=]+)=([^?&=]*)/g;
  const obj = {}
  searchStr.replace(reg, function (rs, $1, $2) {var name = decodeURIComponent($1);
    var val = decodeURIComponent($2);
    val = String(val);
    obj[name] = val;
    return rs;
  });
  return obj
}

能够看到，几个装璜器，有很多代码是反复的，可形象。因而源码中是有个装璜器类。

为了简略起见，我只是把申请相干的数据简略的收集整理存储。所以用了一个 Container 容器。而源码是有一个继承 Container 的 RequestContainer 进行解决。

并且源码局部对于数据的扫描，思考到各种状况，很简单。扫描感兴趣的可看看midwayjs/packages/web/src/base.ts。

集体 github 对应代码实现 node-ts-sample-ioc

插曲

看项源码的时候，第一看 readme 文档，不用说大家都晓得。那么第二去看什么呢？

我的习惯是去看 package.json。外面信息要害信息不少呢。比方依赖哪些库，依据库能猜到我的项目里有些什么性能（前提是你晓得这个库及库的作用）。

遇到不晓得的库，去理解一下，兴许日后会用到，也能更好的理解我的项目在做什么。上面是我新意识的一些库（列举）：

lernajs

Lerna 是一个优化应用 git 和 npm 治理多包存储库的工作流工具，用于治理具备多个包的 JavaScript 我的项目。

将大型代码库拆分为独立的版本包对于代码共享十分有用。然而，代码库比拟大了，子库比拟多，子库之间有依赖，治理子库就会比拟麻烦且难以追踪（一个库的版本改了，依赖的库也须要变更），测试也不易。

lerna 能解决下面的问题，而且能够缩小包的安装时间，包占用的存储空间。毕竟对立治理了，只须要一份（即便多个子库有反复的），否则每个子库都是独自的一个 npm 包，须要独自装置、存储空间。

Lerna 仓库是什么样子？

如下所示的目录构造：

my-lerna-repo/
  package.json
  packages/
    package-1/
      package.json
    package-2/
      package.json

Lerna 能做什么？

Lerna 中的两个次要命令是 lerna bootstrap 和 lerna publish。bootstrap 将把 repo 中的依赖关系链接在一起。publish 将有助于公布软件包更新。

理解更多：

• github:lerna
• lerna: 最佳实际

这个库，对开发大型框架库是十分有用的，平时业务代码开发用不到。简略理解下就好，等真正有机会用到的时候再深刻也不迟。

benchmark.js

A robust benchmarking library that supports high-resolution timers & returns statistically significant results. As seen on jsPerf.

一个弱小的基准测试库，反对高分辨率计时器并返回具备统计意义的后果。

基准测试是一种测试代码性能的办法, 同时也能够用来辨认某段代码的 CPU 或者内存效率问题. 许多开发人员会用基准测试来测试不同的并发模式, 或者用基准测试来辅助配置工作池的数量, 以保障能最大化零碎的吞吐量.

Benchmark.js 应用与 JSLitmus 相似的技术：咱们在 while 循环中运行提取的代码（模式 A），反复执行直到达到最小工夫（模式 B），而后反复整个过程以产生具备统计意义的显着性后果。

理解更多：

• github:benchmark
• javascript-benchmarking，值得一读，如何统计代码的运行工夫，到微秒，跨浏览器。
• 应用 Benchmark.js 和 jsPerf 剖析代码性能

如果是开源的或面向 C 端的我的项目，对性能有高要求的，这个库将会十分有用呢。

inversify.js

A powerful and lightweight inversion of control(IOC) container for JavaScript & Node.js apps powered by TypeScript.

inversify 是一个弱小且轻量级的的基于 typescript 的 IOC 容器框架，反对 js 和 nodejs。

InversifyJS 的开发具备四个次要指标：

1. 容许 JavaScript 开发人员编写合乎 SOLID 准则的代码。
2. 促成并激励恪守最佳 OOP 和 IoC 常规。
3. 尽可能减少运行时开销。
4. 提供最新的开发教训。

理解更多：

• github:inversify
• 解读 IoC 框架 InversifyJS
• InversifyJS 中文文档

如果你的代码模块较多，且彼此之间存在强依赖，无妨思考尝试一下采纳依赖注入的形式，借用这个库实现后续逻辑，当然也能够仿 midwayjs 一样本人实现。

总结

断断续续的看的源码，文章也是断断续续写的，写的不是很好。不过总的来说学到了很多呢：

• 利用装璜器做一些事，能够借助 Reflect-metadata.js 库来更好的治理类的元数据。实例化对象Reflect.construct
• 库拆包 git 及 npm 版本依赖等治理，能够借助 lerna.js 库
• 代码性能基准测试，能够借助 benchmark.js 库。浏览器对微秒工夫的解决
• 代码解耦，能够借助依赖注入容器及管制反转实现的原理，参考Inversify.js、midway.js、injection.js。

其余：

理论往往是在简略版的根底之上思考各种细节、边界、形象、交融等之后，n 个迭代之后的实现，而且后续会不断完善的。

我只是看了一部分我想看的代码，很多细节都没细看(比方web-express。web-koa)，也有一些齐全没看（比方packages-serverless）。目前精力有限，兴许前面须要用到了或者有空的时候会回过头来再看。

做对的事，并把事做对。