这是一个 Python 后端示例，用标准库搭起了一个微型服务端，清晰展示了后端从请求到响应的完整链路。
```python
"""
一个最小但完整的后端：只用 Python 标准库，直接 `python backend.py` 就能跑。
它概括了后端的全部核心原理：
请求 → 中间件 → 路由 → 业务逻辑 → 数据层 → 响应
真实项目里，这些角色分别由 Nginx / 框架 / ORM / Redis 等扮演，
但骨架和下面这 100 行是一样的。
"""
import json
import re
from http.server import BaseHTTPRequestHandler, HTTPServer
---------- 1. 数据层：假装这是 MySQL / Redis ----------
class FakeDB:
def init(self):
self.users = {1: {"id": 1, "name": "alice"}}
self._next_id = 2
def all(self):
return list(self.users.values())
def get(self, uid):
return self.users.get(uid)
def create(self, name):
uid = self._next_id
self._next_id += 1
self.usersuid = {"id": uid, "name": name}
return self.usersuid
db = FakeDB()
---------- 2. 路由表：URL 模式 → 处理函数 ----------
ROUTES = \[\]
def route(method, pattern):
"""注册路由。正则的捕获组会自动作为参数传给处理函数。"""
def deco(fn):
ROUTES.append((method, re.compile(f"^{pattern}$"), fn))
return fn
return deco
---------- 3. 中间件：横切关注点（日志 / 鉴权 / CORS） ----------
MIDDLEWARES = \[\]
def middleware(fn):
MIDDLEWARES.append(fn)
return fn
@middleware
def log_middleware(req):
print(f"LOG {req'method'} {req'path'}")
return None # 返回 None = 放行
@middleware
def auth_middleware(req):
if req"path".startswith("/admin") and req"headers".get("token") != "secret":
return 401, {"error": "unauthorized"} # 短路，直接返回响应
return None
---------- 4. 业务逻辑：每个函数就是一个 API ----------
@route("GET", r"/users")
def list_users(req):
return 200, db.all()
@route("POST", r"/users")
def create_user(req):
name = req"body".get("name")
if not name:
return 400, {"error": "name is required"}
return 201, db.create(name)
@route("GET", r"/users/(\d+)")
def get_user(req, uid):
user = db.get(int(uid))
return (200, user) if user else (404, {"error": "not found"})
@route("GET", r"/admin/stats")
def admin_stats(req):
return 200, {"user_count": len(db.users)}
---------- 5. HTTP 层：解析请求 / 分发 / 写响应 ----------
class Handler(BaseHTTPRequestHandler):
def _handle(self, method):
(a) 读原始报文
length = int(self.headers.get("Content-Length") or 0)
raw = self.rfile.read(length) if length else b""
try:
body = json.loads(raw) if raw else {}
except json.JSONDecodeError:
body = {}
(b) 统一成内部请求对象，屏蔽协议细节
req = {
"method": method,
"path": self.path.split("?")0,
"headers": {k.lower(): v for k, v in self.headers.items()},
"body": body,
}
(c) 分发
status, payload = self.dispatch(req)
(d) 写响应
data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(data)))
self.end_headers()
self.wfile.write(data)
def dispatch(self, req):
中间件链，任意一个短路就结束
for mw in MIDDLEWARES:
short_circuit = mw(req)
if short_circuit:
return short_circuit
路由匹配 → 业务逻辑
for method, pattern, fn in ROUTES:
if method != req"method":
continue
match = pattern.match(req"path")
if match:
try:
return fn(req, *match.groups())
except Exception as e: # 兜底异常处理
return 500, {"error": str(e)}
return 404, {"error": "no route"}
def do_GET(self):
self._handle("GET")
def do_POST(self):
self._handle("POST")
def log_message(self, *args):
pass # 关掉默认日志，用我们自己的中间件
if name == "main":
print("listening on http://127.0.0.1:8000")
HTTPServer(("127.0.0.1", 8000), Handler).serve_forever()
```
后端核心流程：请求、处理与响应
这份代码把后端工作拆成了五个环环相扣的步骤，用最短路径跑通了一次完整请求。
· 数据层：FakeDB 用内存字典模拟数据库，提供 all、get、create 三个原子操作，屏蔽了底层存储细节。
· 路由表：通过 @route 装饰器把 URL 模式和处理函数绑定，正则捕获组会自动作为参数传给处理函数。
· 中间件：@middleware 装饰器注册的横切逻辑会在路由前依次执行。日志中间件只做记录，鉴权中间件在 /admin 路径上检查 token，不通过就立刻短路返回 401。
· 业务逻辑：每个处理函数对应一个 API 端点，负责校验参数、操作数据并返回统一的 (状态码, 响应体) 元组。
· HTTP 层：Handler 负责读取原始请求、组装内部请求对象、按序调用中间件和路由，最后把响应序列化为 JSON 写出，同时兜底 404 和 500 错误。
优化建议： 如需调整服务端口或监听地址，可以修改文件底部 HTTPServer(("127.0.0.1", 8000), Handler).serve_forever() 中的 IP 和端口号。
文章仅供参考用。