位置：文档库 > JavaScript > nodejs实现的简单web服务器功能示例

nodejs实现的简单web服务器功能示例

BlazeOracle 上传于 2021-12-01 03:42

《Node.js实现的简单Web服务器功能示例》

Node.js作为基于Chrome V8引擎的JavaScript运行时环境，凭借其非阻塞I/O和事件驱动特性，成为构建高性能网络应用的理想选择。本文将通过一个完整的示例，展示如何使用Node.js原生模块创建基础Web服务器，涵盖HTTP请求处理、路由分发、静态文件服务等核心功能，并深入解析其工作原理。

一、基础HTTP服务器搭建

Node.js内置的http模块提供了创建HTTP服务器的核心功能。以下是一个最简单的服务器实现：

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello, Node.js Server!\n');
});

const PORT = 3000;
server.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}/`);
});

这段代码创建了一个监听3000端口的服务器，对所有请求返回纯文本响应。运行后访问http://localhost:3000即可看到输出结果。其工作原理如下：

http.createServer()创建服务器实例
回调函数处理每个请求，接收request和response对象
res.writeHead()设置响应头
res.end()发送响应体并结束连接
server.listen()启动服务器监听指定端口

二、请求与响应对象解析

请求对象（req）包含客户端发送的所有信息，响应对象（res）用于构建服务器返回内容。关键属性与方法如下：

1. 请求对象核心属性

// 示例：打印请求方法、URL和头信息
const server = http.createServer((req, res) => {
  console.log(`Method: ${req.method}`);
  console.log(`URL: ${req.url}`);
  console.log('Headers:', req.headers);
  
  res.end('Request info logged');
});

req.method：HTTP方法（GET/POST等）
req.url：请求路径（不含域名和端口）
req.headers：包含所有请求头的对象
req.socket：底层网络套接字信息

2. 响应对象核心方法

// 示例：设置响应头并返回JSON数据
const server = http.createServer((req, res) => {
  res.writeHead(200, {
    'Content-Type': 'application/json',
    'X-Powered-By': 'Node.js'
  });
  
  const data = { message: 'JSON response' };
  res.end(JSON.stringify(data));
});

res.writeHead()：设置状态码和响应头（必须在res.end()前调用）
res.setHeader()：单独设置某个响应头
res.statusCode：直接设置状态码
res.end()：必须调用以结束响应

三、路由系统实现

基础服务器对所有路径返回相同内容，实际应用中需要实现路由功能。以下是一个简单的路由实现：

const http = require('http');

const routes = {
  '/': (req, res) => {
    res.end('Home Page');
  },
  '/about': (req, res) => {
    res.end('About Us');
  },
  '/contact': (req, res) => {
    res.end('Contact Info');
  },
  default: (req, res) => {
    res.writeHead(404);
    res.end('404 Not Found');
  }
};

const server = http.createServer((req, res) => {
  const handler = routes[req.url] || routes.default;
  handler(req, res);
});

server.listen(3000);

更复杂的路由系统可以结合URL解析和正则表达式：

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

const server = http.createServer((req, res) => {
  const parsedUrl = url.parse(req.url, true);
  const pathname = parsedUrl.pathname;
  
  if (pathname === '/api/users') {
    if (req.method === 'GET') {
      res.end(JSON.stringify({ users: ['Alice', 'Bob'] }));
    } else if (req.method === 'POST') {
      let body = '';
      req.on('data', chunk => { body += chunk.toString(); });
      req.on('end', () => {
        const newUser = JSON.parse(body);
        res.end(`User ${newUser.name} created`);
      });
    }
  } else {
    res.writeHead(404);
    res.end('Not Found');
  }
});

server.listen(3000);

四、静态文件服务实现

实际应用中需要提供静态文件（HTML、CSS、JS等）服务。以下是一个简单的静态文件服务器实现：

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);
  const extname = path.extname(filePath).toLowerCase();
  
  const mimeTypes = {
    '.html': 'text/html',
    '.js': 'text/javascript',
    '.css': 'text/css',
    '.json': 'application/json',
    '.png': 'image/png',
    '.jpg': 'image/jpeg',
    '.gif': 'image/gif'
  };
  
  const contentType = mimeTypes[extname] || 'application/octet-stream';
  
  fs.readFile(filePath, (err, content) => {
    if (err) {
      if (err.code === 'ENOENT') {
        fs.readFile(path.join(__dirname, 'public', '404.html'), (err, content) => {
          res.writeHead(404, { 'Content-Type': 'text/html' });
          res.end(content, 'utf8');
        });
      } else {
        res.writeHead(500);
        res.end('Server Error');
      }
    } else {
      res.writeHead(200, { 'Content-Type': contentType });
      res.end(content, 'utf8');
    }
  });
});

server.listen(3000, () => {
  console.log('Static file server running at http://localhost:3000/');
});

关键实现细节：

使用path.join()安全拼接文件路径
通过文件扩展名确定MIME类型
使用fs.readFile()异步读取文件
处理文件不存在（404）和服务器错误（500）情况
设置正确的Content-Type响应头

五、中间件模式实现

Express等框架的核心是中间件模式，我们可以自己实现一个简化版：

class App {
  constructor() {
    this.middlewares = [];
  }
  
  use(middleware) {
    this.middlewares.push(middleware);
  }
  
  listen(port) {
    const server = http.createServer((req, res) => {
      let index = 0;
      
      const next = () => {
        if (index  {
  console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
  next();
});

app.use((req, res, next) => {
  if (req.url === '/protected') {
    // 模拟认证
    const auth = req.headers['authorization'];
    if (auth === 'Bearer secret') {
      next();
    } else {
      res.writeHead(401);
      res.end('Unauthorized');
    }
  } else {
    next();
  }
});

app.use((req, res) => {
  res.end('Hello from middleware!');
});

app.listen(3000);

中间件模式的核心特点：

每个中间件接收(req, res, next)参数
调用next()将控制权传递给下一个中间件
可以修改请求/响应对象或提前结束响应
按注册顺序依次执行

六、错误处理机制

完善的服务器需要处理各种错误情况：

const http = require('http');

const server = http.createServer((req, res) => {
  try {
    // 模拟可能出错的代码
    if (req.url === '/error') {
      throw new Error('Simulated error');
    }
    
    res.end('No errors');
  } catch (err) {
    console.error('Server error:', err);
    res.writeHead(500);
    res.end('Internal Server Error');
  }
});

// 处理未捕获的异常
process.on('uncaughtException', (err) => {
  console.error('Uncaught Exception:', err);
  // 实际应用中应该记录错误并优雅退出
  process.exit(1);
});

server.listen(3000);

更完整的错误处理方案应包含：

同步代码的try-catch
异步代码的回调错误处理
未捕获异常监听
未处理Promise拒绝监听
错误日志记录

七、性能优化技巧

提升Node.js服务器性能的几个关键点：

1. 保持连接（Keep-Alive）

const server = http.createServer((req, res) => {
  res.setHeader('Connection', 'keep-alive');
  // ...其他处理
});

2. 启用Gzip压缩

需要使用zlib模块：

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

const server = http.createServer((req, res) => {
  const acceptEncoding = req.headers['accept-encoding'];
  
  fs.readFile('large-file.txt', (err, data) => {
    if (err) {
      res.writeHead(500);
      return res.end('Error');
    }
    
    if (acceptEncoding.includes('gzip')) {
      res.writeHead(200, { 'Content-Encoding': 'gzip' });
      zlib.gzip(data, (_, compressed) => {
        res.end(compressed);
      });
    } else {
      res.writeHead(200);
      res.end(data);
    }
  });
});

3. 缓存控制

const server = http.createServer((req, res) => {
  const lastModified = new Date().toUTCString();
  
  res.setHeader('Cache-Control', 'public, max-age=3600');
  res.setHeader('Last-Modified', lastModified);
  
  // 检查If-Modified-Since头实现条件请求
  const ifModifiedSince = req.headers['if-modified-since'];
  if (ifModifiedSince === lastModified) {
    res.writeHead(304);
    return res.end();
  }
  
  // ...正常返回内容
});

八、完整示例：带路由和静态文件服务的服务器

综合以上知识，以下是一个功能完整的服务器实现：

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

class Server {
  constructor() {
    this.routes = {
      GET: {},
      POST: {}
    };
    this.staticDir = path.join(__dirname, 'public');
  }

  get(path, handler) {
    this.routes.GET[path] = handler;
  }

  post(path, handler) {
    this.routes.POST[path] = handler;
  }

  handleStatic(req, res) {
    const parsedUrl = url.parse(req.url);
    let filePath = path.join(this.staticDir, parsedUrl.pathname === '/' ? 'index.html' : parsedUrl.pathname);
    
    // 防止路径遍历攻击
    filePath = path.normalize(filePath);
    if (!filePath.startsWith(this.staticDir)) {
      res.writeHead(403);
      return res.end('Forbidden');
    }

    const extname = path.extname(filePath).toLowerCase();
    const mimeTypes = {
      '.html': 'text/html',
      '.js': 'text/javascript',
      '.css': 'text/css',
      '.png': 'image/png',
      '.jpg': 'image/jpeg'
    };

    fs.readFile(filePath, (err, content) => {
      if (err) {
        if (err.code === 'ENOENT') {
          fs.readFile(path.join(this.staticDir, '404.html'), (err, content) => {
            res.writeHead(404, { 'Content-Type': 'text/html' });
            res.end(content || '404 Not Found');
          });
        } else {
          res.writeHead(500);
          res.end('Server Error');
        }
      } else {
        const contentType = mimeTypes[extname] || 'application/octet-stream';
        res.writeHead(200, { 'Content-Type': contentType });
        res.end(content);
      }
    });
  }

  listen(port) {
    const server = http.createServer((req, res) => {
      // 路由处理
      const routeHandler = this.routes[req.method][req.url] || 
                          (() => this.handleStatic(req, res));
      
      // 处理POST请求体
      if (req.method === 'POST') {
        let body = [];
        req.on('data', chunk => { body.push(chunk); })
           .on('end', () => {
             body = Buffer.concat(body).toString();
             routeHandler(req, res, body);
           });
      } else {
        routeHandler(req, res);
      }
    });

    server.listen(port, () => {
      console.log(`Server running at http://localhost:${port}/`);
    });
  }
}

// 使用示例
const app = new Server();

// 定义路由
app.get('/api/users', (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' });
  res.end(JSON.stringify({ users: ['Alice', 'Bob'] }));
});

app.post('/api/users', (req, res, body) => {
  try {
    const newUser = JSON.parse(body);
    res.writeHead(201, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ message: `User ${newUser.name} created` }));
  } catch (err) {
    res.writeHead(400);
    res.end('Invalid JSON');
  }
});

// 启动服务器
app.listen(3000);

九、总结与扩展建议

本文通过多个示例展示了Node.js创建Web服务器的核心技术，包括：

基础HTTP服务器创建
请求/响应对象操作
路由系统实现
静态文件服务
中间件模式
错误处理机制
性能优化技巧

对于生产环境，建议考虑以下扩展：

使用Express/Koa等成熟框架
实现HTTPS支持
添加日志系统（如Winston）
集成数据库访问
实现会话管理
添加CSRF/XSS防护
使用集群模式利用多核CPU

关键词：Node.js、Web服务器、HTTP模块、路由系统、静态文件服务、中间件模式、错误处理、性能优化

简介：本文详细介绍了使用Node.js原生模块实现Web服务器的完整过程，涵盖基础服务器创建、请求响应处理、路由系统实现、静态文件服务、中间件模式、错误处理机制和性能优化技巧，最后提供了一个功能完整的服务器实现示例。

立即下载

JavaScript相关