PythonAI

基于 Python 的毕业设计管理系统架构与 AI 辅助开发实践

介绍基于 Python 的毕业设计管理系统架构，采用 FastAPI 和 PostgreSQL 解决选题冲突、进度黑盒及权限混乱问题。通过 JWT 鉴权和防重复提交逻辑保障安全，并分享利用 AI 工具辅助编写代码、事务逻辑及测试用例的实战经验，提供生产环境部署建议。

云间运维发布于 2026/3/22更新于 2026/9/1168 浏览

1. 先聊聊痛点：毕业设计管理为啥需要系统化？

在动手之前，我们得先搞清楚要解决什么问题。传统的毕业设计管理，很多学校还停留在 Excel 表格、微信群和邮件往来的阶段，这里面槽点实在太多了：

选题冲突严重：学生和导师之间信息不对称，经常出现'一个课题多人抢'或者'好导师被秒光'的情况，全靠手速和关系，很不公平。
过程进度黑盒：开题、中期、答辩这些关键节点，学生提交了啥材料，导师批阅意见是什么，管理员很难全局掌握，催进度基本靠吼。
权限管理混乱：学生误操作了导师的审核界面，管理员不小心删了数据，角色权限划分不清晰，容易出乱子。
文档版本灾难：论文、报告反复修改，不同版本的文件散落在各个聊天记录和邮箱里，查找和归档简直是噩梦。

所以，我们的系统核心目标就是：流程线上化、操作透明化、权限精细化、文档集中化。

2. 技术选型：为什么是 FastAPI + SQLAlchemy？

确定了目标，接下来就是选择趁手的工具。这里主要对比了两个主流方案：

Web 框架：Django vs FastAPI

Django：大而全，自带 Admin 后台、ORM、用户认证，开箱即用。如果追求快速搭建一个管理后台，Django 非常合适。但它的'全家桶'模式有时也显得笨重，灵活性稍差，对于需要精细控制 API 行为和性能的场景，可能不是最轻量的选择。
FastAPI：现代、异步优先、性能极高，并且自动生成交互式 API 文档（Swagger UI）。我们的系统核心是提供清晰的 RESTful API 给前端（比如 Vue/React），FastAPI 的声明式依赖注入系统让实现 JWT 认证、角色权限检查变得异常优雅和模块化。最终我选择了 FastAPI，看中的就是它的高性能、清晰的代码结构以及对 OpenAPI 的原生支持。

数据库：关系型 vs 文档型

关系型数据库（如 PostgreSQL/MySQL）：数据结构规整，存在明确的导师、学生、课题、任务、提交记录等实体，且它们之间关联复杂（一对一、一对多、多对多）。事务性要求高（比如确保学生选题和导师确认的原子性）。因此，关系型数据库是更自然的选择。
文档型数据库（如 MongoDB）：虽然存储如论文草稿这样的半结构化数据很方便，但对于强一致性要求和复杂关联查询的业务，优势不大。

所以，我们选择 PostgreSQL 作为主数据库，配合 SQLAlchemy ORM 来操作。SQLAlchemy 的强大之处在于其表达能力和灵活性，可以清晰地定义模型关系。

3. 核心模块实现细节与 AI 助攻点

整个系统围绕几个核心模块展开，这里分享几个关键部分的实现，以及 AI 工具如何帮我'偷懒'。

3.1 用户角色与 JWT 鉴权

系统有三类用户：学生、导师、管理员。权限设计是关键。我使用 fastapi-jwt-auth 库来处理 JWT。

首先，定义角色枚举和用户模型：

from enum import Enum
from sqlalchemy import Column, Integer, String, Enum as SQLEnum
from app.database import Base

class UserRole(str, Enum):
    STUDENT = "student"
    TEACHER = 
    ADMIN = 

 ():
    __tablename__ = 
     = Column(Integer, primary_key=, index=)
    username = Column(String(), unique=, index=, nullable=)
    hashed_password = Column(String(), nullable=)
    full_name = Column(String())
    role = Column(SQLEnum(UserRole), nullable=)

from datetime import datetime, timedelta
from fastapi import APIRouter, Depends, HTTPException
from fastapi.security import OAuth2PasswordRequestForm
from app.auth import create_access_token, authenticate_user
from app.schemas import Token

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

@router.post("/login", response_model=Token)
async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
    # AI 辅助：快速写出用户认证逻辑骨架
    user = authenticate_user(form_data.username, form_data.password)
    if not user:
        raise HTTPException(status_code=400, detail="用户名或密码错误")
    
    # 定义 Token 过期时间
    access_token_expires = timedelta(minutes=30)
    
    # 创建 JWT Token，主题（sub）通常放用户 ID
    access_token = create_access_token(
        data={"sub": str(user.id), "role": user.role},
        expires_delta=access_token_expires
    )
    return {"access_token": access_token, "token_type": "bearer"}

from fastapi import Depends, HTTPException, status
from fastapi_jwt_auth import AuthJWT
from app.models import User
from app.database import SessionLocal

def get_current_user(Authorize: AuthJWT = Depends()) -> User:
    try:
        Authorize.jwt_required()
        current_user_id = Authorize.get_jwt_subject()
        current_user_role = Authorize.get_jwt_raw_jwt().get("role")
    except Exception:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="无效或过期的令牌")
    
    db = SessionLocal()
    user = db.query(User).filter(User.id == int(current_user_id)).first()
    db.close()
    
    if user is None:
        raise HTTPException(status_code=404, detail="用户不存在")
    return user

# 更进一步，创建角色检查依赖项
def require_role(required_role: UserRole):
    def role_checker(current_user: User = Depends(get_current_user)):
        if current_user.role != required_role and current_user.role != UserRole.ADMIN:
            # 管理员拥有所有权限
            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="权限不足")
        return current_user
    return role_checker

from sqlalchemy import Column, Integer, String, Text, ForeignKey, Enum as SQLEnum
from sqlalchemy.orm import relationship
from sqlalchemy.sql import func
from app.database import Base

class TopicStatus(str, Enum):
    PENDING = "pending"      # 待审核（管理员）
    APPROVED = "approved"    # 已发布，可选
    SELECTED = "selected"    # 已被选择
    ARCHIVED = "archived"    # 已归档

class Topic(Base):
    __tablename__ = "topics"
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(200), nullable=False)
    description = Column(Text)
    requirement = Column(Text)
    capacity = Column(Integer, default=1)          # 可容纳学生数
    current_selected = Column(Integer, default=0)
    status = Column(SQLEnum(TopicStatus), default=TopicStatus.PENDING)
    teacher_id = Column(Integer, ForeignKey("users.id"))
    # 关系
    teacher = relationship("User", back_populates="topics_proposed")
    selections = relationship("SelectionRecord", back_populates="topic")

class SelectionRecordStatus(str, Enum):
    APPLIED = "applied"     # 学生已申请
    APPROVED = "approved"   # 导师已同意
    REJECTED = "rejected"   # 导师已拒绝
    FINALIZED = "finalized" # 管理员最终确认

class SelectionRecord(Base):
    __tablename__ = "selection_records"
    id = Column(Integer, primary_key=True, index=True)
    student_id = Column(Integer, ForeignKey("users.id"), nullable=False)
    topic_id = Column(Integer, ForeignKey("topics.id"), nullable=False)
    status = Column(SQLEnum(SelectionRecordStatus), default=SelectionRecordStatus.APPLIED)
    applied_at = Column(DateTime(timezone=True), server_default=func.now())
    processed_at = Column(DateTime(timezone=True))
    # 关系
    student = relationship("User", back_populates="selections_made")
    topic = relationship("Topic", back_populates="selections")

@router.post("/topics/{topic_id}/apply", dependencies=[Depends(require_role(UserRole.STUDENT))])
async def apply_for_topic(
    topic_id: int,
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
):
    # 1. 检查课题是否存在且状态为可选
    topic = db.query(Topic).filter(Topic.id == topic_id, Topic.status == TopicStatus.APPROVED).first()
    if not topic:
        raise HTTPException(status_code=404, detail="课题不存在或不可选")
    
    # 2. 检查是否已申请过该课题（防重复提交）
    existing_application = db.query(SelectionRecord).filter(
        SelectionRecord.student_id == current_user.id,
        SelectionRecord.topic_id == topic_id
    ).first()
    if existing_application:
        raise HTTPException(status_code=400, detail="您已申请过该课题")
    
    # 3. 检查该学生是否已有最终确认的课题（一人一题）
    finalized_selection = db.query(SelectionRecord).filter(
        SelectionRecord.student_id == current_user.id,
        SelectionRecord.status == SelectionRecordStatus.FINALIZED
    ).first()
    if finalized_selection:
        raise HTTPException(status_code=400, detail="您已有最终确认的课题，无法再次申请")
    
    # 4. 检查课题容量（幂等性考虑：高并发下需使用数据库乐观锁或悲观锁）
    if topic.current_selected >= topic.capacity:
        raise HTTPException(status_code=400, detail="该课题名额已满")
    
    # 5. 创建申请记录
    new_application = SelectionRecord(
        student_id=current_user.id,
        topic_id=topic_id,
        status=SelectionRecordStatus.APPLIED
    )
    db.add(new_application)
    # 注意：这里暂时不更新 topic.current_selected，等导师确认后再更新
    db.commit()
    db.refresh(new_application)
    return {"msg": "申请提交成功", "application_id": new_application.id}

class AuditLog(Base):
    __tablename__ = "audit_logs"
    id = Column(Integer, primary_key=True)
    user_id = Column(Integer, ForeignKey("users.id"))
    action = Column(String(100))           # 例如："TOPIC_APPLY", "GRADE_UPDATE"
    details = Column(Text)                 # 变化详情，JSON 字符串为宜
    ip_address = Column(String(45))
    created_at = Column(DateTime(timezone=True), server_default=func.now())

基于 Python 的毕业设计管理系统架构与 AI 辅助开发实践

1. 先聊聊痛点：毕业设计管理为啥需要系统化？

2. 技术选型：为什么是 FastAPI + SQLAlchemy？

3. 核心模块实现细节与 AI 助攻点

3.1 用户角色与 JWT 鉴权

基于 Python 的毕业设计管理系统架构与 AI 辅助开发实践

1. 先聊聊痛点：毕业设计管理为啥需要系统化？

2. 技术选型：为什么是 FastAPI + SQLAlchemy？

3. 核心模块实现细节与 AI 助攻点

3.1 用户角色与 JWT 鉴权

更多推荐文章

相关免费在线工具

3.2 课题双向选择与防重复提交

4. 安全性分析与性能考量

5. 生产环境避坑指南

6. 总结与延伸思考

更多推荐文章

相关免费在线工具