Node.js的深度实践：从入门到生产环境的完整指南 | 我的个人博客

作为一名从前端转向全栈的开发者，Node.js可以说是我技术路径上最重要的转折点。从最初的好奇尝试，到现在用它构建生产级应用，这几年的实践让我对Node.js有了深刻的理解。今天想和大家分享一下我的Node.js学习和应用心得，希望能对同样在这条路上探索的朋友有所帮助。

为什么选择Node.js？我的技术决策思考

🎯 从前端到全栈的自然过渡

还记得刚开始接触Node.js的时候，我正在做一个需要实时聊天功能的项目。当时面临一个选择：是学习PHP/Python等传统后端语言，还是尝试这个”能让JavaScript跑在服务器上”的新东西？

让我选择Node.js的核心原因：

优势	传统后端语言	Node.js
学习成本	需要学习新语法	复用JS知识
开发效率	前后端语言切换	统一技术栈
团队协作	前后端分离	全栈开发
实时应用	需要额外工具	原生支持优秀

💡 第一次”啊哈”时刻

我永远记得第一次用Node.js写出一个完整API服务时的兴奋感。短短几行代码就能启动一个HTTP服务器：

// 我的第一个Node.js服务器
const http = require('http');

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

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

这种简洁性让我瞬间爱上了Node.js。作为前端开发者，能用熟悉的语法写后端代码，这种认知连贯性大大降低了学习门槛。

Node.js核心概念：我的理解

🔄 事件循环：异步编程的核心

Node.js的事件循环是我花了最长时间理解的概念。刚开始时，我经常被异步回调搞得晕头转向。

// 早期我写的糟糕代码（回调地狱）
fs.readFile('file1.txt', (err, data1) => {
  if (err) throw err;
  fs.readFile('file2.txt', (err, data2) => {
    if (err) throw err;
    fs.readFile('file3.txt', (err, data3) => {
      if (err) throw err;
      console.log(data1 + data2 + data3);
    });
  });
});

// 现在我使用的现代方式
const fs = require('fs').promises;

async function readFiles() {
  try {
    const [data1, data2, data3] = await Promise.all([
      fs.readFile('file1.txt', 'utf8'),
      fs.readFile('file2.txt', 'utf8'),
      fs.readFile('file3.txt', 'utf8')
    ]);
    console.log(data1 + data2 + data3);
  } catch (error) {
    console.error('读取文件失败:', error);
  }
}

事件循环的关键理解：

🔄 单线程但非阻塞：主线程不会被I/O操作阻塞
⚡ 事件驱动：通过事件回调处理异步操作
🎯 适合I/O密集型：文件操作、网络请求、数据库查询

📦 模块系统：从混乱到清晰

Node.js的模块系统让我从一开始的困惑到后来的依赖。特别是从CommonJS到ES Modules的过渡：

// CommonJS (传统方式)
const express = require('express');
const { readFile } = require('fs').promises;

module.exports = {
  startServer,
  handleRequest
};

// ES Modules (现代方式)
import express from 'express';
import { readFile } from 'fs/promises';

export { startServer, handleRequest };

我的模块组织最佳实践：

my-node-app/
├── src/
│   ├── controllers/     # 控制器层
│   ├── services/        # 业务逻辑层
│   ├── models/          # 数据模型
│   ├── middleware/      # 中间件
│   ├── routes/          # 路由定义
│   ├── utils/           # 工具函数
│   └── config/          # 配置文件
├── tests/               # 测试文件
├── docs/                # 文档
└── package.json

实际项目应用：我踩过的坑

🚀 项目一：实时聊天应用

我的第一个正式Node.js项目是一个团队协作工具的聊天模块。这个项目让我深刻理解了Socket.io和WebSocket的威力。

// 聊天服务器核心代码
import { Server } from 'socket.io';
import express from 'express';
import { createServer } from 'http';

const app = express();
const server = createServer(app);
const io = new Server(server, {
  cors: {
    origin: process.env.CLIENT_URL,
    methods: ["GET", "POST"]
  }
});

// 在线用户管理
const activeUsers = new Map();

io.on('connection', (socket) => {
  console.log(`用户连接: ${socket.id}`);
  
  // 用户加入房间
  socket.on('join-room', (data) => {
    const { roomId, userId, username } = data;
    
    socket.join(roomId);
    socket.userId = userId;
    socket.roomId = roomId;
    
    // 记录在线用户
    activeUsers.set(socket.id, { userId, username, roomId });
    
    // 通知房间内其他用户
    socket.to(roomId).emit('user-joined', {
      userId,
      username,
      timestamp: new Date()
    });
    
    // 发送在线用户列表
    const roomUsers = Array.from(activeUsers.values())
      .filter(user => user.roomId === roomId);
    socket.emit('online-users', roomUsers);
  });
  
  // 处理消息
  socket.on('send-message', async (data) => {
    const { roomId, message, messageType = 'text' } = data;
    const user = activeUsers.get(socket.id);
    
    if (!user) return;
    
    // 保存消息到数据库
    const savedMessage = await saveMessage({
      roomId,
      userId: user.userId,
      content: message,
      type: messageType
    });
    
    // 广播消息
    io.to(roomId).emit('new-message', {
      id: savedMessage.id,
      content: message,
      userId: user.userId,
      username: user.username,
      timestamp: savedMessage.createdAt,
      type: messageType
    });
  });
  
  // 处理断开连接
  socket.on('disconnect', () => {
    const user = activeUsers.get(socket.id);
    if (user) {
      activeUsers.delete(socket.id);
      socket.to(user.roomId).emit('user-left', {
        userId: user.userId,
        username: user.username,
        timestamp: new Date()
      });
    }
    console.log(`用户断开连接: ${socket.id}`);
  });
});

server.listen(5000, () => {
  console.log('聊天服务器启动在端口 5000');
});

这个项目让我学到的经验：

内存管理很重要：使用Map而不是普通对象存储用户状态
错误处理不能少：网络中断、重连机制都需要考虑
性能监控必要：监控连接数、消息频率、内存使用

🔐 项目二：认证和授权系统

第二个重要项目是构建一个完整的用户认证系统，这让我深入理解了JWT、中间件和安全性。

// JWT认证中间件
import jwt from 'jsonwebtoken';
import { promisify } from 'util';

const verifyToken = promisify(jwt.verify);

export const authenticateToken = async (req, res, next) => {
  try {
    const authHeader = req.headers.authorization;
    const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
    
    if (!token) {
      return res.status(401).json({ 
        error: 'Access token required' 
      });
    }
    
    // 验证token
    const decoded = await verifyToken(token, process.env.JWT_SECRET);
    
    // 检查用户是否仍然存在
    const user = await User.findById(decoded.userId);
    if (!user) {
      return res.status(401).json({ 
        error: 'User no longer exists' 
      });
    }
    
    // 检查密码是否在token颁发后被更改
    if (user.passwordChangedAt > decoded.iat * 1000) {
      return res.status(401).json({ 
        error: 'Password recently changed. Please log in again.' 
      });
    }
    
    req.user = user;
    next();
  } catch (error) {
    console.error('Token verification failed:', error);
    res.status(403).json({ 
      error: 'Invalid or expired token' 
    });
  }
};

// 角色权限控制
export const requireRole = (...roles) => {
  return (req, res, next) => {
    if (!req.user) {
      return res.status(401).json({ 
        error: 'Authentication required' 
      });
    }
    
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({ 
        error: 'Insufficient permissions' 
      });
    }
    
    next();
  };
};

// 使用示例
app.get('/admin/users', 
  authenticateToken, 
  requireRole('admin', 'superadmin'), 
  getUsersController
);

📊 项目三：数据处理管道

最近的一个项目涉及大量数据处理，让我学会了如何优雅地处理流和大文件。

// 大文件处理示例
import { createReadStream, createWriteStream } from 'fs';
import { pipeline } from 'stream/promises';
import { Transform } from 'stream';
import csv from 'csv-parser';

// 创建数据转换流
const dataTransform = new Transform({
  objectMode: true,
  transform(chunk, encoding, callback) {
    try {
      // 数据清洗和转换
      const processed = {
        id: chunk.id,
        name: chunk.name?.trim(),
        email: chunk.email?.toLowerCase(),
        createdAt: new Date(chunk.created_at),
        // 数据验证
        isValid: this.validateRecord(chunk)
      };
      
      callback(null, processed);
    } catch (error) {
      callback(error);
    }
  },
  
  validateRecord(record) {
    return record.id && 
           record.name && 
           record.email?.includes('@');
  }
});

// 批量写入数据库
const batchInsert = new Transform({
  objectMode: true,
  constructor(options) {
    super(options);
    this.batch = [];
    this.batchSize = 1000;
  },
  
  transform(chunk, encoding, callback) {
    this.batch.push(chunk);
    
    if (this.batch.length >= this.batchSize) {
      this.processBatch()
        .then(() => callback())
        .catch(callback);
    } else {
      callback();
    }
  },
  
  async processBatch() {
    if (this.batch.length === 0) return;
    
    try {
      await User.insertMany(this.batch);
      console.log(`Processed ${this.batch.length} records`);
      this.batch = [];
    } catch (error) {
      console.error('Batch insert failed:', error);
      throw error;
    }
  },
  
  async _flush(callback) {
    try {
      await this.processBatch();
      callback();
    } catch (error) {
      callback(error);
    }
  }
});

// 处理大型CSV文件
async function processLargeCSV(inputFile, outputFile) {
  try {
    await pipeline(
      createReadStream(inputFile),
      csv(),
      dataTransform,
      batchInsert
    );
    
    console.log('文件处理完成');
  } catch (error) {
    console.error('处理失败:', error);
  }
}

性能优化：我的实战经验

⚡ 异步操作优化

在实际项目中，我发现很多性能问题都来自于不当的异步操作使用：

// ❌ 糟糕的串行操作
async function badExample(userIds) {
  const users = [];
  for (const id of userIds) {
    const user = await User.findById(id);
    const profile = await Profile.findByUserId(id);
    users.push({ user, profile });
  }
  return users;
}

// ✅ 优化的并行操作
async function goodExample(userIds) {
  const userPromises = userIds.map(async (id) => {
    const [user, profile] = await Promise.all([
      User.findById(id),
      Profile.findByUserId(id)
    ]);
    return { user, profile };
  });
  
  return Promise.all(userPromises);
}

// 🚀 进一步优化：批量查询
async function bestExample(userIds) {
  const [users, profiles] = await Promise.all([
    User.find({ _id: { $in: userIds } }),
    Profile.find({ userId: { $in: userIds } })
  ]);
  
  // 创建查找映射
  const userMap = new Map(users.map(u => [u._id.toString(), u]));
  const profileMap = new Map(profiles.map(p => [p.userId, p]));
  
  return userIds.map(id => ({
    user: userMap.get(id),
    profile: profileMap.get(id)
  }));
}

🧠 内存使用优化

内存泄漏是Node.js应用的常见问题，我总结了几个关键点：

// 监控内存使用
function logMemoryUsage() {
  const used = process.memoryUsage();
  const messages = [];
  
  for (let key in used) {
    messages.push(`${key}: ${Math.round(used[key] / 1024 / 1024 * 100) / 100} MB`);
  }
  
  console.log('Memory usage:', messages.join(', '));
}

// 定期检查内存使用
setInterval(logMemoryUsage, 30000);

// 缓存管理示例
class LRUCache {
  constructor(maxSize = 1000) {
    this.maxSize = maxSize;
    this.cache = new Map();
  }
  
  get(key) {
    if (this.cache.has(key)) {
      const value = this.cache.get(key);
      // 移到最前面（最近使用）
      this.cache.delete(key);
      this.cache.set(key, value);
      return value;
    }
    return null;
  }
  
  set(key, value) {
    if (this.cache.has(key)) {
      this.cache.delete(key);
    } else if (this.cache.size >= this.maxSize) {
      // 删除最少使用的项
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }
    
    this.cache.set(key, value);
  }
  
  clear() {
    this.cache.clear();
  }
}

// 全局缓存实例
const globalCache = new LRUCache(5000);

🔧 连接池和数据库优化

数据库连接管理是我学到的重要一课：

// MongoDB连接池配置
import mongoose from 'mongoose';

const connectDB = async () => {
  try {
    const conn = await mongoose.connect(process.env.MONGODB_URI, {
      // 连接池配置
      maxPoolSize: 50,          // 最大连接数
      minPoolSize: 5,           // 最小连接数
      maxIdleTimeMS: 30000,     // 连接空闲时间
      serverSelectionTimeoutMS: 5000, // 服务器选择超时
      socketTimeoutMS: 45000,   // Socket超时时间
      
      // 性能优化
      bufferCommands: false,    // 禁用mongoose缓冲
      bufferMaxEntries: 0       // 禁用mongoose缓冲
    });
    
    console.log(`MongoDB Connected: ${conn.connection.host}`);
  } catch (error) {
    console.error('Database connection failed:', error);
    process.exit(1);
  }
};

// 查询优化示例
const User = mongoose.model('User', {
  name: { type: String, index: true },
  email: { type: String, unique: true },
  createdAt: { type: Date, default: Date.now, index: true }
});

// 高效的分页查询
async function getUsersPaginated(page = 1, limit = 20, filters = {}) {
  const skip = (page - 1) * limit;
  
  const [users, total] = await Promise.all([
    User.find(filters)
      .select('name email createdAt') // 只选择需要的字段
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(limit)
      .lean(), // 返回普通对象而不是Mongoose文档
    
    User.countDocuments(filters)
  ]);
  
  return {
    users,
    pagination: {
      currentPage: page,
      totalPages: Math.ceil(total / limit),
      totalItems: total,
      hasNext: page < Math.ceil(total / limit),
      hasPrev: page > 1
    }
  };
}

生产环境部署：踩坑总结

🐳 Docker化部署

我现在所有的Node.js项目都使用Docker部署，这是我的标准配置：

# 多阶段构建Dockerfile
FROM node:18-alpine AS builder

WORKDIR /app

# 复制package文件
COPY package*.json ./

# 安装依赖（包括devDependencies）
RUN npm ci

# 复制源代码
COPY . .

# 构建应用
RUN npm run build

# 生产环境镜像
FROM node:18-alpine AS production

WORKDIR /app

# 创建非root用户
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nodejs -u 1001

# 复制package文件
COPY package*.json ./

# 只安装生产依赖
RUN npm ci --only=production && npm cache clean --force

# 从builder阶段复制构建产物
COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
COPY --from=builder --chown=nodejs:nodejs /app/public ./public

# 切换到非root用户
USER nodejs

# 暴露端口
EXPOSE 3000

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node healthcheck.js

# 启动应用
CMD ["node", "dist/server.js"]

🔧 环境配置管理

配置管理是我花了很多时间才搞清楚的：

// config/index.js
import dotenv from 'dotenv';

// 根据环境加载不同的配置文件
const env = process.env.NODE_ENV || 'development';
dotenv.config({ path: `.env.${env}` });

const config = {
  // 服务器配置
  server: {
    port: parseInt(process.env.PORT) || 3000,
    host: process.env.HOST || 'localhost'
  },
  
  // 数据库配置
  database: {
    uri: process.env.DATABASE_URL,
    options: {
      maxPoolSize: parseInt(process.env.DB_POOL_SIZE) || 10
    }
  },
  
  // JWT配置
  jwt: {
    secret: process.env.JWT_SECRET,
    expiresIn: process.env.JWT_EXPIRES_IN || '24h'
  },
  
  // Redis配置
  redis: {
    host: process.env.REDIS_HOST || 'localhost',
    port: parseInt(process.env.REDIS_PORT) || 6379,
    password: process.env.REDIS_PASSWORD
  },
  
  // 日志配置
  logging: {
    level: process.env.LOG_LEVEL || 'info',
    file: process.env.LOG_FILE || 'app.log'
  }
};

// 验证必需的环境变量
const requiredEnvVars = [
  'DATABASE_URL',
  'JWT_SECRET'
];

for (const envVar of requiredEnvVars) {
  if (!process.env[envVar]) {
    throw new Error(`Required environment variable ${envVar} is not set`);
  }
}

export default config;

📊 监控和日志

生产环境的监控是我学到的重要经验：

// logger.js
import winston from 'winston';
import config from './config/index.js';

const logger = winston.createLogger({
  level: config.logging.level,
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  defaultMeta: { service: 'my-app' },
  transports: [
    new winston.transports.File({ 
      filename: 'logs/error.log', 
      level: 'error' 
    }),
    new winston.transports.File({ 
      filename: 'logs/combined.log' 
    })
  ]
});

// 开发环境下也在控制台输出
if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

export default logger;

// metrics.js - 性能监控
import prometheus from 'prom-client';

// 创建指标收集器
const httpRequestDuration = new prometheus.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status_code'],
  buckets: [0.1, 0.5, 1, 2, 5]
});

const httpRequestsTotal = new prometheus.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route', 'status_code']
});

// 中间件
export const metricsMiddleware = (req, res, next) => {
  const start = Date.now();
  
  res.on('finish', () => {
    const duration = (Date.now() - start) / 1000;
    const labels = {
      method: req.method,
      route: req.route?.path || req.path,
      status_code: res.statusCode
    };
    
    httpRequestDuration.observe(labels, duration);
    httpRequestsTotal.inc(labels);
  });
  
  next();
};

// 注册默认指标
prometheus.collectDefaultMetrics();

export { prometheus };

常见问题和解决方案

Q1: 如何处理未捕获的异常？

我的解决方案：

// 全局异常处理
process.on('uncaughtException', (error) => {
  console.error('Uncaught Exception:', error);
  logger.error('Uncaught Exception', { error: error.stack });
  
  // 优雅关闭
  process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
  logger.error('Unhandled Rejection', { reason, promise });
  
  // 优雅关闭
  process.exit(1);
});

// Express错误处理中间件
const errorHandler = (error, req, res, next) => {
  logger.error('Request error', {
    error: error.stack,
    url: req.url,
    method: req.method,
    ip: req.ip
  });
  
  // 开发环境返回详细错误信息
  if (process.env.NODE_ENV === 'development') {
    res.status(500).json({
      message: error.message,
      stack: error.stack
    });
  } else {
    res.status(500).json({
      message: 'Internal Server Error'
    });
  }
};

app.use(errorHandler);

Q2: 如何优雅地关闭应用？

我的最佳实践：

// graceful-shutdown.js
class GracefulShutdown {
  constructor() {
    this.connections = new Set();
    this.isShuttingDown = false;
  }
  
  // 注册连接
  addConnection(connection) {
    this.connections.add(connection);
    
    connection.on('close', () => {
      this.connections.delete(connection);
    });
  }
  
  // 开始关闭流程
  async shutdown(signal) {
    if (this.isShuttingDown) return;
    
    console.log(`Received ${signal}. Starting graceful shutdown...`);
    this.isShuttingDown = true;
    
    // 停止接收新请求
    server.close(() => {
      console.log('HTTP server closed');
    });
    
    // 关闭数据库连接
    try {
      await mongoose.connection.close();
      console.log('Database connection closed');
    } catch (error) {
      console.error('Error closing database:', error);
    }
    
    // 关闭Redis连接
    try {
      await redis.quit();
      console.log('Redis connection closed');
    } catch (error) {
      console.error('Error closing Redis:', error);
    }
    
    // 等待现有连接完成
    const timeout = setTimeout(() => {
      console.log('Forcing shutdown...');
      process.exit(1);
    }, 10000);
    
    // 等待所有连接关闭
    const checkConnections = setInterval(() => {
      if (this.connections.size === 0) {
        clearInterval(checkConnections);
        clearTimeout(timeout);
        console.log('Graceful shutdown completed');
        process.exit(0);
      }
    }, 100);
  }
}

const gracefulShutdown = new GracefulShutdown();

// 监听关闭信号
['SIGTERM', 'SIGINT'].forEach(signal => {
  process.on(signal, () => gracefulShutdown.shutdown(signal));
});

Q3: 如何进行有效的单元测试？

我的测试策略：

// tests/services/userService.test.js
import { jest } from '@jest/globals';
import UserService from '../../src/services/UserService.js';
import User from '../../src/models/User.js';

// Mock数据库模型
jest.mock('../../src/models/User.js');

describe('UserService', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });
  
  describe('createUser', () => {
    it('should create a new user successfully', async () => {
      // Arrange
      const userData = {
        name: 'John Doe',
        email: 'john@example.com',
        password: 'password123'
      };
      
      const expectedUser = {
        id: '123',
        ...userData,
        createdAt: new Date()
      };
      
      User.create.mockResolvedValue(expectedUser);
      
      // Act
      const result = await UserService.createUser(userData);
      
      // Assert
      expect(User.create).toHaveBeenCalledWith(userData);
      expect(result).toEqual(expectedUser);
    });
    
    it('should throw error for duplicate email', async () => {
      // Arrange
      const userData = {
        name: 'John Doe',
        email: 'john@example.com',
        password: 'password123'
      };
      
      const duplicateError = new Error('Email already exists');
      duplicateError.code = 11000;
      
      User.create.mockRejectedValue(duplicateError);
      
      // Act & Assert
      await expect(UserService.createUser(userData))
        .rejects
        .toThrow('Email already exists');
    });
  });
});

// 集成测试示例
describe('User API Integration', () => {
  let app;
  
  beforeAll(async () => {
    app = await createTestApp();
  });
  
  afterAll(async () => {
    await closeTestApp(app);
  });
  
  beforeEach(async () => {
    await clearTestDB();
  });
  
  it('should create user via API', async () => {
    const userData = {
      name: 'Test User',
      email: 'test@example.com',
      password: 'password123'
    };
    
    const response = await request(app)
      .post('/api/users')
      .send(userData)
      .expect(201);
      
    expect(response.body).toMatchObject({
      id: expect.any(String),
      name: userData.name,
      email: userData.email
    });
    
    expect(response.body.password).toBeUndefined();
  });
});

2025年Node.js趋势：我的观察

🤖 AI集成成为常态

我最近在项目中开始集成AI功能，Node.js在这方面的表现让我印象深刻：

// 集成OpenAI API的聊天机器人
import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

class ChatService {
  async generateResponse(message, context = []) {
    try {
      const completion = await openai.chat.completions.create({
        model: "gpt-3.5-turbo",
        messages: [
          {
            role: "system",
            content: "You are a helpful assistant for a Node.js application."
          },
          ...context,
          {
            role: "user",
            content: message
          }
        ],
        max_tokens: 500,
        temperature: 0.7
      });
      
      return completion.choices[0].message.content;
    } catch (error) {
      console.error('OpenAI API error:', error);
      throw new Error('Failed to generate AI response');
    }
  }
  
  // 流式响应
  async* generateStreamResponse(message, context = []) {
    const stream = await openai.chat.completions.create({
      model: "gpt-3.5-turbo",
      messages: [
        { role: "system", content: "You are a helpful assistant." },
        ...context,
        { role: "user", content: message }
      ],
      stream: true
    });
    
    for await (const chunk of stream) {
      const content = chunk.choices[0]?.delta?.content;
      if (content) {
        yield content;
      }
    }
  }
}

🌥️ 无服务器架构普及

我发现越来越多的项目在使用无服务器架构，Node.js在这方面有天然优势：

// AWS Lambda函数示例
export const handler = async (event, context) => {
  // 减少冷启动时间
  context.callbackWaitsForEmptyEventLoop = false;
  
  try {
    const { httpMethod, path, body } = event;
    
    // 路由处理
    switch (path) {
      case '/users':
        if (httpMethod === 'GET') {
          return await getUsers();
        } else if (httpMethod === 'POST') {
          return await createUser(JSON.parse(body));
        }
        break;
        
      default:
        return {
          statusCode: 404,
          body: JSON.stringify({ error: 'Not found' })
        };
    }
  } catch (error) {
    console.error('Lambda error:', error);
    
    return {
      statusCode: 500,
      body: JSON.stringify({ 
        error: 'Internal server error' 
      })
    };
  }
};

// 数据库连接优化（复用连接）
let cachedDb = null;

async function connectToDatabase() {
  if (cachedDb) {
    return cachedDb;
  }
  
  const client = await MongoClient.connect(process.env.MONGODB_URI);
  cachedDb = client.db();
  
  return cachedDb;
}

我的Node.js学习路径建议

📚 从基础到进阶

根据我的经验，我建议这样的学习路径：

第一阶段：基础掌握（1-2个月）

✅ JavaScript ES6+特性
✅ Node.js核心模块（fs, path, http, events）
✅ npm和包管理
✅ 异步编程（Promise, async/await）

第二阶段：框架和工具（2-3个月）

✅ Express.js或Fastify
✅ 数据库操作（MongoDB/PostgreSQL）
✅ 身份认证和授权
✅ 测试框架（Jest/Mocha）

第三阶段：生产就绪（3-4个月）

✅ 错误处理和日志
✅ 性能优化
✅ 安全最佳实践
✅ 部署和监控

第四阶段：高级特性（持续学习）

✅ 微服务架构
✅ 实时通信（WebSocket）
✅ 缓存策略
✅ 容器化部署

🛠️ 推荐的学习项目

待办事项API - 学习CRUD操作
聊天应用 - 掌握WebSocket
博客系统 - 理解完整架构
电商后端 - 复杂业务逻辑
微服务拆分 - 架构设计能力

总结和展望

经过这几年的实践，我对Node.js有了深刻的理解。它不仅仅是一个JavaScript运行时，更是一个强大的生态系统。从快速原型开发到企业级应用，从传统后端服务到无服务器函数，Node.js都能胜任。

我最大的感悟：

学习曲线友好：对于前端开发者来说是最佳的后端入门选择
生态系统丰富：npm生态提供了几乎所有需要的工具
性能表现优秀：在I/O密集型应用中表现出色
社区活跃：问题解决速度快，新技术跟进及时
就业前景广阔：市场需求持续增长

未来的Node.js我认为会在这些方向发展：

🤖 AI原生支持：更好的机器学习库集成
⚡ 性能持续优化：V8引擎和运行时改进
🌐 Web标准对齐：与浏览器API保持一致
🔒 安全性增强：内置更多安全特性
☁️ 云原生优化：更好的容器和无服务器支持

对于正在学习或考虑学习Node.js的朋友，我的建议是：动手实践永远比理论学习更重要。选择一个感兴趣的项目，边做边学，遇到问题就解决问题，这样的学习方式最高效。

Node.js的世界很精彩，希望我的分享能对你的学习之路有所帮助！

参考资源

有问题欢迎在评论区讨论，我会尽力回答大家的疑问！