想象一下，你刚考完期末试，心里有点忐忑，想知道自己的成绩，或者明天有什么课，想提前预习一下。这时候，你只需要打开学校的网站，登录你的账号，就能清清楚楚地看到自己的成绩单和课程表。是不是很方便？这一切的背后，其实是一个默默工作的“数字管家”——校园管理系统。而在这个系统里，负责把你的成绩和课表漂亮地呈现在网页上的，有一个“老将”叫JSP。

你可能觉得这些网页就是普通的页面，但它们其实是一场精彩的数据接力赛。你的成绩数据存在学校的数据库里，就像图书馆里所有书的信息都编好目录一样。JSP就像一位聪明的图书管理员，当你点击“查询成绩”时，它会立刻跑去数据库，找到你的信息，然后飞快地把你专属的成绩单，变成一张你手机或电脑能看懂的网页。整个过程就像一个自动化的流水线，高效又可靠。

JSP到底是什么？为什么学校都爱用它？

JSP，全名叫JavaServer Pages，你可以把它想象成一个“会写程序的网页”。普通的HTML网页是静态的，就像一张印好字的报纸，内容不会变。但JSP不同，它允许在HTML的模板里嵌入Java程序代码。这样一来，这个网页就“活”了，它能根据不同的访问者（比如不同的学生）和不同的请求（比如查成绩还是看课表），实时地去后台拿数据，然后动态地生成一个专属的页面。

学校喜欢用JSP来开发成绩查询和课程表这些功能，主要有这么几个原因：

  1. 稳定可靠，像老教授一样：JSP是Java技术体系的一部分，Java语言以稳定著称，很多银行系统都在用。学校管理系统需要稳定运行很多年，JSP非常合适。
  2. 安全性高：学生成绩是个人隐私，不能随便泄露。JSP配合Java的安全机制，可以很好地管理用户权限，确保学生只能看自己的成绩，教务处老师才能看所有学生的成绩。
  3. 开发规范，易于维护：一个学校系统可能要换好几拨人来维护。JSP的代码结构清晰，按照MVC（模型-视图-控制器）模式来开发的话，就像一个分工明确的团队，有人专门管数据（JavaBean），有人专门管页面显示（JSP），有人专门管业务逻辑（Servlet），这样即使有新同事加入，也容易看懂代码，接手工作。
  4. 功能强大：因为背后是Java，所以它能做很多复杂的事情，比如处理复杂的选课逻辑、生成复杂的报表，这些都不是问题。

核心功能一：成绩查询的“炼成”之路

我们来一步步拆解，看看一个成绩查询页面是怎么通过JSP实现的。这就像烹饪，我们需要食材、菜谱和厨具。

第一步：准备“食材”——数据库设计 首先，学校得把所有学生的成绩信息都好好存起来。我们假设在数据库里有一张叫student_scores的表格，里面大概有这些信息：

CREATE TABLE student_scores (
    id INT PRIMARY KEY AUTO_INCREMENT,
    student_id VARCHAR(20) NOT NULL COMMENT '学号，比如2021001',
    student_name VARCHAR(50) NOT NULL COMMENT '学生姓名',
    course_name VARCHAR(100) NOT NULL COMMENT '课程名称，比如《高等数学》',
    score INT COMMENT '分数，比如85',
    semester VARCHAR(20) NOT NULL COMMENT '学期，比如2023-2024-1'
);

这张表里，每一行都代表一条成绩记录。比如，学号“2021001”，叫“张三”的同学，在“2023-2024-1”这个学期，《高等数学》考了85分。

第二步：准备“厨具”——JSP页面模板 我们先创建一个JSP文件，比如叫queryScore.jsp。这个页面一开始只包含一个简单的查询表单，就像餐厅的点菜单。

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <title>成绩查询</title>
    <style>
        body { font-family: 'Microsoft YaHei', sans-serif; }
        .container { width: 50%; margin: 50px auto; padding: 20px; border: 1px solid #eee; border-radius: 8px; box-shadow: 0 0 10px rgba(0,0,0,0.1); }
        table { width: 100%; border-collapse: collapse; margin-top: 20px; }
        th, td { padding: 12px; text-align: left; border-bottom: 1px solid #ddd; }
        th { background-color: #f8f9fa; }
        input[type="text"], input[type="submit"] { padding: 10px; margin: 5px 0; }
        input[type="submit"] { background-color: #007bff; color: white; border: none; cursor: pointer; }
    </style>
</head>
<body>
    <div class="container">
        <h2>欢迎使用成绩查询系统</h2>
        <form action="getScoreServlet" method="post">
            <label for="studentId">请输入您的学号：</label><br>
            <input type="text" id="studentId" name="studentId" placeholder="例如：2021001" required><br>
            <label for="semester">请选择学期：</label><br>
            <input type="text" id="semester" name="semester" placeholder="例如：2023-2024-1" required><br><br>
            <input type="submit" value="查询成绩">
        </form>
        
        <!-- 成绩结果将显示在这里 -->
        <div id="result">
            <% 
                // 这里可以用JSP脚本片断来检查是否有传递过来的成绩数据
                // 假设从Servlet转发过来的数据在request作用域，名为“scoreList”
                // 下面的代码会在有数据时动态生成一个表格
                java.util.List<Score> scores = (java.util.List<Score>)request.getAttribute("scoreList");
                if (scores != null && !scores.isEmpty()) {
            %>
                <h3>查询结果</h3>
                <table>
                    <tr>
                        <th>课程名称</th>
                        <th>分数</th>
                        <th>等级</th>
                    </tr>
                    <% for (Score score : scores) { %>
                        <tr>
                            <td><%= score.getCourseName() %></td>
                            <td><%= score.getScore() %></td>
                            <td><%= score.getGrade() %> <!-- 这是一个计算等级的方法 --></td>
                        </tr>
                    <% } %>
                </table>
            <% } %>
        </div>
    </div>
</body>
</html>

看到了吗？这个页面里有固定的HTML部分（比如标题、表格结构），也混入了JSP的标签（<% %>）和表达式（<%= %>）。那些<% %>里的Java代码，就是用来“动态”生成内容的关键。

第三步：制作“智能厨具”——Servlet处理逻辑 用户填写学号和学期，点击“查询成绩”后，请求会发送到一个叫getScoreServlet的Servlet。Servlet就像是厨房里的大厨，专门处理业务逻辑。

// GetScoreServlet.java
import java.io.IOException;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/getScoreServlet") // 这个注解定义了访问路径
public class GetScoreServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 1. 获取前端传来的学号和学期
        String studentId = request.getParameter("studentId");
        String semester = request.getParameter("semester");
        
        // 2. 调用数据访问层（DAO）去数据库查询
        ScoreDAO scoreDAO = new ScoreDAO(); // 假设这是访问数据库的类
        List<Score> scores = scoreDAO.getScoresByStudentIdAndSemester(studentId, semester);
        
        // 3. 将查询到的成绩列表存入request作用域
        request.setAttribute("scoreList", scores);
        
        // 4. 转发回JSP页面进行显示
        // 注意：是“转发”，不是“重定向”。转发时request中的数据会保留。
        request.getRequestDispatcher("queryScore.jsp").forward(request, response);
    }
}

第四步：开始“烹饪”——运行流程 整个过程串起来就是：

  1. 学生访问queryScore.jsp页面，看到输入框。
  2. 学生输入学号“2021001”和学期“2023-2024-1”，点击查询。
  3. 请求被发送到GetScoreServlet。
  4. Servlet像一个勤快的助手，拿着学号和学期去数据库这个“大仓库”里翻找。
  5. 数据库返回了这个学生这学期的所有成绩。
  6. Servlet把这些成绩数据打包好，连同原来的queryScore.jsp页面（一份“菜谱”）一起，送回给学生。
  7. JSP页面收到这份“打包好的食材”（成绩数据），用它动态地渲染出成绩表格，最后呈现给学生的浏览器。

核心功能二：课程表在线查看的“动态魔法”

如果说成绩查询是根据条件找数据，那课程表在线查看就是把一个固定的课程安排，按照不同班级、不同周次进行动态展示。JSP在这里的“魔法”体现在动态生成HTML表格上。

场景：我们需要为不同班级展示他们的每周课程表。

数据结构：通常课程表数据会设计得更复杂，可能包括班级ID、星期几、第几节课、课程名称、教师、教室等。

CREATE TABLE course_schedule (
    id INT PRIMARY KEY AUTO_INCREMENT,
    class_id INT NOT NULL COMMENT '班级ID，比如101班',
    day_of_week INT NOT NULL COMMENT '星期几，1代表星期一，2代表星期二...7代表星期日',
    period INT NOT NULL COMMENT '第几节课，比如1代表第一节课',
    course_name VARCHAR(100) NOT NULL,
    teacher VARCHAR(50),
    classroom VARCHAR(50)
);

JSP动态生成课程表： 我们可以创建一个showSchedule.jsp，它的核心任务是根据传入的classId（班级ID），生成一个7行（星期）x N列（课程节次）的表格，并把课程填进去。

<%@ page import="java.util.List" %>
<%@ page import="com.example.Course" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.util.HashMap" %>
<%@ page import="java.util.ArrayList" %>
<%
    // 假设我们从后端获取了当前班级的课程列表
    // 数据结构可能是: Map<Integer, List<Course>>，key是星期几（1-7），value是该天的课程列表
    Map<Integer, List<Course>> weeklySchedule = (Map<Integer, List<Course>>)request.getAttribute("weeklySchedule");
    
    if (weeklySchedule != null) {
        int maxPeriods = 5; // 假设每天最多5节课，实际可以从数据中计算
%>
        <h3>班级课程表</h3>
        <table border="1" style="border-collapse: collapse; width: 100%;">
            <thead>
                <tr>
                    <th>节次\星期</th>
                    <%
                        // 动态生成星期列的表头
                        String[] dayNames = {"", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
                        for (int day = 1; day <= 7; day++) {
                            out.println("<th>" + dayNames[day] + "</th>");
                        }
                    %>
                </tr>
            </thead>
            <tbody>
                <%
                    // 动态生成每一节课的行
                    for (int period = 1; period <= maxPeriods; period++) {
                %>
                        <tr>
                            <td><strong>第<%= period %>节</strong></td>
                            <% 
                                // 为当前节次，遍历每个星期
                                for (int day = 1; day <= 7; day++) {
                                    out.println("<td>");
                                    // 从weeklySchedule中获取当天、当节的课程
                                    List<Course> dayCourses = weeklySchedule.get(day);
                                    if (dayCourses != null) {
                                        for (Course course : dayCourses) {
                                            if (course.getPeriod() == period) { // 如果这节课属于当前节次
                                                out.println(course.getCourseName() + "<br>" + course.getTeacher() + "<br>" + course.getClassroom());
                                            }
                                        }
                                    }
                                    out.println("</td>");
                                }
                            %>
                        </tr>
                <% } %>
            </tbody>
        </table>
<% } %>

这段JSP代码就像一个精密的“排版员”。它用两层循环：外层循环控制节次（行），内层循环控制星期（列）。在每个交叉的单元格里，它精确地找到属于这个时间点的课程信息，然后把课程名、老师、教室像填色游戏一样填进去。最终，一个结构清晰、信息完整的课程表就从后台数据变成了可视化的网页了。

不止于此：校园管理系统的其他核心模块

成绩和课表只是冰山一角。一个完整的校园管理系统，JSP技术还能支撑起更多强大的模块：

  • 课程管理：教师和教务处可以在线新增、修改、删除课程信息，设定课程的学分、容量、上课时间地点。这些数据会实时同步到学生选课系统和课程表中。
  • 成绩管理：教师登录后，可以为自己负责的班级和课程在线录入、修改学生的平时成绩、考试成绩，系统会自动计算总评成绩。所有操作都有日志记录，确保可追溯。
  • 选课系统：每到选课季，这个模块就成为焦点。JSP页面需要展示可选课程列表、已选课程、课程余量。学生点击“选课”，后端Servlet需要处理复杂的并发逻辑：检查是否时间冲突、课程是否已满、是否满足先修条件等，并完成数据库的更新。
  • 用户角色与权限管理：系统里有学生、教师、管理员等多种角色。JSP页面会根据登录用户的角色，动态地显示或隐藏不同的功能按钮和菜单。例如，学生不会看到“成绩录入”按钮。

局限与演进：老将JSP的现代之路

JSP功不可没，但随着技术发展，它也有一些显得“古老”的地方。比如，直接在JSP里写太多Java代码（像上面的例子），会导致页面混乱，难以维护。前后端职责不清晰，不利于团队协作和前端技术（如Vue, React）的融入。

因此，现代的基于JSP思想的校园管理系统，通常会进行“进化”：

  1. 严格遵循MVC模式：将JSP的使用严格限定在“视图”（View）层，只负责显示数据，通过标签（如JSTL）和EL表达式来获取数据，而不是写大段的Java脚本。业务逻辑全部由Servlet（作为控制器Controller）处理，数据操作由JavaBean或DAO（作为模型Model）处理。
  2. 前后端分离的过渡：很多系统会采用一种“混合”模式。核心的、数据交互密集的页面（如后台管理）依然使用JSP/Servlet技术，因为它成熟稳定。而面向学生的一些交互频繁、体验要求高的页面（如移动端App的网页版），可能会采用更现代的前端框架（如Vue.js）来开发，通过API接口与后端的Java服务（可能是用Spring Boot，其内核依然是Java）进行数据交互。

总而言之，JSP作为一项历经考验的Web开发技术，在校园管理系统的发展史上写下了浓墨重彩的一笔。它让静态的网页拥有了处理业务、动态展示数据的能力，完美地实现了成绩查询、课表查看这些核心功能。虽然技术的浪潮不断向前，新的框架层出不穷，但JSP所代表的“服务器端动态生成页面”的核心思想，以及它所构建的MVC经典架构，依然深刻地影响着当今校园管理系统的开发。它是很多计算机专业学生学习Web开发的第一课，也是许多学校信息化建设中可靠而强大的基石。