一次搞定：Spring Boot + 微信小程序的智慧校园选课系统是怎么从零落地到毕设/实际项目的

如果你正在做毕业设计，或者公司里突然接到“做一个校园选课小程序”这种需求，多半会跟我当初一样：打开 IDEA 新建项目，看着空荡荡的代码区默默抽烟。这玩意儿看着不算复杂，但真正动手才发现——学生端、教师端、管理端、微信授权、选课并发、数据库设计、还有那小程序的审核机制……哪一个单拎出来都能讲半天。

这篇文章就用一个实际交付过的 java springboot 基于微信小程序的智慧校园系统学生选课程学习 项目做底子，把它拆开揉碎，讲清楚：为什么选这套技术栈、表结构怎么设计、学生选课学习整个流程怎么跑通、哪些地方容易踩坑、以及代码和文档里通常不会写明白的细节。无论你是拿来当毕设模板，还是想快速搭一个校园类小程序的后端，这篇文章都能节省你几天的摸索时间。

先说结论：这套系统的最佳组合是 Spring Boot（后端 API 服务）+ 微信小程序原生（前端展示与交互）+ MySQL（数据存储）+ Redis（选课并发控制） 。选课场景本质是“短时间高并发写操作”，不把并发控制想清楚，等到选课日系统炸了再改，就真的晚了。

1. 项目整体设计与技术选型思路

1.1 为什么选 Spring Boot，而不是 SSH 或 SSM

很多人纠结要不要用 SSM（Spring MVC + Spring + MyBatis），或者干脆上手最新的 Spring Cloud。我的建议很直接：毕设或中小型校园系统，Spring Boot 2.7.18 + JDK 1.8 是最稳的组合。原因很简单：

• 内嵌 Tomcat，不需要单独装容器，打包成 jar 就能跑，演示和部署都省事。
• 自动配置机制让你的数据源、Redis、MyBatis 集成代码量降到最低。
• 生态最成熟，遇到问题搜解决方案一搜一大把。你要是用个 Spring Boot 3.4 + JDK 21，配置都能给你烤糊（后面我会细说版本坑）。

这个项目里我用的具体版本组合是：Spring Boot 2.7.18、MyBatis-Plus 3.5.3.1、MySQL 8.0.33、Redis 6.x、Maven 3.8.x。别小看版本锁定这件事，很多同学代码写的没问题，最后挂在依赖冲突上，一调就是两三天。

1.2 微信小程序端：原生开发还是 uni-app

智慧校园系统涉及到的前端页面主要是：首页、课程列表、课程详情、选课确认、我的课表、在线学习（视频/文档）、个人中心。这些页面在原生小程序里实现并不复杂，而且原生小程序能直接用微信官方的 wx.login、wx.request、wx.getUserProfile 等能力，调试最直接。

如果你是同时要出 H5 版、App 版，那可以考虑 uni-app。但单纯做微信小程序，原生体验最顺手，文档最全，遇到问题也更容易排查。另外，从答辩角度讲，原生小程序代码每一行都能讲明白，评委会觉得“你确实是自己做的”。

1.3 数据库设计的整体规划

整个系统我设计了 7 张核心表，外加 2 张扩展表。这里直接贴出整体规划：

补充的两张扩展表是 admin（管理员表）和 course_chapter（课程章节表，用于在线学习模块）。

核心关联关系：学生与课程是多对多，通过 student_course 表关联；课程与教师是多对一；课程与课程安排是一对一（一门课一周只有一个固定的上课时间，实际操作中如果需要多个时间段，可以拆成多个 schedule 记录）。

1.4 选课模块的并发方案选型

这是整个系统技术上最有含金量的部分，也是面试官或者答辩老师最喜欢追问的地方。

选课场景的核心矛盾是：某个课程容量 100 人，结果报了 300 人，如果你用最普通的“先查询是否已满，再插入选课记录”的逻辑，300 个并发请求同时进来，全都能查到“还剩几个名额”，然后全都能插入成功，最后发现选了 300 人——这就是典型的超卖问题，跟电商秒杀一个道理。

处理方案我用的是 前置 Lua 秒杀式校验 + Redis 预热库存 + 数据库最终一致性。简单解释就是：

1. 选课开始前，把课程容量导入 Redis，用 INCR/DECR 做原子扣减。
2. 选课请求先进 Redis 执行一次扣减，扣减成功才写数据库。
3. 数据库层面用唯一索引兜底（student_id + course_id 唯一），保证同一个学生不可能重复选同一门课。

这套方案能扛住至少几百人同时选的场景，而且代码量不大。具体代码在第 3 部分详细讲。

2. 核心功能模块拆解与实操要点

2.1 登录认证：小程序 wx.login 到后端 openid 的完整链路

登录这个点，几乎所有第一次做小程序后端的人都会卡住。卡住的原因不是多难，而是对流程不熟：小程序端 wx.login() 拿到一个 code，这个 code 只能用一次，而且有效期很短（大约 5 分钟）。后端拿这个 code 去微信接口 https://api.weixin.qq.com/sns/jscode2session 换 openid 和 session_key。

关键代码：

java复制// WxLoginController.java
@PostMapping("/wx/login")
public Result login(@RequestBody LoginRequest request) {
    // 1. 用 code 请求微信接口
    String url = "https://api.weixin.qq.com/sns/jscode2session?appid=" + appId
            + "&secret=" + appSecret
            + "&js_code=" + request.getCode()
            + "&grant_type=authorization_code";

    String response = restTemplate.getForObject(url, String.class);
    JSONObject json = JSON.parseObject(response);
    String openid = json.getString("openid");
    String sessionKey = json.getString("session_key");

    if (openid == null) {
        return Result.error("微信登录失败，请重试");
    }

    // 2. 查数据库：该 openid 是否已绑定学生或教师
    Student student = studentMapper.selectOne(new LambdaQueryWrapper<Student>()
            .eq(Student::getOpenid, openid));
    if (student == null) {
        // 未绑定，返回提示，前端引导绑定学号
        return Result.error("该微信未绑定学生账号", 1001);
    }

    // 3. 生成自定义登录态 token，返回给前端
    String token = JwtUtil.generateToken(student.getId());
    return Result.success(new LoginVO(token, student));
}

这个接口里面有两个容易踩的坑。

第一个坑：restTemplate 调微信接口必须设置超时时间。默认的 RestTemplate 没有超时限制，如果微信接口响应慢（网络问题），你的 Tomcat 线程会被挂住，积累多了整个服务就凉了。我给这个项目配了专门的 RestTemplate Bean，连接超时 3 秒、读取超时 3 秒。

第二个坑：openid 是每个小程序每个用户唯一的，但同一个用户用不同的小程序登录，openid 是不同的。如果你的系统可能要做多个小程序端互通（比如一个面向学生、一个面向教师），那就要考虑用 unionid，但这需要开放平台账号，普通毕设项目不折腾它。

登录后的每个接口请求，小程序端在 header 里带 Authorization: Bearer {token}，后端用拦截器解析 token。注意：这个 token 是我们自己发的，不是微信给的东西，合理过期时间建议设置为 7 天，学生不需要每天重新登录。

2.2 选课核心流程：从课程列表到选课成功的完整实现

选课流程的前端界面交互比较多，但核心在后端接口。完整流程是这样的：

小程序端进入“选课中心” -> 调用课程列表接口（带院系、学分、上课时间筛选） -> 点击某门课进入详情 -> 点击“选课”按钮 -> 调后端选课接口 -> 成功则更新“我的课表”。

后端选课接口的完整代码是重点，直接贴出来（这里去掉了实体类定义，只保留核心逻辑）：

java复制// CourseController.java
@PostMapping("/select")
public Result selectCourse(@RequestParam Long courseId, @RequestParam Long studentId) {
    String stockKey = "course:stock:" + courseId;
    String userKey = "course:selected:" + studentId;

    // 1. Lua 脚本原子性判断：是否已选过 + 库存是否足够
    String luaScript =
            "if redis.call('sismember', KEYS[2], ARGV[1]) == 1 then " +
            "  return -1 " +
            "end " +
            "if tonumber(redis.call('get', KEYS[1]) or '0') <= 0 then " +
            "  return -2 " +
            "end " +
            "redis.call('decr', KEYS[1]) " +
            "redis.call('sadd', KEYS[2], ARGV[1]) " +
            "return 1";

    Long result = redisTemplate.execute(
            new DefaultRedisScript<>(luaScript, Long.class),
            Arrays.asList(stockKey, userKey),
            studentId.toString()
    );

    if (result == -1) {
        return Result.error("您已选择该课程，请勿重复选课");
    }
    if (result == -2) {
        return Result.error("课程名额已满");
    }

    // 2. 写数据库（事务）
    try {
        selectCourseService.saveStudentCourse(studentId, courseId);
        return Result.success("选课成功");
    } catch (DuplicateKeyException e) {
        return Result.error("您已选择该课程，请勿重复选课");
    } catch (Exception e) {
        // 数据库写入失败，回补 Redis
        redisTemplate.opsForValue().increment(stockKey);
        redisTemplate.opsForSet().remove(userKey, studentId.toString());
        return Result.error("选课失败，请重试");
    }
}

代码里注释已经很清晰了，但我还是要说三个关键点：

Lua 脚本解决了“判断+扣减”不是原子操作的问题。如果不把“检查是否已选过”“检查库存是否足够”“扣减库存”这三步放进同一个 Lua 脚本，那么在高并发下就会乱套：两个请求同时通过“是否已选过”检查，两个都进到扣减环节，最后一个学生就选了两门相同的课。用 Lua 是因为 Redis 能保证脚本执行期间其他命令不会插入执行，这就是原子性。

数据库最终一致性怎么保证。Redis 扣减成功了，不代表数据库就一定写成功。万一数据库插入时发现异常（比如连接池满了），就得把 Redis 里的库存和已选标记回补回去。这个回补逻辑是最容易被忽略的，但恰恰是最重要的。

唯一索引是最后一道防线。我在 student_course 表加了一个 uk_student_course 唯一索引（student_id + course_id）。就算 Redis 被清空、Lua 脚本没有执行，只要数据库有唯一索引，重复选课照样插入不进去。

2.3 在线学习模块：课程章节、学习进度与视频播放

“选课程学习”中的“学习”这个环节，很多毕设项目只是做一个静态的课程展示页面，但既然题目带了“学习”，就应该有学习闭环：课程章节列表 -> 学习内容（视频/图文）-> 学习进度记录。

这一块技术的重点是学习进度的上报策略。前端每播放完一个视频片段（或者每阅读完一个章节），就上报一次进度。后端接口：

java复制// StudyController.java
@PostMapping("/progress/report")
public Result reportProgress(@RequestBody StudyProgressRequest request) {
    // 参数：studentId, courseId, chapterId, progress(0-100), duration
    StudyProgress progress = new StudyProgress();
    progress.setStudentId(request.getStudentId());
    progress.setCourseId(request.getCourseId());
    progress.setChapterId(request.getChapterId());
    progress.setProgress(request.getProgress());
    progress.setLastStudyTime(new Date());

    // 用 insert or update 逻辑
    studyProgressMapper.insertOrUpdate(progress);
    return Result.success();
}

这里要注意的是 insertOrUpdate 不能无脑用。学生可能反复观看同一章节，每次上报进度都是覆盖 update，但如果学生看了别的章节，就要 insert 新记录。我用的方法是：先按 student_id + course_id + chapter_id 查询，存在就 update，不存在就 insert。然后用 @Transactional 包住，保证一致性。

还有一个细节：视频播放的 URL 不要直接放公网地址，正常情况下课程视频应该走 OSS/CDN。毕设项目本地环境可以直接用小程序的内部文件路径或者自己服务器上的静态资源，但要注意小程序对域名和 HTTPS 是有强校验的（后面问题章节会讲）。

2.4 教师端与管理端：课程审核、选课名单导出

这个系统不是只有学生端，完整的智慧校园系统至少要有三个角色：学生、教师、管理员。

教师端核心功能：维护自己的课程信息（课程名称、学分、上课时间、容量）、查看选课学生名单、录入学生成绩。管理端的核心功能：学生信息导入（通过 Excel）、教师信息管理、课程审核上下架、公告发布。

这一块的逻辑都比较常规，但有两个实操细节很值得分享：

第一个细节：学生信息批量导入用 EasyExcel 而不是 POI。POI 写 Excel 的代码又臭又长，EasyExcel 一个监听器就能搞定，而且对大数据量友好。导入的模板我先在项目 resource 目录放了一个 student_import_template.xlsx，前端下载模板后填写再上传，避免格式不一致的麻烦。

第二个细节：教师提交课程后默认状态是“待审核”，只有管理员审核通过后学生才能看到这门课。这个流程看起来简单，但实际做的时候很多人会忽略，直接在教师提交的时候就同步上架，导致学生看到一堆乱七八糟的测试数据。加一个 status 字段（0 待审核 / 1 已通过 / 2 已驳回），成本很低，但对系统的完整性提升很大。

3. 实操过程与核心环节实现

3.1 开发环境准备：精确到版本的工具链清单

这个项目踩过最多的坑就是版本不匹配，这里把环境信息完整列出来，照着装不会出错：

（吐槽一句：热词里有“springboot版本太高”，这就是真实痛点。我看到很多人直接上 spring-boot-starter-parent 3.x，结果发现 springfox-swagger2 用不了、javax 变成 jakarta、Redis 配置方式全变了，直接在群里问“为什么报错”。新版本是好，但生态成熟度跟不上，搞项目不是玩火，稳定第一。）

3.2 后端项目结构：一个清晰的 package 划分模板

项目结构直接影响开发效率和后期维护。我用的是常见的分层结构，但做了一些适合小项目的调整：

txt复制src/main/java/com/example/smartedu
├── SmartEduApplication.java
├── config
│   ├── RestTemplateConfig.java        // 带超时时间的 RestTemplate
│   ├── RedisConfig.java               // RedisTemplate 序列化配置
│   ├── MybatisPlusConfig.java         // 分页插件配置
│   └── WebMvcConfig.java              // 拦截器注册、跨域配置
├── controller
│   ├── WxLoginController.java
│   ├── CourseController.java
│   ├── StudentCourseController.java
│   ├── StudyController.java
│   ├── TeacherController.java
│   └── AdminController.java
├── service
│   ├── CourseService.java
│   ├── StudentCourseService.java
│   └── impl
│       ├── CourseServiceImpl.java
│       └── ...
├── mapper
│   ├── StudentMapper.java
│   ├── CourseMapper.java
│   └── ...
├── entity
│   ├── Student.java
│   ├── Course.java
│   └── ...
├── common
│   ├── Result.java                    // 统一返回体
│   ├── ResultCode.java
│   ├── JwtUtil.java                   // JWT 工具类
│   ├── UserContext.java               // 线程变量，存放当前登录用户
│   └── GlobalExceptionHandler.java    // 全局异常处理
└── utils
    ├── ExcelUtil.java                 // 导入导出工具
    └── RedisKeyUtil.java              // Redis key 统一管理

几点说明：

• common 包一定要有统一的 Result 返回体。我见过不少人每个接口返回格式都不一样，前端对接时心态直接炸。统一成 { code: 200, msg: "success", data: {...} }，后面所有接口照这个格式来，一辈子不用改前端。
• 全局异常处理不要省。业务异常、参数异常、系统异常分开处理，前端拿到的错误信息才友好。我用 @RestControllerAdvice 统一处理，代码量 30 行左右，收益极大。
• JwtUtil 设计成静态工具类，提供 generateToken、parseToken、isExpired 三个方法，不需要注入任何 Bean，方便在拦截器和 Controller 里直接调。

3.3 数据库初始化脚本：直接可用的建表 SQL 关键片段

数据库脚本一般在项目根目录的 sql 文件夹里，我截取最关键的三张表：

sql复制CREATE TABLE `course` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `course_code` varchar(32) NOT NULL COMMENT '课程编号',
  `course_name` varchar(128) NOT NULL COMMENT '课程名称',
  `credit` decimal(3,1) DEFAULT NULL COMMENT '学分',
  `teacher_id` bigint DEFAULT NULL COMMENT '授课教师ID',
  `capacity` int NOT NULL DEFAULT 50 COMMENT '课程容量',
  `selected_count` int NOT NULL DEFAULT 0 COMMENT '已选人数',
  `status` tinyint NOT NULL DEFAULT 0 COMMENT '状态：0待审核 1已上架 2已下架',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_course_code` (`course_code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='课程表';

CREATE TABLE `student_course` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `student_id` bigint NOT NULL,
  `course_id` bigint NOT NULL,
  `status` tinyint NOT NULL DEFAULT 1 COMMENT '1已选 2已退选 3已结课',
  `select_time` datetime DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_student_course` (`student_id`, `course_id`),
  KEY `idx_course_id` (`course_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='选课记录表';

CREATE TABLE `study_progress` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `student_id` bigint NOT NULL,
  `course_id` bigint NOT NULL,
  `chapter_id` bigint NOT NULL,
  `progress` int NOT NULL DEFAULT 0 COMMENT '进度百分比 0-100',
  `last_study_time` datetime DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_student_chapter` (`student_id`, `course_id`, `chapter_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='学习进度表';

注意几个细节：

student_course 的唯一索引必须是 student_id + course_id，而不是只有其中一个字段，否则一个学生只能选一门课，或者同一门课选了多次。

course 表里的 selected_count 是一个冗余字段，用于前端列表展示和后台统计。它的更新时机是在选课事务提交成功后，用 AtomicInteger 累加，或者直接用数据库 UPDATE course SET selected_count = selected_count + 1 WHERE id = ?。不能用 Redis 里的库存直接覆盖 selected_count，因为 Redis 可能跟数据库存在短暂不一致（比如回补的场景）。

所有表的 create_time 都建议用 DEFAULT CURRENT_TIMESTAMP，少写很多 Java 代码。

3.4 前后端联调：小程序端的关键代码示例

小程序端的核心代码不复杂，但有一些涉及微信能力的细节需要注意。这里直接贴一个课程列表页面的核心 JS：

javascript复制// pages/course/list.js
const app = getApp();

Page({
  data: {
    courseList: [],
    loading: false,
    page: 1,
    hasMore: true
  },

  onLoad() {
    this.loadCourses();
  },

  loadCourses() {
    if (!this.data.hasMore || this.data.loading) return;
    this.setData({ loading: true });

    // 注意：token 从缓存获取，每个请求都要带上
    const token = wx.getStorageSync('token');
    wx.request({
      url: `${app.globalData.baseUrl}/api/course/list`,
      method: 'GET',
      data: { page: this.data.page, pageSize: 10 },
      header: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      },
      success: (res) => {
        console.log('课程列表响应:', res.data);
        if (res.data.code === 200) {
          const list = res.data.data.records;
          this.setData({
            courseList: this.data.courseList.concat(list),
            page: this.data.page + 1,
            hasMore: res.data.data.records.length === 10
          });
        } else if (res.data.code === 401) {
          // token 失效，跳转登录页
          wx.navigateTo({ url: '/pages/login/login' });
        } else {
          wx.showToast({ title: res.data.msg, icon: 'none' });
        }
      },
      fail: (err) => {
        console.error('请求失败:', err);
        wx.showToast({ title: '网络异常', icon: 'none' });
      },
      complete: () => {
        this.setData({ loading: false });
      }
    });
  },

  // 下拉加载更多
  onReachBottom() {
    this.loadCourses();
  }
});

这个页面有两个容易错的地方：

第一，wx.request 的 url 必须是小程序后台配置好的合法域名。在开发阶段，你可以勾选“不校验合法域名”，但一旦要真机预览或上线，就必须在小程序管理后台配置 https 域名。很多人忽略这个，结果开发工具里好好的，手机上一请求就报 url not in domain list。

第二，注意分页参数的命名和后端保持一致。我后端用的是 MyBatis-Plus 分页插件，默认参数名是 page（页码）和 pageSize，但很多人习惯用 current、size 或者 offset、limit。前后端参数不一致是最令人崩溃的错误之一，强烈建议确定一套参数命名规则并全局统一。

3.5 部署上线环节：从 jar 包到服务器的完整流程

部署这部分，我在项目文档里写了很详细的步骤，这里挑关键的说，因为这个地方能拦下一大半人。

后端部署：

1. 本地确认环境无误后，执行 mvn clean package -DskipTests 打包。注意：-DskipTests 不能少，否则有测试类可能会导致打包失败。
2. 将 target 目录下的 jar 包上传到服务器（云服务器或虚拟机都可以）。
3. 在服务器上安装 JDK 8 和 MySQL（我一般用宝塔面板管理，省去很多命令行操作）。
4. 启动命令：nohup java -jar smart-edu-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod > app.log 2>&1 &。
5. 配置 Nginx 反向代理，把 80 端口的 /api/ 转发到后端的 8080 端口。

前端（小程序）部署：

1. 在微信公众平台注册小程序账号，拿到 AppID。
2. 微信开发者工具中上传代码，填写版本号和备注。
3. 在公众平台提交审核，审核通过后发布。

这里具体的坑是：小程序的 request 合法域名必须是 HTTPS，并且需要在公众平台配置。如果你没有现成的 HTTPS 域名，开发阶段就先在“详情 -> 本地设置”里勾选“不校验合法域名”。我见过很多人一上来就卡在域名配置上，以为是代码问题，其实只是少配了一个域名。

4. 常见问题与排查技巧实录

4.1 疑难问题速查表

把真实项目里遇到的频率最高的问题整理成表，每个都是踩过的坑：

4.2 调试技巧：日志和断点的正确打开方式

排查问题最怕的就是“不知道系统里发生了什么”。我给这个项目配置了详细的日志体系：

在 application.yml 里设置：

yaml复制logging:
  level:
    com.example.smartedu: debug
    org.springframework.jdbc.core: debug

这样能在控制台看到完整 SQL 语句和参数值，排查 SQL 写错、参数没传的情况非常有用。

然后每个接口的入口都加上一句日志：

java复制log.info("【选课】学生ID: {}, 课程ID: {}, 时间: {}", studentId, courseId, LocalDateTime.now());

别小看这个习惯，等出了问题要靠日志定位时，你会感谢当时多写的这几行。

另外提醒一句：不要在生产环境把日志级别设为 debug，会刷爆磁盘。平时开发调试用 debug，部署时改成 info。

4.3 小程序首次体验的常见卡点

小程序这边容易卡住的一般是两个点：登录和权限。

登录的问题集中在“知道了 openid，但数据库里没有这个学生”这一步。场景是：学生第一次打开小程序，微信授权了，但系统里还没有他的账号记录。这时候正确的做法是引导输入学号和密码进行绑定，绑定成功后把 openid 写入 student 表。不要在“未绑定”时直接报错“用户不存在”，体验很差。

权限的坑在于：微信小程序的前端代码是能被人扒出来看逻辑的，所以不能在 onLoad 里直接判断一个 data 字段来决定是否展示某个按钮，真正的权限控制必须由后端接口完成。比如：课程管理功能，后端要有“当前登录用户是否为该课程教师”的校验，而不是前端传个 teacherId 后端就直接用。

4.4 性能优化实录：预热缓存与索引优化

这个项目一开始没做性能优化，等到模拟选课测试时，发现 200 个并发请求下数据库 CPU 直接飙到 90%，接口平均耗时 2 秒多。优化之后并发 500 也能稳定在 200ms 以内，怎么做的？两件事：

第一，Redis 预热库存。数据库 1000 门课，选课开始时从数据库把每门课的容量导入 Redis。这一步能显著降低数据库读压力，因为正常情况下选课接口的高频读是在“查库存”和“查是否已选”这两个操作上，这两件事搬到 Redis 里做，数据库只负责最终写入。

第二，给高频查询字段加索引。我检查了所有接口的执行计划，发现课程列表页的 course_name 模糊查询、选课记录表的 student_id 关联查询都存在全表扫描。后来给 course.course_name 加了普通索引，给 student_course.student_id 加了索引，查询时间从 150ms 降到了 10ms 左右。不要觉得数据量小就不用索引，这不是省事，是给未来埋坑。

5. 项目交付物说明：源码、文档和演示视频的正确使用姿势

这个项目标题里带了“源码+文档+运行视频+讲解视频”，很多小伙伴拿到资源后不知道怎么高效利用，我按自己带过的项目经验来说说。

源码：不要急于跑起来。先把目录结构看一遍，pom.xml 里的依赖过一眼，再看 application.yml 里的配置项，最后把数据库脚本导进去，把配置改成自己的环境，再启动。没有这个过程，直接运行，报一堆错，你就会以为是自己环境不对，实际上只是配置没改。

文档：毕设文档一般包含开题报告、任务书、论文正文、答辩 PPT。论文写得详细程度与成绩直接相关，建议把数据库设计（E-R 图 + 表结构说明）、核心接口设计（请求/响应参数表）、业务流程时序图三块写详细。这不只是给老师看的，答辩时老师会随机抽一个接口问你怎么实现的。

运行视频和讲解视频：这类视频一般演示系统功能 + 讲代码结构，看的时候要注意两件事：第一，视频里的版本可能跟源码有细微差异，以源码为准；第二，如果想在里面加入自己的功能（比如加个留言板），先跑通原项目，再动手加功能，别一上来就改代码。我见过太多人拿到项目后第一件事就是删掉“看不懂的代码”，结果系统直接跑不起来。

写在最后

从接到这个智慧校园选课系统的需求开始，到完整交付，前前后后花了两周多时间。最大的感受是：这种项目真正有价值的不是界面有多炫，而是业务逻辑是否经得起推敲。选课的并发处理、多角色的权限模型、学习进度的记录机制——这三个点只要你能讲清楚“设计原因”和“实现方案”，无论是简历还是答辩都能加分不少。

顺着这个思路，后续你还可以把系统扩展到在线考试、成绩查询、图书借阅等场景，架构完全不用变，加表加接口就行。我个人在实际操作中最受用的一句话是：先把流程画清楚，再动手写代码，前后端约定好接口格式，剩下的事情都是按部就班。祝你的项目一次跑通，答辩顺利。