Nest学习：新手入门指南

Nest框架是一个基于TypeScript的高效、可扩展的JavaScript应用程序框架，它通过装饰器模式和依赖注入等特性简化了开发流程。本文将详细介绍Nest框架的优势、安装方法以及如何进行基本的CRUD操作和数据库集成。此外，还将介绍如何使用Swagger生成接口文档，并提供测试和部署的指导。在Nest学习过程中，开发者可以充分利用框架的模块化设计和丰富的插件库，快速构建高质量的企业级应用。

Nest框架是一个用于构建高效、可扩展的服务器端JavaScript应用程序的框架。它基于Angular开发团队所设计的TypeScript框架，采用了现代JavaScript的最佳实践。Nest框架的主要特点包括模块化、可测试性以及能够构建复杂的企业级应用。

Nest框架通过采用装饰器模式、依赖注入和面向对象编程的特性，为开发者提供了一种清晰、可维护的方式来组织代码。这些设计模式使得开发者可以专注于实现业务逻辑，而不是花时间和精力在构建复杂的基础设施上。

1. 性能优越：Nest框架能够提供高性能的应用程序，这得益于它使用了Node.js的核心特性，如非阻塞I/O和事件驱动架构。
2. 模块化设计：Nest框架采用了模块化的设计理念，使得代码可以被清晰地组织和划分。模块可以被独立开发、测试、部署和替换，从而提高代码的可维护性。
3. 可测试性：Nest框架支持单元测试和集成测试，使得应用程序的各个部分可以被独立测试，这有助于确保代码的质量和可靠性。
4. 跨平台支持：Nest框架支持多种后端服务，如数据库、消息队列等，这使得开发人员可以轻松地将应用程序部署到不同的环境中。
5. 丰富的生态系统：Nest拥有大量的插件、库和中间件，这些工具可以帮助开发人员快速实现各种功能，如身份验证、日志记录等。

安装Nest框架需要使用Node.js环境。首先确保已经安装了Node.js，然后使用npm（Node Package Manager）来安装Nest CLI，这是一个命令行工具，用于创建和管理Nest项目。

1. 安装Node.js：可以访问官方网站下载最新版本的Node.js。
2. 安装Nest CLI：打开终端（或命令提示符），运行以下命令以全局安装Nest CLI：

   npm install -g @nestjs/cli

3. 验证安装是否成功：运行以下命令来确保Nest CLI已正确安装，并且可以识别nest命令：

   nest --version

安装完成后，你就可以使用Nest CLI来创建新的Nest项目了。可以通过创建一个新项目来开始使用Nest框架：

nest new my-nest-app
cd my-nest-app
npm install
npm run start

这将创建一个新的Nest项目，并安装所需的依赖包。最后的npm run start命令将启动应用程序，并在浏览器中打开默认的/接口。

使用Nest CLI创建一个新项目，可以使用如下命令：

nest new my-first-nest-app
cd my-first-nest-app
npm install
npm run start

这会创建一个基础的Nest项目结构，包括src目录、main.ts文件等。src目录下的文件是项目的核心代码，而main.ts文件则是应用程序的入口。

在项目的package.json文件中，可以看到已安装的依赖包。如果需要安装额外的依赖包，可以使用npm install <package>命令。例如，如果需要使用TypeORM作为数据库操作工具，则可以安装TypeORM依赖：

npm install @nestjs/typeorm typeorm sqlite3 --save

安装完成后，需要在app.module.ts中引入TypeORM模块，并配置数据库连接。编辑app.module.ts文件，添加如下代码：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { User } from './models/user.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'db.sqlite',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true,
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

这里配置了TypeORM的SQLite数据库连接，并指定实体文件的路径。synchronize: true表示在运行时同步数据库模式。

在命令行中，进入到项目根目录并运行以下命令启动应用程序：

npm run start

启动成功后，应用程序将在默认的端口3000上运行。可以通过访问http://localhost:3000/来查看接口文档。

控制器

控制器是处理HTTP请求的地方。在Nest框架中，控制器使用装饰器来定义路由和处理HTTP请求。下面是一个简单的控制器示例：

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

@Controller('users')
export class UsersController {
  @Get()
  findAll(): string {
    return 'This action returns all users';
  }
}

在这个例子中，UsersController定义了一个GET请求到/users路由，当访问该路由时，将返回This action returns all users。

服务

服务是一组逻辑组件，通常用于执行业务逻辑。服务可以被注入到控制器或其他服务中。下面是一个简单的服务示例：

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

@Injectable()
export class UsersService {
  getUsers(): string {
    return 'This is a list of all users';
  }
}

模块

模块是Nest框架的核心概念，用于组织和封装一组相关的控制器、服务和配置。模块可以被其他模块导入以共享资源和功能。下面是一个简单的模块示例：

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

@Module({
  controllers: [UsersController],
  providers: [UsersService],
})
export class UsersModule {}

管道

管道是自定义验证器，用于在控制器接收请求之前对请求数据进行解析和验证。管道可以被应用于单个控制器或全局控制器。下面是一个简单的管道示例：

import { PipeTransform, Injectable, ArgumentMetadata } from '@nestjs/common';
import { validate } from 'class-validator';
import { plainToClass } from 'class-transformer';

@Injectable()
export class ValidationPipe implements PipeTransform {
  transform(value: any, metadata: ArgumentMetadata) {
    const { metatype } = metadata;
    if (!metatype || !this.toValidate(metatype)) {
      return value;
    }
    const object = plainToClass(metatype, value);
    const errors = validate(object);
    if (errors.length > 0) {
      throw new Error('Validation failed');
    }
    return value;
  }

  private toValidate(metatype: any): boolean {
    const types = [String, Boolean, Number, Array, Object];
    return !types.includes(metatype);
  }
}

装饰器的使用

装饰器在Nest框架中广泛使用，用于定义路由、注入依赖等。下面是一些常用的装饰器及其用法：

• @Controller('users')：定义控制器。
• @Get()：定义GET请求。
• @Inject()：定义服务注入。
• @UsePipes(ValidationPipe)：定义管道应用。

依赖注入

依赖注入是Nest框架的核心特性之一，用于管理对象之间的依赖关系。下面是一个简单的依赖注入示例：

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

@Injectable()
export class UsersController {
  constructor(private readonly userService: UserService) {}

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

在这个例子中，UserService被注入到UsersController中，从而在UsersController中可以直接访问UserService的方法。

CRUD（Create, Read, Update, Delete）操作是Web应用中最常见的操作之一。下面是一个简单的CRUD操作示例，使用TypeORM实现：

数据库模型

首先，定义数据库模型。例如，创建一个User实体：

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

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

  @Column()
  name: string;

  @Column()
  email: string;
}

服务

然后，在服务中实现CRUD操作：

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  async create(name: string, email: string): Promise<User> {
    const user = this.userRepository.create({ name, email });
    return this.userRepository.save(user);
  }

  async findAll(): Promise<User[]> {
    return this.userRepository.find();
  }

  async findOne(id: number): Promise<User> {
    return this.userRepository.findOne({ where: { id } });
  }

  async update(id: number, name: string, email: string): Promise<User> {
    const user = await this.userRepository.findOne({ where: { id } });
    user.name = name;
    user.email = email;
    return this.userRepository.save(user);
  }

  async delete(id: number): Promise<void> {
    await this.userRepository.delete({ id });
  }
}

控制器

最后，在控制器中定义CRUD操作接口：

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

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

  @Post()
  create(@Body() createUserDto: any): Promise<User> {
    return this.userService.create(createUserDto.name, createUserDto.email);
  }

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

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

  @Put(':id')
  update(@Param('id') id: string, @Body() updateUserDto: any): Promise<User> {
    return this.userService.update(+id, updateUserDto.name, updateUserDto.email);
  }

  @Delete(':id')
  remove(@Param('id') id: string): void {
    this.userService.delete(+id);
  }
}

Nest框架支持多种数据库，如MySQL、SQLite、PostgreSQL等。本节以TypeORM集成SQLite为例：

安装依赖

首先安装TypeORM及相关数据库驱动：

npm install @nestjs/typeorm typeorm sqlite3 --save

配置数据库

编辑app.module.ts文件，配置TypeORM：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { User } from './models/user.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'db.sqlite',
      entities: [User],
      synchronize: true,
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

定义实体

创建用户实体：

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

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

  @Column()
  name: string;

  @Column()
  email: string;
}

服务层

在服务中操作数据库：

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  async create(name: string, email: string): Promise<User> {
    const user = this.userRepository.create({ name, email });
    return this.userRepository.save(user);
  }

  async findAll(): Promise<User[]> {
    return this.userRepository.find();
  }

  async findOne(id: number): Promise<User> {
    return this.userRepository.findOne({ where: { id } });
  }

  async update(id: number, name: string, email: string): Promise<User> {
    const user = await this.userRepository.findOne({ where: { id } });
    user.name = name;
    user.email = email;
    return this.userRepository.save(user);
  }

  async delete(id: number): Promise<void> {
    await this.userRepository.delete({ id });
  }
}

控制器层

在控制器中定义接口：

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

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

  @Post()
  create(@Body() createUserDto: any): Promise<User> {
    return this.userService.create(createUserDto.name, createUserDto.email);
  }

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

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

  @Put(':id')
  update(@Param('id') id: string, @Body() updateUserDto: any): Promise<User> {
    return this.userService.update(+id, updateUserDto.name, updateUserDto.email);
  }

  @Delete(':id')
  remove(@Param('id') id: string): void {
    this.userService.delete(+id);
  }
}

Nest框架支持多种接口文档生成工具，如Swagger和ApiDoc。本节以Swagger为例：

安装依赖

安装Swagger相关依赖：

npm install @nestjs/swagger @nestjs/jest --save
npm install swagger-ui-express --save

配置Swagger

编辑app.module.ts文件，配置Swagger：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { User } from './models/user.entity';
import { UsersController } from './users.controller';
import { UserService } from './users.service';
import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'db.sqlite',
      entities: [User],
      synchronize: true,
    }),
    SwaggerModule.forRoot({
      documentBuilder: () =>
        new DocumentBuilder()
          .addBearerAuth()
          .setTitle('Nest API')
          .setDescription('The Nest API description')
          .setVersion('1.0')
          .build(),
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

控制器中调用Swagger

在控制器中调用Swagger中间件：

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

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

  @Get()
  async root(@Request() request: Request) {
    return this.appService.root();
  }

  @Get('api-docs')
  getSwaggerDocument() {
    return this.document.getJson();
  }
}

为了展示Swagger UI，需要在main.ts或app.module.ts中配置：

import { NestFactory } from '@nestjs/core';
import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
import { AppModule } from './app.module';

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

  const document = SwaggerModule.createDocument(app, new DocumentBuilder().build());
  SwaggerModule.setup('api', app, document);

  await app.listen(3000);
}
bootstrap();

启动应用后，访问http://localhost:3000/api即可看到Swagger UI。

单元测试和集成测试是确保应用程序质量的重要手段。下面是如何在Nest框架中编写单元测试和集成测试：

单元测试

单元测试通常用于测试单个模块或组件。以下是一个简单的单元测试示例，使用jest进行测试：

import { UserService } from './user.service';

describe('UserService', () => {
  let service: UserService;

  beforeEach(() => {
    service = new UserService();
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  it('should create a new user', async () => {
    const user = await service.create('John Doe', 'john@example.com');
    expect(user.name).toBe('John Doe');
    expect(user.email).toBe('john@example.com');
  });
});

集成测试

集成测试用于测试应用程序的多个组件之间的交互。以下是一个集成测试示例，测试控制器和服务之间的交互：

import { Test } from '@nestjs/testing';
import { UserController } from './user.controller';
import { UserService } from './user.service';
import { UsersModule } from './user.module';

describe('UserController', () => {
  let controller: UserController;
  let service: UserService;

  beforeEach(async () => {
    const moduleRef = await Test.createTestingModule({
      imports: [UsersModule],
    }).compile();

    service = moduleRef.get<UserService>(UserService);
    controller = moduleRef.get<UserController>(UserController);
  });

  it('should be defined', () => {
    expect(controller).toBeDefined();
  });

  it('should return all users', async () => {
    const users = await controller.findAll();
    expect(users.length).toBeGreaterThan(0);
  });
});

部署Nest应用可以使用多种方式，如Docker、Kubernetes等。这里以Docker为例：

创建Dockerfile

在项目根目录下创建Dockerfile：

FROM node:14

WORKDIR /app

COPY package.json package-lock.json ./

RUN npm ci

COPY . .

EXPOSE 3000

CMD ["npm", "run", "start"]

构建并运行Docker镜像

在命令行中执行以下命令：

docker build -t my-nest-app .
docker run -p 3000:3000 my-nest-app

部署到云平台

可以将Docker镜像部署到云平台，例如AWS、Google Cloud等。首先将镜像上传到Docker Hub或其他镜像仓库，然后在云平台上创建容器并配置路由。

监控和日志是确保应用稳定性和性能的重要手段。Nest框架支持多种工具，如PM2、ELK Stack等。

使用PM2管理进程

PM2是一个进程管理工具，可以用于管理和监控Node.js应用：

npm install pm2 -g
pm2 start dist/main.js --name "my-nest-app"
pm2 startup
pm2 save

使用ELK Stack进行日志分析

ELK Stack（Elasticsearch, Logstash, Kibana）是一个强大的日志分析平台，可以实时监控和分析应用日志：

1. 安装Elasticsearch、Logstash和Kibana。
2. 配置Logstash将应用日志发送到Elasticsearch。
3. 在Kibana中创建仪表板，可视化日志数据。

1. 问：Nest框架是否支持微服务架构？

   • 答：是的，Nest框架支持微服务架构。可以通过@nestjs/microservices模块来构建微服务应用。

2. 问：Nest框架是否支持跨域资源共享（CORS）？

   • 答：是的，可以通过安装@nestjs/cors模块来配置CORS。
3. 问：如何优化Nest应用的性能？
   • 答：可以通过启用缓存、优化数据库查询、使用CDN等方式来优化性能。

• 官方文档：https://docs.nestjs.com/
• GitHub仓库：https://github.com/nestjs/nest
• NestJS官方博客：https://docs.nestjs.com/faq/blog
• 慕课网：https://www.imooc.com/course/list?c=nestjs

• 官方论坛：https://forum.nestjs.com/
• GitHub Issue：https://github.com/nestjs/nest/issues
• Stack Overflow：https://stackoverflow.com/questions/tagged/nestjs