从0开始构建 “完美” 的后端：使用 Nest.js 构建 RESTful API

代码是从项目中截取，归于伪代码，并不保证必定能够正确运转，但是如果您乐意折腾一下，我也以为没有问题，花点时间，运转起来也是能够的

废话不说，直接上手！

今天咱们将运用NestJS创立一个简单的使命办理运用程序。该运用程序将具有以下功能：

1. 用户能够创立、读取、更新和删除使命。
2. 一切使命都存储在MySQL数据库中。

接下来，咱们将分过程创立这个运用程序。

过程1：创立NestJS运用程序

首先，咱们需求装置NestJS CLI，运用以下指令装置：

npm install -g @nestjs/cli

然后，咱们能够运用以下指令创立一个新的NestJS运用程序：

nest new task-manager

过程2：装置必要的依靠项

在这一步，咱们将装置一些必要的依靠项。翻开项目文件夹并运用以下指令装置依靠项：

cd task-manager
npm install --save @nestjs/typeorm typeorm mysql2

在这里，咱们装置了@nestjs/typeorm和typeorm来运用TypeORM库来衔接MySQL数据库。咱们还装置了mysql2作为MySQL驱动程序。

过程3：创立数据库

在这一步，咱们将创立MySQL数据库和表。咱们能够运用MySQL指令行工具或任何MySQL客户端来创立数据库和表。在这里，咱们将运用以下指令在MySQL中创立一个名为task_manager的数据库：

CREATE DATABASE task_manager;

接下来，咱们将创立一个名为task的表，该表将存储使命的信息。以下是创立使命表的SQL查询：

CREATE TABLE task (
  id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
  title VARCHAR(255) NOT NULL,
  description TEXT,
  status VARCHAR(50) NOT NULL DEFAULT 'OPEN'
);

过程4：配置TypeORM

在这一步，咱们将配置TypeORM来衔接MySQL数据库并与使命实体进行交互。翻开src/app.module.ts文件并运用以下代码更新它：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TaskModule } from './task/task.module';
@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      username: 'root',
      password: 'password',
      database: 'task_manager',
      autoLoadEntities: true,
      synchronize: true,
    }),
    TaskModule,
  ],
})
export class AppModule {}

在这里，咱们运用TypeOrmModule.forRoot()办法来配置TypeORM。咱们指定了MySQL数据库的衔接参数，如主机名、端口、用户名、密码和数据库名称。咱们还启用了实体自动加载和数据库同步。

过程5：创立使命实体

在这一步，咱们将创立一个使命实体，用于表示使命的数据模型。翻开src/task/task.entity.ts文件并运用以下代码更新它：

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
@Entity()
export class Task {
  @PrimaryGeneratedColumn()
  id: number;
  @Column()
  title: string;
  @Column({ nullable: true })
  description?: string;
  @Column({ default: 'OPEN' })
  status: string;
}

在这里，咱们运用TypeORM的装修器来界说实体和其属性。@Entity()装修器用于将类标记为实体。@PrimaryGeneratedColumn()装修器用于指定自动生成的主键。@Column()装修器用于界说列。咱们还运用了一些选项，如nullable和default，以指定列的特定属性。

过程6：创立使命模块

在这一步，咱们将创立一个使命模块。模块是NestJS运用程序的核心组件之一，用于将代码组织成相关性质的代码块。翻开src/task/task.module.ts文件并运用以下代码更新它：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Task } from './task.entity';
import { TaskController } from './task.controller';
import { TaskService } from './task.service';
@Module({
  imports: [TypeOrmModule.forFeature([Task])],
  controllers: [TaskController],
  providers: [TaskService],
})
export class TaskModule {}

在这里，咱们运用@Module()装修器来标记该类为模块。咱们运用TypeOrmModule.forFeature()办法来导入使命实体。咱们还将使命控制器和使命服务供给程序添加到该模块的控制器和供给程序列表中。

过程7：创立使命控制器

在这一步，咱们将创立一个使命控制器，用于处理来自客户端的HTTP恳求。翻开src/task/task.controller.ts文件并运用以下代码更新它：

import { Controller, Get, Post, Put, Delete, Body, Param } from '@nestjs/common';
import { TaskService } from './task.service';
import { Task } from './task.entity';
@Controller('tasks')
export class TaskController {
  constructor(private readonly taskService: TaskService) {}
  @Get()
  findAll(): Promise<Task[]> {
    return this.taskService.findAll();
  }
  @Get(':id')
  findOne(@Param('id') id: string): Promise<Task> {
    return this.taskService.findOne(parseInt(id));
  }
  @Post()
  create(@Body() task: Task): Promise<Task> {
    return this.taskService.create(task);
  }
  @Put(':id')
  update(@Param('id') id: string, @Body() task: Task): Promise<Task> {
    return this.taskService.update(parseInt(id), task);
  }
  @Delete(':id')
  delete(@Param('id') id: string): Promise<void> {
    return this.taskService.delete(parseInt(id));
  }
}

在这里，咱们运用@Controller()装修器将该类标记为控制器，并指定其前缀为/tasks。咱们还注入了使命服务，并运用@Get()、@Post()、@Put()、@Delete()装修器来界说处理HTTP GET、POST、PUT和DELETE恳求的办法。咱们还运用@Body()和@Param()装修器来拜访恳求体和URL参数。

过程8：创立使命服务

在这一步，咱们将创立一个使命服务，用于处理运用程序逻辑和数据拜访。翻开src/task/task.service.ts文件并运用以下代码更新它：

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Task } from './task.entity';
@Injectable()
export class TaskService {
  constructor(
    @InjectRepository(Task)
    private readonly taskRepository: Repository<Task>,
  ) {}
  async findAll(): Promise<Task[]> {
    return this.taskRepository.find();
  }
  async findOne(id: number): Promise<Task> {
    return this.taskRepository.findOne(id);
  }
  async create(task: Task): Promise<Task> {
    return this.taskRepository.save(task);
  }
  async update(id: number, task: Task): Promise<Task> {
    const updatedTask = await this.taskRepository.findOne(id);
    if (!updatedTask) {
      return null;
    }
    return this.taskRepository.save({ ...updatedTask, ...task });
  }
  async delete(id: number): Promise<void> {
    await this.taskRepository.delete(id);
  }
}

在这里，咱们运用@Injectable()装修器将该类标记为服务。咱们运用@InjectRepository()装修器来注入使命存储库，并运用Repository泛型来界说存储库的类型。咱们界说了一些办法来处理使命数据的CRUD操作，这些办法运用存储库中的实践办法来执行这些操作。

过程9：发动运用程序

现在咱们现已创立了一切必要的组件来构建咱们的运用程序，现在让咱们发动运用程序并测验它是否正常工作。在终端中运用以下指令发动运用程序：

npm run start:dev

如果一切正常，您应该会看到一条消息，指示运用程序正在监听端口3000。现在让咱们运用curl测验咱们的运用程序。

运用以下指令测验GET /tasks路由：

curl http://localhost:3000/tasks

您应该会看到一个空的JSON数组。这是由于咱们还没有创立任何使命。现在让咱们运用以下指令测验POST /tasks路由，创立一些使命：

curl -H "Content-Type: application/json" -X POST -d '{"title":"Task 1", "description":"Description 1", "status":"OPEN"}' http://localhost:3000/tasks
curl -H "Content-Type: application/json" -X POST -d '{"title":"Task 2", "description":"Description 2", "status":"OPEN"}' http://localhost:3000/tasks
curl -H "Content-Type: application/json" -X POST -d '{"title":"Task 3", "description":"Description 3", "status":"OPEN"}' http://localhost:3000/tasks

现在运用以下指令测验GET /tasks路由，检查咱们创立的使命：

curl http://localhost:3000/tasks

您应该会看到一个包括三个使命的JSON数组。接下来，让咱们测验GET /tasks/:id路由，运用使命的ID检索单个使命：

curl http://localhost:3000/tasks/1

您应该会看到一个JSON呼应，包括ID为1的使命的详细信息。现在让咱们测验PUT /tasks/:id路由，运用使命的ID更新使命：

curl -H "Content-Type: application/json" -X PUT -d '{"status":"IN_PROGRESS"}' http://localhost:3000/tasks/1

现在运用GET /tasks/1路由检索使命，您应该会看到使命的状况已更新为“IN_PROGRESS”。最后，让咱们测验DELETE /tasks/:id路由，运用使命的ID删除使命：

curl -X DELETE http://localhost:3000/tasks/1

现在再次运用GET /tasks路由检索使命，您应该只看到两个使命，由于咱们现已删除了ID为1的使命。

常用的装修器

在 Nest.js 中，装修器是一种特殊类型的 TypeScript 注释，能够用来附加元数据到类、办法、属性和参数上。这些元数据能够在运转时被检索，然后让 Nest.js 能够对运用程序的行为进行更多的自动化。

以下是一些常用的 Nest.js 装修器：

@Controller()

@Controller() 装修器用于界说一个控制器类。控制器类负责处理 HTTP 恳求，通常会包括一组路由处理程序，用于处理恳求和生成呼应。

@Controller('users')
export class UsersController {
  // ...
}

在这个比如中，@Controller('users') 装修器指定了控制器的根途径为 /users。

@Get()

@Get() 装修器用于界说一个 HTTP GET 恳求的路由处理程序。

@Controller('users')
export class UsersController {
  @Get()
  findAll(): string {
    return '此操作回来一切用户';
  }
}

在这个比如中，@Get() 装修器指定了这个路由处理程序处理 HTTP GET 恳求。

@Post()

@Post() 装修器用于界说一个 HTTP POST 恳求的路由处理程序。

@Controller('users')
export class UsersController {
  @Post()
  create(): string {
    return '此操作将创立一个新用户';
  }
}

在这个比如中，@Post() 装修器指定了这个路由处理程序处理 HTTP POST 恳求。

@Param()

@Param() 装修器用于注入 URL 参数的值到路由处理程序的办法参数中。

@Controller('users')
export class UsersController {
  @Get(':id')
  findOne(@Param('id') id: string): string {
    return `此操作回来id为${id}的用户 `;
  }
}

在这个比如中，@Param('id') 装修器指定了将 URL 参数 id 的值注入到办法参数 id 中。

@Body()

@Body() 装修器用于注入恳求体中的数据到路由处理程序的办法参数中。

@Controller('users')
export class UsersController {
  @Post()
  create(@Body() user: CreateUserDto): string {
    return `此操作创立一个名为${user.name}的新用户 `;
  }
}

在这个比如中，@Body() 装修器指定了将恳求体中的数据注入到办法参数 user 中，并运用 CreateUserDto 类型进行验证和转换。

@Query()

@Query() 装修器用于注入查询参数的值到路由处理程序的办法参数中。

@Controller('users')
export class UsersController {
  @Get()
  findAll(@Query() query: GetUsersQueryDto): string {
    return `此操作回来一切具有状况 ${query.status} 的用户`;
  }
}

在这个比如中，@Query() 装修器指定了将查询参数注入到办法参数 query 中，并运用 GetUsersQueryDto 类型进行验证和转换。

@UseGuards()

@UseGuards() 装修器用于将一个或多个护卫绑定到路由处理程序或控制器上。

@Controller('users')
@UseGuards(AuthGuard)
export class UsersController {
  // ...
}

在这个比如中，@UseGuards(AuthGuard) 装修器将 AuthGuard 护卫绑定到 UsersController 控制器上。

@UseInterceptors()

@UseInterceptors() 装修器用于将一个或多个拦截器绑定到路由处理程序或控制器上。

@Controller('users')
@UseInterceptors(LoggingInterceptor)
export class UsersController {
  // ...
}

在这个比如中，@UseInterceptors(LoggingInterceptor) 装修器将 LoggingInterceptor 拦截器绑定到 UsersController 控制器上。

这些装修器只是 Nest.js 中可用的一小部分。通过运用它们，您能够更好地组织和办理运用程序的逻辑，以及进步运用程序的可维护性和可测验性。

总结

在本文中，咱们现已学习了怎么运用Nest.js框架创立一个简单的REST API。咱们学习了怎么运用Nest CLI创立一个新的Nest.js运用程序，怎么界说路由和控制器，怎么创立实体和服务，以及怎么运用TypeORM和MySQL进行数据持久化。咱们还了解了Nest.js中常用的装修器，并运用它们来拜访恳求体和URL参数。