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

聊天室：用户注册

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

创建个 nest 项目：

nest new chat-room-backend
1

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

进入项目，安装 prisma

npm install prisma --save-dev
1

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

npx prisma init
1

改下 .env 的配置：

DATABASE_URL="mysql://root:你的密码@localhost:3306/chat-room"
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) 密码
nick_name VARCHAR(50) 昵称
email VARCHAR(50) 邮箱
head_pic VARCHAR(100) 头像
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)
  nickName String @db.VarChar(50)
  email String @db.VarChar(50)
  headPic String @db.VarChar(100) @default("")
  createTime DateTime @default(now())
  updateTime DateTime @updatedAt
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

注意，这里 username 要添加唯一约束。

在 mysql workbench 里创建 chat-room 的数据库：

先 migrate reset，重置下数据库：

npx prisma migrate reset
1

然后创建新的 migration:

npx prisma migrate dev --name user
1

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

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

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

创建个 module 和 service：

nest g module prisma
1

nest g service prisma --no-spec
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 导出，并且设置 PrismaModule 为全局模块：

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

然后创建 user 模块：

nest g resource user
1

在 UserService 里注入 PrismaService 来做 crud：

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

@Injectable()
export class UserService {

  @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

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

user 模块有这些接口：

接口路径 请求方式 描述
/user/login POST 用户登录
/user/register POST 用户注册
/user/update POST 用户个人信息修改
/user/update_password POST 用户修改密码

我们这节实现注册：

在 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 是封装 body 里的请求参数的，根据界面上要填的信息，创建 dto：

创建 user/dto/register-user.dto.ts

export class RegisterUserDto{
    username: string;

    password: string;

    nickName: string;

    email: string;

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

把服务跑起来：

npm run start:dev
1

在 postman 里调用下试试：

{
    "username": "guang",
    "nickName": "神说要有光",
    "password": "123456",
    "email": "xxxx@xx.com",
    "captcha": "abc123"
}
1
2
3
4
5
6
7

报错了：

数据库中没有 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: '昵称不能为空'
    })
    nickName: 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
31
32
33
34
35

测试下：

没啥问题。

然后实现注册的逻辑。

注册的逻辑是这样的：

我们需要先封装个 redis 模块。

nest g module redis
nest g service redis --no-spec
1
2

安装 redis 的包：

npm install --save redis
1

确保 redis 的 docker 容器是启动的：

添加连接 redis 的 provider

import { Global, Module } from '@nestjs/common';
import { RedisService } from './redis.service';
import { createClient } from 'redis';

@Global()
@Module({
  providers: [
    RedisService,
    {
      provide: 'REDIS_CLIENT',
      async useFactory() {
        const client = createClient({
            socket: {
                host: 'localhost',
                port: 6379
            },
            database: 2
        });
        await client.connect();
        return client;
      }
    }
  ],
  exports: [RedisService]
})
export class RedisModule {}
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

用 @Global() 把它声明为全局模块，这样只需要在 AppModule 里引入，别的模块不用引入也可以注入 RedisService 了。

database 指定为 2，默认是 0

这个 database 就是把存储的 key-value 的数据放到不同命名空间下，避免冲突。

然后写下 RedisService

import { Inject, Injectable } from '@nestjs/common';
import { RedisClientType } from 'redis';

@Injectable()
export class RedisService {

    @Inject('REDIS_CLIENT') 
    private redisClient: RedisClientType;

    async get(key: string) {
        return await this.redisClient.get(key);
    }

    async set(key: string, value: string | number, ttl?: number) {
        await this.redisClient.set(key, value);

        if(ttl) {
            await this.redisClient.expire(key, ttl);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

注入 redisClient，实现 get、set 方法，set 方法支持指定过期时间。

然后继续实现 register 方法。

import { HttpException, HttpStatus, Inject, Injectable, Logger } from '@nestjs/common';
import { PrismaService } from 'src/prisma/prisma.service';
import { RedisService } from 'src/redis/redis.service';
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,
            nickName: user.nickName,
            email: user.email
          },
          select: {
            id: true,
            username: true,
            nickName: true,
            email: true,
            headPic: 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
58
59
60

先检查验证码是否正确，如果正确的话，检查用户是否存在，然后用 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：

测试下：

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

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

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

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

封装个 email 模块：

nest g resource email --no-spec
1

安装发送邮件用的包：

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 声明为全局的，并且导出 EmailService

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

@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 '发送成功';
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

测试下：

邮件发送成功：

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

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

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

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

# 总结

这节我们创建了 nest 项目，并引入了 prisma 和 redis。

通过 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
聊天室：技术选型和数据库设计
聊天室：用户登录

← 聊天室：用户登录→

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