Nest interceptors 过滤器 使用笔记

获取用户信息不显示密码

 - entities 文件
 - 在实体类中引入
 import { Exclude } from "class-transformer";
 
 - 在实体类中使用
 @Exclude()
 password: string

---------------------------------------------------------------------------------
- controller 文件
 - 在控制器中引入
 import {ClassSerializerInterceptor, UseInterceptors }    from '@nestjs/common';
 
 - 在接口上注入
 @UseInterceptors(ClassSerializerInterceptor)
 @Get('/:id')
 async findUser(@Param('id') id: string) {}

****

- 新建一个 dto 文件 user.dto.ts 
import { Expose } from "class-transformer"
export class UserDto {
    @Expose()
    id: number
    
    @Expose()
    email: string
}
- 新建一个 过滤器文件  serialize.interceptors.ts
import { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
import { plainToClass } from "class-transformer";
import { Observable } from "rxjs";
import { map } from "rxjs";
import { UserDto } from "src/users/dto/user.dto";
export class SerializeInterceptors implements NestInterceptor {
    intercept(context: ExecutionContext, next: CallHandler<any>): Observable<any> | Promise<Observable<any>> {
        // 在请求处理程序处理请求之前运行一些东西
        return next.handle().pipe(
            map((item: any) => {
                // 在发出请求后运行一些东西
                return plainToClass(UserDto, item, {
                    excludeExtraneousValues: true // 排除多余的属性
                })
            })
        )
    }
}

- 在控制文件 controller 中使用
 import { UseInterceptors }  from '@nestjs/common';
 import { SerializeInterceptors } from 'src/interceptors/serialize.interceptors';
 // 查询全部数据
 @Get('/')
 @UseInterceptors(SerializeInterceptors)
 findAllUser() {
 	return this.userService.find()
 }

把硬编码的的 serialize.interceptors 实例 改成动态的

import { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
import { plainToClass } from "class-transformer";
import { Observable, map } from "rxjs";

export class SerializeInterceptors implements NestInterceptor {
    constructor(private dto: any) { }
    intercept(context: ExecutionContext, next: CallHandler<any>): Observable<any> | Promise<Observable<any>> {
        // 在请求处理程序处理请求之前运行一些东西
        return next.handle().pipe(
            map((item: any) => {
                // 在发出请求后运行一些东西
                return plainToClass(this.dto, item, {
                    excludeExtraneousValues: true // 排除多余的属性
                })
            })
        )
    }
}

- 使用 
import { UseInterceptors } from '@nestjs/common';
import { SerializeInterceptors } from 'src/interceptors/serialize.interceptors';
import { UserDto } from './dto/user.dto';
// 查询单条数据
@UseInterceptors(new SerializeInterceptors(UserDto))
@Get('/:id')
async findUser(@Param('id') id: string) {}

装饰器优化

- 老的 使用方式 
@UseInterceptors(new SerializeInterceptors(UserDto))

- 新的使用方式
- @Serialize(UserDto)


-  serialize.interceptors.ts 文件
import { CallHandler, ExecutionContext, NestInterceptor,UseInterceptors } from "@nestjs/common";
import { plainToClass } from "class-transformer";
import { Observable, map } from "rxjs";

export function  Serialize(dto:any){
	return UseInterceptors(new SerializeInterceptors(dto))
}

export class SerializeInterceptors implements NestInterceptor {
    constructor(private dto: any) { }
    intercept(context: ExecutionContext, next: CallHandler<any>): Observable<any> | Promise<Observable<any>> {
        // 在请求处理程序处理请求之前运行一些东西
        return next.handle().pipe(
            map((item: any) => {
                // 在发出请求后运行一些东西
                return plainToClass(this.dto, item, {
                    excludeExtraneousValues: true // 排除多余的属性
                })
            })
        )
    }
}