FastAPI 是一个现代、快速（高性能）的 Web 框架，用于构建 API，基于 Python 3.7+ 并使用了类型提示。虽然 FastAPI 和 ThinkPHP 的设计理念和语言不同，但 FastAPI 同样可以实现 ThinkPHP 的核心功能，如路由、模型、视图、中间件、JWT、Session 等。以下是如何用 FastAPI 实现这些功能的详细说明：

一、路由（Route）

FastAPI 实现：
FastAPI 使用装饰器定义路由，支持 HTTP 方法（GET、POST 等）和路径参数、查询参数。

from fastapi import FastAPI

app = FastAPI()

@app.get("/user/{user_id}")
async def read_user(user_id: int):
    return {"user_id": user_id}
 

对比 ThinkPHP：

• ThinkPHP：通过 Route::get() 定义路由。
• FastAPI：使用 @app.get() 装饰器定义路由。

二、中间件（Middleware）

FastAPI 实现：
FastAPI 支持全局中间件，用于在请求处理前后执行逻辑（如日志记录、权限校验）。

from fastapi import Request

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    response.headers["X-Custom-Header"] = "FastAPI"
    return response
 

对比 ThinkPHP：

• ThinkPHP：通过 middleware() 方法绑定中间件。
• FastAPI：使用 @app.middleware() 装饰器注册中间件。

三、控制器（Controller）

FastAPI 实现：
FastAPI 的路由函数相当于控制器方法，负责处理请求和返回响应。

@app.post("/user/")
async def create_user(user: User):
    return {"user": user}
 

对比 ThinkPHP：

• ThinkPHP：控制器类中的方法处理请求。
• FastAPI：路由函数直接处理请求。

四、模型（Model）

FastAPI 实现：
FastAPI 使用 Pydantic 模型定义数据结构，支持数据验证和文档生成。

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str

@app.post("/user/")
async def create_user(user: User):
    return user
 

对比 ThinkPHP：

• ThinkPHP：通过模型类封装数据库操作。
• FastAPI：使用 Pydantic 模型定义数据结构，数据库操作通常结合 ORM（如 SQLAlchemy）实现。

五、视图（View）

FastAPI 实现：
FastAPI 主要用于构建 API，但也可以返回 HTML 或模板渲染的视图（如 Jinja2）。

from fastapi.responses import HTMLResponse

@app.get("/", response_class=HTMLResponse)
async def read_root():
    return "<h1>Hello, FastAPI!</h1>"
 

对比 ThinkPHP：

• ThinkPHP：通过视图模板渲染 HTML。
• FastAPI：可以返回 HTML 或使用模板引擎（如 Jinja2）。

六、JWT（JSON Web Token）

FastAPI 实现：
FastAPI 支持 JWT 认证，通常结合 OAuth2PasswordBearer 和 PyJWT 实现。

from fastapi import Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer
import jwt

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def get_current_user(token: str = Depends(oauth2_scheme)):
    try:
        payload = jwt.decode(token, "SECRET_KEY", algorithms=["HS256"])
        return payload
    except jwt.PyJWTError:
        raise HTTPException(status_code=401, detail="Invalid token")

@app.get("/user/me")
async def read_user_me(current_user: dict = Depends(get_current_user)):
    return current_user
 

对比 ThinkPHP：

• ThinkPHP：通过 JWT 库生成和验证 Token。
• FastAPI：使用 PyJWT 和 OAuth2PasswordBearer 实现 JWT 认证。

七、Session 和 Cookie

FastAPI 实现：
FastAPI 支持 Session 和 Cookie 操作，通常通过 Request 和 Response 对象实现。

from fastapi import Request, Response

@app.post("/login/")
async def login(request: Request, response: Response):
    response.set_cookie(key="session_id", value="12345")
    return {"message": "Logged in"}

@app.get("/session/")
async def read_session(session_id: str = Cookie(None)):
    return {"session_id": session_id}
 

对比 ThinkPHP：

• ThinkPHP：通过 Session 和 Cookie 类操作。
• FastAPI：通过 Request 和 Response 对象操作。

八、数据库操作（ORM）

FastAPI 实现：
FastAPI 通常结合 SQLAlchemy 或 Tortoise ORM 实现数据库操作。

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, bind=engine)
Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String)

@app.post("/user/")
async def create_user(name: str):
    db = SessionLocal()
    user = User(name=name)
    db.add(user)
    db.commit()
    return user
 

对比 ThinkPHP：

• ThinkPHP：通过模型类封装数据库操作。
• FastAPI：结合 SQLAlchemy 或 Tortoise ORM 实现数据库操作。

九、模块化设计

FastAPI 实现：
FastAPI 支持 APIRouter 实现模块化设计，将路由分组管理。

from fastapi import APIRouter

router = APIRouter()

@router.get("/items/")
async def read_items():
    return [{"item": "Foo"}]

app.include_router(router, prefix="/api")
 

对比 ThinkPHP：

• ThinkPHP：通过多模块设计（如 admin、api 模块）。
• FastAPI：使用 APIRouter 实现模块化。

十、性能优化

FastAPI 实现：
FastAPI 天生高性能，支持异步编程，可结合缓存（如 Redis）和任务队列（如 Celery）进一步优化。

from fastapi import BackgroundTasks

def send_email(email: str):
    # 模拟发送邮件
    pass

@app.post("/send-email/")
async def send_email_background(background_tasks: BackgroundTasks, email: str):
    background_tasks.add_task(send_email, email)
    return {"message": "Email sent in background"}
 

对比 ThinkPHP：

• ThinkPHP：通过缓存中间件和任务队列优化性能。
• FastAPI：支持异步编程和任务队列。

总结

通过以上实现，FastAPI 可以完全覆盖 ThinkPHP 的核心功能，同时利用其异步编程和高性能特性，构建现代化的 Web 应用和 API。以下是功能对比表：

功能	ThinkPHP 实现方式	FastAPI 实现方式
路由	Route::get()	@app.get()
中间件	middleware()	@app.middleware()
控制器	控制器类方法	路由函数
模型	模型类 + ORM	Pydantic 模型 + SQLAlchemy
视图	视图模板	HTMLResponse 或 Jinja2
JWT	JWT 库	PyJWT + OAuth2PasswordBearer
Session/Cookie	Session 类	Request 和 Response 对象
数据库	模型类 + 查询构造器	SQLAlchemy 或 Tortoise ORM
模块化	多模块设计	APIRouter
性能优化	缓存中间件 + 任务队列	异步编程 + Celery

通过 FastAPI，开发者可以构建高性能、现代化的 Web 应用，同时享受 Python 生态的强大支持。

（ps.文章由DS辅助撰写）