毕业设计第8周学习记录

本周主要做了关于用户模块的增删查改。并运用postman实现数据的取存，接口的交互，并应用了可视化数据库工具。

安装依赖

项目中我们会用到 Mongoose 来操作我们的数据库，Nest 官方为我们提供了一个 Mongoose 的封装，我们需要安装 mongoose 和 @nestjs/mongoose：

npm install mongoose @nestjs/mongoose --save

安装好之后我们就可以开始编码过程了。

代码实现

1.创建模块

创建一个 User 模块，写一个用户增删改查

nest g module user server

脚手架工具会自动在 src/server/user 文件夹下创建一个 user.module.ts，这是 Nest 的模块文件，Nest 用它来组织整个应用程序的结构。
在src目录下出现sever的文件夹，并出现user的ts文件
打开后如下图所示

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

@Module({})
export class UserModule {}

同时还会在根模块 app.module.ts 中引入 UserModule 这个模块。

相当于一个树形结构，在根模块中引入了 User 模块。
执行上面的终端命令之后，app.module.ts 中的代码已经发生了变化，在文件顶部自动引入了 UserModule，同时也在 @Module 装饰器的 imports 中引入了 UserModule。

2.创建控制器

在终端输入以下命令

nest g controller user server

执行后，发现里面的代码内容如下：

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

@Controller('user')
export class UserController {}

在 Nest 中，controller 就类似前端的「路由」，负责处理「客户端传入的请求」和「服务端返回的响应」。

举个例子，我们如果要通过 http://localhost:3000/user/users 获取所有的用户信息，那么我们可以在 UserController 中创建一个 GET 方法，路径为 users 的路由，这个路由负责返回所有的用户信息。代码：

import { Controller, Get } from '@nestjs/common';
 
@Controller('user')
export class UserController {
  @Get('users')
  findAll(): string {
    return "All User's Info"; // [All User's Info] 暂时代替所有用户的信息
  }
}

3.创建提供者

nest g service user server

provider 我们可以简单地从字面意思来理解，就是「服务的提供者」。

怎么去理解这个「服务提供者」呢？举个例子，我们的 controller 接收到了一个用户的查询请求，我们不能直接在 controller 中去查询数据库并返回，而是要将查询请求交给 provider 来处理，这里我们创建了一个 UserService，就是用来提供「数据库操作服务」的。
当然，provider 不一定只能用来提供数据库的操作服务，还可以用来做一些用户校验，比如使用 JWT 对用户权限进行校验的策略，就可以写成一个策略类，放到 provider 中，为模块提供相应的服务。

controller 和 provider 都创建完后，user.module.ts 文件中多了一些代码，如下图所示：

连接数据库

1.引入 Mongoose 根模块

在根模块，也就是 app.module.ts 中引入 Mongoose 的连接模块：

// app.module.ts
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { UserModule } from './server/user/user.module';
 
@Module({
  imports: [MongooseModule.forRoot('mongodb://localhost/xxx'), UserModule],
  controllers: [AppController],
  providers: [AppService]
})
export class AppModule {}

这段代码里面的 mongodb://localhost/xxx 其实就是本地数据库的地址，xxx 是数据库的名字。

这时候保存文件，如果发现控制台报错，我们看一下报错信息就很容易知道问题在哪里了。

其实就是 mongoose 模块没有类型声明文件，这就很容易解决了，安装一下就好：

npm install @types/mongoose --dev 

2.引入 Mongoose 分模块

这里我们先要创建一个数据表的格式，在 src/server/user 文件夹下创建一个 user.schema.ts 文件，定义一个数据表的格式：

// user.schema.ts
import { Schema } from 'mongoose';
 
export const userSchema = new Schema({
  _id: { type: String, required: true }, // 覆盖 Mongoose 生成的默认 _id
  user_name: { type: String, required: true },
  password: { type: String, required: true }
});

修改 user.module.ts 文件：

// user.module.ts
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { UserController } from './user.controller';
import { userSchema } from './user.schema';
import { UserService } from './user.service';
 
@Module({
  imports: [MongooseModule.forFeature([{ name: 'Users', schema: userSchema }])],
  controllers: [UserController],
  providers: [UserService]
})
export class UserModule {}

一切就绪，终于可以开始编写我们的 CRUD 逻辑了！

CRUD

我们打开 user.service.ts 文件，为 UserService 类添加一个构造函数，让其在实例化的时候能够接收到数据库 Model，这样才能在类中的方法里操作数据库。

1.定义数据传输对象文件

创建user.dto.ts

// user.dto.ts
export class CreateUserDTO {
  readonly _id: string;
  readonly user_name: string;
  readonly password: string;
}
 
export class EditUserDTO {
  readonly user_name: string;
  readonly password: string;
}

2.创建接口文档

// user.interface.ts
import { Document } from 'mongoose';
 
export interface User extends Document {
  readonly _id: string;
  readonly user_name: string;
  readonly password: string;
}

为 UserService 类添加一个构造函数

// user.service.ts
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { CreateUserDTO, EditUserDTO } from './user.dto';
import { User } from './user.interface';
 
@Injectable()
export class UserService {
  constructor(@InjectModel('Users') private readonly userModel: Model<User>) {}
 
  // 查找所有用户
  async findAll(): Promise<User[]> {
    const users = await this.userModel.find();
    return users;
  }
 
  // 查找单个用户
  async findOne(_id: string): Promise<User> {
    return await this.userModel.findById(_id);
  }
 
  // 添加单个用户
  async addOne(body: CreateUserDTO): Promise<void> {
    await this.userModel.create(body);
  }
 
  // 编辑单个用户
  async editOne(_id: string, body: EditUserDTO): Promise<void> {
    await this.userModel.findByIdAndUpdate(_id, body);
  }
 
  // 删除单个用户
  async deleteOne(_id: string): Promise<void> {
    await this.userModel.findByIdAndDelete(_id);
  }
}

因为 mongoose 操作数据库其实是异步的，所以这里我们使用 async 函数来处理异步的过程。

现在，我们可以到 user.controller.ts 中设置路由了，将「客户端的请求」进行处理，调用相应的服务实现相应的功能：

// user.controller.ts
import {
  Body,
  Controller,
  Delete,
  Get,
  Param,
  Post,
  Put
} from '@nestjs/common';
import { CreateUserDTO, EditUserDTO } from './user.dto';
import { User } from './user.interface';
import { UserService } from './user.service';
 
interface UserResponse<T = unknown> {
  code: number;
  data?: T;
  message: string;
}
 
@Controller('user')
export class UserController {
  constructor(private readonly userService: UserService) {}
 
  // GET /user/users
  @Get('users')
  async findAll(): Promise<UserResponse<User[]>> {
    return {
      code: 200,
      data: await this.userService.findAll(),
      message: 'Success.'
    };
  }
 
  // GET /user/:_id
  @Get(':_id')
  async findOne(@Param('_id') _id: string): Promise<UserResponse<User>> {
    return {
      code: 200,
      data: await this.userService.findOne(_id),
      message: 'Success.'
    };
  }
 
  // POST /user
  @Post()
  async addOne(@Body() body: CreateUserDTO): Promise<UserResponse> {
    await this.userService.addOne(body);
    return {
      code: 200,
      message: 'Success.'
    };
  }
 
  // PUT /user/:_id
  @Put(':_id')
  async editOne(
    @Param('_id') _id: string,
    @Body() body: EditUserDTO
  ): Promise<UserResponse> {
    await this.userService.editOne(_id, body);
    return {
      code: 200,
      message: 'Success.'
    };
  }
 
  // DELETE /user/:_id
  @Delete(':_id')
  async deleteOne(@Param('_id') _id: string): Promise<UserResponse> {
    await this.userService.deleteOne(_id);
    return {
      code: 200,
      message: 'Success.'
    };
  }
}

至此，我们就完成了一个完整的 CRUD 操作。

接口测试

接口测试我们用的是 Postman，大家可以去下载一个，非常好用的接口自测工具。

数据库可视化工具我们用的是 MongoDB 官方的 MongoDB Compass，也很不错。

GET /user/users

一开始我们的数据库中什么都没有，所以返回了一个空数组，没用用户信息。

POST /user

POST /user

现在我们添加一条用户信息，服务器返回添加成功。
此步需要下载mongodb的可视化管理软件：MongoDB Compass Community

下载可视化数据库管理平台

MongoDB是一个面向文档的数据库，属于NoSQL数据库，它使用类似JSON的文档和schemata。

MongoDB的默认接口是（CLI）命令行，新用户很难像专业人员那样处理数据库。因此，有一些MongoDB管理工具来提供GUI界面以提高生产力。比如phpmyadmin为MySQL/MariaDB数据库提供基于HTTP网络的GUI界面一样。但是，此处包含的所有工具都不是基于HTTP的，只有少数工具为MongoDB提供Web界面。以下是使用GUI的比较流行的MongoDB管理工具列表：MongoDB Compass Community
下载地址：MongoDB Compass Community.

得到以下数据，则服务器返回添加成功。

Added

GET /user/:_id

添加完一条用户信息之后再查询，能查询到自己添加的信息了。

PUT /user/:_id

现在假如我想修改密码，发送一个 PUT 请求。

Edited

DELETE /user/:_id

选中delete，删除id=1的用户，返回200状态码，回复成功的消息。

发现数据库中的内容已经被删除了。

本周主要做了关于用户模块的增删查改。并运用postman实现数据的取存，接口的交互，并应用了可视化数据库工具。
下周任务，讨论其他api接口的实现。