掌握 NestJS：使用核心概念构建强大的应用程序

NestJS 是一个功能强大的框架，可用于构建各种类型的应用程序，包括 API、微服务和独立应用。它利用模块、控制器、提供程序、中间件、守卫、拦截器、管道和异常过滤器来有效地管理请求处理流程。本博客将深入探讨 NestJS 的核心概念，并提供示例，帮助您了解如何利用其功能构建强大的应用程序。

NestJS 的关键概念

模块：构建块

模块是 Nest 应用程序的基本构建块，它们构成一个图形结构，模块之间可以相互嵌套。模块是一个带有@Module装饰器注解的类，用于组织相关组件，例如控制器、提供程序和服务。

// src/app.module.ts
import { Module } from '@nestjs/common';
import { UsersModule } from './users/users.module';

@Module({
  imports: [UsersModule],
})
export class AppModule {}

控制器：处理请求

NestJS 中的控制器处理传入的请求并生成响应。它们定义用于处理请求的路由和方法，从而支持创建用于各种操作的端点。

// src/users/users.controller.ts
import { Controller, Get } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get()
  findAll() {
    return this.usersService.findAll();
  }
}

提供者：依赖注入

NestJS 中的提供程序是可以作为依赖项注入到其他类的类。这有助于代码组织和可重用性。

// src/users/users.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class UsersService {
  private readonly users = ['John Doe', 'Jane Doe'];

  findAll() {
    return this.users;
  }
}

中间件：控制请求流

NestJS 中的中间件可以记录传入的请求并控制请求流程的各个阶段。中间件函数可以在路由处理程序调用之前执行。

// src/common/middleware/logger.middleware.ts
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(`Request...`);
    next();
  }
}

// src/app.module.ts
import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';

@Module({
  // ...
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes('*');
  }
}

警卫：安全检查

NestJS 中的防护装置充当安全检查，确定请求在到达根处理程序之前是否满足指定条件，例如角色或权限。

// src/common/guards/roles.guard.ts
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';

@Injectable()
export class RolesGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest();
    const user = request.user;
    return user && user.roles && user.roles.includes('admin');
  }
}

// src/app.module.ts
import { APP_GUARD } from '@nestjs/core';
import { RolesGuard } from './common/guards/roles.guard';

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

拦截器：管理请求和响应

拦截器提供对请求和响应周期的完全控制，允许在根处理程序之前和之后执行日志记录、缓存和数据映射等任务。

// src/common/interceptors/logging.interceptor.ts
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`)),
      );
  }
}

// src/app.module.ts
import { APP_INTERCEPTOR } from '@nestjs/core';
import { LoggingInterceptor } from './common/interceptors/logging.interceptor';

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

管道：验证和转换数据

NestJS 中的管道在数据到达处理程序之前会进行验证和转换。这确保数据符合预定义的处理标准。

// src/common/pipes/validation.pipe.ts
import { PipeTransform, Injectable, ArgumentMetadata, BadRequestException } from '@nestjs/common';

@Injectable()
export class ValidationPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    if (typeof value !== 'string') {
      throw new BadRequestException('Validation failed');
    }
    return value.toUpperCase();
  }
}

// src/app.module.ts
import { APP_PIPE } from '@nestjs/core';
import { ValidationPipe } from './common/pipes/validation.pipe';

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

异常过滤器：处理错误

异常过滤器捕获并处理来自请求处理各个部分的错误，提供一种集中的方式来管理错误并确保一致的错误响应。

// src/common/filters/http-exception.filter.ts
import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
import { Request, Response } from 'express';

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

    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
    });
  }
}

// src/app.module.ts
import { APP_FILTER } from '@nestjs/core';
import { HttpExceptionFilter } from './common/filters/http-exception.filter';

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

结论

NestJS 提供了一个强大的框架，用于构建可扩展且可维护的应用程序。通过理解和利用其核心概念——模块、控制器、提供程序、中间件、守卫、拦截器、管道和异常过滤器——您可以有效地管理请求处理流程，并创建功能多样且易于维护的应用程序。这些示例演示了如何在实际场景中应用这些概念，帮助您构建强大而高效的 NestJS 应用程序。

文章来源：https://dev.to/vyan/mastering-nestjs-building-robust-applications-with-core-concepts-5gm3