前言

   FastAPI 作为高性能的异步 Web 框架，凭借简洁的语法、自动的接口文档和优秀的性能，成为 Python Web 开发的热门选择。入门之后，想要开发企业级的 Web 应用，还需要掌握中间件、依赖注入和ORM三大核心进阶特性 —— 它们能帮我们实现代码复用、逻辑解耦，让数据库操作更优雅，大幅提升项目的可维护性和扩展性。

1. 中间件：统一处理所有请求的利器

1.1 中间件的核心应用场景

        中间件的设计初衷是为所有接口添加通用处理逻辑，无需在每个路由中重复编写。

典型场景包括：

• 全局用户身份认证、权限校验
• 接口请求 / 响应日志记录、性能监控
• 跨域请求处理（CORS）、统一设置响应头
• 全局异常捕获与处理

1.2 中间件的定义与基本使用

        定义中间件需使用@app.middleware("http")装饰器，函数为异步类型，接收request（请求对象）和call_next（调用下一个中间件 / 路由处理函数的方法）两个参数，最终返回响应对象。

from fastapi import FastAPI
 
app = FastAPI()
 
# 定义基础中间件
@app.middleware("http")
# async：异步处理，协程
async def global_middleware(request, call_next):
    # request：请求，cell_next：下一个中间件或路由处理函数
    # 请求到达路由前执行：start部分
    print(f"中间件开始处理：{request.method} {request.url}")
    # 传递请求到下一个中间件/路由
    response = await call_next(request)
    # 响应返回客户端前执行：end部分
    print(f"中间件处理完成：响应状态码 {response.status_code}")
    return response
 
@app.get("/")
async def root():
    return {"message": "Hello FastAPI"}

1.3 多个中间件的执行顺序

         FastAPI 中注册多个中间件时，start 部分按注册逆序执行，end 部分按注册顺序执行（自下而上执行 start，自上而下执行 end），可以理解为 “洋葱模型”—— 请求从外层穿透到内层路由，响应从内层穿透回外层客户端。

from  fastapi import FastAPI
 
app = FastAPI()
 
 
# 中间件2
@app.middleware("http")
async def middleware2(request, call_next):
    print("middleware2 start")  # 第一步执行：打印这行
    # 第二步执行：调用 call_next(request)
    # 此时 call_next 的作用是：把请求传递给下一个中间件（middleware1）
    response = await call_next(request)
    print("middleware2 end")  # 第六步执行：打印这行
    return response  # 第七步：返回最终的响应
 
# 中间件1
@app.middleware("http")
async def middleware1(request, call_next):
    print("middleware1 start")  # 第三步执行：打印这行
    # 第四步执行：调用 call_next(request)
    # 此时 call_next 的作用是：把请求传递给最终的路由处理函数（比如你的 / 接口）
    response = await call_next(request)
    print("middleware1 end")  # 第五步执行：打印这行
    return response  # 把路由返回的 response 传回 middleware2
 
# 访问这个根路由
@app.get("/")
async def root():
    print("路由函数执行")  # 第四步中间执行：打印这行
    return {"message": "Hello FastAPI"}  # 返回响应
 
# 访问/时，控制台输出顺序：
# middleware2 start  →  middleware1 start  →  路由函数执行  →  middleware1 end  →  middleware2 end

1.4 中间件的核心特点

• 全局生效：控制所有请求和响应，无需手动调用
• 异步执行：基于协程，不阻塞主线程，符合 FastAPI 的异步设计
• 责任单一：一个中间件实现一个通用逻辑，便于维护

2.依赖注入：抽离通用逻辑，实现代码复用

        如果说中间件是 “全局无差别处理”，那么依赖注入就是精细化的通用逻辑复用—— 可以自定义哪些路由使用通用逻辑，完美解决多个接口重复编写相同代码的问题（如分页参数、数据库连接、局部权限校验）。

2.1 依赖注入的核心概念

• 依赖项：可重用的组件（函数 / 类），负责提供某种功能或数据（如分页参数解析、数据库会话创建）
• 注入：FastAPI 自动调用依赖项，并将执行结果传递到路由处理函数中，无需手动调用
• 核心优势：代码复用、逻辑解耦、易于测试（可轻松替换模拟依赖，无需修改业务代码）

依赖注入的典型应用场景：

• 抽取多个路由的通用参数（如分页的skip/limit、排序参数）
• 共享数据库连接 / 会话管理（创建、使用、关闭）
• 局部接口的身份认证、权限检查（非全局）
• 从请求中提取和验证自定义参数（路径、查询、请求体）

2.2 依赖注入的实战使用

        以分页参数复用为例，这是开发中最常见的场景，多个接口都需要skip（跳过条数）和limit（返回条数）参数，通过依赖注入可一次性实现，多处调用。

步骤一：创建依赖项（通用逻辑函数）

from fastapi import Query
# 分页参数逻辑共用：新闻列表和用户列表
# 1.依赖项
# 定义分页参数依赖项
async def common_page_parameters(
    skip: int = Query(0, ge=0, description="跳过的记录数"),
    limit: int = Query(10, le=100, description="返回的记录数，最大100")
):
    return {"skip": skip, "limit": limit}

步骤 2：导入 Depends，在路由中声明依赖

from fastapi import FastAPI, Depends #2.导入Depends
 
app = FastAPI()
 
# 新闻列表接口：使用分页依赖
@app.get("/news/list")
async def get_news_list(commons = Depends(common_page_parameters)):
    # 直接使用依赖项返回的分页参数
    return {"message": "新闻列表", **commons}
 
# 用户列表接口：复用同一个分页依赖
@app.get("/users/list")
async def get_user_list(commons = Depends(common_page_parameters)):
    return {"message": "用户列表", **commons}

完整代码

from fastapi import FastAPI,Query,Depends
 
app = FastAPI()
 
# 定义分页参数依赖项
async def common_page_parameters(
    skip: int = Query(0, ge=0, description="跳过的记录数"),
    limit: int = Query(10, le=100, description="返回的记录数，最大100")
):
    return {"skip": skip, "limit": limit}
 
# 新闻列表接口：使用分页依赖
@app.get("/news/list")
async def get_news_list(commons = Depends(common_page_parameters)):
    # 直接使用依赖项返回的分页参数
    return {"message": "新闻列表", **commons}
 
# 用户列表接口：复用同一个分页依赖
@app.get("/users/list")
async def get_user_list(commons = Depends(common_page_parameters)):
    return {"message": "用户列表", **commons}

3.中间件与依赖注入的核心区别

很多开发者会混淆两者的使用场景，核心区别在于作用范围和灵活性：

简单来说：所有接口都需要的逻辑用中间件，部分接口需要的逻辑用依赖注入。