Node.js HTTP 服务中的错误处理策略

Node.js HTTP 服务基础

在深入探讨 Node.js HTTP 服务中的错误处理策略之前，我们先来回顾一下 Node.js 中创建 HTTP 服务的基础知识。在 Node.js 里，通过内置的 http 模块可以轻松创建一个 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 模块，然后使用 http.createServer 方法创建了一个服务器实例。这个方法接受一个回调函数，该回调函数会在每次有 HTTP 请求到达服务器时被调用。回调函数有两个参数，req 代表请求对象，包含了客户端请求的所有信息，如请求方法、请求头、请求体等；res 代表响应对象，用于向客户端发送响应。我们设置了响应状态码为 200，响应头的 Content-Type 为 text/plain，并通过 res.end 方法结束响应并发送内容。最后，我们通过 server.listen 方法让服务器监听指定的端口 3000。

常见错误类型

在 Node.js HTTP 服务开发过程中，会遇到各种各样的错误。了解这些常见错误类型，有助于我们制定针对性的错误处理策略。

网络相关错误

1. 端口被占用 当我们尝试启动服务器监听一个已经被其他进程占用的端口时，就会抛出 EADDRINUSE 错误。例如，在上述代码中，如果已经有另一个进程在监听 3000 端口，再次运行这段代码时就会出现这个错误。
2. 连接超时 在客户端与服务器进行连接时，如果在规定的时间内没有成功建立连接，就会触发连接超时错误。这可能是由于网络不稳定、服务器负载过高或者防火墙等原因导致的。在 Node.js 中，我们可以通过设置 socket 的 timeout 属性来控制连接超时时间。

请求处理错误

1. 无效的请求方法 如果客户端发送的请求方法（如 GET、POST、PUT、DELETE 等）不被服务器所支持，这就属于无效的请求方法错误。例如，服务器只处理 GET 和 POST 请求，而客户端发送了一个 PATCH 请求，就会产生这种错误。
2. 错误的请求头 请求头包含了客户端与服务器通信的重要信息，如 Content-Type、User - Agent 等。如果客户端发送的请求头格式不正确或者缺少必要的请求头字段，就可能导致服务器无法正确处理请求。比如，在处理 POST 请求时，客户端没有设置正确的 Content - Type 头来表明请求体的格式，服务器在解析请求体时就可能出错。
3. 请求体解析错误 当客户端发送的请求包含请求体（如 POST、PUT 请求）时，服务器需要对请求体进行解析。如果请求体的格式不符合预期，就会出现请求体解析错误。例如，预期请求体是 JSON 格式，但实际发送的是普通文本，而服务器按照 JSON 格式去解析就会出错。

响应处理错误

1. 状态码设置错误 HTTP 状态码用于表示服务器对请求的处理结果。如果设置了错误的状态码，可能会导致客户端误解服务器的响应意图。比如，本应该返回 200 OK 表示成功，但错误地返回了 404 Not Found。
2. 响应头设置错误 响应头同样重要，它包含了关于响应的一些元信息，如 Content - Type 决定了响应体的内容类型。如果设置错误，可能会导致客户端无法正确处理响应。例如，将 Content - Type 设置为 application/json，但实际响应体是 HTML 内容，浏览器在解析时就会出现问题。

错误处理策略

了解了常见错误类型后，我们来探讨如何在 Node.js HTTP 服务中进行有效的错误处理。

捕获全局未处理的异常

在 Node.js 中，可以通过监听 process 对象的 uncaughtException 事件来捕获全局未处理的异常。这样，即使在请求处理过程中出现了未被捕获的异常，也不会导致服务器崩溃。

process.on('uncaughtException', (err) => {
  console.error('Uncaught Exception:', err.message);
  console.error(err.stack);
  // 可以在这里进行一些紧急处理，如记录日志、通知运维人员等
});

上述代码中，我们为 process 对象的 uncaughtException 事件添加了一个监听器。当有未捕获的异常发生时，会打印出异常信息和堆栈跟踪，方便我们定位问题。不过，需要注意的是，虽然这种方式可以防止服务器崩溃，但最好还是在具体的业务逻辑中尽可能捕获和处理异常，而不是依赖全局的未捕获异常处理。

处理网络相关错误

1. 端口被占用错误处理 当遇到端口被占用的错误（EADDRINUSE）时，我们可以选择提示用户更换端口，或者自动尝试其他可用端口。以下是一个自动尝试其他端口的示例：

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

const startServer = (port) => {
  server.listen(port, () => {
    console.log(`Server running on port ${port}`);
  }).on('error', (err) => {
    if (err.code === 'EADDRINUSE') {
      console.log(`Port ${port} is in use, trying another port...`);
      startServer(port + 1);
    } else {
      console.error('Server startup error:', err.message);
    }
  });
};

const initialPort = 3000;
startServer(initialPort);

在这个示例中，我们定义了一个 startServer 函数，它尝试启动服务器监听指定端口。如果遇到 EADDRINUSE 错误，就会自动尝试下一个端口（端口号加 1），直到找到可用端口为止。

2. 连接超时错误处理 为了处理连接超时错误，我们可以在创建服务器时设置 socket 的 timeout 属性。当连接超时时，会触发 timeout 事件，我们可以在这个事件中进行相应的处理。

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

server.on('connection', (socket) => {
  socket.setTimeout(5000); // 设置连接超时时间为 5 秒
  socket.on('timeout', () => {
    socket.end('Connection timed out.\n');
  });
});

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

上述代码中，我们在服务器的 connection 事件中，为每个新连接的 socket 设置了超时时间为 5 秒。当连接超时时，会自动关闭连接并向客户端发送一条连接超时的消息。

处理请求处理错误

1. 无效的请求方法处理 对于无效的请求方法，我们可以返回一个合适的 HTTP 状态码（如 405 Method Not Allowed），并在响应体中说明支持的请求方法。

const http = require('http');
const server = http.createServer((req, res) => {
  const allowedMethods = ['GET', 'POST'];
  if (!allowedMethods.includes(req.method)) {
    res.statusCode = 405;
    res.setHeader('Content-Type', 'text/plain');
    res.setHeader('Allow', allowedMethods.join(', '));
    res.end(`Method ${req.method} Not Allowed. Allowed methods: ${allowedMethods.join(', ')}`);
  } else {
    // 正常处理请求
    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}`);
});

在这个示例中，我们定义了一个允许的请求方法数组 allowedMethods。如果客户端发送的请求方法不在这个数组中，就返回 405 Method Not Allowed 状态码，并在响应头的 Allow 字段中列出允许的请求方法。

2. 错误的请求头处理 当遇到错误的请求头时，我们可以根据具体情况返回不同的 HTTP 状态码。例如，如果缺少必要的请求头字段，返回 400 Bad Request。

const http = require('http');
const server = http.createServer((req, res) => {
  if (!req.headers['content - type']) {
    res.statusCode = 400;
    res.setHeader('Content-Type', 'text/plain');
    res.end('Missing Content - Type header');
  } else {
    // 正常处理请求
    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}`);
});

在这个例子中，我们检查请求头中是否包含 content - type 字段。如果没有，就返回 400 Bad Request 状态码，并在响应体中说明缺少该字段。

3. 请求体解析错误处理 在处理请求体解析错误时，我们同样返回 400 Bad Request 状态码。以解析 JSON 格式请求体为例：

const http = require('http');
const querystring = require('querystring');

const server = http.createServer((req, res) => {
  let body = '';
  req.on('data', (chunk) => {
    body += chunk.toString();
  });
  req.on('end', () => {
    try {
      const parsedBody = JSON.parse(body);
      // 处理解析后的请求体
      res.statusCode = 200;
      res.setHeader('Content-Type', 'text/plain');
      res.end('Request body parsed successfully');
    } catch (err) {
      res.statusCode = 400;
      res.setHeader('Content-Type', 'text/plain');
      res.end('Error parsing request body');
    }
  });
});

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

上述代码中，我们通过监听 req 的 data 事件来收集请求体数据，当 end 事件触发时，尝试将请求体解析为 JSON 格式。如果解析失败，捕获异常并返回 400 Bad Request 状态码。

处理响应处理错误

1. 状态码设置错误处理 为了避免状态码设置错误，我们可以定义一些辅助函数来确保状态码的正确设置。例如：

const http = require('http');

const sendResponse = (res, statusCode, message) => {
  res.statusCode = statusCode;
  res.setHeader('Content-Type', 'text/plain');
  res.end(message);
};

const server = http.createServer((req, res) => {
  try {
    // 业务逻辑
    sendResponse(res, 200, 'Success');
  } catch (err) {
    sendResponse(res, 500, 'Internal Server Error');
  }
});

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

在这个示例中，我们定义了一个 sendResponse 函数，它接受响应对象 res、状态码 statusCode 和消息 message 作为参数，并负责正确设置状态码和响应内容。在业务逻辑中，通过调用这个函数来发送响应，这样可以减少状态码设置错误的可能性。

2. 响应头设置错误处理 对于响应头设置错误，同样可以通过类似的辅助函数来保证设置的正确性。以设置 Content - Type 为例：

const http = require('http');

const sendResponse = (res, statusCode, message, contentType = 'text/plain') => {
  res.statusCode = statusCode;
  res.setHeader('Content-Type', contentType);
  res.end(message);
};

const server = http.createServer((req, res) => {
  try {
    // 业务逻辑
    sendResponse(res, 200, 'Success', 'application/json');
  } catch (err) {
    sendResponse(res, 500, 'Internal Server Error');
  }
});

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

在这个改进的 sendResponse 函数中，我们增加了一个 contentType 参数，默认值为 text/plain。在调用函数时，可以根据实际情况设置正确的 Content - Type，从而避免响应头设置错误。

日志记录与监控

在处理错误的过程中，日志记录和监控是非常重要的环节。

日志记录

通过记录详细的日志信息，我们可以在出现错误时快速定位问题。Node.js 中有很多优秀的日志库，如 winston 和 morgan。

1. 使用 winston 记录日志 winston 是一个功能强大的日志库，支持多种日志级别和日志输出方式。以下是一个简单的使用示例：

const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transport.Console(),
    new winston.transport.File({ filename: 'error.log' })
  ]
});

const http = require('http');
const server = http.createServer((req, res) => {
  try {
    // 业务逻辑
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/plain');
    res.end('Hello, World!');
  } catch (err) {
    logger.error({
      message: 'Error handling request',
      error: err.message,
      stack: err.stack
    });
    res.statusCode = 500;
    res.setHeader('Content-Type', 'text/plain');
    res.end('Internal Server Error');
  }
});

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

在上述代码中，我们首先创建了一个 winston 日志记录器 logger，它将日志输出到控制台和一个名为 error.log 的文件中。在请求处理过程中，如果出现错误，就使用 logger.error 方法记录错误信息，包括错误消息和堆栈跟踪。

2. 使用 morgan 记录 HTTP 请求日志 morgan 是一个专门用于记录 HTTP 请求日志的库。它可以记录请求的方法、URL、状态码、响应时间等信息。

const http = require('http');
const morgan = require('morgan');

const logger = morgan('dev');

const server = http.createServer((req, res) => {
  logger(req, res, () => {
    try {
      // 业务逻辑
      res.statusCode = 200;
      res.setHeader('Content-Type', 'text/plain');
      res.end('Hello, World!');
    } catch (err) {
      res.statusCode = 500;
      res.setHeader('Content-Type', 'text/plain');
      res.end('Internal Server Error');
    }
  });
});

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

在这个示例中，我们引入了 morgan 并使用 morgan('dev') 创建了一个日志记录器 logger。在服务器的请求处理回调中，通过调用 logger(req, res, callback) 来记录请求日志。dev 格式会以一种简洁易读的方式输出日志信息，方便我们在开发过程中查看请求情况。

监控

除了日志记录，监控也是保障 Node.js HTTP 服务稳定运行的重要手段。我们可以使用工具如 Node.js Process Manager (PM2) 来监控服务器的运行状态，包括 CPU 使用率、内存占用、请求处理速度等。

1. 使用 PM2 进行监控 首先，确保已经全局安装了 PM2：

npm install -g pm2

然后，使用 PM2 启动我们的 Node.js 服务器：

pm2 start app.js

这里的 app.js 是我们的 Node.js 服务器代码文件。启动后，可以通过以下命令查看监控信息：

pm2 monit

pm2 monit 命令会实时显示服务器的 CPU 和内存使用情况，以及每个请求的处理时间等信息。如果服务器出现性能问题或者错误，我们可以通过这些监控数据快速定位和解决问题。

此外，还可以结合一些第三方监控服务，如 New Relic、Datadog 等，这些服务提供了更全面、详细的监控功能，包括分布式追踪、错误分析等，可以帮助我们更好地管理和优化 Node.js HTTP 服务。

错误处理中间件

在实际的 Node.js 项目中，特别是使用 Express 等框架时，错误处理中间件是一种非常有效的错误处理方式。

Express 中的错误处理中间件

Express 是 Node.js 中最流行的 web 应用框架。在 Express 中，错误处理中间件与普通中间件类似，但它接受四个参数：err、req、res 和 next。

const express = require('express');
const app = express();

// 模拟一个会抛出错误的路由
app.get('/error', (req, res, next) => {
  throw new Error('This is a test error');
});

// 错误处理中间件
app.use((err, req, res, next) => {
  console.error(err.message);
  console.error(err.stack);
  res.status(500).send('Internal Server Error');
});

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

在上述代码中，我们定义了一个 /error 路由，它会抛出一个错误。然后，我们定义了一个错误处理中间件 app.use((err, req, res, next) => {... })。当有错误发生时，Express 会自动将错误传递给这个中间件进行处理。在中间件中，我们记录了错误信息和堆栈跟踪，并返回一个 500 Internal Server Error 的响应。

自定义错误处理中间件

除了使用 Express 内置的错误处理机制，我们还可以自定义错误处理中间件来满足特定的需求。例如，我们可以根据不同类型的错误返回不同的状态码和响应内容。

const express = require('express');
const app = express();

class ValidationError extends Error {
  constructor(message) {
    super(message);
    this.name = 'ValidationError';
  }
}

// 模拟一个会抛出验证错误的路由
app.get('/validationError', (req, res, next) => {
  throw new ValidationError('Invalid input');
});

// 自定义错误处理中间件
app.use((err, req, res, next) => {
  if (err instanceof ValidationError) {
    res.status(400).send('Validation failed:'+ err.message);
  } else {
    console.error(err.message);
    console.error(err.stack);
    res.status(500).send('Internal Server Error');
  }
});

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

在这个示例中，我们定义了一个自定义的错误类型 ValidationError。在 /validationError 路由中，我们抛出了这个自定义错误。在自定义错误处理中间件中，我们通过判断错误类型，如果是 ValidationError，就返回 400 Bad Request 状态码和相应的错误信息；否则，按照常规的 500 Internal Server Error 处理。

通过合理使用错误处理中间件，我们可以将错误处理逻辑集中管理，使代码更加清晰、易于维护，同时提高应用程序的健壮性。

总结错误处理策略的重要性

在 Node.js HTTP 服务开发中，错误处理策略至关重要。有效的错误处理可以提高服务的稳定性、可靠性和用户体验。通过捕获全局未处理的异常，我们可以防止服务器因意外错误而崩溃；针对不同类型的网络、请求和响应错误进行相应处理，确保了服务能够正确处理各种客户端请求；合理的日志记录和监控，帮助我们在出现问题时快速定位和解决；而错误处理中间件则让错误处理逻辑更加集中和易于管理。

随着 Node.js 应用的规模和复杂度不断增加，良好的错误处理策略将成为保障应用持续稳定运行的关键因素之一。开发人员应该根据项目的具体需求，综合运用上述各种错误处理方法，打造健壮、可靠的 Node.js HTTP 服务。同时，持续关注新技术和最佳实践，不断优化错误处理机制，以适应不断变化的业务需求和运行环境。