Node.js+Express+Koa2+Nest.js 开发服务端

Node.js 服务端三剑客：Express、Koa2、Nest.js 对比与实战
一个老生常谈却又常谈常新的话题：Node.js 后端框架怎么选？本文从设计哲学、核心机制、代码实战到选型建议，帮你彻底理清 Express、Koa2、Nest.js 的差异。

一、前言：为什么是这三剑客
Node.js 生态里的服务端框架多如牛毛，但真正被广泛使用、形成稳定社区、长期维护的，绕不开这三个名字：

Express：2010 年诞生，Node.js 世界事实上的”标准库”，生态最庞大。

Koa2：2013 年由 Express 原班人马打造，用 async/await 重构中间件模型，”轻量”的极致。

Nest.js：2017 年出现，受 Angular 启发，把 TypeScript、依赖注入、模块化带入 Node 世界，主攻企业级。

它们不是简单的”新替代旧”关系，而是代表了三种截然不同的设计取向。理解这一点，比记住 API 更重要。

二、三者核心定位对比
维度 Express Koa2 Nest.js
诞生时间 2010 2013 2017
设计哲学 简约、中间件线性模型 极简内核、洋葱模型 架构优先、企业级
语言 JavaScript（可用 TS） JavaScript（可用 TS） TypeScript 原生
中间件模型 回调式 (req,res,next) async 洋葱模型 装饰器 + 管道/守卫/拦截器
内置功能 路由、静态资源等 几乎为零，全靠中间件 DI、模块、AOP、微服务
学习曲线 低 低 中高
适合场景 小工具、API 快速原型 轻量服务、需精细控制 中大型项目、团队协作
一句话概括：

Express = 给你一套好用的工具，剩下自己搭。

Koa2 = 只给你一根针，剩下全靠自己织。

Nest.js = 给你一套完整的建筑规范，照着盖楼。

三、核心机制剖析
3.1 Express：线性中间件
Express 的中间件是线性执行的，通过 next() 把控制权交给下一个中间件。

js
app.use((req, res, next) => {
console.log(‘middleware 1’);
next();
});
app.use((req, res, next) => {
console.log(‘middleware 2’);
next();
});
执行顺序是 1 → 2，没有”回流”。这带来一个经典问题：你很难在响应返回后优雅地做收尾工作（比如统一记录耗时）。

3.2 Koa2：洋葱模型
Koa2 借助 async/await，把中间件变成”洋葱”——请求先进后出：

js
app.use(async (ctx, next) => {
console.log(‘1 进入’);
await next();
console.log(‘1 退出’);
});
app.use(async (ctx, next) => {
console.log(‘2 进入’);
await next();
console.log(‘2 退出’);
});
输出：

text
1 进入
2 进入
2 退出
1 退出
这个模型对响应耗时统计、统一错误处理、日志埋点极其友好，是 Koa 最大的技术亮点。

3.3 Nest.js：分层架构 + AOP
Nest.js 把请求生命周期拆成多个可插拔的切面：

text
请求 → 中间件 → 守卫(Guard) → 拦截器(Interceptor)
→ 管道(Pipe) → 控制器(Controller) → 服务(Service)
→ 拦截器 → 异常过滤器(ExceptionFilter) → 响应
配合依赖注入（DI）和模块（Module），代码天然分层、可测试、可复用。这是它适合大型项目的根本原因。

四、实战：同一个接口，三种写法
需求：实现 GET /users/:id，返回用户信息，并记录请求耗时。

4.1 Express 实现
js
const express = require(‘express’);
const app = express();

// 耗时统计中间件
app.use((req, res, next) => {
const start = Date.now();
res.on(‘finish’, () => {
console.log(${req.method} ${req.url} - ${Date.now() - start}ms);
});
next();
});

app.get(‘/users/:id’, (req, res) => {
const { id } = req.params;
res.json({ id, name: User-${id} });
});

app.listen(3000, () => console.log(‘Express on 3000’));
注意：Express 里统计耗时必须监听 res.on(‘finish’)，因为中间件不会”回流”。

4.2 Koa2 实现
js
const Koa = require(‘koa’);
const Router = require(‘@koa/router’);

const app = new Koa();
const router = new Router();

// 耗时统计，利用洋葱模型
app.use(async (ctx, next) => {
const start = Date.now();
await next();
console.log(${ctx.method} ${ctx.url} - ${Date.now() - start}ms);
});

router.get(‘/users/:id’, (ctx) => {
const { id } = ctx.params;
ctx.body = { id, name: User-${id} };
});

app.use(router.routes()).use(router.allowedMethods());
app.listen(3000, () => console.log(‘Koa2 on 3000’));
await next() 之后的代码就是”回流”阶段，天然适合做收尾。

4.3 Nest.js 实现
ts
// users.controller.ts
import { Controller, Get, Param } from ‘@nestjs/common’;
import { UsersService } from ‘./users.service’;

@Controller(‘users’)
export class UsersController {
constructor(private readonly usersService: UsersService) {}

@Get(‘:id’)
findOne(@Param(‘id’) id: string) {
return this.usersService.findOne(id);
}
}
ts
// users.service.ts
import { Injectable } from ‘@nestjs/common’;

@Injectable()
export class UsersService {
findOne(id: string) {
return { id, name: User-${id} };
}
}
ts
// logging.interceptor.ts —— 耗时统计用拦截器实现
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from ‘@nestjs/common’;
import { Observable } from ‘rxjs’;
import { tap } from ‘rxjs/operators’;

@Injectable()
export class LoggingInterceptor implements NestInterceptor {
intercept(context: ExecutionContext, next: CallHandler): Observable {
const start = Date.now();
return next.handle().pipe(
tap(() => console.log(耗时: ${Date.now() - start}ms)),
);
}
}
ts
// main.ts
import { NestFactory } from ‘@nestjs/core’;
import { AppModule } from ‘./app.module’;
import { LoggingInterceptor } from ‘./logging.interceptor’;

async function bootstrap() {
const app = await NestFactory.create(AppModule);
app.useGlobalInterceptors(new LoggingInterceptor());
await app.listen(3000);
}
bootstrap();
同样的需求，Nest 用拦截器统一处理，职责清晰、可全局复用。

五、进阶对比：几个关键维度
5.1 错误处理
Express：靠 next(err) 传递，需要专门的错误中间件（4 个参数）。

js
app.use((err, req, res, next) => {
res.status(500).json({ error: err.message });
});
Koa2：try/catch + 全局监听 app.on(‘error’)。

js
app.use(async (ctx, next) => {
try {
await next();
} catch (err) {
ctx.status = err.status || 500;
ctx.body = { error: err.message };
}
});
Nest.js：内置异常过滤器，抛 HttpException 即可，自动格式化响应。

ts
throw new NotFoundException(‘用户不存在’);
5.2 TypeScript 支持
Express：类型定义靠 @types/express，写起来仍偏 JS 风格。

Koa2：同理，@types/koa 提供类型，但生态中间件类型参差。

Nest.js：TS 原生，装饰器 + 元数据 + DI 全链路类型安全。

5.3 生态与扩展
Express：npm 上中间件数量碾压级，任何需求几乎都有现成包。

Koa2：生态比 Express 小，但核心包质量高，组合自由。

Nest.js：官方体系完善（GraphQL、WebSocket、微服务、Swagger、CQRS），但很多要按它的”规矩”来。

六、性能真相
很多人以为 Koa 比 Express 快很多，其实在真实业务中差距微乎其微：

框架本身的中间件调度开销，相比数据库查询、网络 IO，可以忽略不计。

三者的性能瓶颈几乎都来自业务逻辑和外部依赖。

基准测试里 Koa 略快于 Express，Nest 因抽象层稍慢，但都在同一量级。

结论：不要用性能作为主要选型依据。

七、选型建议
选 Express，如果：
你要快速搭一个 API 原型或小工具。

团队 JS 背景为主，不想引入 TS 复杂度。

需要用到某个只有 Express 才有的中间件。

维护老项目。

选 Koa2，如果：
你追求极简，想自己掌控每一个中间件。

需要洋葱模型带来的精细控制（如统一耗时、事务包裹）。

项目规模中等，不想被框架”绑架”。

选 Nest.js，如果：
项目是中大型、多人协作、长期维护。

团队熟悉 TypeScript 和面向对象/AOP 思想。

需要微服务、GraphQL、CQRS 等企业级能力。

希望代码结构标准化，降低沟通成本。

一张决策图
text
项目规模小 & 快速上线 ──→ Express
需要精细中间件控制 ──→ Koa2
中大型 & 团队协作 ──→ Nest.js
八、总结
框架 一句话评价
Express 生态之王，简单直接，但架构要自己扛
Koa2 洋葱模型优雅，轻到极致，但也”什么都要自己写”
Nest.js 把工程化做到极致，学习成本高，但大型项目真香
三者并非替代关系，而是不同阶段的工具。很多团队的真实路径是：

用 Express 起步 → 业务复杂后转向 Koa2 精细化 → 团队壮大后迁移到 Nest.js 规范化。

没有最好的框架，只有最适合当前团队和业务阶段的框架。理解它们背后的设计哲学，比背 API 更有价值。

本作品采用《CC 协议》，转载必须注明作者和本文链接