说到教育信息化，很多人脑海里浮现的可能是高大上的AI课堂或者云数据中心。但如果你真的去看过那些还在基层学校运行的教务系统，你会发现，真正让数据跑起来的，往往是那些看似“老旧”却极其稳定的技术栈。其中，JavaServer Pages (JSP) 配合 Servlet 的模式，就像是一个不知疲倦的老工匠，在后台默默处理着成千上万条选课数据和成绩录入。
今天，我们不谈虚的理论，直接切入实战。我们要聊的是两个最核心的场景：学生选课和教师成绩管理。这两个场景看似简单，实则暗藏玄机——并发冲突、事务一致性、权限隔离，每一个坑都能让系统崩溃。我们将通过具体的代码逻辑和业务流转，看看 JSP 技术是如何在这些环节中发挥作用的。
选课高峰期的“防堵”策略：并发与锁
想象一下，开学第一周，全校 5000 名学生同时点击“选修《人工智能导论》”。这门课只有 60 个名额。如果这时候你的后端没有处理好并发，结果会怎样？名额可能被超发，变成 65 人，或者因为数据库锁死导致所有学生都选不上。
在传统的 JSP+Servlet 架构中，我们通常采用 “数据库乐观锁” 结合 “应用层队列” 的方式来应对。虽然现在的微服务架构更流行 Redis 分布式锁，但在很多中小型教育信息化项目中，基于 JDBC 的事务控制依然稳健且易于维护。
让我们看看后端处理选课请求的核心 Java 代码逻辑。这里的关键在于 selectForUpdate 的使用，它能确保在同一时刻只有一个线程能修改这条库存记录。
// CourseSelectionService.java
public class CourseSelectionService {
private DataSource dataSource;
public boolean selectCourse(int studentId, int courseId) throws SQLException {
Connection conn = null;
try {
conn = dataSource.getConnection();
conn.setAutoCommit(false); // 开启事务
// 1. 查询当前课程剩余名额，并加上行级锁 (FOR UPDATE)
String checkSql = "SELECT available_slots FROM course WHERE course_id = ? FOR UPDATE";
PreparedStatement pstmtCheck = conn.prepareStatement(checkSql);
pstmtCheck.setInt(1, courseId);
ResultSet rs = pstmtCheck.executeQuery();
if (!rs.next()) {
throw new SQLException("课程不存在");
}
int availableSlots = rs.getInt("available_slots");
// 2. 检查名额是否充足
if (availableSlots <= 0) {
conn.rollback();
return false; // 名额已满
}
// 3. 更新剩余名额
String updateSql = "UPDATE course SET available_slots = available_slots - 1 WHERE course_id = ? AND available_slots > 0";
PreparedStatement pstmtUpdate = conn.prepareStatement(updateSql);
pstmtUpdate.setInt(1, courseId);
int rowsAffected = pstmtUpdate.executeUpdate();
if (rowsAffected == 0) {
// 发生了竞态条件，名额在检查后、更新前被别人抢光了
conn.rollback();
return false;
}
// 4. 插入选课记录
String insertSql = "INSERT INTO student_course (student_id, course_id, status) VALUES (?, ?, 'SELECTED')";
PreparedStatement pstmtInsert = conn.prepareStatement(insertSql);
pstmtInsert.setInt(1, studentId);
pstmtInsert.setInt(2, courseId);
pstmtInsert.executeUpdate();
conn.commit(); // 提交事务，释放锁
return true;
} catch (SQLException e) {
if (conn != null) conn.rollback();
throw e;
} finally {
if (conn != null) conn.close();
}
}
}
在前端展示层，JSP 页面通过 EL 表达式和 JSTL 标签库，将这种复杂的后端逻辑转化为直观的界面。当用户点击“选课”按钮时，前端发送 AJAX 请求，后端返回 JSON 状态。如果成功，JSP 页面局部刷新选课列表；如果失败，则弹出提示。
<!-- select_course.jsp -->
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html>
<html>
<head>
<title>课程选择</title>
<script src="jquery.min.js"></script>
<script>
function submitSelection(courseId) {
$.ajax({
url: 'SelectCourseServlet',
type: 'POST',
data: { courseId: courseId },
success: function(response) {
if (response.success) {
alert('选课成功！');
location.reload(); // 刷新页面以显示最新名额
} else {
alert('选课失败：' + response.message);
}
},
error: function() {
alert('网络错误，请重试');
}
});
}
</script>
</head>
<body>
<h2>可选课程列表</h2>
<table border="1">
<tr>
<th>课程名称</th>
<th>剩余名额</th>
<th>操作</th>
</tr>
<c:forEach var="course" items="${courseList}">
<tr>
<td>${course.name}</td>
<td>${course.availableSlots}</td>
<td>
<c:if test="${course.availableSlots > 0}">
<button onclick="submitSelection(${course.id})">选课</button>
</c:if>
<c:else>
<span style="color:red">已满</span>
</c:if>
</td>
</tr>
</c:forEach>
</table>
</body>
</html>
这种设计虽然古老，但它清晰地展示了 MVC 模式的精髓：Servlet 处理业务逻辑（Model），JSP 负责视图展示（View），而控制器（Controller）则是 Servlet 本身。对于教育信息化项目来说，这种结构的可预测性和稳定性是巨大的优势。
成绩管理的“严谨性”：事务与审计
如果说选课是“快进快出”的交易，那么成绩管理就是“细水长流”的数据沉淀。老师需要录入成绩，系统需要计算平均分、标准差，甚至要支持成绩的修改留痕（审计日志）。这里最大的挑战不是并发，而是数据的准确性和操作的不可抵赖性。
在 JSP 应用中，我们通常会创建一个专门的成绩管理 Servlet。这个 Servlet 不仅要处理分数的录入，还要确保一旦提交，任何修改都必须记录在案。
// GradeManagementServlet.java
public class GradeManagementServlet extends HttpServlet {
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 获取当前登录教师ID（假设已存储在Session中）
Integer teacherId = (Integer) request.getSession().getAttribute("userId");
if (teacherId == null) {
response.sendRedirect("login.jsp");
return;
}
int courseId = Integer.parseInt(request.getParameter("courseId"));
String gradeJson = request.getParameter("gradesJson"); // 前端传来的JSON字符串
// 解析JSON（实际项目中建议使用 Jackson 或 Gson）
List<GradeEntry> grades = parseGrades(gradeJson);
Connection conn = null;
try {
conn = DBUtil.getConnection();
conn.setAutoCommit(false);
for (GradeEntry entry : grades) {
// 1. 更新成绩
String updateSql = "UPDATE student_grade SET score = ? WHERE student_id = ? AND course_id = ?";
PreparedStatement pstmt = conn.prepareStatement(updateSql);
pstmt.setDouble(1, entry.getScore());
pstmt.setInt(2, entry.getStudentId());
pstmt.setInt(3, entry.getCourseId());
pstmt.executeUpdate();
// 2. 记录审计日志（关键步骤：谁在什么时候改了什么）
String logSql = "INSERT INTO grade_audit_log (course_id, student_id, old_score, new_score, operator_id, operate_time) " +
"SELECT student_id, score, ?, ?, ?, NOW() FROM student_grade WHERE student_id = ? AND course_id = ?";
PreparedStatement pstmtLog = conn.prepareStatement(logSql);
// 注意：这里为了简化示例，假设我们在更新前查出了旧分数，或者在触发器中处理
// 在实际复杂场景中，可能需要先 SELECT 旧值，再 UPDATE，再 INSERT LOG
pstmtLog.setInt(1, entry.getOldScore());
pstmtLog.setDouble(2, entry.getNewScore());
pstmtLog.setInt(3, teacherId);
pstmtLog.setInt(4, entry.getStudentId());
pstmtLog.setInt(5, entry.getCourseId());
pstmtLog.executeUpdate();
}
conn.commit();
response.getWriter().write("{\"success\": true, \"message\": \"成绩保存成功\"}");
} catch (Exception e) {
if (conn != null) conn.rollback();
response.getWriter().write("{\"success\": false, \"message\": \"保存失败: " + e.getMessage() + "\"}");
e.printStackTrace();
} finally {
if (conn != null) try { conn.close(); } catch (SQLException e) {}
}
}
// 辅助类，用于接收前端数据
static class GradeEntry {
private int studentId;
private int courseId;
private double oldScore;
private double newScore;
// Getters and Setters...
}
}
在 JSP 页面层面，为了让老师方便地批量录入成绩，我们通常会生成一个动态表格。每一行对应一个学生，输入框绑定学生的 ID。当老师点击“提交”时，JavaScript 会收集所有输入框的值，打包成 JSON 发送给 Servlet。
<!-- grade_entry.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>成绩录入</title>
<style>
table { width: 100%; border-collapse: collapse; margin-top: 20px; }
th, td { border: 1px solid #ddd; padding: 8px; text-align: center; }
th { background-color: #f2f2f2; }
input[type="number"] { width: 80px; padding: 5px; }
</style>
</head>
<body>
<h2>课程：<c:out value="${courseName}" /></h2>
<form id="gradeForm">
<table>
<thead>
<tr>
<th>学号</th>
<th>姓名</th>
<th>原成绩</th>
<th>新成绩</th>
</tr>
</thead>
<tbody>
<c:forEach var="student" items="${studentsWithGrades}">
<tr>
<td><c:out value="${student.studentId}" /></td>
<td><c:out value="${student.studentName}" /></td>
<td><c:out value="${student.currentScore}" /></td>
<td>
<input type="number" step="0.1" name="score_${student.studentId}"
value="<c:out value="${student.currentScore}" />"
data-student-id="${student.studentId}"
data-course-id="${courseId}"
data-old-score="${student.currentScore}">
</td>
</tr>
</c:forEach>
</tbody>
</table>
<br>
<button type="button" onclick="submitGrades()">提交成绩</button>
</form>
<script>
function submitGrades() {
const inputs = document.querySelectorAll('input[type="number"]');
const gradesData = [];
inputs.forEach(input => {
const newScore = parseFloat(input.value);
const oldScore = parseFloat(input.getAttribute('data-old-score'));
const studentId = parseInt(input.getAttribute('data-student-id'));
const courseId = parseInt(document.querySelector('input').getAttribute('data-course-id')); // 简化获取
// 只提交有变化的成绩，减少数据传输量
if (Math.abs(newScore - oldScore) > 0.01) {
gradesData.push({
studentId: studentId,
courseId: courseId,
oldScore: oldScore,
newScore: newScore
});
}
});
if (gradesData.length === 0) {
alert("没有检测到成绩变更");
return;
}
fetch('GradeManagementServlet', {
method: 'POST',
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
body: 'gradesJson=' + encodeURIComponent(JSON.stringify(gradesData))
})
.then(response => response.json())
.then(data => {
if (data.success) {
alert("成绩保存成功！");
location.reload();
} else {
alert("保存失败：" + data.message);
}
});
}
</script>
</body>
</html>
在这个案例中，JSP 不仅仅是 HTML 的容器，它通过与后端数据的紧密绑定（JSTL），实现了动态界面的快速构建。而 JavaScript 则承担了数据收集和数据格式化的工作，减轻了服务器的解析负担。
为什么 JSP 在教育信息化中依然“能打”？
你可能会问，现在 Spring Boot + Vue/React 不是更香吗？为什么还要解析 JSP？
原因很现实：存量系统的维护成本和部署的简易性。
- 学习曲线与维护人员：许多高校的信息中心团队，其核心技术人员可能更熟悉 Java EE 传统栈。让他们在短时间内迁移到微服务和前后端分离架构，人力成本极高。JSP 技术成熟，文档丰富，问题容易排查。
- 部署简单：一个 WAR 包丢进 Tomcat 就能跑，不需要配置 Nginx 反向代理前端静态资源，不需要处理跨域（CORS）问题。对于内网环境的教育系统，这种“单体式”的部署方式反而是一种优势。
- 安全性可控：JSP 运行在服务端，HTML 和逻辑代码分离（如果遵循 JSP Best Practices），避免了前端 XSS 攻击直接暴露业务逻辑的风险。虽然现代框架更安全，但良好的 JSP 开发规范同样能保证安全。
给小朋友也能听懂的“理儿”
如果把整个教育系统比作一家超级大的自助餐厅：
- 学生选课就像是抢热门菜品。比如“糖醋排骨”，只有 60 份。如果 5000 个人同时伸手去拿，厨师（服务器）必须非常聪明，他不能只看一眼说“还有”，然后所有人一起拿，那样最后肯定不够分。厨师得拿着一个小本子（数据库锁），每拿走一份，就划掉一个数字。只有当数字大于 0 时，才允许你拿。这就是我们代码里做的“乐观锁”和“事务”。
- 教师成绩管理就像是批改作业并存档。老师改完分数，不能随便涂改而不留痕迹。如果老师发现给小明打错了，从 90 分改成 80 分，系统不仅要更新黑板上的分数，还要在后台的“黑匣子”里记一笔：“某年某月某日，老师张三把小明的分数从 90 改成了 80”。这样以后如果有人质疑分数，我们可以翻出记录，知道是谁改的，什么时候改的。这就是我们的“审计日志”。
结语：技术是为了解决问题，而不是炫技
教育信息化的核心，不是用了多新的框架，而是数据是否准确、流程是否顺畅、体验是否友好。JSP 技术虽然在互联网大厂的前沿视野中逐渐退居二线，但在教育行业的深水区，它依然凭借稳定、高效、易维护的特点，支撑着无数学校的日常运转。
作为开发者，理解这些“老技术”背后的设计哲学——如事务的一致性、视图与逻辑的分离、并发控制的重要性——比单纯追求新技术更有价值。因为这些原则，是永恒不变的基石。