一、为什么后端要分层？不分层有什么坑

分层本质是单一职责、解耦：把接收请求、业务逻辑、数据库操作、数据模型拆开，一段代码只做一件事。

二、标准四层架构：每层作用与职责

三、数据流转完整流程（用户创建订单示例）

1. 前端POST /order/create 携带商品ID、用户ID
2. Controller接收请求，Pydantic校验参数合法性
3. Controller调用OrderService.create_order(user_id, goods_id)
4. Service开启数据库事务：
   • 调用GoodsRepository查询商品库存
   • 业务判断：库存不足直接抛出异常
   • 调用OrderRepository新增订单
   • 调用GoodsRepository扣减库存
   • 事务提交，失败自动回滚
5. Repository通过ORM Model操作数据表，返回数据
6. 数据逐层回传给Controller，统一JSON返回前端

四、零基础架构设计通用步骤

1. 梳理业务模块：用户、商品、订单、支付等，拆分独立业务域
2. 拆分数据表，设计ORM Model字段与关联关系
3. 划分接口，确定每个接口入参、出参（DTO模型）
4. 按四层架构分配代码文件：每个模块单独一套Controller/Service/Repository
5. 抽取公共工具、全局异常、中间件、配置
6. 规范调用规则：Controller→Service→Repository，禁止跨层反向调用
7. 编写单元测试：Service层优先测试，无需启动接口

五、主流Python后端框架架构对比

六、标准分层项目完整目录结构（FastAPI示例）

project_root/
├── config/                # 全局配置yaml
│   └── app.yml
├── core/                  # 核心公共组件
│   ├── exception.py       # 全局异常、错误码
│   ├── middleware.py      # 跨域、鉴权中间件
│   └── dependencies.py    # 依赖注入（登录校验）
├── utils/                 # 通用工具
│   ├── crypto.py
│   └── date_util.py
├── api/                   # Controller控制层（路由）
│   ├── user.py
│   ├── order.py
│   └── goods.py
├── service/                # Service业务层
│   ├── user_service.py
│   ├── order_service.py
│   └── goods_service.py
├── repository/            # Repository数据层
│   ├── user_repo.py
│   ├── order_repo.py
│   └── goods_repo.py
├── model/                 # 模型层
│   ├── db/                # ORM数据库模型
│   │   ├── user.py
│   │   └── order.py
│   └── dto/               # Pydantic入参出参
│       ├── user_dto.py
│       └── order_dto.py
├── db/                    # 数据库连接、会话
│   └── session.py
├── main.py                # 项目入口
└── requirements.txt

七、分层代码极简示例（创建订单）

1. model/db/order.py ORM模型

from sqlalchemy import Column, Integer, String
from db.session import Base

class Order(Base):
    __tablename__ = "t_order"
    id = Column(Integer, primary_key=True, autoincrement=True)
    user_id = Column(Integer)
    goods_id = Column(Integer)
    status = Column(String)

2. model/dto/order_dto 入参校验

from pydantic import BaseModel

class OrderCreateDTO(BaseModel):
    user_id: int
    goods_id: int

3. repository/order_repo 数据层

from sqlalchemy.orm import Session
from model.db.order import Order

class OrderRepo:
    @staticmethod
    def create(db: Session, user_id: int, goods_id: int):
        new_order = Order(user_id=user_id, goods_id=goods_id, status="pending")
        db.add(new_order)
        db.flush()
        return new_order.id

4. service/order_service 业务层

from sqlalchemy.orm import Session
from repository.order_repo import OrderRepo
from repository.goods_repo import GoodsRepo
from core.exception import BusinessException

class OrderService:
    @staticmethod
    def create_order(db: Session, user_id: int, goods_id: int):
        # 业务校验：查询库存
        goods = GoodsRepo.get_by_id(db, goods_id)
        if goods.stock <= 0:
            raise BusinessException("商品库存不足")
        # 事务操作
        order_id = OrderRepo.create(db, user_id, goods_id)
        GoodsRepo.sub_stock(db, goods_id, 1)
        return order_id

5. api/order.py Controller路由层

from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from db.session import get_db
from model.dto.order_dto import OrderCreateDTO
from service.order_service import OrderService

router = APIRouter(prefix="/order")

@router.post("/create")
def create_order(dto: OrderCreateDTO, db: Session = Depends(get_db)):
    order_id = OrderService.create_order(db, dto.user_id, dto.goods_id)
    return {"code": 200, "msg": "创建成功", "data": {"order_id": order_id}}

八、分层架构核心原则（避坑）

九、小型/中型/大型项目架构取舍

十、总结速查表