在NestJS中创建和管理模块（Modules）：模块间依赖关系和通信

843字
4分钟
2024-07-09
- NestJS

模块是NestJS的核心构建块，它们帮助我们组织代码并管理依赖关系。本文将介绍如何在NestJS中创建和管理模块，探讨模块间的依赖关系和通信，并提供示例代码展示复杂项目中的模块组织和依赖管理。

模块的创建和组织

创建模块

在NestJS中，模块是通过装饰器 @Module() 定义的。以下示例展示了如何创建一个简单的 UsersModule：

1
import { Module } from "@nestjs/common";
2
import { UsersService } from "./users.service";
3
import { UsersController } from "./users.controller";
4

5
@Module({
6
  providers: [UsersService],
7
  controllers: [UsersController],
8
})
9
export class UsersModule {}

组织模块

一个典型的NestJS项目会包含多个模块，每个模块负责不同的功能。例如，可以有一个 AuthModule 处理认证，一个 ProductsModule 处理产品管理，等等。

1
import { Module } from "@nestjs/common";
2
import { UsersModule } from "./users/users.module";
3
import { AuthModule } from "./auth/auth.module";
4
import { ProductsModule } from "./products/products.module";
5

6
@Module({
7
  imports: [UsersModule, AuthModule, ProductsModule],
8
})
9
export class AppModule {}

模块间的依赖关系

导出和导入模块

模块可以通过 exports 属性导出提供的服务，使其他模块可以导入并使用这些服务。以下示例展示了如何导出 UsersService 并在 AuthModule 中导入 UsersModule：

1
import { Module } from "@nestjs/common";
2
import { UsersService } from "./users.service";
3
import { UsersController } from "./users.controller";
4

5
@Module({
6
  providers: [UsersService],
7
  controllers: [UsersController],
8
  exports: [UsersService], // 导出 UsersService
9
})
10
export class UsersModule {}
11

12
// auth/auth.module.ts
13
import { Module } from "@nestjs/common";
14
import { AuthService } from "./auth.service";
15
import { UsersModule } from "../users/users.module";
16

17
@Module({
18
  imports: [UsersModule], // 导入 UsersModule
19
  providers: [AuthService],
20
})
21
export class AuthModule {}

模块间的通信

模块间的通信通常通过服务来实现。例如，AuthService 可以调用 UsersService 来验证用户：

1
import { Injectable } from "@nestjs/common";
2
import { UsersService } from "../users/users.service";
3

4
@Injectable()
5
export class AuthService {
6
  constructor(private readonly usersService: UsersService) {}
7

8
  async validateUser(username: string, pass: string): Promise<any> {
9
    const user = await this.usersService.findOne(username);
10
    if (user && user.password === pass) {
11
      return user;
12
    }
13
    return null;
14
  }
15
}

复杂项目中的模块组织和依赖管理

在复杂项目中，模块的组织和依赖管理变得尤为重要。以下是一些最佳实践：

使用特性模块

将功能相关的代码组织到特性模块中。例如，所有与用户相关的代码都放在 UsersModule 中，所有与产品相关的代码都放在 ProductsModule 中。

使用共享模块

将常用的服务、管道、守卫等放在共享模块中，并在需要的地方导入。例如，可以创建一个 SharedModule 来提供数据库连接、日志服务等。

1
import { Module } from "@nestjs/common";
2
import { DatabaseService } from "./database.service";
3
import { LoggerService } from "./logger.service";
4

5
@Module({
6
  providers: [DatabaseService, LoggerService],
7
  exports: [DatabaseService, LoggerService],
8
})
9
export class SharedModule {}
10

11
// app.module.ts
12
import { Module } from "@nestjs/common";
13
import { SharedModule } from "./shared/shared.module";
14
import { UsersModule } from "./users/users.module";
15
import { AuthModule } from "./auth/auth.module";
16

17
@Module({
18
  imports: [SharedModule, UsersModule, AuthModule],
19
})
20
export class AppModule {}

使用模块间依赖注入

通过依赖注入机制，确保模块间的松耦合。例如，通过构造函数注入服务，而不是在模块内部直接实例化服务。

1
import { Injectable } from "@nestjs/common";
2
import { DatabaseService } from "../shared/database.service";
3

4
@Injectable()
5
export class ProductsService {
6
  constructor(private readonly databaseService: DatabaseService) {}
7

8
  async findAll(): Promise<any[]> {
9
    return this.databaseService.query("SELECT * FROM products");
10
  }
11
}