基于JSP+Servlet+MySQL的学生宿舍管理系统实战项目

本文还有配套的精品资源，点击获取

简介：学生宿舍管理系统是一个典型的JavaWeb应用，采用JSP实现页面展示，Servlet处理业务逻辑，MySQL进行数据存储，实现了用户管理、宿舍管理、学生信息关联、报修流程跟踪及数据统计报表等核心功能。本文详细解析系统架构与开发流程，涵盖数据库设计、前后端交互、权限控制和部署测试，项目经过完整测试，适用于学习JavaWeb全栈开发的初学者掌握Web应用程序的构建方法。

JavaWeb核心技术深度解析：从JSP到MVC架构的完整实践

你有没有遇到过这种情况？——明明代码逻辑没问题，但系统一上线就各种404、500报错，数据库连不上，页面乱码……调试半天才发现是 web.xml 少配了个标签，或者驱动包没放进 WEB-INF/lib 。😅

这其实是很多JavaWeb初学者的真实写照。而背后的根本原因，往往是对整个技术栈的工作机制缺乏系统性理解。今天我们就来一次“打通任督二脉”式的深度剖析，带你从底层原理出发，彻底搞懂JSP、Servlet、MySQL、MVC模式以及部署全流程。

---

想象一下：一个学生打开浏览器，输入宿舍管理系统网址，登录后查看自己的报修进度。这个看似简单的操作，其实触发了一连串精密协作的技术组件。前端请求如何被服务器接收？数据是怎么从数据库取出来又渲染成网页的？权限控制又是怎么实现的？

我们不妨以这个真实场景为线索，一步步揭开JavaWeb应用的神秘面纱。

JSP的本质：不只是HTML+Java，而是编译后的Servlet

很多人以为JSP就是“在HTML里写Java代码”，这种理解太表面了。真正的关键在于—— JSP本质上是一个Servlet 。

当用户第一次访问某个 .jsp 页面时（比如 login.jsp ），Tomcat内部的Jasper引擎会悄悄做四件事：

1. 语法解析 ：检查JSP语法是否合法；
2. 转换 ：将JSP转成 .java 文件（位于 work/Catalina/... 目录下）；
3. 编译 ：用javac把 .java 生成 .class ；
4. 加载执行 ：由JVM运行这个类，输出HTML响应。

来看个经典例子：

<p>当前时间：<%= new java.util.Date() %></p>

这段代码最终会被翻译成什么？不是你想的直接输出，而是：

out.print("当前时间：");
out.print(new java.util.Date());

也就是说，JSP中的 <%= 等价于 out.println() ！是不是有种恍然大悟的感觉？

更进一步，JSP还内置了9个对象（如 request , response , session ），它们都是由容器自动注入的。这意味着你在JSP中可以直接调用：

欢迎回来，${sessionScope.user.name}！

而无需任何声明。这些设计让视图层开发变得极其高效。

不过要注意的是，虽然JSP支持脚本片段（ <% ... %> ），但在现代开发中应尽量避免使用，因为它破坏了MVC的分层原则。正确的做法是配合EL表达式和JSTL标签库，保持页面纯净。

---

Servlet才是幕后英雄：它到底经历了什么？

如果说JSP是前台演员，那Servlet就是真正的导演兼编剧。每一个HTTP请求最终都会落到某个Servlet头上。

而这一切的核心，就是 javax.servlet.Servlet 接口。它定义了五个方法：
- init() ：初始化，只执行一次
- service() ：处理每次请求
- destroy() ：销毁前清理资源
- getServletConfig() / getServletInfo()

实际开发中我们不会直接实现这个接口，而是继承 HttpServlet 类。为什么？因为 HttpServlet 已经帮我们做好了最重要的事： 根据HTTP方法自动分发请求 。

protected void service(HttpServletRequest req, HttpServletResponse resp) {
    String method = req.getMethod();
    if ("GET".equals(method)) {
        doGet(req, resp);
    } else if ("POST".equals(method)) {
        doPost(req, resp);
    }
    // ...
}

你看，这就是为什么你可以只重写 doGet() 或 doPost() 的原因。Tomcat已经帮你把路由逻辑处理好了！

举个登录功能的例子：

@WebServlet("/login")
public class LoginServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws IOException, ServletException {
        // GET请求：显示登录页
        req.getRequestDispatcher("/login.jsp").forward(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
            throws IOException, ServletException {
        String username = req.getParameter("username");
        String password = req.getParameter("password");

        if (userService.authenticate(username, password)) {
            HttpSession session = req.getSession();
            session.setAttribute("user", user);
            resp.sendRedirect("dashboard");  // 成功跳转
        } else {
            req.setAttribute("error", "用户名或密码错误");
            req.getRequestDispatcher("/login.jsp").forward(req, resp);  // 带错回显
        }
    }
}

这里有两个关键跳转方式：
- forward() ：服务器内部转发，URL不变，可以携带request作用域数据；
- redirect() ：客户端重定向，URL改变，适用于防止表单重复提交。

选择哪个？记住一个口诀：“ 读用forward，写用redirect ”。比如查询信息可以用forward，而登录成功后必须redirect，否则刷新页面会再次触发POST。

还有个重要细节： Servlet是单例多线程的 ！整个应用生命周期内只有一个实例，但每个请求都在独立线程中执行 service() 方法。这就带来了一个隐患：

public class BadCounterServlet extends HttpServlet {
    private int count = 0;  // ❌ 危险！多个线程共享此变量

    protected void doGet(...) {
        count++;  // 可能发生竞态条件
    }
}

解决办法要么用局部变量，要么加锁，或者用 AtomicInteger 这类并发工具类。

---

数据库设计的艺术：不仅仅是建表那么简单

一个好的系统，70%的稳定性取决于数据库设计。尤其是在宿舍管理系统这种涉及多角色、多状态流转的业务中，合理的模型设计能避免后期无数坑。

先看核心实体关系：

erDiagram
    STUDENT ||--o{ DORMITORY : "lives_in"
    STUDENT ||--o{ REPAIR_RECORD : "submits"
    ADMIN ||--o{ REPAIR_RECORD : "handles"

    STUDENT {
        varchar student_id PK
        varchar name
        char gender
        varchar phone
        varchar department
        varchar dorm_id FK
    }
    DORMITORY {
        varchar dorm_id PK
        varchar building
        varchar room_number
        int capacity
        int current_occupancy
        varchar type
    }
    ADMIN {
        int admin_id PK
        varchar username
        varchar password_hash
        varchar role
        varchar phone
    }
    REPAIR_RECORD {
        int record_id PK
        varchar student_id FK
        int admin_id FK
        datetime submit_time
        text issue_description
        varchar status
        datetime complete_time
    }

看到没？我们用了外键约束来保证引用完整性。例如学生必须属于某个宿舍，报修单必须关联到具体的学生和管理员。

而且字段命名也很讲究：
- 主键统一叫 xxx_id ，便于识别；
- 密码绝不存明文，而是存储BCrypt哈希值；
- 状态字段建议用枚举或标准化字符串（如”pending”, “processing”, “completed”）；
- 时间字段明确区分 submit_time 和 complete_time ，方便统计处理时长。

再来看看建表语句的关键点：

CREATE TABLE dormitory (
    dorm_id VARCHAR(10) PRIMARY KEY COMMENT '宿舍编号，格式：B1-301',
    building VARCHAR(10) NOT NULL,
    room_number VARCHAR(5) NOT NULL,
    capacity INT NOT NULL DEFAULT 4,
    current_occupancy INT NOT NULL DEFAULT 0,
    type ENUM('male', 'female', 'mixed') NOT NULL DEFAULT 'male'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

几个最佳实践：
- 使用 utf8mb4 字符集，支持emoji；
- 引擎选 InnoDB ，支持事务和行级锁；
- capacity 和 current_occupancy 都设默认值，避免NULL干扰计算；
- type 用ENUM限制取值范围，减少脏数据风险。

别忘了索引！高频查询字段一定要建索引：

CREATE INDEX idx_repair_status ON repair_record(status);
CREATE INDEX idx_student_name ON student(name);

否则随着数据量增长，查询速度会断崖式下降。

---

连接数据库不是“DriverManager.getConnection()”这么简单

你以为拿到Connection就能高枕无忧了？Too young too simple 😏

首先，生产环境绝对不能每次都新建连接。TCP握手+认证过程耗时严重，高并发下直接拖垮数据库。

解决方案是什么？ 连接池 ！

常见的有DBCP、C3P0、HikariCP。以Hikari为例：

HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/dormitorydb");
config.setUsername("root");
config.setPassword("your_password");
config.setMaximumPoolSize(20);
config.setMinimumIdle(5);

HikariDataSource dataSource = new HikariDataSource(config);

这样配置后，你的应用不再频繁创建连接，而是从池子里“借”一个用完归还，性能提升几十倍都不夸张。

其次，SQL注入怎么办？还记得那个经典的笑话吗：“我女儿的名字叫Robert’); DROP TABLE students; –”😂

防御手段就是 PreparedStatement ：

String sql = "SELECT * FROM student WHERE name LIKE ?";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
    pstmt.setString(1, "%" + userInput + "%");  // 自动转义特殊字符
    ResultSet rs = pstmt.executeQuery();
}

占位符 ? 会在预编译阶段就被解析，用户输入只能作为纯数据传入，无法改变SQL结构。即使输入 张%' OR '1'='1 ，也只会当成普通字符串处理。

最后，跨表操作怎么办？比如学生换宿舍，要同时更新三张表：
1. 原宿舍 current_occupancy - 1
2. 新宿舍 current_occupancy + 1
3. 学生记录更新 dorm_id

任何一个步骤失败都不能提交！这就需要用到 事务 ：

conn.setAutoCommit(false);
try {
    updateDormOccupancy(conn, oldId, -1);
    updateDormOccupancy(conn, newId, +1);
    updateStudentDorm(conn, studentId, newId);
    conn.commit();  // 全部成功才提交
} catch (SQLException e) {
    conn.rollback();  // 出错回滚
    throw e;
} finally {
    conn.setAutoCommit(true);
}

ACID特性在这里体现得淋漓尽致：
- 原子性 ：要么全成功，要么全撤销
- 一致性 ：人数永远 ≤ 容量
- 隔离性 ：并发修改互不影响
- 持久性 ：提交后永久生效

---

MVC不是名词堆砌，而是一种思维方式

现在我们回到最开始的问题：用户登录后是如何看到报修进度的？

答案就在MVC架构中。这三个字母代表的不仅是三层结构，更是一种 关注点分离 的设计哲学。

Model：不只是POJO，更是业务规则的守护者

很多人以为Model就是JavaBean，其实这只是冰山一角。真正的Model包含两部分：

1. 实体类（Entity/POJO）

public class RepairRecord {
    private Integer recordId;
    private String studentId;
    private String issueDescription;
    private String status;
    // getters & setters...
}

2. 服务类（Service）

public class RepairService {
    public List<RepairRecord> getRepairsByStudent(String studentId) {
        // 可能涉及多表关联查询
        return repairDAO.findByStudentId(studentId);
    }

    public void submitRepair(RepairForm form) {
        // 校验逻辑
        if (form.getDescription().length() < 10) {
            throw new BusinessException("问题描述不能少于10个字");
        }

        // 构造记录并保存
        RepairRecord record = convert(form);
        repairDAO.save(record);
    }
}

看到了吗？Service层才是真正封装业务逻辑的地方。它可以协调多个DAO，进行复杂校验，甚至调用外部API。这才是Model的完整形态。

View：JSP + EL + JSTL = 清爽的模板语言

传统的JSP满屏 <% ... %> 脚本简直惨不忍睹。现代写法应该是这样的：

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>

<table border="1">
  <tr>
    <th>宿舍号</th>
    <th>问题描述</th>
    <th>提交时间</th>
    <th>状态</th>
  </tr>
  <c:forEach items="${repairList}" var="r">
    <tr>
      <td>${r.dormId}</td>
      <td>${r.issueDescription}</td>
      <td><fmt:formatDate value="${r.submitTime}" pattern="MM-dd HH:mm"/></td>
      <td class="status-${r.status}">${r.statusText}</td>
    </tr>
  </c:forEach>
</table>

几点优势：
- <c:forEach> 替代for循环，代码简洁；
- <fmt:formatDate> 统一日期格式，避免前后端不一致；
- EL表达式 ${} 自动调用getter，无需手动写方法名；
- 所有Java代码都被赶出了视图层，维护性大大增强。

Controller：请求调度中心的大脑

Controller的任务很明确：接收请求 → 调用Service → 分发结果。

@WebServlet("/repair/list")
public class RepairListServlet extends HttpServlet {
    private RepairService service = new RepairService();

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {

        String studentId = (String) req.getSession().getAttribute("userId");

        try {
            List<RepairRecord> repairs = service.getRepairsByStudent(studentId);
            req.setAttribute("repairList", repairs);
            req.getRequestDispatcher("/WEB-INF/views/repair/list.jsp")
               .forward(req, resp);
        } catch (Exception e) {
            log.error("Failed to load repair records", e);
            resp.sendError(500, "系统繁忙，请稍后再试");
        }
    }
}

注意这里的异常处理策略：
- 业务异常封装成 BusinessException 向上抛；
- 系统级错误记录日志并返回500；
- 绝不在Controller里打印堆栈到前端页面（安全风险！）

---

权限控制怎么做？Filter告诉你答案

系统有三种角色：学生、宿管、超级管理员。如何防止越权访问？

虽然没有Spring Security那么强大，但原生Servlet也能搞定。秘诀就是—— Filter过滤器 ！

@WebFilter("/admin/*")  // 拦截所有/admin/路径
public class AuthFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                         FilterChain chain) throws IOException, ServletException {

        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse resp = (HttpServletResponse) response;
        HttpSession session = req.getSession(false);

        // 未登录？
        if (session == null || session.getAttribute("user") == null) {
            resp.sendRedirect("../login.jsp");
            return;
        }

        User user = (User) session.getAttribute("user");
        String servletPath = req.getServletPath();

        // 非管理员尝试访问管理功能？
        if (servletPath.startsWith("/admin/") && !"ADMIN".equals(user.getRole())) {
            resp.sendError(403, "权限不足");
            return;
        }

        // 放行
        chain.doFilter(request, response);
    }
}

这个Filter就像一道安检门，所有请求必须经过它才能进入后续流程。不仅可以做身份认证，还能记录访问日志、压缩响应内容、添加响应头等等。

---

报修模块实战：文件上传与状态机设计

让我们聚焦一个具体功能：学生提交报修申请。

前端需要支持图片上传，所以表单必须加上 enctype="multipart/form-data" ：

<form action="RepairSubmitServlet" method="post" enctype="multipart/form-data">
    <input type="text" name="dormId" placeholder="宿舍号" required />
    <select name="type">
        <option value="water">漏水</option>
        <option value="electricity">电路故障</option>
        <option value="furniture">家具损坏</option>
    </select>
    <textarea name="description" placeholder="请详细描述问题..." required></textarea>
    <input type="file" name="image" accept="image/*" />
    <button type="submit">提交报修</button>
</form>

后端处理要用到 @MultipartConfig 注解：

@WebServlet("/RepairSubmitServlet")
@MultipartConfig(
    fileSizeThreshold = 1024 * 1024,    // 内存阈值
    maxFileSize = 1024 * 1024 * 5,       // 单文件最大5MB
    maxRequestSize = 1024 * 1024 * 10    // 总请求大小10MB
)
public class RepairSubmitServlet extends HttpServlet {

    private static final String UPLOAD_DIR = "/uploads";

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
            throws ServletException, IOException {

        String dormId = req.getParameter("dormId");
        String type = req.getParameter("type");
        String desc = req.getParameter("description");
        Part filePart = req.getPart("image");

        // 处理文件上传
        String fileName = extractFileName(filePart);
        String uploadPath = req.getServletContext().getRealPath(UPLOAD_DIR);
        Path filePath = Paths.get(uploadPath, fileName);
        Files.createDirectories(filePath.getParent());
        filePart.write(filePath.toString());

        // 保存到数据库
        RepairRecord record = new RepairRecord();
        record.setDormId(dormId);
        record.setType(type);
        record.setDescription(desc);
        record.setImageUrl(UPLOAD_DIR + "/" + fileName);
        record.setStatus("pending");
        record.setSubmitTime(new Date());

        repairDAO.save(record);

        resp.sendRedirect("student_dashboard.jsp?msg=报修提交成功！");
    }
}

状态流转也很重要。我们可以用状态模式来管理：

public enum RepairStatus {
    PENDING("待处理"),
    PROCESSING("处理中"),
    COMPLETED("已完成"),
    CANCELLED("已取消");

    private final String label;

    RepairStatus(String label) { this.label = label; }
    public String getLabel() { return label; }
}

然后在JSP中根据不同状态显示不同样式：

<td class="status-${r.status}">
    <c:choose>
        <c:when test="${r.status == 'PENDING'}">⏳ ${r.statusLabel}</c:when>
        <c:when test="${r.status == 'PROCESSING'}">🔧 ${r.statusLabel}</c:when>
        <c:when test="${r.status == 'COMPLETED'}">✅ ${r.statusLabel}</c:when>
        <c:otherwise>❌ ${r.statusLabel}</c:otherwise>
    </c:choose>
</td>

---

部署上线：从WAR包到生产环境的最后一步

开发完成≠万事大吉。部署才是检验真理的唯一标准 🧪

首先打包成WAR文件。如果你用Maven，只需要一行命令：

mvn clean package

就会在 target/ 目录下生成 dormitory-system.war 。

然后把WAR包扔进Tomcat的 webapps/ 目录，启动服务器：

./startup.sh

Tomcat会自动解压并部署应用。访问 http://localhost:8080/dormitory-system 就能看到首页。

如果想自定义上下文路径（比如去掉项目名），可以在 conf/server.xml 里加：

<Context path="/dorm" docBase="dormitory-system.war" reloadable="false"/>

以后就可以通过 http://localhost:8080/dorm 访问了。

常见问题排查清单 ✅：
| 现象 | 可能原因 | 解决方案 |
|------|---------|----------|
| 404 Not Found | WAR未正确解压 | 检查 webapps/ 是否有对应目录 |
| 500 Internal Error | web.xml配置错误 | 查看 logs/catalina.out 日志 |
| ClassNotFoundException | 缺少jar包 | 把依赖放入 WEB-INF/lib |
| 数据库连接失败 | 驱动缺失或URL错误 | 确认 mysql-connector-java.jar 存在且URL正确 |
| 中文乱码 | 字符集未设置 | 在连接字符串加 characterEncoding=utf8 |

建议开启日志监控：

tail -f logs/catalina.out

实时观察启动过程，哪里出错一目了然。

---

总结：技术从来不是孤立存在的

讲了这么多，你会发现： 没有任何一项技术是孤立存在的 。

• JSP依赖Servlet容器来编译执行；
• Servlet依靠 web.xml 或注解完成路由映射；
• 数据库操作离不开连接池和事务管理；
• MVC架构需要三层紧密协作才能运转；
• 最终部署还要考虑服务器配置和安全性。

真正优秀的开发者，不仅要会写代码，更要理解这些组件之间是如何协同工作的。当你下次遇到“页面打不开”、“数据没更新”、“登录不了”等问题时，就能迅速定位是哪一环出了问题。

这套基于原生JavaWeb的技术栈，虽然不如Spring Boot那样“开箱即用”，但它能让你看清Web应用的本质。掌握了这些底层机制，再去学任何框架都会事半功倍。

毕竟，万变不离其宗嘛 💡

本文还有配套的精品资源，点击获取

简介：学生宿舍管理系统是一个典型的JavaWeb应用，采用JSP实现页面展示，Servlet处理业务逻辑，MySQL进行数据存储，实现了用户管理、宿舍管理、学生信息关联、报修流程跟踪及数据统计报表等核心功能。本文详细解析系统架构与开发流程，涵盖数据库设计、前后端交互、权限控制和部署测试，项目经过完整测试，适用于学习JavaWeb全栈开发的初学者掌握Web应用程序的构建方法。

本文还有配套的精品资源，点击获取