⚙️ 后端框架选型

01 为什么框架选型是第一个重大决策

02 2026 后端框架全景图

还有一个特殊维度：运行时本身。2026 年的 JS 运行时已经不止 Node.js：

03 FastAPI — Python SaaS 的默认选择

是什么

FastAPI 是基于 Starlette + Pydantic 构建的现代 Python Web 框架。核心理念：用 Python 类型注解定义一切——路由参数、请求体、响应模型、依赖注入——框架自动完成验证、序列化、文档生成。

核心机制

1. 类型即契约

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr
from typing import Optional

app = FastAPI(title="My SaaS API", version="1.0.0")

# 定义数据模型 → 自动验证 + 自动文档 + 自动序列化
class CreateUser(BaseModel):
    email: EmailStr                          # 自动邮箱格式验证
    name: str
    plan: Optional[str] = "free"            # 默认值
    metadata: Optional[dict] = None

class UserResponse(BaseModel):
    id: int
    email: str
    name: str
    plan: str
    created_at: str

@app.post("/users", response_model=UserResponse, status_code=201)
async def create_user(body: CreateUser, db: DB = Depends(get_db)):
    # body 已经被 Pydantic 验证过 — 不可能收到无效数据
    user = await db.users.create(**body.model_dump())
    return user
    # 响应自动按 UserResponse 序列化 — 多余字段被过滤

2. 依赖注入系统 (Depends)

from fastapi import Depends, HTTPException, Security
from fastapi.security import HTTPBearer

# 依赖链：认证 → 授权 → 业务
async def get_current_user(token: str = Security(HTTPBearer())):
    payload = verify_jwt(token.credentials)
    if not payload:
        raise HTTPException(401, "Invalid token")
    return await User.get(payload["sub"])

async def require_admin(user=Depends(get_current_user)):
    if user.role != "admin":
        raise HTTPException(403, "Admin required")
    return user

# 依赖自动注入，自动验证，自动文档显示锁图标
@app.delete("/users/{user_id}")
async def delete_user(user_id: int, admin=Depends(require_admin)):
    await User.delete(user_id)
    return {"deleted": True}

3. 自动 OpenAPI 文档

何时用 FastAPI

优劣对比

04 Express — Node.js 生态的基石

是什么

Express 是 Node.js 最经典的 Web 框架，定义了 app.get(path, handler) + 中间件栈的模式。几乎所有后续 Node 框架（Koa、Fastify、Hono）都从 Express 的理念出发，然后试图修复它的缺点。

核心机制

1. 中间件洋葱模型

const express = require('express');
const app = express();

// 中间件栈 — 请求依次穿过每一层
app.use(express.json());                    // 解析 body
app.use(cors());                           // CORS
app.use(rateLimit({ windowMs: 15*60*1000, max: 100 })); // 限流

// 认证中间件 — 可选挂载到特定路由
const auth = async (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) return res.status(401).json({ error: 'No token' });
  try {
    req.user = verifyJWT(token);
    next();      // 交给下一个中间件/路由
  } catch {
    res.status(401).json({ error: 'Invalid token' });
  }
};

// 路由 + 中间件组合
app.get('/users/:id', auth, async (req, res) => {
  const user = await User.findById(req.params.id);
  res.json(user);
});

// 错误处理中间件（4 参数）— 放在最后
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Internal error' });
});

2. Router 模块化

// routes/users.js — 独立路由模块
const router = express.Router();

router.get('/', async (req, res) => { /* 列表 */ });
router.post('/', async (req, res) => { /* 创建 */ });
router.get('/:id', async (req, res) => { /* 详情 */ });
router.put('/:id', auth, async (req, res) => { /* 更新 */ });
router.delete('/:id', auth, adminOnly, async (req, res) => { /* 删除 */ });

module.exports = router;

// app.js — 挂载
app.use('/api/users', require('./routes/users'));
app.use('/api/orders', require('./routes/orders'));

Express 的真实问题

05 Hono — Edge-First 的多运行时框架

是什么

Hono（日语"炎🔥"）是基于 Web Standard API 构建的轻量级 Web 框架。核心理念：同一份代码，跑在任何 JS 运行时上——Cloudflare Workers、Deno、Bun、AWS Lambda、Vercel Edge、Node.js。

如果说 Express 定义了 Node.js 的 Web 框架范式，Hono 定义了 Edge 时代的 Web 框架范式。

核心机制

1. Web Standard API

import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'

const app = new Hono()

// Zod 验证 — 端到端类型安全
const createUserSchema = z.object({
  email: z.string().email(),
  name: z.string().min(1),
  plan: z.enum(['free', 'pro', 'enterprise']).default('free')
})

app.post('/users', zValidator('json', createUserSchema), async (c) => {
  const body = c.req.valid('json')  // 自动推断类型！
  const user = await db.users.create(body)
  return c.json(user, 201)
})

// 中间件 — 和 Express 类似但更类型安全
app.use('/api/*', async (c, next) => {
  const start = Date.now()
  await next()
  c.header('X-Response-Time', `${Date.now() - start}ms`)
})

// 这份代码直接跑在 Cloudflare Workers / Deno / Bun / Node.js
export default app

2. 多运行时适配器

// 同一份 Hono 代码，不同入口文件适配不同运行时：

// src/index.ts — Cloudflare Workers
export default app  // wrangler 自动处理

// src/index.node.ts — Node.js
import { serve } from '@hono/node-server'
serve(app)

// src/index.bun.ts — Bun
export default { port: 3000, fetch: app.fetch }

// src/index.denots — Deno
import { Hono } from 'jsr:@hono/hono'

3. RPC — 前后端端到端类型

// server.ts
import { Hono } from 'hono'
const app = new Hono()
  .get('/users', (c) => c.json({ users: [] }))
  .post('/users', zValidator('json', schema), async (c) => {
    const body = c.req.valid('json')
    return c.json({ created: true })
  })

export type AppType = typeof app

// client.ts — 前端自动获得完整类型！
import { hc } from 'hono/client'
import type { AppType } from './server'

const client = hc<AppType>('http://localhost:3000')
const res = await client.users.$post({ json: { email: 'a@b.com' } })
// res 的类型是自动推断的！不需要手写 API client

何时用 Hono

06 Elysia — Bun 原生性能之王

是什么

Elysia 是专为 Bun 运行时设计的 Web 框架，利用 Bun 的原生 API 实现极致性能。它的类型系统（基于 Bun.Type）提供比 Zod 更快的运行时验证 + 编译期类型推断。

核心机制

1. 声明式 Schema + 端到端类型

import Elysia from 'elysia'

const app = new Elysia()
  .post('/users', ({ body }) => {
    // body 的类型自动从 schema 推断！
    return db.users.create(body)
  }, {
    body: t.Object({
      email: t.String({ format: 'email' }),
      name: t.String({ minLength: 1 }),
      plan: t.UnionEnum(['free', 'pro', 'enterprise'])
    }),
    response: t.Object({
      id: t.Number(),
      email: t.String(),
      created: t.Boolean()
    })
  })
  .listen(3000)

2. 插件系统 — 生命周期钩子

const app = new Elysia()
  .use(swagger())            // 自动 Swagger 文档
  .use(jwt({ secret: '...' }))
  .derive(({ headers }) => ({  // 类似 FastAPI Depends
    user: verifyToken(headers.authorization)
  }))
  .onBeforeHandle(({ user }) => {  // 全局守卫
    if (!user) throw new UnauthorizedError()
  })
  .onAfterHandle(({ response }) => { // 全局响应处理
    return { data: response, timestamp: Date.now() }
  })
  .onError(({ code, error }) => {    // 统一错误处理
    return new Response(JSON.stringify({ error: error.message }), {
      status: code
    })
  })

何时用 Elysia

07 Fresh — Deno 全栈 SSR 方案

是什么

Fresh 是 Deno 官方维护的全栈 Web 框架，采用岛架构（Islands Architecture）：默认所有内容在服务端渲染（零 JS 发送到客户端），只有标记为"岛"的交互组件才在客户端水合。

核心机制

1. 岛架构 — 按需水合

// routes/index.tsx — 整个页面默认零客户端 JS
export default function Home() {
  return (
    <main>
      <h1>欢迎来到我的 SaaS</h1>
      <p>这段内容是纯 HTML，零 JS</p>

      {/* 只有这个计数器会水合 — 它是一个"岛" */}
      <IslandCounter start={0} />

      <p>这里也是纯 HTML</p>
    </main>
  )
}

// islands/IslandCounter.tsx — 只有 islands/ 目录下的组件才在客户端运行
import { useState } from 'preact/hooks'

export default function IslandCounter({ start }: { start: number }) {
  const [count, setCount] = useState(start)
  return <button onClick={() => setCount(count + 1)}>Count: {count}</button>
}

2. 路由即文件系统

routes/
├── index.tsx          # /
├── about.tsx          # /about
├── users/
│   ├── index.tsx      # /users
│   └── [id].tsx       # /users/:id — 动态路由
├── api/
│   └── webhooks.ts    # /api/webhooks — API 路由
islands/
├── Counter.tsx        # 交互岛组件
└── SearchBar.tsx      # 交互岛组件

何时用 Fresh

08 NestJS — 企业级 TypeScript 框架

是什么

NestJS 是基于 Express/Fastify（可切换底层）的 Node.js 企业级框架，采用 Angular 风格的装饰器 + 依赖注入 + 模块化架构。它是"大团队做复杂业务"的默认选择。

核心机制

1. 装饰器驱动的一切

// user.controller.ts
import { Controller, Get, Post, Body, Param, UseGuards } from '@nestjs/common'

@Controller('users')
@UseGuards(JwtAuthGuard)
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get()
  findAll() { return this.userService.findAll() }

  @Get(':id')
  findOne(@Param('id') id: string) { return this.userService.findOne(+id) }

  @Post()
  create(@Body() dto: CreateUserDto) { return this.userService.create(dto) }
}

// user.service.ts — 业务逻辑
@Injectable()
export class UserService {
  constructor(@InjectRepository(User) private repo: Repository<User>) {}
  findAll() { return this.repo.find() }
  findOne(id: number) { return this.repo.findOneBy({ id }) }
  create(dto: CreateUserDto) { return this.repo.save(dto) }
}

// user.module.ts — 模块绑定
@Module({
  controllers: [UserController],
  providers: [UserService],
  imports: [TypeOrmModule.forFeature([User])],
})
export class UserModule {}

NestJS 的双面性

09 全面对比：6 框架横评

性能基准参考（hello-world 场景）

10 决策树：你该选哪个？

11 实战：同一 API 的 4 种实现

实现一个 POST /users 端点：邮箱验证 + 密码哈希 + 返回用户。对比 4 个框架的代码量和风格。

FastAPI 实现

from fastapi import FastAPI, Depends, HTTPException
from pydantic import BaseModel, EmailStr
import bcrypt

app = FastAPI()

class CreateUser(BaseModel):
    email: EmailStr
    password: str
    name: str

class UserOut(BaseModel):
    id: int
    email: str
    name: str

@app.post("/users", response_model=UserOut, status_code=201)
async def create_user(body: CreateUser, db=Depends(get_db)):
    if await db.users.find_one({"email": body.email}):
        raise HTTPException(409, "Email exists")
    hashed = bcrypt.hashpw(body.password.encode(), bcrypt.gensalt())
    user = await db.users.insert_one({
        "email": body.email, "name": body.name,
        "password_hash": hashed.decode()
    })
    return {"id": str(user.inserted_id), "email": body.email, "name": body.name}

Hono 实现

import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'
import { hash } from 'bcryptjs'

const app = new Hono()

const schema = z.object({
  email: z.string().email(),
  password: z.string().min(8),
  name: z.string().min(1)
})

app.post('/users', zValidator('json', schema), async (c) => {
  const { email, password, name } = c.req.valid('json')
  const existing = await db.user.findUnique({ where: { email } })
  if (existing) return c.json({ error: 'Email exists' }, 409)
  const user = await db.user.create({
    data: { email, name, passwordHash: await hash(password, 12) }
  })
  return c.json({ id: user.id, email: user.email, name: user.name }, 201)
})

Elysia 实现

import Elysia from 'elysia'
import { hash, compare } from 'bcryptjs'

const app = new Elysia()
  .post('/users', async ({ body }) => {
    const existing = await db.user.findUnique({ where: { email: body.email } })
    if (existing) throw new Error('Email exists')
    const user = await db.user.create({
      data: { email: body.email, name: body.name, passwordHash: await hash(body.password, 12) }
    })
    return { id: user.id, email: user.email, name: user.name }
  }, {
    body: t.Object({
      email: t.String({ format: 'email' }),
      password: t.String({ minLength: 8 }),
      name: t.String({ minLength: 1 })
    })
  })

Express 实现（对比参照）

const express = require('express');
const bcrypt = require('bcryptjs');
const { body, validationResult } = require('express-validator');
const app = express();
app.use(express.json());

app.post('/users',
  body('email').isEmail(),
  body('password').isLength({ min: 8 }),
  body('name').notEmpty(),
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) return res.status(400).json({ errors: errors.array() });
    const { email, password, name } = req.body;
    const existing = await db.user.findUnique({ where: { email } });
    if (existing) return res.status(409).json({ error: 'Email exists' });
    const user = await db.user.create({
      data: { email, name, passwordHash: await bcrypt.hash(password, 12) }
    });
    res.status(201).json({ id: user.id, email, name });
  }
);

12 迁移策略与渐进式替换

现实中，大多数 SaaS 不是从零开始，而是从某个已有框架迁移。以下是安全迁移路线：

Express → Hono/Fastify

// 方案 1：API Gateway 分流
// 新 API 走 Hono 服务（port 3001），旧 API 留 Express（port 3000）
// Nginx/Traefik 按路径前缀路由

// 方案 2：Express 内嵌 Hono
import { handle } from 'hono/node-server'
app.use('/api/v2/*', handle(honoApp))  // 新版 API 走 Hono
// 旧路由继续走 Express

Express → NestJS

// 在 NestJS 模块中引入 Express 中间件
@Module({ ... })
export class LegacyModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(legacyExpressMiddleware).forRoutes('*')
  }
}

任何框架 → FastAPI

# 主服务 (Hono/Express) → AI 微服务 (FastAPI)
# 通过内部 HTTP 调用连接

# FastAPI AI 服务
@app.post("/analyze")
async def analyze(text: str):
    result = await model.predict(text)
    return {"sentiment": result}

// Hono 主服务调用 AI 微服务
app.post('/api/analyze', async (c) => {
  const res = await fetch('http://ai-service:8000/analyze', {
    method: 'POST',
    body: JSON.stringify({ text: c.req.valid('json').text })
  })
  return c.json(await res.json())
})

13 从 Agent 研究看框架选择

在我们的 Agent 架构研究 中，20 个 Agent 项目选择了不同的后端技术栈，这些选择反映了框架的适用场景：

延伸阅读