Elysia vs Express vs Hapi vs Koa：性能、架构与开发体验深度对比

这四个框架都是 JavaScript 生态中构建 Web 服务的重要工具，但它们的底层逻辑和适用场景差异很大。express 是老牌标准，koa 是它的现代继承者，hapi 侧重企业配置，而 elysia 则是针对 Bun 运行时的高性能新秀。让我们从实际工程角度对比它们如何处理常见问题。

🚀 运行环境与启动：Bun 极速 vs Node 稳定

elysia 专为 Bun 运行时设计，利用 Bun 的原生 API 实现极速启动和低内存占用。

// elysia: 专为 Bun 优化
import { Elysia } from 'elysia';

new Elysia()
  .get('/', () => 'Hello Bun')
  .listen(3000);

express 运行在 Node.js 上，启动速度快，生态最成熟，兼容所有 Node 版本。

// express: 标准 Node.js 环境
import express from 'express';

const app = express();
app.get('/', (req, res) => res.send('Hello Node'));
app.listen(3000);

hapi 同样基于 Node.js，启动时需要进行较多的配置初始化，适合大型服务。

// hapi: 配置驱动的 Node 服务
import Hapi from '@hapi/hapi';

const init = async () => {
  const server = Hapi.server({ port: 3000 });
  await server.start();
};
init();

koa 基于 Node.js，轻量级，启动开销小，但需要手动组合中间件。

// koa: 轻量 Node 环境
import Koa from 'koa';

const app = new Koa();
app.use(ctx => {
  ctx.body = 'Hello Koa';
});
app.listen(3000);

🗺️ 路由与验证：内置智能 vs 手动组合

elysia 内置路由和基于 TypeBox 的验证，TypeScript 类型自动推断，无需额外库。

// elysia: 内置验证与类型推断
import { Elysia, t } from 'elysia';

new Elysia()
  .post('/user', ({ body }) => body, {
    body: t.Object({
      name: t.String(),
      age: t.Number()
    })
  })
  .listen(3000);

express 路由简单，但验证需要第三方中间件（如 Joi 或 express-validator）。

// express: 手动添加验证中间件
import express from 'express';
import { check } from 'express-validator';

const app = express();
app.post('/user', 
  check('name').isString(),
  (req, res) => res.send(req.body)
);
app.listen(3000);

hapi 路由配置详细，内置强大的 Joi 验证，适合复杂规则。

// hapi: 配置化路由与验证
import Hapi from '@hapi/hapi';
import Joi from 'joi';

const server = Hapi.server({ port: 3000 });
server.route({
  method: 'POST',
  path: '/user',
  options: {
    validate: {
      payload: Joi.object({ name: Joi.string() })
    }
  },
  handler: (request, h) => request.payload
});

koa 本身无路由，需配合 koa-router，验证也需额外中间件。

// koa: 组合式路由与验证
import Koa from 'koa';
import Router from '@koa/router';

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

router.post('/user', ctx => {
  ctx.body = ctx.request.body;
});

app.use(router.routes());
app.listen(3000);

🧩 中间件与上下文：请求响应对象 vs 统一上下文

elysia 使用统一的上下文对象，插件系统简单，类型安全。

// elysia: 插件与上下文
import { Elysia } from 'elysia';

const logger = new Elysia()
  .onRequest(({ set, request }) => {
    console.log(request.url);
  });

new Elysia()
  .use(logger)
  .get('/', () => 'Logged')
  .listen(3000);

express 使用 req 和 res 两个对象，中间件通过 next() 传递控制流。

// express: 经典 req/res 模式
import express from 'express';

const app = express();
app.use((req, res, next) => {
  console.log(req.url);
  next();
});
app.listen(3000);

hapi 使用 request 和 h (response toolkit) 对象，生命周期扩展点丰富。

// hapi: 生命周期扩展
import Hapi from '@hapi/hapi';

const server = Hapi.server({ port: 3000 });
server.ext('onRequest', (request, h) => {
  console.log(request.path);
  return h.continue;
});

koa 使用单一 ctx 对象，封装了 req 和 res，异步流程更清晰。

// koa: 统一 ctx 对象
import Koa from 'koa';

const app = new Koa();
app.use(async (ctx, next) => {
  console.log(ctx.url);
  await next();
});
app.listen(3000);

⚠️ 错误处理：集中式 vs 分散式

elysia 提供全局错误处理钩子，类型安全，易于统一响应格式。

// elysia: 全局错误钩子
import { Elysia, ValidationError } from 'elysia';

new Elysia()
  .onError(({ code, error }) => {
    if (code === 'VALIDATION') return error.all;
  })
  .listen(3000);

express 依赖专门的错误处理中间件（四个参数的函数）。

// express: 错误处理中间件
import express from 'express';

const app = express();
app.use((err, req, res, next) => {
  res.status(500).send(err.message);
});
app.listen(3000);

hapi 内置强大的错误策略配置，可全局捕获并格式化。

// hapi: 配置化错误策略
import Hapi from '@hapi/hapi';

const server = Hapi.server({ port: 3000 });
server.events.on('request', (request, event) => {
  if (event.error) console.error(event.error);
});

koa 使用 app.on('error') 监听，或在中间件 try/catch 处理。

// koa: 事件监听与 try/catch
import Koa from 'koa';

const app = new Koa();
app.use(async ctx => {
  try {
    throw new Error('Oops');
  } catch (err) {
    ctx.status = 500;
    ctx.body = err.message;
  }
});
app.listen(3000);

🤝 相似之处：核心共性

尽管实现方式不同，这四个框架都解决了 Web 服务的基本需求。

1. 🌐 基于 HTTP 协议

• 都处理请求、响应、头部和状态码。
• 支持 RESTful API 设计。

// 所有框架都支持设置状态码
// elysia: ({ set }) => { set.status = 201; }
// express: res.status(201)
// hapi: h.response().code(201)
// koa: ctx.status = 201

2. 🔌 中间件机制

• 都允许通过中间件扩展功能（日志、认证、解析）。
• 支持顺序执行请求处理逻辑。

// 所有框架都支持日志中间件
// 逻辑类似：记录 URL -> 调用下一步 -> 记录时间

3. 🛡️ 生态系统支持

• 都有社区贡献的插件库。
• 支持连接数据库、缓存等常见服务。

// 所有框架都可连接 Redis
// 使用各自的 HTTP 客户端或专用库

📊 总结：关键差异对比

💡 最终建议

express 是稳妥的选择 🛡️。如果你需要快速上手、寻找现成解决方案或维护旧项目，它的社区资源无人能及。

elysia 是未来的方向 🚀。如果你能接受 Bun 运行时，想要最快的速度和最好的 TypeScript 体验，它是新项目的最佳候选。

hapi 是企业的堡垒 🏢。适合需要严格规范、复杂配置和内置安全策略的大型团队。

koa 是极简主义者的工具 🎨。如果你想要 Express 的灵活但讨厌回调地狱，且愿意自己组装路由和验证，它很合适。

核心思考：不要只看流行度。如果你的团队熟悉 Node.js 且需要稳定，选 express 或 koa。如果你追求性能极限且愿意尝试新技术，选 elysia。如果项目受严格合规要求约束，选 hapi。