Nest应用开发入门教程

概述

Nest框架是一个用于构建高效、可扩展的Node.js服务器端应用程序的框架，采用了现代JavaScript的最佳实践。它支持面向对象编程、函数式编程、依赖注入等特性，并且可以与多种数据库和消息队列配合使用，提供高性能的服务。

Nest框架简介

什么是Nest框架

Nest框架是一个用于构建高效、可扩展的Node.js服务器端应用程序的框架。它采用了现代JavaScript开发的最佳实践，包括面向对象的方法、装饰器和依赖注入。Nest框架的核心设计理念是模块化，这使得开发者能够轻松地将应用程序分解成易于管理和测试的小模块。

Nest框架的灵感来源于Angular框架和TypeScript语言。与Angular类似，Nest框架也使用了装饰器来定义路由、控制器等。同时，它受益于TypeScript的静态类型检查，从而提高了开发效率和代码质量。

Nest框架的特点和优势

Nest框架具有以下特点和优势：

1. 面向对象编程：Nest使用面向对象的设计模式，使得代码结构更加清晰，易于维护。
2. 函数式编程：支持函数式编程，使得代码更加简洁和易于理解。
3. 依赖注入：通过依赖注入，可以将服务注入到控制器和其他组件中，提高代码的可测试性和模块化。
4. 可插拔中间件：支持使用Express中间件，扩展应用程序的功能。
5. 模块化设计：应用程序可以被分解成独立的模块，便于管理和扩展。
6. 跨平台支持：支持多种数据库和消息队列，如MySQL、PostgreSQL、Redis等。
7. 高性能：Nest框架基于Node.js，可以提供高性能的服务。

安装和配置Nest框架

安装Nest框架需要遵循以下步骤：

1. 安装Node.js和npm：确保你的开发环境中已经安装了Node.js和npm。可以通过运行命令 node -v 和 npm -v 来检查版本信息。
2. 安装Nest CLI：使用npm全局安装Nest CLI工具，通过Nest CLI可以快速生成Nest项目。

   npm install -g @nestjs/cli

3. 创建Nest项目：使用Nest CLI创建一个新的Nest项目。

   nest new project-name

4. 启动开发服务器：进入项目目录并启动开发服务器。

   cd project-name
   npm run start:dev

启动后，Nest框架会启动一个本地开发服务器，默认监听端口3000。可以通过浏览器访问http://localhost:3000来查看应用是否正常运行。

创建第一个Nest应用

初步了解Nest项目结构

Nest项目的基本结构包括以下几个主要部分：

• app.module.ts：主模块文件，定义了应用的核心配置。
• main.ts：应用入口文件，启动Nest应用。
• app.controller.ts：控制器文件，定义了应用的路由和处理方法。
• app.service.ts：服务文件，定义了应用的服务逻辑。
• data/、config/、services/、controllers/、guards/、interceptors/、pipes/、modules/：这些目录用于存放不同类型的应用模块和组件。

示例代码

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

// app.module.ts
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

// app.controller.ts
import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

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

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}

使用Nest CLI生成项目

使用Nest CLI可以快速生成项目结构，例如生成一个新的控制器、服务、模块等。下面是一个生成控制器的示例：

1. 生成控制器：

   nest g controller example

   这将生成一个名为example.controller.ts的控制器文件，同时在app.module.ts中添加了相应的导入和配置。

2. 生成服务：

   nest g service example

   这将生成一个名为example.service.ts的服务文件，同时在app.module.ts中添加了相应的导入和配置。

运行和测试应用

1. 启动应用：
   使用npm run start:dev命令启动开发服务器。

   npm run start:dev

2. 测试应用：
   访问http://localhost:3000，查看应用是否正常运行。

控制器与路由

定义控制器

控制器负责处理HTTP请求。每个控制器都对应着一组路由和处理方法。一个控制器可以定义多个处理方法，每个方法都对应着一个HTTP请求。以下是一个简单的控制器示例：

import { Controller, Get } from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Get()
  getUsers(): string {
    return 'List of users';
  }

  @Get(':id')
  getUserById(id: number): string {
    return `User with id ${id}`;
  }
}

在这个示例中，UsersController对应着/users路由。getUsers方法处理GET /users请求，getUserById方法处理GET /users/:id请求。

示例代码

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

@Controller('users')
export class UsersController {
  @Get()
  getUsers(): string {
    return 'List of users';
  }

  @Get(':id')
  getUserById(@Param('id') id: number): string {
    return `User with id ${id}`;
  }
}

在app.module.ts中，需要导入并注册这个控制器：

import { Module } from '@nestjs/common';
import { UsersController } from './users/users.controller';

@Module({
  imports: [],
  controllers: [UsersController],
  providers: [],
})
export class AppModule {}

控制器中的请求处理方法

请求处理方法可以接收HTTP请求参数，并返回相应的响应。以下是一个请求处理方法的示例：

import { Controller, Get, Param } from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Get(':id')
  getUserById(@Param('id') id: number): string {
    return `User with id ${id}`;
  }
}

在上面的示例中，@Param('id')装饰器用于从URL路径中提取id参数。id参数的值会被自动转换为number类型。

示例代码

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

@Module({
  imports: [],
  controllers: [UsersController],
  providers: [],
})
export class AppModule {}

使用装饰器定义路由

Nest框架使用装饰器来定义路由。以下是一些常用的路由装饰器：

• @Get()：定义GET请求。
• @Post()：定义POST请求。
• @Put()：定义PUT请求。
• @Delete()：定义DELETE请求。
• @Patch()：定义PATCH请求。
• @All()：定义所有类型的请求。

示例代码

import { Controller, Get, Post, Put, Delete, Param } from '@nestjs/common';

@Controller('users')
export class UsersController {
  @Get()
  getUsers(): string {
    return 'List of users';
  }

  @Get(':id')
  getUserById(@Param('id') id: number): string {
    return `User with id ${id}`;
  }

  @Post()
  createUser(): string {
    return 'Create a user';
  }

  @Put(':id')
  updateUser(@Param('id') id: number): string {
    return `Update user with id ${id}`;
  }

  @Delete(':id')
  deleteUser(@Param('id') id: number): string {
    return `Delete user with id ${id}`;
  }
}

服务与依赖注入

创建服务

服务用于封装应用的业务逻辑。服务通常不直接处理HTTP请求，而是由控制器调用。服务可以被注入到控制器中，从而实现依赖注入。

以下是一个简单的服务示例：

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

@Injectable()
export class UserService {
  getUsers(): string {
    return 'List of users';
  }
}

示例代码

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

@Injectable()
export class UserService {
  getUsers(): string {
    return 'List of users';
  }
}

使用依赖注入

依赖注入是一种设计模式，用于管理对象之间的依赖关系。在Nest框架中，可以通过构造函数注入服务。

以下是一个使用依赖注入的控制器示例：

import { Controller, Get } from '@nestjs/common';
import { UserService } from './user.service';

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

  @Get()
  getUsers(): string {
    return this.userService.getUsers();
  }
}

示例代码

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

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

  @Get()
  getUsers(): string {
    return this.userService.getUsers();
  }
}

在app.module.ts中，需要导入并注册这个服务：

import { Module } from '@nestjs/common';
import { UsersController } from './users/users.controller';
import { UserService } from './user.service';

@Module({
  imports: [],
  controllers: [UsersController],
  providers: [UserService],
})
export class AppModule {}

服务中的异步操作

服务中可以执行异步操作。例如，可以通过Promise或async/await处理异步请求。

示例代码

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

@Injectable()
export class UserService {
  getUsers(): Promise<string> {
    return new Promise((resolve) => {
      setTimeout(() => {
        resolve('List of users');
      }, 1000);
    });
  }
}

// async版user.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class UserService {
  async getUsers(): Promise<string> {
    await new Promise((resolve) => setTimeout(resolve, 1000));
    return 'List of users';
  }
}

模板和视图

使用模板引擎

Nest框架支持多种模板引擎，例如EJS、Pug、Handlebars等。这里以EJS为例进行说明。

安装EJS模板引擎

首先，需要安装EJS模板引擎：

npm install ejs --save

然后，在app.module.ts中配置EJS模板引擎：

import { Module } from '@nestjs/common';
import { EjsAdapter, EjsEngine } from '@nestjs/platform-express';
import { join } from 'path';

@Module({
  imports: [],
  controllers: [UsersController],
  providers: [UserService, {
    provide: EjsEngine,
    useFactory: () => new EjsEngine(new EjsAdapter(), {
      views: join(__dirname, 'views'),
      cache: false,
    }),
  }],
})
export class AppModule {}

创建模板文件

在项目中创建一个views目录，然后在其中创建一个users.ejs模板文件：

<!-- views/users.ejs -->
<!DOCTYPE html>
<html>
<head>
  <title>Users</title>
</head>
<body>
  <h1>Users</h1>
  <p><%= users %></p>
</body>
</html>

渲染视图

控制器中可以调用渲染视图的方法，将数据传递给模板文件。

import { Controller, Get } from '@nestjs/common';
import { UserService } from './user.service';

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

  @Get()
  getUsers(): any {
    const users = this.userService.getUsers();
    return { view: 'users', locals: { users } };
  }
}

示例代码

// app.module.ts
import { Module } from '@nestjs/common';
import { EjsAdapter, EjsEngine } from '@nestjs/platform-express';
import { join } from 'path';

@Module({
  imports: [],
  controllers: [UsersController],
  providers: [UserService, {
    provide: EjsEngine,
    useFactory: () => new EjsEngine(new EjsAdapter(), {
      views: join(__dirname, 'views'),
      cache: false,
    }),
  }],
})
export class AppModule {}

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

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

  @Get()
  getUsers(): any {
    const users = this.userService.getUsers();
    return { view: 'users', locals: { users } };
  }
}

<!-- views/users.ejs -->
<!DOCTYPE html>
<html>
<head>
  <title>Users</title>
</head>
<body>
  <h1>Users</h1>
  <p><%= users %></p>
</body>
</html>

模板中的数据传递

在控制器中可以将数据传递给模板文件，例如通过locals对象传递数据。

import { Controller, Get } from '@nestjs/common';
import { UserService } from './user.service';

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

  @Get()
  getUsers(): any {
    const users = this.userService.getUsers();
    return { view: 'users', locals: { users } };
  }
}

示例代码

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

@Injectable()
export class UserService {
  getUsers(): string {
    return 'List of users';
  }
}

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

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

  @Get()
  getUsers(): any {
    const users = this.userService.getUsers();
    return { view: 'users', locals: { users } };
  }
}

<!-- views/users.ejs -->
<!DOCTYPE html>
<html>
<head>
  <title>Users</title>
</head>
<body>
  <h1>Users</h1>
  <p><%= users %></p>
</body>
</html>

错误处理与日志记录

捕捉和处理错误

在Nest框架中，可以通过异常过滤器来处理错误。异常过滤器可以捕获特定类型的异常，并返回自定义的错误响应。

示例代码

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

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

    response.status = status;
    response.json({
      statusCode: status,
      message: exception.message,
      error: exception.error,
    });
  }
}

在app.module.ts中，需要注册这个异常过滤器：

import { Module } from '@nestjs/common';
import { UsersController } from './users/users.controller';
import { UserService } from './user.service';
import { HttpExceptionFilter } from './http-exception.filter';

@Module({
  imports: [],
  controllers: [UsersController],
  providers: [UserService, HttpExceptionFilter],
})
export class AppModule {}

使用中间件增强错误处理

Nest框架支持中间件来增强错误处理。中间件可以在请求处理之前或之后执行额外的操作，例如日志记录、认证等。

示例代码

// logger.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: () => void) {
    console.log('Request received');
    next();
  }
}

在app.module.ts中，需要注册这个中间件：

import { Module } from '@nestjs/common';
import { UsersController } from './users/users.controller';
import { UserService } from './user.service';
import { HttpExceptionFilter } from './http-exception.filter';
import { LoggerMiddleware } from './logger.middleware';

@Module({
  imports: [],
  controllers: [UsersController],
  providers: [UserService, HttpExceptionFilter],
  // 注册中间件
  middleware: [LoggerMiddleware],
})
export class AppModule {}

配置日志记录

Nest框架支持多种日志记录库，例如Winston、Pino等。这里以Winston为例进行说明。

安装Winston

首先，需要安装Winston：

npm install winston --save

然后，在app.module.ts中配置Winston日志记录：

import { Module } from '@nestjs/common';
import { WinstonModule } from 'nest-winston';
import * as winston from 'winston';

@Module({
  imports: [
    WinstonModule.forRoot({
      transports: [
        new winston.transports.Console({
          format: winston.format.combine(
            winston.format.timestamp(),
            winston.format.ms(),
            winston.format.splat(),
          ),
        }),
      ],
    }),
  ],
  controllers: [UsersController],
  providers: [UserService, HttpExceptionFilter],
  middleware: [LoggerMiddleware],
})
export class AppModule {}

在控制器中，可以使用winston对象来记录日志：

import { Controller, Get } from '@nestjs/common';
import { UserService } from './user.service';
import * as winston from 'winston';

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

  @Get()
  getUsers(): any {
    winston.info('Fetching users');
    const users = this.userService.getUsers();
    return { view: 'users', locals: { users } };
  }
}

以上是Nest应用开发入门教程的全部内容。通过本教程，你已经掌握了Nest框架的基本概念和使用方法，可以开始构建自己的Nest应用了。如果你需要进一步学习，可以在慕课网（https://www.imooc.com/）上找到更多关于Nest框架的课程和资源。