Nest.js 框架数据库操作

person 无限可能    watch_later 2024-10-06 15:31:50
visibility 228    class Nest.js,数据库操作    bookmark 专栏

Nest.js 提供了与不同类型的数据库（如 SQL 和 NoSQL）集成的能力。最常用的数据库库是 TypeORM（用于 SQL 数据库）和 Mongoose（用于 MongoDB）。本文将详细介绍如何在 Nest.js 中使用这两个库进行数据库操作，涵盖数据库模型、迁移、基本 CRUD 操作以及其他模块的结合使用。

1. 使用 TypeORM 进行 SQL 数据库操作

1.1 安装 TypeORM 和相关依赖

首先，需要安装 TypeORM 和相应的数据库驱动。例如，我们将使用 PostgreSQL：

npm install @nestjs/typeorm typeorm pg

1.2 配置 TypeORM

在 app.module.ts 中配置 TypeORM：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UsersModule } from './users/users.module';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'your_username',
      password: 'your_password',
      database: 'your_database',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true, // 开发阶段可用，生产中建议设为 false
    }),
    UsersModule,
  ],
})
export class AppModule {}

1.3 创建数据库模型

创建一个用户实体模型 user.entity.ts：

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

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

  @Column()
  name: string;

  @Column()
  email: string;

  @Column()
  password: string;
}

1.4 创建用户模块

import { Module } from '@nestjs/common';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  providers: [UsersService],
  controllers: [UsersController],
})
export class UsersModule {}

1.5 创建用户服务

在 users.service.ts 中实现 CRUD 操作：

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

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

  create(user: User) {
    return this.usersRepository.save(user);
  }

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

  findOne(id: number): Promise<User> {
    return this.usersRepository.findOneBy({ id });
  }

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

1.6 创建用户控制器

在 users.controller.ts 中处理请求：

import { Controller, Get, Post, Body, Param, Delete } from '@nestjs/common';
import { UsersService } from './users.service';
import { User } from './user.entity';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  create(@Body() user: User) {
    return this.usersService.create(user);
  }

  @Get()
  findAll() {
    return this.usersService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: number) {
    return this.usersService.findOne(id);
  }

  @Delete(':id')
  remove(@Param('id') id: number) {
    return this.usersService.remove(id);
  }
}

2. 数据库迁移

对于 TypeORM，可以使用 TypeORM CLI 进行数据库迁移。首先，安装 TypeORM CLI：

npm install typeorm -g

然后，添加配置文件 ormconfig.json：

{
  "type": "postgres",
  "host": "localhost",
  "port": 5432,
  "username": "your_username",
  "password": "your_password",
  "database": "your_database",
  "entities": ["src/**/*.entity{.ts,.js}"],
  "migrations": ["src/migration/**/*.ts"],
  "cli": {
    "entitiesDir": "src",
    "migrationsDir": "src/migration"
  }
}

创建迁移

创建迁移命令：

typeorm migration:create -n UserMigration

在生成的迁移文件中，可以定义数据库表结构：

import { MigrationInterface, QueryRunner, Table } from 'typeorm';

export class UserMigration1620000000000 implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.createTable(
      new Table({
        name: 'user',
        columns: [
          {
            name: 'id',
            type: 'int',
            isPrimary: true,
            isGenerated: true,
          },
          {
            name: 'name',
            type: 'varchar',
          },
          {
            name: 'email',
            type: 'varchar',
          },
          {
            name: 'password',
            type: 'varchar',
          },
        ],
      }),
    );
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.dropTable('user');
  }
}

执行迁移

运行迁移：

typeorm migration:run

3. 使用 Mongoose 进行 MongoDB 数据库操作

3.1 安装 Mongoose 和相关依赖

首先，安装 Mongoose：

npm install @nestjs/mongoose mongoose

3.2 配置 Mongoose

在 app.module.ts 中配置 Mongoose：

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { UsersModule } from './users/users.module';

@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost/nest'), // 连接到 MongoDB
    UsersModule,
  ],
})
export class AppModule {}

3.3 创建数据库模型

在 users 文件夹中创建 user.schema.ts：

import { Schema, Document } from 'mongoose';

export const UserSchema = new Schema({
  name: String,
  email: String,
  password: String,
});

export interface User extends Document {
  id: string;
  name: string;
  email: string;
  password: string;
}

3.4 创建用户模块

在 users.module.ts 中导入 Mongoose 模块：

import { Module } from '@nestjs/common';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';
import { MongooseModule } from '@nestjs/mongoose';
import { UserSchema } from './user.schema';

@Module({
  imports: [
    MongooseModule.forFeature([{ name: 'User', schema: UserSchema }]),
  ],
  providers: [UsersService],
  controllers: [UsersController],
})
export class UsersModule {}

3.5 创建用户服务

在 users.service.ts 中实现 CRUD 操作：

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User } from './user.schema';

@Injectable()
export class UsersService {
  constructor(@InjectModel('User') private userModel: Model<User>) {}

  async create(user: User): Promise<User> {
    const createdUser = new this.userModel(user);
    return createdUser.save();
  }

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

  async findOne(id: string): Promise<User> {
    return this.userModel.findById(id).exec();
  }

  async remove(id: string): Promise<void> {
    await this.userModel.findByIdAndDelete(id).exec();
  }
}

3.6 创建用户控制器

在 users.controller.ts 中处理请求：

import { Controller, Get, Post, Body, Param, Delete } from '@nestjs/common';
import { UsersService } from './users.service';
import { User } from './user.schema';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  create(@Body() user: User) {
    return this.usersService.create(user);
  }

  @Get()
  findAll() {
    return this.usersService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usersService.findOne(id);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.usersService.remove(id);
  }
}

4. 总结

通过以上示例，我们展示了如何在 Nest.js 中使用 TypeORM 和 Mongoose 进行数据库操作。对于 SQL 数据库，我们使用 TypeORM 来定义实体、执行 CRUD 操作和管理迁移；而对于 MongoDB，我们使用 Mongoose 来定义模型和实现相应的操作

。

  • TypeORM：适合关系型数据库，支持强类型和复杂查询。
  • Mongoose：适合非关系型数据库，提供灵活的文档结构。

两者的结合使用，使得 Nest.js 成为一个强大的后端框架，能够支持多种数据库需求。通过良好的模块化设计，我们可以将数据库操作与业务逻辑分开，提高代码的可维护性。

评论区
评论列表
作者信息

“这家伙很懒啥都没有写！”

热门专栏

移动零

LeetCode 热题 100 - 两数之和

盛最多水的容器

三数之和

最长连续序列

在网页中使用 Materialize 实现中文日期选择器

MaterializeCSS轮播组件：构建动态网页内容的利器

在网页中使用 Materialize 实现日期选择器

使用 Materialize 实现图文列表布局

使用 Materialize 实现响应式布局

menu