企业官网建设流程全解析

这是一个 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.users[uid] = {"id": uid, "name": name}

return self.users[uid]

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 和端口号。

文章仅供参考用。