如何使用Express.JS接收多个请求

Question

我正在编写Angular 6 + Express.JS应用程序，现在我遇到了以下问题：当同时有多个请求时，有时（尤其是有四个以上的请求时）全部404响应甚至被取消。我在Express中处理请求的方式是否存在任何问题，或者应该对并发请求进行一些调整？

请求：

let requests = [];
files.forEach((file) => {
    if (file.type.toLowerCase().includes('zip')) {
        requests.push(this.imagesService.uploadArchive(file).pipe(first()));
    } else {
        requests.push(this.imagesService.saveImage(file).pipe(first()));
    }
});

forkJoin(requests).subscribe(
    (res) => res.forEach(response => {
        this.onSave.emit(response);
    }), 
    (error) => {
        console.error(error);
    }, 
    () => {
        this.close.emit();
    }
);

快递处理路线：

router.post('/images',
    formidable({
        encoding: 'utf-8',
        uploadDir: path.resolve(__dirname, '..', '..', 'uploads'),
        multiples: true,
        keepExtensions: true
    }),
    (req, res, next) => {
        const image = req.fields;
        const data = req.files;
        image.path = data.image.path;

        const file = fs.createReadStream(image.path);

        saveImage(image).then(
            result => {
                if (result) {
                    res.status(200).send(result);
                } else {
                    console.error("Cannot save image");
                    res.status(400).send("Cannot save image");
                }
        }).catch(e => console.error(e.stack));
});

回复：

更新

router.post('/archives',
    formidable({
        encoding: 'utf-8',
        uploadDir: path.resolve(__dirname, '..', '..', 'uploads'),
        multiples: true,
        keepExtensions: true
    }),
    (req, res, next) => {
        const data = req.files;

        let promises = [];

        fs.readFile(data.archive.path, async (err, archive) => {
            if (err) throw err;

            await extractImagesFromZip(archive, data.archive.path).then((images) =>
                images.forEach((image) => {
                    promises.push(
                        saveImage(image).then(
                            result => {
                                if (result) {
                                    result.path = result.path.split('/').pop();
                                    return result;
                                } else {
                                    console.error("Cannot save image " + image.name);
                                    fs.unlink(image.path, () => {});
                                }
                        }).catch(e => {
                            fs.unlink(image.path, () => {});
                            console.error(e.stack)
                        })
                    );
                })
            );

            Promise.all(promises)
            .then((result) => {
                if (result.length > 0) {
                    res.status(200).send(result)
                } else {
                    res.status(400).send("None images were saved")
                }
            }).catch((error) => {
                console.log(error.stack);
                res.status(400).send("None images were saved")
            });
        });
    }
);

export const extractImagesFromZip = (file, link) => {
    let promises = [];

    var zip = new JSZip();
    return zip.loadAsync(file)
    .then((archive) => {
        Object.values(archive.files).filter(
            f => 
                ['.jpg', '.jpeg', '.png'].some((suffix) => f.name.toLowerCase().endsWith(suffix))
                && ![...f.name.toLowerCase().split('/')].pop().startsWith('.')
                && !f.dir 
        ).forEach(f => promises.push(zip.file(f.name).async('nodebuffer').then((content) => {
            const ext = f.name.split('.').pop().toLowerCase();
            var dest = path.resolve(__dirname, '..', '..') + '/uploads/upload_'
                + crypto.randomBytes(Math.ceil(1322)).toString('hex').slice(0, 32).toLowerCase() 
                + '.' + ext;

            return new Promise((res, rej) => { 
                fs.writeFile(dest, content, (err) => { 
                    if (err) rej(err); 

                    res(new Promise((resolve, reject) => {
                        fs.readFile(dest, (erro, data) => {
                            if (erro) reject(erro);
                            if (data) resolve({ 
                                name: f.name, 
                                type: 'image/' + (ext === 'jpg' ? 'jpeg' : ext), 
                                path: dest 
                            });
                        });
                    }));
                });
            });
        })));

        fs.unlink(link, () => {});

        return Promise.all(promises);
    });
}

export const saveImage = (image) => {
    return database.raw(
        "INSERT INTO images (name, type, path) " +
        "VALUES (?, ?, ?) " +
        "RETURNING name, type, path, id",
        [image.name, image.type, image.path]
    ).then(data => data.rows[0]).catch(e => console.error(e.stack));
};

更新2

如果用户和服务器都在localhost上（不管运行nginx的服务器还是不运行它的服务器），一切都很好，但是当服务器位于远程位置时会出现问题

Answer 1

这样的代码行得通

public async uploadFiles(files: File[]) {
    of(files)
        .pipe(
            concatMap(files =>
                files.map(file => {
                    return this.imagesService
                        .saveImage(file)
                        .pipe(
                            map(),
                            catchError((error, caught) => {
                                console.error(error);

                                return empty();
                            })
                        );
                })
            ),
            concatAll(),
            toArray(),
            map(res => console.log)
        )
        .subscribe();
}