疫情隔离酒店管理系统的开发--论文pf

@TOC

springboot395疫情隔离酒店管理系统的开发--论文pf

绪 论

1.1研究背景与意义

当前，我国的常态化防控正处于迅速发展阶段，管理人员与疫情防控进一步标准化，需各酒店等生活服务场所加强管理，使用健全的信息系统对防控工作进行全方位部署，将从根源上提高疫情防控能力、各类信息的准确把握程度。信息化管理模式是将行业中的工作流程由人工服务，逐渐转换为使用计算机技术的信息化管理服务。这种管理模式发展迅速，使用起来非常简单容易，用户甚至不用掌握相关的专业知识，根据教程指导即可正常使用相关的系统，因而被越来越多的用户所使用。由于相关行业管理信息化，这就使得管理工作不在受到时间和区域的限制，随时随地即可完成相关的工作任务和结果[1]。就目前而言，管理信息化在现代社会中非常流行，使用比较广泛。电子商务技术出现比较早，相关的公司企业使用计算机建立专用的内部网络，通过内部网络完成相应的采购、销售等活动，加快相关的企业之间的交易速度，提高了工作效率[2]。

当下，许多行业采用互联网技术将工作流程信息化、数字化，在一定程度上，减轻了相关人员的工作量，也节约了一定的人力资源，与此同时，人们获取外界的相关信息主要依赖于主流的信息化技术和工具。人们对生活的需求也在不断的发生着变化，为了应对用户的多样化需求，许多相关的第三产业应运而生，管理信息化也逐渐的流行起来，比如电子商务行业。本人通过查询大量学习资料，了解基本的开发系统的基本背景和关键任务，学习和掌握相关的开发技术和设计语言，设计系统功能模块，以及MySQL数据库的相关语法和工具，创建和存储数据表格，反映和关联表格之间相互存在的关系，由此对疫情隔离酒店管理系统进行研发和实现。

疫情防控期间，常态化防控工作尤为重要，为响应政府号召，建设本酒店防控管理系统以落实好常态化防控工作。目前正处于疫情防控期间，疾控专家至今还无法对疫情防控的走向给予准确判断。为了使酒店防控管理更加完善，满足当前酒店需要，设计了一款疫情隔离酒店管理系统，让酒店防控效率更快、准确度更高。本系统采用SpringBoot框架构建系统主流架构，Java语言编码实现系统主要功能模块，VUE技术设计系统动态页面，MySQL数据库管理和存储系统相关的数据资源。通过本管理系统的应用能实现全方位的管理人员管理和疫情控制,做到零压力、低风险的酒店管控。本系统的应用能推动政府常态化防控的发展，更好加快社会文明的进步。

1.2国内外研究现状

1.2.1国内研究现状

国内针对计算机技术在突发公共卫生事件应急管理中的应用研究起步较晚，早期研究大多围绕计算机技术与政府治理的关系展开。张春艳（2014）研究发现政府治理中大数据的作用不容忽视，互联网、云计算等数据处理方式与大数据相结合，可以让数据的有效信息被充分挖掘，使政府部门的风险预估能力得到显著提升。李丹阳（2014）提出中国的应急管理体制已初步完善，为了对突发的公共卫生事件进行高效处置，在模式上必须如商业机构一般，在整个应急管理过程中尽可能地利用计算机技术，同时全面革新原有条块分割的应急管理机制状态。在信息化时代背景下，应急处置预案能及时、精准、高效地解决突发事件带来的不确定性、不可控性等问题，由此提升危机处置的效率和质量。因此，政府运用计算机技术进行危机治理能够实现快速、科学、合理决策。

近两年来，学者在关于计算机技术在突发公共卫生事件应急管理中的研究则主要围绕 2020 年初暴发的新冠肺炎疫情展开。学者认为为了达到疫情的有效防控，应在精准把控疫情动态、科学调配所需物品、助力经济复苏等方面发挥计算机技术的固有优势。江辰等（2021）认为大数据技术在抗击新冠肺炎疫情中的作用功不可没，彰显了中国的社会治理水平。在疫情高危期，该技术通过对海量信息的筛选和验证，在病源追踪、医疗辅助服务、密接者排查、物资调度方面的应对准确高效，最终实现了此次抗疫斗争的全面胜利；陈思（2021）以郑州市中计算机技术在疫情防控的应用为例，提出郑州市运用大数据技术在排查人员感染情况的精准防控、医护物资数据整合的物资调度、数据共享后的联防联控等三个方面的防控模式，有效地提高了疫情防控效果。

近些年，因为国家非常重视和支持第三产业的发展，以及人们的日常生活需求越来越离不开信息管理技术的使用，所以我国的信息管理系统行业发展速度非常快，并且相关的体制法规也正在不断地被完善和改进[3]。国内学者认为计算机技术应该与政府管理手段相结合，需要与当下云计算、互联网、物联网等相关概念结合，发挥其技术优势；同时，围绕计算机技术在疫情防控中应用情况的研究，国内学者认为应该要发挥其精准把控疫情动态、科学调配所需物品、助力经济复苏等方面的功能。新时代背景下，根据人们的相关需求，不断地促进着相关产业的产生与发展，一系列电子产品、应用软件、信息管理系统等新时代的产物逐渐出现在人们的视野中，并且在近几年发展迅速，日渐趋于成熟[4]。我国对于突发公共卫生事件应急管理的研究逐步完善，并开始将目光聚焦于地方政府在源头防范、风险管控、应急准备、监测预警等方面，由此防范新冠肺炎疫情等突发公共卫生事件产生的风险。本文认为在此次新冠肺炎疫情中要注意把握防控的及时性、准确性和有效性三个方面，这对本文在研究疫情防控效果方面提供了理论借鉴。

1.2.2国外研究现状

目前，作为引领世界发展潮流的信息化时代已经到来，且数据的采集、分析、应用等方面已经成为应急处置突发事件的的必要手段，这在西方发达经济体已经成为共识。计算机技术可以实现早期预警，并对政策执行情况可以实时进行采集和反馈。日本、欧盟等发达经济体也分别制定计算机技术战略，提高对异常天气、自然灾害等突发事件的管理与处置。由此可见，计算机技术在突发事件的应急管理中具有重要意义[5]。

关于计算机技术在突发公共卫生事件应急管理方面的研究，国外学者主要从突发公共卫生事件发生时计算机技术对政府应急管理、社交媒体的影响展开分析。在政府应急管理方面，Amaye 等（2016）研究发现，大数据在突发公共卫生事件暴发时能提高政府的信息获取能力，因此亟需搭建应急信息管理系统，以达到从复杂的网络系统中获取重要信息、协调机构间决策的目的。同时，突发公共卫生事件暴发时相关主体不同的利益诉求会对管理时间造成影响，造成行政效率低下，所以通过采集到的大数据信息进行整合分析，并实现对应急管理数据库的搭建和使用，将能有效缓解信息不对称、破解信息孤岛、实现数据及时推送的良好局面。Watson 等（2017）研究结果表明，在突发公共卫生事件的应急处置中计算机技术的作用不容忽视，其鲜明的预警监测、风险感知及资源调配等功能可以为政策当局提供全面的信息参考，提高科学决策水平。在社交媒体分析方面，国外学者认为突发公共卫生事件暴发时民众可以通过社交媒体获取大数据信息，从而实现对危机事件的有效处理。

美国、英国等一些发达国家快速发展计算机技术，促进了客房信息化建设。而后随着相关的技术不断地发展，覆盖面非常广泛，应用领域比较多，促进着疫情隔离酒店管理系统等相关的信息管理系统不断地发展和完善，并且其所设计的系统功能结构也比较合理、全面。相对而言，国外系统的研发在相关领域上还是占据着较大的优势[6]。国外的研究认为计算机在突发公共卫生事件暴发时，能有效协助政府部门掌握全面信息、提高决策水平，同时，社交媒体计算机技术对危机应急管理也具有重要作用。通过梳理国外政府如何运用计算机技术在突发事件应急管理中的具体做法及落地成效，对于本文在研究加强计算机指标共享和公开，提高疫情防控效果提供了有效参考。因此，我们需要吸收国外系统开发领域中的较好的技术精华，发展我国的信息化管理系统，使得其面向大众，能够更好的、更全面的服务于相关的工作人员。

1.3研究内容

现今，互联网技术在我们日常的生活中起到得作用越来越大，对移动设备、电脑等上网设备的使用也越来越频繁和常规化。传统的客房模式主要依靠管理人员纯手工记录的相关信息，比较繁琐，不方便查找，也非常容易出现错误。如今，如果再通过手工记录疫情隔离酒店管理信息，将大大不利于客房相关的疫情隔离酒店管理信息，严重影响客房的发展。因此，本人结合传统的客房模式和先进的电子信息管理模式，使用Java语言编程设计功能模块，VUE技术设计网页布局，MySQL数据库创建和存储数据表格，对疫情隔离酒店管理系统进行设计和开发。本疫情隔离酒店管理系统的设计有利于相关行业实现最大化的资源管理与共享，促进相关行业的信息交流、分工合作，提高相关工作人员的工作效率，最终实现整个疫情隔离酒店管理服务的信息化管理。

1.4论文结构

本文围绕着疫情隔离酒店管理系统的整个开发过程，展开了详细的描述和说明，设计和实现本疫情隔离酒店管理系统的主要工作有：首先分析研究背景、研究状态，其次介绍设计系统时使用到的相关技术，然后通过系统分析确定系统的功能需求，接着通过编码工作详细设计和实现系统，最后再通过系统测试，找出系统存在的问题和解决问题的方法，不断地修改和完善系统。论文内容的组织结构设计如下。

第一章绪论，对于系统的研究背景、研究现状等内容进行了介绍，帮助用户了解和认识疫情隔离酒店管理系统的发展过程。

第二章相关技术介绍，对Java语言、MySQL数据库等相关的开发技术进行了介绍，为后期系统的功能实现提供技术上的支持。

第三章系统分析，分析用户的使用需求，以及系统实现的可行性，对系统进行建模，设计相关的角色及其主要的功能操作需求。

第四章系统设计，对系统的总体功能、数据库表格进行设计，确定将要设计的功能模块。

第五章系统实现，通过相关的功能模块运行图，展现出系统的主要功能模块操作流程。

第六章系统测试，主要使用功能测试的方式，测试系统的相关功能运行和使用的具体情况。

第七章总结与展望，对系统的实现过程进行总结，基本上完成了系统的设计，展望未来将学习和使用更加先进的技术，提高系统的实用性，使得系统更好的服务于使用人员。

51

2 相关技术介绍

2.1 B/S模式

B/S模式是一种比较常用的网络结构模式[7]。B/S模式是由MVC结构组成，即模型、视图、控制器是构成该模式的主要结构[8]。模型主要是指业务模型，视图是面向用户而显示的相关界面，控制器主要是控制保证视图和模型的同步执行。B/S模式的三层结构是相互独立的，换句话说，当某一个模块发生修改和更新，其不会对其他模块产生影响。根据B/S的这一特点，可以将对业务逻辑的处理以及约束条件集中到中间层中，便于前端增加对模型和方法的调用和复用。并且可以直接通过中间层对数据库进行相关的操作处理，大大减少了数据库的连接数，节省了计算机的对相关的资源配置空间。

使用B/S模式可以节省系统资源配置，提高研发工作效率，减少开发时间，因而大大提高了我们开发软件的可能性。B/S模式大大的改变了传统的结构模式，换句话说就是C/S模式的升级版，也可以说这是对C/S模式进行了扩展。在这种结构模式中，用户不用再向使用C/S模式一样，下载客户端，其可以直接通过使用浏览器的方式，打开网站地址，即可访问和使用相关的系统功能服务。

2.2 IDEA开发环境

软件开发使用的编程语言有许多种，而每种编程语言需要通过与其相对应的开发平台进行编译和运行。Eclipse平台和IDEA平台都是目前比较常用的开发环境。Eclipse平台面对用户是开发源代码的，它所具有的功能也是比较齐全的，可以应用于C/S模式软件的开发，但是它所占据的内存容量比较大，运行较慢，并且其并未提供Tomcat服务器，运行过程中需要将代码发布到Tomcat服务器中，测试使用的时间较长，故而不太适用于B/S模式软件的开发。

IDEA平台是建立在Eclipse平台的基础之上，增加了许多的应用插件，比如Tomcat插件、mail组件等。IDEA平台增加了Tomcat插件，代码编写完成或者更新完成时，程序员无需将代码发布到Tomcat服务器中，可以直接通过调试实现程序的运行。IDEA平台增加了Mail组件，该组件可以为本程序提供标准的邮件方法，便于开发人员完成与邮件功能相关的编译工作。IDEA平台占据的内存空间较小，同时其也具有较高的可扩展性，编程人员可以根据需要添加和使用相关的插件。可以支持主流的开源产品和相关的开发框架，被广泛运用到相关的移动系统、web应用系统等开发中。相比于Eclipse平台，本疫情隔离酒店管理系统比较适合使用IDEA平台进行编程和开发。

2.3 MySQL数据库

MySQL是一种小型的关系型数据库管理系统，因为其占用内存空间小，运行速度快，并且源代码也是开源的，运行和维护成本低，系统性能稳定，受到了许多开发人员的喜爱[9]。考虑到MySQL数据库开发成本低，功能齐全等因素，大多中小型网站选择使用MySQL数据库管理数据信息。

SQL Server也是近几年使用较多的关系型数据库，其与MySQL数据库存在的不同之处主要有，在环境方面，SQL Server数据库比较适合于.NET环境，而MySQL数据库适用于几乎所有的语言；在成本方面，SQL Server数据库是商业化的，其运行多个数据库可许证，虽然有一个免费版，但是只能让你对关系型数据库管理系统有一定的认识与了解，熟悉相关的使用流程。如果要想使用SQL Server数据库的话，就需要支付相关费用，而MySQL数据库面向用户是免费并且开放源代码的，如此一来，便极大地方便了用户的使用；在实际应用方面，S上述两种数据库都可以支持Java语言、PHP语言、C++语言的使用，但是MySQL数据库除了支持上述SQL Server数据库能支持的编程语言外，还支持Scheme、Eiffel等其他编程语言，故而MySQL数据库受欢迎程度比SQL Server数据库更高。

2.4 Java语言

Java语言是一种面向对象的编程语言，其具有封装、继承、多态等特征，从而提高编程工作效率，实现软件的设计和开发[10]。继承机制可以继承相关的类和方法，新的类可以在继承已经定义的类的相关特性基础上，扩展自己新的数据和功能，进而提高自身的能力。封装机制可以提高程序的安全性，不对外显示自己的对象属性和行为，主要是通过提供和访问相应的接口来实现对它的相关的控制和使用操作。多态机制可以描述对象的多样性，简单的来说就是引用相同的对象做不同的事务。Java语言具有安全高效的优点，并且其通过依靠Java虚拟机，可以实现跨平台操作。Java语言比较容易学习和掌握，就目前软件开发所使用的开发类语言而言，Java语言比较受程序员喜爱，应用比较广泛。

2.5 VUE技术

Vue 是一套用于构建用户界面的渐进式框架。与其它大型框架不同的是，Vue 被设计为可以自底向上逐层应用。Vue 的核心库只关注视图层，不仅易于上手，还便于与第三方库或既有项目整合。另一方面，当与现代化的工具链以及各种支持类库结合使用时，Vue 也完全能够为复杂的单页应用提供驱动。

vue是轻量级的，它有很多独立的功能或库，我们会根据我们的项目来选用vue的一些功能。就像我们开发项目时如果只用到vue的声明式渲染，我就只用vue的声明渲染，而我们要用他的组件系统，我们可以引用它的组件系统。

2.6 Tomcat服务器

Tomcat服务器是一种开源的应用服务器，它可以操作和运行相关的Servlet代码和VUE代码。Servlet是一个按照相关的规范要求编写而成Java类，其具有平台独立、可移植性等特点，可以在web服务器上加载和运行[12]。对于开发者和测试人员来说，Tomcat服务器操作简单，代码容易理解，性能稳定可靠，所以开发人员使用Tomcat服务器对VUE等程序进行调试是方便可行的。这也就为开发人员选择使用Tomcat服务器提供了一种较大的可能性，并且使用它在一定程度上可以确保设计系统的正常运行。

开发人员使用Tomcat服务器连接数据库，可以更好的完成系统与数据库的搭建工作，实现交互式的管理与控制相关的数据信息，所以Tomcat服务器使用比较广泛。我们的系统属于中小型数据规模，使用Tomcat服务器是足够的。因此，根据上述分析与说明，我们的系统使用Tomcat服务器实现VUE程序调试，连接数据库等功能操作。

2.7 SpringBoot框架

本课题程序开发使用到的框架技术，英文名称缩写是springboot，在JavaWeb开发中使用的流行框架有SSH、SSM、springboot、SpringMVC等，作为一个课题程序采用SSH框架也可以，SSM框架也可以，SpringMVC也可以。SSH框架是属于重量级别的框架，配置繁琐，不够灵活，修改程序需要修改好多个文件，并且运行起来也占用内存较高，CPU使用率相对也高，springboot是基础Spring开发的一套整合架构，更灵活更好用，springboot框架取中间值，既没有SSH臃肿，也没有SpringMVC简化，属于中间级别的，在配置过程和使用过程中更能编写和理解。sprinboot框架取代Hibernate框架是因为它更灵活，不需要完全在框架里操作，它在数据操作上可以写出更灵活的代码，它的性能也比Hibernate框架更稳定。总的来说，使用springboot框架是通过综合考虑而使用的，网上有很多的使用教程和心得体会，而且springboot又是这么的流行，用springboot框架开发是顺其自然的。

3系统分析

3.1需求分析

在对系统进行设计之前，需要进行需求分析，即软件实现前的计划活动。需求分析阶段是设计人员在与用户交流时，将用户的描述转变成具体的需求定义的过程，即准确地理解和确认用户实际上想要实现的系统功能，由此确定系统设计的目的是什么，实现系统必须完成哪些工作，到底能够做什么。需求分析是开发周期阶段中用时最长的重要环节，贯穿于整个系统的研发过程中，需求分析的结果是实现总体功能设计的规划基础，也是实现数据库设计的信息依据，由此展开详细地功能设计，完成系统的功能设计，最后的系统测试和交付工作，又回归到需求分析中，通过对比需求分析报告规划的功能需求，是否与实际设计的系统功能一致，能否实现功能操作和数据处理，确定系统的设计是否符合规范和要求。

需求分析在软件开发周期中是耗时最长的一个环节，系统的整个设计和实现过程主要依赖于需求分析报告。调查收集出不同用户对本疫情隔离酒店管理系统的相关使用需求，由此设计相关的功能模块，从而期望实现用户满意度较高的实用型系统。这一过程是系统能否成功投入市场，也能否被用户所接受和使用的非常关键的一个步骤。相关人员将总体需求分析大致分为了三种，即业务需求分析、功能需求分析、非功能需求分析。业务需求分析对于用户在日常生活、工作上的实际需求为标准和方向，确定需要设计的相关业务事项，其是功能需求分析的基础，在本疫情隔离酒店管理系统设计过程中，主要业务需求包括菜品管理,客房管理,入住记录,健康上报管理等。功能需求分析是通过设计系统功能来实现相关的业务事项，它也是确定一个系统的设计是否具备价值的重要依据。非功能需求分析是在系统使用过程中对性能的具体要求，对功能需求的一个补充内容，也是对功能需求的一个补充内容，主要包括响应需求、安全性需求、稳定性需求、可扩展性需求等内容。非功能需求是在系统功能需求以外的其他必要的需求内容，比如说安全需求、相应需求等，它在最后投入使用阶段，起到了极其重要的作用。

本人通过现场观察、问卷调查等方式，详细地对疫情隔离酒店管理系统进行了需求分析，根据分析结果可知，疫情隔离酒店管理系统主要分为管理员和用户角色。管理员角色主要的功能需求包括个人中心管理、用户管理、房间管理,菜品管理,入住记录管理,健康上报管理等模块，管理员可以通过选择相关的功能模块，实现对相关数据的增、删、改、查等基本操作，管理相应的数据信息记录。在管理员角色功能模块设计过程中，客房是一个及其重要的功能模块，管理员可以通过选择该模块，查看、更新相关客房信息，管理相关的客房入住记录等。用户角色主要的功能需求包括首页、论坛、公告、个人中心等模块，用户可以通过选择相关的功能模块，实现相应的功能操作。在用户角色功能模块设计过程中，客房入住是一个占据重要地位的功能模块，用户可以通过选择客房，入住客房。疫情隔离酒店管理系统的研发，不仅方便了疫情隔离酒店管理的管理人员管理相关的客房入住信息，也方便了用户在线查看想要了解的疫情防控相关信息。因此，对于管理员和用户来说，设计和实现一款疫情隔离酒店管理系统，是非常具有研究的意义和实现价值的，使得管理疫情隔离酒店管理变得非常便捷，极大地满足了相关用户对疫情隔离酒店系统的使用需求。

3.2可行性分析

3.2.1经济可行性

经济可行性是决定是否研发系统的关键性因素。我们主要通过比较实际的收益和成本的方法，来确定一个系统是否具有经济可行性。在使用系统的过程中，当获得的收益大于开发的成本时，说明此系统的研发在经济上是可行的。传统的客房模式主要通过相关的工作人员以手工记录的方式，管理疫情隔离酒店管理信息记录，这种管理模式比较费时费力，管理疫情隔离酒店管理的费用也比较高，一方面疫情隔离酒店管理相关人员支付高额的管理费用，另一方面人工管理疫情隔离酒店管理信息非常容易出错，一旦出现疫情隔离酒店管理信息记录有误，则需要进行返工处理，修改的工作量非常大，极大地影响了疫情隔离酒店管理的管理。

由于本疫情隔离酒店管理系统的开发使用的技术基本上是开源的，获得技术上的支持是没有多少问题的，在软件实现方面所花费的成本是很低的，甚至不需要花费成本。研发系统的成本主要是来自调研、硬件和技术人员等方面。如果系统中需要存储的数据量不是很大，仅需要配置一台普通的服务器，即可满足相关需求。如果需要存储的数据量很大，则需要配置一台具有独立功能的服务器，比如管理数据库需要单独的数据库服务器，负责接入网站需要web服务器等等，但是一台服务器的价格是比较贵的。考虑到数据量和成本，我们使用小型集群服务器，这样既可以充分利用相关的资源，又可以让系统正常访问服务器。疫情隔离酒店管理系统的设计，既可以节约客房成本，也可以保证相关的疫情隔离酒店管理信息不易出错，所以研发本系统是具备经济可行性的。

3.2.2技术可行性

本疫情隔离酒店管理系统使用Java语言编码设计相关的功能模块，MySQL数据库创建和存储数据表格，VUE技术设计网站页面，并且在IDEA开发环境中，编写和运行相关的Java代码，然后在MySQL数据库中设计与系统有关的数据表格，接着通过使用连接代码完成与MySQL数据库的搭建工作，再通过使用开发环境中的Tomcat插件，完成与Tomcat服务器的发布工作，并且通过与Tomcat服务器的交互行为可以实现代码调试工作，最后用户在浏览器中成功的访问和使用本系统。Java语言具有跨平台性，本系统主要通过Java语言进行编码实现的，所以本系统可以支持在多个操作系统或者多个浏览器上运行和使用[14]。MySQL数据库是可以被免费使用的，并且MySQL数据库的日常运行和维护工作比较简单，这样有利于降低本系统的开发成本[15]。VUE技术具有独立性好，实用性高的特点，使用VUE技术设计系统页面可以与服务器完成可靠有效的交互工作[16]。在学校期间，本人已经学习和掌握了Java语言、MySQL数据库、VUE技术等相关的技术相关知识以及用法，因此在技术可行性方面，本系统是可以实现被设计与实现的。

3.2.3操作可行性

本疫情隔离酒店管理系统所采用网络结构是B/S模式，对于开发人员来说，可以直接复用相关的代码，或者稍微对原代码进行修改，使得其满足于本系统的相关需求，如此便可大大节约了开发时间，在最优最短的时间内完成对系统的设计。对于用户来说，如果还如传统的C/S模式一般，只有下载才可使用相关的系统，就非常不方便了，这也极大的限制了一部分用户的使用。现在，本系统采用的是新型的模式设计，用户通过浏览器使用本系统。并且，用户可以根据自身的工作需要，选择相关的菜单按钮操作本系统。在系统的一些功能模块中，本人还添加了相关的使用提示信息，方便用户更好更快的了解和使用本系统。

为了可以让用户更好地体验本系统，本人在windows操作系统平台上，以系统的需求分析为基础，使用相关的开发工具，对疫情隔离酒店管理系统进行研发。用户在浏览器中输入正确的账户信息，对疫情隔离酒店管理系统进行访问，选择使用下拉式菜单的方式，创建交互性强、界面美观友好的疫情隔离酒店管理系统，简化用户对系统的操作和使用。用户可以通过点击相关的功能按钮，选择修改个人信息，查看最新的疫情隔离酒店管理信息，查看推荐的论坛、公告等操作。由此可见，本系统的使用步骤是非常简单，因此，本系统的设计和实现是具备操作可行性的。

3.2.4法律可行性

本疫情隔离酒店管理系统是本人为了完成毕业设计而进行设计和实现的，一般是不用于商业使用的，即不投入市场产生收益，所以无论是从系统的实现条件，还是从系统设计的最终目的上来看，系统的研发是符合现实社会的要求和规范的。本人在开发过程中一直按照正规流程进行Java语言编码设计，MySQL数据库有免费版本可供设计人员使用，而且MySQL是开放源码的关系型数据库，技术人员可以在相关的MySQL酒店交流平台上查看相关的代码，以及寻求专业人员的帮助，所以在系统功能设计和数据库设计上使用的关键技术也是具备合法性。根据系统的实现条件、设计目的、使用的关键技术等内容来看，所以设计本系统具备法律可行性。

3.4系统流程分析

3.4.1用户操作流程

系统的相关用户如果想要成功使用本疫情隔离酒店管理系统，就必须进行登录操作，输入正确的账号密码，才能成功的访问本系统，实现相应的功能操作，用户操作流程图如图3-3所示。

图3-3用户操作流程图

3.4.2数据增加流程

用户成功登录后，在系统允许的前提下，通过合法的操作可以增加相关的数据信息，如果用户的操作不合法，则不能在系统中成功增加数据信息，数据增加流程图如图3-4所示。

3-4数据增加流程图

3.4.3数据修改流程

用户成功登录后，在系统允许的前提下，通过合法的操作可以修改相关的数据信息，如果用户的操作不合法，则不能在系统中成功修改数据信息，数据修改流程图如图3-5所示。

图3-5数据修改流程图

3.4.4数据删除流程

用户成功登录后，在系统允许的前提下，通过合法的操作可以删除失效的数据信息，如果用户的操作不合法，则不能在系统中成功删除数据信息，数据删除流程图如图3-6所示。

图3-6数据删除流程图

4系统设计

4.1系统功能设计

本疫情隔离酒店管理系统主要通过使用Java语言编码设计系统功能，MySQL数据库管理数据，VUE技术设计简洁的、友好的网址页面，然后在IDEA开发平台中，编写相关的Java代码文件，接着通过连接语言完成与数据库的搭建工作，再通过平台提供的Tomcat插件完成信息的交互，最后在浏览器中打开系统网址便可使用本系统。本系统的使用角色可以被分为用户和管理员，用户具有注册、评价信息等功能，管理员具有修改、管理信息等功能，系统总体功能设计图如图4-1所示。

图4-1系统总体功能设计图

4.2数据库设计

4.2.1概念设计

在整个数据库设计的过程中，概念设计为后续的工作做好准备工作，是后续工作得以实现的，也是根据用户参与情况确定对数据的处理要求，从而使得数据库设计成功的关键。概念设计的主要任务是将现实世界的所收集到的使用需求转化为抽象的信息世界结构的过程，能够真实的反映现实生活中实体与实体之间的联系，数据库的相关语法和代码比较容易理解和修改，方便相关人员将相关的数据信息存储到数据库中，并对其进行修改和使用[18]。

建立概念数据模型（E-R），把实现世界与信息世界相关联，是设计数据库的第一步，也是比较重要的一步，一旦设计有误，那整个的数据库设计就有可能是实际意义的，需要相关人员进行返工，比较费时费用，也可能会出现误工的问题。本阶段的设计能够明显的看见各个实体之间，数据的流动情况，具体较强的表达能力，更加方便于开发人员寻找与发现用户具体的需求[19]。因此，E-R的建立，占据着重要的地位，数据库的设计必要的一步就是E-R图的设计。本疫情隔离酒店管理系统主要的实体有管理员、用户等。数据库的概念设计阶段中主要设计的各实体信息E-R图如下图所示。

（1）下图是用户实体和其具备的属性。

用户实体属性图

（2）下图是菜品收藏实体和其具备的属性。

菜品收藏实体属性图

（3）下图是购物车实体和其具备的属性。

购物车实体属性图

（4）下图是客房收藏实体和其具备的属性。

客房收藏实体属性图

（5）下图是菜品实体和其具备的属性。

菜品实体属性图

（6）下图是健康上报实体和其具备的属性。

健康上报实体属性图

（7）下图是入住记录实体和其具备的属性。

入住记录实体属性图

（8）下图是客房实体和其具备的属性。

客房实体属性图

（9）下图是菜品评价实体和其具备的属性。

菜品评价实体属性图

（10）下图是菜品订单实体和其具备的属性。

菜品订单实体属性图

（11）下图是客房预定实体和其具备的属性。

客房预定实体属性图

（12）下图是客房评价实体和其具备的属性。

客房评价实体属性图

4.2.2逻辑设计

本疫情隔离酒店管理系统使用MySQL数据库管理与系统相关的数据信息。逻辑设计阶段是上阶段的具体实现，主要作用是将E-R设计转换为方便数据库进行存储的关系模型，即基本表的形式，方便开发人员后期对数据模型进行优化和管理[20]。逻辑设计阶段是整个数据库设计设计的关键，与系统有关的信息将会在这一阶段中被存储在数据库中，当用户使用本系统进行相关的功能操作时，与之有关的数据信息所在的基本表会发生相应的更新变化。数据库的逻辑设计阶段主要任务是将与系统相关的数据信息，设计成为方便数据库存储和管理的基本表格的形式，具体内容如下。

表4.1菜品表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	caipin_name	String	菜品名称	是
3	caipin_uuid_number	String	菜品编号	是
4	caipin_photo	String	菜品照片	是
5	caipin_types	Integer	菜品类型	是
6	caipin_erji_types	Integer	二级类型	是
7	caipin_kucun_number	Integer	菜品数量	是
8	caipin_old_money	BigDecimal	菜品原价	是
9	caipin_new_money	BigDecimal	现价/份	是
10	caipin_clicknum	Integer	菜品热度	是
11	caipin_content	String	菜品介绍	是
12	shangxia_types	Integer	是否上架	是
13	caipin_delete	Integer	逻辑删除	是
14	insert_time	Date	录入时间	是
15	create_time	Date	创建时间	是

表4.2菜品收藏表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	caipin_id	Integer	菜品	是
3	yonghu_id	Integer	用户	是
4	caipin_collection_types	Integer	类型	是
5	insert_time	Date	收藏时间	是
6	create_time	Date	创建时间	是

表4.3菜品评价表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	caipin_id	Integer	菜品	是
3	yonghu_id	Integer	用户	是
4	caipin_commentback_text	String	评价内容	是
5	insert_time	Date	评价时间	是
6	reply_text	String	回复内容	是
7	update_time	Date	回复时间	是
8	create_time	Date	创建时间	是

表4.4菜品订单表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	caipin_order_uuid_number	String	订单编号	是
3	caipin_id	Integer	菜品	是
4	yonghu_id	Integer	用户	是
5	buy_number	Integer	购买数量	是
6	caipin_order_canzhuo_types	Integer	就餐餐桌	是
7	caipin_order_time	Date	预约时间	是
8	caipin_order_true_price	BigDecimal	实付价格	是
9	caipin_order_types	Integer	订单类型	是
10	caipin_order_payment_types	Integer	支付类型	是
11	insert_time	Date	订单创建时间	是
12	create_time	Date	创建时间	是

表4.5购物车表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	yonghu_id	Integer	所属用户	是
3	caipin_id	Integer	菜品	是
4	buy_number	Integer	购买份数	是
5	create_time	Date	添加时间	是
6	update_time	Date	更新时间	是
7	insert_time	Date	创建时间	是

表4.6字典表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	dic_code	String	字段	是
3	dic_name	String	字段名	是
4	code_index	Integer	编码	是
5	index_name	String	编码名字	是
6	super_id	Integer	父字段id	是
7	beizhu	String	备注	是
8	create_time	Date	创建时间	是

表4.7客房表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	fangjian_name	String	客房名称	是
3	fangjian_uuid_number	String	客房编号	是
4	fangjian_photo	String	客房照片	是
5	fangjian_types	Integer	房型	是
6	fangjian_kucun_number	Integer	剩余房数	是
7	fangjian_old_money	BigDecimal	客房原价	是
8	fangjian_new_money	BigDecimal	现价/天	是
9	fangjian_clicknum	Integer	客房热度	是
10	fangjian_content	String	客房介绍	是
11	shangxia_types	Integer	是否上架	是
12	fangjian_delete	Integer	逻辑删除	是
13	insert_time	Date	录入时间	是
14	create_time	Date	创建时间	是

表4.8客房收藏表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	fangjian_id	Integer	客房	是
3	yonghu_id	Integer	用户	是
4	fangjian_collection_types	Integer	类型	是
5	insert_time	Date	收藏时间	是
6	create_time	Date	创建时间	是

表4.9客房评价表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	fangjian_id	Integer	客房	是
3	yonghu_id	Integer	用户	是
4	fangjian_commentback_text	String	评价内容	是
5	insert_time	Date	评价时间	是
6	reply_text	String	回复内容	是
7	update_time	Date	回复时间	是
8	create_time	Date	创建时间	是

表4.10客房预定表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	fangjian_order_uuid_number	String	订单编号	是
3	fangjian_id	Integer	客房	是
4	yonghu_id	Integer	用户	是
5	buy_number	Integer	预定天数	是
6	fangjian_order_time	Date	入住时间	是
7	fangjian_order_true_price	BigDecimal	实付价格	是
8	fangjian_order_types	Integer	订单类型	是
9	fangjian_order_payment_types	Integer	支付类型	是
10	insert_time	Date	订单创建时间	是
11	create_time	Date	创建时间	是

表4.11健康上报表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	yonghu_id	Integer	用户	是
3	jiankangshangbao_uuid_number	String	健康上报编号	是
4	jiankangshangbao_types	Integer	现在状态	是
5	jiankangshangbao_tiwen_photo	String	体温照片	是
6	jiankangshangbao_tiwen	BigDecimal	体温	是
7	jiankangshangbao_content	String	状态详情	是
8	insert_time	Date	上报时间	是
9	create_time	Date	创建时间	是

表4.12入住记录表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	yonghu_id	Integer	用户	是
3	ruzhu_uuid_number	String	入住编号	是
4	ruzhu_name	String	房间号	是
5	ruzhu_tiwen	BigDecimal	体温	是
6	ruzhu_photo	String	健康码	是
7	ruzhu_file	String	附件	是
8	ruzhu_time	Date	入住时间	是
9	tuifang_time	Date	退房时间	是
10	ruzhu_content	String	入住备注	是
11	insert_time	Date	上传时间	是
12	create_time	Date	创建时间	是

表4.13用户表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	yonghu_uuid_number	String	用户编号	是
3	yonghu_name	String	用户姓名	是
4	yonghu_phone	String	用户手机号	是
5	yonghu_id_number	String	用户身份证号	是
6	yonghu_photo	String	用户头像	是
7	yonghu_email	String	用户邮箱	是
8	new_money	BigDecimal	余额	是
9	jinyong_types	Integer	账户状态	是
10	create_time	Date	创建时间	是

表4.14管理员表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	username	String	员工名	是
3	password	String	密码	是
4	role	String	角色	是
5	addtime	Date	新增时间	是

5系统实现

5.1个人中心

个人中心模块主要负责存管有关于个人的数据信息记录，用户具有查询详细的个人信息资料，根据个人的实际情况及时进行信息变更处理等功能，修改密码界面设计如图5-1所示，个人信息界面设计如图5-2所示。

图5-1修改密码界面

图5-2个人信息界面

5.2管理员管理

管理员管理模块主要负责存管有关于管理员的数据信息记录，管理用户具有查询详细的管理员基础信息，根据管理员的实际情况及时进行信息变更处理等功能，管理员管理的界面设计如图5-3所示。

图5-3管理员管理界面

5.3轮播图管理

轮播图管理模块主要负责存管有关于轮播图的数据信息记录，用户具有查询详细的轮播图信息，根据轮播图的实际情况及时进行信息变更处理等功能，轮播图管理界面设计如图5-4所示。

图5-4轮播图管理界面

5.4菜品信息管理

菜品信息管理模块主要负责存管有关于菜品的数据信息记录，管理员具有查询详细的菜品信息，根据菜品的实际情况及时进行信息变更处理等功能，菜品信息管理界面设计如图5-5所示。

图5-5菜品信息管理界面

5.5基础数据管理

基础数据管理模块主要负责存管有关于菜品类型,餐桌管理,房型管理,健康状态管理的数据信息记录，管理员具有查询详细的菜品类型,餐桌管理,房型管理,健康状态管理的信息，根据基础数据的实际情况及时进行信息变更处理等功能，如下图所示。

5.6客房管理

客房管理模块主要负责存管有关于客房的数据信息记录，管理员具有查询详细的客房信息，根据客房的实际情况及时进行信息变更处理等功能，客房管理界面设计如图5-10所示。

图5-10客房管理界面

FangjianController.java

package com.controller;

import java.io.File;
import java.math.BigDecimal;
import java.net.URL;
import java.text.SimpleDateFormat;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
import org.springframework.beans.BeanUtils;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.context.ContextLoader;
import javax.servlet.ServletContext;
import com.service.TokenService;
import com.utils.*;
import java.lang.reflect.InvocationTargetException;

import com.service.DictionaryService;
import org.apache.commons.lang3.StringUtils;
import com.annotation.IgnoreAuth;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.*;
import com.entity.view.*;
import com.service.*;
import com.utils.PageUtils;
import com.utils.R;
import com.alibaba.fastjson.*;

/**
 * 客房
 * 后端接口
 * @author
 * @email
*/
@RestController
@Controller
@RequestMapping("/fangjian")
public class FangjianController {
    private static final Logger logger = LoggerFactory.getLogger(FangjianController.class);

    private static final String TABLE_NAME = "fangjian";

    @Autowired
    private FangjianService fangjianService;


    @Autowired
    private TokenService tokenService;

    @Autowired
    private CaipinService caipinService;//菜品
    @Autowired
    private CaipinCollectionService caipinCollectionService;//菜品收藏
    @Autowired
    private CaipinCommentbackService caipinCommentbackService;//菜品评价
    @Autowired
    private CaipinOrderService caipinOrderService;//菜品订单
    @Autowired
    private CartService cartService;//购物车
    @Autowired
    private DictionaryService dictionaryService;//字典
    @Autowired
    private FangjianCollectionService fangjianCollectionService;//客房收藏
    @Autowired
    private FangjianCommentbackService fangjianCommentbackService;//客房评价
    @Autowired
    private FangjianOrderService fangjianOrderService;//客房预定
    @Autowired
    private JiankangshangbaoService jiankangshangbaoService;//健康上报
    @Autowired
    private RuzhuService ruzhuService;//入住记录
    @Autowired
    private YonghuService yonghuService;//用户
    @Autowired
    private UsersService usersService;//管理员


    /**
    * 后端列表
    */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永不会进入");
        else if("用户".equals(role))
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        params.put("fangjianDeleteStart",1);params.put("fangjianDeleteEnd",1);
        CommonUtil.checkMap(params);
        PageUtils page = fangjianService.queryPage(params);

        //字典表数据转换
        List<FangjianView> list =(List<FangjianView>)page.getList();
        for(FangjianView c:list){
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c, request);
        }
        return R.ok().put("data", page);
    }

    /**
    * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        FangjianEntity fangjian = fangjianService.selectById(id);
        if(fangjian !=null){
            //entity转view
            FangjianView view = new FangjianView();
            BeanUtils.copyProperties( fangjian , view );//把实体数据重构到view中
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

    /**
    * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody FangjianEntity fangjian, HttpServletRequest request){
        logger.debug("save方法:,,Controller:{},,fangjian:{}",this.getClass().getName(),fangjian.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永远不会进入");

        Wrapper<FangjianEntity> queryWrapper = new EntityWrapper<FangjianEntity>()
            .eq("fangjian_name", fangjian.getFangjianName())
            .eq("fangjian_types", fangjian.getFangjianTypes())
            .eq("fangjian_kucun_number", fangjian.getFangjianKucunNumber())
            .eq("shangxia_types", fangjian.getShangxiaTypes())
            .eq("fangjian_delete", 1)
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        FangjianEntity fangjianEntity = fangjianService.selectOne(queryWrapper);
        if(fangjianEntity==null){
            fangjian.setFangjianClicknum(1);
            fangjian.setShangxiaTypes(1);
            fangjian.setFangjianDelete(1);
            fangjian.setInsertTime(new Date());
            fangjian.setCreateTime(new Date());
            fangjianService.insert(fangjian);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody FangjianEntity fangjian, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
        logger.debug("update方法:,,Controller:{},,fangjian:{}",this.getClass().getName(),fangjian.toString());
        FangjianEntity oldFangjianEntity = fangjianService.selectById(fangjian.getId());//查询原先数据

        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(false)
//            return R.error(511,"永远不会进入");
        if("".equals(fangjian.getFangjianPhoto()) || "null".equals(fangjian.getFangjianPhoto())){
                fangjian.setFangjianPhoto(null);
        }
        if("".equals(fangjian.getFangjianContent()) || "null".equals(fangjian.getFangjianContent())){
                fangjian.setFangjianContent(null);
        }

            fangjianService.updateById(fangjian);//根据id更新
            return R.ok();
    }



    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        List<FangjianEntity> oldFangjianList =fangjianService.selectBatchIds(Arrays.asList(ids));//要删除的数据
        ArrayList<FangjianEntity> list = new ArrayList<>();
        for(Integer id:ids){
            FangjianEntity fangjianEntity = new FangjianEntity();
            fangjianEntity.setId(id);
            fangjianEntity.setFangjianDelete(2);
            list.add(fangjianEntity);
        }
        if(list != null && list.size() >0){
            fangjianService.updateBatchById(list);
        }

        return R.ok();
    }


    /**
     * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName, HttpServletRequest request){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //.eq("time", new SimpleDateFormat("yyyy-MM-dd").format(new Date()))
        try {
            List<FangjianEntity> fangjianList = new ArrayList<>();//上传的东西
            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
            Date date = new Date();
            int lastIndexOf = fileName.lastIndexOf(".");
            if(lastIndexOf == -1){
                return R.error(511,"该文件没有后缀");
            }else{
                String suffix = fileName.substring(lastIndexOf);
                if(!".xls".equals(suffix)){
                    return R.error(511,"只支持后缀为xls的excel文件");
                }else{
                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
                    File file = new File(resource.getFile());
                    if(!file.exists()){
                        return R.error(511,"找不到上传文件，请联系管理员");
                    }else{
                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
                        dataList.remove(0);//删除第一行，因为第一行是提示
                        for(List<String> data:dataList){
                            //循环
                            FangjianEntity fangjianEntity = new FangjianEntity();
//                            fangjianEntity.setFangjianName(data.get(0));                    //客房名称 要改的
//                            fangjianEntity.setFangjianUuidNumber(data.get(0));                    //客房编号 要改的
//                            fangjianEntity.setFangjianPhoto("");//详情和图片
//                            fangjianEntity.setFangjianTypes(Integer.valueOf(data.get(0)));   //房型 要改的
//                            fangjianEntity.setFangjianKucunNumber(Integer.valueOf(data.get(0)));   //剩余房数 要改的
//                            fangjianEntity.setFangjianOldMoney(data.get(0));                    //客房原价 要改的
//                            fangjianEntity.setFangjianNewMoney(data.get(0));                    //现价/天 要改的
//                            fangjianEntity.setFangjianClicknum(Integer.valueOf(data.get(0)));   //客房热度 要改的
//                            fangjianEntity.setFangjianContent("");//详情和图片
//                            fangjianEntity.setShangxiaTypes(Integer.valueOf(data.get(0)));   //是否上架 要改的
//                            fangjianEntity.setFangjianDelete(1);//逻辑删除字段
//                            fangjianEntity.setInsertTime(date);//时间
//                            fangjianEntity.setCreateTime(date);//时间
                            fangjianList.add(fangjianEntity);


                            //把要查询是否重复的字段放入map中
                                //客房编号
                                if(seachFields.containsKey("fangjianUuidNumber")){
                                    List<String> fangjianUuidNumber = seachFields.get("fangjianUuidNumber");
                                    fangjianUuidNumber.add(data.get(0));//要改的
                                }else{
                                    List<String> fangjianUuidNumber = new ArrayList<>();
                                    fangjianUuidNumber.add(data.get(0));//要改的
                                    seachFields.put("fangjianUuidNumber",fangjianUuidNumber);
                                }
                        }

                        //查询是否重复
                         //客房编号
                        List<FangjianEntity> fangjianEntities_fangjianUuidNumber = fangjianService.selectList(new EntityWrapper<FangjianEntity>().in("fangjian_uuid_number", seachFields.get("fangjianUuidNumber")).eq("fangjian_delete", 1));
                        if(fangjianEntities_fangjianUuidNumber.size() >0 ){
                            ArrayList<String> repeatFields = new ArrayList<>();
                            for(FangjianEntity s:fangjianEntities_fangjianUuidNumber){
                                repeatFields.add(s.getFangjianUuidNumber());
                            }
                            return R.error(511,"数据库的该表中的 [客房编号] 字段已经存在 存在数据为:"+repeatFields.toString());
                        }
                        fangjianService.insertBatch(fangjianList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }



    /**
    * 个性推荐
    */
    @IgnoreAuth
    @RequestMapping("/gexingtuijian")
    public R gexingtuijian(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("gexingtuijian方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        CommonUtil.checkMap(params);
        List<FangjianView> returnFangjianViewList = new ArrayList<>();

        //查询订单
        Map<String, Object> params1 = new HashMap<>(params);params1.put("sort","id");params1.put("yonghuId",request.getSession().getAttribute("userId"));
        params1.put("shangxiaTypes",1);
        params1.put("fangjianYesnoTypes",2);
        PageUtils pageUtils = fangjianOrderService.queryPage(params1);
        List<FangjianOrderView> orderViewsList =(List<FangjianOrderView>)pageUtils.getList();
        Map<Integer,Integer> typeMap=new HashMap<>();//购买的类型list
        for(FangjianOrderView orderView:orderViewsList){
            Integer fangjianTypes = orderView.getFangjianTypes();
            if(typeMap.containsKey(fangjianTypes)){
                typeMap.put(fangjianTypes,typeMap.get(fangjianTypes)+1);
            }else{
                typeMap.put(fangjianTypes,1);
            }
        }
        List<Integer> typeList = new ArrayList<>();//排序后的有序的类型 按最多到最少
        typeMap.entrySet().stream().sorted((o1, o2) -> o2.getValue() - o1.getValue()).forEach(e -> typeList.add(e.getKey()));//排序
        Integer limit = Integer.valueOf(String.valueOf(params.get("limit")));
        for(Integer type:typeList){
            Map<String, Object> params2 = new HashMap<>(params);params2.put("fangjianTypes",type);
            params2.put("shangxiaTypes",1);
            params2.put("fangjianYesnoTypes",2);
            PageUtils pageUtils1 = fangjianService.queryPage(params2);
            List<FangjianView> fangjianViewList =(List<FangjianView>)pageUtils1.getList();
            returnFangjianViewList.addAll(fangjianViewList);
            if(returnFangjianViewList.size()>= limit) break;//返回的推荐数量大于要的数量 跳出循环
        }
        params.put("shangxiaTypes",1);
        params.put("fangjianYesnoTypes",2);
        //正常查询出来商品,用于补全推荐缺少的数据
        PageUtils page = fangjianService.queryPage(params);
        if(returnFangjianViewList.size()<limit){//返回数量还是小于要求数量
            int toAddNum = limit - returnFangjianViewList.size();//要添加的数量
            List<FangjianView> fangjianViewList =(List<FangjianView>)page.getList();
            for(FangjianView fangjianView:fangjianViewList){
                Boolean addFlag = true;
                for(FangjianView returnFangjianView:returnFangjianViewList){
                    if(returnFangjianView.getId().intValue() ==fangjianView.getId().intValue()) addFlag=false;//返回的数据中已存在此商品
                }
                if(addFlag){
                    toAddNum=toAddNum-1;
                    returnFangjianViewList.add(fangjianView);
                    if(toAddNum==0) break;//够数量了
                }
            }
        }else {
            returnFangjianViewList = returnFangjianViewList.subList(0, limit);
        }

        for(FangjianView c:returnFangjianViewList)
            dictionaryService.dictionaryConvert(c, request);
        page.setList(returnFangjianViewList);
        return R.ok().put("data", page);
    }

    /**
    * 前端列表
    */
    @IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));

        CommonUtil.checkMap(params);
        PageUtils page = fangjianService.queryPage(params);

        //字典表数据转换
        List<FangjianView> list =(List<FangjianView>)page.getList();
        for(FangjianView c:list)
            dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段

        return R.ok().put("data", page);
    }

    /**
    * 前端详情
    */
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Integer id, HttpServletRequest request){
        logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        FangjianEntity fangjian = fangjianService.selectById(id);
            if(fangjian !=null){

                //点击数量加1
                fangjian.setFangjianClicknum(fangjian.getFangjianClicknum()+1);
                fangjianService.updateById(fangjian);

                //entity转view
                FangjianView view = new FangjianView();
                BeanUtils.copyProperties( fangjian , view );//把实体数据重构到view中

                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody FangjianEntity fangjian, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,fangjian:{}",this.getClass().getName(),fangjian.toString());
        Wrapper<FangjianEntity> queryWrapper = new EntityWrapper<FangjianEntity>()
            .eq("fangjian_name", fangjian.getFangjianName())
            .eq("fangjian_uuid_number", fangjian.getFangjianUuidNumber())
            .eq("fangjian_types", fangjian.getFangjianTypes())
            .eq("fangjian_kucun_number", fangjian.getFangjianKucunNumber())
            .eq("fangjian_clicknum", fangjian.getFangjianClicknum())
            .eq("shangxia_types", fangjian.getShangxiaTypes())
            .eq("fangjian_delete", fangjian.getFangjianDelete())
//            .notIn("fangjian_types", new Integer[]{102})
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        FangjianEntity fangjianEntity = fangjianService.selectOne(queryWrapper);
        if(fangjianEntity==null){
            fangjian.setFangjianClicknum(1);
            fangjian.setFangjianDelete(1);
            fangjian.setInsertTime(new Date());
            fangjian.setCreateTime(new Date());
        fangjianService.insert(fangjian);

            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

}

DateUtil.java

package com.utils;

import java.text.Format;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtil {


    public static String convertString(Date date,String format){
        if(date == null){
            return null;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(date);
    }
}

UsersController.java

package com.controller;

import java.util.List;
import java.util.Arrays;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import com.service.UsersService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.annotation.IgnoreAuth;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.UsersEntity;
import com.service.TokenService;
import com.utils.MPUtil;
import com.utils.PageUtils;
import com.utils.R;

/**
 * 登录相关
 */
@RequestMapping("users")
@RestController
public class UsersController {
	
	@Autowired
	private UsersService usersService;
	
	@Autowired
	private TokenService tokenService;

	/**
	 * 登录
	 */
	@IgnoreAuth
	@PostMapping(value = "/login")
	public R login(String username, String password, String captcha, HttpServletRequest request) {
		UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
		if(user==null || !user.getPassword().equals(password)) {
			return R.error("账号或密码不正确");
		}
		String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());
		R r = R.ok();
		r.put("token", token);
		r.put("role",user.getRole());
		r.put("userId",user.getId());
		return r;
	}
	
	/**
	 * 注册
	 */
	@IgnoreAuth
	@PostMapping(value = "/register")
	public R register(@RequestBody UsersEntity user){
//    	ValidatorUtils.validateEntity(user);
    	if(usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
    		return R.error("用户已存在");
    	}
        usersService.insert(user);
        return R.ok();
    }

	/**
	 * 退出
	 */
	@GetMapping(value = "logout")
	public R logout(HttpServletRequest request) {
		request.getSession().invalidate();
		return R.ok("退出成功");
	}

	/**
	 * 修改密码
	 */
	@GetMapping(value = "/updatePassword")
	public R updatePassword(String  oldPassword, String  newPassword, HttpServletRequest request) {
		UsersEntity users = usersService.selectById((Integer)request.getSession().getAttribute("userId"));
		if(newPassword == null){
			return R.error("新密码不能为空") ;
		}
		if(!oldPassword.equals(users.getPassword())){
			return R.error("原密码输入错误");
		}
		if(newPassword.equals(users.getPassword())){
			return R.error("新密码不能和原密码一致") ;
		}
		users.setPassword(newPassword);
		usersService.updateById(users);
		return R.ok();
	}
	
	/**
     * 密码重置
     */
    @IgnoreAuth
	@RequestMapping(value = "/resetPass")
    public R resetPass(String username, HttpServletRequest request){
    	UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
    	if(user==null) {
    		return R.error("账号不存在");
    	}
    	user.setPassword("123456");
        usersService.update(user,null);
        return R.ok("密码已重置为：123456");
    }
	
	/**
     * 列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params,UsersEntity user){
        EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
    	PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
        return R.ok().put("data", page);
    }

	/**
     * 列表
     */
    @RequestMapping("/list")
    public R list( UsersEntity user){
       	EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
      	ew.allEq(MPUtil.allEQMapPre( user, "user")); 
        return R.ok().put("data", usersService.selectListView(ew));
    }

    /**
     * 信息
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") String id){
        UsersEntity user = usersService.selectById(id);
        return R.ok().put("data", user);
    }
    
    /**
     * 获取用户的session用户信息
     */
    @RequestMapping("/session")
    public R getCurrUser(HttpServletRequest request){
    	Integer id = (Integer)request.getSession().getAttribute("userId");
        UsersEntity user = usersService.selectById(id);
        return R.ok().put("data", user);
    }

    /**
     * 保存
     */
    @PostMapping("/save")
    public R save(@RequestBody UsersEntity user){
//    	ValidatorUtils.validateEntity(user);
    	if(usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
    		return R.error("用户已存在");
    	}
        usersService.insert(user);
        return R.ok();
    }

    /**
     * 修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody UsersEntity user){
//        ValidatorUtils.validateEntity(user);
        usersService.updateById(user);//全部更新
        return R.ok();
    }

    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Long[] ids){
		List<UsersEntity> user = usersService.selectList(null);
		if(user.size() > 1){
			usersService.deleteBatchIds(Arrays.asList(ids));
		}else{
			return R.error("管理员最少保留一个");
		}
        return R.ok();
    }
}

IndexMain.vue

<template>
			<el-main style="padding: 10px 20px;
						background-image: url(/gelijiudian/img/back-list-img-bg.jpg);
						background-size:100% 100%;
						boxShadow: 0 0 6px rgba(0,0,0,0);
                height:calc(100% - ${template2.back.menulist.menulistHeight});
        		">
    		<bread-crumbs :title="title" class="bread-crumbs"></bread-crumbs>
		<router-view class="router-view" style="height:auto;background: transparent;"></router-view>
	</el-main>
</template>

<script>
	import menu from "@/utils/menu";
	export default {
		data() {
			return {
				menuList: [],
				role: "",
				currentIndex: -2,
				itemMenu: [],
				title: '',
			};
		},
		mounted() {
			let menus = menu.list();
			this.menuList = menus;
			this.role = this.$storage.get("role");
		},
		created() {
			this.init();
		},
		methods: {
			init(){
				this.$nextTick(()=>{
					// let h = document.getElementsByClassName('el-aside')[0].clientHeight
					// document.getElementsByClassName('el-main')[0].style.minHeight = "calc(100vh - 60px - " + h+'px)'
				})
			},
			menuHandler(menu) {
				this.$router.push({
					name: menu.tableName
				});
				this.title = menu.menu;
			},
			titleChange(index, menus) {
				this.currentIndex = index
				this.itemMenu = menus;
				console.log(menus);
			},
			homeChange(index) {
				this.itemMenu = [];
				this.title = ""
				this.currentIndex = index
				this.$router.push({
					name: 'home'
				});
			},
			centerChange(index) {
				this.itemMenu = [{
					"buttons": ["新增", "查看", "修改", "删除"],
					"menu": "修改密码",
					"tableName": "updatePassword"
				}, {
					"buttons": ["新增", "查看", "修改", "删除"],
					"menu": "个人信息",
					"tableName": "center"
				}];
				this.title = ""
				this.currentIndex = index
				this.$router.push({
					name: 'home'
				});
				
			}
		}
	};
</script>
<style lang="scss" scoped>
	a {
		text-decoration: none;
		color: #555;
	}

	a:hover {
		background: #00c292;
	}

	.nav-list {
		width: 100%;
		margin: 0 auto;
		text-align: left;
		margin-top: 20px;

		.nav-title {
			display: inline-block;
			font-size: 15px;
			color: #333;
			padding: 15px 25px;
			border: none;
		}

		.nav-title.active {
			color: #555;
			cursor: default;
			background-color: #fff;
		}
	}

	.nav-item {
		margin-top: 20px;
		background: #FFFFFF;
		padding: 15px 0;

		.menu {
			padding: 15px 25px;
		}
	}

	.el-main {
		// background-color: #F6F8FA;
		padding: 0 24px;
		min-height: 100vh;
		// padding-top: 60px;
	}

	.router-view {
		padding: 10px;
		margin-top: 10px;
		background: #FFFFFF;
		box-sizing: border-box;
	}

	.bread-crumbs {
		width: 100%;
		// border-bottom: 1px solid #e9eef3;
		// border-top: 1px solid #e9eef3;
		margin-top: 10px;
		box-sizing: border-box;
	}
	
	.detail-form-content {
	    background: transparent;
	}
</style>

声明

本博客适用于广泛的学术和教育用途，包括但不限于个人学习、开发设计，产品设计。仅供学习参考，旨在为读者提供深入理解和学术研究的材料。