Typescript: Nest.js 中使用声明文件定义依赖注入的类型

Nest.js 是一个流行的 Node.js 服务端框架,它基于 TypeScript 构建,并采用了依赖注入(Dependency Injection, DI)的设计模式。在 Nest.js 中,我们可以使用声明文件(declaration files)来定义依赖注入的类型,从而获得更好的类型检查和智能提示。本文将从浅入深,结合 Nest.js 的源码,讲解如何使用声明文件定义依赖注入的类型。

Nest.js 中的依赖注入

在深入探讨声明文件之前,我们先来了解一下 Nest.js 中的依赖注入。在 Nest.js 中,依赖注入是通过 @Injectable 装饰器实现的。当一个类被 @Injectable 装饰时,Nest.js 会自动创建该类的实例,并将其注入到需要该类实例的地方。

下面是一个简单的例子:

import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  getUser(id: number) {
    // ...
  }
}

@Injectable()
export class AuthService {
  constructor(private readonly userService: UserService) {}

  async validateUser(id: number) {
    const user = await this.userService.getUser(id);
    // ...
  }
}

在这个例子中,UserService 和 AuthService 都是可注入的类。AuthService 的构造函数中声明了一个 UserService 类型的依赖,Nest.js 会自动创建 UserService 的实例,并将其注入到 AuthService 中。

在 Nest.js 源码中探索声明文件的使用

那么,Nest.js 内部是如何使用声明文件来定义依赖注入的类型呢?让我们一起探索一下 Nest.js 的源码。

在 Nest.js 的源码中,有一个 injectable.ts 文件,它定义了 @Injectable 装饰器:

export function Injectable(): ClassDecorator {
  return (target: Function) => {
    Reflect.defineMetadata(SCOPE_OPTIONS_METADATA, { scope: Scope.DEFAULT }, target);
  };
}

这里使用了 Reflect.defineMetadata 来为类添加元数据,标记该类是可注入的。SCOPE_OPTIONS_METADATA 是一个常量,用于定义元数据的键名。

在 injector.ts 文件中,定义了 Injector 类,它负责创建和管理可注入类的实例:

export class Injector {
  // ...

  public get<T>(typeOrToken: Type<T> | Abstract<T> | string | symbol, options: InjectOptions = {}): T {
    const instanceKey = this.getInstanceKey(typeOrToken, options);
    const instanceWrapper = this.instances.get(instanceKey);
    if (instanceWrapper) {
      return instanceWrapper.instance;
    }

    // ...

    const instance = this.instantiateClass<T>(instanceWrapper, moduleRef, ctorHost);
    this.instances.set(instanceKey, new InstanceWrapper(instance));
    return instance;
  }

  // ...
}

这里的 get 方法用于获取可注入类的实例。它首先根据类型或令牌(token)获取实例的键名,然后从 instances 映射中获取实例。如果实例不存在,就调用 instantiateClass 方法创建实例,并将其存储到 instances 映射中。

instantiateClass 方法的定义如下:

private instantiateClass<T>(
  instanceWrapper: InstanceWrapper<T>,
  moduleRef: Module,
  ctorHost: Type<any> | undefined,
): T {
  const { metatype, inject } = instanceWrapper;

  // ...

  const instance = new metatype(...deps);
  instanceWrapper.instance = instance;
  return instance;
}

这里使用了 new 关键字来创建类的实例,并将依赖项作为构造函数的参数传入。metatype 表示要实例化的类,inject 表示类的依赖项。

声明文件在 Nest.js 依赖注入中的应用

为了更好地理解声明文件在 Nest.js 依赖注入中的应用,我们以一个实际的例子来说明。假设我们有一个 UserModule,它包含了 UserService 和 AuthService:

import { Module } from '@nestjs/common';
import { UserService } from './user.service';
import { AuthService } from './auth.service';

@Module({
  providers: [UserService, AuthService],
  exports: [UserService],
})
export class UserModule {}

这里使用 @Module 装饰器定义了 UserModule,并在 providers 属性中声明了 UserService 和 AuthService。

现在,我们要在其他模块中使用 UserService,可以像下面这样导入 UserModule:

import { Module } from '@nestjs/common';
import { UserModule } from './user/user.module';
import { PostService } from './post.service';

@Module({
  imports: [UserModule],
  providers: [PostService],
})
export class PostModule {}

在 PostModule 中,我们导入了 UserModule,这样就可以在 PostService 中注入 UserService 了:

import { Injectable } from '@nestjs/common';
import { UserService } from './user/user.service';

@Injectable()
export class PostService {
  constructor(private readonly userService: UserService) {}

  createPost(userId: number, content: string) {
    const user = this.userService.getUser(userId);
    // ...
  }
}

这里的关键在于,PostService 是如何知道 UserService 的类型的呢?答案就在于 Nest.js 使用了声明文件来定义依赖注入的类型。

在 @nestjs/common 包的根目录下,有一个 index.d.ts 文件,它定义了 Nest.js 中常用的类型:

// @nestjs/common/index.d.ts

export * from './decorators';
export * from './enums';
export * from './exceptions';
export * from './http';
export * from './interfaces';
export * from './pipes';
export * from './services';
export * from './utils';

这里使用 export * from 语法导出了各个子目录下的类型定义。其中,./services 目录下的 index.d.ts 文件定义了 Injectable 类型:

// @nestjs/common/services/index.d.ts

export declare type Injectable<T = any> = T;

我们可以用类图来表示这个过程中的关系:

从图中可以看出,UserService、AuthService 和 PostService 都是 Injectable 类型的子类型。PostService 依赖于 UserService,这种依赖关系是通过声明文件中的类型定义来实现的。

总结

本文结合 Nest.js 的源码,讲解了如何使用声明文件定义依赖注入的类型。我们首先了解了 Nest.js 中的依赖注入,然后深入 Nest.js 源码,探索了 @Injectable 装饰器和 Injector 类的实现。接着,我们通过一个实际的例子,说明了声明文件在 Nest.js 依赖注入中的应用。