Merge remote-tracking branch 'origin/main'

README.md

@@ -1,2 +1,68 @@
-# test
+系统角色分为：经理（管理员）和员工（普通用户）两种用户， 其中经理（管理员）具有查看所有预定、删除客房、查看员工、添加员工等功能权限 员工（普通用户）具有查看空房、客户预订、修改预订、删除预订、注册新客户等功能权限（任务自拟）
+
+
+
+
+
+## 用户角色
+
+| 用户    | 权限                                             |
+| ------- | :----------------------------------------------- |
+| 经理    | 增删改查客房，增删查员工信息，查看自己工资       |
+| 员工2   | 查看空房，预定房间，删除预定，结账，查看自己工资 |
+| 保洁员3 | 接受退房后客户的信息进行卫生打扫，查看自己工资   |
+|         |                                                  |
+| 管理员  | 查看所有客房信息及收益信息，增删改查经理信息。   |
+
+# 主要流程
+
+1.经理设置客房状态并且设置每晚价格。
+
+2.客户可以通过员工预定房间，或者自己预定房间，并且可以选择预定时间（包含钟点房）
+
+3.当客户退房后，通知保洁员进行卫生打扫，保洁员确定卫生情况后，客房重新变为可预定，并且密码重新随机生成
+
+5.老板可以设置经理，员工，保洁员的工资，根据业绩比例进行分配
+
+# 主要实体
+
+用户：用户id，账户名，密码，真实姓名，年龄，身份证号，权限，总绩效。
+
+订单：订单id，房间id，用户id，开始时间，结束时间，总价格，当前状态(已付款，待付款，已入住，未入住，已取消)
+
+房间：房间id，房间位置，房间价格，房间状态(0.停用，1.未预定，2.已预定，3.待清扫)，房间密码
+
+配置：经理工资百分比，员工工资百分比，保洁员工资百分比，经理底薪，员工底薪，保洁员底薪
+
+
+修改：
+
+员工加手机号，房间加房间类型
+
+
+
+个人信息管理（修改信息，头像修改）
+
+经理：员工管理（增加删除员工），房间管理（增加，删除，修改为停用或未预定），订单查看；
+
+员工：订房（1.显示房间列表->生成订单，填信息，），订单管理（付钱，修改房间，退房，取消订单，订单列表）
+
+清洁工：查看待清扫房间列表，修改房间状态
+
+管理员(人员管理（权限修改，密码重置），工资管理（修改），业绩（查看汇总，所有订单列表）)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 

jiudianmanage.sql

@@ -15,35 +15,35 @@
 */
 
 SET NAMES utf8mb4;
-SET FOREIGN_KEY_CHECKS = 0;
+SET FOREIGN_KEY_CHECKS = 0;--临时禁用外键约束检查，便于删除和重建表
 
 -- ----------------------------
 -- Table structure for config
 -- ----------------------------
 DROP TABLE IF EXISTS `config`;
 CREATE TABLE `config`  (
-  `id` int NOT NULL,
-  `managesalary` double(10, 2) NULL DEFAULT NULL,
-  `staffsalary` double(10, 2) NULL DEFAULT NULL,
-  `cleanerssalary` double(10, 2) NULL DEFAULT NULL,
-  `manage` double(10, 2) NULL DEFAULT NULL,
-  `staff` double(10, 2) NULL DEFAULT NULL,
-  `cleaner` double(10, 2) NULL DEFAULT NULL,
-  `totalmoney` double(10, 2) NULL DEFAULT NULL,
-  `totalroom` double(10, 2) NULL DEFAULT NULL,
-  PRIMARY KEY (`id`) USING BTREE
+  `id` int NOT NULL,-- 配置ID，主键，整数类型
+  `managesalary` double(10, 2) NULL DEFAULT NULL,--经理工资，双精度浮点数，最多10位，2位小数
+  `staffsalary` double(10, 2) NULL DEFAULT NULL,--员工工资，同上
+  `cleanerssalary` double(10, 2) NULL DEFAULT NULL,--清洁员工资，同上
+  `manage` double(10, 2) NULL DEFAULT NULL,--经理数量，同上
+  `staff` double(10, 2) NULL DEFAULT NULL,--员工数量，同上
+  `cleaner` double(10, 2) NULL DEFAULT NULL,--清洁员数量，同上
+  `totalmoney` double(10, 2) NULL DEFAULT NULL,-- 总金额，同上
+  `totalroom` double(10, 2) NULL DEFAULT NULL, --总客房数，同上
+  PRIMARY KEY (`id`) USING BTREE--指定索引使用的数据结构
 ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
-
+--使用InnoDB存储引擎，支持事务，字符集为utf8，动态行格式，优化存储
 -- ----------------------------
 -- Table structure for order
 -- ----------------------------
 DROP TABLE IF EXISTS `order`;
 CREATE TABLE `order`  (
-  `orderid` int NOT NULL,
-  `householdname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `ID` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
-  `starttime` datetime NULL DEFAULT NULL,
-  `endtime` datetime NULL DEFAULT NULL,
+  `orderid` int NOT NULL,--订单ID，主键，整数类型
+  `householdname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,--住户姓名，可变长度字符串，最多255字符
+  `ID` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,--身份证号，同上
+  `starttime` datetime NULL DEFAULT NULL,--创建一个名为starttime的字段，类型为datetime，允许为空，且默认值为NULL。
+  `endtime` datetime NULL DEFAULT NULL,--创建一个名为endtime的字段，类型为datetime，允许为空，且默认值为NULL。
   `money` double NULL DEFAULT NULL,
   `state` int NULL DEFAULT NULL,
   `roomid` int NULL DEFAULT NULL,
@@ -74,7 +74,7 @@ CREATE TABLE `user`  (
   `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `age` int NULL DEFAULT NULL,
-  `power` int NULL DEFAULT NULL,
+  `power` int NULL DEFAULT NULL,--权限等级，整数类型
   `IDnumber` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
   `money` double NULL DEFAULT NULL,
   `photoUrl` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
@@ -82,4 +82,4 @@ CREATE TABLE `user`  (
   PRIMARY KEY (`userid`) USING BTREE
 ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
 
-SET FOREIGN_KEY_CHECKS = 1;
+SET FOREIGN_KEY_CHECKS = 1;--重新启用外键约束检查，确保数据完整性。

src/main/java/com/jiudian/manage/ManageApplication.java

@@ -12,17 +12,20 @@ import org.springframework.web.cors.CorsConfiguration;
 import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
 import org.springframework.web.filter.CorsFilter;
 
-
+// Spring Boot 启动类
 @SpringBootApplication
+//告诉 MyBatis 扫描 com.jiudian.manage.mapper 包下的所有接口
 @MapperScan(value = "com.jiudian.manage.mapper")
 public class ManageApplication  extends SpringBootServletInitializer {
 
     public static void main(String[] args) {
         SpringApplication.run(ManageApplication.class, args);
     }
-
+//主方法，启动 Spring 容器
+    // 构建跨域配置对象
     private CorsConfiguration buildConfig() {
         CorsConfiguration corsConfiguration = new CorsConfiguration();
+       //许任何前端域名访问
         corsConfiguration.addAllowedOrigin("*");
         corsConfiguration.addAllowedHeader("*");
         corsConfiguration.addAllowedMethod("*");

src/main/java/com/jiudian/manage/config/CustomMVCConfiguration.java

@@ -1,46 +1,50 @@
 package com.jiudian.manage.config;
-// 导入Spring相关注解和类
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.http.converter.HttpMessageConverter;
+//// 导入Spring相关注解和类，是核心组件
+import org.springframework.context.annotation.Bean;//spring对象
+import org.springframework.context.annotation.Configuration;//注释组件
+import org.springframework.http.converter.HttpMessageConverter;//负责 HTTP 请求 / 响应消息转换的组件
 import org.springframework.http.converter.StringHttpMessageConverter;
-import org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer;
-import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
+import org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer;//配置内容协商（如根据请求头确定返回数据格式）
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;// Spring MVC 的配置适配器组件，用于定制 Web 层的行为（如消息转换、拦截器、视图解析等
 
-import java.nio.charset.Charset;
-import java.util.List;
+import java.nio.charset.Charset;//Java 标准库中处理字符集的类
+import java.util.List;//Java 集合框架中的列表接口，用于存储转换器集合。
 
-// 标记当前类为Spring配置类，用于定义Spring Bean和配置
-@Configuration
-// 自定义MVC配置类，继承WebMvcConfigurerAdapter以扩展Spring MVC的默认配置
-// 注意：WebMvcConfigurerAdapter在Spring 5.0后已过时，推荐直接实现WebMvcConfigurer接口
-public class CustomMVCConfiguration extends WebMvcConfigurerAdapter {
+// * 自定义MVC配置类
+// * 用于配置HTTP消息转换和内容协商，解决中文乱码问题
+// */
+//Spring 会执行这些方法，将返回的对象存入容器（即 “注册 Bean”），供其他组件依赖注入
 
-    // 定义一个Bean，用于处理HTTP消息转换（主要是String类型响应）
+@Configuration //标识当前类是配置类，Spring 会扫描并加载其中的配置。
+public class CustomMVCConfiguration extends WebMvcConfigurerAdapter {
+    //创建并配置String类型的HTTP消息转换器
     @Bean
-    public HttpMessageConverter<String> responseBodyConverter() {
-        // 创建字符串HTTP消息转换器，并指定字符集为UTF-8，解决响应中文乱码问题
+    // 声明这是一个Bean，会被Spring容器管理
+    // 创建字符串消息转换器，处理响应体中字符串转换，设置字符集为UTF-8
+    public HttpMessageConverter<String> responseBodyConverter(){
         StringHttpMessageConverter converter = new StringHttpMessageConverter(
                 Charset.forName("UTF-8"));
-        return converter;
+        return converter;//返回创建的转换器对象，交给 Spring 容器管理。
     }
 
-    // 重写配置消息转换器的方法，用于注册自定义的消息转换器
-    @Override
+    @Override//重写父类，自定义消息转换器配置
+    //HttpMessageConverter<?>：这是 Spring 框架中定义的HTTP 消息转换器接口
+    // ，其中 <?> 是泛型通配符，表示该转换器可以处理任意类型的数据。
+    //List<HttpMessageConverter<?>> converters 表示：一个包含多种 HTTP 消息转换器的列表
     public void configureMessageConverters(
             List<HttpMessageConverter<?>> converters) {
-        // 调用父类方法，保留Spring MVC默认的消息转换器
         super.configureMessageConverters(converters);
-        // 将自定义的字符串消息转换器添加到转换器列表中
+        // 先调用父类方法，保留默认的转换器配置
         converters.add(responseBodyConverter());
+       // 添加我们自定义的字符串转换器
     }
 
-    // 重写内容协商配置方法，用于配置请求内容协商策略
     @Override
+//重写了父类WebMvcConfigurerAdapter中的同名方法，用于自定义 Spring MVC 的内容协商配置
     public void configureContentNegotiation(
             ContentNegotiationConfigurer configurer) {
-        // 禁用路径扩展名作为内容协商的判断依据（例如禁用通过".json"".xml"后缀判断响应格式）
-        // 避免因路径后缀导致的请求格式解析问题
         configurer.favorPathExtension(false);
     }
-}
+}
+// 禁用基于URL路径扩展名,不能有后缀的内容协商
+// 例如：/api/users.json 或 /api/users.xml 这样的URL将不再生效

src/main/java/com/jiudian/manage/controller/ConfigController.java

@@ -1,105 +1,87 @@
-
-// 定义包路径，属于酒店管理系统的控制层
-        package com.jiudian.manage.controller;
-
-// 导入配置实体类
+package com.jiudian.manage.controller;
+//导入所需的类和注解：
+//自定义类：Config（配置信息的实体类）、ConfigService（处理配置业务的服务类）、
+// State（状态常量类，如成功 / 错误码）、StateSignal（统一响应格式工具类）。
+//Spring 注解：@Autowired（依赖注入）、@RestController（标识 REST 控制器）、
+// @RequestMapping（映射 URL 路径）、@RequestParam（接收请求参数）。
+//Java 标准类：Map（用于返回键值对格式的响应数据）。
 import com.jiudian.manage.model.Config;
-// 导入配置服务接口
 import com.jiudian.manage.service.ConfigService;
-// 导入状态常量类
 import com.jiudian.manage.until.State;
-// 导入状态信号工具类（用于封装接口返回结果）
 import com.jiudian.manage.until.StateSignal;
-// 导入Spring自动注入注解
 import org.springframework.beans.factory.annotation.Autowired;
-// 导入SpringMVC请求映射注解
 import org.springframework.web.bind.annotation.RequestMapping;
-// 导入请求参数注解
 import org.springframework.web.bind.annotation.RequestParam;
-// 导入REST风格控制器注解
 import org.springframework.web.bind.annotation.RestController;
-
-// 导入Map集合（用于返回接口结果）
 import java.util.Map;
 
-// 标识该类为REST风格控制器，所有方法返回值会自动转为JSON
-@RestController
-// 定义该控制器的基础请求路径，所有接口路径都以"/config"开头
-@RequestMapping(value = "/config")
+// * 配置管理控制器
+// * 处理与系统配置相关的HTTP请求
+/*流程：1调用服务层获取配置数据。
+        2通过StateSignal统一封装响应格式（无论成功 / 失败，结构一致，方便前端解析）。
+       3. 返回封装后的 Map（自动转为 JSON 响应给前端）。*/
+
+@RestController //标记此类为REST控制器，所有方法返回JSON格式数据
+//建立URL路径与java方法的映射关系，客户端发起HTTP请求，会自动调用该注释的方法
+@RequestMapping(value = "/config") //SpringMVC的注释语法，定义基础URL路径，所有方法的URL都以此为前缀
+//value 是注解的属性，用于指定映射的 URL 路径
+//创建类：配置管理控制器
 public class ConfigController {
-    // 自动注入ConfigService实例，用于调用业务层方法
+    //自动注入ConfigService服务,依赖注入，用于后续调用configservice类中的方法
     @Autowired
     ConfigService configService;
 
     /**
-     * 获取系统配置信息的接口
-     * @return 包含配置信息的Map集合（封装了状态码、提示信息和配置数据）
+     * 获取系统配置信息
+     * @return 包含配置信息的Map对象
      */
-    // 定义接口请求路径，完整路径为"/config/getConfig.do"
-    @RequestMapping(value = "/getConfig.do")
+    @RequestMapping(value = "/getConfig.do") //定义具体的URL路径
     public Map getConfig(){
-        // 调用服务层方法获取配置信息
+        // 调用服务层获取配置信息
         Config config = configService.get();
-        // 创建状态信号对象，用于封装返回结果
+        // 创建状态信号对象，用于统一返回格式
         StateSignal signal = new StateSignal();
-        // 判断是否获取到配置信息
         if(config!=null){
-            // 若获取成功，存入成功状态码
+            // 配置存在，返回成功状态和配置数据
             signal.put(State.SuccessCode);
-            // 存入成功提示信息
             signal.put(State.SuccessMessage);
-            // 存入获取到的配置对象，键为"config"
-            signal.put("config",config);
+            signal.put("config",config);// 键为"config"，值为获取到的配置对象
         }else {
-            // 若获取失败，存入错误状态码
+            // 配置不存在，返回错误状态
             signal.put(State.ErrorCode);
-            // 存入错误提示信息
             signal.put(State.ErrorMessage);
         }
-        // 返回封装好的结果Map
-        return signal.getResult();
+        return signal.getResult();//自动转为 JSON 响应给前端
     }
 
     /**
-     * 修改系统配置的接口
-     * @param managesalary 经理薪水百分比
-     * @param staffsalary 员工薪水百分比
-     * @param cleanerssalary 保洁员薪水百分比
-     * @param manage 经理底薪
-     * @param staff 员工底薪
-     * @param cleaner 保洁员底薪
-     * @param totalmoney 总营业额（可选参数，默认值为-1）
-     * @param totalroom 总卖出房数（可选参数，默认值为-1）
-     * @return 包含修改结果的Map集合（封装了状态码和提示信息）
+     * 修改配置
+     * @param managesalary  经理薪水百分比
+     * @param staffsalary   员工薪水百分比
+     * @param cleanerssalary    保洁员薪水百分比
+     * @param manage    经理底薪
+     * @param staff     员工底薪
+     * @param cleaner   保洁员底薪
+     * @param totalmoney    总营业额
+     * @param totalroom     总卖出房数
+     * @return
      */
-    // 定义接口请求路径，完整路径为"/config/updateConfig.do"
-    @RequestMapping(value = "/updateConfig.do")
-    public Map updateConfig(
-            @RequestParam double managesalary,
-            @RequestParam double  staffsalary,
-            @RequestParam double cleanerssalary,
-            @RequestParam double manage,
-            @RequestParam double staff,
-            @RequestParam double cleaner,
-            @RequestParam(required = false,defaultValue = "-1") double totalmoney,
-            @RequestParam(required = false,defaultValue = "-1") double totalroom){
-        // 调用服务层方法执行修改操作，接收修改结果（布尔值）
+    @RequestMapping(value = "/updateConfig.do")// 定义具体的URL路径
+    // 接受HTTP请求，接收前端传递的配置参数，调用服务层执行更新操作
+    //@RequestParam：用于绑定 HTTP 请求参数到方法参数
+    public Map updateConfig(@RequestParam double managesalary,@RequestParam double  staffsalary,@RequestParam double cleanerssalary,@RequestParam double manage,@RequestParam double staff,@RequestParam double cleaner,@RequestParam(required = false,defaultValue = "-1") double totalmoney,@RequestParam(required = false,defaultValue = "-1") double totalroom){
+
         boolean update = configService.update(managesalary, staffsalary, cleanerssalary, manage, staff, cleaner, totalmoney, totalroom);
-        // 创建状态信号对象，用于封装返回结果
+        // 创建状态信号对象
         StateSignal signal = new StateSignal();
-        // 根据修改结果设置返回信息
         if(update){
-            // 若修改成功，存入成功状态码
+            // 更新成功
             signal.put(State.SuccessCode);
-            // 存入成功提示信息
             signal.put(State.SuccessMessage);
         }else {
-            // 若修改失败，存入错误状态码
             signal.put(State.ErrorCode);
-            // 存入错误提示信息
             signal.put(State.ErrorMessage);
         }
-        // 返回封装好的结果Map
         return signal.getResult();
     }
 }

src/main/java/com/jiudian/manage/controller/FileController.java

@@ -1,5 +1,10 @@
 package com.jiudian.manage.controller;
-
+//导入三类核心资源：
+//自定义业务类：UserService（用户相关业务服务）、FileUtil（文件上传工具类）、State（状态常量类）、StateSignal（统一响应格式工具类）；
+//Spring 注解 / 类：@Autowired（依赖注入）、@RestController（REST 控制器）、@RequestMapping（URL 映射）、@RequestParam（接收请求参数）
+// 、MultipartFile（Spring 封装的上传文件对象，用于接收前端上传的文件）；
+//Java 标准类：File（文件操作）、FileOutputStream（文件输出流，虽未直接用但工具类可能依赖）、Map（响应数据格式）、UUID（生成唯一文件名）、
+// Random（随机数）。
 import com.jiudian.manage.service.UserService;
 import com.jiudian.manage.until.FileUtil;
 import com.jiudian.manage.until.State;
@@ -9,71 +14,60 @@ import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.multipart.MultipartFile;//Spring 封装的上传文件对象，用于接收前端上传的文件
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.util.Map;
 import java.util.Random;
-import java.util.UUID;
-//该控制器的主要功能：
-//处理用户头像上传请求，路径为/upFile/upFilePhoto.do
-//核心流程：
-//生成唯一文件名（避免重复）
-//定义文件存储路径（本地路径 + 数据库存储的相对路径）
-//调用工具类上传文件到本地服务器
-//调用用户服务更新数据库中的用户头像路径
-//根据上传和数据库更新的结果，返回成功 / 失败的响应状态
-// 标记为REST风格控制器，所有方法返回数据而非视图
-@RestController
-// 配置请求路径前缀，所有方法的请求路径都以"/upFile"开头
-@RequestMapping(value = "/upFile")
+import java.util.UUID;//生成唯一文件名
+/**
+ * 文件上传控制器
+ * 主要处理用户头像上传功能
+ * 流程：前端发起请求，把文件和用户 ID 传给FileController的upFilePhoto.do接口；
+ * FileController调用FileUtil保存文件到服务器，同时调用UserService的photo方法；
+ * UserServiceImpl的photo方法创建User实体，调用UserMapper的updateByPrimaryKeySelective更新数据库；
+ * 最后通过StateSignal封装响应，返回给前端 “成功 / 失败” 的结果。
+ */
+@RestController //标记为REST控制器，返回JSON格式数据
+@RequestMapping(value = "/upFile")//定义控制器基础URL路径/根路径，所有方法URL以此为前缀
 public class FileController {
-
-    // 自动注入用户服务类，用于处理用户相关业务（此处主要用于更新用户头像路径）
+    // 自动注入UserService服务
     @Autowired
     UserService userService;
 
-    // 配置具体请求路径，处理用户头像上传请求
     @RequestMapping("/upFilePhoto.do")
-    // @RequestParam指定请求参数：file为上传的文件，userid为用户ID
-    public Map upFilePhoto(@RequestParam MultipartFile file, @RequestParam int userid) {
-        // 生成唯一文件名：UUID避免文件名重复 + 原始文件扩展名（保留文件类型）
-        String fileName = UUID.randomUUID().toString() + file.getOriginalFilename();
-
-        // 本地文件存储路径（项目内的静态资源目录）
+    //返回Map类型（会自动转为 JSON），参数为 “上传文件” 和 “用户 ID”；
+    public Map upFilePhoto(@RequestParam MultipartFile file,@RequestParam int userid){
+        //接受前端上传文件和用户Id参数
+        // 生成唯一的文件名，避免文件名冲突
+        // 使用UUID+原始文件名
+        String fileName = UUID.randomUUID().toString()+file.getOriginalFilename();
+//定义文件保存路径
+        // 本地保存路径：项目资源目录下的static/File文件夹
         String filePath = ".\\src\\main\\resources\\static\\File\\";
-        // 数据库存储的相对路径（用于前端访问时拼接完整路径）
-        String RealfilePath = "File\\" + fileName;
-
-        // 调用用户服务，更新该用户的头像路径到数据库
+        // 数据库存储的“相对路径”：前端访问时用该路径
+        String RealfilePath = "File"+"/"+fileName;
+        // 更新用户头像路径到数据库
         boolean photo = userService.photo(userid, RealfilePath);
-
-        // 标记文件上传是否成功
-        boolean uploadSuccess = false;
+        boolean b = false;
         try {
-            // 调用文件工具类，将文件字节数据上传到指定路径
-            uploadSuccess = FileUtil.uploadFile(file.getBytes(), filePath, fileName);
+           b = FileUtil.uploadFile(file.getBytes(), filePath, fileName);
         } catch (Exception e) {
-            // 捕获上传过程中的异常并打印堆栈信息
+            // 捕获并打印异常信息
             e.printStackTrace();
         }
-
-        // 创建状态信号对象，用于封装响应结果
+        // 创建状态信号对象，封装 API 接口，用于统一JSON回格式
         StateSignal signal = new StateSignal();
-
-        // 判断文件上传和数据库更新是否都成功
-        if (uploadSuccess && photo) {
-            // 都成功则返回成功状态码和消息
+        if(b&&photo){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-        } else {
-            // 有一项失败则返回错误状态码和消息
+        }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        // 返回封装好的响应结果（Map格式）
         return signal.getResult();
     }
-}
+
+
+}

src/main/java/com/jiudian/manage/controller/OrderController.java

@@ -1,145 +1,130 @@
 package com.jiudian.manage.controller;
-
+//导入核心资源：
+//实体类：Order（订单实体，封装订单信息如入住人、时间、房间 ID 等）；
+//服务层：OrderService（订单服务接口）、OrderServiceImpl（接口的实现类，包含订单业务逻辑）；
+//工具类：State（状态常量类，如成功 / 错误码）、StateSignal（统一响应格式工具类）；
+//Spring 注解：@Autowired（依赖注入）、@RestController（REST 控制器）、@RequestMapping（URL 映射）、@RequestParam（接收请求参数）；
+//Java 标准类：List（存储订单列表）、Map（接口返回的响应数据格式）。
 import com.jiudian.manage.model.Order;
 import com.jiudian.manage.service.OrderService;
 import com.jiudian.manage.service.impl.OrderServiceImpl;
 import com.jiudian.manage.until.State;
 import com.jiudian.manage.until.StateSignal;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.RequestMapping;//URL映射
+import org.springframework.web.bind.annotation.RequestParam;//接受参数请求
+import org.springframework.web.bind.annotation.RestController;//REST控制器
 
 import java.util.List;
 import java.util.Map;
-//该控制器的主要功能：
-//提供订单全生命周期的接口：添加、删除、修改状态、分页查询
-//所有接口返回统一格式的响应结果（通过StateSignal封装状态码、提示信息及业务数据）
-//依赖OrderServiceImpl处理具体业务逻辑，控制器层主要负责接收请求、参数传递和结果封装
-//接口路径设计遵循 REST 风格，通过@RequestMapping指定具体访问路径，便于前端调用
-// 标记为REST风格控制器，所有方法返回JSON数据而非视图
+/**
+ * 订单管理控制器
+ * 处理酒店预订系统中的订单相关操作
+ * 这个控制器实现了酒店订单管理的核心功能，包括创建、删除、更新和分页查询订单
+ * 每个接口通过@RequestMapping绑定特定 URL，接收前端参数后调用OrderServiceImpl处理业务；
+ * 统一使用StateSignal封装响应格式（包含状态码、消息、数据），确保前端能统一解析
+ */
 @RestController
-// 配置请求路径前缀，所有订单相关接口路径都以"/order"开头
-@RequestMapping(value = "/order")
+@RequestMapping(value = "/order")//定义该订单控制器的基础路径
 public class OrderController {
-
-    // 自动注入订单服务实现类，用于处理订单相关业务逻辑
     @Autowired
     OrderServiceImpl orderService;
-
+//: 自动注入订单服务实现类
     /**
-     * 添加订单接口
+     * 添加订单
      * @param householdname 入住人姓名
-     * @param id 入住人身份证号
-     * @param starttime 入住开始时间
-     * @param endtime 入住结束时间
-     * @param roomid 房间ID（关联对应的房间）
-     * @param userid 用户ID（下单用户的ID）
-     * @return 包含操作结果的Map（状态码、提示信息）
+     * @param id            入住人身份证号
+     * @param starttime     开始时间
+     * @param endtime       结束时间
+     * @param roomid        房间id
+     * @param userid        用户id
+     * @return
      */
+    //Spring MVC 中的一个注解，用于将 HTTP 请求映射到控制器的处理方法上
     @RequestMapping("/addOrder.do")
-    public Map addOrder(
-            @RequestParam String householdname,
-            @RequestParam String id,
-            @RequestParam String starttime,
-            @RequestParam String endtime,
-            @RequestParam int roomid,
-            @RequestParam int userid
-    ) {
-        // 调用订单服务添加订单，返回操作结果（成功/失败）
-        boolean isSuccess = orderService.addOrder(householdname, id, starttime, endtime, roomid, userid);
-
-        // 创建状态信号对象，用于封装响应结果
+    public Map addOrder(@RequestParam String householdname,@RequestParam String id,@RequestParam String starttime,@RequestParam String endtime,@RequestParam int roomid,@RequestParam int userid){
+        // 调用服务层添加订单
+        boolean b = orderService.addOrder(householdname, id, starttime, endtime, roomid, userid);
+        // 创建统一响应对象StateSignal，封装响应状态和数据
         StateSignal signal = new StateSignal();
-
-        if (isSuccess) {
-            // 操作成功：添加成功状态码和提示信息
+        if(b){
+            //添加成功
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-        } else {
-            // 操作失败：添加错误状态码和提示信息
+        }else {
+            // 添加失败：存入错误状态码和消
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        // 返回封装好的响应结果（Map格式）
-        return signal.getResult();
+        // 返回封装后的响应（Map类型，自动转为JSON给前端）
+        return  signal.getResult();
     }
 
     /**
-     * 删除订单接口（需管理员权限）
-     * @param orderid 要删除的订单ID
-     * @return 包含操作结果的Map（状态码、提示信息）
+     * 删除订单（管理员权限）
+     * @param orderid 订单id
+     * @return
      */
     @RequestMapping("/delOrder.do")
-    public Map delOrder(@RequestParam int orderid) {
-        // 调用订单服务删除指定ID的订单，返回操作结果
-        boolean isSuccess = orderService.delOrder(orderid);
-
+    public Map delOrder(@RequestParam int orderid){
+        // 调用服务层的delOrder方法执行删除操作，返回布尔值结果
+        boolean b = orderService.delOrder(orderid);
         StateSignal signal = new StateSignal();
-
-        if (isSuccess) {
+        if(b){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-        } else {
+        }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        return signal.getResult();
+        return  signal.getResult();
     }
 
     /**
-     * 修改订单状态接口
-     * @param orderid 要修改的订单ID
-     * @param state 新的状态码（如：已预订、已入住、已取消等）
-     * @return 包含操作结果的Map（状态码、提示信息）
+     * 修改订单的状态
+     * @param orderid   订单id
+     * @param state     状态码
+     * @return
      */
     @RequestMapping("/updateOrderState.do")
-    public Map updateOrderState(@RequestParam int orderid, @RequestParam int state) {
-        // 调用订单服务更新指定订单的状态，返回操作结果
-        boolean isSuccess = orderService.updateOrderState(orderid, state);
-
+    public Map updateOrderState(@RequestParam int orderid,@RequestParam int state){
+        // 调用服务层更新订单状态
+        boolean b = orderService.updateOrderState(orderid, state);
         StateSignal signal = new StateSignal();
-
-        if (isSuccess) {
+        if(b){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-        } else {
+        }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        return signal.getResult();
+        return  signal.getResult();
     }
-
     /**
      * 获取所有订单（分页查询）
-     * @param pageNum 页码（第几页）
-     * @param pageSize 每页条数
-     * @return 包含订单列表和分页信息的Map
+     *
+     * @param pageNum 页码
+     * @param pageSize 每页记录数
+     * @return 包含订单列表和分页信息的Map对象
      */
+
     @RequestMapping("/getAllOrder.do")
-    public Map getAllOrder(@RequestParam int pageNum, @RequestParam int pageSize) {
-        // 调用订单服务分页查询所有订单，返回订单列表
-        List<Order> orderList = orderService.getAllOrder(pageNum, pageSize);
+    public Map getAllOrder(@RequestParam int pageNum,@RequestParam int pageSize){
 
+// 调用服务层获取订单列表
+        List<Order> allOrder = orderService.getAllOrder(pageNum, pageSize);
         StateSignal signal = new StateSignal();
-
-        if (orderList != null) {
-            // 查询成功：添加状态信息、订单列表和分页参数
+        if(allOrder!=null){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("List", orderList); // 订单列表数据
-            signal.put("pageNum", pageNum); // 当前页码
-            signal.put("pageSize", pageSize); // 每页条数
-        } else {
-            // 查询失败：添加错误状态信息
+            signal.put("List",allOrder);//键"List"对应值为订单列表
+            signal.put("pageNum",pageNum);//返回当前页码
+            signal.put("pageSize",pageSize);//返回每页条数
+        }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        return signal.getResult();
+        return  signal.getResult();
     }
 
-}
+}

src/main/java/com/jiudian/manage/controller/RoomController.java

@@ -1,5 +1,8 @@
 package com.jiudian.manage.controller;
-
+//业务相关类：User（用户实体，封装用户 ID、账号、权限等信息）、UserServiceImpl（用户服务实现类，处理用户业务逻辑）；
+//工具与常量类：ImageCode（验证码生成工具类）、State（状态常量类，如成功 / 错误码）、StateSignal（统一响应格式工具类）；
+//Spring 与 Servlet 类：@RestController（REST 控制器注解）、@RequestMapping（URL 映射）、@RequestParam（接收请求参数）、HttpServletResponse（输出响应，如验证码图片）、HttpSession（存储会话数据，如验证码）；
+//基础类：List（存储用户列表）、Map（接口返回的 JSON 格式载体）、IOException（处理验证码生成的 IO 异常）
 import com.jiudian.manage.model.Room;
 import com.jiudian.manage.service.RoomService;
 import com.jiudian.manage.until.State;
@@ -11,170 +14,84 @@ import org.springframework.web.bind.annotation.RestController;
 
 import java.util.List;
 import java.util.Map;
-//该控制器的主要功能：
-//提供房间全生命周期的接口：添加、删除、更新、查询（按条件分页查询、按 ID 查询详情）
-//接口设计特点：
-//采用 REST 风格路径，统一前缀/room，便于前端识别和管理
-//更新接口（updateRoom.do）支持部分字段更新，通过默认值区分是否需要更新该字段
-//所有接口返回统一格式的响应结果（通过StateSignal封装状态码、提示信息及业务数据）
-//核心职责：接收前端请求参数，调用RoomService处理业务逻辑，最终返回处理结果
-// 标记为REST风格控制器，所有方法返回JSON数据而非视图
-@RestController
-// 配置请求路径前缀，所有房间相关接口路径都以"/room"开头
-@RequestMapping(value = "/room")
+//这个控制器实现了酒店房间管理的完整功能，包括添加、删除、查询和更新房间信息。
+@RestController//标识是rest控制器，返回JSON数据
+@RequestMapping(value = "/room")//自定义控制器URL接口路径
 public class RoomController {
-
-    // 自动注入房间服务接口，用于处理房间相关业务逻辑
     @Autowired
-    RoomService roomService;
-
-    /**
-     * 添加房间接口
-     * @param local 房间位置（如：3楼301室）
-     * @param money 房间价格
-     * @param state 房间状态（如：0-空闲，1-已预订，2-已入住等）
-     * @param type 房间类型（如：1-单人间，2-双人间，3-套房等）
-     * @return 包含操作结果的Map（状态码、提示信息）
-     */
+    RoomService roomService;//注入服务层依赖，调用方法
     @RequestMapping("/addRoom.do")
-    public Map addRoom(
-            @RequestParam String local,
-            @RequestParam double money,
-            @RequestParam int state,
-            @RequestParam int type
-    ) {
-        // 调用房间服务添加房间，返回操作结果（成功/失败）
-        boolean isSuccess = roomService.addRoom(local, money, state, type);
-
-        // 创建状态信号对象，用于封装响应结果
+    public Map addRoom(@RequestParam String local,@RequestParam double money,@RequestParam int state,@RequestParam int type){
+        boolean b = roomService.addRoom(local, money, state, type);
         StateSignal signal = new StateSignal();
-
-        if (isSuccess) {
-            // 操作成功：添加成功状态码和提示信息
+        if(b){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-        } else {
-            // 操作失败：添加错误状态码和提示信息
+        }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        return signal.getResult();
+        return  signal.getResult();
     }
 
-    /**
-     * 删除房间接口
-     * @param roomid 要删除的房间ID
-     * @return 包含操作结果的Map（状态码、提示信息）
-     */
     @RequestMapping("/delRoom.do")
-    public Map delRoom(@RequestParam int roomid) {
-        // 调用房间服务删除指定ID的房间，返回操作结果
-        boolean isSuccess = roomService.delRoom(roomid);
-
+    public Map delRoom(@RequestParam int roomid){
+        boolean b = roomService.delRoom(roomid);
         StateSignal signal = new StateSignal();
-
-        if (isSuccess) {
+        if(b){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-        } else {
+        }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        return signal.getResult();
+        return  signal.getResult();
     }
-
-    /**
-     * 按状态和类型分页查询房间接口
-     * @param state 房间状态（查询条件）
-     * @param type 房间类型（查询条件）
-     * @param pageNum 页码（第几页）
-     * @param pageSize 每页条数
-     * @return 包含房间列表的Map（状态信息+房间数据）
-     */
-    @RequestMapping("/getRoom.do")
-    public Map selectRoom(
-            @RequestParam int state,
-            @RequestParam int type,
-            @RequestParam int pageNum,
-            @RequestParam int pageSize
-    ) {
-        // 调用房间服务按条件分页查询房间，返回房间列表
-        List<Room> roomList = roomService.getRoomByState(state, type, pageNum, pageSize);
-
+    @RequestMapping("/getRoom.do") //
+    public Map selectRoom(@RequestParam int state,@RequestParam int type,@RequestParam int pageNum,@RequestParam int pageSize){
+        List<Room> roomByState = roomService.getRoomByState(state, type,pageNum,pageSize);
         StateSignal signal = new StateSignal();
-
-        if (roomList != null) {
-            // 查询成功：添加状态信息和房间列表数据
+        if(roomByState!=null){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("List", roomList); // 房间列表
-        } else {
-            // 查询失败：添加错误状态信息
+            signal.put("List",roomByState);
+        }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        return signal.getResult();
+        return  signal.getResult();
     }
-
-    /**
-     * 更新房间信息接口（支持部分字段更新）
-     * @param roomid 要更新的房间ID（必传）
-     * @param local 房间位置（可选，默认"null"表示不更新）
-     * @param money 房间价格（可选，默认-1表示不更新）
-     * @param state 房间状态（可选，默认-1表示不更新）
-     * @param type 房间类型（可选，默认-1表示不更新）
-     * @return 包含操作结果的Map（状态码、提示信息）
-     */
+//更新房间信息
     @RequestMapping("/updateRoom.do")
-    public Map updateRoom(
-            @RequestParam int roomid,
-            @RequestParam(required = false, defaultValue = "null") String local,
-            @RequestParam(required = false, defaultValue = "-1") double money,
-            @RequestParam(required = false, defaultValue = "-1") int state,
-            @RequestParam(required = false, defaultValue = "-1") int type
-    ) {
-        // 调用房间服务更新房间信息，返回操作结果
-        boolean isSuccess = roomService.updateRoom(roomid, local, money, state, type);
-
+    public Map updateRoom(@RequestParam int roomid,@RequestParam(required = false,defaultValue = "null") String local,@RequestParam(required = false,defaultValue = "-1") double money,@RequestParam(required = false,defaultValue = "-1") int state,@RequestParam(required = false,defaultValue = "-1") int type){
+        boolean b = roomService.updateRoom(roomid, local, money, state, type);
         StateSignal signal = new StateSignal();
-
-        if (isSuccess) {
+        if(b){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-        } else {
+        }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        return signal.getResult();
+        return  signal.getResult();
     }
-
-    /**
-     * 根据ID查询房间详情接口
-     * @param roomid 房间ID
-     * @return 包含房间详情的Map（状态信息+房间对象）
-     */
+    //根据ID查询房间详情
     @RequestMapping("/getRoomById.do")
-    public Map getRoomById(@RequestParam int roomid) {
-        // 调用房间服务根据ID查询房间详情，返回房间对象
-        Room room = roomService.getRoomById(roomid);
-
+    public Map getRoomById(@RequestParam int roomid){
+        Room b = roomService.getRoomById(roomid);
         StateSignal signal = new StateSignal();
-
-        if (room != null) {
-            // 查询成功：添加状态信息和房间详情
+        if(b!=null){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("room", room); // 房间详情对象
-        } else {
-            // 查询失败：添加错误状态信息
+            signal.put("room",b);
+        }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        return signal.getResult();
+        return  signal.getResult();
     }
-}
+
+
+
+}
+//这是一个自定义的 StateSignal 类的实例，用于封装 API 响应结果

src/main/java/com/jiudian/manage/controller/UserController.java

@@ -16,256 +16,187 @@ import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.util.List;
 import java.util.Map;
-//该控制器的核心作用：
-//覆盖用户全生命周期管理接口，包括登录（含验证码）、新增、修改、删除、查询（全量 / 按权限 / 按 ID），适配酒店系统的用户管理需求；
-// 标记为REST风格控制器，所有接口返回JSON数据（非视图页面）
+//这个控制器实现了完整的用户管理功能，包括 验证码认证、授权.登录、注册、信息管理操作
 @RestController
-// 配置请求路径前缀，所有用户相关接口的访问路径均以"/user"开头
 @RequestMapping(value = "/user")
 public class UserController {
-
-    // 自动注入用户服务实现类，依赖其处理用户相关的业务逻辑（如登录、增删改查）
+    // 自动注入用户服务实现类
     @Autowired
     UserServiceImpl userService;
 
     /**
-     * 用户登录接口（已测试）
-     * @param useraccount 用户名（登录账号）
-     * @param password 密码
-     * @param icode 用户输入的验证码
-     * @param session HttpSession，用于获取服务器存储的验证码
-     * @return 包含登录结果的Map（状态码、提示信息、用户ID、用户权限）
+     * 登录
+     * @param useraccount
+     * @param password
+     * @return
      */
     @RequestMapping(value = "/login.do")
-    public Map login(
-            @RequestParam String useraccount,
-            @RequestParam String password,
-            @RequestParam String icode,
-            HttpSession session
-    ){
-        // 创建状态信号对象，用于统一封装接口响应结果
+    public Map login(@RequestParam String useraccount, @RequestParam String password,@RequestParam String icode,HttpSession session){
         StateSignal signal = new StateSignal();
-
-        // 从Session中获取服务器生成的验证码（ImageCode.CODENAME为验证码在Session中的存储键名）
-        String serverCode = (String) session.getAttribute(ImageCode.CODENAME);
-        // 打印日志，便于调试（服务器存储的验证码 vs 用户输入的验证码）
-        System.out.println("session: "+serverCode+"   实际"+icode);
-
-        // 第一步：校验验证码（注意：原代码"icode.equals(code)"存在笔误，应为"icode.equals(serverCode)"）
-        if(icode != null && serverCode != null && icode.equals(serverCode)){
-            // 第二步：验证码正确，调用服务层验证账号密码
-            // 返回值为int数组：index0=用户ID，index1=用户权限（如0-普通用户，1-管理员）
-            int[] loginResult = userService.login(useraccount, password);
-
-            // 第三步：判断账号密码验证结果
-            if(loginResult != null){
-                // 登录成功：封装成功状态、用户ID、用户权限
+        // 验证验证码
+        String code = (String) session.getAttribute(ImageCode.CODENAME);
+        System.out.println("session: "+code+"   实际"+icode);
+        if(icode!=null&&code!=null&&icode.equals(code)){
+            // 调用服务层进行登录验证
+            int[] login = userService.login(useraccount, password);
+            if(login!=null){
                 signal.put(State.SuccessCode);
                 signal.put(State.SuccessMessage);
-                signal.put("userid", loginResult[0]);
-                signal.put("power", loginResult[1]);
+                signal.put("userid",login[0]);
+                signal.put("power",login[1]);
             }else {
-                // 登录失败（账号或密码错误）：封装错误状态
                 signal.put(State.ErrorCode);
                 signal.put(State.ErrorMessage);
             }
         }else{
-            // 验证码错误：封装错误状态及自定义提示
             signal.put(State.ErrorCode);
             signal.put("message","验证码输入错误");
         }
-
-        // 返回封装好的响应结果（Map格式，便于前端解析）
         return signal.getResult();
     }
-
     /**
-     * 生成验证码图片接口
-     * @param code 预留参数（未实际使用）
-     * @param response HttpServletResponse，用于向客户端输出验证码图片
-     * @param session HttpSession，用于存储生成的验证码（供登录时校验）
-     * @throws IOException 图片生成或输出过程中可能抛出IO异常
+     * 生成验证码图片
+     *
+     * @param code 验证码
+     * @param response HTTP响应对象
+     * @param session HTTP会话对象
+     * @throws IOException IO异常
      */
     @GetMapping("/createImage")
-    public void createImage(
-            @RequestParam String code,
-            HttpServletResponse response,
-            HttpSession session
-    ) throws IOException {
-        // 调用工具类生成验证码图片，同时将验证码存入Session
-        ImageCode.createImage(response, session);
+    public void createImage(@RequestParam String code, HttpServletResponse response, HttpSession session) throws IOException {
+        // 调用工具类生成验证码图片
+        ImageCode.createImage(response,session);
     }
 
     /**
-     * 添加用户接口（已测试）
-     * @param useraccount 用户名（账号，需唯一）
-     * @param password 密码
-     * @param power 权限（字符串格式，需转为int，如"0"-普通用户，"1"-管理员）
-     * @return 包含添加结果的Map（状态码、提示信息）
+     * 添加用户(已测试)
+     * @param useraccount  用户名
+     * @param password  密码
+     * @param power     权限
+     * @return
      */
     @RequestMapping(value = "/addUser.do")
-    public Map addUser(
-            @RequestParam String useraccount,
-            @RequestParam String password,
-            @RequestParam String power
-    ){
-        // 调用服务层添加用户，将权限参数从String转为int
-        boolean isAddSuccess = userService.addUser(useraccount, password, Integer.parseInt(power));
+    public Map addUser(@RequestParam String useraccount, @RequestParam String password, @RequestParam String power){
+        // 调用服务层添加用户
+        boolean add = userService.addUser(useraccount,password,Integer.parseInt(power));
         StateSignal signal = new StateSignal();
-
-        if(isAddSuccess){
-            // 添加成功：封装成功状态
+        if(add){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
         }else {
-            // 添加失败（如用户名已存在）：封装错误状态
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
         return signal.getResult();
     }
 
     /**
-     * 修改用户信息接口（已测试，支持部分字段更新）
-     * @param userid 要修改的用户ID（必传，唯一标识用户）
-     * @param password 密码（可选，默认"null"表示不修改）
-     * @param username 用户名（可选，默认"null"表示不修改）
-     * @param age 年龄（可选，默认"-1"表示不修改）
-     * @param power 权限（可选，默认"-1"表示不修改）
-     * @param IDnumber 身份证号（可选，默认"null"表示不修改）
-     * @param phonenumber 手机号（可选，默认"null"表示不修改）
-     * @return 包含修改结果的Map（状态码、提示信息）
+     * 修改用户数据
+     * @param userid
+     * @param password
+     * @param username
+     * @param age
+     * @param power
+     * @param IDnumber
+     * @return
      */
     @RequestMapping(value = "/updateUser.do")
-    public Map updateUser(
-            @RequestParam int userid,
-            @RequestParam(required = false, defaultValue = "null") String password,
-            @RequestParam(required = false, defaultValue = "null") String username,
-            @RequestParam(required = false, defaultValue = "-1") int age,
-            @RequestParam(required = false, defaultValue = "-1") int power,
-            @RequestParam(required = false, defaultValue = "null") String IDnumber,
-            @RequestParam(required = false, defaultValue = "null") String phonenumber
-    ){
-        // 调用服务层修改用户信息，传入所有参数（服务层内部判断是否更新对应字段）
-        boolean isUpdateSuccess = userService.alterUser(userid, password, username, age, power, IDnumber, phonenumber);
+    public Map updateUser(@RequestParam int userid,@RequestParam(required = false,defaultValue = "null") String password,@RequestParam(required = false,defaultValue = "null") String username,@RequestParam(required = false,defaultValue = "-1") int age,@RequestParam(required = false,defaultValue = "-1") int power,@RequestParam(required = false,defaultValue = "null") String IDnumber,@RequestParam(required = false,defaultValue = "null") String phonenumber){
+        // 调用服务层更新用户信息
+        boolean upd = userService.alterUser(userid, password, username, age, power, IDnumber,phonenumber);
         StateSignal signal = new StateSignal();
-
-        if(isUpdateSuccess){
+        if(upd){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
         }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
         return signal.getResult();
     }
 
     /**
-     * 删除用户接口（已测试）
-     * @param userid 要删除的用户ID（必传）
-     * @return 包含删除结果的Map（状态码、提示信息）
+     * 删除用户(已测试)
+     * @param userid    用户id
+     * @return
      */
     @RequestMapping(value = "/delUser.do")
-    public Map delUser(@RequestParam("userid") Integer userid){
-        // 调用服务层删除指定ID的用户
-        boolean isDelSuccess = userService.delUser(userid);
+    public Map delUser(@RequestParam("userid")Integer userid){
+        boolean del = userService.delUser(userid);
         StateSignal signal = new StateSignal();
-
-        if(isDelSuccess){
+        if(del){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
         }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
         return signal.getResult();
     }
 
     /**
-     * 获取所有用户列表（分页查询，已测试）
-     * @param pageNum 页码（如1表示第一页）
-     * @param pageSize 每页条数（如10表示每页显示10条）
-     * @return 包含用户列表及分页信息的Map（状态码、提示信息、用户列表、页码、每页条数）
+     * 获取用户列表(已测试)
+     * @return
      */
     @RequestMapping(value = "/getAllUser.do")
-    public Map getAllUser(@RequestParam int pageNum, @RequestParam int pageSize){
-        // 调用服务层分页查询所有用户
-        List<User> userList = userService.getAllUser(pageNum, pageSize);
+    public Map getAllUser(@RequestParam int pageNum,@RequestParam int pageSize){
+        List<User> allUser = userService.getAllUser(pageNum,pageSize);
         StateSignal signal = new StateSignal();
-
-        if(userList != null){
-            // 查询成功：封装成功状态、用户列表、分页参数
+        if(allUser!=null){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("List", userList);
-            signal.put("pageNum", pageNum);
-            signal.put("pageSize", pageSize);
+            signal.put("List",allUser);
+            signal.put("pageNum",pageNum);
+            signal.put("pageSize",pageSize);
         }else {
-            // 查询失败（如无数据）：封装错误状态
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
 
-        return signal.getResult();
+        return  signal.getResult();
     }
 
     /**
-     * 按权限获取用户列表（分页查询）
-     * @param power 权限值（如0-普通用户，1-管理员）
-     * @param pageNum 页码
-     * @param pageSize 每页条数
-     * @return 包含指定权限用户列表及分页信息的Map
+     * 获取对应权限的用户列表
+     * @param power
+     * @return
      */
     @RequestMapping(value = "/getUserByPower.do")
-    public Map getUserByPower(
-            @RequestParam int power,
-            @RequestParam int pageNum,
-            @RequestParam int pageSize
-    ){
-        // 调用服务层按权限分页查询用户
-        List<User> userList = userService.getUserByPower(power, pageNum, pageSize);
+    public Map getUserByPower(@RequestParam int power,@RequestParam int pageNum,@RequestParam int pageSize){
+        List<User> Users = userService.getUserByPower(power,pageNum,pageSize);
         StateSignal signal = new StateSignal();
-
-        if(userList != null){
+        if(Users!=null){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("List", userList);
-            signal.put("pageNum", pageNum);
-            signal.put("pageSize", pageSize);
+            signal.put("List",Users);
+            signal.put("pageNum",pageNum);
+            signal.put("pageSize",pageSize);
         }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        return signal.getResult();
+        return  signal.getResult();
     }
 
     /**
-     * 根据用户ID获取用户详情
-     * @param userid 用户ID
-     * @return 包含用户详情的Map（状态码、提示信息、用户对象）
+     * 通过userid获取信息
+     * @param userid 用户id
+     * @return
      */
     @RequestMapping(value = "/getUserById.do")
     public Map getUserById(@RequestParam int userid){
-        // 调用服务层根据ID查询单个用户详情
         User user = userService.selectUser(userid);
         StateSignal signal = new StateSignal();
-
-        if(user != null){
-            // 查询成功：封装成功状态及用户详情对象
+        if(user!=null){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("user", user);
+            signal.put("user",user);
         }else {
-            // 查询失败（如用户不存在）：封装错误状态
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-
-        return signal.getResult();
+        return  signal.getResult();
     }
 
-}
+
+}

src/main/java/com/jiudian/manage/mapper/ConfigMapper.java

@@ -2,55 +2,27 @@ package com.jiudian.manage.mapper;
 
 import com.jiudian.manage.model.Config;
 import org.springframework.stereotype.Repository;
-//该 Mapper 接口的核心作用：
-//作为配置表（Config 表）与 Java 代码的交互桥梁，通过 MyBatis 实现配置数据的增删改查；
-//通常用于管理酒店管理系统的全局配置项（如酒店名称、联系电话、默认房间价格、系统开关等），这些配置无需频繁修改，但需要持久化存储；
-//与 Service 层协同：Service 层（如 ConfigService）会注入该 Mapper，调用其方法完成配置数据的数据库操作，再对外提供配置查询、修改等业务接口。
-// 标记为Spring的仓库组件，用于将Mapper接口纳入Spring容器管理，避免注入时出现Bean找不到的问题
-@Repository
-// 配置表(Config)的Mapper接口，定义与数据库交互的抽象方法
-// 作用：通过MyBatis框架，将接口方法与SQL语句关联，实现配置数据的CRUD操作
+//这段代码是一个 MyBatis 的 Mapper 接口，用于定义与数据库交互的操作
+// * ConfigMapper接口
+// * 定义与配置表相关的数据库操作
+// 定义数据库操作的方法签名
+//与对应的 XML 映射文件配合使用
+//提供数据库访问的抽象层
+@Repository // 标记为数据访问组件，被Spring管理
 public interface ConfigMapper {
-
-    /**
-     * 根据主键(ID)删除配置表中的一条记录
-     * @param id 配置记录的主键ID
-     * @return 受影响的行数（1表示删除成功，0表示未找到对应记录）
-     */
     int deleteByPrimaryKey(Integer id);
-
     /**
-     * 插入一条完整的配置记录（所有字段都需传入，包括可能为null的字段）
-     * @param record 封装了配置数据的Config对象
-     * @return 受影响的行数（1表示插入成功，0表示插入失败）
+     * 根据主键删除配置记录
+
+     * @return 影响的行数
      */
     int insert(Config record);
 
-    /**
-     * 插入一条配置记录（只插入非null的字段，null字段不参与SQL插入，使用数据库默认值）
-     * @param record 封装了配置数据的Config对象
-     * @return 受影响的行数（1表示插入成功，0表示插入失败）
-     */
     int insertSelective(Config record);
 
-    /**
-     * 根据主键(ID)查询配置表中的一条记录
-     * @param id 配置记录的主键ID
-     * @return 封装了查询结果的Config对象（若未找到则返回null）
-     */
     Config selectByPrimaryKey(Integer id);
 
-    /**
-     * 根据主键(ID)更新配置记录（只更新非null的字段，null字段不更新，保留原数据）
-     * @param record 封装了待更新数据的Config对象（需包含主键ID）
-     * @return 受影响的行数（1表示更新成功，0表示未找到对应记录）
-     */
     int updateByPrimaryKeySelective(Config record);
 
-    /**
-     * 根据主键(ID)更新配置记录（更新所有字段，包括null字段，会覆盖原数据）
-     * @param record 封装了待更新数据的Config对象（需包含主键ID）
-     * @return 受影响的行数（1表示更新成功，0表示未找到对应记录）
-     */
     int updateByPrimaryKey(Config record);
 }

src/main/java/com/jiudian/manage/mapper/OrderMapper.java

@@ -4,58 +4,27 @@ import com.jiudian.manage.model.Order;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
-//：是订单数据在 Java 代码与数据库之间的 “桥梁”，OrderService 层会注入该 Mapper，调用其方法完成订单的增删改查（如 OrderServiceImpl 的 addOrder 方法会调用 insertSelective 插入订单）
-// 标记为Spring仓库组件，将该Mapper接口纳入Spring容器管理，解决Service层注入时的Bean依赖问题
-@Repository
-// 订单表(Order表)的Mapper接口，定义与数据库交互的抽象方法
-// 作用：通过MyBatis框架关联SQL语句，实现订单数据的CRUD（增删改查）操作，是订单业务数据持久化的核心接口
+/**
+ * OrderMapper接口
+ * 定义与订单表相关的数据库操作增删改查
+ */
+@Repository // 标记为数据访问组件，被Spring管理
 public interface OrderMapper {
-
-    /**
-     * 根据订单主键ID删除一条订单记录
-     * @param orderid 订单的唯一标识（主键ID）
-     * @return 受影响的行数（1表示删除成功，0表示未找到对应订单）
-     */
     int deleteByPrimaryKey(Integer orderid);
 
-    /**
-     * 插入一条完整的订单记录（所有字段均需传入，即使字段为null也会参与SQL插入，可能覆盖数据库默认值）
-     * @param record 封装了订单完整数据的Order对象（如userid、roomid、入住时间等）
-     * @return 受影响的行数（1表示插入成功，0表示插入失败）
-     */
     int insert(Order record);
 
-    /**
-     * 插入一条订单记录（仅插入非null的字段，null字段不生成到SQL中，使用数据库默认值）
-     * @param record 封装了订单部分/完整数据的Order对象
-     * @return 受影响的行数（1表示插入成功，0表示插入失败）
-     */
     int insertSelective(Order record);
 
-    /**
-     * 根据订单主键ID查询单条订单详情
-     * @param orderid 订单的唯一标识（主键ID）
-     * @return 封装了订单详情的Order对象（如未找到对应订单则返回null）
-     */
     Order selectByPrimaryKey(Integer orderid);
 
-    /**
-     * 根据订单主键ID更新订单记录（仅更新非null的字段，null字段不更新，保留原数据）
-     * @param record 封装了待更新数据的Order对象（必须包含主键orderid）
-     * @return 受影响的行数（1表示更新成功，0表示未找到对应订单）
-     */
     int updateByPrimaryKeySelective(Order record);
 
-    /**
-     * 根据订单主键ID更新订单记录（更新所有字段，即使字段为null也会覆盖原数据）
-     * @param record 封装了待更新完整数据的Order对象（必须包含主键orderid）
-     * @return 受影响的行数（1表示更新成功，0表示未找到对应订单）
-     */
     int updateByPrimaryKey(Order record);
 
-    /**
-     * 查询所有订单记录（注意：方法名"getAllUser"可能为笔误，语义上应为"getAllOrder"，实际功能是查询全量订单）
-     * @return 所有订单的List集合（若无订单数据则返回空集合，非null）
-     */
     List<Order> getAllUser();
-}
+}
+//返回类型: List<Order>
+//List: 表示返回的是一个集合
+//<Order>: 表示集合中存放的是Order类型的对象
+//所以这个方法返回的是一个包含多个Order对象的列表

src/main/java/com/jiudian/manage/mapper/RoomMapper.java

@@ -4,59 +4,24 @@ import com.jiudian.manage.model.Room;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
-
-// 标记为Spring仓库组件，将该Mapper接口纳入Spring容器管理，确保Service层可正常注入使用
+//MyBatis 的 Mapper 接口，用于定义与房间表相关的数据库操作
+//标记当前接口是 “数据访问层组件”，让 Spring 扫描时能识别并管理；
 @Repository
-// 房间表(Room表)的Mapper接口，定义与数据库交互的抽象方法
-// 作用：通过MyBatis框架关联SQL语句，实现房间数据的CRUD（增删改查）操作，是房间业务数据持久化的核心接口
 public interface RoomMapper {
-
-    /**
-     * 根据房间主键ID删除一条房间记录
-     * @param roomid 房间的唯一标识（主键ID）
-     * @return 受影响的行数（1表示删除成功，0表示未找到对应房间）
-     */
+    //传入要删除的房间 ID（用 Integer 而非 int，支持 null 判断，避免传入无效值）；
     int deleteByPrimaryKey(Integer roomid);
-
-    /**
-     * 插入一条完整的房间记录（所有字段均需传入，null字段会参与SQL插入，可能覆盖数据库默认值）
-     * @param record 封装了房间完整数据的Room对象（如位置、价格、状态、类型等）
-     * @return 受影响的行数（1表示插入成功，0表示插入失败）
-     */
+//全字段插入房间
     int insert(Room record);
-
-    /**
-     * 插入一条房间记录（仅插入非null的字段，null字段不生成到SQL中，使用数据库默认值）
-     * @param record 封装了房间部分/完整数据的Room对象
-     * @return 受影响的行数（1表示插入成功，0表示插入失败）
-     */
+//选择性插入房间
     int insertSelective(Room record);
-
-    /**
-     * 根据房间主键ID查询单条房间详情
-     * @param roomid 房间的唯一标识（主键ID）
-     * @return 封装了房间详情的Room对象（如未找到对应房间则返回null）
-     */
+//按主键查询房间
     Room selectByPrimaryKey(Integer roomid);
-
-    /**
-     * 根据房间主键ID更新房间记录（仅更新非null的字段，null字段不更新，保留原数据）
-     * @param record 封装了待更新数据的Room对象（必须包含主键roomid）
-     * @return 受影响的行数（1表示更新成功，0表示未找到对应房间）
-     */
+//选择性更新房间
     int updateByPrimaryKeySelective(Room record);
-
-    /**
-     * 根据房间主键ID更新房间记录（更新所有字段，即使字段为null也会覆盖原数据）
-     * @param record 封装了待更新完整数据的Room对象（必须包含主键roomid）
-     * @return 受影响的行数（1表示更新成功，0表示未找到对应房间）
-     */
+//全字段更新房间
     int updateByPrimaryKey(Room record);
-
-    /**
-     * 根据房间状态和类型查询房间列表
-     * @param stateType 封装了查询条件的Room对象（主要使用state字段-房间状态、type字段-房间类型）
-     * @return 符合条件的房间List集合（若无匹配房间则返回空集合，非null）
-     */
+//按状态和类型查询房间列表
     List<Room> selectRoomByStateType(Room stateType);
+
+
 }

src/main/java/com/jiudian/manage/mapper/UserMapper.java

@@ -4,72 +4,31 @@ import com.jiudian.manage.model.User;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
-
-// 标记为Spring仓库组件，将该Mapper接口纳入Spring容器管理，避免Service层注入时出现Bean缺失问题
+/**
+ * UserMapper接口
+ * 定义与用户表相关的数据库操作
+ */
+//selectByAccount: 主要用于用户登录验证
+//selectByPower: 用于权限管理，查询特定角色的用户
+//getAllUser: 用于用户管理页面展示所有用户
+//updateByPrimaryKeySelective: 用于用户信息更新，只更新修改过的字段
 @Repository
-// 用户表(User表)的Mapper接口，定义与数据库交互的抽象方法
-// 作用：通过MyBatis框架关联SQL语句，实现用户数据的CRUD（增删改查）操作，是用户业务数据持久化的核心接口
 public interface UserMapper {
-
-    /**
-     * 根据用户主键ID删除一条用户记录
-     * @param userid 用户的唯一标识（主键ID）
-     * @return 受影响的行数（1表示删除成功，0表示未找到对应用户）
-     */
     int deleteByPrimaryKey(Integer userid);
 
-    /**
-     * 插入一条完整的用户记录（所有字段均需传入，null字段会参与SQL插入，可能覆盖数据库默认值）
-     * @param record 封装了用户完整数据的User对象（如账号、密码、权限、手机号等）
-     * @return 受影响的行数（1表示插入成功，0表示插入失败）
-     */
     int insert(User record);
 
-    /**
-     * 插入一条用户记录（仅插入非null的字段，null字段不生成到SQL中，使用数据库默认值）
-     * @param record 封装了用户部分/完整数据的User对象
-     * @return 受影响的行数（1表示插入成功，0表示插入失败）
-     */
     int insertSelective(User record);
 
-    /**
-     * 根据用户主键ID查询单条用户详情
-     * @param userid 用户的唯一标识（主键ID）
-     * @return 封装了用户详情的User对象（如未找到对应用户则返回null）
-     */
     User selectByPrimaryKey(Integer userid);
 
-    /**
-     * 根据用户主键ID更新用户记录（仅更新非null的字段，null字段不更新，保留原数据）
-     * @param record 封装了待更新数据的User对象（必须包含主键userid）
-     * @return 受影响的行数（1表示更新成功，0表示未找到对应用户）
-     */
     int updateByPrimaryKeySelective(User record);
 
-    /**
-     * 根据用户主键ID更新用户记录（更新所有字段，即使字段为null也会覆盖原数据）
-     * @param record 封装了待更新完整数据的User对象（必须包含主键userid）
-     * @return 受影响的行数（1表示更新成功，0表示未找到对应用户）
-     */
     int updateByPrimaryKey(User record);
 
-    /**
-     * 查询所有用户记录
-     * @return 所有用户的List集合（若无用户数据则返回空集合，非null）
-     */
     List<User> getAllUser();
 
-    /**
-     * 根据用户权限查询用户列表
-     * @param power 权限值（如0-普通用户，1-管理员）
-     * @return 符合该权限的用户List集合（若无匹配用户则返回空集合，非null）
-     */
     List<User> selectByPower(Integer power);
 
-    /**
-     * 根据用户账号（useraccount）查询单个用户
-     * @param useraccount 用户登录账号（需唯一）
-     * @return 匹配账号的User对象（用于登录时校验账号是否存在，无匹配则返回null）
-     */
     User selectByAccount(String useraccount);
 }

src/main/java/com/jiudian/manage/model/Config.java

@@ -1,125 +1,138 @@
 package com.jiudian.manage.model;
-// 该包用于存放系统的数据模型类，对应数据库表结构
 
-/**
- * 系统配置信息模型类
- * 对应数据库中的config表，用于存储酒店管理系统的全局配置参数
- * 如人员薪资标准、人员数量统计、总营收、总房间数等
- */
+// * 系统配置实体类
+// * 对应数据库中的config表
+// * 用于存储酒店管理系统的全局配置信息
+// */
 public class Config {
-    // 配置记录的唯一标识（主键），自增整数类型
     private Integer id;
-
-    // 管理人员的薪资标准（例如：管理员月薪，单位：元）
+    /**
+     * 配置ID（主键）
+     * 通常系统配置表只有一条记录，ID固定为1
+     */
     private Double managesalary;
-
-    // 普通员工的薪资标准（例如：前台员工月薪，单位：元）
+    /**
+     * 经理薪水百分比
+     * 用于计算经理的绩效工资
+     * 例如：0.15表示15%
+     */
     private Double staffsalary;
-
-    // 保洁人员的薪资标准（例如：保洁员月薪，单位：元）
+    /**
+     * 员工薪水百分比
+     * 用于计算普通员工的绩效工资
+     * 例如：0.10表示10%
+     */
     private Double cleanerssalary;
-
-    // 管理人员的总数量（系统中登记的管理员人数）
+    /**
+     * 保洁员薪水百分比
+     * 用于计算保洁员的绩效工资
+     * 例如：0.08表示8%
+     */
     private Double manage;
-
-    // 普通员工的总数量（系统中登记的普通员工人数）
+    /**
+     * 经理底薪
+     * 经理的固定薪资基数
+     */
     private Double staff;
-
-    // 保洁人员的总数量（系统中登记的保洁员人数）
+    /**
+     * 员工底薪
+     * 普通员工的固定薪资基数
+     */
     private Double cleaner;
-
-    // 酒店累计的总营收金额（所有订单收入总和，单位：元）
+    /**
+     * 保洁员底薪
+     * 保洁员的固定薪资基数
+     */
     private Double totalmoney;
-
-    // 酒店拥有的总房间数量（所有类型房间的总和）
+    /**
+     * 总营业额
+     * 酒店的总营业收入
+     */
     private Double totalroom;
-
-    // 获取id字段值的方法
+    /**
+     * 总卖出房数
+     * 酒店总共出租的房间数量
+     */
     public Integer getId() {
         return id;
     }
-
-    // 设置id字段值的方法
+    /**
+     * 获取配置ID
+     * @return 配置ID
+     */
     public void setId(Integer id) {
         this.id = id;
     }
-
-    // 获取管理人员薪资标准的方法
+    /**
+     * 设置配置ID
+     * 配置ID
+     */
     public Double getManagesalary() {
         return managesalary;
     }
-
-    // 设置管理人员薪资标准的方法
+    /**
+     * 获取经理薪水百分比
+     * @return 经理薪水百分比
+     */
     public void setManagesalary(Double managesalary) {
         this.managesalary = managesalary;
     }
-
-    // 获取普通员工薪资标准的方法
+    /**
+     * 设置经理薪水百分比
+     * 经理薪水百分比
+     */
     public Double getStaffsalary() {
         return staffsalary;
     }
 
-    // 设置普通员工薪资标准的方法
     public void setStaffsalary(Double staffsalary) {
         this.staffsalary = staffsalary;
     }
 
-    // 获取保洁人员薪资标准的方法
     public Double getCleanerssalary() {
         return cleanerssalary;
     }
 
-    // 设置保洁人员薪资标准的方法
     public void setCleanerssalary(Double cleanerssalary) {
         this.cleanerssalary = cleanerssalary;
     }
 
-    // 获取管理人员数量的方法
     public Double getManage() {
         return manage;
     }
 
-    // 设置管理人员数量的方法
     public void setManage(Double manage) {
         this.manage = manage;
     }
 
-    // 获取普通员工数量的方法
     public Double getStaff() {
         return staff;
     }
 
-    // 设置普通员工数量的方法
     public void setStaff(Double staff) {
         this.staff = staff;
     }
 
-    // 获取保洁人员数量的方法
     public Double getCleaner() {
         return cleaner;
     }
 
-    // 设置保洁人员数量的方法
     public void setCleaner(Double cleaner) {
         this.cleaner = cleaner;
     }
 
-    // 获取酒店总营收的方法
     public Double getTotalmoney() {
         return totalmoney;
     }
 
-    // 设置酒店总营收的方法
     public void setTotalmoney(Double totalmoney) {
         this.totalmoney = totalmoney;
     }
 
-    // 获取酒店总房间数的方法
     public Double getTotalroom() {
         return totalroom;
     }
 
-    // 设置酒店总房间数的方法
     public void setTotalroom(Double totalroom) {
         this.totalroom = totalroom;
     }

src/main/java/com/jiudian/manage/model/Order.java

@@ -1,114 +1,98 @@
-package com.jiudian.manage.model;  // 定义该类所在import java.util.Date;  // 导入日期类，用于处理订单的时间字段
+package com.jiudian.manage.model;
+
 import java.util.Date;
 /**
- * 订单实体类，对应数据库中的order表
- * 用于封装酒店订单的所有信息，是订单数据在系统中流转的载体
- */
+ 订单实体类
+ 对应数据库中的 order 表
+ // 用于存储酒店预订订单信息
+ **/
 public class Order {
-    private Integer orderid;  // 订单ID（主键，自增），唯一标识一条订单记录
+    private Integer orderid;
 
-    private String householdname;  // 入住人姓名（预订房间的实际入住者姓名）
+    private String householdname;
 
-    private String id;  // 入住人身份证号（用于身份核验，字符串类型适配18位身份证）
+    private String id;
 
-    private Date starttime;  // 入住开始时间（订单的生效起始时间）
+    private Date starttime;
 
-    private Date endtime;  // 入住结束时间（订单的生效截止时间）
+    private Date endtime;
 
-    private Double money;  // 订单金额（该订单的总费用，单位：元）
+    private Double money;
 
-    private Integer state;  // 订单状态（用数字标识：如0-已预订、1-已入住、2-已取消、3-已完成等）
+    private Integer state;
 
-    private Integer roomid;  // 关联的房间ID（外键，关联room表的roomid，标识该订单对应的房间）
+    private Integer roomid;
 
-    private Integer userid;  // 关联的用户ID（外键，关联user表的userid，标识下单的用户）
+    private Integer userid;
 
-    // 获取订单ID
     public Integer getOrderid() {
         return orderid;
     }
 
-    // 设置订单ID（通常由数据库自增生成，前端无需传递）
     public void setOrderid(Integer orderid) {
         this.orderid = orderid;
     }
 
-    // 获取入住人姓名
     public String getHouseholdname() {
         return householdname;
     }
 
-    // 设置入住人姓名，自动去除字符串前后空格，避免无效空格影响数据准确性
     public void setHouseholdname(String householdname) {
         this.householdname = householdname == null ? null : householdname.trim();
     }
 
-    // 获取入住人身份证号
     public String getId() {
         return id;
     }
 
-    // 设置入住人身份证号，自动去除前后空格
     public void setId(String id) {
         this.id = id == null ? null : id.trim();
     }
 
-    // 获取入住开始时间
     public Date getStarttime() {
         return starttime;
     }
 
-    // 设置入住开始时间
     public void setStarttime(Date starttime) {
         this.starttime = starttime;
     }
 
-    // 获取入住结束时间
     public Date getEndtime() {
         return endtime;
     }
 
-    // 设置入住结束时间
     public void setEndtime(Date endtime) {
         this.endtime = endtime;
     }
 
-    // 获取订单金额
     public Double getMoney() {
         return money;
     }
 
-    // 设置订单金额（通常根据房间价格和入住时长计算得出）
     public void setMoney(Double money) {
         this.money = money;
     }
 
-    // 获取订单状态
     public Integer getState() {
         return state;
     }
 
-    // 设置订单状态（如用户取消订单时更新为"已取消"状态）
     public void setState(Integer state) {
         this.state = state;
     }
 
-    // 获取关联的房间ID
     public Integer getRoomid() {
         return roomid;
     }
 
-    // 设置关联的房间ID（下单时指定具体房间）
     public void setRoomid(Integer roomid) {
         this.roomid = roomid;
     }
 
-    // 获取下单用户的ID
     public Integer getUserid() {
         return userid;
     }
 
-    // 设置下单用户的ID（关联到具体的下单用户）
     public void setUserid(Integer userid) {
         this.userid = userid;
     }

src/main/java/com/jiudian/manage/model/Room.java

@@ -1,66 +1,58 @@
 package com.jiudian.manage.model;
-
 /**
- * 房间实体类，对应数据库中的room表
- * 用于封装酒店房间的核心信息，是房间数据在系统各层流转的核心载体
+ * 房间实体类
+ * 对应数据库中的room表
+ * 用于存储酒店房间的基本信息
+ * 属性存储：存储房间的基本信息，包括 ID、位置、价格、状态和类型
+ * 数据封装：通过 Getter 和 Setter 方法实现数据的封装和访问控制
  */
 public class Room {
-    private Integer roomid;  // 房间ID（主键，自增），唯一标识一间酒店房间
+    private Integer roomid;
 
-    private String local;  // 房间位置（如"3楼301室"、"1楼豪华套房01"，描述房间的具体位置）
+    private String local;
 
-    private Double money;  // 房间单价（单位：元/天，用于计算订单金额）
+    private Double money;
 
-    private Integer state;  // 房间状态（数字标识：如0-空闲、1-已预订、2-已入住、3-维修中，控制房间是否可下单）
+    private Integer state;
 
-    private Integer type;  // 房间类型（数字标识：如1-单人间、2-双人间、3-套房、4-亲子房，区分不同房型）
+    private Integer type;
 
-    // 获取房间ID（唯一标识，通常用于关联订单、查询房间详情）
     public Integer getRoomid() {
         return roomid;
     }
 
-    // 设置房间ID（由数据库自增生成，前端无需手动传递）
     public void setRoomid(Integer roomid) {
         this.roomid = roomid;
     }
 
-    // 获取房间位置
     public String getLocal() {
         return local;
     }
 
-    // 设置房间位置，自动去除字符串前后空格（避免用户输入多余空格导致位置信息不规范）
     public void setLocal(String local) {
         this.local = local == null ? null : local.trim();
     }
 
-    // 获取房间单价（用于订单创建时计算总费用：单价 × 入住天数）
     public Double getMoney() {
         return money;
     }
 
-    // 设置房间单价（管理员可通过后台修改，如旺季调价）
     public void setMoney(Double money) {
         this.money = money;
     }
 
-    // 获取房间状态（判断房间是否可预订的核心依据）
     public Integer getState() {
         return state;
     }
 
-    // 设置房间状态（如订单创建后改"空闲"为"已预订"，退房后改"已入住"为"空闲"）
     public void setState(Integer state) {
         this.state = state;
     }
 
-    // 获取房间类型（用于用户筛选房型，如"只看双人间"）
     public Integer getType() {
         return type;
     }
 
-    // 设置房间类型（新增房间时指定，区分不同房型的服务与价格）
     public void setType(Integer type) {
         this.type = type;
     }

src/main/java/com/jiudian/manage/model/User.java

@@ -1,126 +1,108 @@
 package com.jiudian.manage.model;
 
-/**
- * 用户实体类，对应数据库中的user表
- * 用于封装酒店管理系统中用户的所有核心信息，是用户数据在系统各层（Controller/Service/Mapper）流转的核心载体
- */
+// * 用户实体类
+// * 对应数据库中的user表
+// * 用于存储系统用户的基本信息
+// 用户信息存储：存储用户的基本信息，包括账号、密码、姓名等
+//权限管理：通过 power 字段实现基于角色的访问控制
+//个人资料：包含身份证号、手机号、头像等个人信息
 public class User {
-    private Integer userid;  // 用户ID（主键，自增），唯一标识系统中的一个用户
+    private Integer userid;
 
-    private String useraccount;  // 用户账号（登录时使用，需唯一，如手机号、自定义用户名）
+    private String useraccount;
 
-    private String password;  // 用户密码（存储时通常会加密，登录时需解密或加密后对比）
+    private String password;
 
-    private String username;  // 用户姓名（真实姓名，用于身份核验或订单信息展示）
+    private String username;
 
-    private Integer age;  // 用户年龄（可选信息，用于用户画像或特定业务限制）
+    private Integer age;
 
-    private Integer power;  // 用户权限（数字标识：如0-普通用户、1-管理员、2-员工，控制用户可操作的功能范围）
+    private Integer power;
 
-    private String idnumber;  // 用户身份证号（用于身份验证，如预订房间时的实名登记）
+    private String idnumber;
 
-    private Double money;  // 用户账户余额（可选，用于系统内支付、退款等资金相关操作）
+    private Double money;
 
-    private String photourl;  // 用户头像URL（存储头像文件在服务器的相对路径，前端通过路径加载头像）
+    private String photourl;
 
-    private String phonenumber;  // 用户手机号（用于联系用户、接收验证码或订单通知）
+    private String phonenumber;
 
-    // 获取用户ID（唯一标识，用于关联订单、更新用户信息等核心操作）
     public Integer getUserid() {
         return userid;
     }
 
-    // 设置用户ID（由数据库自增生成，前端无需手动传递）
     public void setUserid(Integer userid) {
         this.userid = userid;
     }
 
-    // 获取用户账号（登录时的核心凭证之一）
     public String getUseraccount() {
         return useraccount;
     }
 
-    // 设置用户账号，自动去除前后空格（避免因多余空格导致账号登录失败）
     public void setUseraccount(String useraccount) {
         this.useraccount = useraccount == null ? null : useraccount.trim();
     }
 
-    // 获取用户密码（注意：实际系统中需加密存储，此处仅为数据封装）
     public String getPassword() {
         return password;
     }
 
-    // 设置用户密码，自动去除前后空格（避免密码中包含无效空格）
     public void setPassword(String password) {
         this.password = password == null ? null : password.trim();
     }
 
-    // 获取用户姓名
     public String getUsername() {
         return username;
     }
 
-    // 设置用户姓名，自动去除前后空格（规范姓名格式）
     public void setUsername(String username) {
         this.username = username == null ? null : username.trim();
     }
 
-    // 获取用户年龄
     public Integer getAge() {
         return age;
     }
 
-    // 设置用户年龄（通常由用户自主填写或系统根据身份证号解析）
     public void setAge(Integer age) {
         this.age = age;
     }
 
-    // 获取用户权限（系统权限控制的核心依据，如管理员可删除订单，普通用户不可）
     public Integer getPower() {
         return power;
     }
 
-    // 设置用户权限（由管理员分配，如新增管理员账号时设置power=1）
     public void setPower(Integer power) {
         this.power = power;
     }
 
-    // 获取用户身份证号
     public String getIdnumber() {
         return idnumber;
     }
 
-    // 设置用户身份证号，自动去除前后空格（确保身份证号格式准确，便于核验）
     public void setIdnumber(String idnumber) {
         this.idnumber = idnumber == null ? null : idnumber.trim();
     }
 
-    // 获取用户账户余额（用于系统内支付相关业务）
     public Double getMoney() {
         return money;
     }
 
-    // 设置用户账户余额（如充值、扣款后更新余额）
     public void setMoney(Double money) {
         this.money = money;
     }
 
-    // 获取用户头像URL（前端通过该路径加载并展示用户头像）
     public String getPhotourl() {
         return photourl;
     }
 
-    // 设置用户头像URL（用户上传头像后，存储服务器路径到该字段）
     public void setPhotourl(String photourl) {
         this.photourl = photourl == null ? null : photourl.trim();
     }
 
-    // 获取用户手机号（用于发送订单通知、验证码等）
     public String getPhonenumber() {
         return phonenumber;
     }
 
-    // 设置用户手机号，自动去除前后空格（确保手机号格式正确，避免无法接收短信）
     public void setPhonenumber(String phonenumber) {
         this.phonenumber = phonenumber == null ? null : phonenumber.trim();
     }

src/main/java/com/jiudian/manage/service/ConfigService.java

@@ -1,7 +1,10 @@
 package com.jiudian.manage.service;
 
 import com.jiudian.manage.model.Config;
-
+//ConfigService是一个业务逻辑接口，定义了系统配置相关的操作方法。它属于服务层
+//定义配置管理的业务接口
+//约束实现类必须提供的功能
+//作为控制器（Controller）和数据访问层（Mapper）之间的桥梁
 public interface ConfigService {
     public Config get();
     public boolean update(double managesalary,double  staffsalary, double cleanerssalary, double manage, double staff, double cleaner, double totalmoney, double totalroom);

src/main/java/com/jiudian/manage/service/OrderService.java

@@ -3,7 +3,8 @@ package com.jiudian.manage.service;
 import com.jiudian.manage.model.Order;
 
 import java.util.List;
-
+//接口包含了订单管理的完整功能：创建、删除、更新状态、查询
+//将复杂的订单处理逻辑封装在 Service 层，控制器只需调用接口即可
 public interface OrderService {
     /**
      * 增加订单

src/main/java/com/jiudian/manage/service/RoomService.java

@@ -3,7 +3,7 @@ package com.jiudian.manage.service;
 import com.jiudian.manage.model.Room;
 
 import java.util.List;
-
+//RoomService接口中的方法会调用RoomMapper接口中的方法：
 public interface RoomService {
     /**
      * 添加一个新房间

src/main/java/com/jiudian/manage/service/UserService.java

@@ -3,7 +3,12 @@ package com.jiudian.manage.service;
 import com.jiudian.manage.model.User;
 
 import java.util.List;
-
+/*这个UserService接口定义了用户管理系统的核心业务功能，主要包括：
+用户信息管理：查询、添加、删除、修改用户基本信息
+权限管理：根据权限查询用户，设置用户权限
+登录认证：验证用户身份，返回用户 ID 和权限
+业绩管理：增加用户业绩 / 薪水
+头像管理：上传和更新用户头像*/
 public interface UserService {
 
     public User selectUser(int userid);
@@ -42,7 +47,7 @@ public interface UserService {
      * @param money     增加的业绩额
      * @return          是否成功
      */
-    public boolean addSlary(int userid,double money);
+    public boolean addSalary(int userid,double money);
 
     /**
      * 获得所有的用户

src/main/java/com/jiudian/manage/service/impl/ConfigServiceImpl.java

@@ -5,76 +5,41 @@ import com.jiudian.manage.model.Config;
 import com.jiudian.manage.service.ConfigService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-
-// 标记为Spring的Service组件，纳入Spring容器管理，作为配置业务的具体实现类
-@Service
-// 实现ConfigService接口，重写接口定义的配置查询与更新方法
+///**
+// * ConfigService接口的实现类
+// * 处理系统配置相关的业务逻辑
+// */
+@Service // 标记为服务层组件，被Spring管理
 public class ConfigServiceImpl implements ConfigService {
-
-    // 自动注入ConfigMapper接口，通过Mapper与数据库交互，完成配置数据的CRUD
     @Autowired
+    // 自动注入ConfigMapper，用于数据库操作
     ConfigMapper configMapper;
 
-    /**
-     * 查询系统全局配置（默认查询主键ID为1的配置记录）
-     * 说明：系统通常只需要一套全局配置，故固定查询ID=1的记录，避免多配置记录混乱
-     * @return 封装了全局配置数据的Config对象（如薪资标准、人员数量、总营收等）
-     */
     @Override
     public Config get() {
-        // 调用Mapper的按主键查询方法，获取ID=1的配置记录
         return configMapper.selectByPrimaryKey(1);
     }
 
-    /**
-     * 更新系统全局配置（支持部分字段更新）
-     * @param managesalary 管理人员薪资标准
-     * @param staffsalary 普通员工薪资标准
-     * @param cleanerssalary 保洁人员薪资标准
-     * @param manage 管理人员数量
-     * @param staff 普通员工数量
-     * @param cleaner 保洁人员数量
-     * @param totalmoney 酒店总营收（-1表示不更新该字段）
-     * @param totalroom 酒店总房间数（-1表示不更新该字段）
-     * @return 布尔值：true=更新成功，false=更新失败
-     */
     @Override
-    public boolean update(
-            double managesalary,
-            double staffsalary,
-            double cleanerssalary,
-            double manage,
-            double staff,
-            double cleaner,
-            double totalmoney,
-            double totalroom
-    ) {
-        // 创建Config对象，封装待更新的配置数据
+    public boolean update(double managesalary, double staffsalary, double cleanerssalary, double manage, double staff, double cleaner, double totalmoney, double totalroom) {
+       //创建配置对象
         Config config = new Config();
-        // 固定更新ID=1的配置记录（系统唯一全局配置）
         config.setId(1);
-
-        // 设置必更新字段：薪资标准和人员数量（这两类配置通常需要同步更新）
+        // 设置薪资相关配置
         config.setManagesalary(managesalary);
         config.setStaffsalary(staffsalary);
         config.setCleanerssalary(cleanerssalary);
         config.setManage(manage);
         config.setStaff(staff);
         config.setCleaner(cleaner);
-
-        // 条件更新字段：总营收（仅当传入值≠-1时更新，避免覆盖无需修改的数据）
-        if(totalmoney != -1){
+        //对于totalmoney和totalroom字段，只有当传入值不是 - 1 时才更新
+        if(totalmoney!=-1){
             config.setTotalmoney(totalmoney);
         }
-        // 条件更新字段：总房间数（仅当传入值≠-1时更新）
-        if(totalroom != -1){
+        if(totalroom!=-1){
             config.setTotalroom(totalroom);
         }
-
-        // 调用Mapper的选择性更新方法（仅更新Config对象中非null的字段）
-        int affectedRows = configMapper.updateByPrimaryKeySelective(config);
-
-        // 根据受影响行数判断更新是否成功（>0表示有记录被修改，即更新成功）
-        return affectedRows > 0 ? true : false;
+        int i = configMapper.updateByPrimaryKeySelective(config);
+        return i>0?true:false; //根据影响行数判断更新是否成功
     }
-}
+}

src/main/java/com/jiudian/manage/service/impl/OrderServiceImpl.java

@@ -14,159 +14,133 @@ import org.springframework.stereotype.Service;
 
 import java.util.List;
 
-// 标记为Spring的Service组件，纳入容器管理，是订单业务逻辑的具体实现类
+// * OrderService接口的实现类
+// * 处理订单相关的业务逻辑
+// */
 @Service
-// 实现OrderService接口，重写接口定义的订单增删改查方法
 public class OrderServiceImpl implements OrderService {
-
-    // 自动注入订单Mapper，用于订单表的数据库操作
     @Autowired
     OrderMapper orderMapper;
-    // 自动注入房间Mapper，用于关联操作房间表（如修改房间状态）
     @Autowired
     RoomMapper roomMapper;
-    // 自动注入配置Mapper，用于关联更新系统全局配置（如总营收、总订单数）
     @Autowired
     ConfigMapper configMapper;
-
+    // 自动注入相关Mapper
+    @Override
     /**
-     * 创建订单（核心业务：校验房间状态→计算订单金额→同步更新配置与房间状态）
+     * 添加新订单
+     * 包含房间状态检查、订单创建、系统配置更新等完整业务流程
+     *
      * @param householdname 入住人姓名
      * @param id 入住人身份证号
-     * @param starttime 入住开始时间（字符串格式，需转换为Date）
-     * @param endtime 入住结束时间（字符串格式，需转换为Date）
-     * @param roomid 关联的房间ID
-     * @param userid 下单用户ID
-     * @return 布尔值：true=创建成功，false=创建失败
+     * @param starttime 入住开始时间
+     * @param endtime 入住结束时间
+     * @param roomid 房间ID
+     * @param userid 操作用户ID
+     * @return 订单创建成功返回true，失败返回false
      */
-    @Override
-    public boolean addOrder(
-            String householdname,
-            String id,
-            String starttime,
-            String endtime,
-            int roomid,
-            int userid
-    ) {
-        // 1. 校验房间状态：查询指定房间，仅当房间状态为1（假设1=空闲）时允许下单
+    public boolean addOrder(String householdname, String id, String starttime, String endtime, int roomid, int userid) {
+        // 1. 检查房间状态是否为可预订（状态1）
         Room room = roomMapper.selectByPrimaryKey(roomid);
-        if (room.getState() != 1) { // 房间非空闲（如已预订、已入住），直接返回失败
+        if(room.getState()!=1){
             return false;
         }
-
-        // 2. 封装订单数据
+        // 2. 创建订单对象
         Order order = new Order();
-        order.setHouseholdname(householdname); // 入住人姓名
-        order.setId(id); // 入住人身份证号
-        // 调用时间工具类，将字符串格式时间转换为Date类型（适配数据库时间字段）
+        order.setHouseholdname(householdname);
+        order.setId(id);
         order.setStarttime(TimeUtil.formatterTime(starttime));
         order.setEndtime(TimeUtil.formatterTime(endtime));
-        order.setRoomid(roomid); // 关联房间ID
-        order.setUserid(userid); // 关联下单用户ID
-        order.setState(0); // 设置订单初始状态（假设0=已预订）
-
-        // 3. 计算订单金额：入住天数 × 房间单价（调用工具类计算两个时间的天数差）
-        double orderMoney = TimeUtil.getBetweenDay(starttime, endtime) * room.getMoney();
-        order.setMoney(orderMoney);
-
-        // 4. 更新系统全局配置：累加总订单数、总营收（操作Config表中id=1的全局配置）
+        order.setRoomid(roomid);
+        order.setUserid(userid);
+        order.setState(0);
+        // 3. 计算订单金额
+        double money = TimeUtil.getBetweenDay(starttime,endtime)*room.getMoney();
+        order.setMoney(money);
+// 4. 更新系统配置（总营业额和总房间数）
         Config config = configMapper.selectByPrimaryKey(1);
-        config.setTotalroom(config.getTotalroom() + 1); // 总订单数+1（字段名totalroom疑似笔误，应为totalOrder）
-        config.setTotalmoney(config.getTotalmoney() + orderMoney); // 总营收累加订单金额
-        configMapper.updateByPrimaryKeySelective(config); // 选择性更新配置（仅修改非null字段）
-
-        // 5. 插入订单数据到数据库
-        int insertCount = orderMapper.insertSelective(order);
-        if (insertCount > 0) { // 订单插入成功，继续更新房间状态
-            Room updateRoom = new Room();
-            updateRoom.setRoomid(roomid); // 指定要更新的房间ID
-            updateRoom.setState(2); // 修改房间状态为2（假设2=已预订，避免重复下单）
-            int roomUpdateCount = roomMapper.updateByPrimaryKeySelective(updateRoom);
-
-            // 房间状态更新成功，返回订单创建成功；否则返回失败
-            return roomUpdateCount > 0 ? true : false;
-        } else { // 订单插入失败，直接返回失败
+        config.setTotalroom(config.getTotalroom()+1);
+        config.setTotalmoney(config.getTotalmoney()+money);
+        configMapper.updateByPrimaryKeySelective(config);
+// 5. 插入订单记录
+        int insert = orderMapper.insertSelective(order);
+        // 6. 如果订单插入成功，更新房间状态为已入住（状态2
+        if(insert>0){
+            Room room1 = new Room();
+            room1.setRoomid(roomid);
+            room1.setState(2);
+            int i = roomMapper.updateByPrimaryKeySelective(room1);
+            if(i>0){
+                return true;
+            }else{
+                return false;
+            }
+        }else {
             return false;
         }
     }
-
     /**
-     * 删除订单（关联操作：删除订单前先恢复房间为空闲状态）
-     * @param orderid 要删除的订单ID
-     * @return 布尔值：true=删除成功，false=删除失败
+     * 删除订单
+     * 同时更新房间状态为可预订
+     *
+     * @param orderid 订单ID
+     * @return 删除成功返回true，失败返回false
      */
     @Override
     public boolean delOrder(int orderid) {
-        // 1. 根据订单ID查询订单详情，获取关联的房间ID
         Order order = orderMapper.selectByPrimaryKey(orderid);
         Integer roomid = order.getRoomid();
-
-        // 2. 先更新房间状态为1（空闲）：避免删除订单后房间仍处于占用状态
-        Room updateRoom = new Room();
-        updateRoom.setRoomid(roomid);
-        updateRoom.setState(1);
-        int roomUpdateCount = roomMapper.updateByPrimaryKeySelective(updateRoom);
-
-        // 3. 房间状态更新成功后，再删除订单
-        if (roomUpdateCount > 0) {
-            int deleteCount = orderMapper.deleteByPrimaryKey(orderid);
-            return deleteCount > 0 ? true : false; // 订单删除成功则返回true
+        Room room = new Room();
+        room.setRoomid(roomid);
+        room.setState(1);
+        int i = roomMapper.updateByPrimaryKeySelective(room);
+        if(i>0){
+            int i1 = orderMapper.deleteByPrimaryKey(orderid);
+            if(i1>0){
+                return true;
+            }
         }
-        // 房间状态更新失败，直接返回删除失败
         return false;
     }
 
-    /**
-     * 更新订单状态（关联同步房间状态，确保订单与房间状态一致性）
-     * @param orderid 要更新的订单ID
-     * @param state 目标订单状态（数字标识，如2=已入住、3=已完成）
-     * @return 布尔值：true=更新成功，false=更新失败
-     */
     @Override
     public boolean updateOrderState(int orderid, int state) {
-        // 1. 校验订单是否存在：根据ID查询订单，不存在则返回失败
         Order order = orderMapper.selectByPrimaryKey(orderid);
-        if (order == null) {
+        if(order==null){
             return false;
         }
-
-        // 2. 获取订单关联的房间ID，准备同步更新房间状态
         Integer roomid = order.getRoomid();
-        Room updateRoom = new Room();
-        updateRoom.setRoomid(roomid);
-        int roomUpdateCount = 1; // 初始化房间更新结果，默认成功（状态无需同步时用）
-
-        // 3. 根据订单目标状态，同步修改房间状态
-        if (state == 2) { // 假设订单状态2=已入住，对应房间状态3=已入住
-            updateRoom.setState(3);
-            roomUpdateCount = roomMapper.updateByPrimaryKeySelective(updateRoom);
+        Room room = new Room();
+        room.setRoomid(roomid);
+        int i = 1;
+        if(state==2){
+            room.setState(3);
+            i = roomMapper.updateByPrimaryKeySelective(room);
         }
-        if (state == 3) { // 假设订单状态3=已完成（退房），对应房间状态1=空闲
-            updateRoom.setState(1);
-            roomUpdateCount = roomMapper.updateByPrimaryKeySelective(updateRoom);
+        if(state==3){
+            room.setState(1);
+            i = roomMapper.updateByPrimaryKeySelective(room);
         }
-
-        // 4. 房间状态更新成功后，再更新订单状态
-        if (roomUpdateCount > 0) {
-            order.setState(state); // 设置订单新状态
-            int orderUpdateCount = orderMapper.updateByPrimaryKeySelective(order);
-            return orderUpdateCount > 0 ? true : false; // 订单状态更新成功则返回true
+        order.setState(state);
+        if(i>0){
+            int i1 = orderMapper.updateByPrimaryKeySelective(order);
+            if(i1>0){
+                return true;
+            }
         }
-        // 房间状态更新失败，返回订单状态更新失败
         return false;
     }
-
     /**
-     * 分页查询所有订单（使用PageHelper实现分页）
-     * @param pageNum 页码（第几页，从1开始）
-     * @param pageSize 每页条数（每页显示多少条订单）
-     * @return 分页后的订单列表（PageHelper自动处理分页逻辑）
+     * 分页查询所有订单
+     * 使用PageHelper实现分页功能
+     *
+     * @param pageNum 页码
+     * @param pageSize 每页记录数
+     * @return 订单列表
      */
     @Override
     public List<Order> getAllOrder(int pageNum, int pageSize) {
-        // 1. 开启分页：PageHelper会自动拦截后续的查询SQL，添加分页条件（limit）
-        PageHelper.startPage(pageNum, pageSize);
-        // 2. 查询所有订单（注意：OrderMapper的getAllUser方法名疑似笔误，应为getAllOrder）
+        PageHelper.startPage(pageNum,pageSize);
         return orderMapper.getAllUser();
     }
-}
+}

src/main/java/com/jiudian/manage/service/impl/RoomServiceImpl.java

@@ -8,144 +8,80 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
-
-// 标记为Spring的Service组件，纳入容器管理，是房间业务逻辑的具体实现类
+//这个RoomServiceImpl类实现了房间管理的完整业务逻辑，包括：
+//房间的添加、删除、修改
+//房间状态的单独更新
+//基于状态和类型的组合查询
+//分页查询支持
+//代码遵循了面向接口编程的原则，通过依赖注入获取 Mapper 对象，实现了业务逻辑与数据访问的解耦，
+//降低系统中不同组件之间的依赖关系，使它们能够独立地开发、测试和维护。
 @Service
-// 实现RoomService接口，重写接口定义的房间增删改查与状态管理方法
 public class RoomServiceImpl implements RoomService {
-
-    // 自动注入房间Mapper，通过Mapper与数据库交互，完成房间数据的CRUD操作
+    // 自动注入RoomMapper，用于数据库操作
     @Autowired
     RoomMapper roomMapper;
 
-    /**
-     * 新增房间（录入酒店新房间信息）
-     * @param local 房间位置（如"3楼302室"）
-     * @param money 房间单价（元/天）
-     * @param state 房间初始状态（如1=空闲、3=维修中）
-     * @param type 房间类型（如1=单人间、2=双人间）
-     * @return 布尔值：true=新增成功，false=新增失败
-     */
     @Override
     public boolean addRoom(String local, double money, int state, int type) {
-        // 1. 封装房间数据到Room对象
         Room room = new Room();
-        room.setLocal(local);   // 设置房间位置
-        room.setMoney(money);   // 设置房间单价
-        room.setState(state);   // 设置初始状态
-        room.setType(type);     // 设置房间类型
-
-        // 2. 调用Mapper的选择性插入方法（仅插入非null字段，适配初始值场景）
-        int insertCount = roomMapper.insertSelective(room);
-
-        // 3. 根据插入受影响行数判断是否成功（>0表示有记录插入）
-        return insertCount > 0 ? true : false;
+        room.setLocal(local);
+        room.setMoney(money);
+        room.setState(state);
+        room.setType(type);
+        int i = roomMapper.insertSelective(room);
+        return i>0?true:false;
     }
 
-    /**
-     * 删除房间（从系统中移除指定房间）
-     * @param roomid 要删除的房间ID
-     * @return 布尔值：true=删除成功，false=删除失败（如房间不存在）
-     */
     @Override
     public boolean delRoom(int roomid) {
-        // 1. 调用Mapper按主键删除房间
-        int deleteCount = roomMapper.deleteByPrimaryKey(roomid);
-
-        // 2. 根据删除受影响行数判断结果
-        return deleteCount > 0 ? true : false;
+        int i = roomMapper.deleteByPrimaryKey(roomid);
+        return i>0?true:false;
     }
 
-    /**
-     * 更新房间信息（支持部分字段更新，非必传字段不修改）
-     * @param roomid 要更新的房间ID（必传，唯一标识房间）
-     * @param local 房间位置（"null"表示不更新）
-     * @param money 房间单价（-1表示不更新）
-     * @param state 房间状态（-1表示不更新）
-     * @param type 房间类型（-1表示不更新）
-     * @return 布尔值：true=更新成功，false=更新失败
-     */
     @Override
     public boolean updateRoom(int roomid, String local, double money, int state, int type) {
-        // 1. 封装待更新数据（仅设置需要修改的字段）
         Room room = new Room();
-        room.setRoomid(roomid);  // 必传：指定更新的房间ID
-
-        // 条件设置字段：仅当参数非默认值时，才更新对应字段
-        if (!local.equals("null")) {
-            room.setLocal(local);  // 更新房间位置
+        room.setRoomid(roomid);
+        if(!local.equals("null")){
+            room.setLocal(local);
         }
-        if (money != -1) {
-            room.setMoney(money);  // 更新房间单价
+        if(money!=-1){
+            room.setMoney(money);
         }
-        if (state != -1) {
-            room.setState(state);  // 更新房间状态
+        if(state!=-1){
+            room.setState(state);
         }
-        if (type != -1) {
-            room.setType(type);    // 更新房间类型
+        if(type!=-1){
+            room.setType(type);
         }
-
-        // 2. 调用Mapper的选择性更新方法（仅更新Room对象中非null的字段）
-        int updateCount = roomMapper.updateByPrimaryKeySelective(room);
-
-        // 3. 根据更新受影响行数判断结果
-        return updateCount > 0 ? true : false;
+        int i = roomMapper.updateByPrimaryKeySelective(room);
+        return i>0?true:false;
     }
 
-    /**
-     * 单独更新房间状态（简化状态修改流程，无需传递其他字段）
-     * @param roomid 要更新状态的房间ID
-     * @param state 目标状态（如1=空闲、2=已预订）
-     * @return 布尔值：true=状态更新成功，false=更新失败
-     */
     @Override
     public boolean updateRoomState(int roomid, int state) {
-        // 1. 封装房间ID和目标状态
         Room room = new Room();
         room.setRoomid(roomid);
         room.setState(state);
-
-        // 2. 调用选择性更新方法，仅修改状态字段
-        int updateCount = roomMapper.updateByPrimaryKeySelective(room);
-
-        // 3. 判断更新结果
-        return updateCount > 0 ? true : false;
+        int i = roomMapper.updateByPrimaryKeySelective(room);
+        return i>0?true:false;
     }
 
-    /**
-     * 按状态和类型分页查询房间（支持多条件筛选+分页）
-     * @param state 房间状态（-1表示不筛选该条件）
-     * @param type 房间类型（-1表示不筛选该条件）
-     * @param pageNum 页码（第几页）
-     * @param pageSize 每页条数
-     * @return 分页后的房间列表（符合筛选条件）
-     */
     @Override
-    public List<Room> getRoomByState(int state, int type, int pageNum, int pageSize) {
-        // 1. 封装筛选条件（仅设置非-1的参数，避免筛选无效条件）
+    public List<Room> getRoomByState(int state, int type,int pageNum,int pageSize) {
         Room room = new Room();
-        if (state != -1) {
-            room.setState(state);  // 按状态筛选（如只查空闲房间）
+        if(state!=-1){
+            room.setState(state);
         }
-        if (type != -1) {
-            room.setType(type);    // 按类型筛选（如只查双人间）
+        if(type!=-1){
+            room.setType(type);
         }
-
-        // 2. 开启分页：PageHelper自动拦截后续查询SQL，添加limit分页条件
-        PageHelper.startPage(pageNum, pageSize);
-
-        // 3. 调用Mapper按条件查询房间，返回分页后的列表
+        PageHelper.startPage(pageNum,pageSize);
         return roomMapper.selectRoomByStateType(room);
     }
 
-    /**
-     * 按ID查询单个房间详情（用于订单创建、房间信息展示）
-     * @param roomid 房间ID
-     * @return 房间详情对象（Room），不存在则返回null
-     */
     @Override
     public Room getRoomById(int roomid) {
-        // 调用Mapper按主键查询房间详情
         return roomMapper.selectByPrimaryKey(roomid);
     }
-}
+}

src/main/java/com/jiudian/manage/service/impl/UserServiceImpl.java

@@ -1,215 +1,147 @@
 package com.jiudian.manage.service.impl;
 
-import com.github.pagehelper.PageHelper;
-import com.jiudian.manage.mapper.UserMapper;
-import com.jiudian.manage.model.User;
-import com.jiudian.manage.service.UserService;
-import com.jiudian.manage.until.UUIDUtil;
+import com.github.pagehelper.PageHelper;//分页工具，实现分页查询
+import com.jiudian.manage.mapper.UserMapper;//用户数据库接口
+import com.jiudian.manage.model.User;//用户实现类
+import com.jiudian.manage.service.UserService;//用户服务接口
+import com.jiudian.manage.until.UUIDUtil;//生成用户唯一标识
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
-
-// 标记为Spring的Service组件，纳入容器管理，是用户业务逻辑的具体实现类
+//UserServiceImpl是一个完整的用户管理服务实现类，它：
+//实现了 UserService 接口：提供了用户管理的所有功能
+//使用 MyBatis 进行数据访问：通过 UserMapper 操作数据库
+//1. 用户基础操作
+//添加用户：创建新用户账号，自动生成工号
+//删除用户：根据 ID 删除用户
+//查询用户：根据 ID 查询用户详情
+//更新用户：支持部分字段更新，灵活更新用户信息
+//2. 用户信息管理
+//修改个人信息：更新用户名、年龄、手机号等
+//更新头像：上传和更新用户头像
+//业绩管理：增加用户业绩 / 薪水记录
+//3. 用户查询与筛选
+//分页查询：支持分页获取所有用户
+//权限筛选：按权限等级查询特定用户群体
+//灵活查询：支持多条件组合查询
+//4. 用户认证与授权
+//登录验证：验证用户名密码，返回用户 ID 和权限
+//权限管理：基于 power 字段实现用户权限控制
 @Service
-// 实现UserService接口，重写接口定义的用户管理、登录、头像更新等核心方法
+//实现UserService接口的所有抽象方法
 public class UserServiceImpl implements UserService {
-
-    // 自动注入用户Mapper，通过Mapper与数据库交互，完成用户数据的CRUD操作
+    //服务层通过userMapper调用 Mapper 接口中定义的 SQL 操作，实现 “服务层 - 数据访问层” 的交互
     @Autowired
     UserMapper userMapper;
 
-    /**
-     * 根据用户ID查询单个用户详情（用于个人信息展示、权限校验）
-     * @param userid 用户ID（主键）
-     * @return 封装用户详情的User对象，不存在则返回null
-     */
     @Override
+    //查询用户
     public User selectUser(int userid) {
-        // 调用Mapper按主键查询用户，直接返回结果
         return userMapper.selectByPrimaryKey(userid);
     }
 
-    /**
-     * 新增用户（用于管理员创建系统账号，如新增员工、管理员账号）
-     * @param account 用户账号（登录用，需唯一）
-     * @param password 用户密码（初始密码，后续可修改）
-     * @param power 用户权限（如0=普通用户、1=管理员）
-     * @return 布尔值：true=新增成功，false=新增失败（如账号已存在）
-     */
-    public boolean addUser(String account, String password, int power) {
-        // 1. 封装用户基础数据
+    public boolean addUser(String account, String password, int power){
+        //1.创建用户，封装用户信息
         User user = new User();
-        user.setUseraccount(account);  // 设置登录账号
-        user.setPassword(password);    // 设置初始密码（注意：实际系统需加密存储）
-        user.setPower(power);          // 设置用户权限
-        // 2. 生成短UUID作为默认身份证号（避免字段为空，后续用户可自行修改）
+        user.setUseraccount(account);
+        user.setPassword(password);
+        user.setPower(power);
         user.setIdnumber(UUIDUtil.generateShortUuid());
-
-        // 3. 调用Mapper选择性插入用户（仅插入非null字段）
-        int insertCount = userMapper.insertSelective(user);
-
-        // 4. 根据插入受影响行数判断是否成功
-        return insertCount > 0 ? true : false;
+        // 2. 调用UserMapper的insertSelective方法：选择性插入用户（仅插入非null字段）
+        int insert = userMapper.insertSelective(user);
+        // 3. 根据插入结果返回布尔值：受影响行数>0表示插入成功（返回true），否则失败（返回false）
+        return insert>0?true:false;
     }
 
-    /**
-     * 删除用户（管理员权限，从系统中移除指定用户）
-     * @param userid 要删除的用户ID
-     * @return 布尔值：true=删除成功，false=删除失败（如用户不存在）
-     */
     @Override
     public boolean delUser(int userid) {
-        // 1. 调用Mapper按主键删除用户
-        int deleteCount = userMapper.deleteByPrimaryKey(userid);
-
-        // 2. 根据删除受影响行数判断结果
-        return deleteCount > 0 ? true : false;
+        int i = userMapper.deleteByPrimaryKey(userid);
+        return i>0?true:false;
     }
 
-    /**
-     * 修改用户信息（支持部分字段更新，非必传字段不修改）
-     * @param userid 要修改的用户ID（必传，唯一标识用户）
-     * @param password 新密码（"null"表示不更新）
-     * @param username 新姓名（"null"表示不更新）
-     * @param age 新年龄（-1表示不更新）
-     * @param power 新权限（-1表示不更新）
-     * @param IDnumber 新身份证号（"null"表示不更新）
-     * @param phonenumber 新手机号（"null"表示不更新）
-     * @return 布尔值：true=修改成功，false=修改失败
-     */
     @Override
-    public boolean alterUser(
-            int userid,
-            String password,
-            String username,
-            int age,
-            int power,
-            String IDnumber,
-            String phonenumber
-    ) {
-        // 1. 封装待更新数据（仅设置非默认值的字段）
+    //重写修改用户方法
+    public boolean alterUser(int userid, String password, String username, int age, int power, String IDnumber,String phonenumber) {
         User user = new User();
-        user.setUserid(userid);  // 必传：指定修改的用户ID
-
-        // 条件设置字段：仅当参数非默认值时，才更新对应字段
-        if (!password.equals("null")) {
-            user.setPassword(password);    // 更新密码
+        user.setUserid(userid);
+        // 选择性设置字段：仅当参数不是默认值时，才设置（避免覆盖原有数据）
+        if(!password.equals("null")){
+            user.setPassword(password);
         }
-        if (!username.equals("null")) {
-            user.setUsername(username);    // 更新姓名
+        if(!username.equals("null")){
+            user.setUsername(username);
         }
-        if (age != -1) {
-            user.setAge(age);              // 更新年龄
+        if(age!=-1){
+            user.setAge(age);
         }
-        if (power != -1) {
-            user.setPower(power);          // 更新权限（需管理员操作）
+        if(power!=-1){
+            user.setPower(power);
         }
-        if (!IDnumber.equals("null")) {
-            user.setIdnumber(IDnumber);    // 更新身份证号
+        if(!IDnumber.equals("null")){
+            user.setIdnumber(IDnumber);
         }
-        if (!phonenumber.equals("null")) {
-            user.setPhonenumber(phonenumber);  // 更新手机号
+        if(!phonenumber.equals("null")){
+            user.setPhonenumber(phonenumber);
         }
-
-        // 2. 调用Mapper选择性更新用户（仅更新User对象中非null的字段）
-        int updateCount = userMapper.updateByPrimaryKeySelective(user);
-
-        // 3. 根据更新受影响行数判断结果
-        return updateCount > 0 ? true : false;
+        //调用UserMapper的updateByPrimaryKeySelective方法：选择性更新（仅更新非null字段
+        int i = userMapper.updateByPrimaryKeySelective(user);
+        return i>0?true:false;
     }
 
-    /**
-     * 给用户账户充值（增加账户余额，用于系统内支付）
-     * @param userid 充值用户ID
-     * @param money 充值金额（单位：元）
-     * @return 布尔值：true=充值成功，false=充值失败
-     */
     @Override
-    public boolean addSlary(int userid, double money) {
-        // 1. 先查询用户当前余额（避免直接覆盖原有余额）
+    //重写addsalary方法
+    public boolean addSalary(int userid, double money) {
+        // . 先查询用户当前的薪水（money字段)
         User user = userMapper.selectByPrimaryKey(userid);
-        Double currentMoney = user.getMoney();
-
-        // 2. 计算新余额：原有余额 + 充值金额
-        user.setMoney(money + currentMoney);
-
-        // 3. 调用Mapper全量更新用户（因需覆盖money字段，此处用全量更新而非选择性更新）
-        int updateCount = userMapper.updateByPrimaryKey(user);
-
-        // 4. 判断充值结果
-        return updateCount > 0 ? true : false;
+        // 获取用户当前薪水
+        Double money1 = user.getMoney();
+        //计算新薪水：原有薪水 + 提成（money）
+        user.setMoney(money+money1);
+        int i = userMapper.updateByPrimaryKey(user);
+        //根据更新结果返回布尔值
+        return i>0?true:false;
     }
 
-    /**
-     * 分页查询所有用户（管理员用于用户列表管理）
-     * @param pageNum 页码（第几页）
-     * @param pageSize 每页条数
-     * @return 分页后的用户列表
-     */
     @Override
-    public List<User> getAllUser(int pageNum, int pageSize) {
-        // 1. 开启分页：PageHelper自动拦截后续查询SQL，添加limit分页条件
-        PageHelper.startPage(pageNum, pageSize);
-
-        // 2. 调用Mapper查询所有用户，返回分页列表
+    //重写查询所有用户方法
+    public List<User> getAllUser(int pageNum,int pageSize) {
+        PageHelper.startPage(pageNum,pageSize);
+        // 1. 调用PageHelper.startPage：开启分页功能，传入页码（pageNum）和每页条数（pageSize）
         return userMapper.getAllUser();
     }
 
-    /**
-     * 按权限分页查询用户（如查询所有管理员、所有普通用户）
-     * @param power 目标权限（如0=普通用户、1=管理员）
-     * @param pageNum 页码
-     * @param pageSize 每页条数
-     * @return 分页后的指定权限用户列表
-     */
     @Override
-    public List<User> getUserByPower(int power, int pageNum, int pageSize) {
-        // 1. 开启分页
-        PageHelper.startPage(pageNum, pageSize);
+    //重写根据页面查询用户
+    public List<User> getUserByPower(int power,int pageNum,int pageSize) {
+        //开启分页功能
+        PageHelper.startPage(pageNum,pageSize);
 
-        // 2. 调用Mapper按权限查询用户，返回分页列表
+        //  调用UserMapper的selectByPower方法：按权限（power）查询用户（自动分页）
         return userMapper.selectByPower(power);
     }
 
-    /**
-     * 用户登录校验（验证账号密码，返回用户ID和权限）
-     * @param username 登录账号（对应useraccount字段）
-     * @param password 登录密码
-     * @return int数组：index0=用户ID，index1=用户权限；验证失败返回null
-     */
     @Override
     public int[] login(String username, String password) {
-        // 1. 根据账号查询用户（账号唯一，仅返回一个用户）
         User user = userMapper.selectByAccount(username);
-
-        // 2. 校验用户是否存在且密码匹配（注意：实际系统需加密对比密码，此处为明文对比）
-        if (user != null && user.getPassword().equals(password)) {
-            // 3. 验证成功，返回用户ID和权限
-            return new int[]{user.getUserid(), user.getPower()};
-        } else {
-            // 4. 验证失败（账号不存在或密码错误），返回null
+        if(user!=null&&user.getPassword().equals(password)){
+            return new int[]{user.getUserid(),user.getPower()};
+        }else{
             return null;
         }
     }
 
-    /**
-     * 更新用户头像路径（用户上传头像后，同步更新数据库中的头像URL）
-     * @param userid 头像所属用户ID
-     * @param url 头像在服务器的存储路径（相对路径，如"File/xxx.jpg"）
-     * @return 布尔值：true=更新成功，false=更新失败
-     */
     @Override
     public boolean photo(int userid, String url) {
-        // 1. 封装用户ID和头像路径
+        //创建User实体类对象，用于封装更新数据
         User user = new User();
         user.setUserid(userid);
         user.setPhotourl(url);
+        int i = userMapper.updateByPrimaryKeySelective(user);
+        //执行后返回一个 int 类型的结果 i，表示 “受影响的行数”
+        // （即数据库中实际被更新的记录数，成功时通常为 1，失败时为 0）
+        return i > 0 ? true : false;
+    }
 
-        // 2. 调用Mapper选择性更新，仅修改头像路径字段
-        int updateCount = userMapper.updateByPrimaryKeySelective(user);
 
-        // 3. 判断更新结果
-        return updateCount > 0 ? true : false;
-    }
-}
+}

src/main/java/com/jiudian/manage/until/FileUtil.java

@@ -1,44 +1,25 @@
-package com.jiudian.manage.until;  // 工具类包，存放系统通用工具方法
+package com.jiudian.manage.until;
 
 import java.io.File;
 import java.io.FileOutputStream;
-
 /**
- * 文件操作工具类
- * 提供文件上传的通用方法，支撑系统中文件（如用户头像、凭证图片）的服务器存储功能
+ * 上传文件
+ *
+ * @return 上传成功返回true，失败返回false
+ * @throws Exception 如果发生IO异常会抛出
  */
 public class FileUtil {
-
-    /**
-     * 上传文件到服务器指定路径
-     * @param file 待上传的文件字节数组（前端传递的文件会转为字节数组形式传输）
-     * @param filePath 服务器上的文件存储目录路径（如"D:/hotel_upload/avatar/"）
-     * @param fileName 上传后的文件名（建议包含唯一标识，避免文件名重复覆盖）
-     * @return 布尔值：true=上传成功，false=上传失败（实际逻辑中当前仅返回true，异常通过throws抛出）
-     * @throws Exception 抛出文件操作相关异常（如IO异常、权限异常），需调用方捕获处理
-     */
     public static boolean uploadFile(byte[] file, String filePath, String fileName) throws Exception {
-        // 1. 根据存储目录路径创建File对象
+        // 创建目标文件夹
         File targetFile = new File(filePath);
-
-        // 2. 判断存储目录是否存在，不存在则创建多级目录（mkdirs()支持创建嵌套目录，mkdir()不支持）
-        if (!targetFile.exists()) {
+        if(!targetFile.exists()){
             targetFile.mkdirs();
         }
-
-        // 3. 创建文件输出流，指定文件存储路径（目录路径 + 文件名）
-        FileOutputStream out = new FileOutputStream(filePath + fileName);
-
-        // 4. 将文件字节数组写入到输出流（即写入到服务器文件）
+        //写入文件，将文件二进制流（byte[] file）写入指定路径（filePath+fileName）
+        FileOutputStream out = new FileOutputStream(filePath+fileName);
         out.write(file);
-
-        // 5. 刷新输出流，确保所有字节都被写入文件
         out.flush();
-
-        // 6. 关闭输出流，释放IO资源（避免资源泄漏）
         out.close();
-
-        // 7. 文件写入完成，返回上传成功
         return true;
     }
-}
+}

src/main/java/com/jiudian/manage/until/ImageCode.java

@@ -1,85 +1,54 @@
 package com.jiudian.manage.until;
-
+//图像处理：BufferedImage（图像缓冲区，用于绘制验证码图片）、Graphics（绘图工具，用于画背景、文字、干扰元素）、
+// ImageIO（将图像写入输出流，返回给前端）；
+//Servlet 相关：HttpServletResponse（向前端输出图片流）、HttpSession（存储正确验证码，供后续验证使用）；
+//基础工具：Random（生成随机数，用于随机颜色、位置）、OutputStream（字节输出流，承载图片数据）、IOException（处理图像写入的 IO 异常）。
 import javax.imageio.ImageIO;
 import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpSession;
+import javax.servlet.http.HttpSession;//服务器端的会话存储
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.Random;
 
-/**
- * 验证码生成工具类
- * 用于生成图形验证码，支撑用户登录时的安全校验，防止恶意登录或自动化脚本攻击
- */
 public class ImageCode {
-    // 验证码在HttpSession中的存储键名（固定值，登录时需通过该键名获取Session中的验证码）
-    public static final String CODENAME = "ImageCode";
-
-    /**
-     * 生成图形验证码并响应给前端，同时将验证码存入Session
-     * @param response HttpServletResponse，用于向前端输出验证码图片
-     * @param session HttpSession，用于存储生成的验证码（供登录时校验）
-     * @throws IOException 图片写入响应流时可能抛出IO异常，需调用方处理
-     */
+    public static final String CODENAME="ImageCode";
+    //* 生成验证码图片并发送到客户端
+    //HttpServletResponse response：Servlet 响应对象，用于将生成的图片流写入前端（前端通过 <img> 标签加载）；
+    //HttpSession session：会话对象，用于存储正确的验证码（后续登录时，前端传入的验证码需与 Session 中的值对比
     public static void createImage(HttpServletResponse response, HttpSession session) throws IOException {
-        // 1. 创建 BufferedImage 对象（验证码图片载体）：宽80px、高30px，RGB色彩模式
+        // 创建图像缓冲区
         BufferedImage image = new BufferedImage(80, 30, BufferedImage.TYPE_INT_RGB);
-
-        // 2. 获取 Graphics 对象（用于在图片上绘制内容：背景、验证码文字、干扰元素等）
         Graphics g = image.getGraphics();
-
-        // 3. 创建随机数对象（用于生成随机颜色、干扰元素位置等，增强验证码安全性）
         Random r = new Random();
-
-        // 4. 绘制验证码背景：随机颜色填充矩形（覆盖整个图片区域，宽80px、高20px）
+        // 设置背景色
         g.setColor(new Color(r.nextInt(255), r.nextInt(255), r.nextInt(255)));
         g.fillRect(0, 0, 80, 20);
-
-        // 5. 生成4位随机验证码（数字+大写字母组合）
+        //获取生成的验证码
         String code = getNumber();
-
-        // 6. 将生成的验证码存入Session：键为CODENAME，值为验证码，供后续登录校验使用
+        //绑定验证码
+        // 将验证码存储到Session中
         session.setAttribute(CODENAME, code);
-
-        // 7. 设置验证码文字样式：无衬线字体、加粗、字号25px
         g.setFont(new Font(Font.SANS_SERIF, Font.BOLD, 25));
-
-        // 8. 设置验证码文字颜色：随机RGB颜色（与背景色区分，确保清晰可见）
         g.setColor(new Color(r.nextInt(255), r.nextInt(255), r.nextInt(255)));
-
-        // 9. 绘制验证码文字到图片：起始位置（x=5px，y=25px），避免文字超出图片边界
         g.drawString(code, 5, 25);
-
-        // 10. 设置响应头：指定返回内容类型为image/jpeg（告诉前端这是图片数据）
+        //设置消息头
         response.setContentType("image/jpeg");
-
-        // 11. 获取响应输出流，将验证码图片以jpeg格式写入流，响应给前端
         OutputStream os = response.getOutputStream();
         ImageIO.write(image, "jpeg", os);
     }
-
     /**
-     * 生成4位随机验证码（包含数字0-9和大写字母A-Z，增强验证码复杂度）
-     * @return 4位随机字符串（验证码内容）
+     * 生成随机验证码
+     * @return 4位随机验证码
      */
-    public static String getNumber() {
-        // 1. 定义验证码字符池：包含数字和大写字母，共36个字符
+    public static String getNumber(){
         String str = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-
-        // 2. 初始化验证码字符串（用于拼接最终结果）
         String code = "";
-
-        // 3. 循环4次，每次从字符池中随机选取1个字符，组成4位验证码
-        for (int i = 0; i < 4; i++) {
-            // 生成0到str长度-1的随机索引（确保不越界）
-            int index = (int) (Math.random() * str.length());
-            // 根据索引获取字符，拼接到验证码中
-            code += str.charAt(index);
+        for(int i= 0;i<4;i++){
+            int index = (int)(Math.random()*str.length());
+            code+=str.charAt(index);
         }
-
-        // 4. 返回生成的4位验证码
         return code;
     }
 }

src/main/java/com/jiudian/manage/until/State.java

@@ -1,41 +1,45 @@
 package com.jiudian.manage.until;
-
 /**
- * 系统统一状态枚举类
- * 定义接口响应的标准状态码和提示信息，确保所有接口返回格式一致，简化前后端交互逻辑
+ * 状态枚举类
+ * 定义接口返回的标准状态码和提示信息
+ * 用于统一API接口的返回格式
  */
-public enum State {
-    // 成功状态：code=0，message=成功（用于所有业务操作成功的响应，如订单创建成功、用户登录成功）
-    SuccessCode("code", "0"),
-    SuccessMessage("message", "成功"),
-
-    // 失败状态：code=-1，message=失败（用于所有业务操作失败的通用响应，如参数错误、数据库操作失败）
-    ErrorCode("code", "-1"),
-    ErrorMessage("message", "失败");
+public enum  State {
+    /**
+     * 成功状态码
+     * 键名："code"，值："0"
+     */
+    /**
+     * 成功提示信息
+     * 键名："message"，值："成功"
+     */
+    SuccessCode("code","0"),SuccessMessage("message","成功"),
+    ErrorCode("code","-1"),ErrorMessage("message","失败")
+    ;
 
 
-    // 状态对应的键名（如"code"表示状态码的键，"message"表示提示信息的键）
     public String name;
-    // 状态对应的键值（如"0"是成功状态码的值，"成功"是成功提示的值）
     public String message;
-
     /**
-     * 枚举构造方法（枚举的构造方法默认私有，仅在枚举内部创建实例时使用）
-     * @param name 状态键名（如"code"、"message"）
-     * @param message 状态键值（如"0"、"成功"）
+     * 构造方法
+     * @param name 状态键名
+     * @param message 状态值
      */
-    State(String name, String message) {
+    State(String name,String message) {
         this.name = name;
         this.message = message;
     }
-
-    // 获取状态键名的getter方法（供外部访问枚举的name属性）
     public String getName() {
         return name;
     }
 
-    // 获取状态键值的getter方法（供外部访问枚举的message属性）
     public String getMessage() {
         return message;
     }
-}
+
+}
+//状态码标记：使用code="0"表示成功
+//消息提示：使用 "成功" 作为提示信息
+//返回值：Service 方法返回 true 表示业务操作成功
+//数据库影响：数据操作影响行数大于 0
+//前端展示：用户界面显示成功反馈

src/main/java/com/jiudian/manage/until/StateSignal.java

@@ -1,16 +1,34 @@
 package com.jiudian.manage.until;
-
+//HashMap 是 Java 中的哈希表集合，用于存储键值对（key-value），
+// 此处作为响应数据的载体，能灵活存储状态码、消息、业务数据等不同类型的信息。
 import java.util.HashMap;
-
+//StateSignal类是一个响应结果构建器，它：
+//统一了 API 响应格式：所有接口返回包含状态码和消息的标准格式
 public class StateSignal {
+    // 存储响应数据的HashMap
+    //定义 result 为 HashMap 类型，键（key）是字符串类型（如 “code”“message”“user”），
+    // 值（value）是 Object 类型（支持存储数字、字符串、实体类对象等任意类型数据）
     HashMap<String,Object> result = new HashMap<String,Object>();
-
+    /**
+     * 添加状态枚举中的键值对
+     * @param state 状态枚举对象
+     */
     public void put(State state){
         result.put(state.name,state.message);
     }
+    /**
+     * 添加自定义键值对
+     * @param name 键名
+     * @param val 值
+     */
+    //object val：自定义值（可是任意类型，如 List<User> 列表、int 类型的用户 ID、double 类型的价格）；
     public void put(String name,Object val){
         result.put(name,val);
     }
+    /**
+     * 获取构建好的响应结果
+     * @return 包含响应数据的HashMap
+     */
     public HashMap<String, Object> getResult() {
         return result;
     }

src/main/java/com/jiudian/manage/until/TimeUtil.java

@@ -6,71 +6,43 @@ import java.util.Calendar;
 import java.util.Date;
 import java.util.GregorianCalendar;
 
-/**
- * 时间工具类
- * 提供日期格式转换、跨年份日期差计算功能，核心支撑酒店订单模块的入住天数统计与金额计算
- */
 public class TimeUtil {
     /**
-     * 计算两个日期之间的天数差（结果为 date2 - date1 的差值，支持跨年份计算）
-     * 示例：date1="2025-02-28"、date2="2025-03-02" → 返回2；date1="2024-12-30"、date2="2025-01-02" → 返回3
-     *
-     * @param date1 起始日期字符串（格式必须为 yyyy-MM-dd，如"2025-05-01"）
-     * @param date2 结束日期字符串（格式必须为 yyyy-MM-dd，如"2025-05-05"）
-     * @return 两个日期的天数差（若date2在date1之前，可能返回负数，需在业务层判断合理性）
+     * 计算两个日期之间的天数差（date2 - date1）
+     * @param date1 开始日期字符串（格式：yyyy-MM-dd）
+     * @param date2 结束日期字符串（格式：yyyy-MM-dd）
+     * @return 两个日期之间的天数差
      */
-    public static int getBetweenDay(String date1, String date2) {
-        // 创建GregorianCalendar实例（日历工具类），用于处理日期的年、日字段计算
+    public static int getBetweenDay(String  date1, String date2) {
+        // 将字符串日期转换为Calendar对象
         Calendar d1 = new GregorianCalendar();
-        // 将起始日期字符串转为Date类型，设置到日历对象d1中
         d1.setTime(formatterTime(date1));
-
-        // 创建结束日期对应的日历对象d2，同理设置日期
         Calendar d2 = new GregorianCalendar();
         d2.setTime(formatterTime(date2));
-
-        // 第一步：计算同一年份内的天数差（DAY_OF_YEAR 表示当前日期是当年的第几天）
         int days = d2.get(Calendar.DAY_OF_YEAR) - d1.get(Calendar.DAY_OF_YEAR);
-
-        // 获取结束日期的年份，判断是否跨年份（起始年份 != 结束年份）
-        int endYear = d2.get(Calendar.YEAR);
-        if (d1.get(Calendar.YEAR) != endYear) {
-            // 跨年份时，循环累加起始年份到结束年份之间每一年的总天数
+        int y2 = d2.get(Calendar.YEAR);
+        if (d1.get(Calendar.YEAR) != y2) {
             do {
-                // 累加当前起始年份的总天数（getActualMaximum(DAY_OF_YEAR) 可自动处理闰年，如2024年返回366）
                 days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);
-                // 起始年份加1，继续计算下一年，直到起始年份等于结束年份
                 d1.add(Calendar.YEAR, 1);
-            } while (d1.get(Calendar.YEAR) != endYear);
+            } while (d1.get(Calendar.YEAR) != y2);
         }
-
-        // 返回最终计算的天数差
         return days;
     }
-
     /**
-     * 将字符串格式的日期转为Date类型（固定格式：yyyy-MM-dd）
-     * 解决前端传递的日期字符串与后端Date类型不兼容问题，统一日期格式标准
-     *
-     * @param date 日期字符串（格式必须为 yyyy-MM-dd，如"2025-05-01"；格式错误会打印异常栈并返回null）
-     * @return 转换后的Date对象（转换失败时返回null）
+     * 将字符串日期格式化为Date对象
+     * @param date 日期字符串（格式：yyyy-MM-dd）
+     * @return Date对象，如果格式错误返回null
      */
-    public static Date formatterTime(String date) {
-        // 创建SimpleDateFormat实例，指定目标日期格式为 yyyy-MM-dd
+    public static Date formatterTime(String date){
         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
-        // 初始化Date对象，用于接收转换结果
-        Date newDate = null;
-
+        Date newDate=null;
         try {
-            // 尝试将字符串日期解析为Date类型
-            newDate = formatter.parse(date);
+            newDate= formatter.parse(date);
         } catch (ParseException e) {
-            // 解析失败（如日期格式错误，如"2025/05/01"）时，打印异常栈，便于排查问题
             e.printStackTrace();
         }
-
-        // 返回转换后的Date对象（失败时为null）
         return newDate;
     }
 
-}
+}

src/main/java/com/jiudian/manage/until/UUIDUtil.java

@@ -4,15 +4,9 @@ import java.util.UUID;
 
 /**
  * UUID工具类
- * 提供短UUID生成功能，解决原生UUID（36位）过长、不便于存储/展示的问题，
- * 生成的8位短UUID兼顾唯一性与简洁性，适用于临时标识、默认字段值等场景
+ * 提供生成短版UUID的功能，生成工号
  */
 public class UUIDUtil {
-    /**
-     * 短UUID字符池
-     * 包含26个小写字母、10个数字、26个大写字母，共62个字符，
-     * 用于将16进制的UUID片段映射为短字符，保证生成结果的多样性与唯一性
-     */
     public static String[] chars = new String[] { "a", "b", "c", "d", "e", "f",
             "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
             "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5",
@@ -21,34 +15,21 @@ public class UUIDUtil {
             "W", "X", "Y", "Z" };
 
     /**
-     * 生成8位长度的短UUID
-     * 基于JDK原生UUID（32位无分隔符形式）压缩转换，确保全局唯一性，
-     * 相比原生UUID更简洁，适合存储（如用户默认身份证号）或界面展示
-     *
-     * @return 8位随机唯一字符串（示例：xY3a7B9z）
+     * 生成8位UUID
+     * @return 8位UUID
      */
     public static String generateShortUuid() {
-        // 初始化StringBuffer，用于拼接最终的8位短UUID
         StringBuffer shortBuffer = new StringBuffer();
-
-        // 1. 生成原生UUID（格式：xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx）
-        // 2. 调用replace("-", "")去除分隔符，得到32位纯字母数字字符串
         String uuid = UUID.randomUUID().toString().replace("-", "");
-
-        // 循环8次，每次处理4位原生UUID片段，生成1位短字符，最终组成8位短UUID
+        // 将32位UUID转换为8位
         for (int i = 0; i < 8; i++) {
-            // 截取4位字符串（如第1次取0-4位、第2次取4-8位，直至取完32位）
+            // 每4个字符为一组
             String str = uuid.substring(i * 4, i * 4 + 4);
-
-            // 将4位16进制字符串转为10进制整数（如"a1b2"转为十进制整数41394）
+            // 转换为16进制整数
             int x = Integer.parseInt(str, 16);
-
-            // 对62取余（0x3E为十六进制，对应十进制62，与chars数组长度一致），
-            // 通过余数获取chars数组的索引，取出对应字符拼接到shortBuffer
+            // 取模62（字符集大小）得到索引
             shortBuffer.append(chars[x % 0x3E]);
         }
-
-        // 返回最终生成的8位短UUID
         return shortBuffer.toString();
     }
-}
+}

src/main/resources/generator/generatorConfig.xml

@@ -2,8 +2,16 @@
 <!DOCTYPE generatorConfiguration
         PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
         "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
+<!--
+MyBatis Generator配置文件
+功能：自动生成数据库访问层代码，包括实体类、Mapper接口和XML映射文件
+适用：酒店客房管理系统
+-->
 <generatorConfiguration>
-    <!-- 数据库驱动:选择你的本地硬盘上面的数据库驱动包-->
+    <!-- 数据库驱动:选择你的本地硬盘上面的数据库驱动包-
+    作用：指定MySQL数据库驱动的位置，用于连接数据库
+    location：本地Maven仓库中MySQL数据库驱动JAR包的路径->
+
     <classPathEntry  location="C:\Users\14831\.m2\repository\mysql\mysql-connector-java\8.0.11\mysql-connector-java-8.0.11.jar"/>
     <context id="DB2Tables"  targetRuntime="MyBatis3">
         <commentGenerator>

src/main/resources/mappers/ConfigMapper.xml

@@ -1,5 +1,10 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
+<!--
+ConfigMapper.xml - 酒店客房管理系统配置表MyBatis映射文件
+功能：定义配置表的数据库操作SQL语句和结果映射规则
+对应表：config（系统配置表）
+-->
 <mapper namespace="com.jiudian.manage.mapper.ConfigMapper" >
   <resultMap id="BaseResultMap" type="com.jiudian.manage.model.Config" >
     <id column="id" property="id" jdbcType="INTEGER" />

src/main/resources/mappers/OrderMapper.xml

@@ -1,4 +1,10 @@
 <?xml version="1.0" encoding="UTF-8" ?>
+<!--这个 OrderMapper.xml 文件主要用于实现酒店客房管理系统的订单模块功能：
+客房预订：通过insert或insertSelective方法创建新订单
+订单查询：通过getAllUser或selectByPrimaryKey方法查询订单信息
+订单修改：通过updateByPrimaryKey或updateByPrimaryKeySelective方法更新订单状态
+订单取消：通过deleteByPrimaryKey方法删除订单或更新订单状态
+数据库表与 Java 实体类之间的映射关系-->
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 <mapper namespace="com.jiudian.manage.mapper.OrderMapper" >
   <resultMap id="BaseResultMap" type="com.jiudian.manage.model.Order" >
@@ -33,7 +39,7 @@
     where orderid = #{orderid,jdbcType=INTEGER}
   </delete>
   <insert id="insert" parameterType="com.jiudian.manage.model.Order" >
-    insert into orderlist (orderid, householdname, ID,
+    insert into orderlist (orderid, householdname, ID, 
       starttime, endtime, money, 
       state, roomid, userid
       )

src/main/resources/mappers/RoomMapper.xml

@@ -1,4 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--RoomMapper.xml 是酒店客房管理系统中客房模块的核心 MyBatis 映射文件，它：
+定义了客房表与 Java 实体类之间的映射关系-->
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.jiudian.manage.mapper.RoomMapper">
   <resultMap id="BaseResultMap" type="com.jiudian.manage.model.Room">

src/main/resources/mappers/UserMapper.xml

@@ -1,4 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--RoomMapper.xml 是酒店用户管理系统中客房模块的核心 MyBatis 映射文件，它：
+定义了客房表与 Java 实体类之间的映射关系-->
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.jiudian.manage.mapper.UserMapper">
   <resultMap id="BaseResultMap" type="com.jiudian.manage.model.User">

src/main/resources/static/css/footer.css

@@ -1,26 +1,26 @@
 
 .bs-docs-footer {
-    padding-top: 25px;
-    padding-bottom: 50px;
-    height: 12rem;
-    color: #99979c;
-    text-align: center;
-    background-color: rgba(0,0,0,.8);
+    padding-top: 25px;/* 顶部内边距：25px，控制内容与页脚顶部的距离 */
+    padding-bottom: 50px;/* 底部内边距：50px，控制内容与页脚底部的距离 */
+    height: 12rem;/* 固定高度：12rem（rem 是相对根元素字体大小的单位） */
+    color: #99979c;/* 文本颜色：浅灰色，用于页脚的普通文字 */
+    text-align: center; /* 文本居中对齐：页脚内所有内容水平居中 */
+    background-color: rgba(0,0,0,.8); /* 背景色：黑色半透明（透明度 80%） */
 }
 
 .bs-docs-footer-links {
-    padding-left: 0;
-    margin-bottom: 20px;
+    padding-left: 0; /* 左内边距：0，清除列表默认的左侧缩进 */
+    margin-bottom: 20px; /* 底部外边距：20px，控制链接列表与下方元素的距离 */
 }
 
 .bs-docs-footer-links li {
-    display: inline-block;
+    display: inline-block; /* 列表项改为行内块元素：让链接横向排列（默认列表项是块级元素，纵向排列） */
 }
 
 .bs-docs-footer a {
-    color: #fff;
+    color: #fff;/* 链接文字颜色：白色，与页脚普通文字（浅灰）区分开 */
 }
 
 .bs-docs-footer p {
-    margin-bottom: 0;
+    margin-bottom: 0;/* 段落底部外边距：0，清除段落默认的底部间距 */
 }

src/main/resources/static/css/index.css

@@ -1,95 +1,95 @@
 .navbar-default{
-	transition: all 0.6s;
-	background-color: rgba(0,0,0,.7);
-	border: 0;
-	border-radius: 0;
+    transition: all 0.6s;/* 所有所有样式变化添加过渡动画，持续 0.6s（如背景色、尺寸变化时平滑过渡） */
+    background-color: rgba(0,0,0,.7); /* 背景色：黑色半透明（透明度 70%） */
+    border: 0;/* 取消边框 */
+    border-radius: 0; /* 取消圆角（默认导航栏可能有圆角） */
 }
 
 
-.header{                                       
-	text-align: center;
-	letter-spacing: 1rem;
+.header{
+    text-align: center;/* 文本居中对齐 */
+    letter-spacing: 1rem; /* 字符间距为 1rem（增强标题视觉效果） */
 }
 
 .navbar{
-	min-height: 5.4rem !important;
+    min-height: 5.4rem !important; /* 导航栏最小高度为 5.4rem（!important 强制覆盖默认样式） */
 }
 
 
-@media screen and (min-width:1000px){
+@media screen and (min-width:1000px){/* 当屏幕宽度 ≥1000px 时生效 */
 
-.nav-con{
-	padding: 0 12rem;
-}
+    .nav-con{/* 导航内容容器 */
+        padding: 0 12rem;/* 左右内边距为 12rem，让导航内容在大屏上居中且两侧留白 */
+    }
 
 }
 
 
 
 label{
-	display: none;
+    display: none;/* 隐藏所有 label 标签（可能通过其他方式展示表单说明，如占位符） */
 }
 
 .logindiv{
-	border: 1px solid white;
-	padding: 0rem 3.5rem;
-	height: 32rem;
-	background: rgba(255,255,255,.9);
-	position: relative;
-	margin-top: 5rem;
+    border: 1px solid white;/* 白色边框 */
+    padding: 0rem 3.5rem;/* 左右内边距 3.5rem，上下内边距 0 */
+    height: 32rem;/* 固定高度 32rem */
+    background: rgba(255,255,255,.9);/* 背景色：白色半透明（透明度 90%） */
+    position: relative; /* 相对定位，方便内部元素绝对定位 */
+    margin-top: 5rem;/* 顶部外边距 5rem，与上方元素拉开距离 */
 }
 
 .login-h{
-	border-bottom: 2px solid #337AB7;
-	text-align: center;
-	letter-spacing: 2.5px;
+    border-bottom: 2px solid #337AB7;/* 底部边框：2px 实线，蓝色（#337AB7 是 Bootstrap 主题蓝） */
+    text-align: center;/* 文本居中 */
+    letter-spacing: 2.5px;/* 字符间距 2.5px，增强标题感 */
 }
 
 .login-f{
-	padding-top: 2rem !important;
+    padding-top: 2rem !important;/* 顶部内边距 2rem（!important 强制覆盖默认样式） */
 }
 
 .forminput{
-	height: 4rem;
+    height: 4rem;/* 输入框高度 4rem，统一表单元素尺寸 */
 }
 
 .main{
-	background: url('../img/pexels-photo-545049.jpg') no-repeat;
-	background-repeat:no-repeat;
-    background-size: cover;
-	min-height: 40rem;
+    background: url('../img/pexels-photo-545049.jpg') no-repeat;/* 背景图：引用指定图片，不重复 */
+    background-repeat:no-repeat;/* 重复设置不重复（冗余保险） */
+    background-size: cover;/* 背景图自适应：覆盖整个容器，可能裁剪但保持比例 */
+    min-height: 40rem;/* 最小高度 40rem，确保内容区有足够高度 */
 }
-
+/*文本输入框样式*/
 input[type="text"],
 input[type="password"]{
-	text-indent:2.3rem;
-	font-weight:normal;
-	color:black;
-	background:url('../img/login-sprite.png') no-repeat white;
-	background-position:3% 10%;
+    text-indent:2.3rem;/* 文本缩进 2.3rem，避免输入内容与左侧图标重叠 */
+    font-weight:normal;/* 字体常规粗细 */
+    color:black;/* 输入文本颜色为黑色 */
+    background:url('../img/login-sprite.png') no-repeat white;/* 背景：白色 + 引用精灵图（含多个图标） */
+    background-position:3% 10%;/* 精灵图位置：水平 3%，垂直 10%（显示用户名图标） */
 }
-
+/*密码框图标定位*/
 input[type="password"]{
-	background-position:3% 90%;
+    background-position:3% 90%;  /* 密码框精灵图位置：水平 3%，垂直 90%（显示密码图标） */
 }
-
+/*验证码输入框样式*/
 .inputcode{
-	background-position:3% 90% !important;
+    background-position:3% 90% !important;/* 强制验证码输入框使用精灵图 90% 位置的图标（可能复用密码图标） */
 }
-
+/*验证码区域样式*/
 .code{
-	height: 4rem;
-	width: 100%;
-	border:1px solid #3D86ED;
-	border-radius: 5px;
+    height: 4rem;/* 高度 4rem，与输入框保持一致 */
+    width: 100%;/* 宽度 100%，适应父容器 */
+    border:1px solid #3D86ED;/* 边框：1px 实线，浅蓝色 */
+    border-radius: 5px;/* 圆角 5px，柔和边框 */
 }
-
+/*登录按钮样式*/
 .loginbtn{
-	background: #419FD8;
-	color: white;
+    background: #419FD8;/* 按钮背景色：浅蓝色 */
+    color: white;/* 按钮文字颜色：白色 */
 }
 
 .loginbtn:hover{
-	background: #5D89FA;
-	color: white;
+    background: #5D89FA;/* 鼠标悬停时背景色：更深的蓝色 */
+    color: white;/* 悬停时文字保持白色 */
 }

src/main/resources/static/css/myCenter.css

@@ -1,117 +1,118 @@
+/*这段 CSS 代码主要用于设置网站导航栏、侧边栏和主内容区的样式，整体风格统一且带有交互效果。*/
 .navbar-default{
-	transition: all 0.6s;
-	background-color: #219ED8;
-	border: 0;
-	border-radius: 0;
+    transition: all 0.6s; /* 所有样式变化添加0.6秒过渡动画（如hover效果、展开收起） */
+    background-color: #219ED8;/* 导航栏背景色：亮蓝色 */
+    border: 0;/* 取消默认边框 */
+    border-radius: 0;/* 取消默认圆角，改为直角 */
 }
 
 
-.header{                                       
-	text-align: center;
-	letter-spacing: 1rem;
+.header{
+    text-align: center;/* 文本居中对齐 */
+    letter-spacing: 1rem;/* 字符间距1rem，增强标题的视觉松散感 */
 }
 
 .navbar{
-	min-height: 5.4rem !important;
+    min-height: 5.4rem !important;/* 导航栏最小高度5.4rem（!important强制覆盖默认值） */
 }
 
+/*大屏幕响应式布局*/
+@media screen and (min-width:1000px){ /* 屏幕宽度≥1000px时生效 */
 
-@media screen and (min-width:1000px){
-
-.nav-con{
-	padding: 0 12rem;
-}
+    .nav-con{/* 导航内容容器 */
+        padding: 0 12rem;/* 左右内边距12rem，让导航内容在大屏上两侧留白，居中展示 */
+    }
 
 }
 
 label{
-	display: none;
+    display: none;/* 隐藏所有<label>标签（可能通过占位符或其他方式提示表单内容） */
 }
 
-
+/*导航链接样式*/
 .navbar-default .navbar-nav>li>a {
-    color: white;
+    color: white;/* 导航链接文字颜色：白色 */
 }
 
 li.navli{
-	margin-right: 40px;
+    margin-right: 40px;/* 导航项右侧间距40px，避免链接挤在一起 */
 }
-
+/* 汉堡按钮（移动端菜单按钮） hover/focus状态 */
 .navbar-default .navbar-toggle:hover,.navbar-default .navbar-toggle:focus{
-	background: transparent;
+    background: transparent;/* 悬停/聚焦时背景透明（不改变背景色） */
 }
-
+/* 汉堡按钮边框 */
 .navbar-default .navbar-toggle {
-    border-color: white;
+    border-color: white;/* 按钮边框颜色：白色 */
 }
-
+/* 汉堡按钮内部线条 */
 .navbar-default .navbar-toggle .icon-bar {
-    background-color: white;
+    background-color: white;/* 按钮线条颜色：白色 */
 }
 
 .navbar-default .navbar-nav>.open>a, .navbar-default .navbar-nav>.open>a:focus, .navbar-default .navbar-nav>.open>a:hover{
-	background: transparent;
-	color: white;
-	transition: all 0.6s;
-	transform: scale(1.0,1.2);
+    background: transparent;/* 下拉菜单展开时，父项背景透明 */
+    color: white;/* 文字保持白色 */
+    transition: all 0.6s;/* 样式变化过渡动画0.6秒 */
+    transform: scale(1.0,1.2);/* Y轴拉伸1.2倍（纵向轻微放大，增强激活感） */
 }
 
-
+/*导航链接内边距*/
 .navbar-nav>li>a{
-	padding-top: 1.7rem;
+    padding-top: 1.7rem;/* 导航链接顶部内边距1.7rem，控制文字在导航栏中的纵向位置 */
 }
 
 
 .navbar-default .navbar-nav>li>a:hover{
-	color: white;
-	transition: all 0.6s;
+    color: white;/* 悬停时文字保持白色（默认是灰色） */
+    transition: all 0.6s;/* 过渡动画0.6秒（可配合其他hover样式平滑变化） */
 }
 
 .main{
-	margin-top: -20px;
+    margin-top: -20px;/* 顶部负外边距-20px，消除与导航栏之间的默认间距 */
 }
 
 .nopadding{
-	padding: 0;
+    padding: 0;/* 清除元素所有内边距（通用工具类） */
 }
 
 .navlist{
-	min-height: 58rem;
-	background: #254552;
+    min-height: 58rem;/* 侧边栏最小高度58rem，确保高度足够容纳内容 */
+    background: #254552;/* 侧边栏背景色：深青灰色 */
 }
-
+/*侧边栏链接样式*/
 a.list-group-item{
-	color: #C2D2CB;
-	padding-left: 3rem;
+    color: #C2D2CB;/* 链接文字颜色：浅灰绿色 */
+    padding-left: 3rem;/* 左侧内边距3rem，文字向右缩进，增强层级感 */
 
 }
 
 .list-group-item{
-	background-color:transparent;
-	color: #C2D2CB;
-	border:0;
-	border-radius: 0;
+    background-color:transparent; /* 列表项背景透明（继承侧边栏深青灰色） */
+    color: #C2D2CB;/* 文字颜色：浅灰绿色 */
+    border:0;/* 取消默认边框 */
+    border-radius: 0;/* 取消默认圆角，改为直角 */
 }
-
+/*侧边栏链接交互状态*/
 .list-group-item:hover,.list-group-item:focus{
-	background-color:transparent !important;
-	color: #C2D2CB !important;
+    background-color:transparent !important;/* 悬停/聚焦时背景仍透明（!important强制覆盖） */
+    color: #C2D2CB !important;/* 文字颜色保持不变（!important强制覆盖） */
 
 }
 
 .list-group-item.active,.list-group-item.active:hover{
-	background: #20343D  !important;
-	color:white !important;
-	border: 0;
+    background: #20343D  !important;/* 激活项背景色：更深的青灰色（!important强制覆盖） */
+    color:white !important; /* 激活项文字颜色：白色（突出显示） */
+    border: 0;/* 无边框 */
 }
-
+/*图标间距*/
 .glyphicon{
-	margin-right: 10px;
+    margin-right: 10px;/* 图标右侧间距10px，与文字分隔开 */
 }
-
+/*主内容框架*/
 .mainFrame{
-	width: 100%;
-	min-height: 60rem;
+    width: 100%;/* 宽度100%，占满父容器 */
+    min-height: 60rem;/* 最小高度60rem，确保内容区有足够高度 */
 }
 
 

src/main/resources/static/css/pages.css

@@ -1,36 +1,36 @@
-
+/*这段 CSS 代码主要用于定义页面中用户信息展示、数据项布局等元素的样式，功能明确且针对性强。*/
 .nopadding{
-	padding-left: 0;
-	padding-right: 0;
+    padding-left: 0;/* 清除左侧内边距 */
+    padding-right: 0;/* 清除右侧内边距 */
 }
-
+/*定义用户头像的样式，核心是通过 border-radius: 50% 将图片片裁剪成圆形，并通过宽度和外边距控制其大小和居中显示*/
 .userpic{
-	width: 50%;
-	border-radius: 50%;
-	border: 1px solid black;
-	margin-left:25%;
+    width: 50%;/* 宽度为父容器的50%（自适应父元素大小） */
+    border-radius: 50%;/* 圆角半径50%，将图片裁剪成圆形 */
+    border: 1px solid black; /* 1px黑色实线边框，勾勒出头像的轮廓 */
+    margin-left:25%;/* 左侧外边距25%（配合父容器宽度的25%），配合50%宽度实现水平居中 */
 }
-
+/*设置用户名的展示样式，通过居中和与头像的间距*/
 .username{
-	text-align: center;
-	margin-top: 20px;
-	font-size: 1.7rem;
+    text-align: center; /* 文本水平居中（与头像对齐，保持布局一致性） */
+    margin-top: 20px; /* 顶部外边距20px，与上方头像保持距离，避免拥挤 */
+    font-size: 1.7rem;/* 字体大小1.7rem（相对单位，适配不同屏幕） */
 }
 
 .glyphicon{
-	margin-right: 0;
+    margin-right: 0;/* 清除图标图标右侧的默认外边距（重置为0） */
 }
-
+/*定义数据项的通用样式。通过缩进、行高、底部边框等属性，实现数据项的整齐排列和分隔，提升信息展示的条理性。*/
 .fdata {
-    padding-left: 2%;
-    width: 100%;
-    margin: 0 auto;
-    line-height: 3.2;
-    border-bottom: 2px solid #e6e6e6;
-    overflow: hidden;
-    float: left;
+    padding-left: 2%;/* 左侧内边距2%（相对父容器宽度），让内容向右缩进一点，避免贴边 */
+    width: 100%;/* 宽度100%，占满父容器 */
+    margin: 0 auto;/* 水平居中（在父容器内居中显示） */
+    line-height: 3.2;/* 行高3.2倍（控制文本垂直居中，增强可读性） */
+    border-bottom: 2px solid #e6e6e6;/* 底部2px实线边框，颜色为浅灰色（#e6e6e6），用于分隔数据项 */
+    overflow: hidden;/* 超出容器的内容隐藏（避免内容溢出破坏布局） */
+    float: left;/* 左浮动，让多个数据项横向排列（或在父容器内靠左对齐） */
 }
 
 .alterinfo{
-	margin-bottom: 20px !important;
+    margin-bottom: 20px !important;/* 底部外边距20px，且通过!important强制覆盖其他样式，确保与下方元素的间距 */
 }

src/main/resources/static/index.html

@@ -1,100 +1,90 @@
+<!-- 酒店管理系统的登录页面 前端结构-->
 <!DOCTYPE html>
 <html>
 <head>
     <title>酒店管理系统</title>
-    <!-- 设定页面字符编码为UTF-8，确保中文正常显示 -->
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配配置：设置视口宽度为设备宽度，初始缩放比例1，禁止用户手动缩放 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap基础样式库，提供导航栏、表单、按钮等组件的默认样式 -->
     <link rel="stylesheet" type="text/css" href="css/bootstrap.min.css">
-    <!-- 引入登录页专属样式，定制登录框布局、颜色、字体等，匹配系统视觉风格 -->
     <link rel="stylesheet" type="text/css" href="css/index.css">
-    <!-- 引入页脚样式，控制页脚文字、链接的排版与样式 -->
     <link rel="stylesheet" type="text/css" href="css/footer.css">
 
 </head>
-
+<!--页面最外层容器，container-fluid 使容器占满屏幕宽度；main 是自定义类-->
 <body>
-<!-- 页面主体容器：使用Bootstrap的container-fluid类占满屏幕宽度，清除默认内边距 -->
 <div class="container-fluid main" id="main" style="padding: 0">
-    <!-- 顶部导航栏：采用Bootstrap的navbar组件，作为系统标识区域 -->
     <nav class="navbar navbar-default">
+        <!--顶部系统标识栏-->
         <div class="container-fluid nav-con">
             <div class="navbar-header">
-                <!-- 系统名称：设置较大字体和字母间距，使用浅色调突出显示，提升视觉辨识度 -->
                 <a class="navbar-brand" href="#" style="padding-top: 2rem;color: #EDEDED">
                     <span style="font-size: 2.3rem;padding-right: 2rem;letter-spacing: 2px">酒店管理系统</span>
                 </a>
             </div>
         </div>
     </nav>
-    <!-- 左侧空白占位区：通过Bootstrap栅格系统的col-md-7和col-xs-1类，实现登录框在PC端和移动端的居中效果 -->
+    <!-- 登录框布局（左侧留白 + 右侧登录框）-->
     <div class="col-md-7 col-xs-1"></div>
-    <!-- 登录框容器：PC端占3列、移动端占10列，通过自定义logindiv类控制登录框样式 -->
     <div class="col-md-3 col-xs-10 logindiv">
-        <!-- 登录标题区：通过login-h和loginh类控制标题样式，明确“登录”功能 -->
+        <!--登录框顶部标题区：
+      login-h/loginh：自定义类（控制标题位置，如居中、底部边框、间距）；
+      标题 “登录” 明确功能，引导用户操作-->
         <div class="login-h">
             <h3 class="loginh">
                 登录
             </h3>
         </div>
-        <!-- 登录表单：采用Bootstrap的form-horizontal类实现水平表单布局，结构清晰 -->
+        <!--：登录表单容器-->
         <form class="form-horizontal login-f">
-            <!-- 账号输入组：包含标签和输入框 -->
+            <!--收集用户登录账号-->
             <div class="form-group">
                 <label for="inputName" class="col-sm-2 control-label">Username</label>
                 <div class="col-md-12 col-xs-12">
-                    <!-- 账号输入框：通过forminput类统一样式，占位提示同时包含中英文，适配不同用户 -->
                     <input type="text" class="form-control forminput" id="inputName" placeholder="账号 Account">
                 </div>
             </div>
-            <!-- 密码输入组：包含标签和密码类型输入框 -->
+            <!--收集用户登录密码-->
             <div class="form-group">
                 <label for="inputPassword" class="col-sm-2 control-label">Password</label>
                 <div class="col-md-12 col-xs-12">
-                    <!-- 密码输入框：type设为password隐藏输入内容，保护隐私，占位提示包含中英文 -->
                     <input type="password" class="form-control forminput" id="inputPassword" placeholder="密码 Password">
                 </div>
             </div>
-            <!-- 验证码输入组：包含标签、输入框和验证码图片 -->
+            <!--收集验证码，防止自动化登录：
+            左侧输入框（col-md-8 col-xs-7）：id="inputCode" 用于输入验证码；
+            右侧图片区（col-md-4 col-xs-5）：id="code" 是验证码图片容器，src=" " 初始为空，后续通过 JS 从后端加载验证码图片；
+            inputcode/code：自定义类（控制验证码输入框宽度、图片尺寸）。-->
             <div class="form-group">
                 <label for="inputCode" class="col-sm-2 control-label">Code</label>
                 <div class="col-md-8 col-xs-7">
-                    <!-- 验证码输入框：通过inputcode类控制宽度，适配右侧图片区域 -->
                     <input type="text" class="form-control forminput inputcode" id="inputCode" placeholder="验证码 code">
                 </div>
                 <div class="col-md-4 col-xs-5" style="padding-left:0">
-                    <!-- 验证码图片：id为code，用于JS动态加载验证码，点击可刷新 -->
                     <img class="code" id="code" src=" ">
                 </div>
             </div>
-            <!-- 空白表单组：仅用于调整表单间距，优化页面布局美观度 -->
             <div class="form-group">
             </div>
-            <!-- 登录按钮组：控制按钮居中显示 -->
+            <!--提交登录请求-->
             <div class="form-group">
                 <div class="col-md-offset-3  col-md-6  col-xs-12">
-                    <!-- 登录按钮：添加transition过渡动画提升点击反馈，id为loginBtn用于JS绑定点击事件 -->
                     <button type="button" id="loginBtn" class="form-control btn loginbtn" style="transition: all 0.6s;" >登 录</button>
                 </div>
         </form>
     </div>
 </div>
 </div>
-<!-- 页脚区域：包含系统相关链接和版权信息，通过bs-docs-footer类控制样式 -->
+<!--页面底部版权与辅助链接区-->
 <footer class="bs-docs-footer">
     <div class="col-md-12">
         <p>
-            <!-- 系统辅助链接：提供关于系统、联系我们等入口，方便用户了解系统 -->
             <a href="#">关于本站</a>
             <a href="#">廉正举报</a>
             <a href="#">开放平台</a>
             <a href="#">诚征英才</a>
             <a href="#">联系我们</a>
             <a href="#">网站地图</a><br/><br/>
-            <!-- 版权信息：标明开发主体和年份，符合项目规范 -->
-            <em>2025 合肥师范学院 软件工程</em>
+            <em>Copyright © 2018 西安工业大学 All Rights Reserved</em>
         </p>
 
     </div>
@@ -103,9 +93,7 @@
 
 </body>
 </html>
-<!-- 引入jQuery库：提供DOM操作、AJAX请求等核心功能，是后续JS逻辑的基础 -->
 <script type="text/javascript" src="js/jquery.min.js"></script>
-<!-- 引入Bootstrap JS库：支持导航栏、表单等组件的基础交互效果 -->
 <script type="text/javascript" src="js/bootstrap.min.js"></script>
-<!-- 引入登录页专属JS：实现验证码加载刷新、登录表单校验、登录请求提交等核心逻辑 -->
-<script type="text/javascript" src="js/index.js"></script>
+<script type="text/javascript" src="js/index.js"></script><!--登录页面自定义脚本-->
+

src/main/resources/static/js/ad_manage.js

@@ -4,256 +4,256 @@ var pageSize=8;// 每页显示8条数据
 var l;// 用于记录当前页实际加载的数据条数
 // 页面DOM加载完成后执行
 $(document).ready(function(){
-	getStaffList(); // 调用函数，调用获取员工列表的函数，初始化页面数据
-	// 绑定"上一页"按钮点击事件，点击时调用getPre()函数
-	$("#pre").on('click',function(){
-		getPre();
-	});
-	// 绑定"下一页"按钮点击事件，点击时调用getNext()函数
-	$("#next").on('click',function(){
-		getNext();
-	});
+    getStaffList(); // 调用函数，调用获取员工列表的函数，初始化页面数据
+    // 绑定"上一页"按钮点击事件，点击时调用getPre()函数
+    $("#pre").on('click',function(){
+        getPre();
+    });
+    // 绑定"下一页"按钮点击事件，点击时调用getNext()函数
+    $("#next").on('click',function(){
+        getNext();
+    });
 
 })
 
 //判断对象/JSON是否为空 空返回1 非空返回0
 function isEmptyObject(e) {
-	var t;
-	for (t in e) // 遍历对象属性，若存在属性则说明非空
-		return 0;
-	return 1;
+    var t;
+    for (t in e) // 遍历对象属性，若存在属性则说明非空
+        return 0;
+    return 1;
 }
 
 // 存储当前页的员工列表数据
 var list;
 // 获取员工列表数据的函数
 function getStaffList(){
-	$.ajax({
-		type:"post",// 请求类型为POST
-		url:"../user/getAllUser.do",// 请求后端接口地址
-		dataType:"JSON",// 预期返回数据类型为JSON
-		data:{// 传递给后端的参数：当前页码和每页数量
-			"pageNum":pageNum,
-			"pageSize":pageSize
-		},
-		 // 请求成功的回调函数
-		success:function(data){
-		// 后端返回状态码为"0"表示成功
-			if(data.code=="0"){
-			// 若当前页数据为空且页码大于0，回退到上一页并重新加载
-				if(isEmptyObject(data.List)&&pageNum>0){
-					pageNum=pageNum-1;
-					getStaffList();
-				}
-				else{
-					var power=" ";// 存储职位名称
-					var htmlStr=" ";// 存储表格行HTML
-					var btnStr=" ";// 存储操作按钮HTML
-					list=data.List;// 将后端返回的列表数据存入全局变量
+    $.ajax({
+        type:"post",// 请求类型为POST
+        url:"../user/getAllUser.do",// 请求后端接口地址
+        dataType:"JSON",// 预期返回数据类型为JSON
+        data:{// 传递给后端的参数：当前页码和每页数量
+            "pageNum":pageNum,
+            "pageSize":pageSize
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            // 后端返回状态码为"0"表示成功
+            if(data.code=="0"){
+                // 若当前页数据为空且页码大于0，回退到上一页并重新加载
+                if(isEmptyObject(data.List)&&pageNum>0){
+                    pageNum=pageNum-1;
+                    getStaffList();
+                }
+                else{
+                    var power=" ";// 存储职位名称
+                    var htmlStr=" ";// 存储表格行HTML
+                    var btnStr=" ";// 存储操作按钮HTML
+                    list=data.List;// 将后端返回的列表数据存入全局变量
 
-					l=0;// 重置当前页数据条数计数
+                    l=0;// 重置当前页数据条数计数
 
-					// 显示上一页和下一页按钮（默认先显示，后续根据情况隐藏）
-					$("#pre").css("display","block");
-					$("#next").css("display","block");
-					// 清空表格内容并添加表头
-					$("#staffList").empty();
-					$("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
+                    // 显示上一页和下一页按钮（默认先显示，后续根据情况隐藏）
+                    $("#pre").css("display","block");
+                    $("#next").css("display","block");
+                    // 清空表格内容并添加表头
+                    $("#staffList").empty();
+                    $("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
 
-					// 遍历员工列表，生成表格内容
-					for(i in list){
-					// 根据权限值(power)设置职位名称和操作按钮
-						if(list[i].power=="0") {
-							power="管理员";
-							btnStr=" ";// 管理员无操作按钮
-						}
-						else if(list[i].power=="1") {
-							power="经理";
-							// 经理的操作按钮：设置为员工、删除
-							btnStr="<input type=\"button\" id=\"setStaff\" data-userid=\""+list[i].userid+"\" class=\"btn btn-success\" value=\"设置为员工\"/> <input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
-						}
-						else if(list[i].power=="2") {
-							power="员工";// 员工的操作按钮：设置为经理、重置密码、删除
-							btnStr="<input type=\"button\" id=\"setManage\" data-userid=\""+list[i].userid+"\" class=\"btn btn-success\" value=\"设置为经理\"/> <input type=\"button\" id=\"setPwd\" data-userid=\""+list[i].userid+"\" class=\"btn btn-info\" value=\"重置密码\"/> <input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
-						}
-						else {
-							power="清洁工";
-							// 清洁工的操作按钮：重置密码、删除
-							btnStr="<input type=\"button\" id=\"setPwd\" data-userid=\""+list[i].userid+"\" class=\"btn btn-info\" value=\"重置密码\"/> <input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/> "
-						}
-						// 拼接当前员工的表格行HTML
-						htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+power+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
-						// 将表格行添加到表格中
-						$("#staffList").append(htmlStr);
-						l++;// 累加当前页数据条数
-						//console.log(htmlStr)
-					}
+                    // 遍历员工列表，生成表格内容
+                    for(i in list){
+                        // 根据权限值(power)设置职位名称和操作按钮
+                        if(list[i].power=="0") {
+                            power="管理员";
+                            btnStr=" ";// 管理员无操作按钮
+                        }
+                        else if(list[i].power=="1") {
+                            power="经理";
+                            // 经理的操作按钮：设置为员工、删除
+                            btnStr="<input type=\"button\" id=\"setStaff\" data-userid=\""+list[i].userid+"\" class=\"btn btn-success\" value=\"设置为员工\"/> <input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
+                        }
+                        else if(list[i].power=="2") {
+                            power="员工";// 员工的操作按钮：设置为经理、重置密码、删除
+                            btnStr="<input type=\"button\" id=\"setManage\" data-userid=\""+list[i].userid+"\" class=\"btn btn-success\" value=\"设置为经理\"/> <input type=\"button\" id=\"setPwd\" data-userid=\""+list[i].userid+"\" class=\"btn btn-info\" value=\"重置密码\"/> <input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
+                        }
+                        else {
+                            power="清洁工";
+                            // 清洁工的操作按钮：重置密码、删除
+                            btnStr="<input type=\"button\" id=\"setPwd\" data-userid=\""+list[i].userid+"\" class=\"btn btn-info\" value=\"重置密码\"/> <input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/> "
+                        }
+                        // 拼接当前员工的表格行HTML
+                        htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+power+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
+                        // 将表格行添加到表格中
+                        $("#staffList").append(htmlStr);
+                        l++;// 累加当前页数据条数
+                        //console.log(htmlStr)
+                    }
 
-					// 若当前是第1页，隐藏"上一页"按钮
-					if(pageNum=="1") $("#pre").css("display","none");
-					 // 若当前页数据条数小于每页显示数量，说明是最后一页，隐藏"下一页"按钮
-					if(pageSize>l) $("#next").css("display","none");
+                    // 若当前是第1页，隐藏"上一页"按钮
+                    if(pageNum=="1") $("#pre").css("display","none");
+                    // 若当前页数据条数小于每页显示数量，说明是最后一页，隐藏"下一页"按钮
+                    if(pageSize>l) $("#next").css("display","none");
 
-					// 绑定操作按钮的点击事件
-					btnOn();
+                    // 绑定操作按钮的点击事件
+                    btnOn();
 
-				}
-			}
-			else{
-				alert("获取员工列表失败")
-			}
-			
+                }
+            }
+            else{
+                alert("获取员工列表失败")
+            }
 
-			
-		},
-		// 请求失败的回调函数
-		error:function(){
-			alert("获取员工列表发生错误")
-		}
-	})
+
+
+        },
+        // 请求失败的回调函数
+        error:function(){
+            alert("获取员工列表发生错误")
+        }
+    })
 }
 
 // 绑定操作按钮的点击事件
 function btnOn(){
- // 绑定"设置为员工"按钮事件，调用setPosition并传递权限值"2"
-	$("input").filter("#setStaff").on('click',function(event){
+    // 绑定"设置为员工"按钮事件，调用setPosition并传递权限值"2"
+    $("input").filter("#setStaff").on('click',function(event){
         setPosition(event,"2");
-	});
-	 // 绑定"设置为经理"按钮事件，调用setPosition并传递权限值"1"
-	$("input").filter("#setManage").on('click',function(event){
-		setPosition(event,"1");
-	});
-	// 绑定"重置密码"按钮事件，调用setPwd
-	$("input").filter("#setPwd").on('click',function(event){
+    });
+    // 绑定"设置为经理"按钮事件，调用setPosition并传递权限值"1"
+    $("input").filter("#setManage").on('click',function(event){
+        setPosition(event,"1");
+    });
+    // 绑定"重置密码"按钮事件，调用setPwd
+    $("input").filter("#setPwd").on('click',function(event){
         setPwd(event);
-	});
-	// 绑定"删除"按钮事件，调用delUser
-	$("input").filter("#delUser").on('click',function(event){
-		delUser(event);
-	});
-	// 绑定"跳转页码"按钮事件，调用setPage
-	$("input").filter("#setPageBtn").on('click',function( ){
-		setPage( );
-	})
+    });
+    // 绑定"删除"按钮事件，调用delUser
+    $("input").filter("#delUser").on('click',function(event){
+        delUser(event);
+    });
+    // 绑定"跳转页码"按钮事件，调用setPage
+    $("input").filter("#setPageBtn").on('click',function( ){
+        setPage( );
+    })
 }
 
 // 上一页功能：页码减1并重新加载列表
 function getPre(){
-	pageNum=pageNum-1;
-	getStaffList();
+    pageNum=pageNum-1;
+    getStaffList();
 }
 
 // 下一页功能：页码加1并重新加载列表
 function getNext(){
-	pageNum=pageNum+1;
-	getStaffList();
-	
+    pageNum=pageNum+1;
+    getStaffList();
+
 }
 
 // 跳转指定页码功能
 function setPage(){
-	// 验证输入的页码是否合法（大于0）
-	if($("#inputPage").val()<0 || $("#inputPage").val()==0)
-		alert("请输入正确页码");
-	else{
-		pageNum=$("#inputPage").val(); // 更新页码
-		getStaffList();// 重新加载列表
-	}
-	
+    // 验证输入的页码是否合法（大于0）
+    if($("#inputPage").val()<0 || $("#inputPage").val()==0)
+        alert("请输入正确页码");
+    else{
+        pageNum=$("#inputPage").val(); // 更新页码
+        getStaffList();// 重新加载列表
+    }
+
 }
 
 // 修改员工职位（权限）的函数
 function setPosition(event,alter){
-	var userid=$(event.target).data("userid"); // 获取目标员工的ID
-	var info;// 存储目标员工的详细信息
-	// 从当前列表中查找目标员
-	for(i in list){
-		if(list[i].userid==userid){
-			info=list[i];
-		}
-	}
-	// 发送AJAX请求修改权限
-	$.ajax({
-		type:"POST",
-		url:"../user/updateUser.do",// 后端修改用户接口
-		dataType:"JSON",
-		data:{// 传递用户ID和新权限值
-			"userid":info.userid,
-			"power":alter
-		},
-		success:function(data){
-			if(data.code==0){// 修改成功
-				alert("修改成功");
-				getStaffList();// 重新加载列表刷新数据
-			}
-			else
-				alert("修改失败")
-		},
-		error:function(){
-			alert("修改信息出现错误");
-		}
-	})
+    var userid=$(event.target).data("userid"); // 获取目标员工的ID
+    var info;// 存储目标员工的详细信息
+    // 从当前列表中查找目标员
+    for(i in list){
+        if(list[i].userid==userid){
+            info=list[i];
+        }
+    }
+    // 发送AJAX请求修改权限
+    $.ajax({
+        type:"POST",
+        url:"../user/updateUser.do",// 后端修改用户接口
+        dataType:"JSON",
+        data:{// 传递用户ID和新权限值
+            "userid":info.userid,
+            "power":alter
+        },
+        success:function(data){
+            if(data.code==0){// 修改成功
+                alert("修改成功");
+                getStaffList();// 重新加载列表刷新数据
+            }
+            else
+                alert("修改失败")
+        },
+        error:function(){
+            alert("修改信息出现错误");
+        }
+    })
 
 }
 
 // 重置员工密码的函数
 function setPwd(event){
-	var userid=$(event.target).data("userid");// 获取目标员工的ID
-	var info;// 存储目标员工的详细信息
-	// 从当前列表中查找目标员工
-	for(i in list){
-		if(list[i].userid==userid){
-			info=list[i];
-		}
-	}
-	info.password="111111"; // 重置密码为"111111"
-	// 发送AJAX请求修改密码
-	$.ajax({
-		type:"POST",
-		url:"../user/updateUser.do",// 后端修改用户接口
-		dataType:"JSON",
-		data:{// 传递用户ID和新密码
-			"userid":info.userid,
-			"password":info.password
-		},
-		success:function(data){
-			if(data.code==0){// 修改成功
-				alert("修改成功");
-				getStaffList(); // 重新加载列表刷新数据
-			}
-			else
-				alert("修改失败")
-		},
-		error:function(){
-			alert("修改信息出现错误");
-		}
-	})
+    var userid=$(event.target).data("userid");// 获取目标员工的ID
+    var info;// 存储目标员工的详细信息
+    // 从当前列表中查找目标员工
+    for(i in list){
+        if(list[i].userid==userid){
+            info=list[i];
+        }
+    }
+    info.password="111111"; // 重置密码为"111111"
+    // 发送AJAX请求修改密码
+    $.ajax({
+        type:"POST",
+        url:"../user/updateUser.do",// 后端修改用户接口
+        dataType:"JSON",
+        data:{// 传递用户ID和新密码
+            "userid":info.userid,
+            "password":info.password
+        },
+        success:function(data){
+            if(data.code==0){// 修改成功
+                alert("修改成功");
+                getStaffList(); // 重新加载列表刷新数据
+            }
+            else
+                alert("修改失败")
+        },
+        error:function(){
+            alert("修改信息出现错误");
+        }
+    })
 }
 // 删除员工的函数
 function delUser(event){
-	var userid=$(event.target).data("userid"); // 获取目标员工的ID
-	 // 发送AJAX请求删除用户
-	$.ajax({
-		type:"POST",
-		url:"../user/delUser.do",// 后端删除用户接口
-		dataType:"JSON",
-		data:{ // 传递用户ID
-			"userid":userid
-		},
-		success:function(data){
-			if(data.code==0){// 删除成功
-				alert("删除成功");
-				 // 若当前页只剩1条数据，删除后页码回退1页
-				if(l==1)
-					pageNum=pageNum-1;
-				getStaffList();// 重新加载列表刷新数据
-			}
-			else
-				alert("删除失败")
-		},
-		error:function(){
-			alert("删除出现错误");
-		}
-	})
+    var userid=$(event.target).data("userid"); // 获取目标员工的ID
+    // 发送AJAX请求删除用户
+    $.ajax({
+        type:"POST",
+        url:"../user/delUser.do",// 后端删除用户接口
+        dataType:"JSON",
+        data:{ // 传递用户ID
+            "userid":userid
+        },
+        success:function(data){
+            if(data.code==0){// 删除成功
+                alert("删除成功");
+                // 若当前页只剩1条数据，删除后页码回退1页
+                if(l==1)
+                    pageNum=pageNum-1;
+                getStaffList();// 重新加载列表刷新数据
+            }
+            else
+                alert("删除失败")
+        },
+        error:function(){
+            alert("删除出现错误");
+        }
+    })
 
 }

src/main/resources/static/js/ad_order.js

@@ -5,249 +5,249 @@ var l;// 记录当前页实际加载的数据条数
 
 // 页面DOM加载完成后执行初始化操作
 $(document).ready(function(){
-	getorderList(); // 加载订单列表
-	getConfig();// 加载系统配置信息
-	// 绑定"上一页"按钮点击事件
-	$("#pre").on('click',function(){
-		getPre();
-   });
-	// 绑定"下一页"按钮点击事件
-	$("#next").on('click',function(){
-		getNext();
-	});
+    getorderList(); // 加载订单列表
+    getConfig();// 加载系统配置信息
+    // 绑定"上一页"按钮点击事件
+    $("#pre").on('click',function(){
+        getPre();
+    });
+    // 绑定"下一页"按钮点击事件
+    $("#next").on('click',function(){
+        getNext();
+    });
 
 })
 
 //判断对象/JSON是否为空 空返回1 非空返回0
 function isEmptyObject(e) {
-	var t;
-	for (t in e)// 遍历对象属性，存在属性则非空
-		return 0;
-	return 1;
+    var t;
+    for (t in e)// 遍历对象属性，存在属性则非空
+        return 0;
+    return 1;
 }
 
 // 存储当前页的订单列表数据
 var list;
 // 获取订单列表数据
 function getorderList(){
-	$.ajax({
-		type:"post",// 请求类型为POST
-		url:"../order/getAllOrder.do", // 后端获取订单列表的接口
-		dataType:"JSON",// 预期返回JSON格式数据
-		data:{// 传递分页参数
-			"pageNum":pageNum,
-			"pageSize":pageSize		
-		},
-		// 请求成功的回调函数
-		success:function(data){
-		// 若当前页数据为空且页码>0，回退到上一页重新加载
-			if(isEmptyObject(data.List)&&pageNum>0){
-				pageNum=pageNum-1;
-				getorderList();
-			}
-			else{
-				list=data.List;// 存储订单列表数据
-				var htmlStr=" ";// 表格行HTML字符串
-				var btnStr=" ";// 操作按钮HTML字符串
-				var state=" ";// 订单状态文本
-				var sdate;// 入住日期（格式化后）
-				var edate;// 退房日期（格式化后）
-				l=0;// 重置当前页数据计数
-
-				// 显示分页按钮（默认先显示，后续根据情况隐藏）
-				$("#pre").css("display","block");
-				$("#next").css("display","block");
-				// 清空表格并添加表头
-				$("#orderList").empty();
-				$("#orderList").append("<tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>")
-				
-				for(i in list){
-				// 从时间字符串中提取日期部分（格式：年-月-日）
-					sdate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].starttime);
-					edate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].endtime);
-					// 根据订单状态（state）设置状态文本和操作按钮
-					if(list[i].state=="0"){
-						state="未付款";
-						// 未付款订单：仅显示"查看房间"按钮（关联模态框）
-						btnStr="<input  type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\">";
-					}
-					else if(list[i].state=="1"){
-						state="已付款";
-						// 已付款订单：仅显示"查看房间"按钮
-						btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> ";
-					}
-					else if(list[i].state=="2"){
-						state="已完成";
-						// 已完成订单：显示"查看房间"和"删除"按钮
-						btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\" class=\"btn btn-success\"  data-orderid=\""+list[i].orderid+"\" id=\"delOrder\" value=\"删除\">";
-					}
-					else{
-						state="已取消";
-						// 已取消订单：显示"查看房间"和"删除"按钮
-						btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\"  class=\"btn btn-success\"  data-orderid=\""+list[i].orderid+"\" id=\"delOrder\" value=\"删除\">";
-					}
-
-					// 拼接订单表格行HTML
-					htmlStr="<tr data-orderid=\""+list[i].orderid+"\"><td>"+list[i].householdname+"</td><td>"+list[i].id+"</td><td>"+sdate+"</td><td>"+edate+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+btnStr+"</td></tr>";
-					// 添加到表格中
-					$("#orderList").append(htmlStr);
-					l++;// 累加当前页数据条数
-				}
-				 // 若为第1页，隐藏"上一页"按钮
-				if(pageNum=="1") $("#pre").css("display","none");
-				// 若当前页数据少于每页数量，说明是最后一页，隐藏"下一页"按钮
-				if(pageSize>l) $("#next").css("display","none");
-				// 绑定操作按钮事件
-				btnOn();
-			}
-
-		},
-		// 请求失败的回调
-		error:function(){
-			alert("获取订单列表发生错误")
-		}
-	})
+    $.ajax({
+        type:"post",// 请求类型为POST
+        url:"../order/getAllOrder.do", // 后端获取订单列表的接口
+        dataType:"JSON",// 预期返回JSON格式数据
+        data:{// 传递分页参数
+            "pageNum":pageNum,
+            "pageSize":pageSize
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            // 若当前页数据为空且页码>0，回退到上一页重新加载
+            if(isEmptyObject(data.List)&&pageNum>0){
+                pageNum=pageNum-1;
+                getorderList();
+            }
+            else{
+                list=data.List;// 存储订单列表数据
+                var htmlStr=" ";// 表格行HTML字符串
+                var btnStr=" ";// 操作按钮HTML字符串
+                var state=" ";// 订单状态文本
+                var sdate;// 入住日期（格式化后）
+                var edate;// 退房日期（格式化后）
+                l=0;// 重置当前页数据计数
+
+                // 显示分页按钮（默认先显示，后续根据情况隐藏）
+                $("#pre").css("display","block");
+                $("#next").css("display","block");
+                // 清空表格并添加表头
+                $("#orderList").empty();
+                $("#orderList").append("<tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>")
+
+                for(i in list){
+                    // 从时间字符串中提取日期部分（格式：年-月-日）
+                    sdate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].starttime);
+                    edate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].endtime);
+                    // 根据订单状态（state）设置状态文本和操作按钮
+                    if(list[i].state=="0"){
+                        state="未付款";
+                        // 未付款订单：仅显示"查看房间"按钮（关联模态框）
+                        btnStr="<input  type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\">";
+                    }
+                    else if(list[i].state=="1"){
+                        state="已付款";
+                        // 已付款订单：仅显示"查看房间"按钮
+                        btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> ";
+                    }
+                    else if(list[i].state=="2"){
+                        state="已完成";
+                        // 已完成订单：显示"查看房间"和"删除"按钮
+                        btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\" class=\"btn btn-success\"  data-orderid=\""+list[i].orderid+"\" id=\"delOrder\" value=\"删除\">";
+                    }
+                    else{
+                        state="已取消";
+                        // 已取消订单：显示"查看房间"和"删除"按钮
+                        btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\"  class=\"btn btn-success\"  data-orderid=\""+list[i].orderid+"\" id=\"delOrder\" value=\"删除\">";
+                    }
+
+                    // 拼接订单表格行HTML
+                    htmlStr="<tr data-orderid=\""+list[i].orderid+"\"><td>"+list[i].householdname+"</td><td>"+list[i].id+"</td><td>"+sdate+"</td><td>"+edate+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+btnStr+"</td></tr>";
+                    // 添加到表格中
+                    $("#orderList").append(htmlStr);
+                    l++;// 累加当前页数据条数
+                }
+                // 若为第1页，隐藏"上一页"按钮
+                if(pageNum=="1") $("#pre").css("display","none");
+                // 若当前页数据少于每页数量，说明是最后一页，隐藏"下一页"按钮
+                if(pageSize>l) $("#next").css("display","none");
+                // 绑定操作按钮事件
+                btnOn();
+            }
+
+        },
+        // 请求失败的回调
+        error:function(){
+            alert("获取订单列表发生错误")
+        }
+    })
 }
 
 // 绑定操作按钮的点击事件
 function btnOn(){
 // 绑定"跳转页码"按钮事件
-	$("input").filter("#setPageBtn").on('click',function( ){
-		setPage( );
-	});
-	// 绑定"查看房间"按钮事件
-	$("input").filter("#showRoom").on('click',function(event){
-		showRoom(event);
-	})
-	// 绑定"删除订单"按钮事件
-	$("input").filter("#delOrder").on('click',function(event){
-		delOrder(event);
-	});
+    $("input").filter("#setPageBtn").on('click',function( ){
+        setPage( );
+    });
+    // 绑定"查看房间"按钮事件
+    $("input").filter("#showRoom").on('click',function(event){
+        showRoom(event);
+    })
+    // 绑定"删除订单"按钮事件
+    $("input").filter("#delOrder").on('click',function(event){
+        delOrder(event);
+    });
 }
 
 // 上一页功能：页码减1并重新加载列表
 function getPre(){
-	pageNum=pageNum-1;
-	getorderList();
+    pageNum=pageNum-1;
+    getorderList();
 }
 
 // 下一页功能：页码加1并重新加载列表
 function getNext(){
-	pageNum=pageNum+1;
-	getorderList();	
+    pageNum=pageNum+1;
+    getorderList();
 }
 // 跳转指定页码功能
 function setPage(){
-	// 验证页码合法性（必须大于0）
-	if($("#inputPage").val()<0 || $("#inputPage").val()==0)
-		alert("请输入正确页码");
-	else{
-		pageNum=$("#inputPage").val();// 更新页码
-		getorderList();// 重新加载列表
-	}
-	
+    // 验证页码合法性（必须大于0）
+    if($("#inputPage").val()<0 || $("#inputPage").val()==0)
+        alert("请输入正确页码");
+    else{
+        pageNum=$("#inputPage").val();// 更新页码
+        getorderList();// 重新加载列表
+    }
+
 }
 
 // 删除订单功能
 function delOrder(event){
-	var orderid=$(event.target).data("orderid");// 获取订单ID
-	$.ajax({
-		type:"POST",
-		url:"../order/delOrder.do",// 后端删除订单接口
-		dataType:"JSON",
-		data:{// 传递订单ID
-			"orderid":orderid
-		},
-		success:function(data){
-				if(data.code==0){// 删除成功
-					alert("删除成功");
-					// 若当前页只剩1条数据，删除后页码回退1页
-				if(l==1)
-					pageNum=pageNum-1;
-				getorderList();// 重新加载列表刷新数据
-			}
-			else
-				alert("删除失败")
-		},
-		error:function(){
-			alert("删除出现错误");
-		}
-	})
+    var orderid=$(event.target).data("orderid");// 获取订单ID
+    $.ajax({
+        type:"POST",
+        url:"../order/delOrder.do",// 后端删除订单接口
+        dataType:"JSON",
+        data:{// 传递订单ID
+            "orderid":orderid
+        },
+        success:function(data){
+            if(data.code==0){// 删除成功
+                alert("删除成功");
+                // 若当前页只剩1条数据，删除后页码回退1页
+                if(l==1)
+                    pageNum=pageNum-1;
+                getorderList();// 重新加载列表刷新数据
+            }
+            else
+                alert("删除失败")
+        },
+        error:function(){
+            alert("删除出现错误");
+        }
+    })
 
 }
 
 // 查看房间详情功能（点击后显示模态框）
 function showRoom(event){
-	var roomid=$(event.target).data("roomid");// 获取房间ID
-	$.ajax({
-		type:"POST",
-		url:"../room/getRoomById.do",// 后端获取房间详情接口
-		dataType:"JSON",
-		data:{// 传递房间ID
-			"roomid":roomid
-		},
-		success:function(data){
-			var room=data.room;// 房间详情数据
-			if(data.code==0){// 获取成功
-				var htmlStr=" ";// 房间信息表格HTML
-				var state=" ";// 房间状态文本
-				var type=" ";// 房间类型文本
-				// 清空模态框中的表格
-				$("#roomTable").empty();
-				// 转换房间状态编码为文本
-				if(room.state=="0")
-					state="停用";
-				else if(room.state=="1")
-					state="未预定";
-				else if(room.state=="2")
-					state="已预定(入住)";
-				else
-					state="待清扫";
-					// 转换房间类型编码为文本
-				if(room.type=="1")
-					type="单人间";
-				else if(room.type=="2")
-					type="双人间";
-				else if(room.type=="3")
-					type="大床房";
-				else
-					type="套房";
-					// 拼接房间信息表格HTML
-				htmlStr="<tr><th>位置</th><td>"+room.local+"</td></tr><tr><th>价格</th><td>"+room.money+"</td></tr><tr><th>类型</th><td>"+type+"</td></tr><tr><th>状态</th><td>"+state+"</td></tr>"
-				 // 添加到模态框表格中
-				$("#roomTable").append(htmlStr);
-			}
-			else
-				alert("获取失败")
-		},
-		error:function(){
-			alert("获取信息出现错误");
-		}
-	})
+    var roomid=$(event.target).data("roomid");// 获取房间ID
+    $.ajax({
+        type:"POST",
+        url:"../room/getRoomById.do",// 后端获取房间详情接口
+        dataType:"JSON",
+        data:{// 传递房间ID
+            "roomid":roomid
+        },
+        success:function(data){
+            var room=data.room;// 房间详情数据
+            if(data.code==0){// 获取成功
+                var htmlStr=" ";// 房间信息表格HTML
+                var state=" ";// 房间状态文本
+                var type=" ";// 房间类型文本
+                // 清空模态框中的表格
+                $("#roomTable").empty();
+                // 转换房间状态编码为文本
+                if(room.state=="0")
+                    state="停用";
+                else if(room.state=="1")
+                    state="未预定";
+                else if(room.state=="2")
+                    state="已预定(入住)";
+                else
+                    state="待清扫";
+                // 转换房间类型编码为文本
+                if(room.type=="1")
+                    type="单人间";
+                else if(room.type=="2")
+                    type="双人间";
+                else if(room.type=="3")
+                    type="大床房";
+                else
+                    type="套房";
+                // 拼接房间信息表格HTML
+                htmlStr="<tr><th>位置</th><td>"+room.local+"</td></tr><tr><th>价格</th><td>"+room.money+"</td></tr><tr><th>类型</th><td>"+type+"</td></tr><tr><th>状态</th><td>"+state+"</td></tr>"
+                // 添加到模态框表格中
+                $("#roomTable").append(htmlStr);
+            }
+            else
+                alert("获取失败")
+        },
+        error:function(){
+            alert("获取信息出现错误");
+        }
+    })
 }
 
 // 获取系统配置信息（如总营业额、总房间数）
 function getConfig(){
-	$.ajax({
-		type:"POST",
-		url:"../config/getConfig.do",// 后端获取配置接口
-		dataType:"JSON",
-		data:{},// 无参数
-		success:function(data){
-			if(data.code=="0"){// 获取成功
-				var config=data.config;// 配置数据
-				// 更新页面上的总金额和总房间数显示
-				$("#totalMoney").text(config.totalmoney);
-				$("#totalRoom").text(config.totalroom);
-			}
-			else{
-				alert("获取配置错误");
-			}
-
-		},
-		error:function(){
-			alert("获取配置发生错误")
-		}
-
-	});
+    $.ajax({
+        type:"POST",
+        url:"../config/getConfig.do",// 后端获取配置接口
+        dataType:"JSON",
+        data:{},// 无参数
+        success:function(data){
+            if(data.code=="0"){// 获取成功
+                var config=data.config;// 配置数据
+                // 更新页面上的总金额和总房间数显示
+                $("#totalMoney").text(config.totalmoney);
+                $("#totalRoom").text(config.totalroom);
+            }
+            else{
+                alert("获取配置错误");
+            }
+
+        },
+        error:function(){
+            alert("获取配置发生错误")
+        }
+
+    });
 }

src/main/resources/static/js/ad_salary.js

@@ -1,129 +1,129 @@
 // 页面DOM加载完成后执行的初始化函数
 $(document).ready(function(){
 // 加载配置信息
-	getConfig();
-	// 给"查看配置"按钮绑定点击事件，点击时切换显示的标签页
-	$("#showConfig").click(function(){
-		changeTab();
-	});
-	// 给"修改配置"按钮绑定点击事件，点击时切换显示的标签页
-	$("#alterConfig").click(function(){
-		changeTab();
-	});
-	// 给"确认修改"按钮绑定点击事件，点击时执行修改配置的逻辑
-	$("#alterConfigBtn").click(function(){
-		alterConfig();
-	})
+    getConfig();
+    // 给"查看配置"按钮绑定点击事件，点击时切换显示的标签页
+    $("#showConfig").click(function(){
+        changeTab();
+    });
+    // 给"修改配置"按钮绑定点击事件，点击时切换显示的标签页
+    $("#alterConfig").click(function(){
+        changeTab();
+    });
+    // 给"确认修改"按钮绑定点击事件，点击时执行修改配置的逻辑
+    $("#alterConfigBtn").click(function(){
+        alterConfig();
+    })
 })
 // 全局变量，用于存储从后端获取的配置信息
 var config;
 
 //判断字符串是否为空 空返回1 非空返回0
 function isEmptyString(str){
- // 如果字符串是'null'或空字符串，视为空
-	if(str=='null'||str=='')
-		return 1;
-	return 0;
+    // 如果字符串是'null'或空字符串，视为空
+    if(str=='null'||str=='')
+        return 1;
+    return 0;
 }
 
 // 从后端获取配置信息并展示
 function getConfig(){
 // 发起AJAX POST请求
-	$.ajax({
-		type:"POST",// 请求类型
-		url:"../config/getConfig.do", // 请求后端接口地址
-		dataType:"JSON", // 预期后端返回的数据类型
-		data:{},// 请求参数（无参数）
-		// 请求成功的回调函数
-		success:function(data){
-		// 后端返回成功状态码（假设code="0"为成功）
-			if(data.code=="0"){
-			// 存储配置信息到全局变量
-				config=data.config;
-				// 拼接配置信息的HTML字符串（用于展示表格）
-				var htmlStr="<tr><td>经理</td><td>"+config.manage+"</td><td>"+config.managesalary+"%</td></tr>"+
-				"<tr><td>员工</td><td>"+config.staff+"</td><td>"+config.staffsalary+"%</td></tr>"+
-				"<tr><td>清洁工</td><td>"+config.cleaner+"</td><td>"+config.cleanerssalary+"%</td></tr>";
-				// 将HTML添加到表格中展示
-				$("#configList").append(htmlStr);
-				// 给修改表单的输入框赋值（默认显示当前配置）
-				$("#inputMS").val(config.manage);
-				$("#inputSS").val(config.staff);
-				$("#inputCS").val(config.cleaner);
-				$("#inputM").val(config.managesalary);
-				$("#inputS").val(config.staffsalary);
-				$("#inputC").val(config.cleanerssalary);
-			}
-			else{
-			// 后端返回失败，提示错误
-				alert("获取配置错误");
-			}
+    $.ajax({
+        type:"POST",// 请求类型
+        url:"../config/getConfig.do", // 请求后端接口地址
+        dataType:"JSON", // 预期后端返回的数据类型
+        data:{},// 请求参数（无参数）
+        // 请求成功的回调函数
+        success:function(data){
+            // 后端返回成功状态码（假设code="0"为成功）
+            if(data.code=="0"){
+                // 存储配置信息到全局变量
+                config=data.config;
+                // 拼接配置信息的HTML字符串（用于展示表格）
+                var htmlStr="<tr><td>经理</td><td>"+config.manage+"</td><td>"+config.managesalary+"%</td></tr>"+
+                    "<tr><td>员工</td><td>"+config.staff+"</td><td>"+config.staffsalary+"%</td></tr>"+
+                    "<tr><td>清洁工</td><td>"+config.cleaner+"</td><td>"+config.cleanerssalary+"%</td></tr>";
+                // 将HTML添加到表格中展示
+                $("#configList").append(htmlStr);
+                // 给修改表单的输入框赋值（默认显示当前配置）
+                $("#inputMS").val(config.manage);
+                $("#inputSS").val(config.staff);
+                $("#inputCS").val(config.cleaner);
+                $("#inputM").val(config.managesalary);
+                $("#inputS").val(config.staffsalary);
+                $("#inputC").val(config.cleanerssalary);
+            }
+            else{
+                // 后端返回失败，提示错误
+                alert("获取配置错误");
+            }
 
-		},
-		// 请求失败的回调函数
-		error:function(){
-			alert("获取配置发生错误")
-		}
+        },
+        // 请求失败的回调函数
+        error:function(){
+            alert("获取配置发生错误")
+        }
 
-	});
+    });
 }
 
 // 切换标签页（切换"查看配置"和"修改配置"区域的显示状态）
 function changeTab(){
 // 获取两个区域当前的显示状态
-	var info=$("#showConfigDiv").css("display"); // 查看配置区域
-	var alter=$("#alterConfigDiv").css("display");// 修改配置区域
-	 // 如果查看区域正在显示，则隐藏查看区域，显示修改区域（带动画）
-	if(info=="block"){
-		$("#showConfigDiv").css("display","none");
-		$("#alterConfigDiv").fadeIn();	// 淡入动画
-	}
-	else{
-	 // 否则隐藏修改区域，显示查看区域（带动画）
-		$("#alterConfigDiv").css("display","none")
-		$("#showConfigDiv").fadeIn();// 淡入动画
-	}
+    var info=$("#showConfigDiv").css("display"); // 查看配置区域
+    var alter=$("#alterConfigDiv").css("display");// 修改配置区域
+    // 如果查看区域正在显示，则隐藏查看区域，显示修改区域（带动画）
+    if(info=="block"){
+        $("#showConfigDiv").css("display","none");
+        $("#alterConfigDiv").fadeIn();	// 淡入动画
+    }
+    else{
+        // 否则隐藏修改区域，显示查看区域（带动画）
+        $("#alterConfigDiv").css("display","none")
+        $("#showConfigDiv").fadeIn();// 淡入动画
+    }
 }
 
 // 提交修改配置的请求
 function alterConfig(){
 // 校验输入框是否为空（调用isEmptyString函数）
-	if(isEmptyString($("#inputMS").val())||isEmptyString($("#inputM").val())||isEmptyString($("#inputSS").val())||isEmptyString($("#inputS").val())||isEmptyString($("#inputCS").val())||isEmptyString($("#inputC").val()))
-		alert("请填写全内容");// 有空值则提示
-	else{
-	 // 输入完整，发起修改请求
-		$.ajax({
-			type:"POST", // 请求类型
-			url:"../config/updateConfig.do",// 后端修改接口地址
-			dataType:"JSON", // 预期返回数据类型
-			// 请求参数（从输入框获取新的配置值）
-			data:{
-				"managesalary":$("#inputM").val(),
-				"staffsalary":$("#inputS").val(),
-				"cleanerssalary":$("#inputC").val(),
-				"manage":$("#inputMS").val(),
-				"staff":$("#inputSS").val(),
-				"cleaner":$("#inputCS").val()
-			},
-			// 请求成功的回调函数
-			success:function(data){
-				if(data.code=="0"){
-					alert("修改成功");
-					
-				}
-				else{
-					alert("修改配置错误");
-				}
-				// 无论成功与否，刷新页面重新加载配置
-				window.location.reload();
+    if(isEmptyString($("#inputMS").val())||isEmptyString($("#inputM").val())||isEmptyString($("#inputSS").val())||isEmptyString($("#inputS").val())||isEmptyString($("#inputCS").val())||isEmptyString($("#inputC").val()))
+        alert("请填写全内容");// 有空值则提示
+    else{
+        // 输入完整，发起修改请求
+        $.ajax({
+            type:"POST", // 请求类型
+            url:"../config/updateConfig.do",// 后端修改接口地址
+            dataType:"JSON", // 预期返回数据类型
+            // 请求参数（从输入框获取新的配置值）
+            data:{
+                "managesalary":$("#inputM").val(),
+                "staffsalary":$("#inputS").val(),
+                "cleanerssalary":$("#inputC").val(),
+                "manage":$("#inputMS").val(),
+                "staff":$("#inputSS").val(),
+                "cleaner":$("#inputCS").val()
+            },
+            // 请求成功的回调函数
+            success:function(data){
+                if(data.code=="0"){
+                    alert("修改成功");
 
-			},
-			 // 请求失败的回调函数
-			error:function(){
-				alert("修改配置发生错误")
-			}
+                }
+                else{
+                    alert("修改配置错误");
+                }
+                // 无论成功与否，刷新页面重新加载配置
+                window.location.reload();
 
-		});
+            },
+            // 请求失败的回调函数
+            error:function(){
+                alert("修改配置发生错误")
+            }
 
-	}
+        });
+
+    }
 }

src/main/resources/static/js/all_infor.js

@@ -1,14 +1,14 @@
 // 扩展jQuery方法：添加获取URL参数的功能
 (function($){
 // 定义$.getData方法，用于从URL查询参数中获取指定名称的值
-	$.getData=function(name){
-	// 构建正则表达式，匹配URL中"name=value"的参数格式
-		var reg=new RegExp("(^|&)"+name+"=([^&]+)(&|$)?");
-		// 从URL的查询字符串（?后的部分）中提取参数并匹配正则
-		var result = window.location.search.substr(1).match(reg);
-		// 若匹配到结果则返回参数值，否则返回null
-		if (result!= null) return result[2]; return null;
-	}
+    $.getData=function(name){
+        // 构建正则表达式，匹配URL中"name=value"的参数格式
+        var reg=new RegExp("(^|&)"+name+"=([^&]+)(&|$)?");
+        // 从URL的查询字符串（?后的部分）中提取参数并匹配正则
+        var result = window.location.search.substr(1).match(reg);
+        // 若匹配到结果则返回参数值，否则返回null
+        if (result!= null) return result[2]; return null;
+    }
 })(jQuery);
 
 // 从URL参数中获取userid和power（用户ID和权限等级）
@@ -18,228 +18,228 @@ var power=$.getData('power');
 // 页面DOM加载完成后执行的初始化函数
 $(document).ready(function(){
 // 设置用户头像的宽高相等（正方形）
-	var w=$("#userpic").width();
-  	$("#userpic").height(w);
-  	// 给隐藏输入框赋值userid（可能用于表单提交时传递用户ID）
-	$("#inputNone").attr("value",userid);
-	// 绑定"查看信息"按钮点击事件，切换标签页
-	$("#showInfo").click(function(){
-		changeTab();
-	});
-	// 绑定"修改信息"按钮点击事件，切换标签页
-	$("#showAlter").click(function(){
-		changeTab();
-	});
-	// 加载用户基本信息
-	getInfo();
-	// 加载用户薪资信息（根据权限判断是否显示）
-	getSalary();
-	// 绑定"确认修改信息"按钮点击事件，执行修改信息逻辑
-	$("#alterInfoBtn").click(function(){
-		alterInfo();
-	});
-	// 绑定"确认修改密码"按钮点击事件，执行修改密码逻辑
-	$("#alterPwdBtn").click(function(){
-		alterPwd();
-	})
+    var w=$("#userpic").width();
+    $("#userpic").height(w);
+    // 给隐藏输入框赋值userid（可能用于表单提交时传递用户ID）
+    $("#inputNone").attr("value",userid);
+    // 绑定"查看信息"按钮点击事件，切换标签页
+    $("#showInfo").click(function(){
+        changeTab();
+    });
+    // 绑定"修改信息"按钮点击事件，切换标签页
+    $("#showAlter").click(function(){
+        changeTab();
+    });
+    // 加载用户基本信息
+    getInfo();
+    // 加载用户薪资信息（根据权限判断是否显示）
+    getSalary();
+    // 绑定"确认修改信息"按钮点击事件，执行修改信息逻辑
+    $("#alterInfoBtn").click(function(){
+        alterInfo();
+    });
+    // 绑定"确认修改密码"按钮点击事件，执行修改密码逻辑
+    $("#alterPwdBtn").click(function(){
+        alterPwd();
+    })
 
 })
 
 //判断对象/JSON是否为空 空返回1 非空返回0
 function isEmptyObject(e) {
-	var t;
-	// 遍历对象，若存在属性则非空
-	for (t in e)
-		return 0;
-	return 1;
+    var t;
+    // 遍历对象，若存在属性则非空
+    for (t in e)
+        return 0;
+    return 1;
 }
 
 //判断字符串是否为空 空返回1 非空返回0
 function isEmptyString(str){
 // 若字符串为'null'或空字符串，视为空
-	if(str=='null'||str=='')
-		return 1;
-	return 0;
+    if(str=='null'||str=='')
+        return 1;
+    return 0;
 }
 
 // 切换标签页（切换"查看信息"和"修改信息"区域的显示状态）
 function changeTab(){
 // 获取两个区域当前的显示状态
-	var info=$("#showInfodiv").css("display");// 查看信息区域
-	var alter=$("#showAlterdiv").css("display"); // 修改信息区域
-		// 若查看区域显示，则隐藏查看区域，淡入显示修改区域
-	if(info=="block"){
-		$("#showInfodiv").css("display","none");
-		$("#showAlterdiv").fadeIn();
-	}
-	else{
-	// 否则隐藏修改区域，淡入显示查看区域
-		$("#showAlterdiv").css("display","none")
-		$("#showInfodiv").fadeIn();
-	}
+    var info=$("#showInfodiv").css("display");// 查看信息区域
+    var alter=$("#showAlterdiv").css("display"); // 修改信息区域
+    // 若查看区域显示，则隐藏查看区域，淡入显示修改区域
+    if(info=="block"){
+        $("#showInfodiv").css("display","none");
+        $("#showAlterdiv").fadeIn();
+    }
+    else{
+        // 否则隐藏修改区域，淡入显示查看区域
+        $("#showAlterdiv").css("display","none")
+        $("#showInfodiv").fadeIn();
+    }
 }
 // 全局变量，用于存储用户信息
 var info;
 // 从后端获取用户详情信息并展示
 function getInfo(){
-	$.ajax({
-		type:"POST", // 请求类型
-		url:"../user/getUserById.do",// 后端接口地址（根据用户ID获取信息）
-		dataType:"JSON",// 预期返回数据类型
-		data:{
-			"userid":userid   // 请求参数：用户ID
-		},
-		// 请求成功的回调函数
-		success:function(data){
-			if(data.code==0){// 后端返回成功状态（code=0）
-				info=data.user;// 存储用户信息到全局变量
-				var span=$("span");// 获取所有span标签
-				// 设置用户头像图片路径
-				$("#userpic").attr("src",'../'+info.photourl)
-				// 填充查看区域的用户信息（账号、身份证号、姓名、年龄、手机号）
-				span.filter("#account").text(info.useraccount);
-				span.filter("#idnum").text(info.idnumber);
-				span.filter("#name").text(info.username);
-				$("#inputName").val(info.username);
-				// 填充修改区域的输入框（默认显示当前信息）
-				span.filter("#age").text(info.age);
-				$("#inputAge").val(info.age)
-				span.filter("#phone").text(info.phonenumber);
-				$("#inputPhone").val(info.phonenumber)
-			}
-			else{
-				alert("获取信息失败");// 后端返回失败
-			}
-		},
-		// 请求失败的回调函数
-		error:function(){
-			alert("获取信息出现错误");
-		}
-	})
+    $.ajax({
+        type:"POST", // 请求类型
+        url:"../user/getUserById.do",// 后端接口地址（根据用户ID获取信息）
+        dataType:"JSON",// 预期返回数据类型
+        data:{
+            "userid":userid   // 请求参数：用户ID
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            if(data.code==0){// 后端返回成功状态（code=0）
+                info=data.user;// 存储用户信息到全局变量
+                var span=$("span");// 获取所有span标签
+                // 设置用户头像图片路径
+                $("#userpic").attr("src",'../'+info.photourl)
+                // 填充查看区域的用户信息（账号、身份证号、姓名、年龄、手机号）
+                span.filter("#account").text(info.useraccount);
+                span.filter("#idnum").text(info.idnumber);
+                span.filter("#name").text(info.username);
+                $("#inputName").val(info.username);
+                // 填充修改区域的输入框（默认显示当前信息）
+                span.filter("#age").text(info.age);
+                $("#inputAge").val(info.age)
+                span.filter("#phone").text(info.phonenumber);
+                $("#inputPhone").val(info.phonenumber)
+            }
+            else{
+                alert("获取信息失败");// 后端返回失败
+            }
+        },
+        // 请求失败的回调函数
+        error:function(){
+            alert("获取信息出现错误");
+        }
+    })
 }
 // 提交用户基本信息修改请求
 function alterInfo(){
 // 从输入框获取修改后的信息
-	var name=$("#inputName").val();
-	var age=$("#inputAge").val();
-	var phone=$("#inputPhone").val();
-	// 校验输入是否为空
-	if(isEmptyString(name) || isEmptyString(age) || isEmptyString(phone)){
-		alert("请填写全信息");
-	}
-	else{
-	// 输入完整，发起修改请求
-		$.ajax({
-			type:"POST",
-			url:"../user/updateUser.do",// 后端修改用户信息接口
-			dataType:"JSON",
-			data:{
-				"userid":userid, // 用户ID（不变）
-				"password":info.password, // 密码（不变，从原有信息获取）
-				"username":name,// 新姓名
-				"age":age, // 新年龄
-				"power":power,// 权限等级（不变）
-				"IDnumber":info.idnumber, // 身份证号（不变）
-				"phonenumber":phone // 新手机号
+    var name=$("#inputName").val();
+    var age=$("#inputAge").val();
+    var phone=$("#inputPhone").val();
+    // 校验输入是否为空
+    if(isEmptyString(name) || isEmptyString(age) || isEmptyString(phone)){
+        alert("请填写全信息");
+    }
+    else{
+        // 输入完整，发起修改请求
+        $.ajax({
+            type:"POST",
+            url:"../user/updateUser.do",// 后端修改用户信息接口
+            dataType:"JSON",
+            data:{
+                "userid":userid, // 用户ID（不变）
+                "password":info.password, // 密码（不变，从原有信息获取）
+                "username":name,// 新姓名
+                "age":age, // 新年龄
+                "power":power,// 权限等级（不变）
+                "IDnumber":info.idnumber, // 身份证号（不变）
+                "phonenumber":phone // 新手机号
 
-			},
-			success:function(data){
-				if(data.code==0){
-					alert("修改成功");
-					window.location.reload();// 刷新页面加载最新信息
-				}
-				else
-					alert("修改失败")
-			},
-			error:function(){
-				alert("修改信息出现错误");
-			}
-		})
-	}
+            },
+            success:function(data){
+                if(data.code==0){
+                    alert("修改成功");
+                    window.location.reload();// 刷新页面加载最新信息
+                }
+                else
+                    alert("修改失败")
+            },
+            error:function(){
+                alert("修改信息出现错误");
+            }
+        })
+    }
 }
 // 提交密码修改请求
 function alterPwd(){
 // 从输入框获取密码信息
-	var oldPwd=$("#inputoldPwd").val();// 原密码
-	var newPwd=$("#inputnewPwd").val(); // 新密码
-	var renewPwd=$("#inputrenewPwd").val();  // 确认新密码
-	if(isEmptyString(oldPwd) || isEmptyString(newPwd) || isEmptyString(renewPwd)){
-		alert("请填写全信息");
-	}
-	// 校验原密码是否正确（与原有信息比对）
-	else if(oldPwd!=info.password)
-		alert("原密码不正确");
-		// 校验新密码两次输入是否一致
-	else if(newPwd!=renewPwd)
-		alert("新密码输入错误")
-	else{
-	// 校验通过，发起密码修改请求
-		$.ajax({
-			type:"POST",
-			url:"../user/updateUser.do",// 后端修改用户信息接口（复用）
-			dataType:"JSON",
-			data:{
-				"userid":userid,// 用户ID
-				"password":newPwd // 新密码
+    var oldPwd=$("#inputoldPwd").val();// 原密码
+    var newPwd=$("#inputnewPwd").val(); // 新密码
+    var renewPwd=$("#inputrenewPwd").val();  // 确认新密码
+    if(isEmptyString(oldPwd) || isEmptyString(newPwd) || isEmptyString(renewPwd)){
+        alert("请填写全信息");
+    }
+    // 校验原密码是否正确（与原有信息比对）
+    else if(oldPwd!=info.password)
+        alert("原密码不正确");
+    // 校验新密码两次输入是否一致
+    else if(newPwd!=renewPwd)
+        alert("新密码输入错误")
+    else{
+        // 校验通过，发起密码修改请求
+        $.ajax({
+            type:"POST",
+            url:"../user/updateUser.do",// 后端修改用户信息接口（复用）
+            dataType:"JSON",
+            data:{
+                "userid":userid,// 用户ID
+                "password":newPwd // 新密码
 
-			},
-			success:function(data){
-				if(data.code==0){
-					alert("修改成功");
-					window.location.reload(); // 刷新页面
-				}
-				else
-					alert("修改失败")
-			},
-			error:function(){
-				alert("修改密码出现错误");
-			}
-		})
-	}
+            },
+            success:function(data){
+                if(data.code==0){
+                    alert("修改成功");
+                    window.location.reload(); // 刷新页面
+                }
+                else
+                    alert("修改失败")
+            },
+            error:function(){
+                alert("修改密码出现错误");
+            }
+        })
+    }
 }
 
 // 获取并展示用户薪资信息（根据权限判断是否显示）
 function getSalary(){
 // 若权限不为"0"（假设0为非员工/游客，1/2/3为不同角色），则显示薪资区域
-	if(power!="0"){
-		$("#showS").css("display","block");// 显示薪资标签
-		$("#showC").css("display","block");// 显示提成标签
+    if(power!="0"){
+        $("#showS").css("display","block");// 显示薪资标签
+        $("#showC").css("display","block");// 显示提成标签
 
-		// 从后端获取薪资配置信息
-		$.ajax({
-			type:"POST",
-			url:"../config/getConfig.do",// 后端获取配置接口
-			dataType:"JSON",
-			data:{},// 无参数
-			success:function(data){
-				if(data.code=="0"){// 配置获取成功
-					var config=data.config;// 薪资配置信息
+        // 从后端获取薪资配置信息
+        $.ajax({
+            type:"POST",
+            url:"../config/getConfig.do",// 后端获取配置接口
+            dataType:"JSON",
+            data:{},// 无参数
+            success:function(data){
+                if(data.code=="0"){// 配置获取成功
+                    var config=data.config;// 薪资配置信息
 
-					// 根据权限等级显示对应角色的薪资和提成比例
-					if(power=="1"){ // 假设1为经理
-						$("#salary").text(config.manage); // 经理基础薪资
-						$("#commission").text(config.managesalary+"%");// 经理提成比例
-					}
-					else if(power=="2"){// 假设2为员工
+                    // 根据权限等级显示对应角色的薪资和提成比例
+                    if(power=="1"){ // 假设1为经理
+                        $("#salary").text(config.manage); // 经理基础薪资
+                        $("#commission").text(config.managesalary+"%");// 经理提成比例
+                    }
+                    else if(power=="2"){// 假设2为员工
 
-						$("#salary").text(config.staff);// 员工基础薪资
-						$("#commission").text(config.staffsalary+"%");// 员工提成比例
-					}
-					else{ // 其他权限（假设为清洁工）
-						$("#salary").text(config.cleaner); // 清洁工基础薪资
-						$("#commission").text(config.cleanerssalary+"%");// 清洁工提成比例
-					}
+                        $("#salary").text(config.staff);// 员工基础薪资
+                        $("#commission").text(config.staffsalary+"%");// 员工提成比例
+                    }
+                    else{ // 其他权限（假设为清洁工）
+                        $("#salary").text(config.cleaner); // 清洁工基础薪资
+                        $("#commission").text(config.cleanerssalary+"%");// 清洁工提成比例
+                    }
 
-				}
-				else{
-					alert("获取配置错误");
-				}
+                }
+                else{
+                    alert("获取配置错误");
+                }
 
-			},
-			error:function(){
-				alert("获取配置发生错误")
-			}
+            },
+            error:function(){
+                alert("获取配置发生错误")
+            }
 
-		});
-	}
+        });
+    }
 }

src/main/resources/static/js/cleaner_room.js

@@ -4,146 +4,146 @@ var l;
 
 // 页面DOM加载完成后执行初始化操作
 $(document).ready(function(){
-	getroomList();
-	$("#pre").on('click',function(){
-		getPre();
-	});
-	$("#next").on('click',function(){
-		getNext();
-	});
+    getroomList();
+    $("#pre").on('click',function(){
+        getPre();
+    });
+    $("#next").on('click',function(){
+        getNext();
+    });
 
 })
 
 //判断对象/JSON是否为空 空返回1 非空返回0
 function isEmptyObject(e) {
-	var t;
-	for (t in e)
-		return 0;
-	return 1;
+    var t;
+    for (t in e)
+        return 0;
+    return 1;
 }
 
 
 var list;
 // 从后端获取房间列表并展示
 function getroomList(){
-	$.ajax({
-		type:"post",
-		url:"../room/getRoom.do",
-		dataType:"JSON",
-		data:{
-			"state":"3",
-			"type":"-1",
-			"pageNum":pageNum,
-			"pageSize":pageSize			
-		},
-		// 请求成功的回调函数
-		success:function(data){
-		// 若当前页无数据且页码大于0，回退到上一页并重新加载
-			if(isEmptyObject(data.List)&&pageNum>0){
-				pageNum=pageNum-1;
-				getroomList();
-			}
-			else{
-			// 存储房间列表数据
-				list=data.List;
-				var power=" ";
-				var htmlStr=" ";
-				var btnStr=" ";
-				var state=" ";
-				var type=" ";
-				l=0;
-				// 默认显示上一页、下一页按钮
-				$("#pre").css("display","block");
-				$("#next").css("display","block");
-				$("#roomList").empty();
-				$("#roomList").append("<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>");
-				state="未清扫";
-				 // 遍历房间列表，拼接表格内容
-				for(i in list){		
-					if(list[i].type=="1")
-						type="单人间";
-					else if(list[i].type=="2")
-						type="双人间";
-					else if(list[i].type=="3")
-						type="大床房";
-					else
-						type="套房"
-					btnStr="<input type=\"button\"  class=\"btn btn-success\" data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"已清扫\">";
-					htmlStr="<tr data-roomid=\""+list[i].roomid+"\"><td>"+list[i].local+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+type+"</td><td>"+btnStr+"</td></tr>";
-					$("#roomList").append(htmlStr);
-					l++;
-				}
-				if(pageNum=="1") $("#pre").css("display","none");
-				if(pageSize>l) $("#next").css("display","none");
-				btnOn();
-			}
+    $.ajax({
+        type:"post",
+        url:"../room/getRoom.do",
+        dataType:"JSON",
+        data:{
+            "state":"3",
+            "type":"-1",
+            "pageNum":pageNum,
+            "pageSize":pageSize
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            // 若当前页无数据且页码大于0，回退到上一页并重新加载
+            if(isEmptyObject(data.List)&&pageNum>0){
+                pageNum=pageNum-1;
+                getroomList();
+            }
+            else{
+                // 存储房间列表数据
+                list=data.List;
+                var power=" ";
+                var htmlStr=" ";
+                var btnStr=" ";
+                var state=" ";
+                var type=" ";
+                l=0;
+                // 默认显示上一页、下一页按钮
+                $("#pre").css("display","block");
+                $("#next").css("display","block");
+                $("#roomList").empty();
+                $("#roomList").append("<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>");
+                state="未清扫";
+                // 遍历房间列表，拼接表格内容
+                for(i in list){
+                    if(list[i].type=="1")
+                        type="单人间";
+                    else if(list[i].type=="2")
+                        type="双人间";
+                    else if(list[i].type=="3")
+                        type="大床房";
+                    else
+                        type="套房"
+                    btnStr="<input type=\"button\"  class=\"btn btn-success\" data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"已清扫\">";
+                    htmlStr="<tr data-roomid=\""+list[i].roomid+"\"><td>"+list[i].local+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+type+"</td><td>"+btnStr+"</td></tr>";
+                    $("#roomList").append(htmlStr);
+                    l++;
+                }
+                if(pageNum=="1") $("#pre").css("display","none");
+                if(pageSize>l) $("#next").css("display","none");
+                btnOn();
+            }
 
-		},
-		// 请求失败的回调函数
-		error:function(){
-			alert("获取房间列表发生错误")
-		}
-	})
+        },
+        // 请求失败的回调函数
+        error:function(){
+            alert("获取房间列表发生错误")
+        }
+    })
 }
 
 // 绑定页面中操作按钮的点击事件
 function btnOn(){;
-	$("input").filter("#setPageBtn").on('click',function( ){
-		setPage( );
-	});
-	$("input").filter("#setRoom").on('click',function(event ){
-		setRoom(event);
-	});
+    $("input").filter("#setPageBtn").on('click',function( ){
+        setPage( );
+    });
+    $("input").filter("#setRoom").on('click',function(event ){
+        setRoom(event);
+    });
 }
 
 // 修改房间状态为"已清扫"
 function setRoom(event){
-	var roomid=$(event.target).data("roomid");
-	$.ajax({
-		type:"POST",
-		url:"../room/updateRoom.do",
-		dataType:"JSON",
-		data:{
-			"roomid":roomid,
-			"state":"1"
-		},
-		// 请求成功的回调函数
-		success:function(data){
-			if(data.code==0){
-				alert("修改成功");
-				getroomList();
-			}
-			else{
-				alert("修改失败");
-				getroomList();
-			}
-		},
-		error:function(){
-			alert("修改信息出现错误");
-		}
-	})
+    var roomid=$(event.target).data("roomid");
+    $.ajax({
+        type:"POST",
+        url:"../room/updateRoom.do",
+        dataType:"JSON",
+        data:{
+            "roomid":roomid,
+            "state":"1"
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            if(data.code==0){
+                alert("修改成功");
+                getroomList();
+            }
+            else{
+                alert("修改失败");
+                getroomList();
+            }
+        },
+        error:function(){
+            alert("修改信息出现错误");
+        }
+    })
 }
 
 // 加载上一页数据
 function getPre(){
-	pageNum=pageNum-1;
-	getroomList();
+    pageNum=pageNum-1;
+    getroomList();
 }
 
 // 加载下一页数据
 function getNext(){
-	pageNum=pageNum+1;
-	getroomList();	
+    pageNum=pageNum+1;
+    getroomList();
 }
 
 // 跳转到指定页码
 function setPage(){
-	if($("#inputPage").val()<0 || $("#inputPage").val()==0)
-		alert("请输入正确页码");
-	else{
-		pageNum=$("#inputPage").val();
-		getroomList();
-	}
-	
+    if($("#inputPage").val()<0 || $("#inputPage").val()==0)
+        alert("请输入正确页码");
+    else{
+        pageNum=$("#inputPage").val();
+        getroomList();
+    }
+
 }
 

src/main/resources/static/js/index.js

@@ -1,51 +1,51 @@
 // 页面DOM加载完成后执行初始化操作
 $(document).ready(function(){
-	getCode();
-	var h=$(window).height();
-	$("#main").css("height",h);
-	$("#loginBtn").click(function(){
-		login();
-	})
-	$("#code").click(function(){
-		getCode();
-	})
+    getCode();
+    var h=$(window).height();
+    $("#main").css("height",h);
+    $("#loginBtn").click(function(){
+        login();
+    })
+    $("#code").click(function(){
+        getCode();
+    })
 })
 
 
 //获取验证码
 function getCode(){
-	$("#code").attr("src","./user/createImage?code="+Math.random());
+    $("#code").attr("src","./user/createImage?code="+Math.random());
 }
 
 //登录
 function login(){
-	var user=$("#inputName").val();
-	var pwd=$("#inputPassword").val();
-	var code=$("#inputCode").val();
-	// 发起AJAX登录请求
-	$.ajax({
-		type:"POST",
-		url:"./user/login.do",
-		dataType:"JSON",
-		data:{
-			"useraccount":user,
-			"password":pwd,
-			"icode":code
-		},
-		// 请求成功的回调函数（后端返回数据后执行）
-		success:function(data){
-			console.log(data)
-			if(data.code=="0"){
-				var urlString="pages/myCenter.html?power="+data.power+"&userid="+data.userid;
-				window.location.href=urlString;
-			}
-			else if(data.code=="-1"){
-				alert("验证码或密码错误")
-			}
-		},
-		// 请求失败的回调函数（网络错误或接口异常时执行）
-		error:function(){
-			alert("登录 发生错误");
-		}
-	});
+    var user=$("#inputName").val();
+    var pwd=$("#inputPassword").val();
+    var code=$("#inputCode").val();
+    // 发起AJAX登录请求
+    $.ajax({
+        type:"POST",
+        url:"./user/login.do",
+        dataType:"JSON",
+        data:{
+            "useraccount":user,
+            "password":pwd,
+            "icode":code
+        },
+        // 请求成功的回调函数（后端返回数据后执行）
+        success:function(data){
+            console.log(data)
+            if(data.code=="0"){
+                var urlString="pages/myCenter.html?power="+data.power+"&userid="+data.userid;
+                window.location.href=urlString;
+            }
+            else if(data.code=="-1"){
+                alert("验证码或密码错误")
+            }
+        },
+        // 请求失败的回调函数（网络错误或接口异常时执行）
+        error:function(){
+            alert("登录 发生错误");
+        }
+    });
 }

src/main/resources/static/js/jquery-form.js

@@ -9,7 +9,7 @@
  * https://github.com/malsup/form#copyright-and-license
  */
 /*global ActiveXObject */
-
+//简化了AJAX表单提交，处理了文件上传、数据序列化、进度跟踪等复杂问题
 // AMD support
 (function (factory) {
     "use strict";

src/main/resources/static/js/manage_room.js

@@ -1,299 +1,306 @@
-var pageNum=1;
-var pageSize=8;
-var l;
+/**
+ * 酒店客房管理系统前端JavaScript代码
+ * 功能：房间列表展示、分页、增删改查操作
+ */
+
+var pageNum=1;// 当前页码，默认为1
+var pageSize=8; // 每页显示的房间数量
+var l;// 当前页实际显示的房间数量
 
 // 页面DOM加载完成后执行初始化操作
 $(document).ready(function(){
-	getroomList();
-	$("#pre").on('click',function(){
-		getPre();
-	});
-	$("#next").on('click',function(){
-		getNext();
-	});
-	$("input").filter("#setRoomBtn").on('click',function( ){
-		setRoomajax( );
-	});
+    getroomList(); // 首次加载时获取房间列表
+    // 绑定事件监听器
+    $("#pre").on('click',function(){// 上一页按钮点击事件
+        getPre();
+    });
+    $("#next").on('click',function(){// 下一页按钮点击事件
+        getNext();
+    });
+    $("input").filter("#setRoomBtn").on('click',function( ){// 修改房间信息按钮
+        setRoomajax( );
+    });
 
-	$("input").filter("#addRoomBtn").on('click',function(){
-		addRoom();
-	});
+    $("input").filter("#addRoomBtn").on('click',function(){// 添加房间按钮
+        addRoom();
+    });
 
 
 })
 
 //判断对象/JSON是否为空 空返回1 非空返回0
 function isEmptyObject(e) {
-	var t;
-	for (t in e)
-		return 0;
-	return 1;
+    var t;
+    for (t in e)// 遍历对象属性
+        return 0;// 如果有属性，返回0（非空）
+    return 1;// 没有属性，返回1（空）
 }
 
 //判断字符串是否为空 空返回1 非空返回0
 function isEmptyString(str){
-	if(str=='null'||str=='')
-		return 1;
-	return 0;
+    if(str=='null'||str=='')
+        return 1;
+    return 0;
 }
 
 
 
-var list;
+var list;// 存储当前页的房间列表数据
 // 从后端获取房间列表并展示
 function getroomList(){
-	$.ajax({
-		type:"post",
-		url:"../room/getRoom.do",
-		dataType:"JSON",
-		data:{
-			"state":"-1",
-			"type":"-1",
-			"pageNum":pageNum,
-			"pageSize":pageSize		
-		},
-		// 请求成功的回调函数
-		success:function(data){
-			if(isEmptyObject(data.List)&&pageNum>0){
-				pageNum=pageNum-1;
-				getroomList();
-			}
-			else{
-				list=data.List;
-				var power=" ";
-				var htmlStr=" ";
-				var btnStr=" ";
-				var state=" ";
-				var type=" ";
-				l=0;
-				 // 默认显示上一页、下一页按钮
-				$("#pre").css("display","block");
-				$("#next").css("display","block");
-				$("#roomList").empty();
-				$("#roomList").append("<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>")
-				// 遍历房间列表，生成表格内容
-				for(i in list){
-					if(list[i].state=="0"){
-						state="停用";
-						btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"setStart\" value=\"开始使用\"> <input type=\"button\" class=\"btn btn-success\"  data-toggle=\"modal\" data-target=\"#alterRoom\"  data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"修改信息\"> <input type=\"button\" class=\"btn btn-danger\" data-roomid=\""+list[i].roomid+"\" value=\"删除\" id=\"delRoom\">";
-					}
-					else if(list[i].state=="1"){
-						state="未预定";
-						btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"setStop\" value=\"改为停用\"> <input type=\"button\" class=\"btn btn-success\"  data-toggle=\"modal\" data-target=\"#alterRoom\"  data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"修改信息\"> <input type=\"button\" class=\"btn btn-danger\" data-roomid=\""+list[i].roomid+"\" value=\"删除\" id=\"delRoom\">";
-					}
-					else if(list[i].state=="2"){
-						state="已预定(入住)";
-						btnStr="<input type=\"button\" class=\"btn btn-success\"  data-toggle=\"modal\" data-target=\"#alterRoom\"  data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"修改信息\">";
-					}
-					else{
-						state="待清扫";
-						btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"setStop\" value=\"改为停用\"> <input type=\"button\" class=\"btn btn-success\"  data-toggle=\"modal\" data-target=\"#alterRoom\"  data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"修改信息\"> <input type=\"button\" class=\"btn btn-danger\" data-roomid=\""+list[i].roomid+"\" value=\"删除\" id=\"delRoom\">";
-					}
-					// 根据房间类型编码转换为文本
+    $.ajax({
+        type:"post",
+        url:"../room/getRoom.do",// 后端API地址
+        dataType:"JSON", // 期望返回数据类型：JSON
+        data:{// 请求参数
+            "state":"-1",// -1表示查询所有状态
+            "type":"-1", // -1表示查询所有类型
+            "pageNum":pageNum,// 当前页码
+            "pageSize":pageSize// 每页数量
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            // 如果返回数据为空且页码大于0，则回退一页
+            if(isEmptyObject(data.List)&&pageNum>0){
+                pageNum=pageNum-1;
+                getroomList(); // 重新获取数据
+            }
+            else{
+                list=data.List; // 保存房间列表数据
+                var power=" ";// 用于拼接HTML表格内容
+                var htmlStr=" "; // 操作按钮HTML
+                var btnStr=" ";
+                var state=" ";
+                var type=" ";
+                l=0;
+                // 默认显示上一页、下一页按钮
+                $("#pre").css("display","block");
+                $("#next").css("display","block");
+                $("#roomList").empty();
+                $("#roomList").append("<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>")
+                // 遍历房间列表，生成表格内容
+                for(i in list){
+                    if(list[i].state=="0"){
+                        state="停用";
+                        btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"setStart\" value=\"开始使用\"> <input type=\"button\" class=\"btn btn-success\"  data-toggle=\"modal\" data-target=\"#alterRoom\"  data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"修改信息\"> <input type=\"button\" class=\"btn btn-danger\" data-roomid=\""+list[i].roomid+"\" value=\"删除\" id=\"delRoom\">";
+                    }
+                    else if(list[i].state=="1"){
+                        state="未预定";
+                        btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"setStop\" value=\"改为停用\"> <input type=\"button\" class=\"btn btn-success\"  data-toggle=\"modal\" data-target=\"#alterRoom\"  data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"修改信息\"> <input type=\"button\" class=\"btn btn-danger\" data-roomid=\""+list[i].roomid+"\" value=\"删除\" id=\"delRoom\">";
+                    }
+                    else if(list[i].state=="2"){
+                        state="已预定(入住)";
+                        btnStr="<input type=\"button\" class=\"btn btn-success\"  data-toggle=\"modal\" data-target=\"#alterRoom\"  data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"修改信息\">";
+                    }
+                    else{
+                        state="待清扫";
+                        btnStr="<input type=\"button\" class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"setStop\" value=\"改为停用\"> <input type=\"button\" class=\"btn btn-success\"  data-toggle=\"modal\" data-target=\"#alterRoom\"  data-roomid=\""+list[i].roomid+"\" id=\"setRoom\" value=\"修改信息\"> <input type=\"button\" class=\"btn btn-danger\" data-roomid=\""+list[i].roomid+"\" value=\"删除\" id=\"delRoom\">";
+                    }
+                    // 根据房间类型编码转换为文本
 
-					if(list[i].type=="1")
-						type="单人间";
-					else if(list[i].type=="2")
-						type="双人间";
-					else if(list[i].type=="3")
-						type="大床房";
-					else
-						type="套房"
-						// 拼接表格行（包含房间信息和操作按钮）
+                    if(list[i].type=="1")
+                        type="单人间";
+                    else if(list[i].type=="2")
+                        type="双人间";
+                    else if(list[i].type=="3")
+                        type="大床房";
+                    else
+                        type="套房"
+                    // 拼接表格行（包含房间信息和操作按钮）
 
-					htmlStr="<tr data-roomid=\""+list[i].roomid+"\"><td>"+list[i].local+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+type+"</td><td>"+btnStr+"</td></tr>";
-					$("#roomList").append(htmlStr);
-					l++;
-				}
-				if(pageNum=="1") $("#pre").css("display","none");
-				if(pageSize>l) $("#next").css("display","none");
-				btnOn();
-			}
+                    htmlStr="<tr data-roomid=\""+list[i].roomid+"\"><td>"+list[i].local+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+type+"</td><td>"+btnStr+"</td></tr>";
+                    $("#roomList").append(htmlStr);
+                    l++;
+                }
+                if(pageNum=="1") $("#pre").css("display","none");
+                if(pageSize>l) $("#next").css("display","none");
+                btnOn();
+            }
 
-		},
-		// 请求失败的回调函数
-		error:function(){
-			alert("获取房间列表发生错误")
-		}
-	})
+        },
+        // 请求失败的回调函数
+        error:function(){
+            alert("获取房间列表发生错误")
+        }
+    })
 }
 
 // 绑定页面中所有操作按钮的点击事件
 function btnOn(){
-	$("input").filter("#delRoom").on('click',function(event){
-		delRoom(event);
-	});
-	$("input").filter("#setPageBtn").on('click',function( ){
-		setPage( );
-	})
-	$("input").filter("#setStop").on('click',function(event){
-		setState(event,"0");
-	});
-	$("input").filter("#setStart").on('click',function(event){
-		setState(event,"1");
-	});
-	$("input").filter("#setRoom").on('click',function(event){
-		setRoom(event);
-	});
+    $("input").filter("#delRoom").on('click',function(event){
+        delRoom(event);
+    });
+    $("input").filter("#setPageBtn").on('click',function( ){
+        setPage( );
+    })
+    $("input").filter("#setStop").on('click',function(event){
+        setState(event,"0");
+    });
+    $("input").filter("#setStart").on('click',function(event){
+        setState(event,"1");
+    });
+    $("input").filter("#setRoom").on('click',function(event){
+        setRoom(event);
+    });
 
 }
 // 加载上一页数据
 function getPre(){
-	pageNum=pageNum-1;
-	getroomList();
+    pageNum=pageNum-1;
+    getroomList();
 }
 // 加载下一页数据
 function getNext(){
-	pageNum=pageNum+1;
-	getroomList();	
+    pageNum=pageNum+1;
+    getroomList();
 }
 // 填充房间修改表单（将当前房间信息显示到修改弹窗中）
 function setRoom(event){
-	var roomid=$(event.target).data("roomid");
-	var info;
-	for(i in list){
-		if(list[i].roomid==roomid){
-			info=list[i];
-		}
-	}
-	// 将房间信息填充到修改表单的输入框中
-	$("#reinputLocal").val(info.local);
-	$("#reinputPrice").val(info.money);
-	$("#reinputType").val(info.type);
-	$("#reinputid").val(roomid);
+    var roomid=$(event.target).data("roomid");
+    var info;
+    for(i in list){
+        if(list[i].roomid==roomid){
+            info=list[i];
+        }
+    }
+    // 将房间信息填充到修改表单的输入框中
+    $("#reinputLocal").val(info.local);
+    $("#reinputPrice").val(info.money);
+    $("#reinputType").val(info.type);
+    $("#reinputid").val(roomid);
 }
 // 提交房间信息修改请求（AJAX）
 function setRoomajax( ){
-	$.ajax({
-		type:"POST",
-		url:"../room/updateRoom.do",
-		dataType:"JSON",
-		data:{
-			"roomid":$("#reinputid").val(),
-			"money":$("#reinputPrice").val(),
-			"type":$("#reinputType").val(),
-			"local":$("#reinputLocal").val()
-		},
-		// 请求成功的回调函数
-		success:function(data){
-			if(data.code==0){
-				alert("修改成功");
-				$("#reinputLocal").val("");
-				$("#reinputPrice").val("");
-				$("#reinputType").val("");
-				$("#reinputid").val("");
-				$('#alterRoom').modal('toggle');
-				 // 无论成功与否，重新加载房间列表展示最新数据
-				getroomList();
-			}
-			else{
-				alert("修改失败");
-				getroomList();
-			}
-		},
-		error:function(){
-			alert("修改信息出现错误");
-		}
-	})
+    $.ajax({
+        type:"POST",
+        url:"../room/updateRoom.do",
+        dataType:"JSON",
+        data:{
+            "roomid":$("#reinputid").val(),
+            "money":$("#reinputPrice").val(),
+            "type":$("#reinputType").val(),
+            "local":$("#reinputLocal").val()
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            if(data.code==0){
+                alert("修改成功");
+                $("#reinputLocal").val("");
+                $("#reinputPrice").val("");
+                $("#reinputType").val("");
+                $("#reinputid").val("");
+                $('#alterRoom').modal('toggle');
+                // 无论成功与否，重新加载房间列表展示最新数据
+                getroomList();
+            }
+            else{
+                alert("修改失败");
+                getroomList();
+            }
+        },
+        error:function(){
+            alert("修改信息出现错误");
+        }
+    })
 }
 // 修改房间状态（启用/停用）
 function setState(event,alter){
-	var roomid=$(event.target).data("roomid");
-	$.ajax({
-		type:"POST",
-		url:"../room/updateRoom.do",
-		dataType:"JSON",
-		data:{
-			"roomid":roomid,
-			"state":alter
-		},
-		 // 请求成功的回调函数
-		success:function(data){
-			if(data.code==0){
-				alert("修改成功");
-				// 重新加载房间列表展示最新状态
-				getroomList();
-			}
-			else
-				alert("修改失败")
-		},
-		error:function(){
-			alert("修改信息出现错误");
-		}
-	})
+    var roomid=$(event.target).data("roomid");
+    $.ajax({
+        type:"POST",
+        url:"../room/updateRoom.do",
+        dataType:"JSON",
+        data:{
+            "roomid":roomid,
+            "state":alter
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            if(data.code==0){
+                alert("修改成功");
+                // 重新加载房间列表展示最新状态
+                getroomList();
+            }
+            else
+                alert("修改失败")
+        },
+        error:function(){
+            alert("修改信息出现错误");
+        }
+    })
 }
 // 跳转到指定页码
 function setPage(){
-	// 校验输入的页码是否合法（必须大于0）
-	if($("#inputPage").val()<0 || $("#inputPage").val()==0)
-		alert("请输入正确页码");
-	else{
-		pageNum=$("#inputPage").val();
-		getroomList();
-	}
-	
+    // 校验输入的页码是否合法（必须大于0）
+    if($("#inputPage").val()<0 || $("#inputPage").val()==0)
+        alert("请输入正确页码");
+    else{
+        pageNum=$("#inputPage").val();
+        getroomList();
+    }
+
 }
 
 // 删除房间
 function delRoom(event){
-	var roomid=$(event.target).data("roomid");
-	$.ajax({
-		type:"POST",
-		url:"../room/delRoom.do",
-		dataType:"JSON",
-		data:{
-			"roomid":roomid
-		},
-		// 请求成功的回调函数
-		success:function(data){
-				if(data.code==0){
-					alert("删除成功");
-				if(l==1)
-					pageNum=pageNum-1;
-				getroomList();
-			}
-			else
-				alert("删除失败")
-		},
-		error:function(){
-			alert("删除出现错误");
-		}
-	})
+    var roomid=$(event.target).data("roomid");
+    $.ajax({
+        type:"POST",
+        url:"../room/delRoom.do",
+        dataType:"JSON",
+        data:{
+            "roomid":roomid
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            if(data.code==0){
+                alert("删除成功");
+                if(l==1)
+                    pageNum=pageNum-1;
+                getroomList();
+            }
+            else
+                alert("删除失败")
+        },
+        error:function(){
+            alert("删除出现错误");
+        }
+    })
 
 }
 // 添加新房间
 function addRoom(){
-	if(isEmptyString($("#inputLocal").val())||isEmptyString($("#inputLocal").val())||isEmptyString($("#inputType").val()))
-		alert("请填写全内容");
-	else{
-		$.ajax({ 
-			type:"POST",
-			url:"../room/addRoom.do",
-			dataType:"JSON",
-			data:{
-				"local":$("#inputLocal").val(),
-				"money":$("#inputPrice").val(),
-				"state":"1",
-				"type":$("#inputType").val()
-			},
-			success:function(data){
-				if(data.code==0){
-					alert("添加成功");
-					$('#addRoom').modal('toggle');
-					$("#inputLocal").val(" ");
-					$("#inputPrice").val(" ");
-					$("#inputType").val(" ");
-					getroomList();
-				}
-				else{
-					alert("添加失败");
-					window.location.reload();
-				}
-			},
-			error:function(){
-				alert("添加出现错误");
-			}
-		})
-	}
-	
+    if(isEmptyString($("#inputLocal").val())||isEmptyString($("#inputLocal").val())||isEmptyString($("#inputType").val()))
+        alert("请填写全内容");
+    else{
+        $.ajax({
+            type:"POST",
+            url:"../room/addRoom.do",
+            dataType:"JSON",
+            data:{
+                "local":$("#inputLocal").val(),
+                "money":$("#inputPrice").val(),
+                "state":"1",
+                "type":$("#inputType").val()
+            },
+            success:function(data){
+                if(data.code==0){
+                    alert("添加成功");
+                    $('#addRoom').modal('toggle');
+                    $("#inputLocal").val(" ");
+                    $("#inputPrice").val(" ");
+                    $("#inputType").val(" ");
+                    getroomList();
+                }
+                else{
+                    alert("添加失败");
+                    window.location.reload();
+                }
+            },
+            error:function(){
+                alert("添加出现错误");
+            }
+        })
+    }
+
 }

src/main/resources/static/js/manage_staff.js

@@ -3,32 +3,32 @@ var pageSize=8;
 var l;
 // 页面DOM加载完成后执行初始化操作
 $(document).ready(function(){
-	getStaffList();
-	$("#pre").on('click',function(){
-		getPre();
-	});
-	$("#next").on('click',function(){
-		getNext();
-	});
-	$("#addUserBtn").on('click',function(){
-		addUser();
-	})
+    getStaffList();
+    $("#pre").on('click',function(){
+        getPre();
+    });
+    $("#next").on('click',function(){
+        getNext();
+    });
+    $("#addUserBtn").on('click',function(){//添加员工按钮点击事件
+        addUser();
+    })
 
 })
 
 //判断对象/JSON是否为空 空返回1 非空返回0
 function isEmptyObject(e) {
-	var t;
-	for (t in e)
-		return 0;
-	return 1;
+    var t;
+    for (t in e)
+        return 0;
+    return 1;
 }
 
 //判断字符串是否为空 空返回1 非空返回0
 function isEmptyString(str){
-	if(str=='null'||str=='')
-		return 1;
-	return 0;
+    if(str=='null'||str=='')
+        return 1;
+    return 0;
 }
 
 
@@ -36,147 +36,153 @@ function isEmptyString(str){
 var list;
 // 从后端获取员工列表并展示
 function getStaffList(){
-	$.ajax({
-		type:"post",
-		url:"../user/getUserByPower.do",
-		dataType:"JSON",
-		data:{
-			"pageNum":pageNum,
-			"pageSize":pageSize,
-			"power":"2"
-		},
-		success:function(data){
-		// 后端返回成功状态（code=0）
-			if(data.code=="0"){
-			// 若当前页无数据且页码大于0，回退到上一页并重新加载
-				if(isEmptyObject(data.List)&&pageNum>0){
-					pageNum=pageNum-1;
-					getStaffList();
-				}
-				else{
-					var power=" ";
-					var htmlStr=" ";
-					var btnStr=" ";
-					list=data.List;
-					l=0;
-					// 默认显示上一页、下一页按钮
-					$("#pre").css("display","block");
-					$("#next").css("display","block");
-					$("#staffList").empty();
-					$("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
-					 // 遍历员工列表，生成表格内容
-					for(i in list){
-						btnStr="<input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
-						htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+"员工"+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
-						$("#staffList").append(htmlStr);
-						//console.log(htmlStr);
-						l++;
-					}
-					 // 若当前是第1页，隐藏"上一页"按钮
-					if(pageNum=="1") $("#pre").css("display","none");
-					if(pageSize>l) $("#next").css("display","none");
-					btnOn();
-				}
-			}
-			else{
-				alert("获取员工列表失败");
-			}
-			
+    $.ajax({
+        type:"post",
+        url:"../user/getUserByPower.do",
+        dataType:"JSON",
+        data:{
+            "pageNum":pageNum,
+            "pageSize":pageSize,
+            "power":"2"
+        },
+        success:function(data){
+            // 后端返回成功状态（code=0）
+            if(data.code=="0"){
+                // 若当前页无数据且页码大于0，回退到上一页并重新加载
+                if(isEmptyObject(data.List)&&pageNum>0){
+                    pageNum=pageNum-1;
+                    getStaffList();
+                }
+                else{
+                    var power=" ";
+                    var htmlStr=" ";
+                    var btnStr=" ";
+                    list=data.List;//// 保存员工列表数据
+                    l=0; // 重置计数器
+                    // 默认显示上一页、下一页按钮
+                    $("#pre").css("display","block");
+                    $("#next").css("display","block");
+                    //清空表格并添加表头
+                    $("#staffList").empty();
+                    $("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
+                    // 遍历员工列表，生成表格内容
+                    for(i in list){
+                        //生成删除按钮HTML
+                        btnStr="<input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
+                        //凭借表格行HTML
+                        htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+"员工"+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
+                        //将行添加到表格中
+                        $("#staffList").append(htmlStr);
+                        //console.log(htmlStr);
+                        l++;
+                    }
+                    // 若当前是第1页，隐藏"上一页"按钮
+                    if(pageNum=="1") $("#pre").css("display","none");
+                    if(pageSize>l) $("#next").css("display","none");
+                    btnOn();
+                }
+            }
+            else{
+                alert("获取员工列表失败");
+            }
 
-		},
-		error:function(){
-			alert("获取员工列表发生错误")
-		}
-	})
+
+        },
+        error:function(){
+            alert("获取员工列表发生错误")
+        }
+    })
 }
 // 绑定页面中操作按钮的点击事件
 function btnOn(){
-	$("input").filter("#delUser").on('click',function(event){
-		delUser(event);
-	});
-	$("input").filter("#setPageBtn").on('click',function( ){
-		setPage( );
-	})
+    $("input").filter("#delUser").on('click',function(event){
+        delUser(event); // 绑定删除员工按钮点击事件
+    });
+    $("input").filter("#setPageBtn").on('click',function( ){
+        setPage( );// 绑定设置页码按钮点击事件
+    })
 }
 // 加载上一页数据
 function getPre(){
-	pageNum=pageNum-1;
-	getStaffList();
+    pageNum=pageNum-1;
+    getStaffList();
 }
 // 加载下一页数据
 function getNext(){
-	pageNum=pageNum+1;
-	getStaffList();	
+    pageNum=pageNum+1;
+    getStaffList();
 }
 
 // 跳转到指定页码
 function setPage(){
-	
-	if($("#inputPage").val()<0 || $("#inputPage").val()==0)
-		alert("请输入正确页码");
-	else{
-		pageNum=$("#inputPage").val();
-		getStaffList();
-	}
-	
+
+    if($("#inputPage").val()<0 || $("#inputPage").val()==0)
+        alert("请输入正确页码");
+    else{
+        pageNum=$("#inputPage").val();
+        getStaffList();
+    }
+
 }
 
 // 删除员工
 function delUser(event){
-	var userid=$(event.target).data("userid");
-	$.ajax({
-		type:"POST",
-		url:"../user/delUser.do",
-		dataType:"JSON",
-		data:{
-			"userid":userid
-		},
-		success:function(data){
-				if(data.code==0){
-					alert("删除成功");
-				if(l==1)
-					pageNum=pageNum-1;
-				getStaffList();
-			}
-			else
-				alert("删除失败")
-		},
-		error:function(){
-			alert("删除出现错误");
-		}
-	})
+    var userid=$(event.target).data("userid");
+    $.ajax({
+        type:"POST",
+        url:"../user/delUser.do",
+        dataType:"JSON",
+        data:{
+            "userid":userid
+        },
+        success:function(data){
+            if(data.code==0){ // 删除成功
+                alert("删除成功");
+                // 如果删除的是当前页最后一条，页码减1
+                if(l==1)
+                    pageNum=pageNum-1;
+                getStaffList();// 刷新员工列表
+            }
+            else
+                alert("删除失败")
+        },
+        error:function(){
+            alert("删除出现错误");
+        }
+    })
 
 }
 // 添加新员工
 function addUser(){
-	if(isEmptyString($("#inputAccount").val())||isEmptyString($("#inputPwd").val()))
-		alert("请填写全内容");
-	else{
-		$.ajax({
-			type:"POST",
-			url:"../user/addUser.do",
-			dataType:"JSON",
-			data:{
-				"useraccount":$("#inputAccount").val(),
-				"password":$("#inputPwd").val(),
-				"power":"2"
-			},
-			success:function(data){
-				if(data.code==0){
-					alert("添加成功");
-					$('#addUser').modal('toggle');
-					$("#inputAccount").val("");
-					$("#inputPwd").val("")
-					getStaffList();
-				}
-				else
-					alert("添加失败")
-			},
-			// 重新加载员工列表展示新添加的员工
-			error:function(){
-				alert("添加用户出现错误");
-			}
-		})
-	}
-	
+    // 验证表单数据完整性（账号和密码不能为空）
+    if(isEmptyString($("#inputAccount").val())||isEmptyString($("#inputPwd").val()))
+        alert("请填写全内容");
+    else{
+        $.ajax({
+            type:"POST",
+            url:"../user/addUser.do",
+            dataType:"JSON",
+            data:{
+                "useraccount":$("#inputAccount").val(),
+                "password":$("#inputPwd").val(),
+                "power":"2"
+            },
+            success:function(data){
+                if(data.code==0){
+                    alert("添加成功");
+                    $('#addUser').modal('toggle');// 关闭添加员工弹窗
+                    $("#inputAccount").val(""); // 清空账号输入框
+                    $("#inputPwd").val("") // 清空密码输入框
+                    getStaffList();// 刷新员工列表
+                }
+                else
+                    alert("添加失败")
+            },
+            // 重新加载员工列表展示新添加的员工
+            error:function(){
+                alert("添加用户出现错误");
+            }
+        })
+    }
+
 }

src/main/resources/static/js/myCenter.js

@@ -1,10 +1,13 @@
 // 定义jQuery扩展方法：从URL参数中获取指定名称的值
 (function($){
-	$.getData=function(name){
-		var reg=new RegExp("(^|&)"+name+"=([^&]+)(&|$)?");
-		var result = window.location.search.substr(1).match(reg);
-		if (result!= null) return result[2]; return null;		
-	}
+    //创建了一个$.getData()方法，用于从URL查询字符串中获取指定参数的值
+    $.getData=function(name){
+        var reg=new RegExp("(^|&)"+name+"=([^&]+)(&|$)?");
+        //正则表达式：匹配URL参数中的name=value对，^- 字符串开始位置，|- 或，=- 参数名和值之间的等号，([^&]+)- 捕获参数值，[^&]- 匹配任何非&字符，+- 一个或多个字符，(&|$)?- 匹配参数结束，&- 后面跟着其他参数，$- 字符串结束
+        var result = window.location.search.substr(1).match(reg);
+        //获取并匹配URL参数，substr(1)- 去掉开头的?字符，match(reg)- 使用正则表达式匹配字符串
+        if (result!= null) return result[2]; return null;
+    }
 })(jQuery);
 // 从URL参数中获取用户权限（power）和用户ID（userid）
 var power=$.getData('power');
@@ -12,38 +15,40 @@ var userid=$.getData('userid');
 
 // 页面DOM加载完成后执行初始化操作
 $(document).ready(function(){
-	$("#mainFrame").attr("src","all_infor.html?userid="+userid+"&power="+power);
-	$("inputNone").attr("value",userid);
-	var h=$(window).height();
-	$("#tagList").css("height",h);
-	$("#mainFrame").css("height",h);
-	setList();
+    $("#mainFrame").attr("src","all_infor.html?userid="+userid+"&power="+power);
+    $("inputNone").attr("value",userid);
+    var h=$(window).height();
+    $("#tagList").css("height",h);
+    $("#mainFrame").css("height",h);
+    setList();
 })
 // 根据用户权限生成侧边栏菜单
 function setList(){
-	var tagList=" ";
-	if(power=="0"){
-		tagList="<a href=\"all_infor.html?userid="+userid+"&power="+power+"\"  target=\"mainFrame\" class=\"list-group-item active\"><span class=\"glyphicon glyphicon-user\" aria-hidden=\"true\"></span>个人信息</a><a href=\"ad_manage.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-list\" aria-hidden=\"true\"></span>人员管理</a> <a href=\"ad_order.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-shopping-cart\" aria-hidden=\"true\"></span> 订单管理</a> <a href=\"ad_salary.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-usd\" aria-hidden=\"true\"></span>工资管理</a>"
-	}
-	else if(power=="1"){
-		tagList="<a href=\"all_infor.html?userid="+userid+"&power="+power+"\" target=\"mainFrame\" class=\"list-group-item active\"><span class=\"glyphicon glyphicon-user\" aria-hidden=\"true\"></span>个人信息</a><a href=\"manage_staff.html\" target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-list\" aria-hidden=\"true\"></span>员工管理</a><a href=\"manage_room.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-home\" aria-hidden=\"true\"></span>房间管理</a><a href=\"ad_order.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-shopping-cart\" aria-hidden=\"true\"></span> 订单管理</a>"
-	}
-	else if(power=="2"){
-		tagList="<a href=\"all_infor.html?userid="+userid+"&power="+power+"\"  target=\"mainFrame\" class=\"list-group-item active\"><span class=\"glyphicon glyphicon-user\" aria-hidden=\"true\"></span>个人信息</a><a href=\"staff_room.html?userid="+userid+"\" target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-home\" aria-hidden=\"true\"></span>订房</a><a href=\"staff_order.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-shopping-cart\" aria-hidden=\"true\"></span> 订单管理</a><a href=\"staff_cleaner.html\" target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-list\" aria-hidden=\"true\"></span>清洁工管理</a>"
-	}
-	else if(power=="3"){
-		tagList="<a href=\"all_infor.html?userid="+userid+"&power="+power+"\"  target=\"mainFrame\" class=\"list-group-item active\"><span class=\"glyphicon glyphicon-user\" aria-hidden=\"true\"></span>个人信息</a><a href=\"cleaner_room.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-home\" aria-hidden=\"true\"></span>房间管理</a>"
-	}
-	$("#tagList").append(tagList);
-	tagList=$("#tagList").children("a");
-	tagList.on('click',function(event){
-		changeColor(event)
-	});
+    // 2. 根据权限级别生成不同的菜单HTML
+    var tagList=" ";
+    if(power=="0"){/* 超级管理员菜单 */
+        tagList="<a href=\"all_infor.html?userid="+userid+"&power="+power+"\"  target=\"mainFrame\" class=\"list-group-item active\"><span class=\"glyphicon glyphicon-user\" aria-hidden=\"true\"></span>个人信息</a><a href=\"ad_manage.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-list\" aria-hidden=\"true\"></span>人员管理</a> <a href=\"ad_order.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-shopping-cart\" aria-hidden=\"true\"></span> 订单管理</a> <a href=\"ad_salary.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-usd\" aria-hidden=\"true\"></span>工资管理</a>"
+    }
+    else if(power=="1"){/* 管理员菜单 */
+        tagList="<a href=\"all_infor.html?userid="+userid+"&power="+power+"\" target=\"mainFrame\" class=\"list-group-item active\"><span class=\"glyphicon glyphicon-user\" aria-hidden=\"true\"></span>个人信息</a><a href=\"manage_staff.html\" target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-list\" aria-hidden=\"true\"></span>员工管理</a><a href=\"manage_room.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-home\" aria-hidden=\"true\"></span>房间管理</a><a href=\"ad_order.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-shopping-cart\" aria-hidden=\"true\"></span> 订单管理</a>"
+    }
+    else if(power=="2"){ /* 员工菜单 */
+        tagList="<a href=\"all_infor.html?userid="+userid+"&power="+power+"\"  target=\"mainFrame\" class=\"list-group-item active\"><span class=\"glyphicon glyphicon-user\" aria-hidden=\"true\"></span>个人信息</a><a href=\"staff_room.html?userid="+userid+"\" target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-home\" aria-hidden=\"true\"></span>订房</a><a href=\"staff_order.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-shopping-cart\" aria-hidden=\"true\"></span> 订单管理</a><a href=\"staff_cleaner.html\" target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-list\" aria-hidden=\"true\"></span>清洁工管理</a>"
+    }
+    else if(power=="3"){/* 清洁工菜单 */
+        tagList="<a href=\"all_infor.html?userid="+userid+"&power="+power+"\"  target=\"mainFrame\" class=\"list-group-item active\"><span class=\"glyphicon glyphicon-user\" aria-hidden=\"true\"></span>个人信息</a><a href=\"cleaner_room.html\"  target=\"mainFrame\" class=\"list-group-item\"><span class=\"glyphicon glyphicon-home\" aria-hidden=\"true\"></span>房间管理</a>"
+    }
+    $("#tagList").append(tagList)// 将生成的菜单添加到页面
+    // 4. 为菜单项绑定点击事件
+    tagList=$("#tagList").children("a");
+    tagList.on('click',function(event){
+        changeColor(event)
+    });
 }
 // 切换菜单选中状态（高亮当前点击的菜单，取消其他菜单的高亮）
 function changeColor(event){
-	var obj=event.target;
-	var objSi=$(obj).siblings();
-	$(obj).attr("class","list-group-item active");
-	$(objSi).attr("class","list-group-item ");
+    var obj=event.target;//获取实际触发点击事件的DOM元素
+    var objSi=$(obj).siblings();//获取当前元素的所有同级元素
+    $(obj).attr("class","list-group-item active");//为被点击的菜单项添加active类
+    $(objSi).attr("class","list-group-item ");//移除其他菜单项的active类
 }

src/main/resources/static/js/staff_cleaner.js

@@ -1,203 +1,207 @@
-var pageNum=1;
+//清洁工管理的页面,分页获取清洁工列表、添加清洁工、删除清洁工
+var pageNum=1; // 当前页码，默认为第1页
 var pageSize=8;
 var l;
 
-/ 页面DOM加载完成后执行初始化操作
+//页面DOM加载完成后执行初始化操作
 $(document).ready(function(){
-	getStaffList();
-	$("#pre").on('click',function(){
-		getPre();
-	});
-	$("#next").on('click',function(){
-		getNext();
-	});
-	$("#addUserBtn").on('click',function(){
-		addUser();
-	})
+    getStaffList();// 首次加载时获取清洁工列表
+    $("#pre").on('click',function(){
+        getPre();
+    });
+    $("#next").on('click',function(){
+        getNext();
+    });
+    $("#addUserBtn").on('click',function(){
+        addUser();
+    })
 
 })
 
 //判断对象/JSON是否为空 空返回1 非空返回0
 function isEmptyObject(e) {
-	var t;
-	for (t in e)
-		return 0;
-	return 1;
+    var t;
+    for (t in e)
+        return 0;
+    return 1;
 }
 
 //判断字符串是否为空 空返回1 非空返回0
 function isEmptyString(str){
-	if(str=='null'||str=='')
-		return 1;
-	return 0;
+    if(str=='null'||str=='')
+        return 1;
+    return 0;
 }
 
 // 全局变量：存储清洁工列表数据
 var list;
 // 从后端获取清洁工列表并展示
 function getStaffList(){
-	$.ajax({
-		type:"post",
-		url:"../user/getUserByPower.do",
-		dataType:"JSON",
-		data:{
-			"pageNum":pageNum,
-			"pageSize":pageSize,
-			"power":"3"
-		},
-		// 请求成功的回调函数
-		success:function(data){
-			if(data.code){
-				if(isEmptyObject(data.List)&&pageNum>0){
-					pageNum=pageNum-1;
-					getStaffList();
-				}
-				else{
-					var power=" ";
-					var htmlStr=" ";
-					var btnStr=" ";
-					list=data.List;
-					l=0;// 重置当前页记录数
-					// 默认显示上一页、下一页按钮
-					$("#pre").css("display","block");
-					$("#next").css("display","block");
-					$("#staffList").empty();
-					$("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
-					// 遍历清洁工列表，生成表格内容
-					for(i in list){
-						btnStr="<input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
-						htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+"清洁工"+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
-						$("#staffList").append(htmlStr);
-						//console.log(htmlStr);
-						l++;
-					}
-					if(pageNum=="1") $("#pre").css("display","none");
-					if(pageSize>l) $("#next").css("display","none");
-					// 绑定操作按钮的点击事件
-					btnOn();
-				}
-			}
-			else{
-			// 后端返回失败状态，仍尝试渲染列表（兼容处理）
-				alert("获取员工列表失败");
-				var power=" ";
-				var htmlStr=" ";
-				var btnStr=" ";
-				list=data.List;
-				l=0;
-				$("#pre").css("display","block");
-				$("#next").css("display","block");
-				$("#staffList").empty();
-				$("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
-				for(i in list){
-					btnStr="<input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
-					htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+"清洁工"+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
-					$("#staffList").append(htmlStr);
-					//console.log(htmlStr);
-					l++;
-				}
-				if(pageNum=="1") $("#pre").css("display","none");
-				if(pageSize>l) $("#next").css("display","none");
-				btnOn();
-			}
-			
+    $.ajax({
+        type:"post",
+        url:"../user/getUserByPower.do",
+        dataType:"JSON",
+        data:{
+            "pageNum":pageNum,
+            "pageSize":pageSize,
+            "power":"3"
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            if(data.code){
+                if(isEmptyObject(data.List)&&pageNum>0){
+                    pageNum=pageNum-1;
+                    getStaffList();
+                }
+                else{
+                    var power=" ";
+                    var htmlStr=" "; // 用于累积生成表格行的HTML字符串
+                    var btnStr=" ";// 用于生成操作按钮的HTML字符串
+                    list=data.List;// 保存清洁工列表数据
+                    l=0;// 重置当前页记录数
+                    // 默认显示上一页、下一页按钮
+                    $("#pre").css("display","block");//让ID为"pre"的元素以块级元素的方式显示。块级元素会独占一行，默认宽度为父元素的100%。
+                    $("#next").css("display","block");
+                    $("#staffList").empty(); // 清空表格并添加表头
+                    $("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
+                    // 遍历清洁工列表，生成表格内容
+                    for(i in list){
+                        // 生成删除按钮HTML，包含清洁工ID数据属性
+                        btnStr="<input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
+                        // 拼接表格行HTML（包含清洁工信息和操作按钮）
+                        htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+"清洁工"+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
+                        // 将行添加到表格中
+                        $("#staffList").append(htmlStr);
+                        //console.log(htmlStr);
+                        l++;
+                    }
+                    if(pageNum=="1") $("#pre").css("display","none");
+                    if(pageSize>l) $("#next").css("display","none");
+                    // 绑定操作按钮的点击事件
+                    btnOn();
+                }
+            }
+            else{
+                // 后端返回失败状态，仍尝试渲染列表（兼容处理）
+                alert("获取员工列表失败");
+                var power=" ";
+                var htmlStr=" ";
+                var btnStr=" ";
+                list=data.List;
+                l=0;
+                $("#pre").css("display","block");
+                $("#next").css("display","block");
+                $("#staffList").empty();
+                $("#staffList").append("<tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>")
+                for(i in list){
+                    btnStr="<input type=\"button\" id=\"delUser\" data-userid=\""+list[i].userid+"\" class=\"btn btn-danger\" value=\"删除\"/>"
+                    htmlStr="<tr data-userid=\""+list[i].userid+"\"><td>"+list[i].useraccount+"</td><td>"+list[i].idnumber+"</td><td>"+list[i].username+"</td><td>"+list[i].age+"</td><td>"+"清洁工"+"</td><td>"+list[i].phonenumber+"</td><td>"+btnStr+"</td></tr>";
+                    $("#staffList").append(htmlStr);
+                    //console.log(htmlStr);
+                    l++;
+                }
+                if(pageNum=="1") $("#pre").css("display","none");
+                if(pageSize>l) $("#next").css("display","none");
+                btnOn();
+            }
 
-		},
-		error:function(){
-			alert("获取员工列表发生错误")
-		}
-	})
+
+        },
+        error:function(){
+            alert("获取员工列表发生错误")
+        }
+    })
 }
 // 绑定操作按钮的点击事件
 function btnOn(){
- // 给"删除清洁工"按钮绑定点击事件，触发删除逻辑
-	$("input").filter("#delUser").on('click',function(event){
-		delUser(event);
-	});
-	 // 给"跳转页码"按钮绑定点击事件，触发页码跳转
-	$("input").filter("#setPageBtn").on('click',function( ){
-		setPage( );
-	})
+    // 给"删除清洁工"按钮绑定点击事件，触发删除逻辑
+    $("input").filter("#delUser").on('click',function(event){
+        delUser(event);
+    });
+    // 给"跳转页码"按钮绑定点击事件，触发页码跳转
+    $("input").filter("#setPageBtn").on('click',function( ){
+        setPage( );
+    })
 }
 // 加载上一页数据
 function getPre(){
-	pageNum=pageNum-1; // 页码减1
-	getStaffList();
+    pageNum=pageNum-1; // 页码减1
+    getStaffList();
 }
 // 加载下一页数据
 function getNext(){
-	pageNum=pageNum+1;
-	getStaffList();	
+    pageNum=pageNum+1;
+    getStaffList();
 }
 
 // 跳转到指定页码
 function setPage(){
-	
-	if($("#inputPage").val()<0 || $("#inputPage").val()==0)
-		alert("请输入正确页码");
-	else{
-		pageNum=$("#inputPage").val();
-		getStaffList();
-	}
-	
+
+    if($("#inputPage").val()<0 || $("#inputPage").val()==0)
+        alert("请输入正确页码");
+    else{
+        pageNum=$("#inputPage").val();
+        getStaffList();
+    }
+
 }
 
 // 删除清洁工
 function delUser(event){
-	var userid=$(event.target).data("userid");
-	$.ajax({
-		type:"POST",
-		url:"../user/delUser.do",
-		dataType:"JSON",
-		data:{
-			"userid":userid
-		},
-		success:function(data){
-				if(data.code==0){
-					alert("删除成功");
-				if(l==1)
-					pageNum=pageNum-1;
-				getStaffList();
-			}
-			else
-				alert("删除失败")
-		},
-		error:function(){
-			alert("删除出现错误");
-		}
-	})
+    var userid=$(event.target).data("userid"); // 从按钮的data属性获取清洁工ID
+    $.ajax({
+        type:"POST",
+        url:"../user/delUser.do",// 删除用户的后端API
+        dataType:"JSON",
+        data:{
+            "userid":userid
+        },
+        success:function(data){
+            if(data.code==0){
+                alert("删除成功");
+                if(l==1)
+                    pageNum=pageNum-1;
+                getStaffList();//刷新清洁工列表
+            }
+            else
+                alert("删除失败")
+        },
+        error:function(){
+            alert("删除出现错误");
+        }
+    })
 
 }
 // 添加新清洁工
 function addUser(){
-	if(isEmptyString($("#inputAccount").val())||isEmptyString($("#inputPwd").val()))
-		alert("请填写全内容");
-	else{
-		$.ajax({
-			type:"POST",
-			url:"../user/addUser.do",
-			dataType:"JSON",
-			data:{
-				"useraccount":$("#inputAccount").val(),// 清洁工账号
-				"password":$("#inputPwd").val(), // 清洁工密码
-				"power":"3" // 权限设置：3表示清洁工
-			},
-			success:function(data){
-				if(data.code==0){
-					alert("添加成功");
-					$('#addUser').modal('toggle');
-					$("#inputAccount").val("");
-					$("#inputPwd").val("")
-					// 重新加载列表展示新添加的清洁工
-					getStaffList();
-				}
-				else
-					alert("添加失败")
-			},
-			error:function(){
-				alert("添加用户出现错误");
-			}
-		})
-	}
-	
+    if(isEmptyString($("#inputAccount").val())||isEmptyString($("#inputPwd").val()))
+        alert("请填写全内容");
+    else{
+        $.ajax({
+            type:"POST",
+            url:"../user/addUser.do",
+            dataType:"JSON",
+            data:{
+                "useraccount":$("#inputAccount").val(),// 清洁工账号
+                "password":$("#inputPwd").val(), // 清洁工密码
+                "power":"3" // 权限设置：3表示清洁工
+            },
+            success:function(data){
+                if(data.code==0){
+                    alert("添加成功");
+                    $('#addUser').modal('toggle');
+                    $("#inputAccount").val("");
+                    $("#inputPwd").val("")
+                    // 重新加载列表展示新添加的清洁工
+                    getStaffList();
+                }
+                else
+                    alert("添加失败")
+            },
+            error:function(){
+                alert("添加用户出现错误");
+            }
+        })
+    }
+
 }

src/main/resources/static/js/staff_order.js

@@ -3,24 +3,24 @@ var pageSize=8;
 var l;
 
 $(document).ready(function(){
- // 加载订单列表数据
-	getorderList();
-	$("#pre").on('click',function(){
-		getPre();
-	});
-	$("#next").on('click',function(){
-		getNext();
-	});
+    // 加载订单列表数据
+    getorderList();
+    $("#pre").on('click',function(){
+        getPre();
+    });
+    $("#next").on('click',function(){
+        getNext();
+    });
 
 })
 
 //判断对象/JSON是否为空 空返回1 非空返回0
 function isEmptyObject(e) {
-	var t;
-	// 遍历对象，若存在属性则非空
-	for (t in e)
-		return 0;
-	return 1;
+    var t;
+    // 遍历对象，若存在属性则非空
+    for (t in e)
+        return 0;
+    return 1;
 }
 
 
@@ -28,182 +28,183 @@ function isEmptyObject(e) {
 var list;
 // 从后端获取订单列表并展示
 function getorderList(){
-	$.ajax({
-		type:"post",
-		url:"../order/getAllOrder.do",
-		dataType:"JSON",
-		data:{
-			"pageNum":pageNum,
-			"pageSize":pageSize		
-		},
-		// 请求成功的回调函数
-		success:function(data){
-			if(isEmptyObject(data.List)&&pageNum>0){
-				pageNum=pageNum-1;
-				getorderList();
-			}
-			else{
-				list=data.List;
-				var htmlStr=" ";
-				var btnStr=" ";
-				var state=" ";
-				var sdate;
-				var edate;
-				l=0;
-				// 默认显示上一页、下一页按钮
-				$("#pre").css("display","block");
-				$("#next").css("display","block");
-				$("#orderList").empty();
-				$("#orderList").append("<tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>")
-				// 遍历订单列表，生成表格内容
-				for(i in list){
-					sdate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].starttime);
-					edate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].endtime);
-					// 根据订单状态编码设置状态文本和操作按钮
-					if(list[i].state=="0"){
-						state="未付款";
-						btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\"  class=\"btn btn-success\"  data-orderid=\""+list[i].orderid+"\" id=\"setPaied\" value=\"已收款\"> <input type=\"button\"  class=\"btn btn-danger\"  data-orderid=\""+list[i].orderid+"\" id=\"setNone\" value=\"取消\">";
-					}
-					else if(list[i].state=="1"){
-						state="已付款";
-						btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\"  class=\"btn btn-success\"  data-orderid=\""+list[i].orderid+"\" id=\"setFinish\" value=\"退房\">";
-					}
-					else if(list[i].state=="2"){
-						state="已完成";
-						btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\">";
-					}
-					else{
-						state="已取消";
-						btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\">";
-					}
-					// 拼接表格行（包含订单信息和操作按钮）
-					htmlStr="<tr data-orderid=\""+list[i].orderid+"\"><td>"+list[i].householdname+"</td><td>"+list[i].id+"</td><td>"+sdate+"</td><td>"+edate+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+btnStr+"</td></tr>";
-					$("#orderList").append(htmlStr);
-					l++;
-				}
-				if(pageNum=="1") $("#pre").css("display","none");
-				if(pageSize>l) $("#next").css("display","none");
-				btnOn();
-			}
+    $.ajax({
+        type:"post",
+        url:"../order/getAllOrder.do",
+        dataType:"JSON",
+        data:{
+            "pageNum":pageNum,
+            "pageSize":pageSize
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            if(isEmptyObject(data.List)&&pageNum>0){
+                pageNum=pageNum-1;
+                getorderList();
+            }
+            else{
+                list=data.List;
+                var htmlStr=" "; // 用于拼接HTML表格内容
+                var btnStr=" ";// 操作按钮HTML
+                var state=" ";
+                var sdate;
+                var edate;
+                l=0;
+                // 默认显示上一页、下一页按钮
+                $("#pre").css("display","block");
+                $("#next").css("display","block");
+                $("#orderList").empty();
+                $("#orderList").append("<tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>")
+                // 遍历订单列表，生成表格内容
+                for(i in list){
+                    // 使用正则表达式提取日期部分（去掉时间）
+                    sdate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].starttime);
+                    edate=/\d{4}-\d{1,2}-\d{1,2}/g.exec(list[i].endtime);
+                    // 根据订单状态编码设置状态文本和操作按钮
+                    if(list[i].state=="0"){
+                        state="未付款";
+                        btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\"  class=\"btn btn-success\"  data-orderid=\""+list[i].orderid+"\" id=\"setPaied\" value=\"已收款\"> <input type=\"button\"  class=\"btn btn-danger\"  data-orderid=\""+list[i].orderid+"\" id=\"setNone\" value=\"取消\">";
+                    }
+                    else if(list[i].state=="1"){
+                        state="已付款";
+                        btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\"> <input type=\"button\"  class=\"btn btn-success\"  data-orderid=\""+list[i].orderid+"\" id=\"setFinish\" value=\"退房\">";
+                    }
+                    else if(list[i].state=="2"){
+                        state="已完成";
+                        btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\">";
+                    }
+                    else{
+                        state="已取消";
+                        btnStr="<input type=\"button\"  class=\"btn btn-info\" data-roomid=\""+list[i].roomid+"\" id=\"showRoom\"  data-toggle=\"modal\" data-target=\"#showRoomT\" value=\"查看房间\">";
+                    }
+                    // 拼接表格行（包含订单信息和操作按钮）
+                    htmlStr="<tr data-orderid=\""+list[i].orderid+"\"><td>"+list[i].householdname+"</td><td>"+list[i].id+"</td><td>"+sdate+"</td><td>"+edate+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+btnStr+"</td></tr>";
+                    $("#orderList").append(htmlStr);
+                    l++;
+                }
+                if(pageNum=="1") $("#pre").css("display","none"); // 第一页隐藏上一页
+                if(pageSize>l) $("#next").css("display","none");// 如果当前页数量小于pageSize，隐藏下一页
+                btnOn();
+            }
 
-		},
-		error:function(){
-			alert("获取订单列表发生错误")
-		}
-	})
+        },
+        error:function(){
+            alert("获取订单列表发生错误")
+        }
+    })
 }
 // 绑定页面中操作按钮的点击事件
 function btnOn(){
 // 给"跳转页码"按钮绑定点击事件，触发页码跳转
-	$("input").filter("#setPageBtn").on('click',function( ){
-		setPage( );
-	});
-	// 给"查看房间"按钮绑定点击事件，触发查看房间详情
-	$("input").filter("#showRoom").on('click',function(event){
-		showRoom(event);
-	})
-	// 给"已收款"按钮绑定点击事件，将订单状态改为"已付款"（1）
-	$("input").filter("#setPaied").on('click',function(event){
-		setState(event,"1");
-	});
-	// 给"退房"按钮绑定点击事件，将订单状态改为"已完成"（2）
-	$("input").filter("#setFinish").on('click',function(event){
-		setState(event,"2");
-	});
-	 // 给"取消"按钮绑定点击事件，将订单状态改为"已取消"（3）
-	$("input").filter("#setNone").on('click',function(event){
-		setState(event,"3");
-	});
+    $("input").filter("#setPageBtn").on('click',function( ){
+        setPage( );
+    });
+    // 给"查看房间"按钮绑定点击事件，触发查看房间详情
+    $("input").filter("#showRoom").on('click',function(event){
+        showRoom(event);
+    })
+    // 给"已收款"按钮绑定点击事件，将订单状态改为"已付款"（1）
+    $("input").filter("#setPaied").on('click',function(event){
+        setState(event,"1");
+    });
+    // 给"退房"按钮绑定点击事件，将订单状态改为"已完成"（2）
+    $("input").filter("#setFinish").on('click',function(event){
+        setState(event,"2");
+    });
+    // 给"取消"按钮绑定点击事件，将订单状态改为"已取消"（3）
+    $("input").filter("#setNone").on('click',function(event){
+        setState(event,"3");
+    });
 
 }
 // 加载上一页数据
 function getPre(){
-	pageNum=pageNum-1;
-	getorderList();
+    pageNum=pageNum-1;
+    getorderList();
 }
 // 加载下一页数据
 function getNext(){
-	pageNum=pageNum+1;
-	getorderList();	
+    pageNum=pageNum+1;
+    getorderList();
 }
 // 修改订单状态
 function setState(event,alter){
-	var orderid=$(event.target).data("orderid");
-	$.ajax({
-		type:"POST",
-		url:"../order/updateOrderState.do",
-		dataType:"JSON",
-		data:{
-			"orderid":orderid,
-			"state":alter
-		},
-		success:function(data){
-			if(data.code==0){
-				alert("修改成功");
-				getorderList();
-			}
-			else
-				alert("修改失败")
-		},
-		error:function(){
-			alert("修改信息出现错误");
-		}
-	})
+    var orderid=$(event.target).data("orderid");// 从按钮的data属性获取订单ID
+    $.ajax({
+        type:"POST",
+        url:"../order/updateOrderState.do",
+        dataType:"JSON",
+        data:{
+            "orderid":orderid,
+            "state":alter
+        },
+        success:function(data){
+            if(data.code==0){
+                alert("修改成功");
+                getorderList();
+            }
+            else
+                alert("修改失败")
+        },
+        error:function(){
+            alert("修改信息出现错误");
+        }
+    })
 }
 // 跳转到指定页码
 function setPage(){
-	
-	if($("#inputPage").val()<0 || $("#inputPage").val()==0)
-		alert("请输入正确页码");
-	else{
-		pageNum=$("#inputPage").val();
-		getorderList();
-	}
-	
+
+    if($("#inputPage").val()<0 || $("#inputPage").val()==0)
+        alert("请输入正确页码");
+    else{
+        pageNum=$("#inputPage").val();
+        getorderList();
+    }
+
 }
 // 查看订单对应的房间详情
 function showRoom(event){
-	var roomid=$(event.target).data("roomid");
-	$.ajax({
-		type:"POST",
-		url:"../room/getRoomById.do",
-		dataType:"JSON",
-		data:{
-			"roomid":roomid
-		},
-		success:function(data){
-			if(data.code==0){
-				var htmlStr=" ";
-				var state=" ";
-				var type=" ";
-				var room=data.room;
-				$("#roomTable").empty();
-				if(room.state=="0")
-					state="停用";
-				else if(room.state=="1")
-					state="未预定";
-				else if(room.state=="2")
-					state="已预定(入住)";
-				else
-					state="待清扫";
-					// 转换房间类型编码为文本
-				if(room.type=="1")
-					type="单人间";
-				else if(room.type=="2")
-					type="双人间";
-				else if(room.type=="3")
-					type="大床房";
-				else
-					type="套房";
-					// 拼接房间详情表格内容（位置、价格、类型、状态）
-				htmlStr="<tr><th>位置</th><td>"+room.local+"</td></tr><tr><th>价格</th><td>"+room.money+"</td></tr><tr><th>类型</th><td>"+type+"</td></tr><tr><th>状态</th><td>"+state+"</td></tr>"
-				$("#roomTable").append(htmlStr);
-			}
-			else
-				alert("获取失败")
-		},
-		error:function(){
-			alert("获取信息出现错误");
-		}
-	})
+    var roomid=$(event.target).data("roomid");// 从按钮的data属性获取房间ID
+    $.ajax({
+        type:"POST",
+        url:"../room/getRoomById.do",
+        dataType:"JSON",
+        data:{
+            "roomid":roomid
+        },
+        success:function(data){
+            if(data.code==0){ // 获取成功
+                var htmlStr=" ";
+                var state=" ";
+                var type=" ";
+                var room=data.room;
+                $("#roomTable").empty();
+                if(room.state=="0")
+                    state="停用";
+                else if(room.state=="1")
+                    state="未预定";
+                else if(room.state=="2")
+                    state="已预定(入住)";
+                else
+                    state="待清扫";
+                // 转换房间类型编码为文本
+                if(room.type=="1")
+                    type="单人间";
+                else if(room.type=="2")
+                    type="双人间";
+                else if(room.type=="3")
+                    type="大床房";
+                else
+                    type="套房";
+                // 拼接房间详情表格内容（位置、价格、类型、状态）
+                htmlStr="<tr><th>位置</th><td>"+room.local+"</td></tr><tr><th>价格</th><td>"+room.money+"</td></tr><tr><th>类型</th><td>"+type+"</td></tr><tr><th>状态</th><td>"+state+"</td></tr>"
+                $("#roomTable").append(htmlStr);
+            }
+            else
+                alert("获取失败")
+        },
+        error:function(){
+            alert("获取信息出现错误");
+        }
+    })
 }

src/main/resources/static/js/staff_room.js

@@ -1,52 +1,54 @@
+//酒店管理系统的员工订房页面
 // 定义jQuery扩展方法：从URL参数中获取指定名称的值
 (function($){
-	$.getData=function(name){
-		var reg=new RegExp("(^|&)"+name+"=([^&]+)(&|$)?");
-		var result = window.location.search.substr(1).match(reg);
-		if (result!= null) return result[2]; return null;		
-	}
+    $.getData=function(name){
+        var reg=new RegExp("(^|&)"+name+"=([^&]+)(&|$)?");
+        var result = window.location.search.substr(1).match(reg);
+        if (result!= null) return result[2]; return null;
+    }
 })(jQuery);
 // 从URL参数中获取员工ID（当前登录员工）
-var staffid=$.getData("userid");
+var staffid=$.getData("userid");// 当前登录员工的用户ID
 var pageNum=1;
 var pageSize=8;
-var choose;
+var choose;// 存储用户选择的房间ID
 var l;
 
 $(document).ready(function(){
 // 加载可预订的房间列表
-	getroomList();
+    getroomList();
 // 初始化开始日期选择器（datepicker插件）
-	$('#dateStart').datepicker({
-		language: 'zh-CN',
-		format: 'yyyy-mm-dd',
-		autoclose: true
-	}).on('changeDate',function(e){
-	 // 选择开始日期后，设置结束日期的最小可选值为开始日期
-		var startTime = e.date;
-		$('#dateEnd').datepicker('setStartDate',startTime);
-	});
+    $('#dateStart').datepicker({
+        language: 'zh-CN',// 中文显示
+        format: 'yyyy-mm-dd',// 日期格式
+        autoclose: true // 选择后自动关闭
+    }).on('changeDate',function(e){
+        // 选择开始日期后，设置结束日期的最小可选值为开始日期
+        var startTime = e.date;
+        $('#dateEnd').datepicker('setStartDate',startTime);
+    });
 // 初始化结束日期选择器（datepicker插件）
-	$('#dateEnd').datepicker({
-		language: 'zh-CN',
-		format: 'yyyy-mm-dd',
-		autoclose: true
-	}).on('changeDate',function(e){
-	 // 选择结束日期后，设置开始日期的最大可选值为结束日期
-		var endTime = e.date;
-		$('#dateStart').datepicker('setEndDate',endTime);
-	});
+    $('#dateEnd').datepicker({
+        language: 'zh-CN',
+        format: 'yyyy-mm-dd',
+        autoclose: true
+    }).on('changeDate',function(e){
+        // 选择结束日期后，设置开始日期的最大可选值为结束日期
+        var endTime = e.date;
+        $('#dateStart').datepicker('setEndDate',endTime);
+    });
 
 // 绑定"上一页"按钮点击事件
-	$("#pre").on('click',function(){
-		getPre();
-	});
-	$("#next").on('click',function(){
-		getNext();
-	});
-	$("#addOrder").on('click',function(){
-		addOrder();
-	});
+    $("#pre").on('click',function(){
+        getPre();
+    });
+    $("#next").on('click',function(){
+        getNext();
+    });
+    // 绑定"添加订单"按钮点击事件
+    $("#addOrder").on('click',function(){
+        addOrder();
+    });
 
 })
 
@@ -54,158 +56,162 @@ $(document).ready(function(){
 
 //判断对象/JSON是否为空 空返回1 非空返回0
 function isEmptyObject(e) {
-	var t;
-	for (t in e)
-		return 0;
-	return 1;
+    var t;
+    for (t in e)
+        return 0;
+    return 1;
 }
 
-//判断字符串是否为空 空返回1 非空返回0
+//判断字符串是否为空 空返回1 非空返回0，防止提交空数据
 function isEmptyString(str){
-	if(str=='null'||str=='')
-		return 1;
-	return 0;
+    if(str=='null'||str=='')
+        return 1;
+    return 0;
 }
 
 
 var list;
 // 从后端获取可预订的房间列表（状态为"未预定"）
 function getroomList(){
-	$.ajax({
-		type:"post",
-		url:"../room/getRoom.do",
-		dataType:"JSON",
-		data:{
-			"state":"1",
-			"type":"-1",
-			"pageNum":pageNum,
-			"pageSize":pageSize			
-		},
-		 // 请求成功的回调函数
-		success:function(data){
-			if(isEmptyObject(data.List)&&pageNum>0){
-				pageNum=pageNum-1;
-				getroomList();
-			}
-			else{
-				list=data.List;
-				var power=" ";
-				var htmlStr=" ";
-				var btnStr=" ";
-				var state=" ";
-				var type=" ";
-				l=0;
-				// 默认显示分页按钮
-				$("#pre").css("display","block");
-				$("#next").css("display","block");
-				$("#roomList").empty();
-				$("#roomList").append("<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>");
-				state="未预定";
-				// 遍历房间列表生成表格内容
-				for(i in list){
-				// 转换房间类型编码为文本
-					if(list[i].type=="1")
-						type="单人间";
-					else if(list[i].type=="2")
-						type="双人间";
-					else if(list[i].type=="3")
-						type="大床房";
-					else
-						type="套房"
-						// 操作按钮：生成订单（绑定房间ID，点击打开弹窗）
-					btnStr="<input type=\"button\" class=\"btn btn-success\" data-roomid=\""+list[i].roomid+"\" id=\"chooseRoomBtn\" data-toggle=\"modal\" data-target=\"#chooseRoom\" value=\"生成订单\">";
-					htmlStr="<tr data-roomid=\""+list[i].roomid+"\"><td>"+list[i].local+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+type+"</td><td>"+btnStr+"</td></tr>";
-					$("#roomList").append(htmlStr);
-					l++;// 累加记录数
-				}
-				// 分页按钮控制：第1页隐藏上一页，最后一页隐藏下一页
-				if(pageNum=="1") $("#pre").css("display","none");
-				if(pageSize>l) $("#next").css("display","none");
-				btnOn();
-			}
+    $.ajax({
+        type:"post",
+        url:"../room/getRoom.do",
+        dataType:"JSON",
+        data:{
+            "state":"1",
+            "type":"-1",
+            "pageNum":pageNum,
+            "pageSize":pageSize
+        },
+        // 请求成功的回调函数
+        success:function(data){
+            if(isEmptyObject(data.List)&&pageNum>0){
+                pageNum=pageNum-1;
+                getroomList();
+            }
+            else{
+                list=data.List;// 保存房间列表数据
+                var power=" ";
+                var htmlStr=" ";// 用于拼接HTML表格内容
+                var btnStr=" "; // 操作按钮HTML
+                var state=" "; // 房间状态文字描述
+                var type=" ";// 房间类型文字描述
+                l=0;
+                // 默认显示分页按钮
+                $("#pre").css("display","block");
+                $("#next").css("display","block");
+                $("#roomList").empty();
+                $("#roomList").append("<tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>");
+                state="未预定";// 固定状态显示文本
+                // 遍历房间列表生成表格内容
+                for(i in list){
+                    // 转换房间类型编码为文本
+                    if(list[i].type=="1")
+                        type="单人间";
+                    else if(list[i].type=="2")
+                        type="双人间";
+                    else if(list[i].type=="3")
+                        type="大床房";
+                    else
+                        type="套房"
+                    // 操作按钮：生成订单（绑定房间ID，点击打开弹窗）
+                    btnStr="<input type=\"button\" class=\"btn btn-success\" data-roomid=\""+list[i].roomid+"\" id=\"chooseRoomBtn\" data-toggle=\"modal\" data-target=\"#chooseRoom\" value=\"生成订单\">";
+                    htmlStr="<tr data-roomid=\""+list[i].roomid+"\"><td>"+list[i].local+"</td><td>"+list[i].money+"</td><td>"+state+"</td><td>"+type+"</td><td>"+btnStr+"</td></tr>";
+                    $("#roomList").append(htmlStr);
+                    l++;// 累加记录数
+                }
+                // 分页按钮控制：第1页隐藏上一页，最后一页隐藏下一页
+                if(pageNum=="1") $("#pre").css("display","none");
+                if(pageSize>l) $("#next").css("display","none");
+                btnOn();
+            }
 
-		},
-		error:function(){
-			alert("获取房间列表发生错误")
-		}
-	})
+        },
+        error:function(){
+            alert("获取房间列表发生错误")
+        }
+    })
 }
 // 绑定页面操作按钮的点击事件
 function btnOn(){;
-	$("input").filter("#setPageBtn").on('click',function( ){
-		setPage( );
-	});
-	$("input").filter("#chooseRoomBtn").on('click',function(event){
-		chooseRoomBtn(event);
-	});
+    $("input").filter("#setPageBtn").on('click',function( ){
+        setPage( );
+    });
+
+    $("input").filter("#chooseRoomBtn").on('click',function(event){
+        chooseRoomBtn(event);
+    });
 }
 // 加载上一页数据
 function getPre(){
-	pageNum=pageNum-1;
-	getroomList();
+    pageNum=pageNum-1;
+    getroomList();
 }
 // 加载下一页数据
 function getNext(){
-	pageNum=pageNum+1;
-	getroomList();	
+    pageNum=pageNum+1;
+    getroomList();
 }
 // 跳转到指定页码
 function setPage(){
-	if($("#inputPage").val()<0 || $("#inputPage").val()==0)
-		alert("请输入正确页码");
-	else{
-		pageNum=$("#inputPage").val();
-		getroomList();
-	}
-	
+    if($("#inputPage").val()<0 || $("#inputPage").val()==0)
+        alert("请输入正确页码");
+    else{
+        pageNum=$("#inputPage").val();
+        getroomList();
+    }
+
 }
 // 选择房间并填充订单弹窗信息
 function chooseRoomBtn(event){
-	var roomid=$(event.target).data("roomid");
-	choose=roomid;
-	for(i in list){
-		if(list[i].roomid=roomid){
-			$("span").filter("#inputLocal").text(list[i].local);
-		}
-	}
+    var roomid=$(event.target).data("roomid");// 从按钮的data属性获取房间ID
+    // 保存选择的房间ID到全局变量
+    choose=roomid;
+    // 遍历房间列表，找到对应的房间信息
+    for(i in list){
+        if(list[i].roomid=roomid){
+            $("span").filter("#inputLocal").text(list[i].local);
+        }
+    }
 }
 // 提交添加订单请求
 function addOrder(){
-	if(isEmptyString($("#inputName").val())||isEmptyString($("#inputId").val())||isEmptyString($("#dateStart").val())||isEmptyString($("#dateEnd").val()))
-		alert("请填写全内容");
-	else{
-		$.ajax({
-			type:"POST",
-			url:"../order/addOrder.do",
-			dataType:"JSON",
-			data:{
-				"userid":staffid,
-				"roomid":choose,
-				"householdname":$("#inputName").val(),
-				"id":$("#inputId").val(),
-				"starttime":$("#dateStart").val(),
-				"endtime":$("#dateEnd").val()
-			},
-			success:function(data){
-				if(data.code==0){
-					alert("添加成功");
-					$("#inputRoom").val("");
-					$("#inputName").val("");
-					$("#inputId").val("");
-					$("#dateStart").val("");
-					$("#dateEnd").val("");
-					// 关闭订单弹窗
-					$('#chooseRoom').modal('toggle');
-					// 跳转到订单管理页面
-					window.location.href="staff_order.html";
-				}
-			},
-			error:function(){
-				alert("添加订单出现错误");
-			}
-		})
-	}
-	
+    if(isEmptyString($("#inputName").val())||isEmptyString($("#inputId").val())||isEmptyString($("#dateStart").val())||isEmptyString($("#dateEnd").val()))
+        alert("请填写全内容");
+    else{
+        $.ajax({
+            type:"POST",
+            url:"../order/addOrder.do",
+            dataType:"JSON",
+            data:{
+                "userid":staffid,
+                "roomid":choose,
+                "householdname":$("#inputName").val(),
+                "id":$("#inputId").val(),
+                "starttime":$("#dateStart").val(),
+                "endtime":$("#dateEnd").val()
+            },
+            success:function(data){
+                if(data.code==0){
+                    alert("添加成功");
+                    //清空表单字段
+                    $("#inputRoom").val("");
+                    $("#inputName").val("");
+                    $("#inputId").val("");
+                    $("#dateStart").val("");
+                    $("#dateEnd").val("");
+                    // 关闭订单弹窗
+                    $('#chooseRoom').modal('toggle');
+                    // 跳转到订单管理页面
+                    window.location.href="staff_order.html";
+                }
+            },
+            error:function(){
+                alert("添加订单出现错误");
+            }
+        })
+    }
+
 
 }
 

src/main/resources/static/pages/ad_manage.html

@@ -1,55 +1,74 @@
+<!--员工信息管理页面前端结构-->
 <!DOCTYPE html>
 <html>
 <head>
+    <!--指定页面的字符编码为 utf-8，确保中文、特殊符号等能正常显示-->
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 适配移动端：设置视口，确保页面在不同设备上自适应显示 -->
+    <!--适配移动端设备，控制页面在移动屏幕上的显示效果：
+    width=device-width：让页面宽度等于设备屏幕宽度；
+    initial-scale=1：初始缩放比例为 1（无缩放）；
+    maximum-scale=1：禁止用户放大页面，保证移动端布局稳定。-->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap样式库：提供基础UI组件（表格、按钮、表单等）的样式支持 -->
+    <!--引入 Bootstrap 框架的压缩版样式表，用于快速实现响应式布局（如表格、表单样式），避免重复编写基础 CSS。-->
     <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的样式（如布局、颜色） -->
+    <!--引入自定义样式表 myCenter.css 和 pages.css，用于覆盖或补充 Bootstrap 样式-->
     <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义页面通用样式：统一页面间的基础样式（如边距、字体） -->
     <link rel="stylesheet" type="text/css" href="../css/pages.css">
 
 </head>
 
 <body>
-<!-- 主体内容容器：占11列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距控制位置 -->
+<!--定义员工列表的外层容器，使用 Bootstrap 栅格类和自定义样式控制布局：
+col-md-11：在中等屏幕（≥992px）下占 11 列（Bootstrap 栅格共 12 列，留 1 列空白）；
+col-xs-11：在超小屏幕（<768px）下占 11 列，适配移动端；
+nopadding：自定义类（前文 CSS 定义），清除左右内边距；
+内联样式 padding-top:3rem：顶部内边距 3rem，与上方导航栏 / 页头拉开距离；
+内联样式 padding-left: 3rem：左侧内边距 3rem，避免内容贴左边缘。-->
 <div class="col-md-11 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
-    <!-- 表格响应式容器：在小屏幕上自动出现横向滚动条，确保表格内容不溢出 -->
+    <!--Bootstrap 内置类，让表格在小屏幕下可横向滚动-->
     <div class="table-responsive">
-        <!-- 表格组件：边框样式、鼠标悬浮高亮，设置顶部间距，通过ID关联JS操作 -->
+        <!--定义员工列表表格，通过类和属性控制样式与标识：
+      table：Bootstrap 基础表格样式（默认边框、间距）；
+      table-bordered：为表格添加所有单元格的边框；
+      table-hover：鼠标悬停在表格行上时，行背景色变化；
+      内联样式 margin-top: 10px：顶部外边距 10px，与上方元素拉开微小距离；
+      id="staffList"：给表格设置唯一 ID，方便后续 JavaScript 操作。-->
         <table class="table table-bordered table-hover" style="margin-top: 10px" id="staffList">
-            <!-- 表格表头：定义列名，对应员工管理所需的核心信息字段 -->
+            <!--定义表格的表头行（<tr> 为表格行，<th> 为表头单元格）-->
             <tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>
         </table>
-        <!-- 分页控制区域：占12列（全屏宽度），使用内联表单布局 -->
+        <!--Bootstrap 栅格类，让分页控件在中等及以上屏幕下占 12 列（全屏宽度）-->
         <div class="col-md-12">
+            <!--Bootstrap 行内表单类 form-inline，让表单元素（如下一页链接）横向排列-->
             <form class="form-inline">
-                <!-- 上一页按钮组：设置右侧间距，通过ID供JS绑定点击事件 -->
-                <div class="form-group" style="margin-right: 10xp">
+                <!--定义 “上一页” 分页按钮：
+          form-group：Bootstrap 表单组类，用于统一表单元素的间距和样式；
+          内联样式 margin-right: 10xp（疑似笔误，应为 10px）：右侧外边距 10px，与 “下一页” 拉开距离；
+          <a href="#">：空链接（默认不跳转），后续通过 JavaScript 绑定 “上一页” 点击事件；
+          id="pre"：唯一 ID，方便 JS 定位并添加分页逻辑。-->
+                <div class="form-group" style="margin-right: 10px">
                     <a href="#" id="pre">上一页 </a>
                 </div>
-                <!-- （注释掉的）页码跳转功能：输入页码后点击按钮跳转，当前未启用 -->
                 <!--<div class="form-group">
                   <input type="text" style="width: 5rem" class="form-control" id="inputPage">
                   <input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
                 </div>-->
-                <!-- 下一页按钮组：设置左侧间距，通过ID供JS绑定点击事件 -->
+                <!--定义 “下一页” 分页按钮，与 “上一页” 对称：
+              内联样式 margin-left: 10px：左侧外边距 10px，与 “上一页”（或注释的跳转功能）拉开距离；
+              id="next"：唯一 ID，方便 JS 绑定 “下一页” 点击事件。-->
                 <div class="form-group" style="margin-left: 10px">
                     <a href="#" id="next">下一页</a>
                 </div>
             </form>
         </div>
     </div>
+    <!--结束分页表单和外层容器标签。-->
+
 </div>
 
 </body>
 
 </html>
-<!-- 引入jQuery库：提供DOM操作、AJAX请求等基础功能，是Bootstrap和自定义JS的依赖 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script>
-<!-- 引入Bootstrap JS库：实现模态框、下拉菜单等组件的交互功能 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script>
-<!-- 引入员工管理自定义JS：实现表格数据加载、分页切换等核心业务逻辑 -->
-<script type="text/javascript" src="../js/ad_manage.js"></script>
+<script type="text/javascript" src="../js/jquery.min.js"></script><!--入 jQuery 框架的压缩版，用于简化 DOM 操作（获取表格、发送 AJAX 请求（加载员工数据），是 Bootstrap JS 组件的依赖。-->
+<script type="text/javascript" src="../js/bootstrap.min.js"></script><!--引入 Bootstrap 框架的 JS 组件，用于激活 Bootstrap 样式的交互功能-->
+<script type="text/javascript" src="../js/ad_manage.js"></script><!--引入自定义的员工管理脚本-->

src/main/resources/static/pages/ad_order.html

@@ -1,91 +1,79 @@
+<!--订单管理页面的前端结构-->
 <!DOCTYPE html>
 <html>
 <head>
-    <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配：设置视口属性，确保页面在手机、平板等设备上自适应显示，禁止缩放 -->
-    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap样式库：提供表格、按钮、模态框等基础UI组件的默认样式，减少自定义CSS工作量 -->
-    <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，确保页面风格统一 -->
-    <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义页面通用样式：统一各页面的边距、字体、间距等基础样式 -->
-    <link rel="stylesheet" type="text/css" href="../css/pages.css">
+	<meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
+	<link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
+  <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
+  <link rel="stylesheet" type="text/css" href="../css/pages.css">
 
 </head>
 
 <body>
-<!-- 左侧订单列表区域：占9列（Bootstrap栅格），清除默认内边距，设置顶部和左侧内边距控制位置 -->
+
 <div class="col-md-9 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 2rem">
-    <!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
-    <div class="table-responsive">
-        <!-- 订单表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染数据 -->
-        <table class="table table-bordered table-hover" style="margin-top: 10px" id="orderList">
-            <!-- 表格表头：定义订单核心信息列，与后端返回的订单数据字段对应 -->
-            <tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>
-        </table>
-        <!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使元素横向排列 -->
-        <div class="col-md-12">
-            <form class="form-inline">
-                <!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
-                <div class="form-group" style="margin-right: 10xp">
-                    <a href="#" id="pre">上一页 </a>
-                </div>
-                <!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
-                <!--<div class="form-group">
-                  <input type="text" style="width: 5rem" class="form-control" id="inputPage">
-                  <input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
-                </div>-->
-                <!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
-                <div class="form-group" style="margin-left: 10px">
-                    <a href="#" id="next">下一页</a>
-                </div>
-            </form>
+  <div class="table-responsive">
+    <table class="table table-bordered table-hover" style="margin-top: 10px" id="orderList">
+    <tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>
+    </table>
+    <div class="col-md-12">
+      <form class="form-inline">
+        <div class="form-group" style="margin-right: 10xp">
+          <a href="#" id="pre">上一页 </a>
+        </div>
+        <!--<div class="form-group">
+          <input type="text" style="width: 5rem" class="form-control" id="inputPage">
+          <input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
+        </div>-->
+        <div class="form-group" style="margin-left: 10px">
+          <a href="#" id="next">下一页</a>
         </div>
+      </form>
     </div>
+  </div>
 </div>
 
-<!-- 右侧数据统计区域：占3列（Bootstrap栅格），与左侧订单列表并列，展示核心运营数据 -->
 <div class="col-md-3 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 20px">
-    <!-- 总交易额统计卡片：使用列表组样式，通过ID供JS填充统计数据 -->
-    <div class="col-md-8 col-xs-6 nopadding">
-        <ul class="list-group">
-            <li class="list-group-item" style="color:black !important;border: 0.5px  solid #C8C8BF">
-                <span class="badge" id="totalMoney"> </span> <!-- 徽章样式显示金额数据，更醒目 -->
-                总交易额
-            </li>
-        </ul>
-    </div>
-    <!-- 总订房数统计卡片：与交易额卡片样式统一，通过ID供JS填充数据 -->
-    <div class="col-md-8 col-xs-6 nopadding">
-        <ul class="list-group">
-            <li class="list-group-item"  style="color:black !important;border: 0.5px solid #C8C8BF">
-                <span class="badge" id="totalRoom"> </span> <!-- 徽章样式显示数量数据 -->
-                总订房数
-            </li>
-        </ul>
-    </div>
+  <div class="col-md-8 col-xs-6 nopadding">
+    <ul class="list-group">
+      <li class="list-group-item" style="color:black !important;border: 0.5px  solid #C8C8BF">
+        <span class="badge" id="totalMoney"> </span>
+        总交易额
+      </li>
+    </ul>
+  </div>
+  <div class="col-md-8 col-xs-6 nopadding">
+    <ul class="list-group">
+      <li class="list-group-item"  style="color:black !important;border: 0.5px solid #C8C8BF">
+        <span class="badge" id="totalRoom"> </span>
+        总订房数
+      </li>
+    </ul>
+  </div>
 </div>
 
 </body>
 </html>
 
-<!-- 房间详情模态框：隐藏状态，点击订单“操作”列按钮时弹出，展示订单关联的房间信息 -->
 <div class="modal fade" id="showRoomT" tabindex="-1" role="dialog" aria-labelledby="myModalLabel">
-    <div class="modal-dialog" role="document"> <!-- 模态框容器，控制弹窗大小和位置 -->
-        <div class="modal-content"> <!-- 模态框内容区域，包含头部、主体 -->
-            <div class="modal-header"> <!-- 模态框头部：标题+关闭按钮 -->
-                <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
-                <h4 class="modal-title" id="myModalLabel">房间详情</h4> <!-- 模态框标题 -->
-            </div>
-            <div class="modal-body"> <!-- 模态框主体：展示房间详情的表格 -->
-                <table class="table table-bordered table-hover" style="margin-top:10px" id="roomTable">
-                </table> <!-- 表格通过ID供JS动态渲染房间数据（如房间号、位置、价格） -->
-            </div>
-        </div>
+  <div class="modal-dialog" role="document">
+    <div class="modal-content">
+      <div class="modal-header">
+        <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
+        <h4 class="modal-title" id="myModalLabel">房间详情</h4>
+      </div>
+      <div class="modal-body">
+        <table class="table table-bordered table-hover" style="margin-top:10px" id="roomTable">
+        </table>
+      </div>
     </div>
+  </div>
 </div>
 
-<!-- 引入依赖JS文件：确保DOM加载完成前加载核心库，避免报错 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：实现模态框弹出/关闭、响应式交互 -->
-<script type="text/javascript" src="../js/ad_order.js"></script> <!-- 订单管理自定义JS：实现数据加载、分页、模态框交互等业务逻辑 -->
+
+
+<script type="text/javascript" src="../js/jquery.min.js"></script>
+<script type="text/javascript" src="../js/bootstrap.min.js"></script>
+<script type="text/javascript" src="../js/ad_order.js"></script>
+

src/main/resources/static/pages/ad_salary.html

@@ -1,73 +1,116 @@
+<!--员工薪资配置管理页面的前端结构，-->
 <!DOCTYPE html>
 <html>
 <head>
+    <!--指定页面的字符编码为 utf-8，确保中文、特殊符号等能正常显示-->
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配配置：控制页面在不同设备上的缩放行为，确保移动端显示正常 -->
+    <!--适配移动端设备，控制页面在移动屏幕上的显示效果：
+    width=device-width：让页面宽度等于设备屏幕宽度；
+    initial-scale=1：初始缩放比例为 1（无缩放）；
+    maximum-scale=1：禁止用户放大页面，保证移动端布局稳定。-->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap基础样式：提供表格、按钮、输入框等组件的默认样式，保证界面统一性 -->
+    <!--引入 Bootstrap 框架的压缩版样式表，用于快速实现响应式布局（如表格、表单样式），避免重复编写基础 CSS。-->
     <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，匹配整体设计风格 -->
+    <!--引入自定义样式表 myCenter.css 和 pages.css，用于覆盖或补充 Bootstrap 样式-->
     <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义通用页面样式：统一各页面的边距、字体等基础样式，减少重复代码 -->
     <link rel="stylesheet" type="text/css" href="../css/pages.css">
 
 </head>
-
+<!--定义页面主容器，基于 Bootstrap 栅格系统实现响应式布局：
+col-md-6：中等屏幕（≥992px）下占 6 列（总 12 列），宽度为页面一半；
+col-xs-11：超小屏幕（<768px）下占 11 列，左右留少量空白；
+nopadding：自定义类（清除左右内边距）；
+内联样式 padding-top:3rem：顶部内边距 3rem，与页头 / 导航栏拉开距离；
+内联样式 padding-left: 3rem：左侧内边距 3rem，避免内容贴左边缘。-->
 <body>
-<!-- 主体内容容器：占6列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
 <div class="col-md-6 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
-    <!-- 配置查看面板（默认显示）：用于展示当前薪资配置数据 -->
+    <!--“查看配置” 状态的容器，table-responsive 确保表格在小屏幕可横向滚动；id="showConfigDiv" 用于 JS 控制显示 / 隐藏。-->
     <div class="table-responsive" id="showConfigDiv">
-        <!-- “更改配置”按钮：带铅笔图标，点击切换到编辑面板，通过ID绑定JS事件 -->
+        <!--“切换到编辑模式” 的按钮：
+  glyphicon glyphicon-pencil：Bootstrap 图标（铅笔图标，暗示编辑功能）；
+  文本 “更改配置” 明确功能；
+  id="showConfig"：JS 绑定点击事件，用于切换到编辑状态。-->
         <a href="#" id="showConfig" style="font-size:1.7rem">
-            <span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，标识“编辑”功能 -->
+            <span class="glyphicon glyphicon-pencil"></span>
             <span>更改配置</span>
         </a>
-        <!-- 配置展示表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染数据 -->
+        <!--展示薪资配置的表格（查看模式）：
+  table table-bordered table-hover：Bootstrap 表格样式（带边框、悬停高亮）；
+  表头包含 “职位”“底薪”“提成” 三列；
+  id="configList"：JS 动态填充数据（从后端加载当前配置）。-->
         <table class="table table-bordered table-hover" style="margin-top: 10px" id="configList">
-            <!-- 表格表头：定义“职位”“底薪”“提成”三列，对应薪资配置的核心字段 -->
             <tr><th  style="width: 100px">职位</th><th>底薪</th><th>提成</th></tr>
         </table>
     </div>
+    <!--结束 “查看配置” 区域容器。-->
 
-    <!-- 配置编辑面板（默认隐藏）：用于修改薪资配置，初始通过display: none隐藏 -->
+    <!--“编辑配置” 状态的容器，默认通过 display: none 隐藏；id="alterConfigDiv" 用于 JS 控制显示 / 隐藏。-->
     <div class="table-responsive" id="alterConfigDiv" style="display: none">
-        <!-- “返回”按钮：点击切换回查看面板，通过ID绑定JS事件 -->
+        <!--   “返回查看模式” 的按钮：
+           图标与 “更改配置” 一致，文本改为 “返回”；
+           id="alterConfig"：JS 绑定点击事件，用于切换回查看状态。-->
         <a href="#" id="alterConfig" style="font-size:1.7rem">
             <span class="glyphicon glyphicon-pencil"></span>
             <span>返回</span>
         </a>
-        <!-- 配置编辑表格：包含输入框，供管理员输入新的薪资数据 -->
+        <!--编辑模式的表格，表头与查看模式一致，确保布局统一。-->
         <table class="table table-bordered table-hover" style="margin-top: 10px">
             <tr><th style="width: 100px">职位</th><th>底薪</th><th>提成</th></tr>
-            <!-- 经理薪资编辑行：输入框通过ID供JS获取新值 -->
+            <!--经理职位的薪资编辑行：
+            input 输入框：用于修改底薪（id="inputMS"）和提成（id="inputM"）；
+            form-control：Bootstrap 输入框样式，确保美观和响应式。-->
             <tr>
                 <th>经理</th>
-                <th><input type="text" class="form-control" id="inputMS"></th> <!-- 经理底薪输入框 -->
-                <th><input type="text" class="form-control" id="inputM"></th>  <!-- 经理提成输入框 -->
+                <th>
+                    <input type="text" class="form-control" id="inputMS">
+                </th>
+                <th>
+                    <input type="text" class="form-control" id="inputM">
+                </th>
             </tr>
-            <!-- 普通员工薪资编辑行 -->
+            <!--员工职位的薪资编辑行，id="inputSS"（员工底薪）、id="inputS"（员工提成）。-->
             <tr>
                 <th>员工</th>
-                <th><input type="text" class="form-control" id="inputSS"></th> <!-- 员工底薪输入框 -->
-                <th><input type="text" class="form-control" id="inputS"></th>  <!-- 员工提成输入框 -->
+                <th>
+                    <input type="text" class="form-control" id="inputSS">
+                </th>
+                <th>
+                    <input type="text" class="form-control" id="inputS">
+                </th>
             </tr>
-            <!-- 清洁工薪资编辑行 -->
+            <!--清洁工职位的薪资编辑行，id="inputCS"（清洁工底薪）、id="inputC"（清洁工提成）；结束表格标签。-->
             <tr>
                 <th>清洁工</th>
-                <th><input type="text" class="form-control" id="inputCS"></th> <!-- 清洁工底薪输入框 -->
-                <th><input type="text" class="form-control" id="inputC"></th>  <!-- 清洁工提成输入框 -->
+                <th>
+                    <input type="text" class="form-control" id="inputCS">
+                </th>
+                <th>
+                    <input type="text" class="form-control" id="inputC">
+                </th>
             </tr>
         </table>
-        <!-- 确认修改按钮：右对齐，绿色按钮突出“确认”操作，通过ID绑定JS提交事件 -->
+        <!--提交修改的按钮：
+  float: right：右对齐，符合操作习惯；
+  btn btn-success：Bootstrap 成功样式按钮（绿色）；
+  id="alterConfigBtn"：JS 绑定点击事件，用于提交修改后的薪资配置。-->
         <input style="float: right" type="button" id="alterConfigBtn" class="btn btn-success" value="确定"/>
     </div>
+    <!--结束 “编辑配置” 区域容器。-->
+
 </div>
 
+
+
+
+
 </body>
-</html>
 
-<!-- 引入依赖JS文件：确保DOM加载前加载核心库，避免交互逻辑报错 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求能力 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：支持图标渲染、组件交互 -->
-<script type="text/javascript" src="../js/ad_salary.js"></script> <!-- 薪资配置自定义JS：实现面板切换、数据加载与提交 -->
+</html>
+<script type="text/javascript" src="../js/jquery.min.js"></script><!--结束 “编辑配置” 区域容器。-->
+<script type="text/javascript" src="../js/bootstrap.min.js"></script><!--引入 Bootstrap JS 组件，激活图标、按钮等交互样式（确保 glyphicon 图标正常显示）。-->
+<script type="text/javascript" src="../js/ad_salary.js"></script>
+<!--自定义薪资配置脚本，核心逻辑包括：
+页面加载时，向 configList 表格填充当前薪资配置数据；
+绑定 showConfig 点击事件，隐藏查看区域、显示编辑区域，并向输入框填充当前值；
+绑定 alterConfig 点击事件，隐藏编辑区域、显示查看区域；
+绑定 alterConfigBtn 点击事件，获取输入框值并提交到后端保存，成功后更新查看区域数据。-->

src/main/resources/static/pages/all_infor.html

@@ -1,73 +1,222 @@
+<!--用户信息管理页面的前端结构-->
 <!DOCTYPE html>
 <html>
 <head>
+    <title>用户信息</title>
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配：设置视口，确保页面在手机、平板等设备上自适应显示，禁止缩放 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap样式库：提供表格、按钮、输入框等基础UI组件的默认样式，保证界面统一性 -->
     <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的布局、颜色、字体等样式，匹配整体设计风格 -->
     <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义页面通用样式：统一各页面的边距、间距等基础样式，减少重复代码 -->
     <link rel="stylesheet" type="text/css" href="../css/pages.css">
 
 </head>
 
 <body>
-<!-- 主体内容容器：占6列（Bootstrap栅格），清除默认内边距，设置顶部和左侧内边距控制位置 -->
-<div class="col-md-6 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
-    <!-- 配置查看面板（默认显示）：用于展示当前系统中的薪资配置信息 -->
-    <div class="table-responsive" id="showConfigDiv">
-        <!-- 更改配置按钮：带铅笔图标，点击切换到编辑面板，通过ID供JS绑定点击事件 -->
-        <a href="#" id="showConfig" style="font-size:1.7rem">
-            <span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap图标：表示“编辑”操作 -->
-            <span>更改配置</span>
-        </a>
-        <!-- 配置展示表格：带边框、鼠标悬浮高亮，通过ID供JS动态渲染当前薪资配置数据 -->
-        <table class="table table-bordered table-hover" style="margin-top: 10px" id="configList">
-            <!-- 表格表头：定义“职位”“底薪”“提成”三列，与薪资配置数据字段对应 -->
-            <tr><th  style="width: 100px">职位</th><th>底薪</th><th>提成</th></tr>
-        </table>
+<!--页面最外层容器，占满整行（col-md-12/col-xs-12），padding-top:4rem 与页头拉开距离，nopadding 清除默认内边距。-->
+<div class="col-md-12 col-xs-12 nopadding" style="padding-top:4rem;">
+    <!--左侧头像容器，响应式布局：
+col-md-3：中等屏幕占 3 列（宽度 25%）；
+col-xs-4：超小屏幕占 4 列（宽度～33%）；
+margin-bottom:10px：底部外边距，避免内容拥挤。-->
+    <div class="col-md-3 col-xs-4 nopadding" style="margin-bottom:10px">
+        <!--显示用户头像，id="userpic" 用于 JS 动态设置头像图片路径，class="userpic" 关联自定义样式（如大小、边框）。-->
+        <img id="userpic" class="userpic" src=" "/>
+        <!--“修改头像” 按钮：
+  data-toggle="modal" data-target="#changePic"：Bootstrap 模态框触发属性，点击打开 id="changePic" 的弹窗；
+  glyphicon glyphicon-pencil：铅笔图标，暗示编辑功能；-->
+        <div class="col-md-12 col-xs-12 username">
+            <a href="#"  data-toggle="modal" data-target="#changePic">
+                <span class="glyphicon glyphicon-pencil"></span>
+                <span>修改头像</span>
+            </a>
+        </div>
+        <!--结束左侧头像区域容器。-->
     </div>
+    <!--右侧信息容器，与左侧头像形成左右布局：
+col-md-6：中等屏幕占 6 列（宽度 50%）；
+col-xs-8：超小屏幕占 8 列（宽度～67%）；
+border-left:1px solid gray：左侧灰色边框，分隔头像与信息区域；
+padding-left: 20px：左侧内边距，避免内容贴边框。-->
+    <div class="col-md-6 col-xs-8 nopadding" style="border-left:1px solid gray;padding-left: 20px">
+        <!--“查看信息” 模式的容器，display: block 默认显示，id="showInfodiv" 用于 JS 控制显示 / 隐藏。-->
+        <div class="col-md-12  col-xs-12" style="font-size: 1.5rem;margin-bottom: 10px;display: block" id="showInfodiv">
+            <!--“切换到编辑模式” 的按钮，id="showInfo" 绑定 JS 事件，点击后显示编辑视图。-->
+            <a href="#"  id="showInfo">
+                <span class="glyphicon glyphicon-pencil"></span>
+                <span>修改信息</span>
+            </a>
+            <!--账号信息行：
+    id="account"：显示账号（用户名），JS 动态填充；
+    嵌套 “修改密码” 链接，通过 data-target="#changePwd" 打开密码修改弹窗。-->
+            <div class="fdata">
+                <p>
+                    <span>账号 Account ：</span>
+                    <span class="value" id="account">用户名</span>
+                    <a href="#" style="margin-left: 20px"  data-toggle="modal" data-target="#changePwd">
+                        <span class="glyphicon glyphicon-pencil"></span>
+                        <span>修改密码</span>
+                    </a>
+                </p>
+            </div>
+            <!--工号信息行，id="idnum" 用于 JS 填充工号数据。-->
+            <div class="fdata">
+                <p>
+                    <span>工号 ID ：</span>
+                    <span class="value" id="idnum"></span>
+                </p>
+            </div>
+            <div class="fdata">
+                <p>
+                    <span>姓名 Name ：</span>
+                    <span class="value" id="name"></span>
+                </p>
+            </div>
+            <div class="fdata" id="showS" style="display: none">
+                <p>
+                    <span>底薪 Basic Salary ：</span>
+                    <span class="value" id="salary"></span>
+                </p>
+            </div>
+            <div class="fdata" id="showC" style="display: none">
+                <p>
+                    <span>提成 Commission ：</span>
+                    <span class="value" id="commission"></span>
+                </p>
+            </div>
+            <!--年龄（id="age"）和手机号（id="phone"）信息行，JS 动态填充数据；结束 “查看信息” 视图容器。-->
+            <div class="fdata">
+                <p>
+                    <span>年龄 Age ：</span>
+                    <span class="value" id="age"></span>
+                </p>
+            </div>
+            <div class="fdata">
+                <p>
+                    <span>手机号 PhoneNumber ：</span>
+                    <span class="value" id="phone"></span>
+                </p>
+            </div>
+        </div>
+        <!--“编辑信息” 模式的容器，display: none 默认隐藏，id="showAlterdiv" 用于 JS 控制显示 / 隐藏。-->
+        <div class="col-md-12 col-xs-12" style="font-size:1.5rem;margin-bottom: 10px;display: none" id="showAlterdiv">
+            <!--“返回查看模式” 的按钮，id="showAlter" 绑定 JS 事件，点击后隐藏编辑视图。-->
+            <a href="#" id="showAlter">
+                <span class="glyphicon glyphicon-chevron-left"></span>
+                <span>返回</span>
+            </a>
+            <!--编辑表单，form-inline 使表单项横向排列（小屏幕自动堆叠），margin-top: 10px 与 “返回” 按钮拉开距离。-->
+            <form class="form-inline" style="margin-top: 10px">
+                <!--姓名编辑项：
+      form-group：Bootstrap 表单组样式；
+      alterinfo：自定义类，控制编辑项样式；
+      input 输入框 id="inputName"：用于输入新姓名，JS 会预先填充当前姓名。-->
+                <div class="form-group alterinfo col-xs-12 col-md-12">姓名：
+                    <label for="name">Name</label>
+                    <input type="text" name="name" class="form-control" id="inputName">
+                </div>
+                <!--年龄（id="inputAge"）和手机号（id="inputPhone"）编辑项，逻辑同姓名项。-->
+                <div class="form-group alterinfo col-xs-12 col-md-12">年龄：
+                    <label for="age">Age</label>
+                    <input type="text" name="age" class="form-control" id="inputAge">
+                </div>
+                <div class="form-group alterinfo col-xs-12 col-md-12">手机号：
+                    <label for="phone">Phone</label>
+                    <input type="text" name="phone" class="form-control" id="inputPhone">
+                </div>
+                <!--“确认修改” 按钮，id="alterInfoBtn" 绑定 JS 事件，点击后提交编辑的信息；结束编辑表单和视图容器。-->
+                <div class="form-group alterinfo col-xs-12 col-md-12">
+                    <input type="button" id="alterInfoBtn" class="btn btn-success" value="确定"/>
+                </div>
+            </form>
+        </div>
+
 
-    <!-- 配置编辑面板（默认隐藏）：用于修改薪资配置，通过style="display: none"控制初始隐藏 -->
-    <div class="table-responsive" id="alterConfigDiv" style="display: none">
-        <!-- 返回按钮：点击切换回查看面板，通过ID供JS绑定点击事件 -->
-        <a href="#" id="alterConfig" style="font-size:1.7rem">
-            <span class="glyphicon glyphicon-pencil"></span>
-            <span>返回</span>
-        </a>
-        <!-- 配置编辑表格：包含输入框，供管理员输入新的薪资和提成数据 -->
-        <table class="table table-bordered table-hover" style="margin-top: 10px">
-            <tr><th style="width: 100px">职位</th><th>底薪</th><th>提成</th></tr>
-            <!-- 经理薪资编辑行：输入框通过ID供JS获取新值 -->
-            <tr>
-                <th>经理</th>
-                <th><input type="text" class="form-control" id="inputMS"></th> <!-- 经理底薪输入框 -->
-                <th><input type="text" class="form-control" id="inputM"></th>  <!-- 经理提成输入框 -->
-            </tr>
-            <!-- 员工薪资编辑行 -->
-            <tr>
-                <th>员工</th>
-                <th><input type="text" class="form-control" id="inputSS"></th> <!-- 员工底薪输入框 -->
-                <th><input type="text" class="form-control" id="inputS"></th>  <!-- 员工提成输入框 -->
-            </tr>
-            <!-- 清洁工薪资编辑行 -->
-            <tr>
-                <th>清洁工</th>
-                <th><input type="text" class="form-control" id="inputCS"></th> <!-- 清洁工底薪输入框 -->
-                <th><input type="text" class="form-control" id="inputC"></th>  <!-- 清洁工提成输入框 -->
-            </tr>
-        </table>
-        <!-- 确认修改按钮：点击提交新的薪资配置，通过ID供JS绑定点击事件，绿色按钮突出“确认”操作 -->
-        <input style="float: right" type="button" id="alterConfigBtn" class="btn btn-success" value="确定"/>
     </div>
+
 </div>
 
 </body>
-</html>
+<!--：结束右侧信息区域和页面最外层容器。-->
 
-<!-- 引入依赖JS文件：确保DOM加载前加载核心库，避免交互逻辑报错 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：支持图标渲染、组件交互 -->
-<script type="text/javascript" src="../js/ad_salary.js"></script> <!-- 薪资配置自定义JS：实现查看/编辑面板切换、数据加载与提交等业务逻辑 -->
+<!--头像修改弹窗，modal fade 是 Bootstrap 模态框基础样式（带淡入淡出动画），id="changePic" 用于触发显示。-->
+<div class="modal fade" id="changePic" tabindex="-1" role="dialog">
+    <!--弹窗头部：关闭按钮（data-dismiss="modal" 内置关闭功能）；标题 “修改头像”。-->
+    <div class="modal-dialog" role="document">
+        <div class="modal-content">
+            <div class="modal-header">
+                <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
+                <h4 class="modal-title">修改头像</h4>
+            </div>
+            <!--弹窗主体内的 JS 函数 saveReport()：
+            使用 jquery-form 插件的 ajaxSubmit 异步提交表单（避免页面刷新）；
+            根据后端返回的 data.code 判断成功 / 失败，显示提示并刷新页面。-->
+            <div class="modal-body">
+                <script type="text/javascript">
+                    function saveReport(){
+                        $("#uploadProfile").ajaxSubmit(function(data){
+                            console.log(data);
+                            if(data.code==0)
+                                alert("修改头像成功!");
+
+                            else
+                                alert("修改头像失败!");
+                            window.location.reload();
+                        });
+                        return false;
+                        //必须返回false，否则表单会自己再做一次提交操作，并且页面跳转
+                    }
+                </script>
+                <!--头像上传表单：
+                action="../upFile/upFilePhoto.do"：后端处理头像上传的接口；
+                enctype="multipart/form-data"：支持文件上传的表单编码类型；
+                onsubmit="return saveReport()"：提交时执行 saveReport() 函数。-->
+                <form action="../upFile/upFilePhoto.do"  method="post"  enctype="multipart/form-data"  onsubmit="return saveReport()" id="uploadProfile">
+                    <!--隐藏的 userid 输入框：传递当前用户 ID（后端用于关联头像）；type="file" 输入框：用于选择本地图片文件；
+                      “修改头像” 提交按钮：触发表单提交；
+                      结束头像弹窗标签。-->
+                    <input type="text" name="userid" class="form-control" id="inputNone" style="display: none;">文件大小1M以内
+                    <input id="inputFile" name="file" class="btn-file-molding" type="file"><br/>
+                    <input type="submit" id="alterProfile" class="btn btn-success" value="修改头像"/>
+                    <form>
+            </div>
+
+        </div>
+    </div>
+</div>
+<!--密码修改弹窗头部，结构同头像弹窗，标题为 “修改密码”。-->
+<div class="modal fade" id="changePwd" tabindex="-1" role="dialog">
+    <div class="modal-dialog" role="document">
+        <div class="modal-content">
+            <div class="modal-header">
+                <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
+                <h4 class="modal-title">修改密码</h4>
+            </div>
+            <!--原密码输入项，type="password" 隐藏输入内容，id="inputoldPwd" 用于 JS 获取值。-->
+            <div class="modal-body" style="width: 80%;padding-left:20%">
+                <div class="form-group alterinfo">请输入原密码：
+                    <label for="oldPwd">oldPwd</label>
+                    <input type="password" name="oldPwd" class="form-control" id="inputoldPwd">
+                </div>
+                <!--新密码和确认密码输入项，id="inputnewPwd" 和 id="inputrenewPwd" 用于 JS 验证两次输入是否一致。-->
+                <div class="form-group alterinfo">请输入新密码：
+                    <label for="newPwd">newPwd</label>
+                    <input type="password" name="newPwd" class="form-control" id="inputnewPwd">
+                </div>
+                <div class="form-group alterinfo">确认新密码：
+                    <label for="renewPwd">newPwd</label>
+                    <input type="password" name="renewPwd" class="form-control" id="inputrenewPwd">
+                </div>
+                <!--“确认修改密码” 按钮，id="alterPwdBtn" 绑定 JS 事件（验证密码格式、一致性后提交后端）；结束密码弹窗标签。-->
+                <div class="form-group alterinfo">
+                    <input type="button" id="alterPwdBtn" class="btn btn-success" value="确定"/>
+                </div>
+            </div>
+
+        </div>
+    </div>
+</div>
+</html>
+<script type="text/javascript" src="../js/jquery.min.js"></script><!--引入 jQuery 框架，简化 DOM 操作（如切换视图、获取输入值、绑定事件）。-->
+<script type="text/javascript" src="../js/bootstrap.min.js"></script><!--引入 Bootstrap JS 组件，激活模态框、图标等交互功能（确保弹窗正常显示 / 隐藏）。-->
+<script type="text/javascript" src="../js/jquery-form.js"></script><!--引入 jQuery Form 插件，提供 ajaxSubmit 方法实现表单异步提交（用于头像上传）-->
+<script type="text/javascript" src="../js/all_infor.js"></script><!--自定义用户信息管理脚本-->

src/main/resources/static/pages/cleaner_room.html

@@ -1,53 +1,69 @@
+<!--清洁工视角的房间管理页面 前端结构-->
 <!DOCTYPE html>
 <html>
 <head>
+    <!--指定页面的字符编码为 utf-8，确保中文、特殊符号等能正常显示-->
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配：控制页面在手机、平板等设备上的缩放，确保自适应显示，禁止手动缩放 -->
+    <!--适配移动端设备，控制页面在移动屏幕上的显示效果：
+    width=device-width：让页面宽度等于设备屏幕宽度；
+    initial-scale=1：初始缩放比例为 1（无缩放）；
+    maximum-scale=1：禁止用户放大页面，保证移动端布局稳定。-->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap基础样式：提供表格、按钮、表单等组件的默认样式，保证界面美观统一 -->
+    <!--引入 Bootstrap 框架的压缩版样式表，用于快速实现响应式布局（如表格、表单样式），避免重复编写基础 CSS。-->
     <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的布局、颜色、字体等样式，匹配整体设计风格 -->
+    <!--引入自定义样式表 myCenter.css 和 pages.css，用于覆盖或补充 Bootstrap 样式-->
     <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义通用页面样式：统一各页面的边距、间距等基础样式，减少重复代码 -->
     <link rel="stylesheet" type="text/css" href="../css/pages.css">
 
 </head>
-
+<!--定义页面主容器，基于 Bootstrap 栅格系统实现响应式布局：
+col-md-8：中等屏幕（≥992px）下占 8 列（总 12 列），宽度约为页面 2/3；
+col-xs-11：超小屏幕（<768px）下占 11 列，左右留少量空白；
+nopadding：自定义类，清除容器默认左右内边距；
+内联样式 padding-top:3rem：顶部内边距 3rem，与上方导航栏 / 页头拉开距离；
+内联样式 padding-left: 3rem：左侧内边距 3rem，避免列表贴左边缘。-->
 <body>
-<!-- 主体内容容器：占8列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
 <div class="col-md-8 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
-    <!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
+    <!--Bootstrap 内置类，让表格在小屏幕下可横向滚动（避免房间信息列过多导致溢出，保证移动端可读性）。-->
     <div class="table-responsive">
-        <!-- 房间列表表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染房间数据 -->
+        <!--定义房间列表表格，通过类和属性控制样式与标识：
+  table：Bootstrap 基础表格样式（默认间距、轻量边框）；
+  table-bordered：为所有单元格添加完整边框，清晰分隔行列；
+  table-hover：鼠标悬停在表格行上时背景色变化，提升交互体验；
+  内联样式 margin-top: 10px：顶部外边距 10px，与容器顶部轻微拉开距离；
+  id="roomList"：唯一 ID，方便后续 JavaScript 动态填充房间数据（如从后端加载房间列表）。-->
         <table class="table table-bordered table-hover" style="margin-top: 10px" id="roomList">
-            <!-- 表格表头：定义“位置”“价格”“状态”“类型”“操作”五列，对应房间管理核心信息 -->
+            <!--定义表格表头行（<tr> 为行，<th> 为表头单元格），包含 5 个核心房间字段-->
             <tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>
+            <!--Bootstrap 栅格类，让分页控件在中等及以上屏幕下占 12 列（全屏宽度），确保分页居中显示，与表格宽度匹配。-->
         </table>
-        <!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使分页元素横向排列 -->
         <div class="col-md-12">
+            <!--Bootstrap 行内表单类 form-inline，让分页元素（上一页、下一页链接）横向排列，节省空间且布局紧凑，避免分页区域占用过多垂直空间。-->
             <form class="form-inline">
-                <!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
-                <div class="form-group" style="margin-right: 10xp">
+                <!--定义 “上一页” 按钮，用于加载前一页房间数据-->
+                <div class="form-group" style="margin-right: 10px">
                     <a href="#" id="pre">上一页 </a>
                 </div>
-                <!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
                 <!--<div class="form-group">
                   <input type="text" style="width: 5rem" class="form-control" id="inputPage">
                   <input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
                 </div>-->
-                <!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
+                <!--定义 “下一页” 按钮-->
                 <div class="form-group" style="margin-left: 10px">
                     <a href="#" id="next">下一页</a>
                 </div>
             </form>
         </div>
     </div>
+
+
 </div>
 
 </body>
+
+
 </html>
+<script type="text/javascript" src="../js/jquery.min.js"></script><!--引入 jQuery 框架，用于简化 DOM 操作（如获取表格 / 分页元素、绑定点击事件）、发送 AJAX 请求（如从后端加载房间数据、提交状态修改），是后续交互逻辑的基础依赖。-->
+<script type="text/javascript" src="../js/bootstrap.min.js"></script><!--引入 Bootstrap JS 组件，激活 Bootstrap 样式的交互效果（如表格悬停、表单布局适配），确保页面视觉与交互一致性。-->
+<script type="text/javascript" src="../js/cleaner_room.js"></script><!--引入清洁工房间管理的自定义脚本-->
 
-<!-- 引入依赖JS文件：确保DOM加载前加载核心库，避免交互逻辑报错 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：支持响应式组件交互（如表格样式渲染） -->
-<script type="text/javascript" src="../js/cleaner_room.js"></script> <!-- 清洁工房间管理自定义JS：实现房间数据加载、分页切换、操作按钮功能等业务逻辑 -->

src/main/resources/static/pages/manage_room.html

@@ -1,76 +1,90 @@
+<!-- 管理员视角的房间管理页面 -->
 <!DOCTYPE html>
 <html>
 <head>
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配：控制页面在不同设备上的缩放行为，确保移动端显示正常且禁止手动缩放 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap基础样式：提供表格、模态框、按钮等组件的默认样式，保证界面统一性 -->
     <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，匹配整体设计风格 -->
     <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义通用页面样式：统一各页面的边距、字体等基础样式，减少重复代码 -->
     <link rel="stylesheet" type="text/css" href="../css/pages.css">
 
 </head>
-
+<!--定义页面主容器，基于 Bootstrap 栅格系统实现响应式布局：
+col-md-10：中等屏幕（≥992px）下占 10 列（总 12 列），留出两侧空白；
+col-xs-11：超小屏幕（<768px）下占 11 列，左右留少量空白；
+nopadding：自定义类，清除容器默认左右内边距；
+内联样式 padding-top:3rem：顶部内边距 3rem，与上方导航栏 / 页头拉开距离；
+内联样式 padding-left: 3rem：左侧内边距 3rem，避免列表贴左边缘。-->
 <body>
-<!-- 主体内容容器：占10列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
 <div class="col-md-10 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
-    <!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
+    <!--Bootstrap 内置类，让表格在小屏幕下可横向滚动（避免房间信息列过多导致溢出，保证移动端可读性）。-->
     <div class="table-responsive">
-        <!-- “添加房间”按钮：带铅笔图标，点击通过data属性触发“添加房间”模态框 -->
+        <!--触发 “添加房间” 弹窗的按钮：
+  data-toggle="modal" data-target="#addRoom"：Bootstrap 模态框触发属性，点击打开 id="addRoom" 的弹窗；
+  font-size:1.7rem：按钮文字放大，突出 “添加” 核心操作；
+  glyphicon glyphicon-pencil：铅笔图标，暗示 “编辑 / 新增” 功能；
+  文本 “添加房间” 明确功能，符合管理员操作场景。-->
         <a href="#" style="font-size:1.7rem" data-toggle="modal" data-target="#addRoom" >
-            <span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，标识“新增”功能 -->
+            <span class="glyphicon glyphicon-pencil"></span>
             <span>添加房间</span>
         </a>
-        <!-- 房间列表表格：带边框、鼠标悬浮高亮效果，固定列宽避免布局混乱，通过ID供JS动态渲染数据 -->
+        <!--定义房间列表表格，通过类和属性控制样式与标识：
+  table：Bootstrap 基础表格样式；
+  table-bordered：为所有单元格添加边框，清晰分隔行列；
+  table-hover：鼠标悬停行时背景色变化，提升交互体验；
+  内联样式 margin-top: 10px：顶部外边距 10px，与 “添加房间” 按钮拉开距离；
+  id="roomList"：唯一 ID，方便后续 JS 动态填充房间数据（如从后端加载列表）。-->
         <table class="table table-bordered table-hover" style="margin-top: 10px" id="roomList">
-            <!-- 表格表头：定义“位置”“价格”“状态”“类型”“操作”五列，对应房间管理核心字段 -->
+            <!--定义表头行，5 列均设置固定宽度 100px（除 “操作” 列）-->
             <tr><th style="width:100px">位置</th><th  style="width:100px">价格</th><th  style="width:100px">状态</th><th  style="width:100px">类型</th><th>操作</th></tr>
+            <!--实现分页查看房间列表：form-inline：让分页元素横向排列；
+            id="pre"/id="next"：“上一页”“下一页” 链接，后续 JS 绑定分页数据加载事件-->
         </table>
-        <!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使分页元素横向排列 -->
         <div class="col-md-12">
             <form class="form-inline">
-                <!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
-                <div class="form-group" style="margin-right: 10xp">
+                <div class="form-group" style="margin-right: 10px">
                     <a href="#" id="pre">上一页 </a>
                 </div>
-                <!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
                 <!--<div class="form-group">
                   <input type="text" style="width: 5rem" class="form-control" id="inputPage">
                   <input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
                 </div>-->
-                <!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
                 <div class="form-group" style="margin-left: 10px">
                     <a href="#" id="next">下一页</a>
                 </div>
             </form>
         </div>
     </div>
+
+
 </div>
 
 </body>
+<!--结束表格容器和页面主容器。-->
 
-<!-- 新增房间模态框：隐藏状态，通过data-target="#addRoom"触发显示，用于录入新房间信息 -->
+<!--添加房间” 弹窗-->
+<!--弹窗头部：modal fade：Bootstrap 弹窗基础样式 + 淡入淡出动画；
+关闭按钮：data-dismiss="modal" 内置关闭功能；
+标题 “添加房间” 明确弹窗用途。-->
 <div class="modal fade" id="addRoom" tabindex="-1" role="dialog">
-    <div class="modal-dialog" role="document"> <!-- 模态框容器，控制弹窗大小和位置 -->
-        <div class="modal-content"> <!-- 模态框内容区域，包含头部、主体 -->
-            <div class="modal-header"> <!-- 模态框头部：标题+关闭按钮 -->
+    <div class="modal-dialog" role="document">
+        <div class="modal-content">
+            <div class="modal-header">
                 <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
-                <h4 class="modal-title">添加房间</h4> <!-- 模态框标题，明确功能用途 -->
+                <h4 class="modal-title">添加房间</h4>
             </div>
-            <div class="modal-body" style="width: 80%;padding-left:20%"> <!-- 模态框主体：表单区域，居中布局 -->
-                <!-- 房间位置输入项：标签+输入框，通过ID供JS获取输入值 -->
+            <!--“房间位置” 输入项：form-group alterinfo：控制表单组样式（间距、对齐）-->
+            <div class="modal-body" style="width: 80%;padding-left:20%">
                 <div class="form-group alterinfo">请输入位置：
-                    <label for="inputLocal">inputPrice</label> <!-- 标签for属性与输入框ID关联，提升可访问性 -->
+                    <label for="inputLocal">inputPrice</label>
                     <input type="text" name="inputLocal" class="form-control" id="inputLocal">
                 </div>
-                <!-- 房间价格输入项 -->
+                <!--“房间价格” 输入项，id="inputPrice" 用于 JS 获取价格值。-->
                 <div class="form-group alterinfo">请输入价格：
                     <label for="inputPrice">inputPrice</label>
                     <input type="text" name="inputPrice" class="form-control" id="inputPrice">
                 </div>
-                <!-- 房间类型下拉选择项：预设单人间、双人间等选项，通过ID供JS获取选择值 -->
+                <!--“房间类型” 下拉选择框：选项值 1-4 对应不同房型，便于后端存储；id="inputType"：JS 获取选中的类型值。-->
                 <div class="form-group alterinfo">请选择类型：
                     <select class="form-control" id="inputType">
                         <option value="1">单人间</option>
@@ -79,16 +93,18 @@
                         <option value="4">套房</option>
                     </select>
                 </div>
-                <!-- 确认添加按钮：绿色按钮突出“确认”操作，通过ID供JS绑定提交事件 -->
+                <!--“确认添加” 按钮：
+               btn btn-success：Bootstrap 绿色成功样式按钮；
+               id="addRoomBtn"：JS 绑定点击事件，提交新增房间数据。-->
                 <div class="form-group alterinfo">
                     <input type="button" id="addRoomBtn" class="btn btn-success" value="确定"/>
                 </div>
             </div>
+
         </div>
     </div>
 </div>
-
-<!-- 修改房间模态框：隐藏状态，点击表格“操作”列的修改按钮触发，用于更新房间信息 -->
+<!--弹窗头部，标题为 “修改房间”，结构同 “添加房间” 弹窗。-->
 <div class="modal fade" id="alterRoom" tabindex="-1" role="dialog">
     <div class="modal-dialog" role="document">
         <div class="modal-content">
@@ -96,22 +112,22 @@
                 <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
                 <h4 class="modal-title">修改房间</h4>
             </div>
+            <!--隐藏的 “房间 ID” 输入框：
+            display:none 隐藏，不显示给用户；
+            id="reinputid"：存储待修改房间的 ID（后端需通过 ID 定位房间），JS 预先填充。-->
             <div class="modal-body" style="width: 80%;padding-left:20%">
-                <!-- 房间ID隐藏输入项：存储待修改房间的ID，不显示给用户，通过ID供JS传递参数 -->
                 <div class="form-group alterinfo" style="display:none">
                     <input type="text" class="form-control" id="reinputid">
                 </div>
-                <!-- 房间位置修改输入项：默认填充待修改房间的当前位置 -->
+                <!--：“位置”“价格”“类型” 输入项，id 前缀为 reinput（区别于 “添加” 弹窗），JS 会预先填充待修改房间的当前值。-->
                 <div class="form-group alterinfo">请输入位置：
                     <label for="reinputLocal">inputPrice</label>
                     <input type="text" name="reinputLocal" class="form-control" id="reinputLocal">
                 </div>
-                <!-- 房间价格修改输入项：默认填充当前价格 -->
                 <div class="form-group alterinfo">请输入价格：
                     <label for="reinputPrice">inputPrice</label>
                     <input type="text" name="reinputPrice" class="form-control" id="reinputPrice">
                 </div>
-                <!-- 房间类型修改下拉项：默认选中当前类型 -->
                 <div class="form-group alterinfo">请选择类型：
                     <select class="form-control" id="reinputType">
                         <option value="1">单人间</option>
@@ -120,17 +136,16 @@
                         <option value="4">套房</option>
                     </select>
                 </div>
-                <!-- 确认修改按钮：通过ID供JS绑定提交事件，提交修改后关闭模态框并刷新表格 -->
+                <!--“确认修改” 按钮，id="setRoomBtn" 绑定 JS 事件，提交修改后的房间数据。-->
                 <div class="form-group alterinfo">
                     <input type="button" id="setRoomBtn" class="btn btn-success" value="确定"/>
                 </div>
             </div>
+
         </div>
     </div>
 </div>
 </html>
-
-<!-- 引入依赖JS文件：确保DOM加载前加载核心库，避免交互逻辑报错 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：实现模态框弹出/关闭、下拉选择等组件交互 -->
-<script type="text/javascript" src="../js/manage_room.js"></script> <!-- 管理员房间管理自定义JS：实现房间数据加载、新增/修改/分页等核心逻辑 -->
+<script type="text/javascript" src="../js/jquery.min.js"></script><!--引入 jQuery 框架，简化 DOM 操作（如获取输入值、绑定事件、发送 AJAX 请求）。-->
+<script type="text/javascript" src="../js/bootstrap.min.js"></script><!--引入 Bootstrap JS 组件，激活弹窗的显示 / 隐藏、动画等交互效果。-->
+<script type="text/javascript" src="../js/manage_room.js"></script><!--自定义房间管理脚本-->

src/main/resources/static/pages/manage_staff.html

@@ -1,86 +1,90 @@
+<!-- 管理员视角的员工管理页面前端结构-->
 <!DOCTYPE html>
 <html>
 <head>
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配：控制页面在手机、平板等设备上的缩放，确保自适应显示且禁止手动缩放 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap基础样式：提供表格、模态框、按钮等组件的默认样式，保证界面统一性 -->
     <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，匹配整体设计风格 -->
     <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义通用页面样式：统一各页面的边距、字体等基础样式，减少重复代码 -->
     <link rel="stylesheet" type="text/css" href="../css/pages.css">
 
 </head>
-
+<!--定义页面主容器，基于 Bootstrap 栅格系统实现响应式布局：
+col-md-11：中等屏幕（≥992px）下占 11 列（总 12 列），左右留少量空白；
+col-xs-11：超小屏幕（<768px）下占 11 列，布局与中等屏幕一致；
+nopadding：自定义类，清除容器默认左右内边距；
+内联样式 padding-top:3rem：顶部内边距 3rem，与上方导航栏 / 页头拉开距离；
+内联样式 padding-left: 3rem：左侧内边距 3rem，避免列表贴左边缘。-->
 <body>
-<!-- 主体内容容器：占11列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
 <div class="col-md-11 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
-    <!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
     <div class="table-responsive">
-        <!-- “添加员工”按钮：带铅笔图标，通过data属性触发“添加员工”模态框，明确功能用途 -->
+        <!--触发 “添加员工” 弹窗的按钮：
+  data-toggle="modal" data-target="#addUser"：Bootstrap 模态框触发属性，点击打开 id="addUser" 的弹窗-->
         <a href="#" style="font-size:1.7rem" data-toggle="modal" data-target="#addUser" >
-            <span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，增强“新增”操作辨识度 -->
+            <span class="glyphicon glyphicon-pencil"></span>
             <span>添加员工</span>
         </a>
-        <!-- 员工列表表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染员工数据 -->
+        <!--定义员工列表表格-->
         <table class="table table-bordered table-hover" style="margin-top: 10px" id="staffList">
-            <!-- 表格表头：定义“账号”“员工号”“姓名”等核心字段，覆盖员工管理关键信息 -->
             <tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>
+            <!--实现分页查看员工列表：
+        form-inline：让分页元素横向排列；
+        id="pre"/id="next"：“上一页”“下一页” 链接，后续 JS 绑定分页数据加载事件-->
         </table>
-        <!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使分页元素横向排列 -->
         <div class="col-md-12">
             <form class="form-inline">
-                <!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
-                <div class="form-group" style="margin-right: 10xp">
+                <div class="form-group" style="margin-right: 10px">
                     <a href="#" id="pre">上一页 </a>
                 </div>
-                <!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
                 <!--<div class="form-group">
                   <input type="text" style="width: 5rem" class="form-control" id="inputPage">
                   <input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
                 </div>-->
-                <!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
                 <div class="form-group" style="margin-left: 10px">
                     <a href="#" id="next">下一页</a>
                 </div>
             </form>
         </div>
     </div>
+
+
 </div>
 
 </body>
-
-<!-- 新增员工模态框：隐藏状态，通过data-target="#addUser"触发显示，用于录入新员工基础信息 -->
+<!--定义 “添加员工” 弹窗，modal fade 是 Bootstrap 模态框基础样式（带淡入淡出动画），id="addUser" 用于触发显示。-->
 <div class="modal fade" id="addUser" tabindex="-1" role="dialog">
-    <div class="modal-dialog" role="document"> <!-- 模态框容器，控制弹窗大小和位置 -->
-        <div class="modal-content"> <!-- 模态框内容区域，包含头部、主体 -->
-            <div class="modal-header"> <!-- 模态框头部：标题+关闭按钮，明确功能并支持关闭操作 -->
+    <!--弹窗头部：关闭按钮：data-dismiss="modal" 是 Bootstrap 内置属性，点击关闭弹窗-->
+    <div class="modal-dialog" role="document">
+        <div class="modal-content">
+            <div class="modal-header">
                 <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
-                <h4 class="modal-title">添加员工</h4> <!-- 模态框标题，与按钮功能呼应 -->
+                <h4 class="modal-title">添加员工</h4>
             </div>
-            <div class="modal-body" style="width: 80%;padding-left:20%"> <!-- 模态框主体：表单区域，居中布局提升美观度 -->
-                <!-- 员工账号输入项：标签+输入框，通过ID供JS获取输入的账号（登录核心凭证） -->
+            <!--弹窗主体区域，width: 80%;padding-left:20% 让表单居中显示，避免内容贴左边缘。-->
+            <div class="modal-body" style="width: 80%;padding-left:20%">
+                <!--“员工账号” 输入项：form-group alterinfo：控制表单组样式（间距、对齐）；
+                  label 文本为 “newAcc”（提示该字段含义）；
+                  id="inputAccount"：输入框唯一标识，JS 后续获取账号值。-->
                 <div class="form-group alterinfo">请输入账号：
-                    <label for="newAcc">newAcc</label> <!-- 标签for属性与输入框ID关联，提升可访问性（点击标签聚焦输入框） -->
+                    <label for="newAcc">newAcc</label>
                     <input type="text" name="newAcc" class="form-control" id="inputAccount">
                 </div>
-                <!-- 员工初始密码输入项：用于新员工首次登录，后续可自行修改 -->
+                <!--“员工密码” 输入项-->
                 <div class="form-group alterinfo">请输入密码：
                     <label for="newPwd">newPwd</label>
                     <input type="text" name="newPwd" class="form-control" id="inputPwd">
                 </div>
-                <!-- 确认添加按钮：绿色按钮突出“确认”操作，通过ID供JS绑定提交事件 -->
+                <!--“确认添加” 按钮：btn btn-success：Bootstrap 绿色成功样式按钮，提示操作正向性；
+                  id="addUserBtn"：JS 绑定点击事件，验证并提交新增员工数据（账号、密码）。-->
                 <div class="form-group alterinfo">
                     <input type="button" id="addUserBtn" class="btn btn-success" value="确定"/>
                 </div>
             </div>
+
         </div>
     </div>
 </div>
 </html>
-
-<!-- 引入依赖JS文件：确保DOM加载前加载核心库，避免交互逻辑报错 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：实现模态框弹出/关闭、组件交互 -->
-<script type="text/javascript" src="../js/manage_staff.js"></script> <!-- 管理员员工管理自定义JS：实现员工数据加载、新增、分页等核心逻辑 -->
+<script type="text/javascript" src="../js/jquery.min.js"></script>
+<script type="text/javascript" src="../js/bootstrap.min.js"></script>
+<script type="text/javascript" src="../js/manage_staff.js"></script><!--自定义员工管理脚本-->

src/main/resources/static/pages/myCenter.html

@@ -1,63 +1,76 @@
+<!-- 酒店管理系统的主框架页面-->
 <!DOCTYPE html>
 <html>
 <head>
     <title>酒店管理系统</title>
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配：控制页面在不同设备上的缩放行为，确保自适应显示且禁止手动缩放 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap基础样式：提供导航栏、列表组等组件的默认样式，保证界面统一性 -->
     <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的导航栏、侧边栏布局与颜色，匹配系统整体风格 -->
     <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义页脚样式：控制页脚布局与文字样式（当前页脚注释未启用，预留扩展） -->
     <link rel="stylesheet" type="text/css" href="../css/footer.css">
 
 </head>
-
+<!--定义系统顶部导航栏，navbar navbar-default 是 Bootstrap 导航栏基础样式，后续通过自定义样式覆盖默认外观。-->
 <body>
-<!-- 顶部导航栏：采用Bootstrap默认导航栏组件，展示系统名称与用户操作入口 -->
 <nav class="navbar navbar-default">
-    <div class="container-fluid nav-con"> <!-- 导航栏容器，通过自定义类控制样式 -->
-        <div class="navbar-header"> <!-- 导航栏头部：包含系统名称与移动端菜单按钮 -->
-            <!-- 移动端折叠按钮：屏幕缩小时显示，点击展开导航菜单 -->
+    <!--导航栏容器，container-fluid 使导航栏占满屏幕宽度；nav-con 是自定义类（可能控制导航栏内边距，如大屏下左右留白）。-->
+    <div class="container-fluid nav-con">
+        <!--移动端 “汉堡按钮”（折叠导航触发器）：navbar-toggle collapsed：Bootstrap 折叠按钮样式，默认折叠状态；
+          data-toggle="collapse" data-target="#bs-example-navbar-collapse-1"：点击时展开 / 折叠目标导航菜单；
+          3 个 icon-bar 组成汉堡图标，适配移动端小屏幕。-->
+        <div class="navbar-header">
             <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
                 <span class="sr-only">Toggle navigation</span>
                 <span class="icon-bar"></span>
                 <span class="icon-bar"></span>
                 <span class="icon-bar"></span>
             </button>
-            <!-- 系统名称：突出显示，作为导航栏品牌标识 -->
+            <!--导航栏品牌标识（系统名称）：navbar-brand：Bootstrap 品牌样式，通常放 logo 或系统名；
+            内联样式 padding-top: 2rem 调整名称垂直位置，color: white 设为白色（配合导航栏深色背景）；
+            文字放大（2.3rem）+ 字符间距（2px），突出系统名称。-->
             <a class="navbar-brand" href="#" style="padding-top: 2rem;color: white">
                 <span style="font-size: 2.3rem;padding-right: 2rem;letter-spacing: 2px">酒店管理系统</span>
             </a>
         </div>
-        <!-- 导航栏右侧菜单：包含用户欢迎语与退出入口 -->
+        <!--导航栏右侧菜单：collapse navbar-collapse：与汉堡按钮联动，控制菜单展开 / 折叠；
+          navbar-right：菜单右对齐；
+          navli：自定义类（控制菜单项间距，如右侧留白）；
+          “欢迎！”：后续可通过 JS 动态填充当前登录用户（如 “欢迎！管理员”）；
+          “退出”：点击跳转至登录页（../index.html），实现退出登录。-->
         <div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
             <ul class="nav navbar-nav navbar-right">
-                <li class="navli"><a href="#">欢迎！</a></li> <!-- 动态显示当前登录用户名（需JS填充） -->
-                <li class="navli"><a href="../index.html">退出</a></li> <!-- 退出系统，跳转回登录页 -->
+                <li class="navli"><a href="#">欢迎！</a></li>
+                <li class="navli"><a href="../index.html">退出</a></li>
             </ul>
         </div>
     </div>
 </nav>
-
-<!-- 主体内容区：左右分栏布局，占满12列 -->
+<!--主内容区外层容器，col-md-12 占满整行，main 是自定义类，nopadding 清除默认内边距。-->
 <div class="col-md-12 main nopadding">
-    <!-- 左侧侧边栏：占2列，展示功能菜单列表 -->
+    <!--左侧功能导航栏：
+        col-md-2：中等屏幕下占 2 列（总 12 列），宽度约 1/6，为右侧内容区留空间；
+        navlist：自定义类（控制导航栏样式，如深色背景、最小高度）；
+        list-group：Bootstrap 列表组样式，用于渲染导航项；
+        id="tagList"：空容器，后续通过 JS 动态填充系统模块（如 “员工管理”“房间管理”“订单管理”），实现导航项的灵活加载。-->
     <div class="col-md-2 navlist nopadding">
         <div class="list-group" id="tagList">
-            <!-- 功能菜单通过JS动态生成（根据用户权限显示不同菜单，如管理员显示“员工管理”，清洁工显示“房间清洁”） -->
+
         </div>
-    </div>
 
-    <!-- 右侧内容展示区：占10列，通过iframe加载具体功能页面 -->
+
+    </div>
+    <!--右侧内容展示区，通过 iframe 加载具体功能页面：
+    col-md-10：中等屏幕下占 10 列，与左侧 col-md-2 合计 12 列，填满主内容区；
+    iframe：嵌入式框架，用于加载外部页面（无需刷新主框架）；
+    frameborder="0"：隐藏 iframe 边框，避免视觉割裂；
+    id="mainFrame"/name="mainFrame"：标识 iframe，方便 JS 控制跳转（如点击左侧导航，更新 iframe 的 src 加载对应页面）；
+    mainFrame：自定义类（控制 iframe 尺寸，如 width:100%; min-height:60rem，确保填满右侧区域）；
+    src=""：初始为空，后续通过 JS 设置默认加载页面-->
     <div class="col-md-10 nopadding">
         <iframe frameborder="0" id="mainFrame" class="mainFrame" name="mainFrame" src=""></iframe>
-        <!-- iframe特性：页面切换时不刷新整体布局，仅加载内部内容，提升操作流畅度 -->
     </div>
-</div>
 
-<!-- 页脚（当前注释未启用）：预留系统版权、联系信息等内容展示区域 -->
+</div>
 <!--
 <footer class="col-md-12 bs-docs-footer">
   <div class="col-md-12">
@@ -68,16 +81,15 @@
     <a href="#">诚征英才</a>
     <a href="#">联系我们</a>
     <a href="#">网站地图</a><br/><br/>
-    <em>Copyright © 2025 合肥师范学院 All Rights Reserved</em>
+    <em>Copyright © 2017 西安工业大学 All Rights Reserved</em>
     </p>
+
   </div>
-</footer>
--->
+</footer>-->
+
 
 </body>
 </html>
-
-<!-- 引入依赖JS文件：确保DOM加载前加载核心库，实现导航、菜单、iframe加载等功能 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：实现导航栏折叠、列表组交互等 -->
-<script type="text/javascript" src="../js/myCenter.js"></script> <!-- 系统主页面JS：动态生成侧边栏菜单、控制iframe加载、填充用户名等核心逻辑 -->
+<script type="text/javascript" src="../js/jquery.min.js"></script>
+<script type="text/javascript" src="../js/bootstrap.min.js"></script>
+<script type="text/javascript" src="../js/myCenter.js"></script><!--自定义主框架脚本-->

src/main/resources/static/pages/staff_cleaner.html

@@ -1,86 +1,80 @@
+<!-- 清洁工专项管理页面 的前端结构-->
 <!DOCTYPE html>
 <html>
 <head>
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配：控制页面在手机、平板等设备上的缩放，确保自适应显示且禁止手动缩放 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap基础样式：提供表格、模态框、按钮等组件的默认样式，保证界面统一性 -->
     <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，匹配系统整体设计风格 -->
     <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义通用页面样式：统一各页面的边距、字体等基础样式，减少重复代码 -->
     <link rel="stylesheet" type="text/css" href="../css/pages.css">
 
 </head>
-
+<!--定义页面主容器-->
 <body>
-<!-- 主体内容容器：占11列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
 <div class="col-md-11 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
-    <!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
     <div class="table-responsive">
-        <!-- “添加清洁工”按钮：带铅笔图标，通过data属性触发“添加清洁工”模态框，明确功能指向 -->
+        <!--触发 “添加清洁工” 弹窗的核心操作按钮-->
         <a href="#" style="font-size:1.7rem" data-toggle="modal" data-target="#addUser" >
-            <span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，增强“新增”操作辨识度 -->
+            <span class="glyphicon glyphicon-pencil"></span>
             <span>添加清洁工</span>
         </a>
-        <!-- 清洁工列表表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染清洁工数据 -->
+        <!--展示清洁工信息的核心表格-->
         <table class="table table-bordered table-hover" style="margin-top: 10px" id="staffList">
-            <!-- 表格表头：定义“账号”“员工号”“姓名”等核心字段，覆盖清洁工管理的关键信息 -->
             <tr><th>账号</th><th>员工号</th><th>姓名</th><th>年龄</th><th>职位</th><th>联系方式</th><th>操作</th></tr>
+            <!--实现清洁工列表的分页查看-->
         </table>
-        <!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使分页元素横向排列 -->
         <div class="col-md-12">
             <form class="form-inline">
-                <!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
-                <div class="form-group" style="margin-right: 10xp">
+                <div class="form-group" style="margin-right: 10px">
                     <a href="#" id="pre">上一页 </a>
                 </div>
-                <!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
                 <!--<div class="form-group">
                   <input type="text" style="width: 5rem" class="form-control" id="inputPage">
                   <input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
                 </div>-->
-                <!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
                 <div class="form-group" style="margin-left: 10px">
                     <a href="#" id="next">下一页</a>
                 </div>
             </form>
         </div>
     </div>
+
+
 </div>
 
 </body>
-
-<!-- 新增清洁工模态框：隐藏状态，通过data-target="#addUser"触发显示，用于录入新清洁工基础信息 -->
+<!--定义 “添加清洁工” 的弹窗-->
 <div class="modal fade" id="addUser" tabindex="-1" role="dialog">
-    <div class="modal-dialog" role="document"> <!-- 模态框容器，控制弹窗大小和位置 -->
-        <div class="modal-content"> <!-- 模态框内容区域，包含头部、主体 -->
-            <div class="modal-header"> <!-- 模态框头部：标题+关闭按钮，明确功能并支持关闭操作 -->
+    <!--弹窗头部区域，包含关闭按钮和标题：关闭按钮：data-dismiss="modal" 是 Bootstrap 内置属性，点击后直接关闭弹窗；&times; 是 “×” 符号，直观表示关闭功能；
+         标题 “添加清洁工”：明确弹窗用途，与按钮文字呼应-->
+    <div class="modal-dialog" role="document">
+        <div class="modal-content">
+            <div class="modal-header">
                 <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
-                <h4 class="modal-title">添加清洁工</h4> <!-- 模态框标题，与按钮功能呼应，避免混淆 -->
+                <h4 class="modal-title">添加清洁工</h4>
             </div>
-            <div class="modal-body" style="width: 80%;padding-left:20%"> <!-- 模态框主体：表单区域，居中布局提升美观度与操作便捷性 -->
-                <!-- 清洁工账号输入项：标签+输入框，账号为登录核心凭证，通过ID供JS获取输入值 -->
+
+            <div class="modal-body" style="width: 80%;padding-left:20%">
+                <!--“清洁工账号” 输入项-->
                 <div class="form-group alterinfo">请输入账号：
-                    <label for="newAcc">newAcc</label> <!-- 标签for属性与输入框ID关联，点击标签可聚焦输入框，提升可访问性 -->
+                    <label for="newAcc">newAcc</label>
                     <input type="text" name="newAcc" class="form-control" id="inputAccount">
                 </div>
-                <!-- 清洁工初始密码输入项：用于新清洁工首次登录，后续可自行修改密码 -->
+                <!--“清洁工密码” 输入项-->
                 <div class="form-group alterinfo">请输入密码：
                     <label for="newPwd">newPwd</label>
                     <input type="text" name="newPwd" class="form-control" id="inputPwd">
                 </div>
-                <!-- 确认添加按钮：绿色按钮突出“确认”操作，通过ID供JS绑定提交事件，点击后完成新增 -->
+                <!--“确认添加” 按钮-->
                 <div class="form-group alterinfo">
                     <input type="button" id="addUserBtn" class="btn btn-success" value="确定"/>
                 </div>
             </div>
+
         </div>
     </div>
 </div>
 </html>
-
-<!-- 引入依赖JS文件：确保DOM加载前加载核心库，实现数据渲染、模态框交互等功能 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：实现模态框弹出/关闭、组件交互 -->
-<script type="text/javascript" src="../js/staff_cleaner.js"></script> <!-- 清洁工管理自定义JS：实现列表渲染、新增提交、分页等核心逻辑 -->
+<script type="text/javascript" src="../js/jquery.min.js"></script>
+<script type="text/javascript" src="../js/bootstrap.min.js"></script>
+<script type="text/javascript" src="../js/staff_cleaner.js"></script><!--清洁工专项管理的自定义脚本-->

src/main/resources/static/pages/staff_order.html

@@ -1,70 +1,65 @@
+<!--员工视角的订单管理页面前端结构-->
 <!DOCTYPE html>
 <html>
 <head>
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配：控制页面在不同设备上的缩放行为，确保自适应显示且禁止手动缩放 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap基础样式：提供表格、模态框等组件的默认样式，保证界面统一性 -->
     <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，匹配系统整体设计风格 -->
     <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义通用页面样式：统一各页面的边距、字体等基础样式，减少重复代码 -->
     <link rel="stylesheet" type="text/css" href="../css/pages.css">
 
 </head>
 
 <body>
-<!-- 主体内容容器：占8列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
 <div class="col-md-8 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
-    <!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
     <div class="table-responsive">
-        <!-- 订单列表表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染订单数据 -->
+        <!--定义订单列表表格-->
         <table class="table table-bordered table-hover" style="margin-top: 10px" id="orderList">
-            <!-- 表格表头：定义“入住人”“身份证号”“时间”“金额”“状态”“操作”列，覆盖员工所需的订单核心信息 -->
             <tr><th>入住人</th><th>身份证号</th><th>开始时间</th><th>结束时间</th><th>总金额</th><th>状态</th><th>操作</th></tr>
+            <!--实现订单列表的分页查看-->
         </table>
-        <!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使分页元素横向排列 -->
         <div class="col-md-12">
             <form class="form-inline">
-                <!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
-                <div class="form-group" style="margin-right: 10xp">
+                <div class="form-group" style="margin-right: 10px">
                     <a href="#" id="pre">上一页 </a>
                 </div>
-                <!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
                 <!--<div class="form-group">
                   <input type="text" style="width: 5rem" class="form-control" id="inputPage">
                   <input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
                 </div>-->
-                <!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
                 <div class="form-group" style="margin-left: 10px">
                     <a href="#" id="next">下一页</a>
                 </div>
             </form>
         </div>
     </div>
+
+
 </div>
 
 </body>
 </html>
-
-<!-- 房间详情模态框：隐藏状态，点击订单“操作”列按钮触发显示，用于查看订单关联的房间信息 -->
+<!--定义 “查看房间详情” 的弹窗-->
 <div class="modal fade" id="showRoomT" tabindex="-1" role="dialog" aria-labelledby="myModalLabel">
-    <div class="modal-dialog" role="document"> <!-- 模态框容器，控制弹窗大小和位置 -->
-        <div class="modal-content"> <!-- 模态框内容区域，包含头部、主体 -->
-            <div class="modal-header"> <!-- 模态框头部：标题+关闭按钮，明确功能并支持关闭操作 -->
+    <!--弹窗头部区域-->
+    <div class="modal-dialog" role="document">
+        <div class="modal-content">
+            <div class="modal-header">
                 <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
-                <h4 class="modal-title" id="myModalLabel">房间详情</h4> <!-- 模态框标题，清晰标识内容用途 -->
+                <h4 class="modal-title" id="myModalLabel">房间详情</h4>
             </div>
-            <div class="modal-body"> <!-- 模态框主体：展示房间详情的表格容器 -->
+            <!--弹窗主体区域，用于展示订单关联的房间信息-->
+            <div class="modal-body">
                 <table class="table table-bordered table-hover" style="margin-top: 10px" id="roomTable">
-                    <!-- 表格内容通过JS动态渲染（如房间位置、价格、类型等） -->
                 </table>
             </div>
         </div>
     </div>
 </div>
+<!--结束弹窗内容、容器和模态框整体标签。-->
+
+
+<script type="text/javascript" src="../js/jquery.min.js"></script>
+<script type="text/javascript" src="../js/bootstrap.min.js"></script>
+<script type="text/javascript" src="../js/staff_order.js"></script><!--自定义员工订单管理脚本-->
 
-<!-- 引入依赖JS文件：确保DOM加载前加载核心库，实现数据渲染、模态框交互等功能 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：实现模态框弹出/关闭、组件交互 -->
-<script type="text/javascript" src="../js/staff_order.js"></script> <!-- 员工订单管理自定义JS：实现订单列表渲染、分页、房间详情查看等逻辑 -->

src/main/resources/static/pages/staff_room.html

@@ -1,99 +1,97 @@
+<!--员工视角的房间管理与订单生成页面 前端结构-->
 <!DOCTYPE html>
 <html>
 <head>
     <meta http-equiv="Content-Type" Content="text/html; charset=utf-8">
-    <!-- 移动端适配：控制页面在手机、平板等设备上的缩放，确保自适应显示且禁止手动缩放 -->
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-    <!-- 引入Bootstrap基础样式：提供表格、模态框、输入框等组件的默认样式，保证界面统一性 -->
     <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
-    <!-- 引入自定义个人中心样式：补充项目专属的布局、颜色等样式，匹配系统整体设计风格 -->
     <link rel="stylesheet" type="text/css" href="../css/myCenter.css">
-    <!-- 引入自定义通用页面样式：统一各页面的边距、字体等基础样式，减少重复代码 -->
     <link rel="stylesheet" type="text/css" href="../css/pages.css">
 
 
 </head>
 
 <body>
-<!-- 主体内容容器：占8列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距调整位置 -->
 <div class="col-md-8 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
-    <!-- 响应式表格容器：小屏幕下自动显示横向滚动条，避免表格内容溢出页面 -->
     <div class="table-responsive">
-        <!-- 房间列表表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染房间数据 -->
+        <!--id="roomList"：唯一 ID，方便后续 JavaScript 动态填充房间数据（如从后端加载房间列表，区分 “空闲”“已入住” 等状态）-->
         <table class="table table-bordered table-hover" style="margin-top: 10px" id="roomList">
-            <!-- 表格表头：定义“位置”“价格”“状态”“类型”“操作”列，覆盖员工查看与操作房间的核心信息 -->
             <tr><th>位置</th><th>价格</th><th>状态</th><th>类型</th><th>操作</th></tr>
+            <!--实现房间列表的分页查看-->
         </table>
-        <!-- 分页控制区：占12列（全屏宽度），采用内联表单布局使分页元素横向排列 -->
         <div class="col-md-12">
             <form class="form-inline">
-                <!-- 上一页按钮：设置右侧间距，通过ID供JS绑定分页切换事件 -->
-                <div class="form-group" style="margin-right: 10xp">
+                <div class="form-group" style="margin-right: 10px">
                     <a href="#" id="pre">上一页 </a>
                 </div>
-                <!-- （注释待启用）页码跳转功能：输入页码后点击按钮跳转，当前暂未实现 -->
                 <!--<div class="form-group">
                   <input type="text" style="width: 5rem" class="form-control" id="inputPage">
                   <input type="button" id="setPageBtn" class="btn btn-default" value="跳转">
                 </div>-->
-                <!-- 下一页按钮：设置左侧间距，通过ID供JS绑定分页切换事件 -->
                 <div class="form-group" style="margin-left: 10px">
                     <a href="#" id="next">下一页</a>
                 </div>
             </form>
         </div>
     </div>
+
+
 </div>
 
 </body>
-
-<!-- 生成订单模态框：隐藏状态，点击房间“操作”列的“预订”按钮触发，用于录入客人信息并创建订单 -->
+<!--定义 “为房间生成订单” 的弹窗-->
 <div class="modal fade" id="chooseRoom" tabindex="-1" role="dialog">
-    <div class="modal-dialog" role="document"> <!-- 模态框容器，控制弹窗大小和位置 -->
-        <div class="modal-content"> <!-- 模态框内容区域，包含头部、主体 -->
-            <div class="modal-header"> <!-- 模态框头部：标题+关闭按钮，明确功能并支持关闭操作 -->
+    <!--弹窗头部区域：
+     关闭按钮：data-dismiss="modal" 是 Bootstrap 内置属性，点击关闭弹窗；&times; 为 “×” 符号，直观表示关闭；
+     标题 “生成订单”：明确弹窗用途，与房间列表 “操作” 列功能呼应。-->
+    <div class="modal-dialog" role="document">
+        <div class="modal-content">
+            <div class="modal-header">
                 <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
-                <h4 class="modal-title">生成订单</h4> <!-- 模态框标题，清晰标识功能用途 -->
+                <h4 class="modal-title">生成订单</h4>
             </div>
-            <div class="modal-body" style="width: 80%;padding-left:20%"> <!-- 模态框主体：表单区域，居中布局提升操作便捷性 -->
-                <!-- 房间位置展示项：仅显示选中房间的位置，不可编辑，通过ID供JS填充数据 -->
+            <div class="modal-body" style="width: 80%;padding-left:20%">
+                <!--房间位置显示项：非输入框，通过 id="inputLocal" 由 JS 动态填充当前选中房间的位置。-->
                 <div class="form-group alterinfo">位置：
                     <span id="inputLocal"></span>
                 </div>
-                <!-- 入住人姓名输入项：必填，通过ID供JS获取客人姓名 -->
+                <!--入住人姓名输入项-->
                 <div class="form-group alterinfo">入住人姓名：
-                    <label for="inputName">inputName</label> <!-- 标签与输入框关联，提升可访问性 -->
+                    <label for="inputName">inputName</label>
                     <input type="text" name="inputName" class="form-control" id="inputName">
                 </div>
-                <!-- 身份证号输入项：必填，用于身份核验，通过ID供JS获取 -->
+                <!--入住人身份证号输入项-->
                 <div class="form-group alterinfo">身份证号：
                     <label for="inputId">inputId</label>
                     <input type="text" name="inputId" class="form-control" id="inputId">
                 </div>
-                <!-- 入住开始日期选择项：集成日期选择器，支持日历弹窗选择，避免手动输入格式错误 -->
+                <!--入住开始日期选择项-->
                 <div class="form-group alterinfo">开始日期：
                     <label for="inputStart">inputId</label>
                     <input type="text" name="inputStart" class="form-control"  data-provide="datepicker" id="dateStart">
                 </div>
-                <!-- 入住结束日期选择项：同开始日期，支持日历弹窗选择 -->
+                <!--入住结束日期选择项-->
                 <div class="form-group alterinfo">结束日期：
                     <label for="inputEnd">inputId</label>
                     <input type="text" name="inputEnd" class="form-control" data-provide="datepicker" id="dateEnd">
                 </div>
-                <!-- 确认生成订单按钮：绿色按钮突出“确认”操作，通过ID供JS绑定提交事件 -->
+                <!--“确认生成订单” 按钮-->
                 <div class="form-group alterinfo">
                     <input type="button" id="addOrder" class="btn btn-success" value="确定"/>
                 </div>
             </div>
+
         </div>
     </div>
 </div>
 
 
 </html>
-<!-- 引入依赖JS文件：确保DOM加载前加载核心库，实现数据渲染、日期选择、模态框交互等功能 -->
-<script type="text/javascript" src="../js/jquery.min.js"></script> <!-- jQuery：提供DOM操作、AJAX请求核心能力 -->
-<script type="text/javascript" src="../js/bootstrap.min.js"></script> <!-- Bootstrap JS：实现模态框、组件交互 -->
-<script type="text/javascript" src="../js/bootstrap-datepicker.js"></script> <!-- 日期选择器核心JS：提供日历弹窗功能 -->
-<script type="text/javascript" src="../js/bootstrap-datepicker.zh-CN.min.js"></script> <!-- 日期选择器中文包：显示中文日历与提示 -->
-<script type="text/javascript" src="../js/staff_room.js"></script> <!-- 员工房间管理自定义JS：实现房间列表渲染、订单生成、分页等核心逻辑 -->
+<script type="text/javascript" src="../js/jquery.min.js"></script>
+<script type="text/javascript" src="../js/bootstrap.min.js"></script>
+<script type="text/javascript" src="../js/bootstrap-datepicker.js"></script><!--引入 Bootstrap Datepicker 日期选择器插件-->
+<script type="text/javascript" src="../js/bootstrap-datepicker.zh-CN.min.js"></script>
+<script type="text/javascript" src="../js/staff_room.js"></script><!--自定义房间管理与订单生成脚本-->
+
+
+