nest 中绝对的核心 ioc di、mvc、aop

控制反转（IoC）和依赖注入（DI）

控制反转是一种设计原则，用于将组件的创建和管理的控制权从组件本身转移到外部容器或框架。在传统的编程实践中，组件（如类或函数）通常会自行创建和管理它们的依赖项。IoC 通过将这些依赖项的创建和绑定移交给框架来颠倒这种控制。

在 Nest.js 中，IoC 容器负责管理对象的生命周期和依赖关系。它自动创建对象（称为 providers），解析它们的依赖关系，并在需要时将它们注入到其他对象中。这样做的好处是可以实现更高的模块化和更容易的单元测试。

依赖注入是实现 IoC 的一种技术。DI 允许类的依赖关系在运行时动态地传递给它，而不是在类内部硬编码。这样，类不需要知道如何创建它们的依赖项，只需要知道依赖项的接口。这使得类更加松耦合，并且更容易测试和维护。

在 Nest.js 中，DI 主要通过构造函数注入实现。Nest.js 使用 TypeScript 的类型系统和装饰器来指定一个类的依赖关系，并在创建类的实例时自动注入这些依赖项。

Nest.js 中的 DI 实现

Providers: 在 Nest.js 中，任何可以注入到其他类中的东西都被称为 provider。这包括服务、仓库、工厂等。
Modules: Nest.js 使用模块来组织代码。每个模块定义了一组提供者、控制器和其他类，这些类是模块的一部分。模块系统允许 Nest.js 知道如何组织和加载应用程序的不同部分。
Decorators: Nest.js 使用 TypeScript 装饰器来标记类和属性，以便 IoC 容器可以识别和注入依赖项。例如，@Injectable() 装饰器用于标记一个类作为 provider，而 @Inject() 装饰器用于注入特定的依赖项。

以下是一个简单的 Nest.js 服务和模块的例子，展示了依赖注入：

typescript 复制代码

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

@Injectable()
export class MyService {
  // MyService 的逻辑...
}

import { Module } from '@nestjs/common';
import { MyService } from './my.service';

@Module({
  providers: [MyService],
  exports: [MyService]
})
export class MyModule {}

在这个例子中，MyService 是一个 provider，它通过 @Injectable() 装饰器标记。MyModule 是一个模块，它通过 @Module 装饰器声明 MyService 为其提供者之一。

当 Nest.js 应用程序启动时，IoC 容器会根据模块和提供者的定义来解析依赖关系，并自动创建和注入实例。

通过这种方式，Nest.js 利用 IoC 和 DI 提供了一个强大的架构，使得应用程序更加灵活和可维护。

MVC

MVC 是一种将应用程序分为三个核心组件的软件设计模式，即模型（Model）、视图（View）和控制器（Controller），旨在分离内部业务逻辑和用户界面，从而使得应用程序的开发、维护和扩展更为高效和有组织。

模型（Model）

在 Nest.js 中，模型通常代表与数据相关的部分，它可以是一个简单的类，也可以是利用 ORM（如 TypeORM 或 Sequelize）定义的数据模型。模型负责数据的存储、检索、更新和删除 --- 这通常涉及到数据库的交互。

typescript 复制代码

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  email: string;
}

在上面的示例中，我们定义了一个用户模型，它通过装饰器定义了如何在数据库中创建表和字段。

视图（View）

Nest.js 作为一个后端框架，通常不直接处理视图，而是将数据发送给客户端（如浏览器或移动应用），由客户端框架（如 Angular、React 或 Vue.js）来处理视图相关的工作。不过，Nest.js 也支持模板引擎（如 Handlebars、EJS 或 Pug），从而可以直接从服务器渲染视图。

如果你选择在 Nest.js 中使用模板引擎，你的视图可能看起来是这样的：

html 复制代码

<!DOCTYPE html>
<html>
<head>
  <title>User Profile</title>
</head>
<body>
  <h1>{{ user.name }}</h1>
  <p>Email: {{ user.email }}</p>
</body>
</html>

此视图使用 Handlebars 语法显示用户信息。

控制器（Controller）

控制器是 MVC 架构中的指挥中心。在 Nest.js 中，控制器负责处理传入的请求，并返回响应给客户端。控制器使用装饰器来定义路由，并将请求路由到对应的处理函数。

typescript 复制代码

import { Controller, Get, Post, Body, Param } from '@nestjs/common';
import { UserService } from './user.service';
import { User } from './user.entity';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get()
  async findAll(): Promise<User[]> {
    return this.userService.findAll();
  }

  @Get(':id')
  async findOne(@Param('id') id: string): Promise<User> {
    return this.userService.findOne(id);
  }

  @Post()
  async create(@Body() user: User): Promise<void> {
    await this.userService.create(user);
  }
}

在这个例子中，我们定义了一个 UserController，它有三个方法：获取所有用户、获取一个特定用户和创建一个新用户。这些方法分别与 HTTP 请求的 GET 和 POST 方法对应。

模型定义了应用程序的数据结构，视图负责展示数据（尽管在 Nest.js 中通常是由前端框架处理），而控制器则作为模型和视图之间的桥梁，处理业务逻辑和用户输入。

Nest.js 的 MVC 架构为开发人员提供了一种清晰、模块化的方式来构建应用程序。

访问到一个请求方法后，可能会经过 Controller（控制器）、Service（服务）、Repository（数据库访问）的逻辑。

如果我想在调用 Controller 之前和之后加入一段通用逻辑呢？
AOP 的好处是可以把一些通用逻辑分离到切面中，保持业务逻辑的纯粹性，这样切面逻辑可以复用，还可以动态的增删。

AOP 基础知识

在现代的软件开发实践中，面向划面编程（AOP）是一种编程范式，它允许开发者将横切关注点（cross-cutting concerns）从业务逻辑中分离出来。这有助于增强模块化，使得代码更易于理解、维护和扩展。

Nest.js 作为一个强大的 Node.js 框架，提供了一套丰富的装饰器和帮助函数来支持 AOP 的实现。AOP 通过封装横切关注点的逻辑，允许开发者在不同的应用程序执行点动态地注入附加行为。

在 Nest.js 中，AOP 通常是通过使用 MiddleWare（中间件） 、 Interceptors （拦截器）、Guards （守卫）、Filters （过滤器）、 **管道（Pipes）**和 Custom Decorators（自定义装饰器）来实现的。接下来，我们将详细了解这些组件和它们在 AOP 中的作用。

中间件（Middleware）

在 Nest.js 中，中间件是处于请求和响应周期中的一个关键点，它们类似于 Express 或 Koa 中的中间件。

中间件的主要作用是在请求被路由处理程序处理之前，执行一些代码，可以用来执行诸如日志记录、请求验证、设置请求头或者结束请求/响应周期等任务。

中间件函数可以访问请求对象（req）、响应对象（res）以及应用的 next 函数，next 函数是一个当被调用时将控制权交给下一个中间件的函数。

如果当前中间件没有结束请求/响应循环，则必须调用 next()，以将控制权传递给下一个中间件，否则请求将被挂起。

在 Nest.js 中，中间件需要实现 NestMiddleware 接口，并定义 use 方法。以下是一个中间件的简单示例，用于记录请求信息：

typescript 复制代码

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`${req.method} ${req.originalUrl}`);
    next();
  }
}

在上述代码中，LoggerMiddleware 类实现了 use 方法，该方法记录了请求的 HTTP 方法和 URL，然后调用 next() 以继续处理请求。

要将中间件应用到 Nest.js 应用程序中，你需要在模块中使用 configure 方法来设置它们。通常，你会在 configure 方法中指定中间件应该应用到的路由。例如：

typescript 复制代码

import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';

@Module({
  // ...
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('*'); // 应用到所有的路由
  }
}

在 AppModule 类中，我们实现了 NestModule 接口的 configure 方法，并通过 MiddlewareConsumer 的 apply 和 forRoutes 方法指定了中间件和中间件应用的路由。

中间件是处理请求流程中不可或缺的一个环节，在 Nest.js 中，中间件提供了一种弹性极高的方法来介入请求和响应的过程。通过合理地使用中间件，可以大大增强应用程序的功能性和灵活性。

守卫（Guards）

在 Nest.js 中，守卫主要负责处理请求的权限控制。通常是在路由处理程序执行之前，来决定是否允许请求继续进行。这使得守卫成为实现例如认证和授权这类横切关注点的理想选择。

守卫是通过实现 CanActivate 接口创建的。每个守卫都必须提供一个 canActivate 函数，它返回一个布尔值或一个返回布尔值的 Promise 或 Observable，以确定是否可以继续当前请求。

下面是一个简单的守卫示例，它检查请求是否包含有效的认证令牌：

typescript 复制代码

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const request = context.switchToHttp().getRequest();
    return this.validateRequest(request);
  }

  private validateRequest(request: Request): boolean {
    // 这里应该有一个真实的验证逻辑，这里仅作为示例
    return request.headers.authorization === 'some-secret-token';
  }
}

在上面的代码中，AuthGuard 检查传入请求的 authorization 头是否符合预期。

在实际应用中，validateRequest 方法会包含更复杂的逻辑，可能会调用一个服务来验证令牌的有效性。

要在 Nest.js 应用程序中使用守卫，你可以将其绑定到控制器或路由处理程序级别：

typescript 复制代码

// 绑定到控制器
@Controller('users')
@UseGuards(AuthGuard)
export class UsersController {
  // ...
}

// 绑定到路由处理程序
@Controller('users')
export class UsersController {
  @Get(':id')
  @UseGuards(AuthGuard)
  getUserById(@Param('id') id: string) {
    // ...
  }
}

通过使用守卫，你可以确保只有经过验证和授权的请求才能访问特定的处理程序或控制器，从而增加了应用程序的安全性。

也可以绑定到全局模块，这样通过 provider 的方式声明的 Guard 是在 IoC 容器里的，可以注入别的 provider：

typescript 复制代码

// app.module.ts
@Module({
  providers: [
    {
      provide: APP_GUARD, // 使用 APP_GUARD 令牌
      useClass: AuthGuard, // 将 AuthGuard 声明为全局的 Guard
    },
    AuthService,
  ],
})
export class AppModule {}

typescript 复制代码

// auth.guard.ts
@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private authService: AuthService) {}

  canActivate(context: ExecutionContext): boolean | Promise<boolean> | Observable<boolean> {
    // 在这里可以使用注入的 AuthService 进行身份验证逻辑
    return this.authService.isAuthenticated();
  }
}

拦截器（Interceptors）

拦截器是 Nest.js 中实现 AOP 的核心概念之一。它们允许你在方法执行之前或之后插入额外的逻辑。

拦截器非常适合处理日志记录、异常映射、事务处理等横切关注点。

在 Nest.js 中，拦截器是通过实现 NestInterceptor 接口创建的。拦截器有一个 intercept 方法，该方法接收两个参数：

ExecutionContext 和 CallHandler。ExecutionContext 提供了当前请求的详细信息，而 CallHandler 是一个可调用的流，代表了处理的下一个步骤（通常是路由处理程序）。

让我们通过一个日志记录的示例来看看拦截器是如何工作的：

typescript 复制代码

import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  CallHandler,
} from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log('Before...');

    const now = Date.now();
    return next
      .handle()
      .pipe(
        tap(() => console.log(`After... ${Date.now() - now}ms`))
      );
  }
}

在上面的代码中，我们创建了一个简单的 LoggingInterceptor，它在请求处理之前和之后打印日志，并记录处理时间。

我们使用 tap 操作符来执行日志记录，它是一个不影响流中数据的 RxJS 操作符。

要在 Nest.js 中使用这个拦截器，你可以将其绑定到模块级别或控制器级别，甚至可以绑定到单个路由处理程序上：

typescript 复制代码

// 绑定到模块级别
@Module({
  providers: [
    {
      provide: APP_INTERCEPTOR,
      useClass: LoggingInterceptor,
    },
  ],
})
export class AppModule {}


// 绑定到控制器或路由处理程序
@Controller()
@UseInterceptors(LoggingInterceptor)
export class SomeController {
  @Get()
  @UseInterceptors(LoggingInterceptor)
  findAll() {
    // ...
  }
}

拦截器提供了一种强大而灵活的方式来应用通用的处理逻辑，而不会污染我们的业务逻辑代码。

Interceptor 和 Middleware 的区别主要在于参数不同。

Interceptor 可以拿到调用的 controller 和 handler。

typescript 复制代码

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log('Before...');
    
    const controller = context.getClass(); // 获取当前调用的控制器
    const handler = context.getHandler(); // 获取当前调用的处理器
    
    // 执行下一个中间件或处理器
    return next.handle().pipe(
      tap(() => console.log('After...'))
    );
  }
}

管道（Pipes）

在Nest.js中，管道（Pipes）是另一个核心概念，用于处理请求中的输入数据，例如验证或转换数据。管道可以在数据到达路由处理程序之前执行一些操作，确保路由处理程序接收到的数据是正确和预期的格式。

管道主要有两种用途：

验证（Validation）：确保传入的数据符合一定的标准，如果数据无效，可以抛出异常。
转换（Transformation）：将输入数据转换成期望的形式，例如从字符串转换为整数，或者从用户输入的日期字符串转换为Date对象。

管道通过实现 PipeTransform 接口来创建，该接口包含一个 transform 方法。这个方法接收两个参数：当前处理的值和一个 ArgumentMetadata 对象，后者包含关于当前参数的元数据。

下面是一个简单的管道示例，用于验证字符串长度：

typescript 复制代码

import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';

@Injectable()
export class ValidateStringLengthPipe implements PipeTransform<string> {
  constructor(private readonly minLength: number) {}

  transform(value: string, metadata: ArgumentMetadata): string {
    if (value.length < this.minLength) {
      throw new BadRequestException(`The string is too short. Should be at least ${this.minLength} characters long.`);
    }
    return value;
  }
}

在上述例子中，ValidateStringLengthPipe确保一个字符串至少有指定的最小长度。如果不是，它会抛出BadRequestException。

使用管道的示例如下：

typescript 复制代码

@Controller('cats')
export class CatsController {
  @Post()
  async create(@Body(new ValidateStringLengthPipe(10)) body: string) {
    // ...
  }
}

在 CatsController 的 create 方法中，我们通过 @Body 装饰器和管道结合使用，以确保传入的 body 至少有 10 个字符长。如果客户端发送了一个长度小于10 的字符串，请求将会失败，并且会返回一个 BadRequestException。

Nest.js 内置了一些常用的管道，例如 ValidationPipe，它可以与类验证器（class-validator）库结合使用，提供强大的数据验证功能。

使用管道可以极大提升应用程序的健壮性，确保应用程序的业务逻辑处理之前，输入数据的正确性和有效性。

Nest 内置了一些 Pipe：

ValidationPipe
ParseIntPipe
ParseBoolPipe
ParseArrayPipe
ParseUUIDPipe
DefaultValuePipe
ParseEnumPipe
ParseFloatPipe
ParseFilePipe

管道不仅支持上面对某个参数级别生效，也能对整个 Controller 、方法、全局都生效。

typescript 复制代码

// 参数级别的 Pipes
@Get(':id')
getUserById(@Param('id', ParseIntPipe) id: number) {
  // ...
}

// Controller 生效
@Controller('users')
@UsePipes(ValidationPipe)
export class UsersController {
  // ...
}

// 方法级别的 Pipes
@Controller('users')
export class UsersController {
  @Post()
  @UsePipes(ValidationPipe)
  createUser(@Body() createUserDto: CreateUserDto) {
    // ...
  }
}

// 全局 Pipes
import { Module } from '@nestjs/common';
import { APP_PIPE } from '@nestjs/core';
import { ValidationPipe } from './pipes/validation.pipe';

@Module({
  providers: [
    {
      provide: APP_PIPE,
      useClass: ValidationPipe,
    },
  ],
})
export class AppModule {}

自定义装饰器（Custom Decorators）

自定义装饰器在 Nest.js 中提供了一种强大的方式来封装和重用注解逻辑。它们可以用来提取请求中的特定数据，或者注入依赖项等。创建自定义装饰器通常涉及到定义一个函数，它返回一个装饰器工厂的结果。

让我们看一个常见的例子：创建一个自定义装饰器来提取 JWT（JSON Web Token）中的用户信息。

typescript 复制代码

import { createParamDecorator, ExecutionContext } from '@nestjs/common';

export const GetUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user; // 假设请求已经通过某个中间件添加了`user`属性
  },
);

在上面的代码中，GetUser 装饰器允许我们直接在路由处理程序的参数中提取用户对象，这样可以非常方便地访问当前请求的用户信息。

使用这个装饰器的示例如下：

typescript 复制代码

@Controller('profile')
export class ProfileController {
  @Get()
  getProfile(@GetUser() user) {
    return user;
  }
}

在 ProfileController 的 getProfile 方法中，我们使用了 @GetUser() 装饰器来获取当前请求的用户对象。这样的封装使得控制器的代码更加清晰，也更容易测试。

自定义装饰器可以用于多种情况，比如权限验证、日志记录、业务逻辑等，它们为你的 Nest.js 应用程序提供了更高的灵活性和模块化。

同样自定义装饰器定义后，使用的方式也有多种，有类装饰器、方法装饰器、参数装饰器、属性装饰器。

异常过滤器（ExceptionFilter）

异常过滤器在 Nest.js 中是处理异常的推荐方式。它们提供了一种方法来捕获控制器中抛出的异常，并根据需要对其进行处理，例如记录日志、转换异常对象，或者发送自定义的响应给客户端。这样可以确保你的错误处理逻辑集中化，易于管理。

异常过滤器通过实现 ExceptionFilter 接口并定义 catch 方法来创建。在 catch 方法中，你可以处理异常，并调用 HttpArgumentsHost 来控制返回给客户端的响应。

下面是一个简单的异常过滤器示例：

typescript 复制代码

import {
  ExceptionFilter,
  Catch,
  ArgumentsHost,
  HttpException,
  HttpStatus,
} from '@nestjs/common';

@Catch(HttpException)
export class HttpErrorFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();
    const status = exception.getStatus();

    const errorResponse = {
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      method: request.method,
      message: exception.message || null,
    };

    response
      .status(status)
      .json(errorResponse);
  }
}

在这个例子中，HttpErrorFilter 捕获 HttpException 及其子类的异常。当异常发生时，它构造了一个包含错误信息和其他相关信息的响应体，并将其返回给客户端。

要在你的 Nest.js 应用中使用此过滤器，你可以绑定它到整个应用、某个控制器或者具体的路由处理程序上，如下所示：

typescript 复制代码

// 绑定到全局
import { Module } from '@nestjs/common';

@Module({
  // ...
  providers: [
    {
      provide: APP_FILTER,
      useClass: HttpErrorFilter,
    },
  ],
})
export class AppModule {}

// 绑定到控制器
@Controller('some-route')
@UseFilters(HttpErrorFilter)
export class SomeController {
  // ...
}

// 绑定到路由处理程序
@Controller('some-route')
export class SomeController {
  @Get()
  @UseFilters(HttpErrorFilter)
  findSomeRoute() {
    // ...
  }
}

Nest 内置了很多 http 相关的异常，都是 HttpException 的子类：

BadRequestException
UnauthorizedException
NotFoundException
ForbiddenException
NotAcceptableException
RequestTimeoutException
ConflictException
GoneException
PayloadTooLargeException
UnsupportedMediaTypeException
UnprocessableException
InternalServerErrorException
NotImplementedException
BadGatewayException
ServiceUnavailableException
GatewayTimeoutException

当然，也可以 extends HttpException 自己扩展。
Nest 通过这样的方式实现了异常到响应的对应关系，代码里只要抛出不同的异常，就会返回对应的响应。

几种 AOP 方式的顺序

顺序如下：

中间件 (Middleware): 在路由处理程序之前执行，通常用于执行一些全局的任务，比如日志记录、请求预处理等。
守卫 (Guards): 在中间件之后、路由处理程序和拦截器之前执行，主要用于权限验证和授权。
拦截器 (Interceptors): 在守卫之后、路由处理程序之前执行，可以用于绑定额外的逻辑，如转换返回结果、绑定额外的逻辑到方法的执行之前或之后、扩展基本方法行为等。
管道 (Pipes): 可以在参数处理时执行，如数据转换和验证。
路由处理程序 (Route Handler): 实际的控制器方法，在这里执行请求的主要逻辑。
异常过滤器 (Exception Filters): 在路由处理程序之后执行，用于捕获和处理异常。

注意：自定义装饰器通常是用来注入额外的元数据到类、方法或者参数中，它们并不直接参与请求处理流程的顺序。

如果你的自定义装饰器是在管道、守卫、拦截器中使用的，那么它们的作用将会在这些特定组件的执行阶段体现出来。例如：

如果你在参数上使用自定义装饰器来提取或转换请求中的某些数据，那么这个装饰器的效果会在管道处理这个参数时体现。
如果你在守卫或拦截器中使用自定义装饰器来获取方法或类上的元数据，那么这个装饰器的效果会在守卫或拦截器执行时体现。

总的来说，自定义装饰器的作用是在它们被应用的地方体现的，并且它们的执行顺序取决于它们被用于哪个请求处理阶段的组件中。

拦截器可以被组织成一个链条，每个拦截器都可以在请求到达目标处理程序之前或之后执行某些逻辑。当有多个拦截器应用于一个路由时，它们的执行顺序将按照它们在代码中的声明顺序依次执行。

例如，假设有三个拦截器：拦截器A、拦截器B 和拦截器C。当请求到达目标处理程序之前，首先会执行拦截器A 的逻辑，然后是拦截器B 的逻辑，最后是拦截器C 的逻辑。类似地，在响应返回之前，拦截器C 的逻辑会先执行，然后是拦截器B 的逻辑，最后是拦截器A 的逻辑。

最佳实践

通过前面的介绍，我们了解到 Nest.js 通过提供拦截器、守卫、过滤器和自定义装饰器等强大的特性，使得面向切面编程（AOP）成为可能。AOP 在 Nest.js 应用程序中的应用提高了代码的模块化，使得横切关注点的管理变得更为集中和统一。

在实际开发中，要充分利用 AOP 带来的好处，以下是一些最佳实践：

明确划分责任：确保 AOP 的实现专注于单一职责，例如日志记录应只关注日志处理，认证守卫应只处理认证逻辑。
适度使用：虽然 AOP 提供了强大的工具来解耦代码，但过度使用可以使代码变得难以理解和维护。在考虑使用 AOP 之前，应评估是否真的需要。
统一处理异常：通过全局异常过滤器统一处理异常，可以避免在业务逻辑中到处编写错误处理代码。
重用逻辑：在可能的情况下，应该创建可重用的拦截器、守卫和装饰器，以减少重复代码并提高效率。
编写可测试的代码：AOP 实现应该易于单元测试，确保拦截器、守卫等能够在隔离环境中测试其逻辑。
文档化：对于自定义装饰器、拦截器等 AOP 元素，应该提供清晰的文档说明其用途和使用方式，以便团队成员理解和正确使用。

总结来说，Nest.js 的 AOP 功能为构建可维护、可扩展和高效的 Node.js 应用程序提供了强有力的支持。通过本文的介绍，希望你能够深入理解这些概念，并在你的下一个 Nest.js 项目中运用这些强大的工具。

nest 中绝对的核心 ioc di、mvc、aop

控制反转（IoC）和 依赖注入（DI）

Nest.js 中的 DI 实现

MVC

模型（Model）

视图（View）

控制器（Controller）

AOP 基础知识

中间件（Middleware）

守卫（Guards）

拦截器（Interceptors）

管道（Pipes）

自定义装饰器（Custom Decorators）

异常过滤器（ExceptionFilter）

几种 AOP 方式的顺序

最佳实践

控制反转（IoC）和依赖注入（DI）