Java+SSM+Flask少儿编程在线培训系统设计：代码评测与实战部署

1. 项目定位：少儿编程在线培训系统到底在做什么

先说一句实话，“少儿编程在线培训系统”这类题目，我在带学员做毕业设计和项目实战时见过不下几十个版本。但绝大多数都停留在“一个课程列表加一个视频播放页”的玩具水平。真正能让项目在答辩现场站得住脚、能让面试官多问几句的版本，一定是在“互动练习”这件事上做出了差异化。而标题里那句“Java+SSM+Flask”的组合，恰恰就是奔着这个目标去的。

这个项目本质上要做的事情并不复杂：给 6 到 16 岁的孩子提供编程课程，孩子可以在线看课、做练习，写完代码后提交到服务器运行，系统返回运行结果，教师和家长能看到学习进度。但“在线提交代码并运行”这一环，才是整个系统的分水岭。做得好的系统，学生提交 Python、C++ 代码后，服务器能真正执行，返回输出、报错信息、运行耗时；做得粗糙的系统，只能让学生把代码截图或者复制到留言框里，老师私下看，这根本算不上“在线编程培训”。

适合读这篇文章的人，我默认是两类：一类是正在做Java方向毕业设计的学生，手里拿到了类似题目，需要把技术路线理清楚，知道代码该怎么组织、服务该怎么搭；另一类是初入行的Java开发工程师，想了解一个真实在线教育系统里，SSM 后端和 Python 服务是怎么协作的，而不只是停留在写 CRUD 的层面。

接下来我按自己的实战经验，把这个项目从技术选型到部署排错完整拆一遍。文中涉及的目录结构、配置片段、代码思路，都是我实际带项目时验证过、可以继续沿用的方案。

1.1 从少儿编程场景反推系统需求

做系统设计之前，先别急着写代码。把业务场景捋清楚，后面所有的表结构和接口都会自然浮现出来。

少儿编程和成人编程培训最大的区别在于“课程分层”。市面上主流机构一般把课程划分为三层：低龄段以图形化编程为主（Scratch、Blockly 拖积木），这个阶段不涉及真实代码；中龄段开始接触 Python，主要用于培养逻辑思维；高龄段转向 C++，很多是奔着信息学竞赛去的。所以一个完整的在线培训系统，课程体系至少要能承载这几种形态：录播/直播课、图文讲义、在线编程练习、作业提交与批改。

用户的角色也和我们平时做的后台管理系统不一样。它不是简单的“管理员-用户”两级，而是会拆出学生、教师、教务管理员，甚至家长端。学生端关注报课、看课、做练习、查成绩；教师端关注课程上架、作业批改、查看班级学习统计；管理端关注讲师管理、课程审核、订单和营收数据。如果做毕业设计，家长端不一定要完整实现，但数据模型里至少要预留监护人绑定的字段，否则答辩时被问到“怎么体现少儿属性”会卡壳。

核心业务链路是这样一条线：学生登录 → 浏览选择课程 → 学习课时内容 → 进入编程练习 → 编写代码并提交 → 后端评测并返回结果 → 教师查看/批改 → 家长查看学习报告。这条链路上，最重的技术点在“代码提交与运行评测”，也就是标题里用 Flask 来做的那部分。

1.2 为什么偏偏是 SSM + Flask，而不是 SpringBoot 全家桶

很多同学拿到题目后第一反应是：Java 就 Java，为什么要搭配一个 Flask？这不是给自己找麻烦吗？

我理解这种疑问，但实际分析下来，这个组合不但不麻烦，反而很合理。先说 SSM 部分。SSM 指的是 Spring + SpringMVC + MyBatis 三个框架的组合，在 2015 年到 2020 年之间，它是 Java 企业级开发绝对的统治性方案。虽然现在新项目都在往 SpringBoot 上迁移，但大量存量系统、教学资料、面试题里，SSM 依然是出场率极高的关键词。做毕业设计选 SSM，最大的好处是“资料多、论文好写、答辩好讲”，框架本身的原理（IoC 容器、AOP、DispatcherServlet、MyBatis 动态代理）都是面试官爱问的点，不管你是真的熟练还是对着文档调通，都有话可说。

再说 Flask 部分。这里有个关键认知：Flask 不是用来替代 SSM 的，它在系统里单独扮演一个“代码评测网关”的角色。在线编程系统最核心的技术难点，是服务器需要动态执行学生提交的代码。这个过程涉及创建子进程、限制 CPU 和内存、捕获标准输出、处理超时，这些能力在 Python 生态里简直是为所欲为：subprocess 调用外部编译器，resource 模块限制资源占用，一行 psutil 就能解决进程监控。而如果用 Java 来实现同样的事情，要处理 Runtime.exec 的各种边缘情况，要自己做进程树清理，代码量和坑位都成倍增加。

所以最务实的架构是：业务主站（用户、课程、订单、权限、数据统计）用 SSM 来实现，因为这部分是典型的业务管理系统，Java 的工程化优势明显；在线评测服务用 Flask 来写，因为这部分是典型的运维型、进程型任务，Python 的处理效率最高。两部分通过 HTTP 接口通信，互不干扰。等到项目扩展到大并发阶段，评测服务还能独立部署成集群，这也符合真实互联网公司“核心业务与重计算服务分离”的思路。

说实话，我第一次见到这种设计时也怀疑是拼凑，但后来在企业里看到真实的生产环境：主站 Java、推荐服务 Python、算法网关 Go 写……才发现不同语言各管一段才是常态。这个项目标题恰好把两种典型的语言选型放在了一起，反而成了一个很有话可讲的技术亮点。

1.3 数据库选型与核心表结构设计

数据库这块，我强烈建议用 MySQL 5.7 或 8.0，这两个版本在 SSM 生态下最稳定，网上踩坑资料也最全。不要为了追求“新”去选 PostgreSQL，虽然它也很好，但毕业设计场景下，时间成本才是最贵的，没必要为了实验性而冒险。

核心表建议拆成这几组：

用户域：sys_user（用户主表）、sys_role（角色表）、sys_user_role（用户角色关联表）、student_info（学生扩展信息，含家长手机号、年级）、teacher_info（教师扩展信息）。

课程域：course（课程主表）、course_chapter（课时章节表）、course_type（课程分类，对应图形化/Python/C++）、course_order（订单表，含支付状态）。

练习域：exercise（练习题表，含题目描述、输入输出样例）、exercise_submit（提交记录表，含代码内容、评测状态、运行结果、耗时）、exercise_case（评测用例表，含输入和期望输出）。

学习域：study_progress（学习进度表，记录课时完成情况）、homework（作业表）、homework_submit（作业提交与批改记录）。

这六组表基本能覆盖系统所有核心功能。有一个特别容易忽视的设计点：提交记录表要存“代码内容”的副本，而不是关联出一个 code_id 指向别处。道理很简单，学生提交的代码是历史快照，如果之后题目改了或者代码被清理了，历史记录就无法追溯，教师的批改就失去了上下文。数据表设计时，凡是“记录”性质的数据，尽量保留现场快照，这是我从真实上线项目里总结出来的原则。

2. 核心模块拆分与功能实现要点

系统功能模块从用户视角分三条线：前台学习线、后台管理线、评测服务线。下面一条一条拆开讲，每一步都说清楚“为什么这么做”以及“要注意什么”。

2.1 学员端学习链路：从注册登录到代码提交

学生端的功能链看似常规，但在少儿编程场景下有几个细节值得注意。

第一，注册登录。建议用手机号加验证码的方式，而不是用户名密码。原因很简单：用户是未成年人，他们大概率记不住复杂密码，而家长在旁协助时，手机验证码是最低门槛的验证方式。当然真要做验证码发送需要接入短信服务商，考虑成本，毕业设计阶段可以在代码里内置一个“万能验证码”或者把验证码打印到日志里，但接口设计上要保持真实对接的可能性。

第二，课程学习页。推荐采用“章节制”，每一章包含一个视频或图文讲义，然后紧跟一组练习。学生在进入练习前必须先标记完成课时学习，这个进度记录写到 study_progress 表。这个小逻辑很朴素，但它是学习报告、家长端“学了多少”的数据来源，设计时要留好。

第三，在线编程练习。这是整个系统最体现水平的功能。页面上引入一个代码编辑器组件，我实际用得最多的是 CodeMirror，比 Monaco Editor 轻量，而且支持 Python、C++、Java 等语言的语法高亮，对 IE 的兼容也做好过。编辑器下方是一个控制台区域，显示评测结果。前端发送代码到后端的流程是：点击提交 → JS 把代码字符串和题目 ID POST 到 SSM 的 /submit 接口 → SSM 落库生成一条 pending 状态的提交记录 → 然后再转调 Flask 服务执行评测 → 同步或异步拿到结果后更新记录并返回给前端。

这里要提醒一个经常出问题的地方：代码字符串中带有换行、引号、特殊字符，在 JSON 传输时很容易被转义搞坏。建议前端提交时统一用 Base64 编码一次，后端再解码，能省掉大量莫名其妙的乱码和截断问题。这一点在调试时极容易踩坑，我先写在这里，后面排错部分还会详细说。

2.2 管理端设计：课程、讲师、统计三大块

管理端如果用四个字概括，就是“越权即崩”。少儿培训机构的运营人员通常不是技术人员，所以权限模型不能太复杂，但也不能不设防。我的建议是走经典的三层：教务管理员可以管一切；讲师只能管自己的课程和作业；教务主管可以看全部数据但不能改核心课程定价。用 SpringMVC 拦截器加角色注解就能实现，不一定要上 Shiro 或 Spring Security，除非你答辩时想讲权限框架原理，再加不迟。

课程管理模块包含三个核心操作：课程发布、章节维护、题目关联。发布课程时要支持封面上传，这里建议用本地存储路径加 Nginx 静态映射的方式，不要为了图方便把图片存数据库 BLOB 字段，性能和代码可维护性都很差。在课程编辑页面里，讲师可以选择已有的练习题，也可以临时创建新题，题目结构最好支持多组输入输出用例，因为评测逻辑需要多组数据对比才能判定正确。

统计报表这个模块，别做得太复杂，但一定要有。少儿编程机构高频看的三个数据是：课程报名人数趋势、练习完成率、代码评测通过率。用 MyBatis 写几条聚合查询就能搞定，返回给前端用 ECharts 渲染柱状图和折线图。答辩时这一块很容易成为加分项，因为评委一看就知道你懂业务，不是只会写 CRUD。

2.3 在线评测服务的实现细节：Flask 如何真正跑起来

这是整个项目的灵魂，也是很多同学没有底气的地方。我用一个相对完整的方案讲清楚。

Flask 服务独立运行在某个端口（比如 5000），它只对外开放两个接口：/health 用于健康检查，/run 用于执行代码。接收的参数是：language（python/java/cpp）、code（Base64 解码后的源码）、timeout（超时秒数）、memory_limit（内存上限，单位 MB）。返回的结果包含：success 布尔值、stdout 输出、stderr 错误信息、exit_code 退出码、run_time 毫秒耗时。SSM 调用它时用 RestTemplate 或者 HttpClient 发送 POST 请求，连接超时设置成 5 秒，读取超时设置得比评测超时略大，防止学生提交死循环代码时把 Java 后端线程也拖死。

核心执行逻辑用 Python 的 subprocess 实现，大概思路是：把源码写入临时目录 → 按语言选择命令（c++ 用 g++ 编译后运行，java 用 javac 编译后运行 java，python 直接 python 运行）→ subprocess.run 传入 timeout 参数 → 捕获 stdout 和 stderr → 结束后清理临时文件。

安全方面要注意三点：一是绝对不要用 root 用户运行 Flask 服务，要单独建一个低权限的系统账号，这样即使学生提交了恶意代码，也无法把服务器搞崩；二是临时目录要给每个提交生成一个唯一子目录（用 UUID），学生代码里即使写死路径也影响不到别人；三是 C++ 编译时要加 -fno-stack-protector 之类的安全编译选项吗？不，恰恰相反，应该默认加 -O2 -static 就好，安全选项的复杂度远超本文范围，但我们至少要确保程序运行不了 root 权限。

这里放一个最精简的 Flask 执行器示例，帮助理解整体流程。

python复制@app.route('/run', methods=['POST'])
def run_code():
    data = request.get_json(force=True)
    language = data.get('language')
    code = base64.b64decode(data.get('code')).decode('utf-8')
    timeout = int(data.get('timeout', 5))

    workdir = f'/tmp/judge/{uuid.uuid4().hex}'
    os.makedirs(workdir, exist_ok=True)
    try:
        if language == 'python':
            src_file = os.path.join(workdir, 'main.py')
            with open(src_file, 'w', encoding='utf-8') as f:
                f.write(code)
            cmd = ['python3', src_file]
        elif language == 'cpp':
            src_file = os.path.join(workdir, 'main.cpp')
            with open(src_file, 'w', encoding='utf-8') as f:
                f.write(code)
            compiler = subprocess.run(['g++', src_file, '-o', workdir + '/main', '-O2'],
                                      capture_output=True, timeout=timeout)
            if compiler.returncode != 0:
                return jsonify(success=False, stderr=compiler.stderr.decode('utf-8', errors='ignore'))
            cmd = [workdir + '/main']
        elif language == 'java':
            src_file = os.path.join(workdir, 'Main.java')
            with open(src_file, 'w', encoding='utf-8') as f:
                f.write(code)
            compiler = subprocess.run(['javac', src_file], capture_output=True, timeout=timeout)
            if compiler.returncode != 0:
                return jsonify(success=False, stderr=compiler.stderr.decode('utf-8', errors='ignore'))
            cmd = ['java', '-cp', workdir, 'Main']
        else:
            return jsonify(success=False, stderr='unsupported language')

        start = time.time()
        proc = subprocess.run(cmd, capture_output=True, timeout=timeout,
                              cwd=workdir, env={})
        elapsed_ms = int((time.time() - start) * 1000)
        return jsonify(success=True,
                       stdout=proc.stdout.decode('utf-8', errors='ignore'),
                       stderr=proc.stderr.decode('utf-8', errors='ignore'),
                       exit_code=proc.returncode,
                       run_time=elapsed_ms)
    except subprocess.TimeoutExpired:
        return jsonify(success=False, stderr='timeout exceeded, your code was killed')
    except Exception as e:
        return jsonify(success=False, stderr=str(e))
    finally:
        shutil.rmtree(workdir, ignore_errors=True)

这段代码只保证最基础的执行能力，生产环境中还需要配合 cgroup、seccomp 等更严格的控制，但对毕业设计来说，能跑通并讲清楚原理已经完全够用。如果你想让项目看起来更完整，可以在 Flask 端加入“沙箱隔离”的说明，不一定真的实现 Docker 容器，但至少要在文档中阐述这层设计思路，这在答辩时很加分。

3. 环境搭建、联调与部署全流程实操记录

下面这部分是真正动手的过程记录。照着走一遍，能省掉大量搜索报错的时间。我自己按这个流程走过不下五次，每次都能稳定跑通。

3.1 开发环境与版本选型

建议这样搭配，兼容性经过验证：

这里要强调一个经验：不要为了追新版本而盲目升级。SSM + JDK 8 + Tomcat 8.5 这个组合网上资料最丰富，遇到任何问题一搜就有答案。用 JDK 17 跑老 SSM 项目，光 module-access 报错就够你折腾一晚上，完全没必要。

3.2 SSM 工程搭建与核心配置文件

创建 SSM 工程推荐用 Maven 的 war 包结构，目录如下：

code复制src/main/java
  ├── com.example.controller
  ├── com.example.service
  ├── com.example.service.impl
  ├── com.example.mapper
  ├── com.example.entity
  └── com.example.common
src/main/resources
  ├── jdbc.properties
  ├── mybatis-config.xml
  ├── spring-mvc.xml
  └── applicationContext.xml
src/main/webapp
  └── WEB-INF

核心依赖在 pom.xml 中，贴出最关键的几项：

xml复制<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.49</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.22</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.11.3</version>
    </dependency>
</dependencies>

注意 MySQL 驱动版本：如果数据库是 MySQL 5.7，用 5.1.49 就好；如果数据库是 8.0，需要切换成 8.0.33，同时 jdbc.url 里加 serverTimezone=Asia/Shanghai 和 allowPublicKeyRetrieval=true。这个坑极其常见，后面问题排查部分还会强调。

spring-mvc.xml 中的核心配置是注解扫描和视图解析器：

xml复制<context:component-scan base-package="com.example.controller" />
<mvc:annotation-driven />
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/" />
    <property name="suffix" value=".jsp" />
</bean>
<mvc:default-servlet-handler />

这里有个值得展开的细节：<mvc:default-servlet-handler /> 一定要加。不加的话，项目里的静态资源（CSS、JS、图片）全部会被 DispatcherServlet 拦截，页面样式丢得一干二净，很多人折腾半天找不到原因。

applicationContext.xml 里主要配置数据源、SqlSessionFactory 和事务管理器。MyBatis 的 mapper.xml 文件建议放在 resources 下的 mapper 目录，并在 SqlSessionFactory 配置中指定 mapperLocations：

xml复制<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="configLocation" value="classpath:mybatis-config.xml" />
    <property name="mapperLocations" value="classpath:mapper/*.xml" />
</bean>

3.3 Flask 评测服务与 SSM 的联调方式

Flask 服务单独启动后，SSM 这边要封装一个 RemoteJudgeClient。我建议不要把调用细节写在 Service 里，而是单独建一个 judge 包，里面放一个 RestTemplate 配置类和一个调用方法。这样即使以后把评测服务换成其他地址，只改一处配置即可。

java复制@Service
public class JudgeClient {
    @Value("${judge.base-url}")
    private String judgeBaseUrl;

    public JudgeResult submit(String language, String code, int timeout) {
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        Map<String, Object> body = new HashMap<>();
        body.put("language", language);
        body.put("code", Base64.getEncoder().encodeToString(code.getBytes(StandardCharsets.UTF_8)));
        body.put("timeout", timeout);
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(body, headers);
        try {
            ResponseEntity<JudgeResult> response = restTemplate.postForEntity(
                    judgeBaseUrl + "/run", request, JudgeResult.class);
            return response.getBody();
        } catch (ResourceAccessException e) {
            return JudgeResult.fail("评测服务不可用，请稍后重试");
        }
    }
}

联调时需要注意的是统一字符编码。SSM 的 POST 请求默认可能使用 ISO-8859-1 编码传递中文注释，导致 Flask 端收到乱码。我的做法是在 SSM 的 CharacterEncodingFilter 里强制 UTF-8，同时在前端提交前对代码 Base64 编码，双保险下乱码问题基本绝迹。

workflow 总结：

1. 启动 MySQL，初始化数据库脚本
2. 启动 Flask：python app.py，验证 curl POST /run 能返回结果
3. 启动 Tomcat，SSM 工程自动加载
4. 在管理端创建课程和题目
5. 学生端提交一段 Python 打印代码，观察流程日志

如果能走通以上五步，说明项目主干已经通了。剩下的就是细节打磨：页面样式、数据校验、异常提示。

3.4 Linux 服务器部署要点

学校一般要求把项目部署到服务器上演示，这里给出一个经过验证的部署流程。

在服务器上规划三个目录：/opt/java-app 放 Tomcat 和 war 包，/opt/flask-app 放 Flask 代码和虚拟环境，/data/uploads 放课程封面。Nginx 监听 80 端口，把 /api/ 前缀的请求转发到 Tomcat 8080，把 /judge/ 前缀的请求转发到 Flask 5000，静态资源直接读取 /data/uploads。

Flask 部分用 gunicorn 启动，而不是直接用 python app.py，原因在于 gunicorn 有 worker 进程管理能力，一个 worker 挂了会自动拉起。启动命令示例：

bash复制cd /opt/flask-app
source venv/bin/activate
gunicorn -w 2 -b 127.0.0.1:5000 app:app --daemon

这里有个值得提醒的坑：gunicorn 默认配置下，子进程执行编译器时可能受工作目录影响。一定要在 Flask 代码中的临时目录 context 下执行 subprocess，否则可能出现“g++ 编译失败”但本地测试通过的现象。最简单的排查方法是在编译命令后加 print(cwd)。

Nginx 反向代理的关键配置如下：

nginx复制server {
    listen 80;
    server_name your-domain.com;

    location / { proxy_pass http://127.0.0.1:8080; }
    location /judge/ { proxy_pass http://127.0.0.1:5000; }
}

小型演示系统，这套配置完全够用。如果你想展示更强的部署能力，可以把 MySQL 也装在同一台机器上，并在文档中画出三层的部署架构图，答辩时会给评委留下“能落地”的印象。

4. 高频问题排查与调试文档整理经验

我按项目推进顺序，把最常遇到、最浪费时间的问题整理成速查表，每个问题都附上排查思路和解决方案。这些内容不仅是调试手册，也是你写“调试文档”“说明文档”时的骨架材料。

4.1 SSM 开发阶段的高频报错

这里面的 MyBatis BindingException 尤其值得多说一句。很多人遇到这个错误第一反应是去翻 XML，但实际原因往往是 Maven 编译时没有把 resources 目录下的 XML 复制到 target 目录。检查方法很简单：打开 target/classes 目录，看 mapper 文件夹下有没有对应 XML。没有的话，在 pom.xml 的 build 节点中加资源声明，把 src/main/java 下的 XML 也纳入编译范围。

4.2 SSM 调用 Flask 评测服务的问题

这是整个项目运行时最容易出问题的环节，我把常见情况列出来：

第一，Flask 返回 502 或连接超时。先确认 Flask 服务是不是 gunicorn 启动的，再 curl 一下 /health 接口。如果 curl 通而 SSM 转发不通，多半是 Nginx 配置里 proxy_pass 的路径少了末尾斜杠，导致路径拼接错误。

第二，提交的代码包含特殊字符导致 JSON 解析失败。现象是 Flask 端直接抛 400 Bad Request。解决方案就是我前面强调的 Base64 编码，让代码内容变成纯 ASCII 字符串，所有特殊字符的解析问题一次性解决。

第三，Python 代码中的中文输出在返回时变成乱码。这是因为 stdout 的编码格式受到系统 locale 影响，Flask 在 decode 时要用 errors='ignore' 兼容非 UTF-8 字符。如果你希望更严谨，可以在执行 Python 前设置 PYTHONIOENCODING=utf-8 环境变量。

第四，超时逻辑失效。subprocess.run 的 timeout 参数确实会抛出 TimeoutExpired，但它只能终止当前等待的调用，并不能保证把子进程树全部杀掉。如果学生代码里通过 subprocess 又启动了其他程序，那会留下孤儿进程。稳妥的做法是用 start_new_session=True 让子进程进入新的进程组，然后在 timeout 异常时 os.killpg 整个组。

4.3 代码编辑器与前端联调的一些细节

前端这块我踩过几个比较隐蔽的坑，提出来供参考。CodeMirror 实例在页面初始化时，如果 DOM 元素是隐藏的，渲染后可能出现显示不全。解决方案是在切换到练习 Tab 时主动调用 editor.refresh()。另一个常见问题是编辑器里代码的缩进会被浏览器吃掉，提交时需要用 \t 或空格替代。

还有，前后端分离时跨域问题几乎必然遇到。如果你不想在 SpringMVC 里写 CORS 配置类，最简单的办法是在 Nginx 层统一配置跨域头：

nginx复制add_header Access-Control-Allow-Origin *;
add_header Access-Control-Allow-Methods 'GET, POST, OPTIONS';
add_header Access-Control-Allow-Headers 'Content-Type, Authorization';

这样 SSM 和 Flask 都不用处理 CORS，所有请求都走 Nginx 这个大门，干净统一。

4.4 调试文档和说明文档该怎么整理

标题里提到“LW+调试文档+讲解”，这里的 LW 一般指论文或项目文档。我强烈建议把排查经验直接沉淀到调试文档里，不要单独另写。一个结构清晰的调试文档包含五部分：

1. 环境版本清单（JDK、Maven、Tomcat、MySQL、Python、Flask 逐一列出）
2. 启动步骤（从初始化数据库到启动 Flask 再到启动 Tomcat，每一步附带验证方式）
3. 核心接口清单（每个 Controller 方法和 Flask 接口的 URL、参数、返回结构）
4. 常见问题速查表（就按上面那几类问题整理，每个问题带原因和解决动作）
5. 演示数据说明（预置一个学生账号、一个教师账号、若干门课程和题目，方便答辩时快速演示）

这份文档对你的作用不只是应付交付，更是你自己的排障手册。我每次带项目都要求学生亲手重写一遍，因为“写不进文档的问题，就是没真正搞懂的问题”。

演示路径也要提前演练：从学生登录开始，选课，看一节视频，进入练习页，提交一段能正确运行的 Python 代码，再提交一段有语法错误的 C++ 代码，展示评测结果的差异。最后切到教师端查看提交记录和批改。整个过程控制在五分钟以内，重点突出“代码能真正运行”这个差异化亮点。

5. 一些拿得出手的扩展方向

项目做完以后，如果你想让它更有竞争力，有三个扩展方向是我比较推荐的，性价比依次递增。

方向一：加入图形化编程模块。低龄段孩子不会写代码，但可以拖积木。你不需要自己实现 Blockly，只需要引入 Google 的 Blockly 开源库，把积木块映射成 WeDo、Python 或 JavaScript 代码。这一块做到“能拖动、能生成代码、能提交评测”，项目就有了区别于其他毕设的鲜明特色。

方向二：加入学习报告生成。根据提交记录表统计学生的通过率、平均耗时、错题知识点，生成一张可视化报告页面。这个功能在家长端很能打，因为家长看不懂代码，但看得懂“通过率 85%，超过班级平均”这样的指标。实现上就是几条复杂一点的 SQL，成本低但业务表现力强。

方向三：评测服务升级为异步队列。当前同步调用在并发量上来后会卡死线程，一个死循环代码就可能拖垮整个 Tomcat。优化方式是引入消息队列，比如 RabbitMQ 或 Kafka，学生提交代码后立刻返回“评测中”，评测完成后通过 WebSocket 推送结果。这个设计如果能在答辩时讲清楚，评委基本不会再问你 “数据量大了怎么办”这类问题。

我的实际体会是，评价一个毕业设计项目的标准，从来不是“用了多新的技术”，而是“你能不能把一个完整的故事讲圆”——业务背景、技术选型、核心难点、解决方案、演示效果，每个环节都能自圆其说。这个选题恰好提供了天然的完整叙事：少儿编程火、在线教育火、真实代码评测有难度、SSM+Flask 有亮点，你只需要沉下心把每个环节都做扎实，它就能成为一份拿得出手的作品。

最后分享一个我调试时常用的小技巧：在 Flask 端加一个 DEBUG 路由，接收 JSON 并原样回显，用来快速定位是参数解析问题还是业务逻辑问题。这个接口虽然不起眼，但联调时能省下一个下午的时间。