FastApi大全-优雅得构造MVC架构目录

我们在创建一个后端服务或者数据接口服务得时候要先构建FastAPI的MVC架构目录。
FastAPI的MVC架构可以清晰地分离业务逻辑、数据模型和路由控制。以下是一个典型的目录结构示例：

project/

├── app/
│   ├── controllers/  # 控制层
│   │   ├── user_controller.py
│   │   └── item_controller.py
│   ├── models/       # 模型层
│   │   ├── user.py
│   │   └── item.py
│   ├── services/     # 业务逻辑层
│   │   ├── user_service.py
│   │   └── item_service.py
│   ├── schemas/      # Pydantic模型
│   │   ├── user.py
│   │   └── item.py
│   └── main.py       # 应用入口
├── tests/            # 测试
└── requirements.txt  # 依赖

控制层实现示例
控制层负责处理HTTP请求和响应，调用服务层完成业务逻辑：

# controllers/user_controller.py
from fastapi import APIRouter, Depends
from ..services.user_service import UserService
from ..schemas.user import UserCreate, UserResponse

router = APIRouter(prefix="/users", tags=["users"])

@router.post("/", response_model=UserResponse)
async def create_user(user: UserCreate, service: UserService = Depends()):
    return service.create_user(user)

@router.get("/{user_id}", response_model=UserResponse)
async def get_user(user_id: int, service: UserService = Depends()):
    return service.get_user(user_id)

服务层实现
服务层包含核心业务逻辑：

# services/user_service.py
from ..models.user import User
from ..schemas.user import UserCreate, UserResponse

class UserService:
    async def create_user(self, user_data: UserCreate) -> UserResponse:
        user = await User.create(**user_data.dict())
        return UserResponse.from_orm(user)
    
    async def get_user(self, user_id: int) -> UserResponse:
        user = await User.get_or_404(user_id)
        return UserResponse.from_orm(user)

模型层实现
模型层定义数据结构和数据库交互：

# models/user.py
from tortoise.models import Model
from tortoise import fields

class User(Model):
    id = fields.IntField(pk=True)
    username = fields.CharField(max_length=50, unique=True)
    email = fields.CharField(max_length=100)
    
    class Meta:
        table = "users"

Pydantic模型定义
数据验证和序列化模型：

# schemas/user.py
from pydantic import BaseModel

class UserCreate(BaseModel):
    username: str
    email: str

class UserResponse(BaseModel):
    id: int
    username: str
    email: str
    
    class Config:
        orm_mode = True

应用入口配置
将各个模块组装成完整应用：

# main.py
from fastapi import FastAPI
from app.controllers import user_controller, item_controller
from tortoise.contrib.fastapi import register_tortoise

app = FastAPI()
app.include_router(user_controller.router)
app.include_router(item_controller.router)

register_tortoise(
    app,
    db_url="sqlite://db.sqlite3",
    modules={"models": ["app.models.user", "app.models.item"]},
    generate_schemas=True
)

依赖注入实践
FastAPI的依赖注入系统可以优雅地管理服务层依赖：

# dependencies.py
from app.services.user_service import UserService

def get_user_service():
    return UserService()

# 在控制器中使用
@router.get("/")
async def list_users(service: UserService = Depends(get_user_service)):
    return await service.list_users()

测试编写建议
为控制器编写测试确保接口行为正确：

# tests/test_users.py
from fastapi.testclient import TestClient
from app.main import app

client = TestClient(app)

def test_create_user():
    response = client.post("/users/", json={"username": "test", "email": "test@example.com"})
    assert response.status_code == 200
    assert "id" in response.json()

这种架构清晰地分离了关注点，使代码更易于维护和测试。控制层保持简洁，仅处理HTTP相关逻辑，业务逻辑完全由服务层处理，模型层专注于数据持久化。