TypeScript依赖注入框架Typedi的使用、原理、源码解读

简介

typedi是一个基于TS的装饰器和reflect-metadata的依赖注入轻量级框架，使用简单易懂，方便拓展。

使用typedi的前提是安装reflect-metadata，并在项目的入口文件的第一行中声明import ‘reflect-metadata’，这样就会在原生的Reflect API上挂载metadata操作相关的API。

前提

  1. 项目中引入reflect-metadata依赖
pnpm add reflect-metadata
  1. 在项目的入口文件的第一行声明
import 'reflect-metadata'
  1. 在tsconfig.json中开启装饰器语法和装饰器元数据
{"compilerOptions": {"experimentalDecorators": true,"emitDecoratorMetadata": true}
}

当开启了emitDecoratorMetadata后，TS会自动为装饰器生成metadata，有3个metadata：

  • design:type 被装饰器修饰的目标的类型，即成员的类型
  • design:paramtypes 方法的参数的类型集合，是一个数组，只有被修饰是方法时，此metadata才有效，否则就是undefined
  • design:returntype 方法的返回值类型，只有方法独有的metadata

安装typedi

pnpm add typedi

注册实例到容器中

typedi是基于IOC和DI的思想，因此需要有一个容器来容纳所有的bean

有三种方式注册你的实例到容器Container中：

  • 使用@Service()修饰的类(声明式)
  • 用Token注册一个实例(手动式)
  • 用字符串来注册一个实例(手动式)

Token和字符串标识符可以用来注册类以外的其他值。Token和字符串标识符都可以注册任何类型的值，包括除undefined之外的原始值。它们必须在容器上用Container.set()函数设置，然后才能通过Container.get()请求它们。

使用@Service注入：

import 'reflect-metadata'
import { Service, Container } from 'typedi'@Service()
class Person {name: string = 'John'age: number = 30
}const obj = Container.get(Person) as Personconsole.log(obj)
// Person { name: 'John', age: 30 }

使用Token或字符串注入：

import 'reflect-metadata'
import { Service, Container, Token } from 'typedi'Container.set('message', 'Hello World')
console.log(Container.get('message')) // Hello Worldconst token = new Token('TOKEN_INDEX')
Container.set(token, 'Nice to meet you!')
console.log(Container.get(token)) // Nice to meet you!

依赖注入

三种方式注入依赖的实例：

  • 通过类的构造函数参数自动注入
  • 使用@Inject()装饰器来标注需要注入的属性
  • 直接使用Container.get()来获取实例，手动注入

构造函数参数注入

import 'reflect-metadata'
import { Service, Container, Token } from 'typedi'@Service()
class A {say(){console.log('A ...')}
}@Service()
class B {constructor(public a: A){}say(){console.log('B ...')this.a.say()}
}const b = Container.get(B) as B
b.say()
// B ...
// A ...

@Inject()属性注入

import 'reflect-metadata'
import { Service, Container, Token, Inject } from 'typedi'@Service()
class A {say(){console.log('A ...')}
}@Service()
class B {@Inject()a: Asay(){console.log('B ...')this.a.say()}
}const b = Container.get(B) as B
b.say()
// B ...
// A ...

bean的作用域

默认注入到容器中的实例都是单例的，即每次从容器中获取的对象都是同一个对象

import 'reflect-metadata'
import { Service, Container, Token, Inject } from 'typedi'@Service()
class Person {name = 'John Doe'age = 21
}const obj1 = Container.get(Person)
const obj2 = Container.get(Person)
// 判断两个对象是否是同一个对象
console.log(obj1 === obj2) // true

如果想要每次请求容器时，都会得到一个新的对象，可以这样做

import 'reflect-metadata'
import { Service, Container, Token, Inject } from 'typedi'@Service({ transient: true })
class Person {name = 'John Doe'age = 21
}const obj1 = Container.get(Person)
const obj2 = Container.get(Person)
// 判断两个对象是否是同一个对象
console.log(obj1 === obj2) // false

@Inject

@Inject是一个属性和参数装饰器，用于解决一个类的属性或构造函数参数的依赖

默认情况下，他能推断出属性或参数的类型，并初始化一个检测到的类型的实例，然而这种行为可以通过指定一个自定义的可构造类型、Token或已命名的Service作为第一个参数 来覆盖

属性注入

属性的类型是自动推断出来的，所以不需要定义所需的值来作为装饰器的参数

import 'reflect-metadata';
import { Container, Inject, Service } from 'typedi';@Service()
class InjectedExampleClass {print() {console.log('I am alive!');}
}@Service()
class ExampleClass {@Inject()withDecorator: InjectedExampleClass;withoutDecorator: InjectedExampleClass;
}const instance = Container.get(ExampleClass);/*** `instance`变量是一个ExampleClass实例* 其`withDecorator`属性包含一个InjectedExampleClass实例* 而`withoutDecorator`属性undefined*/
console.log(instance);instance.withDecorator.print();
// "I am alive!" (InjectedExampleClass.print 方法)
console.log(instance.withoutDecorator);
// undefined, 因为这个属性没有用@Inject装饰器标记

构造函数注入

构造函数注入，当一个类被@Service装饰器标注时，在构造器注入中不需要@Inject装饰器，TS会自动推断并为每个构造参数注入正确的类实例。

但是注意，@Inject可以用来覆盖注入的类型

import 'reflect-metadata';
import { Container, Inject, Service } from 'typedi';@Service()
class InjectedExampleClass {print() {console.log('I am alive!');}
}@Service()
class ExampleClass {constructor(@Inject()public withDecorator: InjectedExampleClass,public withoutDecorator: InjectedExampleClass) {}
}const instance = Container.get(ExampleClass);/*** `instance'变量是一个ExampleClass实例* 它同时具有
`withDecorator`和`withoutDecorator`属性* 都包含一个
InjectedExampleClass实例。*/
console.log(instance);instance.withDecorator.print();
// 输出 "I am alive!" (InjectedExampleClass.print function)
instance.withoutDecorator.print();
// 输出 "I am alive!" (InjectedExampleClass.print function)

明确请求目标类型

默认情况下，TypeDI将尝试推断属性和参数的类型并注入适当的类实例。当必要时，可以覆盖注入值的类型：

  • 通过@Inject( () => type)，其中type是一个可构造的值（例如，一个类的定义）
  • 通过@Inject(myToken)，其中myToken是一个Token类的实例
  • 通过@Inject(serviceName)，其中serviceName是一个字符串，已经通过Container.set(serviceName, value)注册过了
import 'reflect-metadata';
import { Container, Inject, Service } from 'typedi';@Service()
class InjectedExampleClass {print() {console.log('I am alive!');}
}@Service()
class BetterInjectedClass {print() {console.log('I am a different class!');}
}@Service()
class ExampleClass {@Inject()inferredPropertyInjection: InjectedExampleClass;/*** 我们告诉TypeDI，用`BetterInjectedClass`类初始化。* 不管推断的类型是什么。*/@Inject(() => BetterInjectedClass)explicitPropertyInjection: InjectedExampleClass;constructor(public inferredArgumentInjection: InjectedExampleClass,/*** 我们告诉TypeDI，用`BetterInjectedClass`类初始化。* 不管推断的类型是什么。*/@Inject(() => BetterInjectedClass)public explicitArgumentInjection: InjectedExampleClass) {}
}/*** `instance`变量是一个 ExampleClass 的实例，同时具有* - `inferredPropertyInjection` 和 `inferredArgumentInjection` 属性* 都包含一个`InjectedExampleClass`实例* - `explicitPropertyInjection`和`explicitArgumentInjection`属性* 都包含一个`BetterInjectedClass'实例。*/
const instance = Container.get(ExampleClass);instance.inferredPropertyInjection.print();
// "I am alive!" (InjectedExampleClass.print function)
instance.explicitPropertyInjection.print();
// "I am a different class!" (BetterInjectedClass.print function)
instance.inferredArgumentInjection.print();
// "I am alive!" (InjectedExampleClass.print function)
instance.explicitArgumentInjection.print();
// "I am a different class!" (BetterInjectedClass.print function)

循环依赖

依赖注入最常见的问题就是循环依赖，因此为了避免循环依赖，我们需要为属性指明类型
在循环依赖的情况下，TS无法推断出属性的类型，就导致design:type为undefined，typedi就无法实例化，因此我们需要强制给出类型。

// Car.ts
@Service()
export class Car {@Inject(type => Engine)engine: Engine;
}// Engine.ts
@Service()
export class Engine {@Inject(type => Car)car: Car;
}

注意这种方式只能解决属性注入，不能解决构造参数的注入。

需要注意的是，通常循环依赖意味着：

  1. 模块间的指责分工不明
  2. 单个模块的指责过多(不满足单一职责原则)
  3. 缺少合理的抽象层

Service Token

在使用@Service()来注入一个实例到Container中时，我们可以给出@Service()参数，用来唯一标识这个实例，参数类型通常是字符串或Token类型。

使用字符串

import 'reflect-metadata'
import { Service, Token, Container, Inject } from 'typedi'@Service('userComponet')
class Person {name = 'john'
}@Service('userIndex')
class PersonController {@Inject('userComponet')obj: Personsay(){console.log('userIndex ... ',this.obj.name)}
}console.log((Container.get('userComponet') as Person).name); // john(Container.get('userIndex') as PersonController).say() // userIndex ... john

使用Token

Service Token 可以用来标识Container中唯一的一个实例，可以安全地从Container中获取Bean

import 'reflect-metadata';
import { Container, Token } from 'typedi';export const JWT_SECRET_TOKEN = new Token<string>('MY_SECRET');Container.set(JWT_SECRET_TOKEN, 'wow-such-secure-much-encryption');/*** 这个值是类型安全的，因为Token是类型化的。*/
const JWT_SECRET = Container.get(JWT_SECRET_TOKEN);
console.log(JWT_SECRET)

可以与@Inject()搭配使用，覆盖属性或参数的推断类型

import 'reflect-metadata';
import { Container, Token, Inject, Service } from 'typedi';export const JWT_SECRET_TOKEN = new Token<string>('MY_SECRET');Container.set(JWT_SECRET_TOKEN, 'wow-such-secure-much-encryption');@Service()
class Example {@Inject(JWT_SECRET_TOKEN)myProp: string;
}const instance = Container.get(Example);
// instance.myProp属性有为Token分配的值。

同名的Token

两个具有相同名称的Token是不同的Token，一个Token实例是唯一的，类似于Symbol类型。

import 'reflect-metadata';
import { Container, Token } from 'typedi';const tokenA = new Token('TOKEN');
const tokenB = new Token('TOKEN');Container.set(tokenA, 'value-A');
Container.set(tokenB, 'value-B');const tokenValueA = Container.get(tokenA);
// tokenValueA 是 "value-A"
const tokenValueB = Container.get(tokenB);
// tokenValueB 是 "value-B"console.log(tokenValueA === tokenValueB);
// false

Token和字符串的对比

Token和字符串都可以用来标识一个Service实例，但是推荐使用Token，因为Token是类型安全的，而同一个string的名称真的就是唯一表示Service实例。

继承性

当基类和继承类都被标记为@Service()后，属性是支持继承性的。

在创建时，继承有装饰属性的类将收到这些属性上的初始化实例。

即当子类继承了父类的依赖注入的属性时，子类中的此属性也是可以直接使用的

import 'reflect-metadata';
import { Container, Token, Inject, Service } from 'typedi';@Service()
class InjectedClass {name: string = 'InjectedClass';
}@Service()
class BaseClass {name: string = 'BaseClass';@Inject()injectedClass: InjectedClass;
}@Service()
class ExtendedClass extends BaseClass {name: string = 'ExtendedClass';
}const instance = Container.get(ExtendedClass);console.log(instance.injectedClass.name);
// 输出"InjectedClass"
console.log(instance.name);
// 输出 "ExtendedClass"

参考文章

https://static.kancloud.cn/czkme/dependency-inject/2511047

源码解读

原理说明

依赖注入的核心就是容器Container
Container.set(id, value)向容器中push一个实例
Container.get(id)从容器中get一个实例

Container容器对象中的核心概念：

  • ServiceMetadata,被容器接管的每个类都叫做一个Service，ServiceMetadata就是这个类对应的信息，每个类都有一个与之对应的ServiceMetadata实例
  • metadataMap,是一个map，保存的是某一个类的配置信息
  • handlers，是一个数组，所有@Inject()的属性都是一个handler，表示待注入的属性。此容器接管的所有类中的@Inject()标注的属性都在这个数组中

按照装饰器的执行顺序，一个类中的@Inject()先执行，然后是@Service()
@Inject可以用在属性和构造参数上。

看一下ServiceMetadata的结构

export interface ServiceMetadata<Type = unknown> {// service的唯一标识，id: string | Token | Constructable | AbstractConstructor | CallableFunction; /*** 实例的作用域*  singleton 单例模式， 单例的实例会被放在default容器中*  container 从指定容器中创建实例，从此容器中也是单例的*  transient 瞬时的，每次从容器请求都会创建一个新的实例*/scope: 'singleton' | 'container' | 'transient'; // Service的类型，就是构造函数类型type: Constructable<Type> | null; // 创建此类型实例的工厂，factory: [Constructable<unknown>, string] | CallableFunction | undefined; // 此实例的工厂方法// 目标类的实例value: unknown | Symbol;// 是否允许在同一个service id下注册多个实例multiple: boolean;/*** 是否立即实例化，当为true，容器创建完成后就会实例化此类的bean；* 当为false，只有当用时才会实例化*/eager: boolean;/*** 引用此类的 metadata 的容器*/referencedBy: Map<ContainerIdentifier, ContainerInstance>;
}

@Inject的原理

首先要清楚@Inject()的用法：

  • @Inject()中可以给Service的id，用来指定注入特定的实例
  • @Inject()中的参数还可以是一个函数，用来强制修改要注入的类型

一个Handler的结构

export interface Handler<T = unknown> {// 属性所在的类(构造函数)，即此属性需要注入的目标类object: Constructable<T>; // 成员名称propertyName?: string;// 成员在构造函数参数中的索引，// 若@Inject()标注的是类中实例属性，则此属性为undefinedindex?: number;// 一个方法，在@Inject()中已经实现了，从指定的容器中获取此属性的实例value: (container: ContainerInstance) => any;
}

当在一个属性上标注了@Inject()后，实际上就发生了一件事情，向容器中注入一个此属性的handler

20240117154925

@Service发生了什么

@Service()发生了两件事：

  1. 初始化此class的ServiceMetadata
  2. 向Container.metadataMap()中push这个ServiceMetadata
    看图
    20240117155904

Container.get(id)

Container.get(id)是从容器中获取实例，在这个步骤中完成了类的实例化。
这个框架的核心就是get()方法
20240117163134

总结

基于Container的依赖注入，无非就是两件事，向Container中push实例和从Container中get实例。
typedi采用了惰性加载的方式，初始只保存类的metadata(类的配置信息)，
Container.get()时才会对类进行实例化，而在类实例化的过程中，如果检测都有需要注入的属性，则会继续调用Container.get()来实例化属性，经典的递归形式；后续如果如果要获取某个实例，判断已经实例化了直接返回，就不需要继续实例化了

typedi这个框架设计非常小巧强悍，代码简洁，支持自定义拓展。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/414469.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

优思学院｜初入职质量工程师必须要考CQE？你真正要做的是...

优思学院｜初入职质量工程师必须要考CQE？你真正要做的是...

最近收到有一位质量工程师的人士提问&#xff0c;他是初入职的新人&#xff0c;是否需要考质量工程师证&#xff0c;很多人以为需要&#xff0c;因为做会计的有会计证&#xff0c;要开车的人要有驾驶证&#xff0c;所以质量工程师就需要有质量工程师证&#xff0c;做但其实这并…
阅读更多...
soso移动营业大厅（纯后端+MySQL数据库+JDBC）

soso移动营业大厅（纯后端+MySQL数据库+JDBC）

一、项目需求 中国移动,中国联通,中国电信是国内3大通信运营商,每个运营商都提供了不同的品牌套餐来应对不同的用户群,比如北京移动主要有全球通,神州行,动感地带等3大品牌套餐,每种套餐的内容和费用不同,嗖嗖移动是一个假定的通信运营商,提供了话痨套餐,网虫套餐,超人套餐,各…
阅读更多...
【C语言基础考研向】06运算符与表达式

【C语言基础考研向】06运算符与表达式

文章目录 1.运算符分类 2.算术运算符及表达式 3.关系运算符与关系表达式 4.c语言运算级优先级表 课后习题自测 1.运算符分类 语言提供了13种类型的运算符,如下所示. (1)算术运算符( - * / %) . (2)关系运算符(>< >< l) . (3)逻辑运算符(l && ll) . (4)位…
阅读更多...
【SpringCloud】微服务框架后端部署详细过程记录20240119

【SpringCloud】微服务框架后端部署详细过程记录20240119

前言&#xff1a;前两天公司接到客户提供的一个微服务框架&#xff0c;导师让我在本地部署验证一下该框架的可用性&#xff0c;借此机会记录一下微服务项目的一个基本部署流程&#xff0c;仅供学习参考&#xff0c;如有不足还请指正&#xff01; 文件结构 提供的压缩文件共包含…
阅读更多...
NVIDIA 大模型 RAG 分享笔记

NVIDIA 大模型 RAG 分享笔记

文章目录 大语言模型在垂直领域落地的三个挑战&#xff1a;什么是 RAG以及为什么能解决大预言模型所带来的的这三个问题RAG 不是一项技术而是整体的 Pipeline非参数化 &#xff1a;数据库部分加载到数据库中检索阶段 提升检索效率的技术检索前&#xff1a;对query做处理use que…
阅读更多...
开源项目汇总：机器学习前沿探索 | 开源专题 No.60

开源项目汇总：机器学习前沿探索 | 开源专题 No.60

facebookresearch/xformers Stars: 6.0k License: NOASSERTION xFormers 是一个加速 Transformer 研究的工具包&#xff0c;主要功能如下&#xff1a; 可自定义构建模块&#xff1a;无需样板代码即可使用的独立/可定制化构建模块。这些组件与领域无关&#xff0c;被视觉、NLP…
阅读更多...
MS2358——96KHz、24bit 音频 ADC

MS2358——96KHz、24bit 音频 ADC

产品简述 MS2358 是带有采样速率 8kHz-96kHz 的立体声音频模数 转换器&#xff0c;适合于面向消费者的专业音频系统。 MS2358 通过使用增强型双位 Δ - ∑ 技术来实现其高精度 的特点。 MS2358 支持单端的模拟输入&#xff0c;所以不需要外部器 件&#xff0c;非常适…
阅读更多...
基于docker创建nginx容器

基于docker创建nginx容器

docker一键安装可以参考我这个博客&#xff1a;一键安装docker 1.创建基础容器 docker run -p280:280 --name nginx -d nginx创建挂载到容器的宿主机文件夹 mkdir -p /home/000nginx-ebrms-ftp/html mkdir -p /home/000nginx-ebrms-ftp/logs mkdir -p /home/000nginx-ebrms-f…
阅读更多...
C++ Linux动态库的编译和调用

C++ Linux动态库的编译和调用

一、C动态库编译 采用g编译C动态库&#xff0c;命令如下&#xff1a; g -fPIC -shared -o 动态库名 cpp文件名1.1 关于fPIC选项 首先了解动态库的载入时重定位。 一般linux的可执行文件都是elf格式&#xff08;一种二进制文件格式&#xff09;&#xff0c;在可执行文件的头部包…
阅读更多...
C++进阶（五）二叉搜索树

C++进阶（五）二叉搜索树

&#x1f4d8;北尘_&#xff1a;个人主页 &#x1f30e;个人专栏:《Linux操作系统》《经典算法试题 》《C》 《数据结构与算法》 ☀️走在路上&#xff0c;不忘来时的初心 文章目录 一、二叉搜索树概念二、二叉搜索树操作三、二叉搜索树的实现四、二叉搜索树的应用五、二叉搜索…
阅读更多...
Maxwell介绍

Maxwell介绍

一、介绍 介绍&#xff1a;它读取MySQL binlog并将数据更改作为JSON写入Kafka、Kinesis和其他流媒体平台&#xff08;目前支持&#xff1a;kafka、RabbitMQ、Redis、file、Kinesis、Nats、Google Cloud Pub/Sub、Google Cloud Bigquery、SNS&#xff09; 版本&#xff1a;从v1.…
阅读更多...
electron-builder打包过程中报错的处理

electron-builder打包过程中报错的处理

electron在使用electron-builder打包过程中需要用到四个包&#xff0c;但是由于内网的网络限制&#xff0c;下载不下来&#xff0c;会导致报错。下面即为具体的包&#xff1a; 通过镜像 https://registry.npmmirror.com/ https://registry.npmmirror.com/ 去下载相关的资…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023