FastAPI环境配置详解一步步教你搭建高效开发环境

引言

FastAPI是一个现代、高性能的Web框架，用于构建API，基于Python 3.6+的类型提示。它具有以下显著优势：

高性能：与NodeJS和Go相当
快速编码：提高开发速度约200%-300%
减少错误：减少约40%的人为错误
直观易用：强大的编辑器支持和自动补全
基于标准：完全兼容API开放标准

搭建一个高效的开发环境是充分利用FastAPI这些优势的第一步。本文将详细介绍如何从零开始构建一个完整的FastAPI开发环境。

系统要求

在开始之前，请确保你的系统满足以下基本要求：

操作系统：Windows、macOS或Linux
Python版本：3.6或更高版本（推荐3.8+）
内存：至少4GB RAM（推荐8GB+）
存储空间：至少1GB可用空间
网络连接：用于下载和安装必要的包

Python环境设置

检查Python安装

首先，检查你的系统是否已安装Python：

# 在Windows上 python --version # 在macOS或Linux上 python3 --version

如果Python已安装，你将看到类似”Python 3.8.5”的输出。如果没有安装或版本低于3.6，你需要先安装或升级Python。

安装Python

在Windows上安装Python：

访问Python官方网站：https://www.python.org/downloads/
下载最新的Python安装程序（选择3.8或更高版本）
运行安装程序，确保勾选”Add Python to PATH”选项
按照安装向导完成安装

在macOS上安装Python：

推荐使用Homebrew安装Python：

# 安装Homebrew（如果尚未安装） /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" # 使用Homebrew安装Python brew install python

在Linux上安装Python：

在Ubuntu/Debian系统上：

sudo apt update sudo apt install python3 python3-pip

在CentOS/RHEL系统上：

sudo yum install python3 python3-pip

虚拟环境创建

使用虚拟环境可以隔离项目依赖，避免包版本冲突。Python提供了几种创建虚拟环境的方法，我们将介绍两种最常用的方法：venv和conda。

使用venv创建虚拟环境

venv是Python自带的虚拟环境管理工具，无需额外安装。

创建虚拟环境：

# 创建一个名为"fastapi-env"的虚拟环境 python -m venv fastapi-env # Windows python3 -m venv fastapi-env # macOS/Linux

激活虚拟环境：

# Windows fastapi-envScriptsactivate # macOS/Linux source fastapi-env/bin/activate

激活后，你会在命令行前面看到虚拟环境的名称，例如(fastapi-env) C:UsersYourName>。

退出虚拟环境：

deactivate

使用conda创建虚拟环境

如果你使用Anaconda或Miniconda，可以使用conda创建虚拟环境。

安装Miniconda（如果尚未安装）：

访问Miniconda安装页面：https://docs.conda.io/en/latest/miniconda.html

下载适合你系统的安装程序并按照说明进行安装。

创建虚拟环境：

# 创建一个名为"fastapi-env"的Python 3.8环境 conda create -n fastapi-env python=3.8

激活虚拟环境：

conda activate fastapi-env

退出虚拟环境：

conda deactivate

FastAPI安装

现在我们已经设置了虚拟环境，接下来安装FastAPI及其相关依赖。

基本安装

在激活的虚拟环境中，运行以下命令安装FastAPI：

pip install fastapi

安装ASGI服务器

FastAPI需要ASGI服务器来运行。Uvicorn是一个高性能的ASGI服务器，推荐使用：

pip install "uvicorn[standard]"

[standard]选项会安装Uvicorn及其推荐的依赖，包括httptools和uvloop（在Linux系统上），这些可以提高性能。

可选依赖

根据你的项目需求，你可能还需要安装以下包：

# 用于数据库交互 pip install sqlalchemy # 用于数据库迁移 pip install alembic # 用于ORM pip install databases # 用于Pydantic模型验证（FastAPI已经包含，但有时需要单独更新） pip install pydantic # 用于CORS支持 pip install fastapi[all] # 用于认证 pip install python-jose[cryptography] pip install passlib[bcrypt] # 用于测试 pip install pytest pytest-asyncio httpx

创建requirements.txt文件

为了便于项目管理和部署，建议创建一个requirements.txt文件，列出所有依赖：

# 生成requirements.txt pip freeze > requirements.txt

requirements.txt文件内容示例：

fastapi==0.68.0 uvicorn==0.15.0 pydantic==1.8.2 sqlalchemy==1.4.23 alembic==1.7.1 databases==0.5.3 python-jose==3.3.0 passlib==1.7.4 pytest==6.2.5 pytest-asyncio==0.15.1 httpx==0.19.0

开发工具配置

选择合适的开发工具并正确配置可以大大提高开发效率。以下是几种常用的IDE和编辑器的配置方法。

Visual Studio Code配置

VS Code是一个轻量级但功能强大的代码编辑器，非常适合FastAPI开发。

安装VS Code：https://code.visualstudio.com/
安装Python扩展：
- 打开VS Code
- 按Ctrl+P（或Cmd+P）并输入ext install ms-python.python
- 点击”Install”安装Python扩展
安装其他有用的扩展：
- Pylance：提供更好的代码智能提示
- Python Test Explorer：方便运行测试
- REST Client：用于测试API端点
配置VS Code工作区：在项目根目录创建.vscode/settings.json文件：

{ "python.pythonPath": "fastapi-env/bin/python", // macOS/Linux // "python.pythonPath": "fastapi-env\Scripts\python.exe", // Windows "python.linting.enabled": true, "python.linting.pylintEnabled": true, "python.formatting.provider": "black", "editor.formatOnSave": true, "python.testing.pytestEnabled": true, "python.testing.unittestEnabled": false, "python.testing.nosetestsEnabled": false }

配置启动文件：在.vscode/launch.json中添加FastAPI启动配置：

{ "version": "0.2.0", "configurations": [ { "name": "Python: FastAPI", "type": "python", "request": "launch", "module": "uvicorn", "args": [ "main:app", "--reload", "--host", "0.0.0.0", "--port", "8000" ], "jinja": true, "justMyCode": true } ] }

PyCharm配置

PyCharm是一个功能全面的Python IDE，提供了许多专业开发功能。

安装PyCharm：https://www.jetbrains.com/pycharm/
创建新项目：
- 打开PyCharm
- 选择”Create New Project”
- 选择项目位置
- 在”New environment using”中选择”Virtualenv”
- 确保选择了正确的Python解释器
配置项目解释器：
- 转到File > Settings > Project: [项目名] > Python Interpreter
- 点击齿轮图标，选择”Add…”
- 选择”Existing environment”
- 浏览到虚拟环境中的Python解释器（例如fastapi-env/bin/python）
配置运行/调试配置：
- 点击右上角的下拉菜单，选择”Edit Configurations…”
- 点击”+“号，选择”Python”
- 在”Script path”中选择uvicorn的路径（在虚拟环境的Scripts或bin目录中）
- 在”Parameters”中输入：main:app --reload --host 0.0.0.0 --port 8000
- 给配置命名，例如”FastAPI”
安装有用的插件：
- .env：支持.env文件
- RESTful WebServices：测试API端点
- Key Promoter X：学习快捷键

项目结构

一个良好的项目结构可以使代码更易于维护和扩展。以下是一个推荐的FastAPI项目结构：

my_fastapi_project/ ├── app/ │ ├── __init__.py │ ├── main.py # FastAPI应用实例和路由 │ ├── core/ # 核心配置 │ │ ├── __init__.py │ │ ├── config.py # 配置设置 │ │ └── security.py # 安全相关功能 │ ├── models/ # 数据模型 │ │ ├── __init__.py │ │ ├── user.py │ │ └── item.py │ ├── schemas/ # Pydantic模型 │ │ ├── __init__.py │ │ ├── user.py │ │ └── item.py │ ├── api/ # API路由 │ │ ├── __init__.py │ │ ├── v1/ │ │ │ ├── __init__.py │ │ │ ├── endpoints/ │ │ │ │ ├── __init__.py │ │ │ │ ├── users.py │ │ │ │ └── items.py │ │ │ └── api.py # API v1路由 │ ├── crud/ # 数据库操作 │ │ ├── __init__.py │ │ ├── base.py │ │ ├── user.py │ │ └── item.py │ ├── db/ # 数据库相关 │ │ ├── __init__.py │ │ ├── session.py # 数据库会话 │ │ └── base_class.py # 声明基类 │ ├── tests/ # 测试 │ │ ├── __init__.py │ │ ├── conftest.py │ │ ├── test_users.py │ │ └── test_items.py │ └── utils/ # 工具函数 │ ├── __init__.py │ └── helpers.py ├── alembic.ini # Alembic配置文件 ├── .env # 环境变量 ├── .gitignore ├── requirements.txt ├── Dockerfile └── README.md

创建基本文件

让我们创建一些基本文件来启动项目：

app/main.py - 主应用文件：

from fastapi import FastAPI from app.api.v1.api import api_router from app.core.config import settings app = FastAPI( title=settings.PROJECT_NAME, openapi_url=f"{settings.API_V1_STR}/openapi.json" ) app.include_router(api_router, prefix=settings.API_V1_STR) @app.get("/") async def root(): return {"message": "Welcome to FastAPI"}

app/core/config.py - 配置文件：

from typing import Any, Dict, Optional, List, Union from pydantic import BaseSettings, validator class Settings(BaseSettings): API_V1_STR: str = "/api/v1" PROJECT_NAME: str = "My FastAPI Project" # CORS BACKEND_CORS_ORIGINS: List[str] = ["http://localhost:3000", "http://localhost:8000"] @validator("BACKEND_CORS_ORIGINS", pre=True) def assemble_cors_origins(cls, v: Union[str, List[str]]) -> Union[List[str], str]: if isinstance(v, str) and not v.startswith("["): return [i.strip() for i in v.split(",")] elif isinstance(v, (list, str)): return v raise ValueError(v) # Database POSTGRES_SERVER: str = "localhost" POSTGRES_USER: str = "postgres" POSTGRES_PASSWORD: str = "password" POSTGRES_DB: str = "appdb" DATABASE_URL: Optional[str] = None @validator("DATABASE_URL", pre=True) def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v return f"postgresql://{values.get('POSTGRES_USER')}:{values.get('POSTGRES_PASSWORD')}@{values.get('POSTGRES_SERVER')}/{values.get('POSTGRES_DB')}" # JWT SECRET_KEY: str = "your-secret-key-here" ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8 # 8 days class Config: case_sensitive = True settings = Settings()

app/api/v1/api.py - API路由：

from fastapi import APIRouter from app.api.v1.endpoints import users, items api_router = APIRouter() api_router.include_router(users.router, prefix="/users", tags=["users"]) api_router.include_router(items.router, prefix="/items", tags=["items"])

app/api/v1/endpoints/users.py - 用户端点：

from fastapi import APIRouter, Depends, HTTPException from sqlalchemy.orm import Session from app import crud, schemas from app.db.session import get_db router = APIRouter() @router.post("/", response_model=schemas.User) def create_user( *, db: Session = Depends(get_db), user_in: schemas.UserCreate, ): """ Create new user. """ user = crud.user.get_by_email(db, email=user_in.email) if user: raise HTTPException( status_code=400, detail="The user with this username already exists in the system.", ) user = crud.user.create(db, obj_in=user_in) return user @router.get("/{user_id}", response_model=schemas.User) def read_user( user_id: int, db: Session = Depends(get_db), ): """ Get a specific user by id. """ user = crud.user.get(db, id=user_id) if not user: raise HTTPException(status_code=404, detail="User not found") return user

数据库配置

FastAPI支持多种数据库，包括PostgreSQL、MySQL、SQLite等。这里我们将以PostgreSQL为例，介绍如何配置数据库连接。

安装数据库驱动

首先，安装PostgreSQL的Python驱动：

pip install psycopg2-binary

配置数据库连接

在app/core/config.py中，我们已经定义了数据库连接的配置参数。现在，让我们创建数据库会话管理文件：

app/db/session.py - 数据库会话管理：

from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker from app.core.config import settings engine = create_engine(settings.DATABASE_URL) SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) Base = declarative_base() def get_db(): """ 获取数据库会话 """ db = SessionLocal() try: yield db finally: db.close()

app/db/base_class.py - 声明基类：

from typing import Any from sqlalchemy.ext.declarative import as_declarative, declared_attr @as_declarative() class Base: id: Any __name__: str # 生成表名 @declared_attr def __tablename__(cls) -> str: return cls.__name__.lower()

创建数据模型

让我们创建一个用户模型作为示例：

app/models/user.py - 用户模型：

from sqlalchemy import Boolean, Column, Integer, String from app.db.base_class import Base class User(Base): __tablename__ = "users" id = Column(Integer, primary_key=True, index=True) email = Column(String, unique=True, index=True, nullable=False) hashed_password = Column(String, nullable=False) is_active = Column(Boolean, default=True) is_superuser = Column(Boolean, default=False) full_name = Column(String)

app/models/init.py - 导入所有模型：

from app.db.base_class import Base from app.models.user import User # 确保所有模型都被导入，以便Alembic可以检测到它们

创建Pydantic模型

Pydantic模型用于数据验证和序列化：

app/schemas/user.py - 用户Pydantic模型：

from typing import Optional from pydantic import BaseModel, EmailStr class UserBase(BaseModel): email: EmailStr is_active: Optional[bool] = True full_name: Optional[str] = None class UserCreate(UserBase): password: str class UserUpdate(UserBase): password: Optional[str] = None class UserInDBBase(UserBase): id: Optional[int] = None class Config: orm_mode = True class User(UserInDBBase): pass class UserInDB(UserInDBBase): hashed_password: str

创建CRUD操作

CRUD（创建、读取、更新、删除）操作是与数据库交互的基本操作：

app/crud/base.py - 基础CRUD操作：

from typing import Any, Dict, Generic, List, Optional, Type, TypeVar, Union from fastapi.encoders import jsonable_encoder from pydantic import BaseModel from sqlalchemy.orm import Session from app.db.base_class import Base ModelType = TypeVar("ModelType", bound=Base) CreateSchemaType = TypeVar("CreateSchemaType", bound=BaseModel) UpdateSchemaType = TypeVar("UpdateSchemaType", bound=BaseModel) class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): def __init__(self, model: Type[ModelType]): """ CRUD object with default methods to Create, Read, Update, Delete (CRUD). **Parameters** * `model`: A SQLAlchemy model class * `schema`: A Pydantic model (schema) class """ self.model = model def get(self, db: Session, id: Any) -> Optional[ModelType]: return db.query(self.model).filter(self.model.id == id).first() def get_multi( self, db: Session, *, skip: int = 0, limit: int = 100 ) -> List[ModelType]: return db.query(self.model).offset(skip).limit(limit).all() def create(self, db: Session, *, obj_in: CreateSchemaType) -> ModelType: obj_in_data = jsonable_encoder(obj_in) db_obj = self.model(**obj_in_data) db.add(db_obj) db.commit() db.refresh(db_obj) return db_obj def update( self, db: Session, *, db_obj: ModelType, obj_in: Union[UpdateSchemaType, Dict[str, Any]] ) -> ModelType: obj_data = jsonable_encoder(db_obj) if isinstance(obj_in, dict): update_data = obj_in else: update_data = obj_in.dict(exclude_unset=True) for field in obj_data: if field in update_data: setattr(db_obj, field, update_data[field]) db.add(db_obj) db.commit() db.refresh(db_obj) return db_obj def remove(self, db: Session, *, id: int) -> ModelType: obj = db.query(self.model).get(id) db.delete(obj) db.commit() return obj

app/crud/user.py - 用户CRUD操作：

from typing import Any, Dict, Optional, Union from sqlalchemy.orm import Session from app.core.security import get_password_hash, verify_password from app.crud.base import CRUDBase from app.models.user import User from app.schemas.user import UserCreate, UserUpdate class CRUDUser(CRUDBase[User, UserCreate, UserUpdate]): def get_by_email(self, db: Session, *, email: str) -> Optional[User]: return db.query(User).filter(User.email == email).first() def create(self, db: Session, *, obj_in: UserCreate) -> User: db_obj = User( email=obj_in.email, hashed_password=get_password_hash(obj_in.password), full_name=obj_in.full_name, is_active=obj_in.is_active, ) db.add(db_obj) db.commit() db.refresh(db_obj) return db_obj def update( self, db: Session, *, db_obj: User, obj_in: Union[UserUpdate, Dict[str, Any]] ) -> User: if isinstance(obj_in, dict): update_data = obj_in else: update_data = obj_in.dict(exclude_unset=True) if "password" in update_data and update_data["password"]: hashed_password = get_password_hash(update_data["password"]) del update_data["password"] update_data["hashed_password"] = hashed_password return super().update(db, db_obj=db_obj, obj_in=update_data) def authenticate(self, db: Session, *, email: str, password: str) -> Optional[User]: user = self.get_by_email(db, email=email) if not user: return None if not verify_password(password, user.hashed_password): return None return user def is_active(self, user: User) -> bool: return user.is_active def is_superuser(self, user: User) -> bool: return user.is_superuser user = CRUDUser(User)

配置Alembic用于数据库迁移

Alembic是一个数据库迁移工具，可以帮助我们管理数据库模式的变更。

初始化Alembic：

alembic init alembic

编辑alembic.ini文件，修改数据库连接：

# 将 sqlalchemy.url = driver://user:pass@localhost/dbname # 修改为： sqlalchemy.url = postgresql://postgres:password@localhost/appdb

编辑alembic/env.py文件，添加模型导入：

from app.models import * # noqa from app.db.base_class import Base target_metadata = Base.metadata

创建初始迁移：

alembic revision --autogenerate -m "Initial migration"

应用迁移：

alembic upgrade head

测试环境配置

测试是确保代码质量和功能正确性的关键部分。FastAPI与pytest完美集成，可以轻松编写和运行测试。

安装测试工具

我们已经在前面的requirements.txt中包含了测试工具：

pip install pytest pytest-asyncio httpx

配置测试

app/tests/conftest.py - 测试配置：

import pytest from fastapi.testclient import TestClient from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from app.db.base_class import Base from app.main import app from app.db.session import get_db # 使用SQLite内存数据库进行测试 SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db" engine = create_engine( SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False} ) TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) def override_get_db(): try: db = TestingSessionLocal() yield db finally: db.close() app.dependency_overrides[get_db] = override_get_db @pytest.fixture def client(): Base.metadata.create_all(bind=engine) with TestClient(app) as c: yield c Base.metadata.drop_all(bind=engine)

app/tests/test_users.py - 用户测试：

def test_create_user(client): response = client.post( "/api/v1/users/", json={"email": "test@example.com", "password": "password", "full_name": "Test User"}, ) assert response.status_code == 200 data = response.json() assert data["email"] == "test@example.com" assert data["full_name"] == "Test User" assert "id" in data def test_read_user(client): # 首先创建一个用户 response = client.post( "/api/v1/users/", json={"email": "test@example.com", "password": "password", "full_name": "Test User"}, ) assert response.status_code == 200 user_id = response.json()["id"] # 然后读取该用户 response = client.get(f"/api/v1/users/{user_id}") assert response.status_code == 200 data = response.json() assert data["email"] == "test@example.com" assert data["full_name"] == "Test User" assert data["id"] == user_id

运行测试

在项目根目录运行以下命令来执行测试：

pytest

部署环境准备

将FastAPI应用部署到生产环境需要一些额外的配置和工具。

使用Docker容器化应用

创建Dockerfile：

FROM python:3.9-slim WORKDIR /app COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt COPY . . CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

创建.dockerignore文件：

__pycache__ *.pyc *.pyo *.pyd .Python env pip-log.txt .tox .coverage .coverage.* .cache nosetests.xml coverage.xml *,cover *.cover .git .mypy_cache .pytest_cache .hypothesis .venv .env

构建Docker镜像：

docker build -t my-fastapi-app .

运行Docker容器：

docker run -d --name my-fastapi-container -p 8000:8000 my-fastapi-app

使用Docker Compose

对于包含多个服务（例如Web应用和数据库）的应用，可以使用Docker Compose：

创建docker-compose.yml文件：

version: '3.8' services: web: build: . command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload volumes: - .:/app ports: - "8000:8000" depends_on: - db environment: - DATABASE_URL=postgresql://postgres:password@db:5432/appdb db: image: postgres:13 environment: - POSTGRES_USER=postgres - POSTGRES_PASSWORD=password - POSTGRES_DB=appdb volumes: - postgres_data:/var/lib/postgresql/data/ ports: - "5432:5432" volumes: postgres_data:

使用Docker Compose启动服务：

docker-compose up -d

使用Gunicorn作为生产服务器

虽然Uvicorn是一个很好的ASGI服务器，但在生产环境中，你可能需要使用Gunicorn来管理多个Uvicorn工作进程：

安装Gunicorn和Uvicorn工作器：

pip install gunicorn uvicorn.workers

创建gunicorn_conf.py文件：

bind = "0.0.0.0:8000" workers = 4 worker_class = "uvicorn.workers.UvicornWorker"

启动Gunicorn：

gunicorn -c gunicorn_conf.py app.main:app

最佳实践

以下是一些提高FastAPI开发效率的最佳实践：

使用环境变量

使用python-dotenv库从.env文件加载环境变量：

安装python-dotenv：

pip install python-dotenv

创建.env文件：

POSTGRES_SERVER=localhost POSTGRES_USER=postgres POSTGRES_PASSWORD=password POSTGRES_DB=appdb SECRET_KEY=your-secret-key-here

在config.py中加载环境变量：

from pydantic import BaseSettings from dotenv import load_dotenv load_dotenv() class Settings(BaseSettings): # ... 其他配置 POSTGRES_SERVER: str POSTGRES_USER: str POSTGRES_PASSWORD: str POSTGRES_DB: str SECRET_KEY: str class Config: env_file = ".env"

使用预提交钩子

预提交钩子可以在每次提交前自动运行代码检查和格式化：

安装pre-commit：

pip install pre-commit

创建.pre-commit-config.yaml文件：

repos: - repo: https://github.com/psf/black rev: 21.9b0 hooks: - id: black language_version: python3 - repo: https://github.com/pycqa/isort rev: 5.9.3 hooks: - id: isort - repo: https://github.com/pycqa/flake8 rev: 3.9.2 hooks: - id: flake8 - repo: https://github.com/pre-commit/mirrors-mypy rev: v0.910 hooks: - id: mypy additional_dependencies: [types-requests, types-attrs]

安装预提交钩子：

pre-commit install

使用日志记录

良好的日志记录对于调试和监控应用程序非常重要：

配置日志记录：

import logging from app.core.config import settings logging.basicConfig( level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", handlers=[ logging.FileHandler("app.log"), logging.StreamHandler() ] ) logger = logging.getLogger(__name__)

在应用程序中使用日志记录：

from fastapi import FastAPI import logging logger = logging.getLogger(__name__) app = FastAPI() @app.get("/") async def root(): logger.info("Root endpoint called") return {"message": "Hello World"}

使用中间件

中间件可以添加全局功能到应用程序，例如CORS支持、请求日志记录等：

from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware from fastapi.middleware.gzip import GZipMiddleware import time import logging logger = logging.getLogger(__name__) app = FastAPI() # 添加CORS中间件 app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # 添加Gzip中间件 app.add_middleware(GZipMiddleware, minimum_size=1000) # 添加请求日志中间件 @app.middleware("http") async def log_requests(request, call_next): start_time = time.time() response = await call_next(request) process_time = time.time() - start_time logger.info(f"Request: {request.method} {request.url} - Completed in {process_time:.4f}s") return response

使用依赖注入

FastAPI的依赖注入系统是一个强大的功能，可以帮助你组织代码并重用组件：

from fastapi import FastAPI, Depends, HTTPException, status from fastapi.security import OAuth2PasswordBearer from typing import Optional app = FastAPI() oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") async def get_current_user(token: str = Depends(oauth2_scheme)): # 这里应该是验证token并返回用户的逻辑 if token != "secret": raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid authentication credentials", headers={"WWW-Authenticate": "Bearer"}, ) return {"username": "user"} @app.get("/users/me") async def read_users_me(current_user: dict = Depends(get_current_user)): return current_user