基于JSP+Servlet的大学宿舍信息管理系统 - 源码深度解析

JavaJavaScriptHTMLCSSMySQLJSP+Servlet
2026-02-105 浏览

文章摘要

本项目是一款专为高校宿舍管理场景设计的全流程信息化解决方案，核心业务价值在于彻底改变传统依赖纸质登记和人工沟通的低效管理模式。系统精准解决了高校后勤部门在学生住宿信息更新不及时、床位分配与调整流程繁琐、访客与物品出入记录缺失等核心痛点，通过数字化手段实现了宿舍资源的精细化管控与信息的实时同步，显著提...

高校宿舍智能管理平台：JSP+Servlet全流程信息化解决方案

在高校后勤管理领域，宿舍管理一直是一个复杂而关键的环节。传统的人工登记、纸质档案管理方式不仅效率低下，还容易导致数据不一致和信息滞后。本系统通过JSP+Servlet技术栈构建了一个完整的宿舍管理解决方案，实现了从学生入住到日常管理的全流程数字化。

系统架构与技术栈

系统采用经典的MVC架构模式，前端使用JSP进行页面渲染，结合HTML、CSS和JavaScript实现用户交互。后端以Servlet作为核心控制器，处理所有业务逻辑请求。数据持久层采用纯JDBC方式与MySQL数据库进行交互，通过DAO模式封装数据访问逻辑。

技术栈选择体现了成熟稳定的企业级Java Web开发方案：

  • 表示层：JSP、HTML5、CSS3、JavaScript
  • 控制层：Servlet、Filter、Listener
  • 数据层：JDBC、MySQL连接池
  • 服务器：Tomcat等Servlet容器

这种分层架构确保了代码的可维护性和扩展性，各层职责明确，耦合度低。

数据库设计亮点分析

学生信息表设计优化

CREATE TABLE `t_student` (
  `studentId` int(11) NOT NULL AUTO_INCREMENT,
  `stuNum` varchar(255) DEFAULT NULL COMMENT '学号',
  `password` varchar(255) DEFAULT NULL COMMENT '密码',
  `name` varchar(255) DEFAULT NULL COMMENT '名字',
  `dormBuildId` int(11) DEFAULT NULL COMMENT '宿舍楼ID',
  `dormName` varchar(11) DEFAULT NULL COMMENT '宿舍名称',
  `sex` varchar(255) DEFAULT NULL COMMENT '性别',
  `tel` varchar(15) DEFAULT NULL COMMENT '电话',
  PRIMARY KEY (`studentId`)
) ENGINE=InnoDB AUTO_INCREMENT=33 DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci COMMENT='学生表'

该表设计体现了几个重要优化考虑：

  1. 主键设计：使用自增整数作为主键，提高索引效率，同时避免学号变更带来的外键关联问题
  2. 字段长度优化：电话号码字段限制为15字符，符合国际号码标准；宿舍名称限制为11字符，适应常见命名规范
  3. 字符集选择：采用utf8字符集，支持中文存储，避免乱码问题
  4. 注释完整性：每个字段都添加了详细的注释，提高可维护性

宿舍管理表的关系设计

CREATE TABLE `t_dorm` (
  `dormId` int(11) NOT NULL AUTO_INCREMENT,
  `dormBuildId` int(11) DEFAULT NULL COMMENT '宿舍楼ID',
  `dormName` varchar(255) DEFAULT NULL COMMENT '宿舍名称',
  `dormType` varchar(255) DEFAULT NULL COMMENT '宿舍类型',
  `dormNumber` int(11) DEFAULT NULL COMMENT '宿舍人数',
  `dormTel` varchar(255) DEFAULT NULL COMMENT '宿舍电话',
  PRIMARY KEY (`dormId`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci COMMENT='宿舍表'

宿舍表的设计支持灵活的宿舍管理：

  • 层级关系：通过dormBuildId建立与宿舍楼的关联，支持多栋楼宇管理
  • 类型分类：dormType字段支持不同类型宿舍（如4人间、6人间）的分类管理
  • 容量控制：dormNumber字段确保宿舍人数不超过设计容量

记录表的审计追踪设计

CREATE TABLE `t_record` (
  `recordId` int(11) NOT NULL AUTO_INCREMENT,
  `studentNumber` varchar(255) DEFAULT NULL COMMENT '学号',
  `studentName` varchar(255) DEFAULT NULL COMMENT '学生姓名',
  `dormBuildId` int(11) DEFAULT NULL COMMENT '宿舍楼ID',
  `dormName` varchar(11) DEFAULT NULL COMMENT '宿舍名称',
  `date` date DEFAULT NULL COMMENT '日期',
  `detail` varchar(255) DEFAULT NULL COMMENT '详情',
  PRIMARY KEY (`recordId`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci COMMENT='记录表'

记录表的设计实现了完整的审计追踪功能：

  • 时间戳记录：date字段记录操作时间，支持按时间范围查询
  • 详细信息存储：detail字段存储具体的操作内容，满足审计要求
  • 学生信息冗余：同时存储学号和姓名，避免联表查询，提高查询效率

数据库结构

核心功能实现深度解析

多角色权限管理系统

系统设计了三级权限体系：系统管理员、宿舍管理员和学生。每种角色拥有不同的操作权限和界面视图。

权限控制Servlet实现：

public class AuthFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, 
                        FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        HttpSession session = httpRequest.getSession(false);
        
        String requestURI = httpRequest.getRequestURI();
        
        // 公开资源放行
        if (requestURI.endsWith("login.jsp") || requestURI.endsWith("loginServlet")) {
            chain.doFilter(request, response);
            return;
        }
        
        // 检查用户登录状态和权限
        if (session == null || session.getAttribute("user") == null) {
            httpResponse.sendRedirect(httpRequest.getContextPath() + "/login.jsp");
            return;
        }
        
        User user = (User) session.getAttribute("user");
        if (!hasPermission(user, requestURI)) {
            httpResponse.sendError(HttpServletResponse.SC_FORBIDDEN, "权限不足");
            return;
        }
        
        chain.doFilter(request, response);
    }
    
    private boolean hasPermission(User user, String uri) {
        String role = user.getRole();
        // 根据角色和URI进行权限验证
        if ("admin".equals(role)) {
            return uri.contains("/admin/");
        } else if ("dormManager".equals(role)) {
            return uri.contains("/dorm/");
        } else if ("student".equals(role)) {
            return uri.contains("/student/");
        }
        return false;
    }
}

宿舍分配算法实现

系统采用智能宿舍分配算法，考虑性别、专业、班级等多重因素，实现合理的宿舍分配。

宿舍分配核心逻辑：

public class DormAllocationService {
    
    public List<AllocationResult> autoAllocateDorms(List<Student> students, 
                                                   List<Dorm> availableDorms) {
        // 按性别分组
        Map<String, List<Student>> studentsByGender = students.stream()
            .collect(Collectors.groupingBy(Student::getSex));
        
        Map<String, List<Dorm>> dormsByGender = availableDorms.stream()
            .collect(Collectors.groupingBy(Dorm::getDormType));
        
        List<AllocationResult> results = new ArrayList<>();
        
        // 分别处理不同性别的学生分配
        for (String gender : studentsByGender.keySet()) {
            List<Student> genderStudents = studentsByGender.get(gender);
            List<Dorm> genderDorms = dormsByGender.get(gender);
            
            // 按专业和班级排序，尽量让同专业同班级的学生住在一起
            genderStudents.sort(Comparator.comparing(Student::getMajor)
                                         .thenComparing(Student::getClassName));
            
            results.addAll(allocateForGender(genderStudents, genderDorms));
        }
        
        return results;
    }
    
    private List<AllocationResult> allocateForGender(List<Student> students, 
                                                    List<Dorm> dorms) {
        List<AllocationResult> results = new ArrayList<>();
        int studentIndex = 0;
        
        for (Dorm dorm : dorms) {
            int capacity = dorm.getDormNumber();
            List<Student> dormStudents = new ArrayList<>();
            
            for (int i = 0; i < capacity && studentIndex < students.size(); i++) {
                dormStudents.add(students.get(studentIndex));
                studentIndex++;
            }
            
            if (!dormStudents.isEmpty()) {
                results.add(new AllocationResult(dorm, dormStudents));
            }
            
            if (studentIndex >= students.size()) {
                break;
            }
        }
        
        return results;
    }
}

考勤记录管理功能

系统提供完善的考勤记录管理，支持晚归登记、缺勤记录等功能。

考勤记录DAO实现：

public class RecordDAO {
    private Connection conn;
    
    public RecordDAO(Connection connection) {
        this.conn = connection;
    }
    
    public boolean addRecord(Record record) throws SQLException {
        String sql = "INSERT INTO t_record (studentNumber, studentName, " +
                    "dormBuildId, dormName, date, detail) VALUES (?, ?, ?, ?, ?, ?)";
        
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, record.getStudentNumber());
            pstmt.setString(2, record.getStudentName());
            pstmt.setInt(3, record.getDormBuildId());
            pstmt.setString(4, record.getDormName());
            pstmt.setDate(5, new java.sql.Date(record.getDate().getTime()));
            pstmt.setString(6, record.getDetail());
            
            return pstmt.executeUpdate() > 0;
        }
    }
    
    public List<Record> getRecordsByDorm(String dormName, Date startDate, Date endDate) 
            throws SQLException {
        String sql = "SELECT * FROM t_record WHERE dormName = ? " +
                    "AND date BETWEEN ? AND ? ORDER BY date DESC";
        
        List<Record> records = new ArrayList<>();
        
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, dormName);
            pstmt.setDate(2, new java.sql.Date(startDate.getTime()));
            pstmt.setDate(3, new java.sql.Date(endDate.getTime()));
            
            ResultSet rs = pstmt.executeQuery();
            while (rs.next()) {
                records.add(extractRecordFromResultSet(rs));
            }
        }
        
        return records;
    }
    
    private Record extractRecordFromResultSet(ResultSet rs) throws SQLException {
        Record record = new Record();
        record.setRecordId(rs.getInt("recordId"));
        record.setStudentNumber(rs.getString("studentNumber"));
        record.setStudentName(rs.getString("studentName"));
        record.setDormBuildId(rs.getInt("dormBuildId"));
        record.setDormName(rs.getString("dormName"));
        record.setDate(rs.getDate("date"));
        record.setDetail(rs.getString("detail"));
        return record;
    }
}

缺勤记录管理

学生信息管理模块

学生信息管理模块提供完整的学生信息CRUD操作，支持批量导入导出功能。

学生信息Servlet控制器：

@WebServlet("/student/*")
public class StudentServlet extends HttpServlet {
    private StudentService studentService = new StudentService();
    
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        String action = request.getPathInfo();
        
        switch (action) {
            case "/list":
                showStudentList(request, response);
                break;
            case "/edit":
                showEditForm(request, response);
                break;
            case "/delete":
                deleteStudent(request, response);
                break;
            default:
                showStudentList(request, response);
        }
    }
    
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        String action = request.getPathInfo();
        
        if ("/save".equals(action)) {
            saveStudent(request, response);
        } else if ("/update".equals(action)) {
            updateStudent(request, response);
        }
    }
    
    private void showStudentList(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        try {
            int page = Integer.parseInt(request.getParameter("page") == null ? 
                                       "1" : request.getParameter("page"));
            int size = 10;
            
            List<Student> students = studentService.getStudentsByPage(page, size);
            int totalCount = studentService.getTotalCount();
            int totalPages = (int) Math.ceil((double) totalCount / size);
            
            request.setAttribute("students", students);
            request.setAttribute("currentPage", page);
            request.setAttribute("totalPages", totalPages);
            request.getRequestDispatcher("/admin/studentList.jsp").forward(request, response);
            
        } catch (SQLException e) {
            throw new ServletException("数据库操作失败", e);
        }
    }
    
    private void saveStudent(HttpServletRequest request, HttpServletResponse response) 
            throws ServletException, IOException {
        try {
            Student student = extractStudentFromRequest(request);
            boolean success = studentService.addStudent(student);
            
            if (success) {
                request.getSession().setAttribute("message", "学生信息添加成功");
            } else {
                request.getSession().setAttribute("error", "学生信息添加失败");
            }
            
            response.sendRedirect(request.getContextPath() + "/student/list");
            
        } catch (SQLException e) {
            throw new ServletException("数据库操作失败", e);
        }
    }
}

学生管理界面

宿舍管理员功能实现

宿舍管理员模块专注于日常宿舍管理工作，包括学生信息查看、考勤记录添加等。

宿舍管理员服务层：

public class DormManagerService {
    private DormManagerDAO dormManagerDAO = new DormManagerDAO();
    private RecordDAO recordDAO = new RecordDAO();
    
    public List<Student> getStudentsByDormBuild(int dormBuildId) throws SQLException {
        return dormManagerDAO.getStudentsByDormBuild(dormBuildId);
    }
    
    public boolean addAbsenceRecord(String studentNumber, String detail) throws SQLException {
        // 获取学生信息
        Student student = dormManagerDAO.getStudentByNumber(studentNumber);
        if (student == null) {
            return false;
        }
        
        // 创建缺勤记录
        Record record = new Record();
        record.setStudentNumber(studentNumber);
        record.setStudentName(student.getName());
        record.setDormBuildId(student.getDormBuildId());
        record.setDormName(student.getDormName());
        record.setDate(new Date());
        record.setDetail(detail);
        
        return recordDAO.addRecord(record);
    }
    
    public List<Record> getRecentRecords(int dormBuildId, int days) throws SQLException {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DAY_OF_MONTH, -days);
        Date startDate = calendar.getTime();
        Date endDate = new Date();
        
        return recordDAO.getRecordsByDormBuildAndDateRange(dormBuildId, startDate, endDate);
    }
}

宿舍管理员查看学生

实体模型设计

系统采用面向对象的设计思想，构建了完整的实体模型体系：

学生实体类设计：

public class Student {
    private int studentId;
    private String stuNum;
    private String password;
    private String name;
    private int dormBuildId;
    private String dormName;
    private String sex;
    private String tel;
    private String major;
    private String className;
    
    // 构造函数
    public Student() {}
    
    public Student(String stuNum, String password, String name, int dormBuildId, 
                  String dormName, String sex, String tel) {
        this.stuNum = stuNum;
        this.password = password;
        this.name = name;
        this.dormBuildId = dormBuildId;
        this.dormName = dormName;
        this.sex = sex;
        this.tel = tel;
    }
    
    // Getter和Setter方法
    public int getStudentId() { return studentId; }
    public void setStudentId(int studentId) { this.studentId = studentId; }
    
    public String getStuNum() { return stuNum; }
    public void setStuNum(String stuNum) { this.stuNum = stuNum; }
    
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    
    // ... 其他getter/setter方法
}

宿舍实体类设计：

public class Dorm {
    private int dormId;
    private int dormBuildId;
    private String dormName;
    private String dormType;
    private int dormNumber;
    private String dormTel;
    private int currentNumber; // 当前居住人数
    private String buildName;  // 宿舍楼名称
    
    // 业务方法
    public boolean isFull() {
        return currentNumber >= dormNumber;
    }
    
    public int getAvailableBeds() {
        return dormNumber - currentNumber;
    }
    
    public boolean canAccommodate(int number) {
        return getAvailableBeds() >= number;
    }
    
    // Getter和Setter方法
    public int getDormId() { return dormId; }
    public void setDormId(int dormId) { this.dormId = dormId; }
    
    public int getDormBuildId() { return dormBuildId; }
    public void setDormBuildId(int dormBuildId) { this.dormBuildId = dormBuildId; }
    
    // ... 其他getter/setter方法
}

功能展望与优化方向

1. 引入Redis缓存提升性能

当前系统直接访问MySQL数据库，在高并发场景下可能存在性能瓶颈。引入Redis作为缓存层可以显著提升系统响应速度。

实现方案：

public class StudentServiceWithCache {
    private StudentDAO studentDAO;
    private RedisTemplate redisTemplate;
    
    public Student getStudentByNumber(String stuNum) {
        String cacheKey = "student:" + stuNum;
        Student student = (Student) redisTemplate.opsForValue().get(cacheKey
本文关键词
JSPServlet大学宿舍信息管理系统源码解析MVC架构

上下篇

上一篇
没有更多文章
下一篇
没有更多文章