Java系统eclipse和idea都可以SpringBoot 高校宿舍管理系统附源码带论文

个人名片：
作者简介：一名大三在校生，计科专业
个人主页：莫白媛
座右铭：舒服是留给死人的
**学习目标: 坚持每一次的学习打卡，掌握更多知识！还要学iOS开发和考研呢！

一 摘要说明

基于 SpringBoot 的高校宿舍管理系统设计与开发
摘 要：宿舍是大学生学习与生活的主要场所之一，宿舍管理是高校学工管理事务中尤为重要的一项。随着我国高校招生规模的进一步扩大，学生总体人数的不断增加，宿舍管理工作变得愈加沉重和琐碎，学生宿舍信息的采集、汇总、统计与分析等各项工作都面临诸多困难，传统的管理模式早已无法满足当前我国高校的管理需求了。因此，迫切需要研究设计和开发一个新型的高校宿舍管理系统，以便更好地满足高校宿舍管理工作的实际需求，方便宿管人员开展管理工作，提升管理水平，提高工作效率，节约人力、物力，为广大学生群体提供更优质、高效的服务。基于上述背景，本文设计并开发了一个高校宿舍管理系统。系统采用 B/S 架构，后端基于 Java 语言和 SpringBoot 框架的方式进行了开发，前端则是使用 Layui 框
架，结合 HTML、JQuery、Ajax 等技术进行开发，并使用 MySQL 数据库对所有相关的信息进行了存储。系统主要包括基本信息管理、离返校管理、宿舍分配管理、宿舍日常管理、综合查询管理等五大功能模块，并根据学生、辅导员、宿舍管理员的使用需求对这些功能进行了细化和实现。通过本系统能够方便、快捷地采集、查看、统计相关的信息，并以图形化界面的方式展示出来，较好地满足了目标用户的需求，提高了宿舍管理的水平，有利于我国推进高校学工管理真正实现信息化、科学化、
规范化的历史性进程。
关键词：宿舍管理；SpringBoot；宿舍分配；管理系统

二 主要功能描述

通过对宿舍管理工作中相关业务流程的调研和分析，确定了系统的功能主要有：
（1）基本信息管理
基本信息分为学生信息和宿舍信息两部分，其功能是负责维护这些信息，对它们进行增删查改等操作。
（2）宿舍分配管理
根据给定的宿舍信息与学生信息，按照一定的规则自动地给还未分配宿舍的学生分配宿舍，学生可在该宿舍内自选床位，最终的宿舍分配信息可以以文件形
式（如 Excel 表格）导出。
（3）宿舍日常管理
主要包括卫生管理、报修管理、留言管理等。
卫生管理：记录并维护卫生检查信息。
报修管理：添加、查看、修改报修单信息。
留言管理：包括发布公告、失物招领、普通留言以及对这些信息的维护。
（4）离返校管理
对节假日学生的去向、寒暑假学生的留校以及返校登记信息进行统计及管
理，并以图表形式呈现统计信息。
（5）综合查询管理
包括查找学生信息、各楼栋/专业的学生宿舍分配情况、卫生检查情况、学
生离返校及留校信息、指定类型的留言、查看宿舍成员等

2.3.2 用例建模

本系统所面向的客户群主要分为学生、辅导员和宿舍管理员三种类型的用户，不同类型的用户对系统的功能具有不同的需求。
（1）学生
可以选择床位、查看自己所在的宿舍以及同宿舍人员的信息；填写、查看和修改自己宿舍的报修单；查看每周的卫生检查情况；节假日时填写离校登记信息、寒暑假提交留校申请以及填写返校登记信息；查看留言板上的公告、失物招领信息，发布留言等；修改自己的基本信息和账号的密码。学生用例如图 2.1 所示。

（2）辅导员
负责维护学生的基本信息；查看学生宿舍分配信息；查看学生节假日的去向信息和返校信息；查看和审批学生的寒暑假留校的申请；查看学生的卫生检查情况。辅导员用例如图 2.2 所示。

（3）宿舍管理员
负责维护宿舍信息；为新生分配宿舍；处理学生的报修申请；发布公告、失物招领等信息到留言板上；查看学生寒暑假留校信息；每周进行卫生检查并将检查情况记录到系统中。宿舍管理员用例如图 2.3 所示。

2.3.3 行为建模

由于篇幅的限制，以下将通过活动图来对系统一些重要功能的业务流程进行行为
建模。
（1）查看宿舍信息
学生登录到系统中之后，选择查看自己宿舍信息，如果是第一次使用本系统，系统会提示学生还没有选择床位，学生床位选取完毕后系统将显示学生所在宿舍的相关信息。其活动图如图 2.4 所示。

（2）填写留校申请
学生登录后，填写留校申请信息，并提交到系统中保存。其活动图如下图 2.5所示。

（3）添加学生信息
辅导员登录后，可以单个地或批量地添加学生信息。其活动图如图 2.6 所示

（4）审批留校申请
辅导员登录后可以对学生的留校申请进行审批，选择批准或不批准并填写意见，最后提交给系统保存。其活动图如图 2.7 所示。

（5）预分配宿舍
宿舍管理员成功进入系统后，可以为没有住宿信息的学生分配宿舍。选择学
生名单和空余宿舍列表提交给系统，由系统按照学院、专业、班级、性别相同或
邻近的聚集居住的原则，按学号从小到大的顺序依次为学生安排宿舍。其活动图如图 2.8

（6）添加卫生检查记录
宿舍管理员登录后，可以单个或批量地添加卫生检查记录。其活动图如图 2.9所示

3.1 系统体系结构

系统遵照 MVC 设计架构理念和工作模式，采用了三层体系结构，分别为表现层、业务逻辑层以及数据访问层。

表现层：用于接收用户的输入数据以及呈现业务逻辑层返回的数据。简而言之，就是呈现给用户的界面。
业务逻辑层：对从客户端接收到的数据信息进行逻辑化的处理，通过调用数据访问层所提供的接口来完成对数据的获取、修改等功能，最后把处理的结果反馈给上一层。
数据访问层：直接与数据库进行交互，实现对数据的增删查改等操作，并将操作的结果返回给上一层。

3.2 功能模块设计

依据前文对系统功能的具体描述以及针对用户实际需求的综合分析，系统主要功能的模块结构如下图所示。

ER图和数据表设计找我私聊或者评论

三 系统实现（最后有代码源码）

4.1.1 登录（最后有代码源码）

为了保证系统的安全性，用户在进入系统前必须先登录，通过账号的合法性检验后才能进入系统。登录的界面如图 4.1 所示，用户输入账号信息，点击“登录”的按钮，将表单数据提交到后端。如果存在相应的用户信息，则系统跳转到对应权限的页面；不然验证失败，系统给予错误提示。

4.1.2 学生端

学生端主页面如图 4.2 所示，其功能主要包括了我的宿舍、离返校登记、留言板、基本资料管理等。

（1）我的宿舍

包含了我的宿舍、我的报修和卫生检查记录三个子功能。
 我的宿舍学生可以查看本人所在的宿舍和室友的信息。如果是初次进入本系统，系统将提示学生选择床位，床位选择界面如图 4.3 所示，学生可以根据系统提供的宿舍布局为参考，从未被选择的床位中选取自己想要的床位。

 我的报修
学生可以查看本宿舍的报修信息（包括自己提交的和他人提交的），填写和修改报修单信息，但只能修改本人提交的报修单，且只能修改未处理的，正在处理和已处理的报修信息则不能被更改。

 卫生检查记录
学生可以查看自己宿舍的卫生检查情况，系统优先显示近期的记录，对于不合格（低于 60 分）的记录，系统将高亮显示，提醒学生。

（2）离返校登记

包括了离校登记、返校登记以及留校申请三个子功能。
 离校登记
系统将显示学生所有的离校登记信息，学生也可以在该页面下提交和编辑登记信息。填写时，学生需选择去向类型，如果是回家或者外出，必须填写目的地、回校时间、紧急联系人，如果是留校，以上三项信息则无需填写。

 留校申请
寒暑假期间有留校需求的学生需要向学院提交留校申请。申请填写页面如图4.8 所示，学生需要说明留校的原因，留校的截止时间，并提供家长手写的同意留校及安全保证承诺的图片。

 返校登记
临近开学时学生要填写返校信息，主要内容有是否要延迟返校、返校时间、延迟的原因、交通方式以及车次的信息。

（3）留言板
在这里，学生可以查看所在楼栋的相关留言信息，包括公告、失物招领以及普通留言；也可以发布留言与他人进行沟通，编辑和查看自己的留言等。留言信息以便签的形式呈现出来，不同类型的留言使用不同的底色以示区分。

四 源码

controller
DorMController.java

package com.usc.lzh.doms.controller;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.usc.lzh.doms.entity.*;
import com.usc.lzh.doms.service.DorMService;
import com.usc.lzh.doms.utils.MyStringUtil;
import com.usc.lzh.doms.utils.DataGridViewResult;
import com.usc.lzh.doms.utils.ExcelUtils;
import com.usc.lzh.doms.vo.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import com.alibaba.fastjson.JSON;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.text.SimpleDateFormat;
import java.util.*;

@Controller
@RequestMapping("/dm")
public class DorMController {

    @Resource
    private DorMService dormService;

    /**
     * 卫生检查列表
     *
     * @return
     */
    @RequestMapping(value = "/cleanList")
    public String cleanList() {
        return "/dm/clean-list";
    }

    /**
     * 查看卫生检查情况
     *
     * @param ciVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/list")
    public DataGridViewResult findCleanInfoList(CleanInfoVo ciVo, HttpServletRequest request) {
        // 获取宿管员管理的宿舍区和楼栋号，拼接成brcode
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        String brcode = MyStringUtil.getBrcode(brarea, brbid, "");
        if (StringUtils.isNotBlank(brcode)) {
            ciVo.setBrcode(brcode);
        }
        System.out.println(ciVo);

        // 设置分页信息
        PageHelper.startPage(ciVo.getPage(), ciVo.getLimit());
        // 查询
        List<CleanInfo> list = dormService.findCleanInfoListByPage(ciVo);
        // 创建分页对象
        PageInfo<CleanInfo> pageInfo = new PageInfo<CleanInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 更改卫生检查信息
     *
     * @param ci
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/update")
    public String updateCleanInfo(CleanInfo ci) {
        System.out.println(ci);
        HashMap<String, Object> map = new HashMap<>();
        int result = dormService.updateCleanInfo(ci);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "更改成功！");
        } else {
            map.put("success", false);
            map.put("msg", "更改失败！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 删除卫生检查记录
     *
     * @param id
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/delete")
    public String deleteCleanInfo(String id) {
        System.out.println(id);
        HashMap<String, Object> map = new HashMap<>();
        int result = dormService.deleteCleanInfo(id);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "删除成功！");
        } else {
            map.put("success", false);
            map.put("msg", "删除失败！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 返回添加卫生检查记录页面
     *
     * @return
     */
    @RequestMapping(value = "/clean/add.html")
    public String addCleanInfo() {
        return "/dm/clean-add";
    }

    /**
     * 批量添加卫生检查记录
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/add")
    public String batchAddCleanInfo(HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        String params = request.getParameter("params");
        String checker = (String) request.getSession().getAttribute("uname");
        try {
            boolean result = dormService.batchInsertCleanInfo(params, checker);
            if (result) {
                map.put("success", true);
                map.put("msg", "添加成功！");
            } else {
                map.put("success", false);
                map.put("msg", "添加失败！");
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "添加失败！");
        }
        return JSON.toJSONString(map);
    }


    /**
     * 学生报修列表
     *
     * @return
     */
    @RequestMapping(value = "/repairList")
    public String viewRepairList() {
        return "/dm/repair-list";
    }

    /**
     * 查找该宿管员负责的楼栋下的报修信息
     *
     * @param riVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/repair/list")
    public DataGridViewResult findRepairInfoList(RepairInfoVo riVo, HttpServletRequest request) {
        // 拼接brcode
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        if (StringUtils.isBlank(brarea)) {
            brarea = riVo.getBrarea();
        }
        if (StringUtils.isBlank(brbid)) {
            brbid = riVo.getBrbid();
        }
        String brcode = MyStringUtil.getBrcode(brarea, brbid, "");
        if (StringUtils.isNotBlank(brcode)) {
            riVo.setBrcode(brcode);
        }
        System.out.println(riVo);

        // 设置分页信息
        PageHelper.startPage(riVo.getPage(), riVo.getLimit());
        // 查询
        List<RepairInfo> list = dormService.findRepairInfoListByPage(riVo);
        // 创建分页对象
        PageInfo<RepairInfo> pageInfo = new PageInfo<RepairInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 查看报修详情
     *
     * @return
     */
    @RequestMapping(value = "/repair/detail.html")
    public String repairDetail() {
        return "/dm/repair-detail";
    }


    /**
     * 导出报修数据
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @RequestMapping(value = "/repair/export.action")
    public void exportToExcel(HttpServletRequest request, HttpServletResponse response) {
        HashMap<String, Object> map = new HashMap<>();
        response.reset();// 清除缓存

        // 获取宿管员管理的宿舍区和楼栋号，拼接成brcode
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        String brcode = MyStringUtil.getBrcode(brarea, brbid, "");
        String status = request.getParameter("status");

        System.out.println("status" + status);
        System.out.println("brcode" + brcode);
        // 根据条件查找报修列表
        List<RepairInfo> list = dormService.exportRepairInfo(brcode, status);

        // 拼接excel表名
        StringBuffer filenamebuffer = new StringBuffer();
        if (StringUtils.isNotBlank(brcode)) {
            filenamebuffer.append(brcode);
            filenamebuffer.append("-");
        }
        filenamebuffer.append("报修表");
        String filename = filenamebuffer.toString();
        try {
            ExcelUtils.writeExcel(filename, response, list, RepairInfo.class);
            map.put("success", true);
            map.put("msg", "导出成功！");
            System.out.println(JSON.toJSONString(map));
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "导出失败！");
        }
//        return JSON.toJSONString(map);
    }

    /**
     * 批量更改报修状态
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/repair/edit")
    public String editRepairStatus(HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        String params = request.getParameter("params");
        if (StringUtils.isNotBlank(params)) {
            boolean result = dormService.batchEditRepairStatus(params);
            if (result) {
                map.put("success", true);
                map.put("msg", "更改成功！");
                return JSON.toJSONString(map);
            } else {
                map.put("success", false);
                map.put("msg", "更改失败！");
                return JSON.toJSONString(map);
            }
        }
        map.put("success", false);
        map.put("msg", "更改失败！请选择要更改的行。");
        return JSON.toJSONString(map);
    }

    /**
     * 学生报修列表
     *
     * @return
     */
    @RequestMapping(value = "/buildroomList")
    public String viewBuildRoomList() {
        return "/dm/buildroom-list";
    }

    /**
     * 查看宿舍信息
     *
     * @param biVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/buildroom/list")
    public DataGridViewResult findBuildRoomInfo(BuildRoomInfoVo biVo, HttpServletRequest request) {
        // 拼接brcode
        String brarea = (String) request.getSession().getAttribute("brarea");
        if (StringUtils.isBlank(brarea)) {
            brarea = biVo.getBrarea();
        }
        /*
         * 如果管理员负责具体的一栋楼，则只能查询本栋楼有关的宿舍信息；
         * 如果是负责一个区，则可以查询这个区下所有楼的宿舍信息
         * session中没有brbid说明是负责一个区的，此时按照用户输入的楼栋数来进行查询
         */
        String brbid = (String) request.getSession().getAttribute("brbid");
        if (StringUtils.isBlank(brbid)) {
            brbid = biVo.getBrbid();
        }
        String brrid = biVo.getBrrid();
        String brcode = MyStringUtil.getBrcode(brarea, brbid, brrid);
        if (StringUtils.isNotBlank(brcode)) {
            biVo.setBrcode(brcode);
        }
        System.out.println(biVo);

        // 设置分页信息
        PageHelper.startPage(biVo.getPage(), biVo.getLimit());
        // 查询
        List<RepairInfo> list = dormService.findBuildRoomInfoListByPage(biVo);
        // 创建分页对象
        PageInfo<RepairInfo> pageInfo = new PageInfo<RepairInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 单个添加宿舍信息
     *
     * @param bi
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/buildroom/add")
    public String addBuildRoomInfo(BuildRoomInfo bi) {
        HashMap<String, Object> map = new HashMap<>();
        // 拼接brcode，如果brcode是空，说明宿舍信息错误了
        String brarea = bi.getBrarea();
        String brbid = bi.getBrbid();
        String brrid = bi.getBrrid();
        String brcode = MyStringUtil.getBrcode(brarea, brbid, brrid);
        if (StringUtils.isBlank(brcode)) {
            map.put("success", false);
            map.put("msg", "添加失败！宿舍信息错误！");
            return JSON.toJSONString(map);
        }

        // 计算空余数
        Integer free = bi.getVolume() - bi.getPeople();
        if (free < 0) {
            map.put("success", false);
            map.put("msg", "添加失败！入住数不能大于床位数！");
            return JSON.toJSONString(map);
        }

        bi.setBrcode(brcode);
        bi.setFree(free);
        System.out.println(bi);
        List<BuildRoomInfo> list = new ArrayList<>();
        list.add(bi);

        boolean result = dormService.addBuildRoomInfo(list);
        if (result) {
            map.put("success", true);
            map.put("msg", "添加成功！");
        } else {
            map.put("success", false);
            map.put("msg", "添加失败！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 导入宿舍信息
     *
     * @param file excel表格
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/buildroom/import.action")
    public String importExcel(@RequestParam("file") MultipartFile file) {
        HashMap<String, Object> map = new HashMap<>();
        try {
            List<BuildRoomInfo> list = ExcelUtils.readExcel("", BuildRoomInfo.class, file);
            // 拼接brcode和计算空余数
            for (int i = 0; i < list.size(); i++) {
                String brarea = list.get(i).getBrarea();
                String brbid = list.get(i).getBrbid();
                String brrid = list.get(i).getBrrid();
                String brcode = MyStringUtil.getBrcode(brarea, brbid, brrid);
                Integer free = list.get(i).getVolume() - list.get(i).getPeople();
                list.get(i).setBrcode(brcode);
                list.get(i).setFree(free);
            }
            boolean result = dormService.addBuildRoomInfo(list);
            if (result) {
                map.put("code", 200);
                map.put("msg", "导入成功！");
                map.put("data", null);
            } else {
                map.put("code", 500);
                map.put("msg", "导入失败！");
                map.put("data", null);
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("code", 500);
            map.put("msg", "导入失败！");
            map.put("data", null);
        }
        return JSON.toJSONString(map);
    }

    /**
     * 更改宿舍信息
     *
     * @param bi
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/buildroom/update")
    public String updateBuildRoomInfo(BuildRoomInfo bi) {
        HashMap<String, Object> map = new HashMap<>();
        try {
            // 如果入住数小于等于床位数，则执行更新操作，否则返回提示
            Integer free = bi.getVolume() - bi.getPeople();
            if (free >= 0) {
                bi.setFree(free);
                System.out.println(bi);
                int result = dormService.updateBuildRoomInfo(bi);
                // 返回值大于0表示成功执行了更改操作，小于0表示发生了异常
                if (result > 0) {
                    map.put("success", true);
                    map.put("msg", "更改成功！");
                    return JSON.toJSONString(map);
                } else {
                    map.put("success", false);
                    map.put("msg", "更改失败！");
                    return JSON.toJSONString(map);
                }
            } else {
                map.put("success", false);
                map.put("msg", "更改失败！入住数不能大于床位数！");
                return JSON.toJSONString(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "更改失败！");
            return JSON.toJSONString(map);
        }
    }

    /**
     * 删除宿舍信息
     *
     * @param brcode
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/buildroom/delete")
    public String deleteBuildRoomInfo(String brcode) {
        System.out.println(brcode);
        HashMap<String, Object> map = new HashMap<>();
        int result = dormService.deleteBuildRoomInfo(brcode);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "删除成功！");
        } else {
            map.put("success", false);
            map.put("msg", "删除失败！");
        }
        return JSON.toJSONString(map);
    }

    @RequestMapping(value = "/messageList")
    public String viewMessageBoard() {
        return "/dm/message-list";
    }


    /**
     * 公告管理、失物招领
     *
     * @param mbVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/list")
    public DataGridViewResult findMessageList(MessageBoardVo mbVo, HttpServletRequest request) {
        // 获取当前管理员的管理区域
        // 如果管理员负责众多楼栋，则按查询条件的宿舍区和楼栋来查，否则只能查他所负责的楼栋的公告信息
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        if (StringUtils.isBlank(brarea)) {
            brarea = mbVo.getBrarea();
        }
        if (StringUtils.isBlank(brbid)) {
            brbid = mbVo.getBrbid();
        }
        String brcode = MyStringUtil.getBrcode(brarea, brbid, "");
        mbVo.setBrcode(brcode);
        System.out.println(mbVo);

        // 设置分页信息
        PageHelper.startPage(mbVo.getPage(), mbVo.getLimit());
        // 查询
        List<MessageBoard> list = dormService.findMessageListByPage(mbVo);
        // 创建分页对象
        PageInfo<MessageBoard> pageInfo = new PageInfo<MessageBoard>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 添加公告/失物招领信息
     *
     * @param mb
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/add")
    public String addMessage(MessageBoard mb, HttpServletRequest request) {
        // announcer是管理员的uname
        String uname = (String) request.getSession().getAttribute("uname");
        mb.setAnnouncer(uname);

        HashMap<String, Object> map = new HashMap<>();
        int result = dormService.addMessage(mb);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "添加成功！");
        } else {
            map.put("success", false);
            map.put("msg", "添加失败！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 更新公告/失物招领
     *
     * @param mb
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/update")
    public String updateMessage(MessageBoard mb) {
        // 拼接brcode
        String brcode = MyStringUtil.getBrcode(mb.getBrarea(), mb.getBrbid(), "");
        mb.setBrcode(brcode);

        System.out.println(mb);

        HashMap<String, Object> map = new HashMap<>();
        int result = dormService.updateMessage(mb);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "更改成功！");
        } else {
            map.put("success", false);
            map.put("msg", "更改失败！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 批量删除公告/失物招领信息
     *
     * @param request 获取前端传来的id数组
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/delete")
    public String deleteMessage(HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        String params = request.getParameter("params");
        System.out.println(params);
        try {
            if (StringUtils.isNotBlank(params)) {
                // 获取id数组
                JSONArray jsonArray = JSONArray.parseArray(params);
                List<Integer> list = new ArrayList<>();
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject obj = jsonArray.getJSONObject(i);
                    Integer id = (Integer) obj.get("id");
                    System.out.println(id);
                    list.add(id);
                }
                boolean result = dormService.deleteMessage(list);
                if (result) {
                    map.put("success", true);
                    map.put("msg", "删除成功！");
                } else {
                    map.put("success", false);
                    map.put("msg", "删除失败！");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "删除失败！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 留校信息列表
     *
     * @return
     */
    @RequestMapping(value = "/stayinList")
    public String viewStayInfoList() {
        return "/dm/stayin-list";
    }

    /**
     * 查找留校信息列表
     *
     * @param stVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/list")
    public DataGridViewResult findStayInfoListByPage(StayInfoVo stVo, HttpServletRequest request) {
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        if (StringUtils.isNotBlank(brarea)) {
            stVo.setBrarea(brarea);
        }
        if (StringUtils.isNotBlank(brbid)) {
            stVo.setBrbid(brbid);
        }
        System.out.println(stVo);
        // 设置分页信息
        PageHelper.startPage(stVo.getPage(), stVo.getLimit());
        // 查询
        List<StayInfo> list = dormService.findStayInfoListByPage(stVo);
        // 创建分页对象
        PageInfo<StayInfo> pageInfo = new PageInfo<StayInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 导出学生留校信息
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/export.action")
    public void exportStayInfoToExcel(HttpServletRequest request, HttpServletResponse response) {
        response.reset();// 清除缓存
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        // 查找学生登记信息
        List<StayInfo> list = dormService.exportStayInfo(brarea, brbid);

        // 拼接excel表名
        StringBuffer filenamebuffer = new StringBuffer();
        if (StringUtils.isNotBlank(brarea)) {
            filenamebuffer.append(brarea);
            filenamebuffer.append("-");
        }
        if (StringUtils.isNotBlank(brbid)) {
            filenamebuffer.append(brbid);
            filenamebuffer.append("栋-");
        }
        filenamebuffer.append("学生留校信息");
        String filename = filenamebuffer.toString();
        try {
            ExcelUtils.writeExcel(filename, response, list, StayInfo.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取留校申请中的统计数据
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/echartsData")
    public String getStayInfoEchartsData(HttpServletRequest request) {
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        JSONObject data = dormService.getStayInfoEchartsData(brarea, brbid);
        System.out.println(JSON.toJSONString(data));
        return JSON.toJSONString(data);
    }

    /**
     * 预分配宿舍界面
     *
     * @return
     */
    @RequestMapping(value = "/allocation/pre")
    public String preAllocateDorm() {
        return "/dm/pre-allocate";
    }

    /**
     * 查找空余寝室
     *
     * @param biVo
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/room/list")
    public DataGridViewResult getFreeRoomList(BuildRoomInfoVo biVo) {
        System.out.println(biVo);
        // 设置分页信息
        PageHelper.startPage(biVo.getPage(), biVo.getLimit());
        // 查询
        List<BuildRoomInfo> list = dormService.findFreeRoomListByPage(biVo);
        // 创建分页对象
        PageInfo<BuildRoomInfo> pageInfo = new PageInfo<BuildRoomInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 查找未分配寝室的学生
     *
     * @param siVo
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/student/list")
    public DataGridViewResult getNotAllocateStudentList(StudentInfoVo siVo) {
        System.out.println(siVo);
        // 设置分页信息
        PageHelper.startPage(siVo.getPage(), siVo.getLimit());
        // 查询
        List<StudentInfo> list = dormService.findNotAllocateStudentListByPage(siVo);
        // 创建分页对象
        PageInfo<StudentInfo> pageInfo = new PageInfo<StudentInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    @ResponseBody
    @RequestMapping(value = "/allocation/doAllocate")
    public String doAllocate(HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        String room = request.getParameter("room");
        String student = request.getParameter("student");
        System.out.println(room);
        System.out.println(student);
        map.put("msg", "接受到数据");
        return JSON.toJSONString(map);
    }

    /**
     * 判断床位数够不够
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/isEnough")
    public String judgeIsEnough() {
        HashMap<String, Object> map = new HashMap<>();
        boolean enough = dormService.judgeIsEnough();
        if (enough) {
            map.put("success", true);
        } else {
            map.put("success", false);
            map.put("msg", "床位数不够，请先添加空余宿舍信息！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 全部分配
     *
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/assignAll")
    public String assignAll() {
        HashMap<String, Object> map = new HashMap<>();
        boolean success = dormService.doAssignAll();
        if (success) {
            map.put("success", true);
            map.put("msg", "分配完毕，分配结果显示在当前页面下方。");
        } else {
            map.put("success", false);
            map.put("msg", "分配失败！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 显示分配结果
     *
     * @param aiVo
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/result")
    public DataGridViewResult viewAllocateResult(AllocationInfoVo aiVo) {
        // 设置分页信息
        PageHelper.startPage(aiVo.getPage(), aiVo.getLimit());
        // 查询
        List<AllocationInfo> list = dormService.viewAllocateResult(aiVo);
        // 创建分页对象
        PageInfo<AllocationInfo> pageInfo = new PageInfo<AllocationInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }


    /**
     * 宿舍分配列表
     *
     * @return
     */
    @RequestMapping(value = "/allocation/list")
    public String allocationList() {
        return "/dm/allocation-list";
    }


    /**
     * 查询宿舍分配信息
     * 查询条件：专业/年级
     *
     * @param aiVo
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/info")
    public DataGridViewResult findAllocationInfoList(AllocationInfoVo aiVo, HttpServletRequest request) {
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        if (StringUtils.isNotBlank(brarea)) {
            aiVo.setBrarea(brarea);
        }
        if (StringUtils.isNotBlank(brbid)) {
            aiVo.setBrbid(brbid);
        }
        System.out.println(aiVo);
        // 设置分页信息
        PageHelper.startPage(aiVo.getPage(), aiVo.getLimit());
        // 查询
        List<AllocationInfo> list = dormService.findAllocationInfoListByPage(aiVo);
        // 创建分页对象
        PageInfo<AllocationInfo> pageInfo = new PageInfo<AllocationInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }


    /**
     * 导出学生宿舍分配信息
     *
     * @param request
     * @param response
     */
    @ResponseBody
    @RequestMapping(value = "/allocation/export.action")
    public void exportAllocationInfoToExcel(HttpServletRequest request, HttpServletResponse response) {
        response.reset();// 清除缓存
        String brarea = (String) request.getSession().getAttribute("brarea");
        String brbid = (String) request.getSession().getAttribute("brbid");
        // 查找宿舍分配信息
        List<AllocationInfo> list = dormService.exportAllocationInfo(brarea, brbid);

        // 拼接excel表名
        StringBuffer filenamebuffer = new StringBuffer();
        if (StringUtils.isNotBlank(brarea)) {
            filenamebuffer.append(brarea);
            filenamebuffer.append("-");
        }
        if (StringUtils.isNotBlank(brbid)) {
            filenamebuffer.append(brbid);
            filenamebuffer.append("栋-");
        }
        filenamebuffer.append("学生宿舍分配名单");
        String filename = filenamebuffer.toString();
        try {
            ExcelUtils.writeExcel(filename, response, list, AllocationInfo.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

StudentController.java

package com.usc.lzh.doms.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.usc.lzh.doms.entity.*;
import com.usc.lzh.doms.service.StudentService;
import com.usc.lzh.doms.utils.DataGridViewResult;
import com.usc.lzh.doms.vo.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

@Controller
@RequestMapping("/student")
public class StudentController {
    @Resource
    private StudentService studentService;

    /**
     * 我的卫生检查记录界面
     *
     * @return
     */
    @RequestMapping(value = "/viewMyCleanInfo")
    public String viewMyCleanInfo() {
        return "/student/clean-list";
    }

    /**
     * 查询我的宿舍卫生检查记录
     *
     * @param ciVo    分页信息
     * @param request 用于获取session中的uid
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/clean/list")
    public DataGridViewResult findMyCleanInfoListByPage(CleanInfoVo ciVo, HttpServletRequest request) {
        // 获取学号
        String uid = (String) request.getSession().getAttribute("uid");
        ciVo.setStuid(uid);
        // 设置分页信息
        PageHelper.startPage(ciVo.getPage(), ciVo.getLimit());
        // 查询
        List<CleanInfo> list = studentService.findMyCleanInfoListByPage(ciVo);
        // 创建分页对象
        PageInfo<CleanInfo> pageInfo = new PageInfo<CleanInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 我的报修界面
     *
     * @return
     */
    @RequestMapping(value = "/viewMyRepairInfo")
    public String viewMyRepairInfo() {
        return "/student/repair-list";
    }

    /**
     * 查询我的宿舍的报修记录
     *
     * @param riVo    分页信息
     * @param request 用于获取session中的uid
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/repair/list")
    public DataGridViewResult findMyRepairInfoListByPage(RepairInfoVo riVo, HttpServletRequest request) {
        // 获取学号
        String uid = (String) request.getSession().getAttribute("uid");
        riVo.setStuid(uid);
        // 设置分页信息
        PageHelper.startPage(riVo.getPage(), riVo.getLimit());
        // 查询
        List<RepairInfo> list = studentService.findMyRepairInfoListByPage(riVo);
        // 创建分页对象
        PageInfo<RepairInfo> pageInfo = new PageInfo<RepairInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 提交报修单
     *
     * @param ri
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/repair/add")
    public String addRepairInfo(RepairInfo ri, HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        String stuid = (String) request.getSession().getAttribute("uid");
        ri.setStuid(stuid);
        // 报修提交时间
        Date date = new Date();
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        ri.setSubtime(format.format(date));
        System.out.println(ri);

        // 去执行添加操作
        int result = studentService.addRepairInfo(ri);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "添加成功");
        } else {
            map.put("success", false);
            map.put("msg", "添加失败");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 修改报修单
     *
     * @param ri
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/repair/update")
    public String updateRepairInfo(RepairInfo ri, HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        System.out.println(ri);

        // 判断这是不是自己的提交的报修单
        String stuid = (String) request.getSession().getAttribute("uid");
        if (!stuid.equals(ri.getStuid())) {
            map.put("success", false);
            map.put("msg", "只能修改自己提交的报修单！");
            return JSON.toJSONString(map);
        }

        int result = studentService.updateRepairInfo(ri);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "修改成功！");
        } else {
            map.put("success", false);
            map.put("msg", "修改失败！");
        }
        return JSON.toJSONString(map);
    }


    /**
     * 我的宿舍界面
     *
     * @return
     */
    @RequestMapping(value = "/viewMyDormInfo")
    public String viewMyDormInfo() {
        return "/student/myDorm";
    }


    /**
     * 查看留言板
     *
     * @return
     */
    @RequestMapping(value = "/viewMessageBoard")
    public String viewMessageBoard() {
        return "/student/messageboard";
    }

    @ResponseBody
    @RequestMapping(value = "/message/list")
    public String findMessageListByPage(HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        try {
            // 获取id，用来查找所在宿舍区
            String uid = (String) request.getSession().getAttribute("uid");
            // 获取当前页
            Integer curr = Integer.parseInt(request.getParameter("curr"));
            // 获取页面size
            Integer limit = Integer.parseInt(request.getParameter("limit"));
            // 获取信息类型
            Integer type = Integer.parseInt(request.getParameter("type"));
            // 起始行数
            Integer start = (curr - 1) * limit;
            List<MessageBoard> list = studentService.findMessageListByPage(uid, start, limit, type);
            // 总行数
            Integer count = studentService.findMessageCount(type);
            // 总页数
            Integer total = (count - 1) / limit + 1;
            map.put("success", true);
            map.put("count", count);
            map.put("total", total);
            map.put("curr", curr);
            map.put("limit", limit);
            map.put("data", list);
            System.out.println(JSON.toJSONString(map));
            return JSON.toJSONString(map);
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "系统错误！");
            return JSON.toJSONString(map);
        }
    }

    /**
     * 查看我的留言
     *
     * @return
     */
    @RequestMapping(value = "viewMyMessage")
    public String viewMyMessage() {
        return "/student/my-message";
    }


    /**
     * 查看我的留言
     *
     * @param mbVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/my")
    public DataGridViewResult myMessage(MessageBoardVo mbVo, HttpServletRequest request) {
        String uname = (String) request.getSession().getAttribute("uname");
        mbVo.setAnnouncer(uname);

        // 设置分页信息
        PageHelper.startPage(mbVo.getPage(), mbVo.getLimit());
        // 查询
        List<MessageBoard> list = studentService.findMyMessage(mbVo);
        // 创建分页对象
        PageInfo<MessageBoard> pageInfo = new PageInfo<MessageBoard>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 发布留言
     *
     * @param mb
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/add")
    public String addMessage(MessageBoard mb, HttpServletRequest request) {
        String uname = (String) request.getSession().getAttribute("uname");
        mb.setAnnouncer(uname);

        HashMap<String, Object> map = new HashMap<>();
        int result = studentService.addMessage(mb);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "添加成功！");
        } else {
            map.put("success", false);
            map.put("msg", "添加失败！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 批量删除留言
     *
     * @param request 获取前端传来的id数组
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/message/delete")
    public String deleteMessage(HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        String params = request.getParameter("params");
        System.out.println(params);
        try {
            if (StringUtils.isNotBlank(params)) {
                // 获取id数组
                JSONArray jsonArray = JSONArray.parseArray(params);
                List<Integer> list = new ArrayList<>();
                for (int i = 0; i < jsonArray.size(); i++) {
                    JSONObject obj = jsonArray.getJSONObject(i);
                    Integer id = (Integer) obj.get("id");
                    list.add(id);
                }
                boolean result = studentService.deleteMessage(list);
                if (result) {
                    map.put("success", true);
                    map.put("msg", "删除成功！");
                } else {
                    map.put("success", false);
                    map.put("msg", "删除失败！");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("success", false);
            map.put("msg", "删除失败！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 查看学生基本信息
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/basic/info")
    public String viewStudentInfo(HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();

        String stuid = (String) request.getSession().getAttribute("uid");
        if (StringUtils.isNotBlank(stuid)) {
            StudentInfo si = studentService.findStudentInfoByStuid(stuid);
            if (si != null) {
                map.put("success", true);
                map.put("data", si);
            } else {
                map.put("success", false);
                map.put("msg", "系统错误：不存在该用户！");
            }
        }
        return JSON.toJSONString(map);
    }

    /**
     * 更改基本信息
     *
     * @param si
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/basic/update")
    public String updateStudentInfo(StudentInfo si) {
        HashMap<String, Object> map = new HashMap<>();
        System.out.println(si);
        int result = studentService.updateStudentInfo(si);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "保存成功！");
        } else {
            map.put("success", false);
            map.put("msg", "保存失败！");
        }
        return JSON.toJSONString(map);
    }

    @RequestMapping(value = "/leave/register")
    public String myLeaveInfo() {
        return "/student/leave-info";
    }

    /**
     * 查找我的离校登记记录
     *
     * @param liVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/leave/list")
    public DataGridViewResult findMyLeaveInfoByPage(LeaveInfoVo liVo, HttpServletRequest request) {
        String stuid = (String) request.getSession().getAttribute("uid");
        liVo.setStuid(stuid);
        System.out.println(liVo);

        // 设置分页信息
        PageHelper.startPage(liVo.getPage(), liVo.getLimit());
        // 查询
        List<LeaveInfo> list = studentService.findMyLeaveInfoByPage(liVo);
        // 创建分页对象
        PageInfo<LeaveInfo> pageInfo = new PageInfo<LeaveInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }


    /**
     * 添加离校登记记录
     *
     * @param li
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/leave/add")
    public String addMyLeaveInfo(LeaveInfo li, HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();

        String stuid = (String) request.getSession().getAttribute("uid");
        li.setStuid(stuid);
        System.out.println(li);

        int result = studentService.addMyLeaveInfo(li);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "登记成功！");
        } else {
            map.put("success", false);
            map.put("msg", "登记失败，请稍后再试！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 修改离校登记记录
     *
     * @param li
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/leave/update")
    public String updateMyLeaveInfo(LeaveInfo li) {
        HashMap<String, Object> map = new HashMap<>();

        System.out.println(li);

        int result = studentService.updateMyLeaveInfo(li);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "更改成功！");
        } else {
            map.put("success", false);
            map.put("msg", "更改失败，请稍后再试！");
        }
        return JSON.toJSONString(map);
    }


    /**
     * 留校申请
     *
     * @return
     */
    @RequestMapping(value = "/stayin/apply")
    public String myStayInfo() {
        return "/student/stayin-apply";
    }

    /**
     * 查看自己的留校申请
     *
     * @param siVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/list")
    public DataGridViewResult findMyStayInfoListByPage(StayInfoVo siVo, HttpServletRequest request) {
        String stuid = (String) request.getSession().getAttribute("uid");
        siVo.setStuid(stuid);
        System.out.println(siVo);

        // 设置分页信息
        PageHelper.startPage(siVo.getPage(), siVo.getLimit());
        // 查询
        List<StayInfo> list = studentService.findMyStayInfoListByPage(siVo);
        // 创建分页对象
        PageInfo<StayInfo> pageInfo = new PageInfo<StayInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 上传图片
     *
     * @param file
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/uploadImage")
    public String uploadOpinionImage(MultipartFile file, HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        HashMap<String, Object> data = new HashMap<>();
        try {
            if (file != null) {
                String stuid = (String) request.getSession().getAttribute("uid");
                String originalFilename = file.getOriginalFilename();
                Date date = new Date();
                String fileName = date.getTime() + "-" + originalFilename;
                // 类路径
//                String path = ResourceUtils.getURL("classpath:").getPath();
                String classPath = "F:/IDEA/workspace/高校宿舍管理系统/doms/target/classes/static";
                // 父路径
                String src = "/upload/stayin/" + stuid + "/";
                File directory = new File(classPath, src);
                if (!directory.exists()) {
                    directory.mkdir();
                }
                // 文件名
                String imagePath = directory.getPath() + "\\" + fileName;
                System.out.println(imagePath);
                file.transferTo(new File(imagePath));
                data.put("src", src + fileName);
                map.put("code", 0);
                map.put("msg", "上传成功！");
                map.put("data", data);
                return JSON.toJSONString(map);
            } else {
                map.put("code", -1);
                map.put("msg", "请选择图片！");
                return JSON.toJSONString(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
            map.put("code", -1);
            map.put("msg", "上传失败，请稍后重试！");
            return JSON.toJSONString(map);
        }
    }


    /**
     * 提交留校申请
     *
     * @param si
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/add")
    public String addStayInfo(StayInfo si, HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        String stuid = (String) request.getSession().getAttribute("uid");
        si.setStuid(stuid);

        System.out.println(si);
        int result = studentService.addMyStayInfo(si);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "提交申请成功");
        } else {
            map.put("success", false);
            map.put("msg", "提交申请失败，请稍后重试！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 修改留校申请信息
     *
     * @param si
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stayin/update")
    public String updateMyStayInfo(StayInfo si) {
        HashMap<String, Object> map = new HashMap<>();

        System.out.println(si);

        int result = studentService.updateMyStayInfo(si);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "修改成功！");
        } else {
            map.put("success", false);
            map.put("msg", "修改失败，请稍后再试！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 查看我的返校信息
     *
     * @return
     */
    @RequestMapping(value = "/viewMyBackInfo")
    public String viewMyBackToScInfo() {
        return "/student/back-info";
    }

    /**
     * 查找我的返校登记记录
     *
     * @param bsVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/back/list")
    public DataGridViewResult findMyBackInfoByPage(BackToScInfoVo bsVo, HttpServletRequest request) {
        String stuid = (String) request.getSession().getAttribute("uid");
        bsVo.setStuid(stuid);
        System.out.println(bsVo);

        // 设置分页信息
        PageHelper.startPage(bsVo.getPage(), bsVo.getLimit());
        // 查询
        List<BackToScInfo> list = studentService.findMyBackInfoByPage(bsVo);
        // 创建分页对象
        PageInfo<BackToScInfo> pageInfo = new PageInfo<BackToScInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }


    /**
     * 添加返校登记记录
     *
     * @param bs
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/back/add")
    public String addMyBackInfo(BackToScInfo bs, HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();

        String stuid = (String) request.getSession().getAttribute("uid");
        bs.setStuid(stuid);
        System.out.println(bs);

        int result = studentService.addMyBackInfo(bs);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "提交成功！");
        } else {
            map.put("success", false);
            map.put("msg", "提交失败，请稍后再试！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 修改返校登记记录
     *
     * @param bs
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/back/update")
    public String updateMyBackInfo(BackToScInfo bs) {
        HashMap<String, Object> map = new HashMap<>();

        System.out.println(bs);

        int result = studentService.updateMyBackInfo(bs);
        if (result > 0) {
            map.put("success", true);
            map.put("msg", "更改成功！");
        } else {
            map.put("success", false);
            map.put("msg", "更改失败，请稍后再试！");
        }
        return JSON.toJSONString(map);
    }

    /**
     * 密码设置
     *
     * @return
     */
    @RequestMapping(value = "/setting")
    public String passwordSetting() {
        return "password-setting";
    }

    @RequestMapping(value = "/myDormitoryInfo")
    public String viewMyDormitoryInfo() {
        return "/student/my-dormitory";
    }

    /**
     * 查看自己宿舍信息
     *
     * @param aiVo
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/mydorm/list")
    public DataGridViewResult findMyDormitoryInfoListByPage(AllocationInfoVo aiVo, HttpServletRequest request) {
        String stuid = (String) request.getSession().getAttribute("uid");
        aiVo.setStuid(stuid);
        System.out.println(aiVo);

        // 设置分页信息
        PageHelper.startPage(aiVo.getPage(), aiVo.getLimit());
        // 查询
        List<AllocationInfo> list = studentService.findMyDormitoryInfoListByPage(aiVo);
        // 创建分页对象
        PageInfo<AllocationInfo> pageInfo = new PageInfo<AllocationInfo>(list);
        // 按接口要求返回数据
        DataGridViewResult data = new DataGridViewResult(pageInfo.getTotal(), pageInfo.getList());
        return data;
    }

    /**
     * 判断是否已经选择床位了
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/mydorm/isChoosed")
    public String isChooseBed(HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        String stuid = (String) request.getSession().getAttribute("uid");
        boolean status = studentService.isChooseBed(stuid);
        map.put("status", status);
        return JSON.toJSONString(map);
    }

    /**
     * 提交选择的床位号
     *
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/mydorm/chooseBed")
    public String chooseBed(HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        String stuid = (String) request.getSession().getAttribute("uid");
        String bed = request.getParameter("bed");
        if (StringUtils.isNotBlank(bed)) {
            int bedNum = Integer.parseInt(bed);
            // 提交床位号
            int result = studentService.chooseBed(stuid, bedNum);
            if (result > 0) {
                map.put("success", true);
                map.put("msg", "选择成功！");
            } else {
                map.put("success", false);
                map.put("msg", "选择失败！");
            }
            return JSON.toJSONString(map);
        } else {
            map.put("success", false);
            map.put("msg", "床位号不能为空！");
            return JSON.toJSONString(map);
        }
    }

    /**
     * 查找已经选择了的床位
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/mydorm/alreadyBeds")
    public String findAlreadyChooseBeds(HttpServletRequest request) {
        HashMap<String, Object> map = new HashMap<>();
        String stuid = (String) request.getSession().getAttribute("uid");
        List<Integer> list = studentService.findAlreadyChooseBeds(stuid);
        map.put("beds", list);
        return JSON.toJSONString(map);
    }
}

entity
AllocationInfo.java

package com.usc.lzh.doms.entity;

import com.usc.lzh.doms.utils.ExcelColumn;

/**
 * @author:lzh
 * @time:2021.4.10 宿舍分配/预分配信息
 */
public class AllocationInfo {
    // 学生相关信息
    @ExcelColumn(value = "学号", col = 1)
    private String stuid;

    @ExcelColumn(value = "姓名", col = 2)
    private String stuname;

    @ExcelColumn(value = "学院", col = 3)
    private String stucollege;

    @ExcelColumn(value = "专业", col = 4)
    private String studept;

    @ExcelColumn(value = "班级", col = 5)
    private String stuclass;

    // 宿舍相关信息
    @ExcelColumn(value = "宿舍编号", col = 6)
    private String brcode;

    @ExcelColumn(value = "宿舍区", col = 7)
    private String brarea;

    @ExcelColumn(value = "楼栋", col = 8)
    private String brbid;

    @ExcelColumn(value = "寝室", col = 9)
    private String brrid;

    @ExcelColumn(value = "床位号", col = 10)
    private Integer bed;
    // 预分配的状态（1已选床位/0未选）
    private Integer status;

    private String stugrade;

    private String stutel;

    public String getBrcode() {
        return brcode;
    }

    public void setBrcode(String brcode) {
        this.brcode = brcode;
    }

    public String getBrarea() {
        return brarea;
    }

    public void setBrarea(String brarea) {
        this.brarea = brarea;
    }

    public String getBrbid() {
        return brbid;
    }

    public void setBrbid(String brbid) {
        this.brbid = brbid;
    }

    public String getBrrid() {
        return brrid;
    }

    public void setBrrid(String brrid) {
        this.brrid = brrid;
    }

    public String getStuid() {
        return stuid;
    }

    public void setStuid(String stuid) {
        this.stuid = stuid;
    }

    public String getStuname() {
        return stuname;
    }

    public void setStuname(String stuname) {
        this.stuname = stuname;
    }

    public String getStucollege() {
        return stucollege;
    }

    public void setStucollege(String stucollege) {
        this.stucollege = stucollege;
    }

    public String getStudept() {
        return studept;
    }

    public void setStudept(String studept) {
        this.studept = studept;
    }

    public String getStuclass() {
        return stuclass;
    }

    public void setStuclass(String stuclass) {
        this.stuclass = stuclass;
    }

    public Integer getBed() {
        return bed;
    }

    public void setBed(Integer bed) {
        this.bed = bed;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public String getStugrade() {
        return stugrade;
    }

    public void setStugrade(String stugrade) {
        this.stugrade = stugrade;
    }

    public String getStutel() {
        return stutel;
    }

    public void setStutel(String stutel) {
        this.stutel = stutel;
    }

    @Override
    public String toString() {
        return "AllocationInfo{" +
                "stuid='" + stuid + '\'' +
                ", stuname='" + stuname + '\'' +
                ", stucollege='" + stucollege + '\'' +
                ", studept='" + studept + '\'' +
                ", stuclass='" + stuclass + '\'' +
                ", brcode='" + brcode + '\'' +
                ", brarea='" + brarea + '\'' +
                ", brbid='" + brbid + '\'' +
                ", brrid='" + brrid + '\'' +
                ", bed=" + bed +
                ", status=" + status +
                ", stugrade='" + stugrade + '\'' +
                '}';
    }
}

Menu.java

package com.usc.lzh.doms.entity;

public class Menu {
    private Integer id;
    private Integer pid;
    private String title;
    private String href;
    private String target;
    private String icon;
    private String utype;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getPid() {
        return pid;
    }

    public void setPid(Integer pid) {
        this.pid = pid;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getHref() {
        return href;
    }

    public void setHref(String href) {
        this.href = href;
    }

    public String getTarget() {
        return target;
    }

    public void setTarget(String target) {
        this.target = target;
    }

    public String getIcon() {
        return icon;
    }

    public void setIcon(String icon) {
        this.icon = icon;
    }

    public String getUtype() {
        return utype;
    }

    public void setUtype(String utype) {
        this.utype = utype;
    }

    @Override
    public String toString() {
        return "Menu{" +
                "id=" + id +
                ", pid=" + pid +
                ", title='" + title + '\'' +
                ", href='" + href + '\'' +
                ", target='" + target + '\'' +
                ", icon='" + icon + '\'' +
                ", utype='" + utype + '\'' +
                '}';
    }
}

service
DorMService.java

package com.usc.lzh.doms.service;

import com.alibaba.fastjson.JSONObject;
import com.usc.lzh.doms.entity.*;
import com.usc.lzh.doms.vo.*;

import java.util.List;

public interface DorMService {

    /**
     * 查找报修信息
     *
     * @param riVo 分页查询的参数，负责的楼栋编号
     * @return
     */
    public List<RepairInfo> findRepairInfoListByPage(RepairInfoVo riVo);

    /**
     * 导出报修信息
     *
     * @param brcode 宿舍楼编号
     * @param status 报修状态
     * @return
     */
    public List<RepairInfo> exportRepairInfo(String brcode, String status);

    /**
     * 批量更改报修状态
     *
     * @param params ids和status
     */
    public boolean batchEditRepairStatus(String params);

    /**
     * 查询卫生检查信息
     *
     * @param ciVo
     * @return
     */
    public List<CleanInfo> findCleanInfoListByPage(CleanInfoVo ciVo);

    /**
     * 更改卫生检查信息
     *
     * @param ci
     * @return
     */
    public int updateCleanInfo(CleanInfo ci);

    /**
     * 删除卫生检查记录
     *
     * @param id
     * @return
     */
    public int deleteCleanInfo(String id);

    /**
     * 批量添加卫生检查记录
     *
     * @param params  卫生检查信息的json数据
     * @param checker 检查人
     * @return
     */
    public boolean batchInsertCleanInfo(String params, String checker);

    /**
     * 查找宿舍信息
     *
     * @param biVo
     * @return
     */
    public List<RepairInfo> findBuildRoomInfoListByPage(BuildRoomInfoVo biVo);

    /**
     * 修改宿舍信息
     *
     * @param bi
     * @return
     */
    public int updateBuildRoomInfo(BuildRoomInfo bi);

    /**
     * 删除宿舍信息
     *
     * @param brcode 宿舍编号
     * @return
     */
    public int deleteBuildRoomInfo(String brcode);

    /**
     * 添加宿舍信息
     *
     * @param list
     * @return
     */
    public boolean addBuildRoomInfo(List<BuildRoomInfo> list);

    /**
     * 查看自己发布的公告信息
     *
     * @param mbVo
     * @return
     */
    public List<MessageBoard> findMessageListByPage(MessageBoardVo mbVo);

    /**
     * 添加公告信息
     *
     * @param mb
     * @return
     */
    public int addMessage(MessageBoard mb);

    /**
     * 修改公告信息
     *
     * @param mb
     * @return
     */
    public int updateMessage(MessageBoard mb);

    /**
     * 批量删除公告/失物招领信息
     *
     * @param list id数组
     * @return
     */
    public boolean deleteMessage(List<Integer> list);

    /**
     * 查找留校信息列表
     *
     * @param stVo
     * @return
     */
    public List<StayInfo> findStayInfoListByPage(StayInfoVo stVo);

    /**
     * 导出学生留校信息
     *
     * @param brarea
     * @param brbid
     * @return
     */
    public List<StayInfo> exportStayInfo(String brarea, String brbid);

    /**
     * 获取留校学生的统计数据
     *
     * @param brarea
     * @param brbid
     * @return
     */
    public JSONObject getStayInfoEchartsData(String brarea, String brbid);

    /**
     * 查找宿舍分配信息
     *
     * @param aiVo 按专业、班级、宿舍区、楼栋进行查找
     * @return
     */
    public List<AllocationInfo> findAllocationInfoListByPage(AllocationInfoVo aiVo);

    /**
     * 导出宿舍分配信息
     *
     * @param brarea
     * @param brbid
     * @return
     */
    public List<AllocationInfo> exportAllocationInfo(String brarea, String brbid);

    /**
     * 查找空余寝室
     *
     * @param biVo
     * @return
     */
    public List<BuildRoomInfo> findFreeRoomListByPage(BuildRoomInfoVo biVo);

    /**
     * 查找未分配寝室的学生
     *
     * @param siVo
     * @return
     */
    public List<StudentInfo> findNotAllocateStudentListByPage(StudentInfoVo siVo);

    /**
     * 判断床位够不够
     *
     * @return
     */
    public boolean judgeIsEnough();


    /**
     * 分配宿舍（全部分配）
     *
     * @return
     */
    public boolean doAssignAll();

    /**
     * 显示分配结果
     *
     * @param aiVo
     * @return
     */
    public List<AllocationInfo> viewAllocateResult(AllocationInfoVo aiVo);
}

主Main代码
DomsApplication.java

package com.usc.lzh.doms;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan("com.usc.lzh.doms.mapper")
@SpringBootApplication
public class DomsApplication {

    public static void main(String[] args) {
        SpringApplication.run(DomsApplication.class, args);
    }

}

五 要源码和报告的总结

这里点我拿源码哦
大家可以尝试敲一敲，这样一步步就会了解到springboot框架，jsp文件和layoutui布局设计Maven等等，大家一起继续加油！源码看评论区免费或者评论区发邮箱。
看到这别忘三连加关注，么么叽么么叽么么哒！！！！

高校对于宿舍的管理直接关系着学生综合素质的培养，是高校学生工作管理中重要的一个组成部分，学生宿舍管理的信息化程度可以反映出学校服务学生的效率，为宿舍管理的最终决策提供依据本文根据高校宿舍管理工作的现实需求，使用软件工程的理论和方法，设计并实现了一个基于 SpringBoot 的高校宿舍管理系统。
本文所做的工作主要有以下几点：
（1）阐述高校宿舍管理系统研究的背景和意义，分析总结国内外学者对同类系统研究的现状和发展趋势。
（2）对高校宿舍管理系统的需求进行分析，提出了系统的建设目标，从经济、技术、操作几个方面对系统研究和开发的可行性问题进行了分析，描述了系统的主要功能需求有基本信息管理、宿舍分配管理、日常管理、离返校管理、综合查询管理等，进行了用例建模和行为建模，也分析了系统的非功能性需求。
（3）对高校宿舍管理系统的整体进行设计，包括体系结构设计、功能模块设计和数据库设计。
（4）利用相关开发技术实现高校宿舍管理系统，并针对系统的主要功能进行了测试，验证了系统各个功能的实现的正确性。