使用NestJS开发Node.js应用的方法

我来讲解使用 NestJS 开发 Node.js 应用的方法完整攻略。

总体概述

什么是 Nest？

Nest 是一个基于 Express，Fastify 的框架，用来构建优雅的、可拓展的应用程序。

为什么选择 Nest？

基于 Typescript，拥有更好的类型安全和代码可读性
支持依赖注入 (DI)
可以很容易地整合第三方库
可以使用与 Angular 相同的装饰器语法声明模块和控制器
注重模块化设计，易于维护和拓展

安装 Nest

Nest 官方提供了命令行工具 @nestjs/cli，可以帮助我们快速创建一个 Nest 应用。

npm i -g @nestjs/cli
nest new project-name

安装 Nest 后，我们可以使用 nest new 命令创建新项目，这样会自动帮我们安装好必要的依赖和配置文件。

创建 Controller 和 Service

创建 Controller

在 Nest 应用中，Controller 负责处理 HTTP 请求以及响应。使用 @Controller() 装饰器可以声明一个 Controller。

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

@Controller('hello')
export class HelloController {
  @Get()
  sayHello(): string {
    return 'Hello Nest!';
  }
}

在上面的例子中，我们声明了一个名为 HelloController 的 Controller，并把路由路径设为 /hello。在 sayHello 方法中，我们返回了一个字符串 'Hello Nest!'。

创建 Service

在 Nest 应用中，Service 可以用来实现业务逻辑，并将其注入到 Controller 中使用。使用 @Injectable() 装饰器可以声明一个 Service。

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

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

在上面的例子中，我们声明了一个名为 HelloService 的 Service，并在其中实现了一个名为 getHello 的方法。

注册 Controller 和 Service

注册 Controller

在 Nest 应用中，可以使用 @Module() 装饰器声明一个模块。与模块相关联的 Controller 和 Service 可以在 @Module() 装饰器中进行注册和引入。

import { Module } from '@nestjs/common';
import { HelloController } from './hello.controller';

@Module({
  controllers: [HelloController],
})
export class HelloModule {}

在上面的例子中，我们声明了一个名为 HelloModule 的 Module，并注册了我们之前声明的 HelloController。

注册 Service

与注册 Controller 类似，我们可以在 @Module() 装饰器的 providers 属性中注册 Service。

import { Module } from '@nestjs/common';
import { HelloController } from './hello.controller';
import { HelloService } from './hello.service';

@Module({
  controllers: [HelloController],
  providers: [HelloService],
})
export class HelloModule {}

在上面的例子中，我们将之前声明的 HelloService 注册到了 HelloModule 中。

示例

下面是一个创建了一个简单的 API 并使用 MongoDB 存储数据的 Nest 应用示例。

第一步：创建新应用

首先，我们使用 Nest CLI 创建新应用，并安装 Express 和 Mongoose 依赖。

nest new nest-mongoose-sample
cd nest-mongoose-sample
npm i express mongoose

第二步：连接 MongoDB

在 app.module.ts 中导入 Mongoose 模块并连接 MongoDB 数据库。

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

@Module({
  imports: [MongooseModule.forRoot('mongodb://localhost/nest-mongoose-sample')],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

在上面的例子中，我们导入了 Mongoose 模块，并使用 MongooseModule.forRoot 方法连接了 MongoDB 数据库 (mongodb://localhost/nest-mongoose-sample)。

第三步：创建 Model

在 Nest 应用中，我们可以使用 @Schema() 和 @Prop() 装饰器来声明一个 Mongoose Model。

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

@Schema()
export class Cat extends Document {
  @Prop()
  name: string;

  @Prop()
  age: number;

  @Prop()
  breed: string;
}

export const CatSchema = SchemaFactory.createForClass(Cat);

在上面的例子中，我们声明了一个名为 Cat 的 Mongoose Model，包含了三个字段：name、age 和 breed。

第四步：创建 Controller 和 Service

我们创建了一个名为 cat.service.ts 的 Service，并使用 Mongoose 实现了增删改查等方法。

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Cat, CatDocument } from './cat.schema';

@Injectable()
export class CatService {
  constructor(@InjectModel(Cat.name) private catModel: Model<CatDocument>) {}

  async create(cat: Cat): Promise<Cat> {
    const createdCat = new this.catModel(cat);
    return createdCat.save();
  }

  async findAll(): Promise<Cat[]> {
    return this.catModel.find().exec();
  }

  async findOne(id: string): Promise<Cat> {
    return this.catModel.findById(id).exec();
  }

  async delete(id: string): Promise<Cat> {
    return this.catModel.findByIdAndDelete(id).exec();
  }
}

在上面的例子中，我们使用 @InjectModel 装饰器在 Service 中注入了 Cat Model。然后实现了 create、findAll、findOne 和 delete 等方法。

我们创建了一个名为 cat.controller.ts 的 Controller，并调用 CatService 中的方法。

import { Controller, Get, Post, Body, Param, Delete } from '@nestjs/common';
import { CatService } from './cat.service';
import { Cat } from './cat.schema';

@Controller('cat')
export class CatController {
  constructor(private readonly catService: CatService) {}

  @Post()
  create(@Body() cat: Cat): Promise<Cat> {
    return this.catService.create(cat);
  }

  @Get()
  findAll(): Promise<Cat[]> {
    return this.catService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string): Promise<Cat> {
    return this.catService.findOne(id);
  }

  @Delete(':id')
  delete(@Param('id') id: string): Promise<Cat> {
    return this.catService.delete(id);
  }
}

在上面的例子中，我们使用 @Body() 和 @Param() 装饰器分别提取请求参数和路径参数，并调用 CatService 中的方法。

第五步：注册 Controller 和 Service

最后，在 app.module.ts 中注册 CatController 和 CatService。

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { Cat, CatSchema } from './cat.schema';
import { CatController } from './cat.controller';
import { CatService } from './cat.service';

@Module({
  imports: [MongooseModule.forRoot('mongodb://localhost/nest-mongoose-sample'), MongooseModule.forFeature([{ name: Cat.name, schema: CatSchema }])],
  controllers: [CatController],
  providers: [CatService],
})
export class AppModule {}

在上面的例子中，我们注册了 CatController 和 CatService。使用 MongooseModule.forFeature 方法注册了 Cat Model。

现在，可以使用下面的命令运行该应用。