夜猫子的知识栈
神说要有光
2025-03-10
目录

考试系统；用户注册

这节正式进入开发，我们先来开发注册功能。

在 docker desktop 里把 mysql 的容器跑起来：

安装 prisma

npm install prisma --save-dev
1

然后执行 prisma init 创建 schema 文件：

npx prisma init
1

改下 .env 的配置：

DATABASE_URL="mysql://root:你的密码@localhost:3306/exam-system"
1

并且修改下 schema 里的 datasource 部分：

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}
1
2
3
4

然后创建 model。

前面分析过用户表的结构：

字段名 数据类型 描述
id INT 用户ID
username VARCHAR(50) 用户名
password VARCHAR(50) 密码
email VARCHAR(50) 邮箱
create_time DATETIME 创建时间
update_time DATETIME 更新时间

创建对应的 modal：

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

model User {
  id  Int @id @default(autoincrement())
  username String @db.VarChar(50) @unique
  password String @db.VarChar(50)
  email String @db.VarChar(50)
  createTime DateTime @default(now())
  updateTime DateTime @updatedAt
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这里 username 要添加唯一约束。

在 mysql workbench 里创建 exam-system 的数据库：

先 migrate reset，重置下数据库：

npx prisma migrate reset
1

然后创建新的 migration:

npx prisma migrate dev --name user
1

这时就生成了迁移文件，包含创建 user 表的 sql 语句：

在 mysql workbench 里可以看到创建好的 user 表：

并且 migrate dev 还会生成 client 代码，接下来我们就可以直接来做 CRUD 了。

创建个公共 lib

nest g lib prisma
1

改下 PrismaService，继承 PrismaClient，这样它就有 crud 的 api 了：

import { Injectable, OnModuleInit } from '@nestjs/common';
import { PrismaClient } from '@prisma/client';

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {

    constructor() {
        super({
            log: [
                {
                    emit: 'stdout',
                    level: 'query'
                }
            ]
        })
    }

    async onModuleInit() {
        await this.$connect();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在 constructor 里设置 PrismaClient 的 log 参数，也就是打印 sql 到控制台。

在 onModuleInit 的生命周期方法里调用 $connect 来连接数据库。

这样各处就都可以注入 PrismaService 用了。

在 user 微服务引入 PrismaModule：

然后在 UserService 里注入 PrismaService 来做 crud：

import { PrismaService } from '@app/prisma';
import { Inject, Injectable } from '@nestjs/common';
import { Prisma } from '@prisma/client';

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

  @Inject(PrismaService)
  private prisma: PrismaService;

  async create(data: Prisma.UserCreateInput) {
      return await this.prisma.user.create({
          data,
          select: {
              id: true
          }
      });
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

写代码的时候你会发现，参数的类型 prisma 都给你生成好了，直接用就行：

我们这节实现注册：

在 UserController 增加一个 post 接口：

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { UserService } from './user.service';
import { RegisterUserDto } from './dto/register-user.dto';

@Controller('user')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Post('register')
  async register(@Body() registerUser: RegisterUserDto) {
      return await this.userService.create(registerUser);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

创建 dto/register-user.dto.ts

export class RegisterUserDto{
    username: string;

    password: string;

    email: string;

    captcha: string;
}
1
2
3
4
5
6
7
8
9

把服务跑起来：

npm run start:dev user
1

在 postman 里调用下试试：

{
    "username": "guang",
    "password": "123456",
    "email": "xxxx@xx.com",
    "captcha": "abc123"
}
1
2
3
4
5
6

报错了：

数据库中没有 captcha 的字段。

我们要在调用 service 之前删掉它：

再试一下：

服务端打印了 insert 的 sql 语句：

数据库里也可以看到这条记录：

然后加一下 ValidationPipe，来对请求体做校验。

安装用到的包：

npm install --save class-validator class-transformer
1

全局启用 ValidationPipe：

app.useGlobalPipes(new ValidationPipe());
1

然后加一下校验规则：

import { IsEmail, IsNotEmpty, MinLength } from "class-validator";

export class RegisterUserDto {

    @IsNotEmpty({
        message: "用户名不能为空"
    })
    username: string;
    
    @IsNotEmpty({
        message: '密码不能为空'
    })
    @MinLength(6, {
        message: '密码不能少于 6 位'
    })
    password: string;
    
    @IsNotEmpty({
        message: '邮箱不能为空'
    })
    @IsEmail({}, {
        message: '不是合法的邮箱格式'
    })
    email: string;
    
    @IsNotEmpty({
        message: '验证码不能为空'
    })
    captcha: string;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

测试下：

没啥问题。

然后实现注册的逻辑。

注册的逻辑是这样的：

继续实现 UserService 的 register 方法：

import { HttpException, HttpStatus, Inject, Injectable, Logger } from '@nestjs/common';
import { PrismaService } from '@app/prisma';
import { RedisService } from '@app/redis';
import { RegisterUserDto } from './dto/register-user.dto';

@Injectable()
export class UserService {

  @Inject(PrismaService)
  private prismaService: PrismaService;

  @Inject(RedisService)
  private redisService: RedisService;

  private logger = new Logger();

  async register(user: RegisterUserDto) {
      const captcha = await this.redisService.get(`captcha_${user.email}`);

      if(!captcha) {
          throw new HttpException('验证码已失效', HttpStatus.BAD_REQUEST);
      }

      if(user.captcha !== captcha) {
          throw new HttpException('验证码不正确', HttpStatus.BAD_REQUEST);
      }

      const foundUser = await this.prismaService.user.findUnique({
        where: {
          username: user.username
        }
      });

      if(foundUser) {
        throw new HttpException('用户已存在', HttpStatus.BAD_REQUEST);
      }

      try {
        return await this.prismaService.user.create({
          data: {
            username: user.username,
            password: user.password,
            email: user.email
          },
          select: {
            id: true,
            username: true,
            email: true,
            createTime: true
          }
        });
      } catch(e) {
        this.logger.error(e, UserService);
        return null;
      }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

先检查验证码是否正确，如果正确的话，检查用户是否存在，然后用 prismaService.create 插入数据。

失败的话用 Logger 记录错误日志。

这里的 md5 方法放在 src/utils.ts 里，用 node 内置的 crypto 包实现。

import * as crypto from 'crypto';

export function md5(str) {
    const hash = crypto.createHash('md5');
    hash.update(str);
    return hash.digest('hex');
}
1
2
3
4
5
6
7

在 UserController 里调用下：

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { UserService } from './user.service';
import { RegisterUserDto } from './dto/register-user.dto';

@Controller('user')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Post('register')
  async register(@Body() registerUser: RegisterUserDto) {
    return await this.userService.register(registerUser);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

然后在 postman 里测试下：

因为还没实现发送邮箱验证码的逻辑，这里我们手动在 redis 添加一个 key：

测试下：

带上错误的验证码，返回验证码不正确；

image.png

带上正确的验证码，注册成功：

这时可以在数据库里看到这条记录：

image.png

然后我们来实现发送邮箱验证码的功能。

封装个 email 的 lib：

nest g lib email
1
2

image.png

安装发送邮件用的包：

npm install nodemailer --save
1

在 EmailService 里实现 sendMail 方法

import { Injectable } from '@nestjs/common';
import { createTransport, Transporter} from 'nodemailer';

@Injectable()
export class EmailService {

    transporter: Transporter
    
    constructor() {
      this.transporter = createTransport({
          host: "smtp.qq.com",
          port: 587,
          secure: false,
          auth: {
              user: '你的邮箱地址',
              pass: '你的授权码'
          },
      });
    }

    async sendMail({ to, subject, html }) {
      await this.transporter.sendMail({
        from: {
          name: '考试系统',
          address: '你的邮箱地址'
        },
        to,
        subject,
        html
      });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

把邮箱地址和授权码改成你自己的。

具体怎么生成授权码，看前面的 node 发送邮件 (opens new window)那节。

引入 EmailModule：

image.png

然后在 UserController 里添加一个 get 接口：

image.png

import { Controller, Get, Post, Body, Patch, Param, Delete, Inject, Query } from '@nestjs/common';
import { UserService } from './user.service';
import { RegisterUserDto } from './dto/register-user.dto';
import { EmailService } from '@app/email';
import { RedisService } from '@app/redis';

@Controller('user')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Inject(EmailService)
  private emailService: EmailService;

  @Inject(RedisService)
  private redisService: RedisService;

  @Get('register-captcha')
  async captcha(@Query('address') address: string) {
      const code = Math.random().toString().slice(2,8);

      await this.redisService.set(`captcha_${address}`, code, 5 * 60);

      await this.emailService.sendMail({
        to: address,
        subject: '注册验证码',
        html: `<p>你的注册验证码是 ${code}</p>`
      });
      return '发送成功';
  }

  @Post('register')
  async register(@Body() registerUser: RegisterUserDto) {
    return await this.userService.register(registerUser);
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

测试下：

image.png

邮件发送成功：

image.png

redis 里也保存了邮箱地址对应的验证码：

通过邮件发送验证码之后，保存到 redis，注册的时候取出邮箱地址对应的验证码来校验。

这样，整个注册的流程就完成了。

代码在小册仓库 (opens new window)。

# 总结

这节我们引入了 prisma，封装了 prisma、email 这两个 lib。

通过 prisma 的 migrate 功能，生成迁移 sql 并同步到数据库。

此外，prisma 会生成 client 的代码，我们封装了 PrismaService 来做 CRUD。

我们实现了 /user/register 和 /user/register-captcha 两个接口。

/user/register-captcha 会向邮箱地址发送一个包含验证码的邮件，并在 redis 里存一份。

/user/register 会根据邮箱地址查询 redis 中的验证码，验证通过会把用户信息保存到表中。

这样，注册功能就完成了。

编辑 (opens new window)
上次更新: 2025/10/27 10:53:52
考试系统：微服务、Lib 拆分
考试系统：用户登录、修改密码

← 考试系统：用户登录、修改密码→

最近更新
01
UNiAPP中使用虚拟列表
01-09
02
uni统计使用
11-12
03
原生三方SDK集成探索
11-12
更多文章>
Copyright © 2019-2026 Study | MIT License