介绍
在现代软件开发中，依赖注入是一种非常有用的设计模式。它可以帮助我们解耦代码、提高可测试性，并使得代码更加灵活和可扩展。在本文中，我将介绍如何使用TypeScript来实现依赖注入，并考虑各种情况，包括单例、循环依赖等。
依赖注入的概念很简单，它基于一个容器（Container），用于管理对象的创建和依赖关系的解决。在使用依赖注入之前，我们需要定义一些“可注入”的类（Injectable），并标记它们的依赖关系（Inject）。接下来，让我们逐步实现这个过程。
第一步：定义@Injectable装饰器
@Injectable装饰器是标记一个类为可注入的基础。我们可以通过使用Reflect Metadata库来实现这个装饰器。首先，我们需要安装这个库：
npm install reflect-metadata
然后，在项目的顶层文件或入口文件中添加以下代码：
import 'reflect-metadata';
现在，我们可以定义自己的@Injectable装饰器了：
import 'reflect-metadata';
export function Injectable() {
return function (target: any) {
Reflect.defineMetadata('injectable', true, target);
};
}
这个装饰器只是简单地使用Reflect.defineMetadata方法为被装饰的类添加了一个名为’injectable’的元数据标记。
第二步：定义@Inject装饰器
@Inject装饰器用于标记类的依赖关系。
同理，我们可以定义自己的@Inject装饰器：
import 'reflect-metadata';
export function Inject() {
return function (target: any, propertyKey: string) {
const type = Reflect.getMetadata('design:type', target, propertyKey);
Reflect.defineMetadata('inject', type, target, propertyKey);
};
}
这个装饰器会使用Reflect.getMetadata方法获取属性的类型，并使用Reflect.defineMetadata方法将类型信息存储到元数据中。
第三步：实现Container类
接下来，我们需要实现一个容器类，用于管理对象的创建和依赖关系的解决。我们的容器类需要支持以下功能：
- 注册可注入的类
- 解决类的依赖关系
- 创建单例对象
- 处理循环依赖
下面是一个简化的Container类的示例：
import 'reflect-metadata';
type Constructor<T = any> = new (...args: any[]) => T;
export class Container {
private instances: Map<Constructor, any> = new Map();
register<T>(clazz: Constructor<T>) {
const injectable = Reflect.getMetadata('injectable', clazz);
if (!injectable) {
throw new Error(`Class ${clazz.name} is not marked with @Injectable()`);
}
this.instances.set(clazz, null);
}
resolve<T>(clazz: Constructor<T>): T {
const instance = this.instances.get(clazz);
if (instance !== null) {
return instance;
}
const injectParams = Reflect.getMetadata('design:paramtypes', clazz) || [];
const resolvedParams = injectParams.map(param => this.resolve(param));
const newInstance = new clazz(...resolvedParams);
this.instances.set(clazz, newInstance);
return newInstance;
}
}
这个Container类具有两个主要方法：register用于注册可注入的类，resolve用于解决类的依赖关系。
第四步：单例和循环依赖的处理。
使用示例在使用示例之前，我们先来考虑一些特殊情况，包括单例和循环依赖的处理。
- 单例：有时候我们希望某个类只被创建一次，并在整个应用程序中共享使用。为了实现这个目标，我们可以在Container类中添加一个单例缓存，以确保每个类只有一个实例。
private singletonInstances: Map<Constructor, any> = new Map();
// resolve方法中的代码修改为：
resolve<T>(clazz: Constructor<T>): T {
const singletonInstance = this.singletonInstances.get(clazz);
if (singletonInstance !== undefined) {
return singletonInstance;
}
// ...
const newInstance = new clazz(...resolvedParams);
this.instances.set(clazz, newInstance);
this.singletonInstances.set(clazz, newInstance);
// ...
}
现在，当我们解析一个已经解析过的类时，将会返回它的单例实例。
- 循环依赖：循环依赖是指两个或多个类之间相互依赖的情况。为了解决循环依赖，我们可以使用延迟加载的方式创建对象实例。具体做法是，在容器中维护一个解析队列，按需解析依赖关系。
private resolvingQueue: Set<Constructor> = new Set();
// resolve方法中的代码修改为：
resolve<T>(clazz: Constructor<T>): T {
if (this.resolvingQueue.has(clazz)) {
throw new Error(`Circular dependency detected for class ${clazz.name}`);
}
const singletonInstance = this.singletonInstances.get(clazz);
if (singletonInstance !== undefined) {
return singletonInstance;
}
const instance = this.instances.get(clazz);
if (instance !== null) {
return instance;
}
this.resolvingQueue.add(clazz);
// ...
const newInstance = new clazz(...resolvedParams);
this.instances.set(clazz, newInstance);
this.singletonInstances.set(clazz, newInstance);
// ...
this.resolvingQueue.delete(clazz);
return newInstance;
}
现在，当检测到循环依赖时，将会抛出一个错误。
使用示例
现在我们可以使用我们实现的依赖注入框架来创建和管理对象实例了。下面是一个简单的使用示例：
import { Container, Injectable, Inject } from 'your-inject-package';
@Injectable()
class Foo {
bar: Bar;
constructor(@Inject() bar: Bar) {
this.bar = bar;
}
}
@Injectable()
class Bar {}
const container = new Container();
container.register(Foo);
container.register(Bar);
const fooInstance = container.resolve(Foo);
console.log(fooInstance instanceof Foo); // true
console.log(fooInstance.bar instanceof Bar); // true
在这个示例中，我们定义了两个可注入的类Foo和Bar，并使用@Inject装饰器标记了Foo类对Bar类的依赖关系。然后，我们通过Container类注册这两个类，并使用resolve方法解析Foo类的实例。最后，我们验证了Foo类的实例以及它的依赖关系是否正确创建。
总结
本文中，我们介绍了如何使用TypeScript来实现依赖注入，并考虑了单例和循环依赖等各种情况。通过定义@Injectable和@Inject装饰器，我们可以标记类的可注入性和依赖关系，并通过Container类来管理对象的创建和依赖关系的解决。依赖注入可以帮助我们解耦代码、提高可测试性，并使得代码更加灵活和可扩展。希望本文对你理解和应用依赖注入有所帮助！
