NestJS ( 一 ) 总览 安装 连接数据库

125 阅读4分钟

介绍

Nest是一个用于构建高效 , 可扩展的Nodejs服务端应用程序的框架 . 它使用渐进式javascript, 内置并完全支持Ts 并结合了OOP面向对象编程 FP函数式编程 FRP函数式响应编程的元素

在底层,Nest使用强大的HTTP Server框架 如Express 和 Fasify Nest在这些框架之上提供了一定程度的抽象 同时将API直接暴露给开发者

安装

npm i -g @nestjs/cli
nest new project-name
src
    app.controller.spec.ts  // 对于基本控制器的单元测试样例
    app.controller.ts     // 带有单个路由的基本控制器
    app.module.ts        // 应用程序的根模块
    app.service.ts       // 带有单个方法的基本服务
    main.ts             //入口文件  使用NestFactory用来创建Nest应用实例
// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

连接MySql数据库

npm i typeorm mysql2 @nestjs/typeorm -S

app.module.ts

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { TypeOrmModule } from "@nestjs/typeorm";
import { UserModule } from './user/user.module';
@Module({
  imports: [
    UserModule,
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: ip,
      port: port,
      username: '***',
      password: '***',
      database: 'test-vip',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true,
    })
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

例如: user表 --- 只是demo demo demo

image.png

user.entity.ts

import { BaseEntity, Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";

@Entity()

export class User extends BaseEntity {
    /**
     * 
     *  @PrimaryGeneratedColumn() 创建一个主列,该值将使用自动增量值自动生成。 
     *  它将使用auto-increment /serial /sequence创建int列(取决于数据库)。
     *  你不必在保存之前手动分配其值,该值将会自动生成。
     * 
     * */ 
    @PrimaryGeneratedColumn({
        type:'int',
        name:'id',
        comment:"主键id"
    })
    id: number;
    @Column({
        type:'varchar',
        length:50,
        name:'username',
        comment:'用户名'
    })
    username: string;
    @Column()
    password: string
    @Column()
    role: string
    // 是一个特殊列,自动为实体插入日期。无需设置此列,该值将自动设置。
    @CreateDateColumn()
    createTime:Date
    //是一个特殊列,在每次调用实体管理器或存储库的save时,自动更新实体日期。无需设置此列,该值将自动设置。
    @UpdateDateColumn()
    updateTime:Date
}

user.module.ts

import { Module } from '@nestjs/common';
import { UserService } from './user.service';
import { TypeOrmModule } from "@nestjs/typeorm";
import { User } from "./user.entity";
import { UserController } from "./user.controller";

@Module({
  imports:[TypeOrmModule.forFeature([User])],
  providers: [UserService],
  controllers:[UserController]
})
export class UserModule {}

user.service.ts

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

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
  ) {} 
  async findAll(page: number, limit: number,username:string,password:string){
    let list = await this.userRepository.createQueryBuilder("user")
    .skip((page-1)*limit)
    .limit(limit)
    .where("user.username LIKE :username",{username:`%${username}%`})
    .andWhere("user.password LIKE :password",{password:`%${password}%`})
    .getManyAndCount()
    return {
      total:list[1],
      list:list[0]
    }
  }
  async create(user: User): Promise<User> {
    return await this.userRepository.save(user);
  } 
  async update(user: User): Promise<void> {
    await this.userRepository.update(user.id, user);
  } 
  async delete(id: number): Promise<void> {
    await this.userRepository.delete(id);
  }
}

user.controller.ts

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

@Controller('user')
export class UserController {
  constructor(private readonly userService: UserService) {}
  @Get("list")
  async findAll(@Query('page') page: number = 1, @Query('limit') limit: number = 10,@Query("username") username:string = "",@Query("password") password:string = "") {
    limit = Math.min(limit, 50);
    return this.userService.findAll(page, limit,username,password);
  }
  @Post("add")
  async create(@Body() user: User): Promise<User> {
    return this.userService.create(user);
  } 
  @Put(':id')
  async update(@Param('id') id: number, @Body() user: User): Promise<void> {
    user.id = id;
    await this.userService.update(user);
  } 
  @Delete(':id')
  async delete(@Param('id') id: number): Promise<void> {
    await this.userService.delete(id);
  }
}

image.png

使用MongoDB

npm i mongoose @nestjs/mongoose -S

app.module.ts

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { AuthModule } from './auth/auth.module';
import { UsersModule } from './users/users.module';
import { MongooseModule } from "@nestjs/mongoose"
import { ClientModule } from './client/client.module';


@Module({
  imports: [
    MongooseModule.forRoot("mongodb://root:rootpassword@ip/database"),
    UsersModule,
    AuthModule,
    ClientModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

例如: user表 --- 只是demo demo demo

user.schema.ts


import { Schema } from "mongoose";

export const UserSchema = new Schema(
    {
        username: { type: String, required: true },
        password: { type: String, required: true },
        role: { type: String, required: false },
        createTime:{type:Number},
        updateTime:{type:Number},
    },
    {
        versionKey: false,
        autoCreate: true,
        timestamps: { createdAt: 'createTime', updatedAt: 'updateTime', currentTime: ()=>Date.now() },
    }
)

user.module.ts

/*
 * @Author: zhang_gen_yuan
 * @Date: 2023-05-10 20:36:03
 * @LastEditTime: 2023-05-10 21:21:00
 * @Descripttion: 
 */
import { Module,forwardRef } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';
import { UserSchema } from "./users.schema";
import { MongooseModule } from '@nestjs/mongoose';

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

user.service.ts

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User, CreateUserDTO, LoginDTO } from "./user.interface"

@Injectable()
export class UsersService {
    private readonly users: User[];
    constructor(@InjectModel("Users") private readonly userModel: Model<User>) { }
    async getUserList(body, pager) {
        const total: number = await this.userModel.countDocuments(body)
        console.log(total, "总条数")
        return await this.userModel.find(body).skip((pager.pageNum - 1) * pager.pageSize).limit(pager.pageSize).then(list => {
            console.log("list", list.length)
            return {
                total,
                list
            }
        })
    }

    async insetUser(body: any) {
        return await this.userModel.create(body)
    }

    async deleteUser(body) {
        return await this.userModel.deleteOne(body)
    }

    async updateUser(_id, body) {
        return await this.userModel.findByIdAndUpdate(_id, body)
    }

    async findOne(username, password) {
        const user = await this.userModel.findOne({ username })
        if(!user) return {};
        return user
    }
}

user.controller.ts

/*
 * @Author: zhang_gen_yuan
 * @Date: 2023-05-10 20:36:03
 * @LastEditTime: 2023-05-10 21:28:28
 * @Descripttion: 
 */
import { Controller, Get, Query, Body, Post,Inject,UseGuards } from '@nestjs/common';
import { AuthGuard } from "@nestjs/passport";
import { UsersService } from './users.service';
import { ApiBody, ApiParam, ApiProperty, ApiQuery, ApiTags } from "@nestjs/swagger";

@Controller('user')
export class UsersController {
  constructor(private readonly userService: UsersService) { }
  @UseGuards(AuthGuard('jwt'))
  @Get('list')
  @ApiQuery({ name: "username", type: String, description: "用户名" })
  @ApiQuery({ name: "pageSize", type: Number, description: "一页大小" })
  @ApiQuery({ name: "pageNum", type: Number, description: "页数" })
  async findAll(@Query() query): Promise<any> {
    const queryData: any = {}
    const pager = {
      pageSize: query.pageSize || 10,
      pageNum: query.pageNum || 1,
    }
    if (query.username) queryData.username = query.username
    return await this.userService.getUserList(queryData, pager)
  }

  @Post("save")
  async saveUser(@Body() body) {
    console.log(body,"body")
    return await this.userService.insetUser(body)
  }

  @Post("delete")
  @ApiBody({})
  async deleteUser(@Body() body) {
    const data = { _id: body.id }
    return await this.userService.deleteUser(data)
  }

  @Post("update")
  async updateUser(@Body() body) {
    return await this.userService.updateUser(body._id, body)
  }
}

服务器运维本人使用的宝塔

宝塔面板 www.bt.cn/new/downloa…

Centos安装脚本

yum install -y wget && wget -O install.sh https://download.bt.cn/install/install_6.0.sh && sh install.sh ed8484bec

部署的话 就是打个build包 丢到服务器

image.png