NestJS 文件上传下载

文件上传

服务端

• 通过 multer 处理 formdata

• 接口签名验证

  不能通过 SignGuard 验证签名，因为 Guards are executed after all middleware, but before any interceptor or pipe。而 multer 是在 Interceptors 中才解析上传数据的，因此在 SignGuard 中无法获取到 req body

普通文件

图片、txt 等

• 文件较小，使用默认的内存存储，在服务层处理

// controller
  @Version('1')
  @Post('file_upload')
  // @UseGuards(SignGuard)
  @UseInterceptors(FileInterceptor('file'))
  async fileUpload(@Body() body, @UploadedFile() file: Express.Multer.File) {
    if (!file) {
      throw new HttpErrorResponse(
        ApiErrorCode.DATA_ERR,
        '上传文件为空，请重新选择',
      );
    }
    if (signCheck(body.timestamp, body.sign, body.algo)) {
      return await this.commonService.fileUpload(file, body);
    } else {
      throw new HttpUnauthorizedError('签名校验失败');
    }
  }

// service
  async fileUpload(file: Express.Multer.File, body) {
    const fileName = body.file_name || file.originalname
    const extName = extname(file.originalname).slice(1).toLowerCase()

    let encoding: BufferEncoding = 'utf8'
    if (['jpg', 'png', 'jpeg'].includes(extName)) {
      encoding = 'binary'
    }

    const filePath = join(cwd(), 'public', dayjs().format('YYYY-MM-DD'))
    await fse.ensureDir(filePath)
    await fse.writeFile(join(filePath, fileName), file.buffer, { encoding })
    return {
      file_name: fileName
    }
  }

压缩文件

• 文件较大，指定磁盘存储，保存到磁盘再处理

export class Controller {
    constructor(private readonly service: Service) {}

    @Post('studentImg')
    @UseInterceptors(
        FileInterceptor('file', {
            // 指定磁盘存储
            storage: multer.diskStorage({
                destination: (req, _, cb) => {
                    // 这里拿不到 body 中的数据，构建 dir 不要用body中的id
                    const dir = join('/tmp', 'import', Utils.randomString(6));
                    fs.ensureDirSync(dir);
                    cb(null, dir);
                },
                filename: (_, file, cb) => {
                    cb(null, file.originalname);
                },
            }),
            fileFilter: (req, file, cb) => {
                if (
                    !['application/x-zip-compressed', 'application/zip'].includes(
                        file.mimetype,
                    ) ||
                    file.originalname.split('.').pop() !== 'zip'
                ) {
                    cb(
                        new HttpErrorResponse(ApiErrorCode.DATA_ERR, '仅支持zip压缩文件'),
                        false,
                    );
                } else if (file.size === 0) {
                    cb(
                        new HttpErrorResponse(ApiErrorCode.DATA_ERR, '上传文件为空'),
                        false,
                    );
                } else {
                    cb(null, true);
                }
            },
            limits: {
                // 控制上传文件的大小，multer底层用的流传输，因此内存占用变化不大，可上传GB级文件
                fileSize: Conf.fileSizeLimit,
            },
        }),
    )
    async importStudentImg(
    	@Body() body: ImportDto,
     	@UploadedFile() file: Express.Multer.File,
    ) {
        // 选择一个文件，然后再修改这个文件的名称，上传时就找不到这个文件
        // 此时不会执行 FileInterceptor 的回调，这里获取到的 file 为 undefined
        if (!file) {
            throw new HttpErrorResponse(
                ApiErrorCode.DATA_ERR,
                '上传文件为空，请重新选择',
            );
        }
        // 大文件处理，判断是否满足可处理条件，即可返回。
        // 通过获取处理结果的接口（异步）获取处理结果。
        const preCheckRet = await this.service.preImportStudentImg(
            body.id,
            file,
        );

        return {
            state: preCheckRet.isSuccess ? 1 : 0,
            message: preCheckRet.message,
        };
    }
}

// service
export class Service {
  constructor(private readonly service: Service) {
    @Inject('REDIS_CLIENT')
    private readonly redisClient: Redis,
  }
  private randomStr = Utils.randomString(6); // 防止处理过程中服务器重启导致key没有及时删除

  async preImportStudentImg(id: string, file: Express.Multer.File) {
    const key = `import_img:${id}:${this.randomStr}`;
    // 并发控制
    const isProcessing = await this.redisClient.get(key);

    if (isProcessing) {
      return {
        isSuccess: false,
        message: '上传失败',
      };
    }

    await this.redisClient.set(key, 1, 86400); // ttl key，控制'并发控制'的时间

    try {
      // 利用 AdmZip 解压
      const zip = new AdmZip(file.path);
      zip.getEntries().forEach((entry) => {
        // 转码，windows压缩上传到linux，中文会乱码，导致找不到文件
        entry.entryName = iconv.decode(entry.rawEntryName, 'gbk');
      });
      zip.extractAllTo(file.destination);

      // 对文件的一些处理逻辑
      const fileNames = await fs.readdir(file.destination);

      // 开始处理
      this.handleData(xxx,yyy)
      // 保证一定删除 redis key 和 上传的文件
      .finally(async () => {
        await this.redisClient.del(key);
        await fs.remove(file.destination);
      });

      return {
        isSuccess: true,
        message: '上传成功',
      };
    } catch (error) {
      // 保证一定删除 redis key 和 上传的文件
      await this.redisClient.del(key);
      await fs.remove(file.destination);
      return {
        isSuccess: false,
        message: error.message,
      };
    }
  }
}

客户端

• 通过 form-data 构建 formdata
• 通过 axios POST 上传

const fileName = uuid.v1() + ".jpg";
const formData = new FormData();
formData.append("file_name", fileName);
formData.append("timestamp", timestamp);
formData.append("sign", sign);
formData.append(
  "file",
  fse.createReadStream(join(__dirname, "abc.jpg"))
);
formData.append("algo", 1);

await Axios.post("http://localhost:8801/v1/common/file_upload", formData, {
  headers: {
    // 这里不能手动加 'Content-Type': 'multipart/form-data'
    ...formData.getHeaders(),
  },
});

文件下载

服务端

• 静态目录下的文件可以直接访问下载，不需要提供接口
• 接口需通过 token 或时间戳+签名校验

@Version('1')
@Get('file_download/*')
async fileDownload(@Query() query: DownloadFileDto, @Req() req: Request, @Res() res: Response) {
    if (signCheck(query.timestamp, query.sign)) {
        // 解析 path 拿到文件名
        const fileName = req.path.split('/').splice(-2, 2).join('/')
        const path = join(cwd(), 'public', fileName)
        const check = await fse.exists(path)
        if (check) {
            return res.sendFile(path)
        } else {
            res.status(404).send({
                message: 'file not found'
            })
        }
    } else {
        throw new HttpUnauthorizedError('签名验证失败')
    }
}

客户端

// const url = 'http://localhost:8801/2024-01-25/0b2dfd20-bb5d-11ee-8738-f36b83f6da50.jpg' // 静态目录下的文件可以直接下载
const url =
  "http://localhost:8801/v1/common/file_download/2024-01-25/0b2dfd20-bb5d-11ee-8738-f36b83f6da50.jpg";

const res = await Axios.get(url, {
  params: {
    sign: "11",
    timestamp: 12,
  },
  // 配置了 responseType 情况下，res.data 是一个可读流
  responseType: "stream",
});
const filepath = join(__dirname, "a.jpg"); // 在dist目录下
const writer = fse.createWriteStream(filepath);
// res.data 是一个可读流，通过 pipe 方法，将数据从可读流输到可写流
res.data.pipe(writer);
writer.on("finish", () => console.log("download finished"));
writer.on("error", (err) => console.log("error:", err));