Node.js中http模块详解

Node.js 中 http 模块全部 API 详解

Node.js 的 http 模块提供了创建 HTTP 服务器和客户端的功能。以下是 http 模块的所有 API 详解：

1. 创建 HTTP 服务器

const http = require('http');

// 1. 基本服务器
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World\n');
});

server.listen(3000, '127.0.0.1', () => {
  console.log('服务器运行在 http://127.0.0.1:3000/');
});

// 2. 使用 Server 类
const server2 = new http.Server((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World\n');
});

server2.listen(3001);

// 3. 处理不同请求方法
const server3 = http.createServer((req, res) => {
  switch (req.method) {
    case 'GET':
      handleGet(req, res);
      break;
    case 'POST':
      handlePost(req, res);
      break;
    default:
      res.writeHead(405);
      res.end('Method Not Allowed');
  }
});

function handleGet(req, res) {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ message: 'GET request handled' }));
}

function handlePost(req, res) {
  let body = '';
  
  req.on('data', chunk => {
    body += chunk.toString();
  });
  
  req.on('end', () => {
    try {
      const data = JSON.parse(body);
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ received: data }));
    } catch (e) {
      res.writeHead(400);
      res.end('Invalid JSON');
    }
  });
}

2. 服务器事件

// 1. 连接事件
server.on('connection', (socket) => {
  console.log('新连接建立');
  
  socket.on('data', (chunk) => {
    console.log('收到数据:', chunk.toString());
  });
  
  socket.on('end', () => {
    console.log('连接结束');
  });
  
  socket.on('error', (err) => {
    console.error('Socket 错误:', err);
  });
});

// 2. 请求事件
server.on('request', (req, res) => {
  console.log('收到请求:', req.method, req.url);
});

// 3. 错误事件
server.on('error', (err) => {
  console.error('服务器错误:', err);
});

// 4. 关闭事件
server.on('close', () => {
  console.log('服务器关闭');
});

// 5. 监听事件
server.on('listening', () => {
  console.log('服务器开始监听');
});

3. 服务器方法

// 1. 启动服务器
server.listen(3000, '127.0.0.1', () => {
  console.log('服务器运行在 http://127.0.0.1:3000/');
});

// 2. 关闭服务器
server.close(() => {
  console.log('服务器已关闭');
});

// 3. 获取服务器地址信息
const address = server.address();
console.log('服务器地址:', address);
// { address: '127.0.0.1', family: 'IPv4', port: 3000 }

// 4. 设置超时
server.setTimeout(60000); // 60 秒
server.on('timeout', (socket) => {
  console.log('连接超时');
});

// 5. 获取最大头信息大小
const maxHeaderSize = server.maxHeaderSize;
console.log('最大头信息大小:', maxHeaderSize);

// 6. 设置最大头信息大小
server.maxHeaderSize = 16384; // 16KB

4. 请求对象 (http.IncomingMessage)

// 1. 请求属性
server.on('request', (req, res) => {
  console.log('请求方法:', req.method);
  console.log('请求 URL:', req.url);
  console.log('请求头:', req.headers);
  console.log('HTTP 版本:', req.httpVersion);
  console.log('HTTP 版本号:', req.httpVersionMajor, req.httpVersionMinor);
  console.log('原始 URL:', req.rawHeaders);
  console.log('原始尾随头信息:', req.rawTrailers);
  console.log('尾随头信息:', req.trailers);
  console.log('Socket:', req.socket);
  console.log('连接:', req.connection);
});

// 2. 请求事件
server.on('request', (req, res) => {
  // 数据事件
  req.on('data', (chunk) => {
    console.log('收到数据块:', chunk);
  });
  
  // 结束事件
  req.on('end', () => {
    console.log('请求数据接收完成');
  });
  
  // 错误事件
  req.on('error', (err) => {
    console.error('请求错误:', err);
  });
  
  // 关闭事件
  req.on('close', () => {
    console.log('请求关闭');
  });
  
  // 中止事件
  req.on('aborted', () => {
    console.log('请求中止');
  });
});

// 3. 请求方法
server.on('request', (req, res) => {
  // 销毁请求
  req.destroy();
  
  // 暂停请求
  req.pause();
  
  // 恢复请求
  req.resume();
});

5. 响应对象 (http.ServerResponse)

// 1. 响应属性
server.on('request', (req, res) => {
  console.log('响应头已发送:', res.headersSent);
  console.log('响应完成:', res.finished);
  console.log('响应发送中:', res.sending);
  console.log('响应状态码:', res.statusCode);
  console.log('响应状态消息:', res.statusMessage);
  console.log('Socket:', res.socket);
});

// 2. 响应方法
server.on('request', (req, res) => {
  // 设置响应头
  res.setHeader('Content-Type', 'text/plain');
  res.setHeader('X-Custom-Header', 'value');
  
  // 获取响应头
  const contentType = res.getHeader('Content-Type');
  console.log('Content-Type:', contentType);
  
  // 移除响应头
  res.removeHeader('X-Custom-Header');
  
  // 写入响应头
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  
  // 写入响应体
  res.write('Hello ');
  res.write('World\n');
  
  // 结束响应
  res.end();
  
  // 刷新响应头
  res.flushHeaders();
});

// 3. 响应事件
server.on('request', (req, res) => {
  // 完成事件
  res.on('finish', () => {
    console.log('响应完成');
  });
  
  // 关闭事件
  res.on('close', () => {
    console.log('响应关闭');
  });
});

6. HTTP 客户端

// 1. 发送 GET 请求
const getReq = http.get('http://example.com', (res) => {
  console.log('状态码:', res.statusCode);
  console.log('头信息:', res.headers);
  
  let data = '';
  
  res.on('data', chunk => {
    data += chunk;
  });
  
  res.on('end', () => {
    console.log('响应数据:', data);
  });
});

getReq.on('error', (err) => {
  console.error('请求错误:', err);
});

// 2. 发送 POST 请求
const postData = JSON.stringify({ key: 'value' });

const options = {
  hostname: 'example.com',
  path: '/api/data',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData)
  }
};

const postReq = http.request(options, (res) => {
  console.log('状态码:', res.statusCode);
  
  let data = '';
  
  res.on('data', chunk => {
    data += chunk;
  });
  
  res.on('end', () => {
    console.log('响应数据:', data);
  });
});

postReq.on('error', (err) => {
  console.error('请求错误:', err);
});

postReq.write(postData);
postReq.end();

// 3. 使用 Agent
const agent = new http.Agent({
  keepAlive: true,
  keepAliveMsecs: 1000,
  maxSockets: 10
});

const reqWithAgent = http.request({
  hostname: 'example.com',
  path: '/',
  agent: agent
}, (res) => {
  // 处理响应
});

// 4. 取消请求
const req = http.request(options, (res) => {
  // 处理响应
});

req.abort(); // 取消请求

7. HTTP 代理

// 1. 创建代理服务器
const proxyServer = http.createServer((req, res) => {
  const options = {
    hostname: 'target-server.com',
    path: req.url,
    method: req.method,
    headers: req.headers
  };
  
  const proxyReq = http.request(options, (proxyRes) => {
    res.writeHead(proxyRes.statusCode, proxyRes.headers);
    proxyRes.pipe(res);
  });
  
  proxyReq.on('error', (err) => {
    console.error('代理请求错误:', err);
    res.writeHead(500);
    res.end('Proxy Error');
  });
  
  req.pipe(proxyReq);
});

proxyServer.listen(8080);

// 2. 使用 http-proxy-middleware
const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');

const app = express();

app.use('/api', createProxyMiddleware({
  target: 'http://target-server.com',
  changeOrigin: true,
  pathRewrite: {
    '^/api': ''
  },
  onProxyRes: (proxyRes, req, res) => {
    proxyRes.headers['Access-Control-Allow-Origin'] = '*';
  }
}));

app.listen(3000);

8. HTTPS 服务器

const https = require('https');
const fs = require('fs');

// 1. 创建 HTTPS 服务器
const options = {
  key: fs.readFileSync('private.key'),
  cert: fs.readFileSync('certificate.crt')
};

const httpsServer = https.createServer(options, (req, res) => {
  res.writeHead(200);
  res.end('Secure connection');
});

httpsServer.listen(443);

// 2. HTTPS 客户端
const httpsReq = https.get('https://example.com', (res) => {
  console.log('状态码:', res.statusCode);
  
  let data = '';
  
  res.on('data', chunk => {
    data += chunk;
  });
  
  res.on('end', () => {
    console.log('响应数据:', data);
  });
});

httpsReq.on('error', (err) => {
  console.error('请求错误:', err);
});

9. 中间件模式

// 1. 基本中间件
function middleware(req, res, next) {
  console.log('请求:', req.method, req.url);
  next();
}

// 2. 错误处理中间件
function errorHandler(err, req, res, next) {
  console.error('错误:', err);
  res.writeHead(500);
  res.end('Internal Server Error');
}

// 3. 中间件链
const middlewares = [
  middleware,
  (req, res, next) => {
    req.timestamp = Date.now();
    next();
  },
  (req, res, next) => {
    console.log('请求时间:', req.timestamp);
    next();
  }
];

// 4. 应用中间件
function applyMiddlewares(req, res, middlewares) {
  let index = 0;
  
  function next() {
    if (index < middlewares.length) {
      const middleware = middlewares[index++];
      middleware(req, res, next);
    } else {
      // 所有中间件处理完毕，发送响应
      res.writeHead(200, { 'Content-Type': 'text/plain' });
      res.end('Hello World\n');
    }
  }
  
  next();
}

// 5. 使用中间件
const server = http.createServer((req, res) => {
  applyMiddlewares(req, res, middlewares);
});

10. 实际应用示例

// 1. 文件服务器
const fileServer = http.createServer((req, res) => {
  const filePath = path.join(__dirname, req.url);
  
  fs.stat(filePath, (err, stats) => {
    if (err) {
      res.writeHead(404);
      res.end('File Not Found');
      return;
    }
    
    if (stats.isFile()) {
      const stream = fs.createReadStream(filePath);
      res.writeHead(200, { 'Content-Type': getContentType(filePath) });
      stream.pipe(res);
    } else {
      res.writeHead(403);
      res.end('Forbidden');
    }
  });
});

function getContentType(filePath) {
  const ext = path.extname(filePath);
  const contentTypes = {
    '.html': 'text/html',
    '.js': 'text/javascript',
    '.css': 'text/css',
    '.json': 'application/json',
    '.png': 'image/png',
    '.jpg': 'image/jpeg',
    '.gif': 'image/gif'
  };
  
  return contentTypes[ext] || 'application/octet-stream';
}

// 2. API 服务器
const apiServer = http.createServer((req, res) => {
  const url = new URL(req.url, `http://${req.headers.host}`);
  
  if (url.pathname === '/api/users') {
    if (req.method === 'GET') {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify([
        { id: 1, name: 'User 1' },
        { id: 2, name: 'User 2' }
      ]));
    } else if (req.method === 'POST') {
      let body = '';
      
      req.on('data', chunk => {
        body += chunk.toString();
      });
      
      req.on('end', () => {
        try {
          const user = JSON.parse(body);
          res.writeHead(201, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify({ id: 3, ...user }));
        } catch (e) {
          res.writeHead(400);
          res.end('Invalid JSON');
        }
      });
    } else {
      res.writeHead(405);
      res.end('Method Not Allowed');
    }
  } else {
    res.writeHead(404);
    res.end('Not Found');
  }
});

// 3. 负载均衡器
const servers = [
  { host: 'server1.example.com', port: 3001 },
  { host: 'server2.example.com', port: 3002 },
  { host: 'server3.example.com', port: 3003 }
];

let currentServer = 0;

const loadBalancer = http.createServer((req, res) => {
  const server = servers[currentServer];
  currentServer = (currentServer + 1) % servers.length;
  
  const options = {
    hostname: server.host,
    port: server.port,
    path: req.url,
    method: req.method,
    headers: req.headers
  };
  
  const proxyReq = http.request(options, (proxyRes) => {
    res.writeHead(proxyRes.statusCode, proxyRes.headers);
    proxyRes.pipe(res);
  });
  
  proxyReq.on('error', (err) => {
    console.error('代理请求错误:', err);
    res.writeHead(502);
    res.end('Bad Gateway');
  });
  
  req.pipe(proxyReq);
});

http 模块的主要特点：

1. 提供 HTTP 服务器和客户端功能
2. 支持请求和响应处理
3. 支持 HTTPS
4. 提供事件驱动 API
5. 支持流式处理

使用建议：

1. 使用事件处理请求和响应
2. 正确处理错误情况
3. 使用流式处理大文件
4. 设置适当的超时
5. 考虑使用更高级的框架（如 Express）简化开发