检测sql语句执行效率

简单使用

```  js
  app.enableCors(); // 添加跨域
```

 自定义配置

```js
app.enableCors((req, callback) => {
   callback(null, { origin: req.headers.origin, credentials: true });
}); // 添加跨域
```



NestJs 配置跨域

```ts
const job = new CronJob(`0 */1 * * * *`, async () => {
  const now = dayjs().toDate();
  const oneMinuteAgo = dayjs().subtract(5, 'minute').toDate();
  const messages = await this.pushMessageRepository.findBy({
    status: 1,
    pushTime: Between(oneMinuteAgo, now),
  });
  messages.forEach((item) => {
    this.push(item.id);
  });
});
this.schedulerRegistry.addCronJob(`cron-pushMessage`, job);
job.start();
```



js简单使用定时任务

今天接触到一个mysql的业务场景

有两张表：course、teacher

course 表中有 teacher_ids 字段。里面存储的是 teacher 表的 id 以逗号分隔的字符串。

现在要查询 course 列表，并且关联查询出 teacher_ids 中关联教师的数据。



MySQL提供了一个名为`FIND_IN_SET()`的内置字符串函数，允许您在逗号分隔的字符串列表中查找指定字符串的位置。

下面说明了`FIND_IN_SET()`函数的语法。

```sql
FIND_IN_SET(needle,haystack);
```

`FIND_IN_SET()`函数接受两个参数：

- 第一个参数`needle`是要查找的字符串。
- 第二个参数`haystack`是要搜索的逗号分隔的字符串列表。

参考：https://www.yiibai.com/mysql/find_in_set.html 



原生语句用法：

```sql
select * from tp_course join tp_course_teacher on find_in_set(tp_course_teacher.id, tp_course.teacher_ids);
```

Typeorm:

```js
async find({ where, order, take, skip }: findDto) {
  const [list, total] = await this.courseRepository
    .createQueryBuilder('course')
    .leftJoinAndMapMany(
      'course.teachers',
      Teacher,
      'teacher',
      `FIND_IN_SET(teacher.id, course.teacher_ids)`,
    )
    .where(where)
    .orderBy(order)
    .take(take)
    .skip(skip)
    .getManyAndCount();
  return { list, total };
}
```
knex 过滤:
```
const targetId = 123; // 要检查的目标 id

const result = await knex('your_table')
  .whereRaw(`FIND_IN_SET(?, your_column) > 0`, [targetId])
  .select('*');
```



MYSQL关联查询以逗号分隔id的数据

# 前言
在后端开发中，对数据库的了解是必不可少的。这里记录一下我所掌握的一些常用命令。
# 常用命令
- `mysql_secure_installation` 初始化数据库
- `mysql -u root -p` 连接数据库
- `alter user root@localhost identified by 'root';` 更改数据库密码
- `show databases` 查看数据库
- `create database database_name` 创建数据库
- `create database database_name default character set charset_name ` 创建数据库，设置字符集
- `alter database database_name default character set charset_name ` 修改数据库字符集
- `drop database my_db` 删除数据库
- `use my_db` 选择数据库
- `show tables` 查看表
- `create table table_name(column_name column_type)` 创建表
- `drop table table_name` 删除表
- `insert into table_name values(column_value_1, column_value_2)` 插入数据
- `insert into table_name(column_name_1, column_name_2) values(column_value_1, column_value_2)` 插入数据

# 表

## 创建表

```sql
-- 创建用户表
create table user
(
userid varchar(100) primary key,
nickname varchar(20),
email varchar(20),
phone int(11),
`password` varchar(20),
createdate datetime,
avatar varchar(255),
sex int,
birthday date,
address varchar(255)
)
-- 创建博文表
create table blog
(
blogid varchar(100) primary key,
title varchar(255) not null,
content longtext
)
-- 创建发表博文表
create table blog_add
(
userid varchar(100),
blogid varchar(100),
createdate datetime
) 
-- 创建博文浏览表
create table blog_look
(
userid varchar(100),
blogid varchar(100),
foreign key(userid) references `user`(userid),
foreign key(blogid) references blog(blogid)
)
-- 创建博文点赞表
create table blog_agree
(
userid varchar(100) unique,
blogid varchar(100) unique,
foreign key(userid) references `user`(userid),
foreign key(blogid) references blog(blogid)
)
```

## 修改表结构

```sql
ALTER TABLE <表名> 
{ ADD COLUMN <列名> <类型>        #增加列
| CHANGE COLUMN <旧列名> <新列名> <新列类型>        #修改列名&数据类型
| ALTER COLUMN <列名> { SET DEFAULT <默认值> | DROP DEFAULT }        #修改某列的默认值
| MODIFY COLUMN <列名> <类型>        #修改数据类型
| DROP COLUMN <列名>        #删除列
| RENAME TO <新表名>        #重命名表 （TO可省略不写，不影响）
| CHARACTER SET <字符集名>        #修改字符集（表的编码格式等）
| COLLATE <校对规则名> }        字符集内用于字符比较和排序的一套规则
```

## 联合唯一约束

```sql
create table blog_agree
(
userid varchar(100) not null,
blogid varchar(100) not null,
foreign key(userid) references `user`(userid),
foreign key(blogid) references blog(blogid),
unique(userid,blogid)
)
```

# 触发器

查看所有触发器

```sql
show triggers;
```

删除触发器

```sql
drop trigger user_insert_before;
```

创建触发器

```sql
-- 创建触发器user_insert_before，用户信息必须符合以下条件，否则插入失败。条件如下：
-- 1. 性别只能为：null、0、1。
-- 2. 生日不能大于当天。
-- 3. 注册时间不能大于当前。
create trigger user_insert_before before insert on `user` for each row
begin
	if new.sex !=0 
	or new.sex!=1 
	or new.sex is not null
	or new.birthday > now() 
	or new.createdate > now() then
		insert into errortable values(0);
	end if;
end;

insert into user(username,nickname,email,phone,`password`,createdate,avatar,sex,birthday,address) values
(null,'小贩','1778211090@qq.com',13454133320,'admin','2022-6-1','http://heiza.work/avatar.png',1,'2000-2-5','山东省滨州市惠民县')

-- 创建触发器blog_insert_before，录入博客信息时，浏览量不能为负数，否则插入失败。
create trigger blog_insert_before before insert on blog for each row
begin
	if new.title is null or new.look < 0 then
		insert into errortable values(0);
	end if;
end;

show triggers;
drop trigger blog_insert_before;
insert into blog(title,content,look) values
('《望庐山瀑布》 [唐] 李白','日照香炉生紫烟，遥看瀑布挂前川。飞流直下三千尺，疑是银河落九天。',-1)
```

# 函数

```sql
-- 创建一个函数get_user_age，传入用户id，返回用户当前年龄。
create function get_user_age(uid varchar(100)) returns int
reads sql data
begin
	declare age int;
	select year(now())-year(birthday) into age from user where userid = uid;
	return age;
end;
select get_user_age('db5c22fee48311eca808b025aa2e1a1b');

-- 创建一个函数get_blog_agree_count，传入博文id，返回博文的点赞数。
create function get_blog_agree_count(bid varchar(100)) returns bigint
reads sql data
begin
	declare agree_count bigint;
	select count(*) into agree_count from blog_agree where blogid = bid;
	return agree_count;
end;
select get_blog_agree_count('2f07108ee48511eca808b025aa2e1a1b');

-- 创建一个函数get_comment_agree_count，传入评论id，返回评论的点赞数。
create function get_comment_agree_count(cid varchar(100)) returns bigint
reads sql data
begin
	declare agree_count bigint;
	select count(*) into agree_count from comment_agree where commentid = cid;
	return agree_count;
end;
select get_comment_agree_count('021a265de48b11eca808b025aa2e1a1b');

-- 创建一个函数get_comment_comment_count，传入评论id，返回评论的回复数。
create function get_comment_comment_count(cid varchar(100)) returns bigint
reads sql data
begin
	declare comment_count bigint;
	select count(*) into comment_count from comment_comment where parentid = cid;
	return comment_count;
end;
select get_comment_comment_count('0219e77be48b11eca808b025aa2e1a1b');

-- 创建一个函数get_blog_comment_count，传入博文id，返回博文的评论数。
create function get_blog_comment_count(bid varchar(100)) returns bigint
reads sql data
begin
	declare blog_comment_count bigint;
	declare comment_comment_count bigint;
	select count(*) into blog_comment_count from blog_comment where blogid = bid;
	select count(*) into comment_comment_count from blog_comment join comment_comment on blog_comment.commentid = comment_comment.parentid;
	return blog_comment_count+comment_comment_count;
end;
select get_blog_comment_count('2f06ec42e48511eca808b025aa2e1a1b');
```

# 存储过程

```sql
-- 创建一个存储过程agree_blog_list，传入用户id，返回点赞的博文列表。
create procedure agree_blog_list(uid varchar(100))
reads sql data
begin
	select * from blog join blog_agree on blog.blogid = blog_agree.blogid where blog_agree.userid=uid;
end;
call agree_blog_list('db5c22fee48311eca808b025aa2e1a1b');
-- 创建一个存储过程user_blog_list，传入用户id，返回该用户发表的博文列表。
create procedure user_blog_list(uid varchar(100))
reads sql data
begin
	select * from blog join blog_add on blog.blogid = blog_add.blogid where blog_add.userid=uid;
end;
call user_blog_list('db5c22fee48311eca808b025aa2e1a1b');
```

# 视图

```sql
-- 创建视图view_user_info，查看用户信息，包含当前年龄，不包含密码信息。
create view view_user_info as select userid,username,nickname,email,phone,avatar,sex,birthday,address,createdate,get_user_age(userid) as age from user;
select * from view_user_info;

-- 创建视图view_blog_info，查看博文信息，包含点赞量和评论数。
create view view_blog_info as select blogid,title,content,look,get_blog_agree_count(blogid) as agree_count,get_blog_comment_count(blogid) as comment_count,createdate from blog;
select * from view_blog_info;
-- 创建视图view_blog_hot_list，查看点赞量大于100的文章列表。
create view view_blog_hot_list as select * from blog where get_blog_agree_count(blogid)>100;
select * from view_blog_hot_list;

-- 创建视图view_blog_hotlook_list，查看浏览量大于100的文章列表。
create view view_blog_hotlook_list as select * from blog where look>100;
select * from view_blog_hotlook_list;
```

MySQL 常用命令合集

```ts
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ServeStaticModule } from '@nestjs/serve-static';
import { join } from 'path';

@Module({
  imports: [
    ServeStaticModule.forRoot({
      rootPath: join(__dirname, '..', 'public'),
      serveRoot: '/public'
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule { }
```

这样配置之后就可以通过访问 `http://localhost:3000/public/avatar.jpg`，访问到 `public` 目录中的文件了。

NestJS 配置静态资源目录

# 前言
在使用 NestJS 的过程中，涉及到了 OSS 上传文件的功能，这里简单记录一下。
# 代码实现
oss.controller.ts
```ts
import { Controller, Post, UseInterceptors, UploadedFile } from '@nestjs/common';
import { FileInterceptor } from '@nestjs/platform-express';
import { Result } from 'src/utils/ResultType';
import { OssService } from './oss.service';

@Controller({ path: 'oss', version: '1' })
export class OssController {
  constructor(private readonly ossService: OssService) { }

  @Post('uploadImage')
  @UseInterceptors(FileInterceptor('file'))
  async uploadImage(@UploadedFile() file: Express.Multer.File) {
    const res = await this.ossService.uploadFile('images/' + file.originalname, file.buffer, file.size)
    return Result.success(res)
  }
}
```

oss.service.ts

```ts
import { Injectable } from '@nestjs/common';
import * as OSS from 'ali-oss';

@Injectable()
export class OssService {
  private client: any
  constructor() {
    this.client = new OSS({
      region: 'oss-cn-hangzhou',
      accessKeyId: 'LTAI5tPH6aKN7Jo6Ft2CPkoU',
      accessKeySecret: 'SCG5GiJ1SAcvIJ7UMSRMtu4IUemQjy',
      bucket: 'somelight'
    })
  }
  public async uploadFile(ossPath: string, localPath: any, size: number): Promise<string> {
    if (size > 5 * 1024 * 1024) {
      return await this.resumeUpload(ossPath, localPath)
    } else {
      return await this.upload(ossPath, localPath)
    }
  }
  // oss put上传文件
  private async upload(ossPath: string, localPath: string): Promise<string> {

    const res = await this.client.put(ossPath, localPath)
    // 将文件设置为公共可读
    await this.client.putACL(ossPath, 'public-read')
    return res.url
  }

  // oss 断点上传
  private async resumeUpload(ossPath: string, localPath: string): Promise<string> {
    let checkPoint: number = 0
    let bRet = ''
    for (let i = 0; i < 3; i++) {
      let result = this.client.multipartUpload(ossPath, localPath, {
        checkPoint,
        async progress(percent: number, cpt: any) {
          checkPoint = cpt
        }
      })
      await this.client.putACL(ossPath, 'public-read')
      bRet = result.url
      break
    }
    return bRet
  }

  // 删除文件
  private async deleteOne(filePath: string) {
    if (!filePath) {
      return
    }
    await this.client.delete(filePath)
  }

  // 删除多个文件
  private async deleteMulti(filePathArr: string[]) {
    await this.client.deleteMulti(filePathArr, { quiet: true })
  }

  // 获取文件的url
  public async getFileSignatureUrl(filePath: string): Promise<string> {
    if (!filePath) {
      return null
    }
    const result = await this.client.signatureUrl(filePath, { expires: 36000 })
    return result
  }

  // 判断文件是否存在
  public async existObject(ossPath: string): Promise<boolean> {
    try {
      const result = await this.client.get(ossPath)
      if (result.res.status === 200) {
        return true
      }
    } catch (err) {
      if (err.code === 'NoSuchKey') {
        return false
      }
    }
  }
}

```

# 总结
以上就是我对NestJS处理OSS上传文件的一些总结。

NestJS 实现 OSS上传文件

# 前言
在使用NestJS的过程中，用到了JWT做登录鉴权，在这里记录一下这部分内容。

首先附上官网介绍：https://docs.nestjs.com/security/authentication
# 具体实现

先安装相关依赖

```
npm install --save @nestjs/passport passport passport-local passport-jwt
npm install --save-dev @types/passport-local
```

添加 auth 相关文件，这里面处理 token 的颁发和解析

```
nest g module auth
nest g service auth
```

创建 `auth/jwt.strategy.ts` 文件，这是 jwt 的策略文件。

```ts
import { ExtractJwt, Strategy } from 'passport-jwt';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable } from '@nestjs/common';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: process.env.SECRET,
    });
  }

  async validate(payload: any) {
    return payload
  }
}
```

编辑 `auth/auth.module.ts` 文件

```ts
import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt/dist';
import { AuthService } from './auth.service';
import { JwtStrategy } from './jwt.strategy';

@Module({
  imports: [
    JwtModule.register({
      secret: process.env.SECRET, // 这里是jwt的密钥
      signOptions: { expiresIn: '60s' }
    })
  ],
  providers: [AuthService, JwtStrategy],
  exports: [AuthService],
})
export class AuthModule { }

```

对应一些常量，我存储在了根目录下的 `.env`文件中，推荐包括数据库在内等关键信息都存储在这里面。

使用 process 对象需要在 `app.module.ts` 中添加以下配置

```ts
import { ConfigModule } from '@nestjs/config';

@Module({
  imports: [
    ConfigModule.forRoot(),
    ...
  ],
  controllers: [AppController],
  providers: [AppService],
})
```

编辑 `auth/auth.service.ts`文件，这里我们只需要声明一个获取 token 的函数。

```ts
import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';

@Injectable()
export class AuthService {
  constructor(private jwtService: JwtService) { }

  public async getToken(payload) {
    return this.jwtService.sign(payload, { secret: process.env.SECRET })
  }
}
```

编辑`user/user.module.ts`文件，引入 `AuthModule` 模块

```ts
import { Module } from '@nestjs/common';
import { UserService } from './user.service';
import { UserController } from './user.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './entities/user.entity';
import { AuthModule } from 'src/auth/auth.module';

@Module({
  imports: [TypeOrmModule.forFeature([User]), AuthModule],
  controllers: [UserController],
  providers: [UserService],
  exports: [UserService]
})
export class UserModule { }
```

编辑 `user/user.service.ts`文件，当登录校验完成后，获取token返回给前端。

```ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { CreateUserDto } from './dto/create-user.dto';
import { LoginUserDto } from './dto/login-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { User } from './entities/user.entity';
import { Result, stateCode } from '../config/ResultType';
import { comparePassword } from 'src/utils/bcrypt';
import { AuthService } from 'src/auth/auth.service';

@Injectable()
export class UserService {
  constructor(@InjectRepository(User) private userRepository: Repository<User>, private authService: AuthService) { }

  // 用户登录
  async login(loginUserDto: LoginUserDto) {
    const { user_account } = loginUserDto
    const user = await this.userRepository.findOne({
      select: ['user_password'],
      where: {
        user_account
      }
    })
    if (user && comparePassword(loginUserDto.user_password, user.user_password)) {
      // 重新获取用户信息
      const res = await this.userRepository.findOne({ where: { user_account } })
      const token = await this.authService.getToken({ ...res })
      return Result.success({ ...res, token });
    } else {
      return Result.fail(stateCode.UNEXPECT, '用户名或密码错误')
    }
  }
  // ...
  async findOneByAccount(user_account: LoginUserDto['user_account']) {
    return await this.userRepository.findOne({
      select: ['user_id', 'user_password'],
      where: { user_account }
    });
  }

  async findOne(id: number) {
    return await this.userRepository.findOne({ where: { user_id: id } });
  }
}
```

编辑`user/user.controller.ts`文件，进行 jwt 的校验

```ts
import { Controller, Get, Post, Body, Patch, Param, Delete, UseGuards, Req } from '@nestjs/common';
import { UserService } from './user.service';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { LoginUserDto } from './dto/login-user.dto';
import { AuthGuard } from '@nestjs/passport';
import { Result } from 'src/config/ResultType';

@Controller({ path: 'user', version: '1' })
export class UserController {
  constructor(private readonly userService: UserService) { }

  @Post('login')
  login(@Body() loginUserDto: LoginUserDto) {
    return this.userService.login(loginUserDto)
  }
    
  @UseGuards(AuthGuard('jwt'))
  @Get('whoami')
  async whoami(@Req() req) {
    const res = await this.userService.findOne(+req.user.user_id) // 通过jwt中的user_id，获取用户信息
    return Result.success(res)
  }
}
```

这样，通过访问 `http://localhost:3000/v1/user/login`，就可以获取到 token 了。

通过访问 `http://localhost:3000/v1/user/whoami`，在 header 里面携带 `Authorization:Bearer token`，就可以获取到登录用户的信息。

> 注意，这里的 Bearer 是必须要携带的，不然token会校验失败。

这里的 `@UseGuards(AuthGuard('jwt'))`是对单个接口进行校验，如果整个模块都需要 jwt 校验的话，可以将这行代码放至`@Controller()`上方，对整个模块的接口都进行校验。

# 总结
以上就是我对 NestJS 中使用 JWT 的一些个人总结。

NestJS 实现 JWT

# 前言
在使用NestJS过程中接触到了 TypeORM 这个ORM框架。

这里以一个 ToDoList 为案例，介绍一下这个库的使用。

中文文档：https://typeorm.bootcss.com/

# 安装和引入

安装

`npm install --save @nestjs/typeorm typeorm mysql2`

引入数据库

```ts
// app.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mysql',
      username: 'root',
      password: 'root',
      host: 'localhost',
      port: 3306,
      database: 'todolistdb',
      entities: [__dirname + '/**/*.entity{.ts,.js}'], //实体文件
      synchronize: true, //synchronize字段代表是否自动将实体类同步到数据库
      retryDelay: 500, //重试连接数据库间隔
      retryAttempts: 10, //重试连接数据库的次数
      autoLoadEntities: true, //如果为true,将自动加载实体 forFeature()方法注册的每个实体都将自动添加到配置对象的实体数组中
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule { }
```

# 建立todo对象

```ts
// src/todo/entities/todo.entity.ts
import { Column, Entity, PrimaryGeneratedColumn } from "typeorm";

@Entity()
export class Todo {
  // 自增列
  @PrimaryGeneratedColumn()
  id: number
  @Column()
  content: string
  @Column()
  status: boolean
}
```

# 增删改查

以一个简单的 ToDoList 为例

```ts
// src/todo/todo.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Result } from 'src/config/resultType';
import { Repository } from 'typeorm';
import { CreateTodoDto } from './dto/create-todo.dto';
import { UpdateTodoDto } from './dto/update-todo.dto';
import { Todo } from './entities/todo.entity';

@Injectable()
export class TodoService {
  constructor(@InjectRepository(Todo) private todoRepository: Repository<Todo>) { }

  async create(createTodoDto: CreateTodoDto) {
    let res = await this.todoRepository.insert(createTodoDto)
    return Result.success(res)
  }

  async findAll() {
    let res = await this.todoRepository.find()
    return Result.success(res)
  }

  async findOne(id: number) {
    let res = await this.todoRepository.findOne({ where: { id } })
    return Result.success(res)
  }

  async update(id: number, updateTodoDto: UpdateTodoDto) {
    let res = await this.todoRepository.update(id, updateTodoDto)
    return Result.success(res)
  }

  async remove(id: number) {
    let res = await this.todoRepository.delete(id)
    return Result.success(res)
  }
}
// src/config/resultType.ts
export enum stateCode {
  OK = 200,
  UNEXPECT = 400, //未知错误
  NEED_AUTH = 401, //需要登录
  NO_FIND = 402, //找不到相关资源
  BAD_REQUEST = 403, //请求错误
  EXISTED = 408, //字段已存在
  SEVER_ERR = 500, //服务器错误
}

export class Result {
  constructor(private code: stateCode,
    private data: Object | Array<any> | string | null,
    private msg: string
  ) { }
  public static success(data: Object | Array<any> | string | null) {
    return new Result(200, data, "success")
  }
  public static fail(code: stateCode, msg: string) {
    return new Result(code, null, msg)
  }
}
```



# 

后端分类文章