MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Node.js 文件系统与 HTTP 的集成案例

2021-07-277.3k 阅读

一、Node.js 文件系统简介

在深入探讨 Node.js 文件系统与 HTTP 的集成之前，我们先来了解一下 Node.js 文件系统模块。Node.js 提供了一个 fs 模块，它是文件系统操作的核心。这个模块提供了一系列方法，用于对文件和目录进行创建、读取、写入、删除等操作。

1.1 同步与异步操作

fs 模块中的方法分为同步和异步两种形式。例如，fs.readFileSync 是同步读取文件的方法，而 fs.readFile 则是异步读取文件的方法。同步方法会阻塞程序的执行，直到操作完成，这在处理较大文件或需要进行大量文件操作时可能会导致性能问题。而异步方法则不会阻塞主线程，它们通过回调函数或 Promise 来处理操作结果。

// 同步读取文件
const fs = require('fs');
try {
    const data = fs.readFileSync('example.txt', 'utf8');
    console.log(data);
} catch (err) {
    console.error(err);
}

// 异步读取文件
fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log(data);
});

1.2 文件操作方法

  • 读取文件：fs.readFile 和 fs.readFileSync 已提及，另外还有 fs.createReadStream 用于创建可读流来逐块读取大文件，提高内存使用效率。
const readableStream = fs.createReadStream('largeFile.txt');
readableStream.on('data', (chunk) => {
    console.log('Received a chunk of data:', chunk.length);
});
readableStream.on('end', () => {
    console.log('All data has been read.');
});
  • 写入文件：fs.writeFile 和 fs.writeFileSync 用于写入文件内容。同样，fs.createWriteStream 可创建可写流，用于高效写入大数据。
const data = 'This is some data to write to the file.';
fs.writeFile('newFile.txt', data, (err) => {
    if (err) {
        console.error(err);
    } else {
        console.log('File written successfully.');
    }
});
  • 目录操作：fs.mkdir 和 fs.mkdirSync 用于创建目录，fs.rmdir 和 fs.rmdirSync 用于删除目录，fs.readdir 和 fs.readdirSync 用于读取目录内容。
// 创建目录
fs.mkdir('newDir', (err) => {
    if (err) {
        console.error(err);
    } else {
        console.log('Directory created successfully.');
    }
});

// 读取目录内容
fs.readdir('newDir', (err, files) => {
    if (err) {
        console.error(err);
    } else {
        console.log('Files in the directory:', files);
    }
});

二、Node.js HTTP 模块基础

Node.js 的 http 模块是构建 HTTP 服务器和客户端的基础。它提供了简单而强大的功能，使得在 Node.js 中搭建 HTTP 服务变得相对容易。

2.1 创建 HTTP 服务器

使用 http.createServer 方法可以创建一个 HTTP 服务器实例。这个方法接受一个回调函数，该回调函数会在每次有 HTTP 请求到达服务器时被调用。回调函数有两个参数，分别是 request 和 response，它们分别代表 HTTP 请求和响应对象。

const http = require('http');

const server = http.createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/plain');
    res.end('Hello, World!');
});

const port = 3000;
server.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

在上述代码中，我们创建了一个简单的 HTTP 服务器，它监听在 3000 端口上。当有请求到达时，服务器会返回一个包含 “Hello, World!” 的文本响应。

2.2 处理 HTTP 请求

request 对象提供了关于 HTTP 请求的详细信息，比如请求方法（req.method）、请求 URL（req.url）等。我们可以根据这些信息来处理不同的请求。

http.createServer((req, res) => {
    if (req.method === 'GET' && req.url === '/') {
        res.statusCode = 200;
        res.setHeader('Content-Type', 'text/plain');
        res.end('Welcome to the home page.');
    } else if (req.method === 'GET' && req.url === '/about') {
        res.statusCode = 200;
        res.setHeader('Content-Type', 'text/plain');
        res.end('This is the about page.');
    } else {
        res.statusCode = 404;
        res.setHeader('Content-Type', 'text/plain');
        res.end('Page not found.');
    }
}).listen(3000, () => {
    console.log('Server running on port 3000');
});

此代码根据请求的 URL 来返回不同的响应内容。如果请求的是根路径（/），返回欢迎信息；如果请求的是 /about，返回关于页面的信息；否则返回 404 错误信息。

2.3 设置 HTTP 响应

response 对象用于设置和发送 HTTP 响应。我们可以通过 res.statusCode 设置状态码，res.setHeader 设置响应头，res.end 发送响应体并结束响应。

http.createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'application/json');
    const responseData = { message: 'This is a JSON response' };
    res.end(JSON.stringify(responseData));
}).listen(3000, () => {
    console.log('Server running on port 3000');
});

这里我们设置了响应头为 application/json，并将一个 JSON 对象作为响应体发送给客户端。

三、Node.js 文件系统与 HTTP 的集成案例

3.1 静态文件服务器

构建一个静态文件服务器是文件系统与 HTTP 集成的常见案例。这个服务器可以根据客户端请求的 URL 来返回相应的静态文件，如 HTML、CSS、JavaScript 文件等。

const http = require('http');
const fs = require('fs');
const path = require('path');

const server = http.createServer((req, res) => {
    const filePath = path.join(__dirname, 'public', req.url === '/'? 'index.html' : req.url);

    fs.stat(filePath, (err, stats) => {
        if (err) {
            if (err.code === 'ENOENT') {
                res.statusCode = 404;
                res.setHeader('Content-Type', 'text/plain');
                res.end('File not found');
            } else {
                res.statusCode = 500;
                res.setHeader('Content-Type', 'text/plain');
                res.end('Server error');
            }
            return;
        }

        if (stats.isFile()) {
            const contentType = getContentType(filePath);
            res.statusCode = 200;
            res.setHeader('Content-Type', contentType);
            const readStream = fs.createReadStream(filePath);
            readStream.pipe(res);
        } else {
            res.statusCode = 404;
            res.setHeader('Content-Type', 'text/plain');
            res.end('File not found');
        }
    });
});

function getContentType(filePath) {
    const extname = path.extname(filePath).toLowerCase();
    switch (extname) {
        case '.html':
            return 'text/html';
        case '.css':
            return 'text/css';
        case '.js':
            return 'application/javascript';
        default:
            return 'application/octet-stream';
    }
}

const port = 3000;
server.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

在这段代码中，我们创建了一个 HTTP 服务器。当有请求到达时，它会尝试从 public 目录中读取相应的文件。path.join 方法用于构建文件的完整路径。fs.stat 方法用于获取文件或目录的状态信息，通过判断文件是否存在以及是否为文件来决定如何响应。getContentType 函数根据文件的扩展名来设置正确的 Content - Type 响应头。如果文件存在且是文件，则通过可读流将文件内容管道传输到响应中。

3.2 文件上传服务

另一个常见的集成案例是实现文件上传服务。在 Node.js 中，我们可以使用 http 模块结合 fs 模块来实现这个功能。

const http = require('http');
const fs = require('fs');
const formidable = require('formidable');

const server = http.createServer((req, res) => {
    if (req.method === 'POST') {
        const form = new formidable.IncomingForm();
        form.uploadDir = path.join(__dirname, 'uploads');
        form.parse(req, (err, fields, files) => {
            if (err) {
                res.statusCode = 500;
                res.setHeader('Content-Type', 'text/plain');
                res.end('Error uploading file');
                return;
            }
            const oldPath = files.file.path;
            const newPath = path.join(form.uploadDir, files.file.name);
            fs.rename(oldPath, newPath, (err) => {
                if (err) {
                    res.statusCode = 500;
                    res.setHeader('Content-Type', 'text/plain');
                    res.end('Error moving file');
                } else {
                    res.statusCode = 200;
                    res.setHeader('Content-Type', 'text/plain');
                    res.end('File uploaded successfully');
                }
            });
        });
    } else {
        res.statusCode = 405;
        res.setHeader('Content-Type', 'text/plain');
        res.end('Method Not Allowed');
    }
});

const port = 3000;
server.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

在上述代码中，我们首先检查请求方法是否为 POST，因为文件上传通常使用 POST 方法。然后，我们使用 formidable 模块来解析表单数据。formidable 是一个流行的 Node.js 模块，用于处理文件上传和表单数据。form.uploadDir 设置了上传文件的临时存储目录。在解析表单数据后，我们将临时文件移动到指定的上传目录中。如果操作成功，返回成功消息；如果出现错误，返回相应的错误消息。

3.3 动态生成内容并返回

有时候我们需要根据文件内容动态生成 HTTP 响应。例如，读取一个 JSON 文件，根据其中的数据生成 HTML 内容并返回给客户端。

const http = require('http');
const fs = require('fs');
const path = require('path');

const server = http.createServer((req, res) => {
    if (req.method === 'GET' && req.url === '/generate') {
        const jsonFilePath = path.join(__dirname, 'data.json');
        fs.readFile(jsonFilePath, 'utf8', (err, data) => {
            if (err) {
                res.statusCode = 500;
                res.setHeader('Content-Type', 'text/plain');
                res.end('Error reading JSON file');
                return;
            }
            try {
                const jsonData = JSON.parse(data);
                let html = '<html><body><h1>Dynamic Content</h1><ul>';
                jsonData.forEach((item) => {
                    html += `<li>${item.name}: ${item.value}</li>`;
                });
                html += '</ul></body></html>';
                res.statusCode = 200;
                res.setHeader('Content-Type', 'text/html');
                res.end(html);
            } catch (parseErr) {
                res.statusCode = 500;
                res.setHeader('Content-Type', 'text/plain');
                res.end('Error parsing JSON data');
            }
        });
    } else {
        res.statusCode = 404;
        res.setHeader('Content-Type', 'text/plain');
        res.end('Page not found');
    }
});

const port = 3000;
server.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

在这段代码中，当客户端请求 /generate 路径时，服务器读取 data.json 文件。如果读取成功，将 JSON 数据解析并生成 HTML 内容，然后将这个 HTML 内容作为响应返回给客户端。如果读取文件或解析 JSON 数据时出现错误，返回相应的错误消息。

四、集成中的注意事项

4.1 错误处理

在文件系统与 HTTP 集成的过程中，错误处理至关重要。无论是文件操作失败还是 HTTP 请求处理出错，都需要妥善处理，以提供良好的用户体验。在前面的代码示例中，我们已经看到了一些常见的错误处理方式，如文件不存在时返回 404 错误，服务器内部错误时返回 500 错误等。 对于文件系统操作，fs 模块的方法可能会因为权限问题、文件不存在等原因抛出错误。在处理 HTTP 请求时，可能会遇到请求方法不支持、请求数据格式错误等问题。我们需要在代码中对这些可能出现的错误进行全面的处理。

http.createServer((req, res) => {
    if (req.method === 'POST') {
        const form = new formidable.IncomingForm();
        form.uploadDir = path.join(__dirname, 'uploads');
        form.on('error', (err) => {
            res.statusCode = 500;
            res.setHeader('Content-Type', 'text/plain');
            res.end('Error parsing form data');
        });
        form.parse(req, (err, fields, files) => {
            if (err) {
                res.statusCode = 500;
                res.setHeader('Content-Type', 'text/plain');
                res.end('Error uploading file');
                return;
            }
            // 文件移动等后续操作
        });
    } else {
        res.statusCode = 405;
        res.setHeader('Content-Type', 'text/plain');
        res.end('Method Not Allowed');
    }
});

在这个文件上传的例子中，我们不仅在 form.parse 回调中处理了可能出现的错误，还通过 form.on('error') 监听了 formidable 模块在解析表单数据过程中可能出现的错误。

4.2 性能优化

在处理大量文件或高并发的 HTTP 请求时，性能优化非常关键。对于文件读取，使用流（fs.createReadStream 和 fs.createWriteStream）可以显著提高性能，特别是在处理大文件时。流允许我们逐块处理数据，而不是一次性将整个文件读入内存。 在 HTTP 服务器方面，合理设置缓存、优化路由处理逻辑等都可以提升性能。例如，对于静态文件服务器，可以根据文件的修改时间等信息设置适当的缓存头，减少不必要的文件读取和传输。

http.createServer((req, res) => {
    const filePath = path.join(__dirname, 'public', req.url === '/'? 'index.html' : req.url);

    fs.stat(filePath, (err, stats) => {
        if (err) {
            if (err.code === 'ENOENT') {
                res.statusCode = 404;
                res.setHeader('Content-Type', 'text/plain');
                res.end('File not found');
            } else {
                res.statusCode = 500;
                res.setHeader('Content-Type', 'text/plain');
                res.end('Server error');
            }
            return;
        }

        if (stats.isFile()) {
            const contentType = getContentType(filePath);
            res.statusCode = 200;
            res.setHeader('Content-Type', contentType);
            // 设置缓存头
            res.setHeader('Cache - Control','max - age = 3600'); // 缓存1小时
            const readStream = fs.createReadStream(filePath);
            readStream.pipe(res);
        } else {
            res.statusCode = 404;
            res.setHeader('Content-Type', 'text/plain');
            res.end('File not found');
        }
    });
});

这里我们为静态文件服务器设置了 Cache - Control 头，指示客户端可以缓存文件 1 小时，从而减少重复请求相同文件时的服务器负载。

4.3 安全考虑

在集成过程中，安全问题不容忽视。对于文件上传功能，要防止恶意文件上传，比如通过检查文件扩展名、文件大小等方式进行验证。同时，要避免路径遍历攻击，在构建文件路径时，确保用户输入的路径不会导致访问到不应该访问的文件或目录。

const http = require('http');
const fs = require('fs');
const formidable = require('formidable');
const path = require('path');

const server = http.createServer((req, res) => {
    if (req.method === 'POST') {
        const form = new formidable.IncomingForm();
        form.uploadDir = path.join(__dirname, 'uploads');
        form.parse(req, (err, fields, files) => {
            if (err) {
                res.statusCode = 500;
                res.setHeader('Content-Type', 'text/plain');
                res.end('Error uploading file');
                return;
            }
            const allowedExtensions = ['.jpg', '.png', '.pdf'];
            const fileExtension = path.extname(files.file.name).toLowerCase();
            if (!allowedExtensions.includes(fileExtension)) {
                res.statusCode = 400;
                res.setHeader('Content-Type', 'text/plain');
                res.end('Invalid file type');
                return;
            }
            const fileSizeLimit = 1024 * 1024; // 1MB
            if (files.file.size > fileSizeLimit) {
                res.statusCode = 400;
                res.setHeader('Content-Type', 'text/plain');
                res.end('File size exceeds limit');
                return;
            }
            const oldPath = files.file.path;
            const newPath = path.join(form.uploadDir, files.file.name);
            fs.rename(oldPath, newPath, (err) => {
                if (err) {
                    res.statusCode = 500;
                    res.setHeader('Content-Type', 'text/plain');
                    res.end('Error moving file');
                } else {
                    res.statusCode = 200;
                    res.setHeader('Content-Type', 'text/plain');
                    res.end('File uploaded successfully');
                }
            });
        });
    } else {
        res.statusCode = 405;
        res.setHeader('Content-Type', 'text/plain');
        res.end('Method Not Allowed');
    }
});

const port = 3000;
server.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

在这个改进的文件上传代码中，我们检查了文件的扩展名是否在允许的列表中，并且检查了文件大小是否超过限制，从而提高了文件上传功能的安全性。

通过以上对 Node.js 文件系统与 HTTP 集成的深入探讨，我们不仅了解了两者的基本原理，还通过实际案例掌握了它们的集成方式以及在集成过程中需要注意的各种问题。希望这些知识和代码示例能帮助你在前端开发中更好地利用 Node.js 实现强大的功能。