【全套】基于Java的新生宿舍管理系统的设计与实现

💗💗💗作者简介💗💗	博主毕业于985大学计算机专业，从事计算机开发行业4年多，就职某大厂，累计辅导学生2000+人，获得好评无数，主要技术有SpringBoot、SSM、Vue、Mysql、Html、javascript、css、JSP、可视化、小程序、uniapp、javaswing、nodejs、electron等设计与开发，累计开发程序6000+套，有需要的小伙伴可以在文末获得联系方式，诚信经营，个人开发，全程辅导，包通过，包维护，包讲解。

1.系统简介（摘要）

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

关键词：宿舍管理；SpringBoot框架；MySQL数据库

2.开发技术

2.1 SpringBoot框架

SpringBoot适合初学者，也适合从以前的Spring框架开发者学习，学习起来是很方便的，不管是纯英文教程还是中文教程，国内外都有很多学习的资料。Spring Boot可以运行所有的Spring项目，进行无缝切换。内置了Servlet 容器，不需要对代码进行打包变成WAR就可以运行。自带应用监控，运行的时候可以实时的对正在运行的项目进行监控，可以随时发现问题所在并且能定位发生的问题，可以让程序员及时的修改问题。

2.2 MySQL数据库

一般学习程序开发的人员如果学习数据库的话，肯定是要学习MySQL数据库，MySQL数据库通过这么多年的不断发展，社区版本都是免费的，最重要的是小巧，占用电脑空间比较小，让更多的开发人员可以不需要更换更高级的电脑就可以进行学习。学习只是一个方面，最重要的是MySQL市场占有率是世界第一，基本上十个公司就有七八个用得MySQL数据库。MySQL的优点不只是这么粗浅，MySQL首先是开源的，只要不是商用就不用花钱，并且大型的数据也是支持的，只要是市面上存在的操作系统，MySQL都可以有对应的版本可供使用。因为MySQL是开源的，如果有对MySQL有特殊需求的甚至可以自己修改源码，达到符合自己使用的目的。MySQL数据库好处多多，最重要的一点符合本设计的开发需求，可以说本设计只用到了MySQL的一些基础功能，而这点基础功能就完全够用。MySQL学习的教程网上很多，许多关于入门的教程就完全可以达到普通程序员的开发水平，只需要把基本的知识学会了，到公司里面也只是根据不同的业务逻辑进行不同的语句编写而已。

2.3 Java语言

Java语言是目前最流行的语言之一，不仅可以做桌面窗口形式的程序，还可以做浏览器访问的程序，目前最流行的就是用Java语言作为基础，做各种程序的后台处理。Java语言是操作变量的语言，而变量则是Java对于数据存在形式的定义，变量用来操作内存，而内存则牵扯到计算机安全问题，这样Java语言反而有了免疫直接针对用Java语言开发出来的程序的病毒，有效地提高了Java语言开发出来程序的生存能力。Java是具有动态运行能力的一种语言，Java的类不仅仅可以用Java核心提供的基础类，还可以进行重写，这样会让Java的功能变得更加丰富，甚至可以编写一些功能模块进行封装。Java是一种开源的语言，可以对Java里面的各种类以及引用方法进行追溯，甚至可以对已经编译过的语言进行反编译，这样不仅仅提高学习的效率，并且可以学习其他从业者提供的优雅的编程方式。Java语言发展到现在，已经在各个行业扎根，学习Java可以从事的行业很多，并且学习的方法很多，网上有很多免费的教程，甚至有些高深的知识也只需要付费就可以进行学习，而不是像Java语言之初，每一个编程人员都需要用记事本进行手动编码，现在有很多集成开发环境帮助Java从业者。选择Java语言进行编程，是一种很好的解决问题的方式。

2.4 Vue.js框架

Vue.js是一款用于构建用户界面的 JavaScript 框架。它基于标准 HTML、CSS 和 JavaScript 构建，并提供了一套声明式的、组件化的编程模型，帮助开发者高效地开发用户界面。Vue.js 是一款流行的 JavaScript 前端框架，旨在更好地组织与简化 Web 开发。Vue.js 的核心库只关注视图层，使得它易于与其他库或已有项目整合。同时，Vue.js 也拥有强大的生态系统，包括各种插件和工具，可以帮助开发者构建复杂、单页应用、全栈/服务端渲染（SSR）等。Vue.js 采用了 MVVM架构设计模式，这是一种源于 MVC（Model-View-Controller）模式的设计思想。在 MVVM 中，View 和 Model 是不可以直接进行通信的，它们之间是通过 ViewModel 这个中介充当着观察者的角色来进行中转的。ViewModel 向上与视图层 View 进行双向数据绑定，向下与 Model 通过接口请求进行数据交互，起到承上启下的作用。这种设计模式使得数据驱动和组件化的思想得以实现，大大提高了开发效率。Vue.js 是一个独立的社区驱动的项目，由尤雨溪在 2014 年创建。它是一个成熟的、经历了无数实战考验的框架，目前在生产环境中使用非常广泛，可以轻松处理大多数 Web 应用的场景，并且几乎不需要手动优化，完全有能力处理大规模的应用。总的来说，Vue.js 是一个功能强大、易于上手且广泛应用的 JavaScript 框架，适合各种规模和复杂度的 Web 开发项目。

2.5 B/S结构简介

随着软件系统的不断改进和升级，B/S结构产品更为方便的特征体现地十分明显。对于一个中等偏大的公司来说，如果系统管理员每天要在很多台电脑之间来回查看，不断奔走，那么效率和工作量就会变得很低，但是如果使用了B/S结构，那么管理员只要对服务器进行管理就够了。
B/S结构最大的优点它不需要安装任何的软件，它所有的客户端就只是浏览器，所以只要有一台电脑并且可以上网就可以解决所有问题，客户端可以完全地不用管理员维护。无论使用系统的使用者是什么样的规模，也不管分支有多么的庞大，都不会对维护和升级的工作量造成影响，所有的维护和升级只需要操作服务器。随着B/S结构的不断发展，使用的人也不断增加，从而带动了AJAX技术的发展，和B/S结构一样，它也能在客户端上处理程序，这便缓解了服务器的负担，提高了交互性，而且实现了局部实时刷新。

3.系统截图

4.系统源代码

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();
        }
    }
}