Python接口开发从入门到精通：完整实战指南

最新推荐文章于 2026-04-08 23:10:09 发布

原创最新推荐文章于 2026-04-08 23:10:09 发布 · 1.6k 阅读

16 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#python #开发语言

python 专栏收录该内容

44 篇文章

订阅专栏

在这里插入图片描述

文章目录

一、为什么选择Python开发接口？

Python凭借其简洁的语法、丰富的生态和强大的框架支持，已经成为开发RESTful API的首选语言之一。无论你是构建微服务、移动端后端，还是Web应用，Python都能让你快速高效地完成任务。

二、接口开发核心概念

2.1 什么是RESTful API？

REST：表现层状态转移
API：应用程序编程接口
HTTP方法：GET（获取）、POST（创建）、PUT（更新）、DELETE（删除）

2.2 接口开发流程图

三、环境搭建

3.1 创建虚拟环境

# Windows
python -m venv api_env
api_env\Scripts\activate

# Mac/Linux
python3 -m venv api_env
source api_env/bin/activate

3.2 安装必要依赖

pip install fastapi uvicorn sqlalchemy pymysql python-dotenv
pip install pydantic redis celery pytest httpx

四、使用FastAPI开发接口（推荐）

4.1 基础入门示例

# main.py
from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel, Field
from typing import Optional, List
from datetime import datetime

# 创建FastAPI应用实例
app = FastAPI(
    title="用户管理API",
    description="这是一个完整的用户管理接口文档",
    version="1.0.0",
    docs_url="/docs",  # Swagger文档路径
    redoc_url="/redoc"  # ReDoc文档路径
)

# 定义请求体模型
class UserCreate(BaseModel):
    username: str = Field(..., min_length=3, max_length=50, description="用户名")
    email: str = Field(..., description="电子邮箱")
    age: int = Field(ge=0, le=150, description="年龄")
    password: str = Field(..., min_length=6, description="密码")
    
    class Config:
        schema_extra = {
            "example": {
                "username": "zhangsan",
                "email": "zhangsan@example.com",
                "age": 25,
                "password": "123456"
            }
        }

class UserResponse(BaseModel):
    id: int
    username: str
    email: str
    age: int
    created_at: datetime

# 模拟数据库
fake_db = []
user_id_counter = 1

# GET请求 - 获取所有用户
@app.get("/users", response_model=List[UserResponse], status_code=status.HTTP_200_OK)
async def get_all_users(skip: int = 0, limit: int = 10):
    """
    获取用户列表
    
    - **skip**: 跳过的记录数
    - **limit**: 返回的最大记录数
    """
    return fake_db[skip: skip + limit]

# GET请求 - 获取单个用户
@app.get("/users/{user_id}", response_model=UserResponse)
async def get_user(user_id: int):
    """
    根据ID获取用户信息
    """
    for user in fake_db:
        if user["id"] == user_id:
            return user
    raise HTTPException(
        status_code=status.HTTP_404_NOT_FOUND,
        detail=f"用户ID {user_id} 不存在"
    )

# POST请求 - 创建用户
@app.post("/users", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
async def create_user(user: UserCreate):
    """
    创建新用户
    """
    global user_id_counter
    
    # 检查用户名是否已存在
    for existing_user in fake_db:
        if existing_user["username"] == user.username:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
                detail="用户名已存在"
            )
    
    new_user = {
        "id": user_id_counter,
        "username": user.username,
        "email": user.email,
        "age": user.age,
        "created_at": datetime.now()
    }
    fake_db.append(new_user)
    user_id_counter += 1
    return new_user

# PUT请求 - 更新用户
@app.put("/users/{user_id}", response_model=UserResponse)
async def update_user(user_id: int, user: UserCreate):
    """
    完整更新用户信息
    """
    for index, existing_user in enumerate(fake_db):
        if existing_user["id"] == user_id:
            updated_user = {
                "id": user_id,
                "username": user.username,
                "email": user.email,
                "age": user.age,
                "created_at": existing_user["created_at"]
            }
            fake_db[index] = updated_user
            return updated_user
    
    raise HTTPException(status_code=404, detail="用户不存在")

# DELETE请求 - 删除用户
@app.delete("/users/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
async def delete_user(user_id: int):
    """
    删除用户
    """
    for index, user in enumerate(fake_db):
        if user["id"] == user_id:
            fake_db.pop(index)
            return
    
    raise HTTPException(status_code=404, detail="用户不存在")

4.2 运行服务器

# 开发模式运行
uvicorn main:app --reload --host 0.0.0.0 --port 8000

# 生产模式运行
uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

五、数据库集成实战

5.1 数据库配置

# database.py
from sqlalchemy import create_engine, Column, Integer, String, DateTime, Boolean
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session
from datetime import datetime
import os
from dotenv import load_dotenv

load_dotenv()

# 数据库连接配置
DATABASE_URL = os.getenv(
    "DATABASE_URL", 
    "mysql+pymysql://root:password@localhost:3306/api_db?charset=utf8mb4"
)

# 创建数据库引擎
engine = create_engine(
    DATABASE_URL,
    pool_size=10,           # 连接池大小
    max_overflow=20,        # 最大溢出连接数
    pool_pre_ping=True,     # 连接前检测
    echo=False              # 是否打印SQL语句
)

# 创建会话工厂
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# 创建基类
Base = declarative_base()

# 依赖注入：获取数据库会话
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

5.2 定义数据模型

# models.py
from sqlalchemy import Column, Integer, String, DateTime, Boolean, Text
from database import Base
from datetime import datetime

class User(Base):
    __tablename__ = "users"
    
    id = Column(Integer, primary_key=True, index=True)
    username = Column(String(50), unique=True, index=True, nullable=False)
    email = Column(String(100), unique=True, index=True, nullable=False)
    hashed_password = Column(String(255), nullable=False)
    full_name = Column(String(100))
    age = Column(Integer)
    is_active = Column(Boolean, default=True)
    created_at = Column(DateTime, default=datetime.now)
    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)

class Article(Base):
    __tablename__ = "articles"
    
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(200), nullable=False)
    content = Column(Text)
    author_id = Column(Integer, index=True)
    view_count = Column(Integer, default=0)
    created_at = Column(DateTime, default=datetime.now)

5.3 创建表结构

# init_db.py
from database import engine
import models

def init_database():
    # 创建所有表
    models.Base.metadata.create_all(bind=engine)
    print("数据库表创建成功！")

if __name__ == "__main__":
    init_database()

5.4 完整的CRUD接口

# crud_api.py
from fastapi import FastAPI, Depends, HTTPException, Query, status
from sqlalchemy.orm import Session
from sqlalchemy import or_, and_
from pydantic import BaseModel, Field
from typing import Optional, List
from datetime import datetime
import hashlib

from database import get_db, engine
import models

# 创建表
models.Base.metadata.create_all(bind=engine)

app = FastAPI()

# Pydantic模型
class UserCreate(BaseModel):
    username: str = Field(..., min_length=3, max_length=50)
    email: str
    password: str = Field(..., min_length=6)
    full_name: Optional[str] = None
    age: Optional[int] = Field(None, ge=0, le=150)

class UserUpdate(BaseModel):
    username: Optional[str] = Field(None, min_length=3, max_length=50)
    email: Optional[str] = None
    full_name: Optional[str] = None
    age: Optional[int] = Field(None, ge=0, le=150)

class UserResponse(BaseModel):
    id: int
    username: str
    email: str
    full_name: Optional[str]
    age: Optional[int]
    is_active: bool
    created_at: datetime
    
    class Config:
        orm_mode = True

class ArticleCreate(BaseModel):
    title: str = Field(..., min_length=1, max_length=200)
    content: str

class ArticleResponse(BaseModel):
    id: int
    title: str
    content: str
    author_id: int
    view_count: int
    created_at: datetime
    
    class Config:
        orm_mode = True

# 辅助函数
def hash_password(password: str) -> str:
    """密码加密"""
    return hashlib.sha256(password.encode()).hexdigest()

# 用户接口
@app.post("/api/users", response_model=UserResponse, status_code=201)
async def create_user(user: UserCreate, db: Session = Depends(get_db)):
    """创建用户"""
    # 检查用户名是否已存在
    existing_user = db.query(models.User).filter(
        or_(
            models.User.username == user.username,
            models.User.email == user.email
        )
    ).first()
    
    if existing_user:
        raise HTTPException(
            status_code=400,
            detail="用户名或邮箱已存在"
        )
    
    # 创建新用户
    db_user = models.User(
        username=user.username,
        email=user.email,
        hashed_password=hash_password(user.password),
        full_name=user.full_name,
        age=user.age
    )
    
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

@app.get("/api/users", response_model=List[UserResponse])
async def get_users(
    skip: int = Query(0, ge=0),
    limit: int = Query(20, ge=1, le=100),
    search: Optional[str] = None,
    is_active: Optional[bool] = None,
    db: Session = Depends(get_db)
):
    """获取用户列表（支持搜索和筛选）"""
    query = db.query(models.User)
    
    # 搜索条件
    if search:
        query = query.filter(
            or_(
                models.User.username.contains(search),
                models.User.email.contains(search),
                models.User.full_name.contains(search)
            )
        )
    
    # 状态筛选
    if is_active is not None:
        query = query.filter(models.User.is_active == is_active)
    
    users = query.offset(skip).limit(limit).all()
    return users

@app.get("/api/users/{user_id}", response_model=UserResponse)
async def get_user(user_id: int, db: Session = Depends(get_db)):
    """获取单个用户详情"""
    user = db.query(models.User).filter(models.User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    return user

@app.put("/api/users/{user_id}", response_model=UserResponse)
async def update_user(user_id: int, user_update: UserUpdate, db: Session = Depends(get_db)):
    """更新用户信息"""
    user = db.query(models.User).filter(models.User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    
    # 更新字段
    update_data = user_update.dict(exclude_unset=True)
    for field, value in update_data.items():
        setattr(user, field, value)
    
    user.updated_at = datetime.now()
    db.commit()
    db.refresh(user)
    return user

@app.delete("/api/users/{user_id}", status_code=204)
async def delete_user(user_id: int, db: Session = Depends(get_db)):
    """删除用户（软删除）"""
    user = db.query(models.User).filter(models.User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    
    # 软删除
    user.is_active = False
    db.commit()
    return None

# 文章接口
@app.post("/api/articles", response_model=ArticleResponse, status_code=201)
async def create_article(
    article: ArticleCreate,
    author_id: int = Query(..., description="作者ID"),
    db: Session = Depends(get_db)
):
    """创建文章"""
    # 验证作者是否存在
    author = db.query(models.User).filter(models.User.id == author_id).first()
    if not author:
        raise HTTPException(status_code=404, detail="作者不存在")
    
    db_article = models.Article(
        title=article.title,
        content=article.content,
        author_id=author_id
    )
    
    db.add(db_article)
    db.commit()
    db.refresh(db_article)
    return db_article

@app.get("/api/articles", response_model=List[ArticleResponse])
async def get_articles(
    skip: int = 0,
    limit: int = 20,
    author_id: Optional[int] = None,
    db: Session = Depends(get_db)
):
    """获取文章列表"""
    query = db.query(models.Article)
    
    if author_id:
        query = query.filter(models.Article.author_id == author_id)
    
    articles = query.order_by(models.Article.created_at.desc()).offset(skip).limit(limit).all()
    return articles

@app.get("/api/articles/{article_id}", response_model=ArticleResponse)
async def get_article(article_id: int, db: Session = Depends(get_db)):
    """获取文章详情（增加浏览次数）"""
    article = db.query(models.Article).filter(models.Article.id == article_id).first()
    if not article:
        raise HTTPException(status_code=404, detail="文章不存在")
    
    # 增加浏览次数
    article.view_count += 1
    db.commit()
    db.refresh(article)
    return article

六、中间件与依赖注入

6.1 自定义中间件

# middleware.py
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.trustedhost import TrustedHostMiddleware
from starlette.middleware.base import BaseHTTPMiddleware
import time
import logging

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class LoggingMiddleware(BaseHTTPMiddleware):
    """请求日志中间件"""
    
    async def dispatch(self, request: Request, call_next):
        start_time = time.time()
        
        # 记录请求信息
        logger.info(f"Request: {request.method} {request.url.path}")
        
        # 处理请求
        response = await call_next(request)
        
        # 记录响应时间
        process_time = time.time() - start_time
        response.headers["X-Process-Time"] = str(process_time)
        logger.info(f"Response: {response.status_code} - Time: {process_time:.3f}s")
        
        return response

class RateLimitMiddleware(BaseHTTPMiddleware):
    """简单的限流中间件"""
    
    def __init__(self, app, calls=10, period=60):
        super().__init__(app)
        self.calls = calls
        self.period = period
        self.requests = {}
    
    async def dispatch(self, request: Request, call_next):
        client_ip = request.client.host
        
        # 检查限流
        current_time = time.time()
        if client_ip in self.requests:
            request_times = self.requests[client_ip]
            # 清理过期记录
            request_times = [t for t in request_times if current_time - t < self.period]
            
            if len(request_times) >= self.calls:
                from fastapi import HTTPException
                raise HTTPException(status_code=429, detail="请求过于频繁")
            
            request_times.append(current_time)
            self.requests[client_ip] = request_times
        else:
            self.requests[client_ip] = [current_time]
        
        response = await call_next(request)
        return response

# 配置CORS
def setup_middlewares(app: FastAPI):
    app.add_middleware(
        CORSMiddleware,
        allow_origins=["http://localhost:3000", "https://yourdomain.com"],
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )
    
    app.add_middleware(
        TrustedHostMiddleware,
        allowed_hosts=["localhost", "127.0.0.1", "yourdomain.com"]
    )
    
    app.add_middleware(LoggingMiddleware)
    app.add_middleware(RateLimitMiddleware, calls=100, period=60)

6.2 依赖注入实战

# dependencies.py
from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from sqlalchemy.orm import Session
from jose import JWTError, jwt
from datetime import datetime, timedelta
import os

from database import get_db
import models

# 配置
SECRET_KEY = os.getenv("SECRET_KEY", "your-secret-key")
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

security = HTTPBearer()

def create_access_token(data: dict):
    """创建JWT token"""
    to_encode = data.copy()
    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

def verify_token(token: str):
    """验证JWT token"""
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        user_id: int = payload.get("sub")
        if user_id is None:
            raise HTTPException(status_code=401, detail="无效的token")
        return user_id
    except JWTError:
        raise HTTPException(status_code=401, detail="无效的token")

async def get_current_user(
    credentials: HTTPAuthorizationCredentials = Depends(security),
    db: Session = Depends(get_db)
):
    """获取当前登录用户"""
    token = credentials.credentials
    user_id = verify_token(token)
    
    user = db.query(models.User).filter(models.User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    
    if not user.is_active:
        raise HTTPException(status_code=403, detail="账户已被禁用")
    
    return user

async def get_current_active_user(
    current_user: models.User = Depends(get_current_user)
):
    """获取当前活跃用户"""
    if not current_user.is_active:
        raise HTTPException(status_code=400, detail="账户未激活")
    return current_user

# 使用示例
@app.post("/api/login")
async def login(username: str, password: str, db: Session = Depends(get_db)):
    """用户登录"""
    user = db.query(models.User).filter(models.User.username == username).first()
    if not user or user.hashed_password != hash_password(password):
        raise HTTPException(status_code=401, detail="用户名或密码错误")
    
    access_token = create_access_token(data={"sub": str(user.id)})
    return {"access_token": access_token, "token_type": "bearer"}

@app.get("/api/profile")
async def get_profile(current_user: models.User = Depends(get_current_user)):
    """获取当前用户信息（需要登录）"""
    return current_user

七、异常处理与响应封装

7.1 全局异常处理

# exceptions.py
from fastapi import FastAPI, Request, status
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
from sqlalchemy.exc import SQLAlchemyError
import logging

logger = logging.getLogger(__name__)

class BusinessException(Exception):
    """业务异常"""
    def __init__(self, code: int, message: str):
        self.code = code
        self.message = message

def setup_exception_handlers(app: FastAPI):
    
    @app.exception_handler(BusinessException)
    async def business_exception_handler(request: Request, exc: BusinessException):
        return JSONResponse(
            status_code=200,
            content={
                "code": exc.code,
                "message": exc.message,
                "data": None
            }
        )
    
    @app.exception_handler(RequestValidationError)
    async def validation_exception_handler(request: Request, exc: RequestValidationError):
        errors = []
        for error in exc.errors():
            errors.append({
                "field": ".".join(str(loc) for loc in error["loc"]),
                "message": error["msg"]
            })
        
        return JSONResponse(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            content={
                "code": 422,
                "message": "参数验证失败",
                "errors": errors
            }
        )
    
    @app.exception_handler(SQLAlchemyError)
    async def sqlalchemy_exception_handler(request: Request, exc: SQLAlchemyError):
        logger.error(f"Database error: {str(exc)}")
        return JSONResponse(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            content={
                "code": 500,
                "message": "数据库操作失败",
                "data": None
            }
        )
    
    @app.exception_handler(Exception)
    async def general_exception_handler(request: Request, exc: Exception):
        logger.error(f"Unexpected error: {str(exc)}", exc_info=True)
        return JSONResponse(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            content={
                "code": 500,
                "message": "服务器内部错误",
                "data": None
            }
        )

# 统一响应封装
class ResponseModel:
    @staticmethod
    def success(data=None, message="操作成功"):
        return {
            "code": 200,
            "message": message,
            "data": data
        }
    
    @staticmethod
    def error(code: int, message: str, data=None):
        return {
            "code": code,
            "message": message,
            "data": data
        }

八、异步处理与性能优化

8.1 异步接口示例

# async_api.py
import asyncio
from fastapi import FastAPI, BackgroundTasks
import httpx
import aiofiles
from concurrent.futures import ThreadPoolExecutor
import time

app = FastAPI()

# 异步HTTP请求
@app.get("/api/async-fetch")
async def fetch_multiple_urls(urls: list[str]):
    """并发获取多个URL"""
    async with httpx.AsyncClient() as client:
        tasks = [client.get(url) for url in urls]
        responses = await asyncio.gather(*tasks)
        return [{"url": str(r.url), "status": r.status_code} for r in responses]

# 后台任务
def process_data(data: dict):
    """耗时任务在后台执行"""
    time.sleep(5)  # 模拟耗时操作
    print(f"Processing completed: {data}")

@app.post("/api/background-task")
async def background_task(data: dict, background_tasks: BackgroundTasks):
    """后台任务接口"""
    background_tasks.add_task(process_data, data)
    return {"message": "任务已提交", "task_id": "123456"}

# 异步文件上传
@app.post("/api/async-upload")
async def upload_file(file: UploadFile = File(...)):
    """异步文件上传"""
    async with aiofiles.open(f"uploads/{file.filename}", 'wb') as f:
        content = await file.read()
        await f.write(content)
    
    return {"filename": file.filename, "size": len(content)}

九、接口文档与测试

9.1 自动生成API文档

from fastapi import FastAPI, Query, Path, Body
from typing import Annotated

app = FastAPI(
    title="完整API接口文档",
    description="""
    # API功能说明
    
    ## 用户模块
    - 用户注册、登录、信息管理
    
    ## 文章模块
    - 文章发布、编辑、删除
    
    ## 权限控制
    - JWT token认证
    - 角色权限管理
    
    ## 联系方式
    技术支持: support@example.com
    """,
    version="2.0.0",
    terms_of_service="http://example.com/terms/",
    contact={
        "name": "API Support",
        "url": "http://example.com/support",
        "email": "support@example.com",
    },
    license_info={
        "name": "MIT License",
        "url": "https://opensource.org/licenses/MIT",
    }
)

@app.get("/api/search")
async def search(
    keyword: Annotated[str, Query(min_length=1, max_length=50, description="搜索关键词")],
    page: Annotated[int, Query(ge=1, le=100, description="页码")] = 1,
    page_size: Annotated[int, Query(ge=1, le=50, description="每页数量")] = 10
):
    """
    搜索接口
    
    - **keyword**: 必填，搜索关键词
    - **page**: 可选，默认1
    - **page_size**: 可选，默认10
    
    返回搜索结果列表
    """
    return {"keyword": keyword, "page": page, "page_size": page_size}

9.2 单元测试

# test_api.py
import pytest
from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_create_user():
    """测试创建用户"""
    response = client.post("/api/users", json={
        "username": "testuser",
        "email": "test@example.com",
        "password": "123456",
        "full_name": "Test User"
    })
    
    assert response.status_code == 201
    data = response.json()
    assert data["username"] == "testuser"
    assert "id" in data

def test_get_user_not_found():
    """测试获取不存在的用户"""
    response = client.get("/api/users/99999")
    assert response.status_code == 404

def test_login():
    """测试登录"""
    response = client.post("/api/login", data={
        "username": "testuser",
        "password": "123456"
    })
    
    assert response.status_code == 200
    assert "access_token" in response.json()

@pytest.mark.parametrize("username,email,expected_status", [
    ("", "test@example.com", 422),  # 空用户名
    ("tu", "test@example.com", 422),  # 用户名太短
    ("testuser", "invalid-email", 422),  # 无效邮箱
])
def test_user_validation(username, email, expected_status):
    """测试用户输入验证"""
    response = client.post("/api/users", json={
        "username": username,
        "email": email,
        "password": "123456"
    })
    assert response.status_code == expected_status

十、部署与监控

10.1 Docker部署

# Dockerfile
FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# docker-compose.yml
version: '3.8'

services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=mysql+pymysql://root:password@db:3306/api_db
    depends_on:
      - db
      - redis
    volumes:
      - ./logs:/app/logs
  
  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: api_db
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
  
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"

volumes:
  mysql_data:

10.2 性能监控

# monitoring.py
from prometheus_fastapi_instrumentator import Instrumentator
from fastapi import FastAPI
import time

def setup_monitoring(app: FastAPI):
    # Prometheus监控
    Instrumentator().instrument(app).expose(app)
    
    # 自定义指标
    @app.middleware("http")
    async def monitor_requests(request: Request, call_next):
        start_time = time.time()
        response = await call_next(request)
        duration = time.time() - start_time
        
        # 记录请求耗时
        response.headers["X-Response-Time"] = str(duration)
        
        # 这里可以将指标发送到监控系统
        if duration > 1:  # 超过1秒
            print(f"Slow request: {request.url.path} - {duration:.2f}s")
        
        return response

十一、最佳实践总结

11.1 项目结构

api_project/
├── app/
│   ├── __init__.py
│   ├── main.py              # 应用入口
│   ├── config.py            # 配置文件
│   ├── database.py          # 数据库配置
│   ├── models/              # 数据模型
│   ├── schemas/             # Pydantic模型
│   ├── api/                 # 路由
│   │   ├── v1/
│   │   │   ├── users.py
│   │   │   └── articles.py
│   ├── core/                # 核心功能
│   │   ├── security.py
│   │   └── dependencies.py
│   ├── services/            # 业务逻辑
│   ├── middleware/          # 中间件
│   └── utils/               # 工具函数
├── tests/                   # 测试
├── requirements.txt
├── Dockerfile
└── docker-compose.yml

11.2 性能优化建议

使用连接池：数据库连接池、Redis连接池
缓存策略：使用Redis缓存热点数据
异步处理：耗时操作使用后台任务
数据库优化：添加索引、分页查询
响应压缩：启用Gzip压缩

11.3 安全建议

使用HTTPS
密码加密存储
JWT token设置合理过期时间
输入验证和SQL注入防护
限流防止DDoS攻击
CORS正确配置

十二、运行与测试

# 安装依赖
pip install -r requirements.txt

# 初始化数据库
python init_db.py

# 启动服务
uvicorn main:app --reload --host 0.0.0.0 --port 8000

# 访问文档
# Swagger UI: http://localhost:8000/docs
# ReDoc: http://localhost:8000/redoc

# 运行测试
pytest tests/ -v

# 性能测试
ab -n 1000 -c 100 http://localhost:8000/api/users

总结

本文详细介绍了使用Python开发RESTful API的完整流程，包括：

✅ 框架选择：FastAPI vs Flask vs Django
✅ 基础入门：路由、请求、响应
✅ 数据库集成：SQLAlchemy ORM使用
✅ 中间件开发：日志、限流、CORS
✅ 认证授权：JWT token实现
✅ 异常处理：全局异常捕获
✅ 异步处理：async/await应用
✅ 测试部署：单元测试、Docker容器化