代码解读：

• 路径参数{user_id}会从URL中提取，user_id: int会自动进行类型转换和校验——传入非数字会返回422错误

• 查询参数从?skip=0&limit=10中提取，有默认值的参数是可选的

• 类型注解让IDE能提供自动补全，也让框架能自动校验

访问示例：

• GET /users/123 → {"user_id": 123, "name": "User_123"}

• GET /items?skip=5&limit=20&category=books

4.2 请求体与Pydantic模型

这是FastAPI最核心的能力之一——用Pydantic模型定义请求和响应的数据结构。

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


app = FastAPI()


# 定义请求体模型
class UserCreate(BaseModel):
    username: str = Field(..., min_length=3, max_length=20, description="用户名")
    email: EmailStr = Field(..., description="邮箱地址")
    password: str = Field(..., min_length=8, description="密码")
    age: Optional[int] = Field(None, ge=0, le=150, description="年龄")
    tags: list[str] = []


# 定义响应体模型
class UserResponse(BaseModel):
    id: int
    username: str
    email: str
    age: Optional[int]
    created_at: datetime


@app.post("/users", response_model=UserResponse)
async def create_user(user: UserCreate):
    # 业务逻辑：创建用户
    return UserResponse(
        id=1,
        username=user.username,
        email=user.email,
        age=user.age,
        created_at=datetime.now()
    )

from fastapi import FastAPI, Depends, Header, HTTPException


app = FastAPI()


# 定义一个依赖：验证Token
async def verify_token(authorization: str = Header(...)):
    """从请求头中提取并验证Token"""
    if not authorization.startswith("Bearer "):
        raise HTTPException(status_code=401, detail="无效的认证格式")
    token = authorization.replace("Bearer ", "")
    if token != "valid-token":
        raise HTTPException(status_code=401, detail="无效的Token")
    return {"user_id": 1, "username": "admin"}


# 使用依赖
@app.get("/protected")
async def protected_route(user: dict = Depends(verify_token)):
    return {"message": f"欢迎, {user['username']}!", "user": user}

import asyncio
from fastapi import FastAPI


app = FastAPI()


# 同步函数（适用于CPU密集型操作）
@app.get("/sync")
def sync_endpoint():
    # 同步操作，会阻塞线程
    return {"result": "done"}


# 异步函数（适用于I/O密集型操作）
@app.get("/async")
async def async_endpoint():
    # 模拟I/O操作：数据库查询、外部API调用等
    await asyncio.sleep(1)
    # 在等待期间，事件循环可以处理其他请求
    return {"result": "done after 1 second"}


# 混合使用：在异步函数中调用同步代码
@app.get("/mixed")
async def mixed_endpoint():
    # 使用 run_in_executor 将同步代码放到线程池执行
    result = await asyncio.to_thread(sync_heavy_work)
    return {"result": result}


def sync_heavy_work():
    # CPU密集型操作
    return sum(range(1000000))

from fastapi import FastAPI, Depends
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
from sqlalchemy.orm import declarative_base, Mapped, mapped_column
from sqlalchemy import select


# 数据库配置
DATABASE_URL = "postgresql+asyncpg://user:password@localhost/db"
engine = create_async_engine(DATABASE_URL, echo=True)
AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False)


Base = declarative_base()


# 定义模型
class User(Base):
    __tablename__ = "users"
    id: Mapped[int] = mapped_column(primary_key=True)
    username: Mapped[str] = mapped_column(unique=True)
    email: Mapped[str]


# 依赖：获取数据库会话
async def get_db():
    async with AsyncSessionLocal() as session:
        yield session


app = FastAPI()


@app.get("/users")
async def get_users(db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(User))
    users = result.scalars().all()
    return [{"id": u.id, "username": u.username, "email": u.email} for u in users]

启动服务后访问/docs，你会看到一份完整的、可交互的API文档——参数说明、请求示例、响应示例全部自动生成。

前后端联调时，后端把服务地址发给前端，前端打开/docs就能看到所有接口的详细信息，还能在线测试。

这种体验，用过一次就再也回不去了。

九、优缺点

优点

1. 极高的开发效率：通过Python类型注解自动生成API文档，无需手动编写Swagger配置。定义一个用户注册接口，代码量较传统框架缩短60%。在真实项目中，开发周期可以从6周缩短至2周。

2. 卓越的性能：基于ASGI异步架构，在TechEmpower基准测试中JSON序列化性能达到Django的8倍，接近Go语言框架Gin的水平。

3. 自动文档生成：写代码的同时文档自动生成，前后端联调效率大幅提升。

4. 类型安全：通过Pydantic模型在运行时自动检查数据类型，错误响应会准确指出哪个字段失败及原因。

5. 原生异步支持：天然支持async/await，非常适合I/O密集型工作负载（API调用、数据库查询、文件操作）。

6. 依赖注入系统：非常灵活，支持权限校验、Token校验、DB会话管理等。

7. 生产级特性：内置CORS、GZip、HTTPS重定向等中间件，支持WebSocket实时通信。

缺点

1. 生态不如Django完善：ORM、Admin等功能不如Django完整。

2. Pydantic学习成本：初学者需要适应Model模式。

3. 高度依赖类型提示：代码量相比Flask会多一些。

4. 部分组件需自行封装：如全局异常、中间件体系等。

5. 社区相对较新：虽然增长迅速，但相比Django和Flask，在某些特定场景下可能缺乏足够的支持和资源。

6. CPU密集型场景不如Java：在CPU密集型场景下，Spring Boot（Java）凭借JIT优化和线程池优势，性能更稳定。

十、一张图看懂适用场景

最佳使用场景

AI模型部署：机器学习模型要对外提供服务，FastAPI的高并发+自动文档两个特性完美契合。某AI公司使用FastAPI部署模型预测服务，开发周期大幅缩短。

微服务架构：某电商平台使用FastAPI重构订单服务后，开发周期从6周缩短至2周，错误率下降72%，支持每秒2000+的并发请求。

数据处理API：需要对外提供数据查询、统计、导出等接口的场景。

实时应用：WebSocket聊天、实时监控等需要双向通信的场景。

快速原型：需要快速验证想法、展示Demo的场景。

不太适合的场景

大型企业级全栈应用：如果需要强大的Admin后台、完善的ORM、内置的用户认证系统，Django可能更合适。

CPU密集型计算：复杂算法、大数据处理等场景，Java（Spring Boot）凭借JIT优化性能更稳定。

已有Java技术栈的团队：如果团队全是Java开发者，引入Python需要额外的学习成本和运维成本。

十一、和Spring Boot的真实对比

一位开发者做了一个真实的实验：同一个业务服务，用FastAPI和Spring Boot各写一遍，同时上线跑六个月。

开发阶段：FastAPI只用了两天就把服务跑起来了，而Spring Boot那边还在跟Maven依赖作斗争。几行代码就搞定了自动参数校验、自动生成文档。

压测阶段（1000并发用户） ：

• FastAPI：响应时间50分位45ms，吞吐量2400次/秒，内存占用180MB

• Spring Boot：响应时间50分位80ms，吞吐量1800次/秒

FastAPI在开发速度和首轮性能上全面领先。

但最终结果是写Java的同事赢了——不是因为性能，而是因为运维体系、监控告警、日志聚合、错误追踪这些“非功能需求” ，Spring Boot的生态更成熟。

这个实验告诉我们：技术选型不能只看开发速度和性能，还要看整个团队的技术栈、运维体系和长期维护成本。

更多项目实战在我的技术网站：susan.net.cn/project

十二、写在最后

FastAPI不是一个要“取代”Spring Boot的框架，而是一个在特定场景下能让你事半功倍的工具。

如果你是Java开发者，遇到以下情况时，可以考虑把FastAPI加入你的技术工具箱：

• 需要快速部署一个AI模型推理服务

• 需要搭建一个高性能的数据API

• 需要快速验证一个产品原型

• 团队中已经有Python能力

如果你是完全的Python新手，FastAPI可能是最好的入门框架之一——语法简洁、文档优秀、社区活跃，而且能让你快速看到成果。

技术选型没有银弹。

FastAPI在API开发、微服务、AI部署等场景下表现惊艳，但在大型企业级全栈应用、CPU密集型计算等场景下，Spring Boot依然是更稳妥的选择。

我的建议是：花一个周末把FastAPI跑一遍，写一个完整的CRUD服务。感受一下“写代码=写文档”的体验，体会一下“类型注解自动校验”的便利。然后根据你的实际项目需求，决定是否引入生产环境。

毕竟，多一个趁手的工具，就多一条解决问题的路。

开源地址：

• FastAPI：github.com/tiangolo/fa… （80K+ Star）

• 官方文档：fastapi.tiangolo.com