README.md

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

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,-- 配置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--指定索引使用的数据结构
+  `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
 ) 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,--订单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。
+  `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,
   `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,20 +12,17 @@ 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,50 +1,46 @@
 package com.jiudian.manage.config;
-//// 导入Spring相关注解和类，是核心组件
-import org.springframework.context.annotation.Bean;//spring对象
-import org.springframework.context.annotation.Configuration;//注释组件
-import org.springframework.http.converter.HttpMessageConverter;//负责 HTTP 请求 / 响应消息转换的组件
+// 导入Spring相关注解和类
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.converter.HttpMessageConverter;
 import org.springframework.http.converter.StringHttpMessageConverter;
-import org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer;//配置内容协商（如根据请求头确定返回数据格式）
-import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;// Spring MVC 的配置适配器组件，用于定制 Web 层的行为（如消息转换、拦截器、视图解析等
+import org.springframework.web.servlet.config.annotation.ContentNegotiationConfigurer;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
 
-import java.nio.charset.Charset;//Java 标准库中处理字符集的类
-import java.util.List;//Java 集合框架中的列表接口，用于存储转换器集合。
+import java.nio.charset.Charset;
+import java.util.List;
 
-// * 自定义MVC配置类
-// * 用于配置HTTP消息转换和内容协商，解决中文乱码问题
-// */
-//Spring 会执行这些方法，将返回的对象存入容器（即 “注册 Bean”），供其他组件依赖注入
-
-@Configuration //标识当前类是配置类，Spring 会扫描并加载其中的配置。
+// 标记当前类为Spring配置类，用于定义Spring Bean和配置
+@Configuration
+// 自定义MVC配置类，继承WebMvcConfigurerAdapter以扩展Spring MVC的默认配置
+// 注意：WebMvcConfigurerAdapter在Spring 5.0后已过时，推荐直接实现WebMvcConfigurer接口
 public class CustomMVCConfiguration extends WebMvcConfigurerAdapter {
-    //创建并配置String类型的HTTP消息转换器
+
+    // 定义一个Bean，用于处理HTTP消息转换（主要是String类型响应）
     @Bean
-    // 声明这是一个Bean，会被Spring容器管理
-    // 创建字符串消息转换器，处理响应体中字符串转换，设置字符集为UTF-8
-    public HttpMessageConverter<String> responseBodyConverter(){
+    public HttpMessageConverter<String> responseBodyConverter() {
+        // 创建字符串HTTP消息转换器，并指定字符集为UTF-8，解决响应中文乱码问题
         StringHttpMessageConverter converter = new StringHttpMessageConverter(
                 Charset.forName("UTF-8"));
-        return converter;//返回创建的转换器对象，交给 Spring 容器管理。
+        return converter;
     }
 
-    @Override//重写父类，自定义消息转换器配置
-    //HttpMessageConverter<?>：这是 Spring 框架中定义的HTTP 消息转换器接口
-    // ，其中 <?> 是泛型通配符，表示该转换器可以处理任意类型的数据。
-    //List<HttpMessageConverter<?>> converters 表示：一个包含多种 HTTP 消息转换器的列表
+    // 重写配置消息转换器的方法，用于注册自定义的消息转换器
+    @Override
     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,87 +1,105 @@
-package com.jiudian.manage.controller;
-//导入所需的类和注解：
-//自定义类：Config（配置信息的实体类）、ConfigService（处理配置业务的服务类）、
-// State（状态常量类，如成功 / 错误码）、StateSignal（统一响应格式工具类）。
-//Spring 注解：@Autowired（依赖注入）、@RestController（标识 REST 控制器）、
-// @RequestMapping（映射 URL 路径）、@RequestParam（接收请求参数）。
-//Java 标准类：Map（用于返回键值对格式的响应数据）。
+
+// 定义包路径，属于酒店管理系统的控制层
+        package com.jiudian.manage.controller;
+
+// 导入配置实体类
 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;
-import java.util.Map;
 
-// * 配置管理控制器
-// * 处理与系统配置相关的HTTP请求
-/*流程：1调用服务层获取配置数据。
-        2通过StateSignal统一封装响应格式（无论成功 / 失败，结构一致，方便前端解析）。
-       3. 返回封装后的 Map（自动转为 JSON 响应给前端）。*/
+// 导入Map集合（用于返回接口结果）
+import java.util.Map;
 
-@RestController //标记此类为REST控制器，所有方法返回JSON格式数据
-//建立URL路径与java方法的映射关系，客户端发起HTTP请求，会自动调用该注释的方法
-@RequestMapping(value = "/config") //SpringMVC的注释语法，定义基础URL路径，所有方法的URL都以此为前缀
-//value 是注解的属性，用于指定映射的 URL 路径
-//创建类：配置管理控制器
+// 标识该类为REST风格控制器，所有方法返回值会自动转为JSON
+@RestController
+// 定义该控制器的基础请求路径，所有接口路径都以"/config"开头
+@RequestMapping(value = "/config")
 public class ConfigController {
-    //自动注入ConfigService服务,依赖注入，用于后续调用configservice类中的方法
+    // 自动注入ConfigService实例，用于调用业务层方法
     @Autowired
     ConfigService configService;
 
     /**
-     * 获取系统配置信息
-     * @return 包含配置信息的Map对象
+     * 获取系统配置信息的接口
+     * @return 包含配置信息的Map集合（封装了状态码、提示信息和配置数据）
      */
-    @RequestMapping(value = "/getConfig.do") //定义具体的URL路径
+    // 定义接口请求路径，完整路径为"/config/getConfig.do"
+    @RequestMapping(value = "/getConfig.do")
     public Map getConfig(){
-        // 调用服务层获取配置信息
+        // 调用服务层方法获取配置信息
         Config config = configService.get();
-        // 创建状态信号对象，用于统一返回格式
+        // 创建状态信号对象，用于封装返回结果
         StateSignal signal = new StateSignal();
+        // 判断是否获取到配置信息
         if(config!=null){
-            // 配置存在，返回成功状态和配置数据
+            // 若获取成功，存入成功状态码
             signal.put(State.SuccessCode);
+            // 存入成功提示信息
             signal.put(State.SuccessMessage);
-            signal.put("config",config);// 键为"config"，值为获取到的配置对象
+            // 存入获取到的配置对象，键为"config"
+            signal.put("config",config);
         }else {
-            // 配置不存在，返回错误状态
+            // 若获取失败，存入错误状态码
             signal.put(State.ErrorCode);
+            // 存入错误提示信息
             signal.put(State.ErrorMessage);
         }
-        return signal.getResult();//自动转为 JSON 响应给前端
+        // 返回封装好的结果Map
+        return signal.getResult();
     }
 
     /**
-     * 修改配置
-     * @param managesalary  经理薪水百分比
-     * @param staffsalary   员工薪水百分比
-     * @param cleanerssalary    保洁员薪水百分比
-     * @param manage    经理底薪
-     * @param staff     员工底薪
-     * @param cleaner   保洁员底薪
-     * @param totalmoney    总营业额
-     * @param totalroom     总卖出房数
-     * @return
+     * 修改系统配置的接口
+     * @param managesalary 经理薪水百分比
+     * @param staffsalary 员工薪水百分比
+     * @param cleanerssalary 保洁员薪水百分比
+     * @param manage 经理底薪
+     * @param staff 员工底薪
+     * @param cleaner 保洁员底薪
+     * @param totalmoney 总营业额（可选参数，默认值为-1）
+     * @param totalroom 总卖出房数（可选参数，默认值为-1）
+     * @return 包含修改结果的Map集合（封装了状态码和提示信息）
      */
-    @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){
-
+    // 定义接口请求路径，完整路径为"/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){
+        // 调用服务层方法执行修改操作，接收修改结果（布尔值）
         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,10 +1,5 @@
 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;
@@ -14,60 +9,71 @@ 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;//Spring 封装的上传文件对象，用于接收前端上传的文件
+import org.springframework.web.multipart.MultipartFile;
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.util.Map;
 import java.util.Random;
-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以此为前缀
+import java.util.UUID;
+//该控制器的主要功能：
+//处理用户头像上传请求，路径为/upFile/upFilePhoto.do
+//核心流程：
+//生成唯一文件名（避免重复）
+//定义文件存储路径（本地路径 + 数据库存储的相对路径）
+//调用工具类上传文件到本地服务器
+//调用用户服务更新数据库中的用户头像路径
+//根据上传和数据库更新的结果，返回成功 / 失败的响应状态
+// 标记为REST风格控制器，所有方法返回数据而非视图
+@RestController
+// 配置请求路径前缀，所有方法的请求路径都以"/upFile"开头
+@RequestMapping(value = "/upFile")
 public class FileController {
-    // 自动注入UserService服务
+
+    // 自动注入用户服务类，用于处理用户相关业务（此处主要用于更新用户头像路径）
     @Autowired
     UserService userService;
 
+    // 配置具体请求路径，处理用户头像上传请求
     @RequestMapping("/upFilePhoto.do")
-    //返回Map类型（会自动转为 JSON），参数为 “上传文件” 和 “用户 ID”；
-    public Map upFilePhoto(@RequestParam MultipartFile file,@RequestParam int userid){
-        //接受前端上传文件和用户Id参数
-        // 生成唯一的文件名，避免文件名冲突
-        // 使用UUID+原始文件名
-        String fileName = UUID.randomUUID().toString()+file.getOriginalFilename();
-//定义文件保存路径
-        // 本地保存路径：项目资源目录下的static/File文件夹
+    // @RequestParam指定请求参数：file为上传的文件，userid为用户ID
+    public Map upFilePhoto(@RequestParam MultipartFile file, @RequestParam int userid) {
+        // 生成唯一文件名：UUID避免文件名重复 + 原始文件扩展名（保留文件类型）
+        String fileName = UUID.randomUUID().toString() + file.getOriginalFilename();
+
+        // 本地文件存储路径（项目内的静态资源目录）
         String filePath = ".\\src\\main\\resources\\static\\File\\";
-        // 数据库存储的“相对路径”：前端访问时用该路径
-        String RealfilePath = "File"+"/"+fileName;
-        // 更新用户头像路径到数据库
+        // 数据库存储的相对路径（用于前端访问时拼接完整路径）
+        String RealfilePath = "File\\" + fileName;
+
+        // 调用用户服务，更新该用户的头像路径到数据库
         boolean photo = userService.photo(userid, RealfilePath);
-        boolean b = false;
+
+        // 标记文件上传是否成功
+        boolean uploadSuccess = false;
         try {
-           b = FileUtil.uploadFile(file.getBytes(), filePath, fileName);
+            // 调用文件工具类，将文件字节数据上传到指定路径
+            uploadSuccess = FileUtil.uploadFile(file.getBytes(), filePath, fileName);
         } catch (Exception e) {
-            // 捕获并打印异常信息
+            // 捕获上传过程中的异常并打印堆栈信息
             e.printStackTrace();
         }
-        // 创建状态信号对象，封装 API 接口，用于统一JSON回格式
+
+        // 创建状态信号对象，用于封装响应结果
         StateSignal signal = new StateSignal();
-        if(b&&photo){
+
+        // 判断文件上传和数据库更新是否都成功
+        if (uploadSuccess && 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,130 +1,145 @@
 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;//URL映射
-import org.springframework.web.bind.annotation.RequestParam;//接受参数请求
-import org.springframework.web.bind.annotation.RestController;//REST控制器
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
 
 import java.util.List;
 import java.util.Map;
-/**
- * 订单管理控制器
- * 处理酒店预订系统中的订单相关操作
- * 这个控制器实现了酒店订单管理的核心功能，包括创建、删除、更新和分页查询订单
- * 每个接口通过@RequestMapping绑定特定 URL，接收前端参数后调用OrderServiceImpl处理业务；
- * 统一使用StateSignal封装响应格式（包含状态码、消息、数据），确保前端能统一解析
- */
+//该控制器的主要功能：
+//提供订单全生命周期的接口：添加、删除、修改状态、分页查询
+//所有接口返回统一格式的响应结果（通过StateSignal封装状态码、提示信息及业务数据）
+//依赖OrderServiceImpl处理具体业务逻辑，控制器层主要负责接收请求、参数传递和结果封装
+//接口路径设计遵循 REST 风格，通过@RequestMapping指定具体访问路径，便于前端调用
+// 标记为REST风格控制器，所有方法返回JSON数据而非视图
 @RestController
-@RequestMapping(value = "/order")//定义该订单控制器的基础路径
+// 配置请求路径前缀，所有订单相关接口路径都以"/order"开头
+@RequestMapping(value = "/order")
 public class OrderController {
+
+    // 自动注入订单服务实现类，用于处理订单相关业务逻辑
     @Autowired
     OrderServiceImpl orderService;
-//: 自动注入订单服务实现类
+
     /**
-     * 添加订单
+     * 添加订单接口
      * @param householdname 入住人姓名
-     * @param id            入住人身份证号
-     * @param starttime     开始时间
-     * @param endtime       结束时间
-     * @param roomid        房间id
-     * @param userid        用户id
-     * @return
+     * @param id 入住人身份证号
+     * @param starttime 入住开始时间
+     * @param endtime 入住结束时间
+     * @param roomid 房间ID（关联对应的房间）
+     * @param userid 用户ID（下单用户的ID）
+     * @return 包含操作结果的Map（状态码、提示信息）
      */
-    //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 b = orderService.addOrder(householdname, id, starttime, endtime, roomid, userid);
-        // 创建统一响应对象StateSignal，封装响应状态和数据
+    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);
+
+        // 创建状态信号对象，用于封装响应结果
         StateSignal signal = new StateSignal();
-        if(b){
-            //添加成功
+
+        if (isSuccess) {
+            // 操作成功：添加成功状态码和提示信息
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-        }else {
-            // 添加失败：存入错误状态码和消
+        } else {
+            // 操作失败：添加错误状态码和提示信息
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-        // 返回封装后的响应（Map类型，自动转为JSON给前端）
-        return  signal.getResult();
+
+        // 返回封装好的响应结果（Map格式）
+        return signal.getResult();
     }
 
     /**
-     * 删除订单（管理员权限）
-     * @param orderid 订单id
-     * @return
+     * 删除订单接口（需管理员权限）
+     * @param orderid 要删除的订单ID
+     * @return 包含操作结果的Map（状态码、提示信息）
      */
     @RequestMapping("/delOrder.do")
-    public Map delOrder(@RequestParam int orderid){
-        // 调用服务层的delOrder方法执行删除操作，返回布尔值结果
-        boolean b = orderService.delOrder(orderid);
+    public Map delOrder(@RequestParam int orderid) {
+        // 调用订单服务删除指定ID的订单，返回操作结果
+        boolean isSuccess = orderService.delOrder(orderid);
+
         StateSignal signal = new StateSignal();
-        if(b){
+
+        if (isSuccess) {
             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
+     * 修改订单状态接口
+     * @param orderid 要修改的订单ID
+     * @param state 新的状态码（如：已预订、已入住、已取消等）
+     * @return 包含操作结果的Map（状态码、提示信息）
      */
     @RequestMapping("/updateOrderState.do")
-    public Map updateOrderState(@RequestParam int orderid,@RequestParam int state){
-        // 调用服务层更新订单状态
-        boolean b = orderService.updateOrderState(orderid, state);
+    public Map updateOrderState(@RequestParam int orderid, @RequestParam int state) {
+        // 调用订单服务更新指定订单的状态，返回操作结果
+        boolean isSuccess = orderService.updateOrderState(orderid, state);
+
         StateSignal signal = new StateSignal();
-        if(b){
+
+        if (isSuccess) {
             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){
+    public Map getAllOrder(@RequestParam int pageNum, @RequestParam int pageSize) {
+        // 调用订单服务分页查询所有订单，返回订单列表
+        List<Order> orderList = orderService.getAllOrder(pageNum, pageSize);
 
-// 调用服务层获取订单列表
-        List<Order> allOrder = orderService.getAllOrder(pageNum, pageSize);
         StateSignal signal = new StateSignal();
-        if(allOrder!=null){
+
+        if (orderList != null) {
+            // 查询成功：添加状态信息、订单列表和分页参数
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("List",allOrder);//键"List"对应值为订单列表
-            signal.put("pageNum",pageNum);//返回当前页码
-            signal.put("pageSize",pageSize);//返回每页条数
-        }else {
+            signal.put("List", orderList); // 订单列表数据
+            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,8 +1,5 @@
 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;
@@ -14,84 +11,170 @@ import org.springframework.web.bind.annotation.RestController;
 
 import java.util.List;
 import java.util.Map;
-//这个控制器实现了酒店房间管理的完整功能，包括添加、删除、查询和更新房间信息。
-@RestController//标识是rest控制器，返回JSON数据
-@RequestMapping(value = "/room")//自定义控制器URL接口路径
+//该控制器的主要功能：
+//提供房间全生命周期的接口：添加、删除、更新、查询（按条件分页查询、按 ID 查询详情）
+//接口设计特点：
+//采用 REST 风格路径，统一前缀/room，便于前端识别和管理
+//更新接口（updateRoom.do）支持部分字段更新，通过默认值区分是否需要更新该字段
+//所有接口返回统一格式的响应结果（通过StateSignal封装状态码、提示信息及业务数据）
+//核心职责：接收前端请求参数，调用RoomService处理业务逻辑，最终返回处理结果
+// 标记为REST风格控制器，所有方法返回JSON数据而非视图
+@RestController
+// 配置请求路径前缀，所有房间相关接口路径都以"/room"开头
+@RequestMapping(value = "/room")
 public class RoomController {
+
+    // 自动注入房间服务接口，用于处理房间相关业务逻辑
     @Autowired
-    RoomService roomService;//注入服务层依赖，调用方法
+    RoomService roomService;
+
+    /**
+     * 添加房间接口
+     * @param local 房间位置（如：3楼301室）
+     * @param money 房间价格
+     * @param state 房间状态（如：0-空闲，1-已预订，2-已入住等）
+     * @param type 房间类型（如：1-单人间，2-双人间，3-套房等）
+     * @return 包含操作结果的Map（状态码、提示信息）
+     */
     @RequestMapping("/addRoom.do")
-    public Map addRoom(@RequestParam String local,@RequestParam double money,@RequestParam int state,@RequestParam int type){
-        boolean b = roomService.addRoom(local, money, state, type);
+    public Map addRoom(
+            @RequestParam String local,
+            @RequestParam double money,
+            @RequestParam int state,
+            @RequestParam int type
+    ) {
+        // 调用房间服务添加房间，返回操作结果（成功/失败）
+        boolean isSuccess = roomService.addRoom(local, money, state, type);
+
+        // 创建状态信号对象，用于封装响应结果
         StateSignal signal = new StateSignal();
-        if(b){
+
+        if (isSuccess) {
+            // 操作成功：添加成功状态码和提示信息
             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){
-        boolean b = roomService.delRoom(roomid);
+    public Map delRoom(@RequestParam int roomid) {
+        // 调用房间服务删除指定ID的房间，返回操作结果
+        boolean isSuccess = roomService.delRoom(roomid);
+
         StateSignal signal = new StateSignal();
-        if(b){
+
+        if (isSuccess) {
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-        }else {
+        } else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-        return  signal.getResult();
+
+        return signal.getResult();
     }
-    @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);
+
+    /**
+     * 按状态和类型分页查询房间接口
+     * @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);
+
         StateSignal signal = new StateSignal();
-        if(roomByState!=null){
+
+        if (roomList != null) {
+            // 查询成功：添加状态信息和房间列表数据
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("List",roomByState);
-        }else {
+            signal.put("List", roomList); // 房间列表
+        } 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 b = 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 isSuccess = roomService.updateRoom(roomid, local, money, state, type);
+
         StateSignal signal = new StateSignal();
-        if(b){
+
+        if (isSuccess) {
             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查询房间详情
+
+    /**
+     * 根据ID查询房间详情接口
+     * @param roomid 房间ID
+     * @return 包含房间详情的Map（状态信息+房间对象）
+     */
     @RequestMapping("/getRoomById.do")
-    public Map getRoomById(@RequestParam int roomid){
-        Room b = roomService.getRoomById(roomid);
+    public Map getRoomById(@RequestParam int roomid) {
+        // 调用房间服务根据ID查询房间详情，返回房间对象
+        Room room = roomService.getRoomById(roomid);
+
         StateSignal signal = new StateSignal();
-        if(b!=null){
+
+        if (room != null) {
+            // 查询成功：添加状态信息和房间详情
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("room",b);
-        }else {
+            signal.put("room", room); // 房间详情对象
+        } else {
+            // 查询失败：添加错误状态信息
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-        return  signal.getResult();
-    }
 
-
-
-}
-//这是一个自定义的 StateSignal 类的实例，用于封装 API 响应结果
+        return signal.getResult();
+    }
+}

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

@@ -16,187 +16,256 @@ 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
-     * @return
+     * 用户登录接口（已测试）
+     * @param useraccount 用户名（登录账号）
+     * @param password 密码
+     * @param icode 用户输入的验证码
+     * @param session HttpSession，用于获取服务器存储的验证码
+     * @return 包含登录结果的Map（状态码、提示信息、用户ID、用户权限）
      */
     @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();
-        // 验证验证码
-        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){
+
+        // 从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、用户权限
                 signal.put(State.SuccessCode);
                 signal.put(State.SuccessMessage);
-                signal.put("userid",login[0]);
-                signal.put("power",login[1]);
+                signal.put("userid", loginResult[0]);
+                signal.put("power", loginResult[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 HTTP响应对象
-     * @param session HTTP会话对象
-     * @throws IOException IO异常
+     * 生成验证码图片接口
+     * @param code 预留参数（未实际使用）
+     * @param response HttpServletResponse，用于向客户端输出验证码图片
+     * @param session HttpSession，用于存储生成的验证码（供登录时校验）
+     * @throws IOException 图片生成或输出过程中可能抛出IO异常
      */
     @GetMapping("/createImage")
-    public void createImage(@RequestParam String code, HttpServletResponse response, HttpSession session) throws IOException {
-        // 调用工具类生成验证码图片
-        ImageCode.createImage(response,session);
+    public void createImage(
+            @RequestParam String code,
+            HttpServletResponse response,
+            HttpSession session
+    ) throws IOException {
+        // 调用工具类生成验证码图片，同时将验证码存入Session
+        ImageCode.createImage(response, session);
     }
 
     /**
-     * 添加用户(已测试)
-     * @param useraccount  用户名
-     * @param password  密码
-     * @param power     权限
-     * @return
+     * 添加用户接口（已测试）
+     * @param useraccount 用户名（账号，需唯一）
+     * @param password 密码
+     * @param power 权限（字符串格式，需转为int，如"0"-普通用户，"1"-管理员）
+     * @return 包含添加结果的Map（状态码、提示信息）
      */
     @RequestMapping(value = "/addUser.do")
-    public Map addUser(@RequestParam String useraccount, @RequestParam String password, @RequestParam String power){
-        // 调用服务层添加用户
-        boolean add = userService.addUser(useraccount,password,Integer.parseInt(power));
+    public Map addUser(
+            @RequestParam String useraccount,
+            @RequestParam String password,
+            @RequestParam String power
+    ){
+        // 调用服务层添加用户，将权限参数从String转为int
+        boolean isAddSuccess = userService.addUser(useraccount, password, Integer.parseInt(power));
         StateSignal signal = new StateSignal();
-        if(add){
+
+        if(isAddSuccess){
+            // 添加成功：封装成功状态
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
         }else {
+            // 添加失败（如用户名已存在）：封装错误状态
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
+
         return signal.getResult();
     }
 
     /**
-     * 修改用户数据
-     * @param userid
-     * @param password
-     * @param username
-     * @param age
-     * @param power
-     * @param IDnumber
-     * @return
+     * 修改用户信息接口（已测试，支持部分字段更新）
+     * @param userid 要修改的用户ID（必传，唯一标识用户）
+     * @param password 密码（可选，默认"null"表示不修改）
+     * @param username 用户名（可选，默认"null"表示不修改）
+     * @param age 年龄（可选，默认"-1"表示不修改）
+     * @param power 权限（可选，默认"-1"表示不修改）
+     * @param IDnumber 身份证号（可选，默认"null"表示不修改）
+     * @param phonenumber 手机号（可选，默认"null"表示不修改）
+     * @return 包含修改结果的Map（状态码、提示信息）
      */
     @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 upd = 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 isUpdateSuccess = userService.alterUser(userid, password, username, age, power, IDnumber, phonenumber);
         StateSignal signal = new StateSignal();
-        if(upd){
+
+        if(isUpdateSuccess){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
         }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
+
         return signal.getResult();
     }
 
     /**
-     * 删除用户(已测试)
-     * @param userid    用户id
-     * @return
+     * 删除用户接口（已测试）
+     * @param userid 要删除的用户ID（必传）
+     * @return 包含删除结果的Map（状态码、提示信息）
      */
     @RequestMapping(value = "/delUser.do")
-    public Map delUser(@RequestParam("userid")Integer userid){
-        boolean del = userService.delUser(userid);
+    public Map delUser(@RequestParam("userid") Integer userid){
+        // 调用服务层删除指定ID的用户
+        boolean isDelSuccess = userService.delUser(userid);
         StateSignal signal = new StateSignal();
-        if(del){
+
+        if(isDelSuccess){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
         }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
+
         return signal.getResult();
     }
 
     /**
-     * 获取用户列表(已测试)
-     * @return
+     * 获取所有用户列表（分页查询，已测试）
+     * @param pageNum 页码（如1表示第一页）
+     * @param pageSize 每页条数（如10表示每页显示10条）
+     * @return 包含用户列表及分页信息的Map（状态码、提示信息、用户列表、页码、每页条数）
      */
     @RequestMapping(value = "/getAllUser.do")
-    public Map getAllUser(@RequestParam int pageNum,@RequestParam int pageSize){
-        List<User> allUser = userService.getAllUser(pageNum,pageSize);
+    public Map getAllUser(@RequestParam int pageNum, @RequestParam int pageSize){
+        // 调用服务层分页查询所有用户
+        List<User> userList = userService.getAllUser(pageNum, pageSize);
         StateSignal signal = new StateSignal();
-        if(allUser!=null){
+
+        if(userList != null){
+            // 查询成功：封装成功状态、用户列表、分页参数
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("List",allUser);
-            signal.put("pageNum",pageNum);
-            signal.put("pageSize",pageSize);
+            signal.put("List", userList);
+            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
-     * @return
+     * 按权限获取用户列表（分页查询）
+     * @param power 权限值（如0-普通用户，1-管理员）
+     * @param pageNum 页码
+     * @param pageSize 每页条数
+     * @return 包含指定权限用户列表及分页信息的Map
      */
     @RequestMapping(value = "/getUserByPower.do")
-    public Map getUserByPower(@RequestParam int power,@RequestParam int pageNum,@RequestParam int pageSize){
-        List<User> Users = userService.getUserByPower(power,pageNum,pageSize);
+    public Map getUserByPower(
+            @RequestParam int power,
+            @RequestParam int pageNum,
+            @RequestParam int pageSize
+    ){
+        // 调用服务层按权限分页查询用户
+        List<User> userList = userService.getUserByPower(power, pageNum, pageSize);
         StateSignal signal = new StateSignal();
-        if(Users!=null){
+
+        if(userList != null){
             signal.put(State.SuccessCode);
             signal.put(State.SuccessMessage);
-            signal.put("List",Users);
-            signal.put("pageNum",pageNum);
-            signal.put("pageSize",pageSize);
+            signal.put("List", userList);
+            signal.put("pageNum", pageNum);
+            signal.put("pageSize", pageSize);
         }else {
             signal.put(State.ErrorCode);
             signal.put(State.ErrorMessage);
         }
-        return  signal.getResult();
+
+        return signal.getResult();
     }
 
     /**
-     * 通过userid获取信息
-     * @param userid 用户id
-     * @return
+     * 根据用户ID获取用户详情
+     * @param userid 用户ID
+     * @return 包含用户详情的Map（状态码、提示信息、用户对象）
      */
     @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,27 +2,55 @@ package com.jiudian.manage.mapper;
 
 import com.jiudian.manage.model.Config;
 import org.springframework.stereotype.Repository;
-//这段代码是一个 MyBatis 的 Mapper 接口，用于定义与数据库交互的操作
-// * ConfigMapper接口
-// * 定义与配置表相关的数据库操作
-// 定义数据库操作的方法签名
-//与对应的 XML 映射文件配合使用
-//提供数据库访问的抽象层
-@Repository // 标记为数据访问组件，被Spring管理
+//该 Mapper 接口的核心作用：
+//作为配置表（Config 表）与 Java 代码的交互桥梁，通过 MyBatis 实现配置数据的增删改查；
+//通常用于管理酒店管理系统的全局配置项（如酒店名称、联系电话、默认房间价格、系统开关等），这些配置无需频繁修改，但需要持久化存储；
+//与 Service 层协同：Service 层（如 ConfigService）会注入该 Mapper，调用其方法完成配置数据的数据库操作，再对外提供配置查询、修改等业务接口。
+// 标记为Spring的仓库组件，用于将Mapper接口纳入Spring容器管理，避免注入时出现Bean找不到的问题
+@Repository
+// 配置表(Config)的Mapper接口，定义与数据库交互的抽象方法
+// 作用：通过MyBatis框架，将接口方法与SQL语句关联，实现配置数据的CRUD操作
 public interface ConfigMapper {
-    int deleteByPrimaryKey(Integer id);
+
     /**
-     * 根据主键删除配置记录
+     * 根据主键(ID)删除配置表中的一条记录
+     * @param id 配置记录的主键ID
+     * @return 受影响的行数（1表示删除成功，0表示未找到对应记录）
+     */
+    int deleteByPrimaryKey(Integer id);
 
-     * @return 影响的行数
+    /**
+     * 插入一条完整的配置记录（所有字段都需传入，包括可能为null的字段）
+     * @param record 封装了配置数据的Config对象
+     * @return 受影响的行数（1表示插入成功，0表示插入失败）
      */
     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,27 +4,58 @@ import com.jiudian.manage.model.Order;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
-/**
- * OrderMapper接口
- * 定义与订单表相关的数据库操作增删改查
- */
-@Repository // 标记为数据访问组件，被Spring管理
+//：是订单数据在 Java 代码与数据库之间的 “桥梁”，OrderService 层会注入该 Mapper，调用其方法完成订单的增删改查（如 OrderServiceImpl 的 addOrder 方法会调用 insertSelective 插入订单）
+// 标记为Spring仓库组件，将该Mapper接口纳入Spring容器管理，解决Service层注入时的Bean依赖问题
+@Repository
+// 订单表(Order表)的Mapper接口，定义与数据库交互的抽象方法
+// 作用：通过MyBatis框架关联SQL语句，实现订单数据的CRUD（增删改查）操作，是订单业务数据持久化的核心接口
 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,24 +4,59 @@ import com.jiudian.manage.model.Room;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
-//MyBatis 的 Mapper 接口，用于定义与房间表相关的数据库操作
-//标记当前接口是 “数据访问层组件”，让 Spring 扫描时能识别并管理；
+
+// 标记为Spring仓库组件，将该Mapper接口纳入Spring容器管理，确保Service层可正常注入使用
 @Repository
+// 房间表(Room表)的Mapper接口，定义与数据库交互的抽象方法
+// 作用：通过MyBatis框架关联SQL语句，实现房间数据的CRUD（增删改查）操作，是房间业务数据持久化的核心接口
 public interface RoomMapper {
-    //传入要删除的房间 ID（用 Integer 而非 int，支持 null 判断，避免传入无效值）；
+
+    /**
+     * 根据房间主键ID删除一条房间记录
+     * @param roomid 房间的唯一标识（主键ID）
+     * @return 受影响的行数（1表示删除成功，0表示未找到对应房间）
+     */
     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);
-//全字段更新房间
-    int updateByPrimaryKey(Room record);
-//按状态和类型查询房间列表
-    List<Room> selectRoomByStateType(Room stateType);
 
+    /**
+     * 根据房间主键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,31 +4,72 @@ import com.jiudian.manage.model.User;
 import org.springframework.stereotype.Repository;
 
 import java.util.List;
-/**
- * UserMapper接口
- * 定义与用户表相关的数据库操作
- */
-//selectByAccount: 主要用于用户登录验证
-//selectByPower: 用于权限管理，查询特定角色的用户
-//getAllUser: 用于用户管理页面展示所有用户
-//updateByPrimaryKeySelective: 用于用户信息更新，只更新修改过的字段
+
+// 标记为Spring仓库组件，将该Mapper接口纳入Spring容器管理，避免Service层注入时出现Bean缺失问题
 @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,138 +1,125 @@
 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
-     * @return 配置ID
-     */
+
+    // 设置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,98 +1,114 @@
-package com.jiudian.manage.model;
-
+package com.jiudian.manage.model;  // 定义该类所在import java.util.Date;  // 导入日期类，用于处理订单的时间字段
 import java.util.Date;
 /**
- 订单实体类
- 对应数据库中的 order 表
- // 用于存储酒店预订订单信息
- **/
+ * 订单实体类，对应数据库中的order表
+ * 用于封装酒店订单的所有信息，是订单数据在系统中流转的载体
+ */
 public class Order {
-    private Integer orderid;
+    private Integer orderid;  // 订单ID（主键，自增），唯一标识一条订单记录
 
-    private String householdname;
+    private String householdname;  // 入住人姓名（预订房间的实际入住者姓名）
 
-    private String id;
+    private String id;  // 入住人身份证号（用于身份核验，字符串类型适配18位身份证）
 
-    private Date starttime;
+    private Date starttime;  // 入住开始时间（订单的生效起始时间）
 
-    private Date endtime;
+    private Date endtime;  // 入住结束时间（订单的生效截止时间）
 
-    private Double money;
+    private Double money;  // 订单金额（该订单的总费用，单位：元）
 
-    private Integer state;
+    private Integer state;  // 订单状态（用数字标识：如0-已预订、1-已入住、2-已取消、3-已完成等）
 
-    private Integer roomid;
+    private Integer roomid;  // 关联的房间ID（外键，关联room表的roomid，标识该订单对应的房间）
 
-    private Integer userid;
+    private Integer userid;  // 关联的用户ID（外键，关联user表的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,58 +1,66 @@
 package com.jiudian.manage.model;
+
 /**
- * 房间实体类
- * 对应数据库中的room表
- * 用于存储酒店房间的基本信息
- * 属性存储：存储房间的基本信息，包括 ID、位置、价格、状态和类型
- * 数据封装：通过 Getter 和 Setter 方法实现数据的封装和访问控制
+ * 房间实体类，对应数据库中的room表
+ * 用于封装酒店房间的核心信息，是房间数据在系统各层流转的核心载体
  */
 public class Room {
-    private Integer roomid;
+    private Integer roomid;  // 房间ID（主键，自增），唯一标识一间酒店房间
 
-    private String local;
+    private String local;  // 房间位置（如"3楼301室"、"1楼豪华套房01"，描述房间的具体位置）
 
-    private Double money;
+    private Double money;  // 房间单价（单位：元/天，用于计算订单金额）
 
-    private Integer state;
+    private Integer state;  // 房间状态（数字标识：如0-空闲、1-已预订、2-已入住、3-维修中，控制房间是否可下单）
 
-    private Integer type;
+    private Integer type;  // 房间类型（数字标识：如1-单人间、2-双人间、3-套房、4-亲子房，区分不同房型）
 
+    // 获取房间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,108 +1,126 @@
 package com.jiudian.manage.model;
 
-// * 用户实体类
-// * 对应数据库中的user表
-// * 用于存储系统用户的基本信息
-// 用户信息存储：存储用户的基本信息，包括账号、密码、姓名等
-//权限管理：通过 power 字段实现基于角色的访问控制
-//个人资料：包含身份证号、手机号、头像等个人信息
+/**
+ * 用户实体类，对应数据库中的user表
+ * 用于封装酒店管理系统中用户的所有核心信息，是用户数据在系统各层（Controller/Service/Mapper）流转的核心载体
+ */
 public class User {
-    private Integer userid;
+    private Integer userid;  // 用户ID（主键，自增），唯一标识系统中的一个用户
 
-    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;
+    private Integer power;  // 用户权限（数字标识：如0-普通用户、1-管理员、2-员工，控制用户可操作的功能范围）
 
-    private String idnumber;
+    private String idnumber;  // 用户身份证号（用于身份验证，如预订房间时的实名登记）
 
-    private Double money;
+    private Double money;  // 用户账户余额（可选，用于系统内支付、退款等资金相关操作）
 
-    private String photourl;
+    private String photourl;  // 用户头像URL（存储头像文件在服务器的相对路径，前端通过路径加载头像）
 
-    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,10 +1,7 @@
 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,8 +3,7 @@ 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,12 +3,7 @@ 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);
@@ -47,7 +42,7 @@ public interface UserService {
      * @param money     增加的业绩额
      * @return          是否成功
      */
-    public boolean addSalary(int userid,double money);
+    public boolean addSlary(int userid,double money);
 
     /**
      * 获得所有的用户

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

@@ -5,41 +5,76 @@ import com.jiudian.manage.model.Config;
 import com.jiudian.manage.service.ConfigService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-///**
-// * ConfigService接口的实现类
-// * 处理系统配置相关的业务逻辑
-// */
-@Service // 标记为服务层组件，被Spring管理
+
+// 标记为Spring的Service组件，纳入Spring容器管理，作为配置业务的具体实现类
+@Service
+// 实现ConfigService接口，重写接口定义的配置查询与更新方法
 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) {
-       //创建配置对象
+    public boolean update(
+            double managesalary,
+            double staffsalary,
+            double cleanerssalary,
+            double manage,
+            double staff,
+            double cleaner,
+            double totalmoney,
+            double totalroom
+    ) {
+        // 创建Config对象，封装待更新的配置数据
         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);
-        //对于totalmoney和totalroom字段，只有当传入值不是 - 1 时才更新
-        if(totalmoney!=-1){
+
+        // 条件更新字段：总营收（仅当传入值≠-1时更新，避免覆盖无需修改的数据）
+        if(totalmoney != -1){
             config.setTotalmoney(totalmoney);
         }
-        if(totalroom!=-1){
+        // 条件更新字段：总房间数（仅当传入值≠-1时更新）
+        if(totalroom != -1){
             config.setTotalroom(totalroom);
         }
-        int i = configMapper.updateByPrimaryKeySelective(config);
-        return i>0?true:false; //根据影响行数判断更新是否成功
+
+        // 调用Mapper的选择性更新方法（仅更新Config对象中非null的字段）
+        int affectedRows = configMapper.updateByPrimaryKeySelective(config);
+
+        // 根据受影响行数判断更新是否成功（>0表示有记录被修改，即更新成功）
+        return affectedRows > 0 ? true : false;
     }
-}
+}

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

@@ -14,133 +14,159 @@ import org.springframework.stereotype.Service;
 
 import java.util.List;
 
-// * OrderService接口的实现类
-// * 处理订单相关的业务逻辑
-// */
+// 标记为Spring的Service组件，纳入容器管理，是订单业务逻辑的具体实现类
 @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 入住开始时间
-     * @param endtime 入住结束时间
-     * @param roomid 房间ID
-     * @param userid 操作用户ID
-     * @return 订单创建成功返回true，失败返回false
+     * @param starttime 入住开始时间（字符串格式，需转换为Date）
+     * @param endtime 入住结束时间（字符串格式，需转换为Date）
+     * @param roomid 关联的房间ID
+     * @param userid 下单用户ID
+     * @return 布尔值：true=创建成功，false=创建失败
      */
-    public boolean addOrder(String householdname, String id, String starttime, String endtime, int roomid, int userid) {
-        // 1. 检查房间状态是否为可预订（状态1）
+    @Override
+    public boolean addOrder(
+            String householdname,
+            String id,
+            String starttime,
+            String endtime,
+            int roomid,
+            int userid
+    ) {
+        // 1. 校验房间状态：查询指定房间，仅当房间状态为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);
+        order.setHouseholdname(householdname); // 入住人姓名
+        order.setId(id); // 入住人身份证号
+        // 调用时间工具类，将字符串格式时间转换为Date类型（适配数据库时间字段）
         order.setStarttime(TimeUtil.formatterTime(starttime));
         order.setEndtime(TimeUtil.formatterTime(endtime));
-        order.setRoomid(roomid);
-        order.setUserid(userid);
-        order.setState(0);
-        // 3. 计算订单金额
-        double money = TimeUtil.getBetweenDay(starttime,endtime)*room.getMoney();
-        order.setMoney(money);
-// 4. 更新系统配置（总营业额和总房间数）
+        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的全局配置）
         Config config = configMapper.selectByPrimaryKey(1);
-        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 {
+        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 { // 订单插入失败，直接返回失败
             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();
-        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;
-            }
+
+        // 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
         }
+        // 房间状态更新失败，直接返回删除失败
         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 room = new Room();
-        room.setRoomid(roomid);
-        int i = 1;
-        if(state==2){
-            room.setState(3);
-            i = roomMapper.updateByPrimaryKeySelective(room);
+        Room updateRoom = new Room();
+        updateRoom.setRoomid(roomid);
+        int roomUpdateCount = 1; // 初始化房间更新结果，默认成功（状态无需同步时用）
+
+        // 3. 根据订单目标状态，同步修改房间状态
+        if (state == 2) { // 假设订单状态2=已入住，对应房间状态3=已入住
+            updateRoom.setState(3);
+            roomUpdateCount = roomMapper.updateByPrimaryKeySelective(updateRoom);
         }
-        if(state==3){
-            room.setState(1);
-            i = roomMapper.updateByPrimaryKeySelective(room);
+        if (state == 3) { // 假设订单状态3=已完成（退房），对应房间状态1=空闲
+            updateRoom.setState(1);
+            roomUpdateCount = roomMapper.updateByPrimaryKeySelective(updateRoom);
         }
-        order.setState(state);
-        if(i>0){
-            int i1 = orderMapper.updateByPrimaryKeySelective(order);
-            if(i1>0){
-                return true;
-            }
+
+        // 4. 房间状态更新成功后，再更新订单状态
+        if (roomUpdateCount > 0) {
+            order.setState(state); // 设置订单新状态
+            int orderUpdateCount = orderMapper.updateByPrimaryKeySelective(order);
+            return orderUpdateCount > 0 ? true : false; // 订单状态更新成功则返回true
         }
+        // 房间状态更新失败，返回订单状态更新失败
         return false;
     }
+
     /**
-     * 分页查询所有订单
-     * 使用PageHelper实现分页功能
-     *
-     * @param pageNum 页码
-     * @param pageSize 每页记录数
-     * @return 订单列表
+     * 分页查询所有订单（使用PageHelper实现分页）
+     * @param pageNum 页码（第几页，从1开始）
+     * @param pageSize 每页条数（每页显示多少条订单）
+     * @return 分页后的订单列表（PageHelper自动处理分页逻辑）
      */
     @Override
     public List<Order> getAllOrder(int pageNum, int pageSize) {
-        PageHelper.startPage(pageNum,pageSize);
+        // 1. 开启分页：PageHelper会自动拦截后续的查询SQL，添加分页条件（limit）
+        PageHelper.startPage(pageNum, pageSize);
+        // 2. 查询所有订单（注意：OrderMapper的getAllUser方法名疑似笔误，应为getAllOrder）
         return orderMapper.getAllUser();
     }
-}
+}

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

@@ -8,80 +8,144 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
-//这个RoomServiceImpl类实现了房间管理的完整业务逻辑，包括：
-//房间的添加、删除、修改
-//房间状态的单独更新
-//基于状态和类型的组合查询
-//分页查询支持
-//代码遵循了面向接口编程的原则，通过依赖注入获取 Mapper 对象，实现了业务逻辑与数据访问的解耦，
-//降低系统中不同组件之间的依赖关系，使它们能够独立地开发、测试和维护。
+
+// 标记为Spring的Service组件，纳入容器管理，是房间业务逻辑的具体实现类
 @Service
+// 实现RoomService接口，重写接口定义的房间增删改查与状态管理方法
 public class RoomServiceImpl implements RoomService {
-    // 自动注入RoomMapper，用于数据库操作
+
+    // 自动注入房间Mapper，通过Mapper与数据库交互，完成房间数据的CRUD操作
     @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);
-        int i = roomMapper.insertSelective(room);
-        return i>0?true:false;
+        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;
     }
 
+    /**
+     * 删除房间（从系统中移除指定房间）
+     * @param roomid 要删除的房间ID
+     * @return 布尔值：true=删除成功，false=删除失败（如房间不存在）
+     */
     @Override
     public boolean delRoom(int roomid) {
-        int i = roomMapper.deleteByPrimaryKey(roomid);
-        return i>0?true:false;
+        // 1. 调用Mapper按主键删除房间
+        int deleteCount = roomMapper.deleteByPrimaryKey(roomid);
+
+        // 2. 根据删除受影响行数判断结果
+        return deleteCount > 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);
-        if(!local.equals("null")){
-            room.setLocal(local);
+        room.setRoomid(roomid);  // 必传：指定更新的房间ID
+
+        // 条件设置字段：仅当参数非默认值时，才更新对应字段
+        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);    // 更新房间类型
         }
-        int i = roomMapper.updateByPrimaryKeySelective(room);
-        return i>0?true:false;
+
+        // 2. 调用Mapper的选择性更新方法（仅更新Room对象中非null的字段）
+        int updateCount = roomMapper.updateByPrimaryKeySelective(room);
+
+        // 3. 根据更新受影响行数判断结果
+        return updateCount > 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);
-        int i = roomMapper.updateByPrimaryKeySelective(room);
-        return i>0?true:false;
+
+        // 2. 调用选择性更新方法，仅修改状态字段
+        int updateCount = roomMapper.updateByPrimaryKeySelective(room);
+
+        // 3. 判断更新结果
+        return updateCount > 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) {
+    public List<Room> getRoomByState(int state, int type, int pageNum, int pageSize) {
+        // 1. 封装筛选条件（仅设置非-1的参数，避免筛选无效条件）
         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);    // 按类型筛选（如只查双人间）
         }
-        PageHelper.startPage(pageNum,pageSize);
+
+        // 2. 开启分页：PageHelper自动拦截后续查询SQL，添加limit分页条件
+        PageHelper.startPage(pageNum, pageSize);
+
+        // 3. 调用Mapper按条件查询房间，返回分页后的列表
         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,147 +1,215 @@
 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;
-//UserServiceImpl是一个完整的用户管理服务实现类，它：
-//实现了 UserService 接口：提供了用户管理的所有功能
-//使用 MyBatis 进行数据访问：通过 UserMapper 操作数据库
-//1. 用户基础操作
-//添加用户：创建新用户账号，自动生成工号
-//删除用户：根据 ID 删除用户
-//查询用户：根据 ID 查询用户详情
-//更新用户：支持部分字段更新，灵活更新用户信息
-//2. 用户信息管理
-//修改个人信息：更新用户名、年龄、手机号等
-//更新头像：上传和更新用户头像
-//业绩管理：增加用户业绩 / 薪水记录
-//3. 用户查询与筛选
-//分页查询：支持分页获取所有用户
-//权限筛选：按权限等级查询特定用户群体
-//灵活查询：支持多条件组合查询
-//4. 用户认证与授权
-//登录验证：验证用户名密码，返回用户 ID 和权限
-//权限管理：基于 power 字段实现用户权限控制
+
+// 标记为Spring的Service组件，纳入容器管理，是用户业务逻辑的具体实现类
 @Service
-//实现UserService接口的所有抽象方法
+// 实现UserService接口，重写接口定义的用户管理、登录、头像更新等核心方法
 public class UserServiceImpl implements UserService {
-    //服务层通过userMapper调用 Mapper 接口中定义的 SQL 操作，实现 “服务层 - 数据访问层” 的交互
+
+    // 自动注入用户Mapper，通过Mapper与数据库交互，完成用户数据的CRUD操作
     @Autowired
     UserMapper userMapper;
 
+    /**
+     * 根据用户ID查询单个用户详情（用于个人信息展示、权限校验）
+     * @param userid 用户ID（主键）
+     * @return 封装用户详情的User对象，不存在则返回null
+     */
     @Override
-    //查询用户
     public User selectUser(int userid) {
+        // 调用Mapper按主键查询用户，直接返回结果
         return userMapper.selectByPrimaryKey(userid);
     }
 
-    public boolean addUser(String account, String password, int power){
-        //1.创建用户，封装用户信息
+    /**
+     * 新增用户（用于管理员创建系统账号，如新增员工、管理员账号）
+     * @param account 用户账号（登录用，需唯一）
+     * @param password 用户密码（初始密码，后续可修改）
+     * @param power 用户权限（如0=普通用户、1=管理员）
+     * @return 布尔值：true=新增成功，false=新增失败（如账号已存在）
+     */
+    public boolean addUser(String account, String password, int power) {
+        // 1. 封装用户基础数据
         User user = new User();
-        user.setUseraccount(account);
-        user.setPassword(password);
-        user.setPower(power);
+        user.setUseraccount(account);  // 设置登录账号
+        user.setPassword(password);    // 设置初始密码（注意：实际系统需加密存储）
+        user.setPower(power);          // 设置用户权限
+        // 2. 生成短UUID作为默认身份证号（避免字段为空，后续用户可自行修改）
         user.setIdnumber(UUIDUtil.generateShortUuid());
-        // 2. 调用UserMapper的insertSelective方法：选择性插入用户（仅插入非null字段）
-        int insert = userMapper.insertSelective(user);
-        // 3. 根据插入结果返回布尔值：受影响行数>0表示插入成功（返回true），否则失败（返回false）
-        return insert>0?true:false;
+
+        // 3. 调用Mapper选择性插入用户（仅插入非null字段）
+        int insertCount = userMapper.insertSelective(user);
+
+        // 4. 根据插入受影响行数判断是否成功
+        return insertCount > 0 ? true : false;
     }
 
+    /**
+     * 删除用户（管理员权限，从系统中移除指定用户）
+     * @param userid 要删除的用户ID
+     * @return 布尔值：true=删除成功，false=删除失败（如用户不存在）
+     */
     @Override
     public boolean delUser(int userid) {
-        int i = userMapper.deleteByPrimaryKey(userid);
-        return i>0?true:false;
+        // 1. 调用Mapper按主键删除用户
+        int deleteCount = userMapper.deleteByPrimaryKey(userid);
+
+        // 2. 根据删除受影响行数判断结果
+        return deleteCount > 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) {
+    public boolean alterUser(
+            int userid,
+            String password,
+            String username,
+            int age,
+            int power,
+            String IDnumber,
+            String phonenumber
+    ) {
+        // 1. 封装待更新数据（仅设置非默认值的字段）
         User user = new User();
-        user.setUserid(userid);
-        // 选择性设置字段：仅当参数不是默认值时，才设置（避免覆盖原有数据）
-        if(!password.equals("null")){
-            user.setPassword(password);
+        user.setUserid(userid);  // 必传：指定修改的用户ID
+
+        // 条件设置字段：仅当参数非默认值时，才更新对应字段
+        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);  // 更新手机号
         }
-        //调用UserMapper的updateByPrimaryKeySelective方法：选择性更新（仅更新非null字段
-        int i = userMapper.updateByPrimaryKeySelective(user);
-        return i>0?true:false;
+
+        // 2. 调用Mapper选择性更新用户（仅更新User对象中非null的字段）
+        int updateCount = userMapper.updateByPrimaryKeySelective(user);
+
+        // 3. 根据更新受影响行数判断结果
+        return updateCount > 0 ? true : false;
     }
 
+    /**
+     * 给用户账户充值（增加账户余额，用于系统内支付）
+     * @param userid 充值用户ID
+     * @param money 充值金额（单位：元）
+     * @return 布尔值：true=充值成功，false=充值失败
+     */
     @Override
-    //重写addsalary方法
-    public boolean addSalary(int userid, double money) {
-        // . 先查询用户当前的薪水（money字段)
+    public boolean addSlary(int userid, double money) {
+        // 1. 先查询用户当前余额（避免直接覆盖原有余额）
         User user = userMapper.selectByPrimaryKey(userid);
-        // 获取用户当前薪水
-        Double money1 = user.getMoney();
-        //计算新薪水：原有薪水 + 提成（money）
-        user.setMoney(money+money1);
-        int i = userMapper.updateByPrimaryKey(user);
-        //根据更新结果返回布尔值
-        return i>0?true:false;
+        Double currentMoney = user.getMoney();
+
+        // 2. 计算新余额：原有余额 + 充值金额
+        user.setMoney(money + currentMoney);
+
+        // 3. 调用Mapper全量更新用户（因需覆盖money字段，此处用全量更新而非选择性更新）
+        int updateCount = userMapper.updateByPrimaryKey(user);
+
+        // 4. 判断充值结果
+        return updateCount > 0 ? true : false;
     }
 
+    /**
+     * 分页查询所有用户（管理员用于用户列表管理）
+     * @param pageNum 页码（第几页）
+     * @param pageSize 每页条数
+     * @return 分页后的用户列表
+     */
     @Override
-    //重写查询所有用户方法
-    public List<User> getAllUser(int pageNum,int pageSize) {
-        PageHelper.startPage(pageNum,pageSize);
-        // 1. 调用PageHelper.startPage：开启分页功能，传入页码（pageNum）和每页条数（pageSize）
+    public List<User> getAllUser(int pageNum, int pageSize) {
+        // 1. 开启分页：PageHelper自动拦截后续查询SQL，添加limit分页条件
+        PageHelper.startPage(pageNum, pageSize);
+
+        // 2. 调用Mapper查询所有用户，返回分页列表
         return userMapper.getAllUser();
     }
 
+    /**
+     * 按权限分页查询用户（如查询所有管理员、所有普通用户）
+     * @param power 目标权限（如0=普通用户、1=管理员）
+     * @param pageNum 页码
+     * @param pageSize 每页条数
+     * @return 分页后的指定权限用户列表
+     */
     @Override
-    //重写根据页面查询用户
-    public List<User> getUserByPower(int power,int pageNum,int pageSize) {
-        //开启分页功能
-        PageHelper.startPage(pageNum,pageSize);
+    public List<User> getUserByPower(int power, int pageNum, int pageSize) {
+        // 1. 开启分页
+        PageHelper.startPage(pageNum, pageSize);
 
-        //  调用UserMapper的selectByPower方法：按权限（power）查询用户（自动分页）
+        // 2. 调用Mapper按权限查询用户，返回分页列表
         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);
-        if(user!=null&&user.getPassword().equals(password)){
-            return new int[]{user.getUserid(),user.getPower()};
-        }else{
+
+        // 2. 校验用户是否存在且密码匹配（注意：实际系统需加密对比密码，此处为明文对比）
+        if (user != null && user.getPassword().equals(password)) {
+            // 3. 验证成功，返回用户ID和权限
+            return new int[]{user.getUserid(), user.getPower()};
+        } else {
+            // 4. 验证失败（账号不存在或密码错误），返回null
             return null;
         }
     }
 
+    /**
+     * 更新用户头像路径（用户上传头像后，同步更新数据库中的头像URL）
+     * @param userid 头像所属用户ID
+     * @param url 头像在服务器的存储路径（相对路径，如"File/xxx.jpg"）
+     * @return 布尔值：true=更新成功，false=更新失败
+     */
     @Override
     public boolean photo(int userid, String url) {
-        //创建User实体类对象，用于封装更新数据
+        // 1. 封装用户ID和头像路径
         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,25 +1,44 @@
-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);
-        if(!targetFile.exists()){
+
+        // 2. 判断存储目录是否存在，不存在则创建多级目录（mkdirs()支持创建嵌套目录，mkdir()不支持）
+        if (!targetFile.exists()) {
             targetFile.mkdirs();
         }
-        //写入文件，将文件二进制流（byte[] file）写入指定路径（filePath+fileName）
-        FileOutputStream out = new FileOutputStream(filePath+fileName);
+
+        // 3. 创建文件输出流，指定文件存储路径（目录路径 + 文件名）
+        FileOutputStream out = new FileOutputStream(filePath + fileName);
+
+        // 4. 将文件字节数组写入到输出流（即写入到服务器文件）
         out.write(file);
+
+        // 5. 刷新输出流，确保所有字节都被写入文件
         out.flush();
+
+        // 6. 关闭输出流，释放IO资源（避免资源泄漏）
         out.close();
+
+        // 7. 文件写入完成，返回上传成功
         return true;
     }
-}
+}

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

@@ -1,54 +1,85 @@
 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 {
-    public static final String CODENAME="ImageCode";
-    //* 生成验证码图片并发送到客户端
-    //HttpServletResponse response：Servlet 响应对象，用于将生成的图片流写入前端（前端通过 <img> 标签加载）；
-    //HttpSession session：会话对象，用于存储正确的验证码（后续登录时，前端传入的验证码需与 Session 中的值对比
+    // 验证码在HttpSession中的存储键名（固定值，登录时需通过该键名获取Session中的验证码）
+    public static final String CODENAME = "ImageCode";
+
+    /**
+     * 生成图形验证码并响应给前端，同时将验证码存入Session
+     * @param response HttpServletResponse，用于向前端输出验证码图片
+     * @param session HttpSession，用于存储生成的验证码（供登录时校验）
+     * @throws IOException 图片写入响应流时可能抛出IO异常，需调用方处理
+     */
     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();
-        //绑定验证码
-        // 将验证码存储到Session中
+
+        // 6. 将生成的验证码存入Session：键为CODENAME，值为验证码，供后续登录校验使用
         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);
     }
+
     /**
-     * 生成随机验证码
-     * @return 4位随机验证码
+     * 生成4位随机验证码（包含数字0-9和大写字母A-Z，增强验证码复杂度）
+     * @return 4位随机字符串（验证码内容）
      */
-    public static String getNumber(){
+    public static String getNumber() {
+        // 1. 定义验证码字符池：包含数字和大写字母，共36个字符
         String str = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+        // 2. 初始化验证码字符串（用于拼接最终结果）
         String code = "";
-        for(int i= 0;i<4;i++){
-            int index = (int)(Math.random()*str.length());
-            code+=str.charAt(index);
+
+        // 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);
         }
+
+        // 4. 返回生成的4位验证码
         return code;
     }
 }

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

@@ -1,45 +1,41 @@
 package com.jiudian.manage.until;
+
 /**
- * 状态枚举类
- * 定义接口返回的标准状态码和提示信息
- * 用于统一API接口的返回格式
+ * 系统统一状态枚举类
+ * 定义接口响应的标准状态码和提示信息，确保所有接口返回格式一致，简化前后端交互逻辑
  */
-public enum  State {
-    /**
-     * 成功状态码
-     * 键名："code"，值："0"
-     */
-    /**
-     * 成功提示信息
-     * 键名："message"，值："成功"
-     */
-    SuccessCode("code","0"),SuccessMessage("message","成功"),
-    ErrorCode("code","-1"),ErrorMessage("message","失败")
-    ;
+public enum State {
+    // 成功状态：code=0，message=成功（用于所有业务操作成功的响应，如订单创建成功、用户登录成功）
+    SuccessCode("code", "0"),
+    SuccessMessage("message", "成功"),
 
+    // 失败状态：code=-1，message=失败（用于所有业务操作失败的通用响应，如参数错误、数据库操作失败）
+    ErrorCode("code", "-1"),
+    ErrorMessage("message", "失败");
 
+
+    // 状态对应的键名（如"code"表示状态码的键，"message"表示提示信息的键）
     public String name;
+    // 状态对应的键值（如"0"是成功状态码的值，"成功"是成功提示的值）
     public String message;
+
     /**
-     * 构造方法
-     * @param name 状态键名
-     * @param message 状态值
+     * 枚举构造方法（枚举的构造方法默认私有，仅在枚举内部创建实例时使用）
+     * @param name 状态键名（如"code"、"message"）
+     * @param message 状态键值（如"0"、"成功"）
      */
-    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,34 +1,16 @@
 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,43 +6,71 @@ import java.util.Calendar;
 import java.util.Date;
 import java.util.GregorianCalendar;
 
+/**
+ * 时间工具类
+ * 提供日期格式转换、跨年份日期差计算功能，核心支撑酒店订单模块的入住天数统计与金额计算
+ */
 public class TimeUtil {
     /**
-     * 计算两个日期之间的天数差（date2 - date1）
-     * @param date1 开始日期字符串（格式：yyyy-MM-dd）
-     * @param date2 结束日期字符串（格式：yyyy-MM-dd）
-     * @return 两个日期之间的天数差
+     * 计算两个日期之间的天数差（结果为 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之前，可能返回负数，需在业务层判断合理性）
      */
-    public static int getBetweenDay(String  date1, String date2) {
-        // 将字符串日期转换为Calendar对象
+    public static int getBetweenDay(String date1, String date2) {
+        // 创建GregorianCalendar实例（日历工具类），用于处理日期的年、日字段计算
         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 y2 = d2.get(Calendar.YEAR);
-        if (d1.get(Calendar.YEAR) != y2) {
+
+        // 获取结束日期的年份，判断是否跨年份（起始年份 != 结束年份）
+        int endYear = d2.get(Calendar.YEAR);
+        if (d1.get(Calendar.YEAR) != endYear) {
+            // 跨年份时，循环累加起始年份到结束年份之间每一年的总天数
             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) != y2);
+            } while (d1.get(Calendar.YEAR) != endYear);
         }
+
+        // 返回最终计算的天数差
         return days;
     }
+
     /**
-     * 将字符串日期格式化为Date对象
-     * @param date 日期字符串（格式：yyyy-MM-dd）
-     * @return Date对象，如果格式错误返回null
+     * 将字符串格式的日期转为Date类型（固定格式：yyyy-MM-dd）
+     * 解决前端传递的日期字符串与后端Date类型不兼容问题，统一日期格式标准
+     *
+     * @param date 日期字符串（格式必须为 yyyy-MM-dd，如"2025-05-01"；格式错误会打印异常栈并返回null）
+     * @return 转换后的Date对象（转换失败时返回null）
      */
-    public static Date formatterTime(String date){
+    public static Date formatterTime(String date) {
+        // 创建SimpleDateFormat实例，指定目标日期格式为 yyyy-MM-dd
         SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
-        Date newDate=null;
+        // 初始化Date对象，用于接收转换结果
+        Date newDate = null;
+
         try {
-            newDate= formatter.parse(date);
+            // 尝试将字符串日期解析为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,9 +4,15 @@ import java.util.UUID;
 
 /**
  * UUID工具类
- * 提供生成短版UUID的功能，生成工号
+ * 提供短UUID生成功能，解决原生UUID（36位）过长、不便于存储/展示的问题，
+ * 生成的8位短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",
@@ -15,21 +21,34 @@ public class UUIDUtil {
             "W", "X", "Y", "Z" };
 
     /**
-     * 生成8位UUID
-     * @return 8位UUID
+     * 生成8位长度的短UUID
+     * 基于JDK原生UUID（32位无分隔符形式）压缩转换，确保全局唯一性，
+     * 相比原生UUID更简洁，适合存储（如用户默认身份证号）或界面展示
+     *
+     * @return 8位随机唯一字符串（示例：xY3a7B9z）
      */
     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("-", "");
-        // 将32位UUID转换为8位
+
+        // 循环8次，每次处理4位原生UUID片段，生成1位短字符，最终组成8位短UUID
         for (int i = 0; i < 8; i++) {
-            // 每4个字符为一组
+            // 截取4位字符串（如第1次取0-4位、第2次取4-8位，直至取完32位）
             String str = uuid.substring(i * 4, i * 4 + 4);
-            // 转换为16进制整数
+
+            // 将4位16进制字符串转为10进制整数（如"a1b2"转为十进制整数41394）
             int x = Integer.parseInt(str, 16);
-            // 取模62（字符集大小）得到索引
+
+            // 对62取余（0x3E为十六进制，对应十进制62，与chars数组长度一致），
+            // 通过余数获取chars数组的索引，取出对应字符拼接到shortBuffer
             shortBuffer.append(chars[x % 0x3E]);
         }
+
+        // 返回最终生成的8位短UUID
         return shortBuffer.toString();
     }
-}
+}

src/main/resources/generator/generatorConfig.xml

@@ -2,16 +2,8 @@
 <!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,10 +1,5 @@
 <?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,10 +1,4 @@
 <?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" >
@@ -39,7 +33,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,6 +1,4 @@
 <?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,6 +1,4 @@
 <?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;/* 顶部内边距：25px，控制内容与页脚顶部的距离 */
-    padding-bottom: 50px;/* 底部内边距：50px，控制内容与页脚底部的距离 */
-    height: 12rem;/* 固定高度：12rem（rem 是相对根元素字体大小的单位） */
-    color: #99979c;/* 文本颜色：浅灰色，用于页脚的普通文字 */
-    text-align: center; /* 文本居中对齐：页脚内所有内容水平居中 */
-    background-color: rgba(0,0,0,.8); /* 背景色：黑色半透明（透明度 80%） */
+    padding-top: 25px;
+    padding-bottom: 50px;
+    height: 12rem;
+    color: #99979c;
+    text-align: center;
+    background-color: rgba(0,0,0,.8);
 }
 
 .bs-docs-footer-links {
-    padding-left: 0; /* 左内边距：0，清除列表默认的左侧缩进 */
-    margin-bottom: 20px; /* 底部外边距：20px，控制链接列表与下方元素的距离 */
+    padding-left: 0;
+    margin-bottom: 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;/* 段落底部外边距：0，清除段落默认的底部间距 */
+    margin-bottom: 0;
 }

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

@@ -1,95 +1,95 @@
 .navbar-default{
-    transition: all 0.6s;/* 所有所有样式变化添加过渡动画，持续 0.6s（如背景色、尺寸变化时平滑过渡） */
-    background-color: rgba(0,0,0,.7); /* 背景色：黑色半透明（透明度 70%） */
-    border: 0;/* 取消边框 */
-    border-radius: 0; /* 取消圆角（默认导航栏可能有圆角） */
+	transition: all 0.6s;
+	background-color: rgba(0,0,0,.7);
+	border: 0;
+	border-radius: 0;
 }
 
 
-.header{
-    text-align: center;/* 文本居中对齐 */
-    letter-spacing: 1rem; /* 字符间距为 1rem（增强标题视觉效果） */
+.header{                                       
+	text-align: center;
+	letter-spacing: 1rem;
 }
 
 .navbar{
-    min-height: 5.4rem !important; /* 导航栏最小高度为 5.4rem（!important 强制覆盖默认样式） */
+	min-height: 5.4rem !important;
 }
 
 
-@media screen and (min-width:1000px){/* 当屏幕宽度 ≥1000px 时生效 */
+@media screen and (min-width:1000px){
 
-    .nav-con{/* 导航内容容器 */
-        padding: 0 12rem;/* 左右内边距为 12rem，让导航内容在大屏上居中且两侧留白 */
-    }
+.nav-con{
+	padding: 0 12rem;
+}
 
 }
 
 
 
 label{
-    display: none;/* 隐藏所有 label 标签（可能通过其他方式展示表单说明，如占位符） */
+	display: none;
 }
 
 .logindiv{
-    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，与上方元素拉开距离 */
+	border: 1px solid white;
+	padding: 0rem 3.5rem;
+	height: 32rem;
+	background: rgba(255,255,255,.9);
+	position: relative;
+	margin-top: 5rem;
 }
 
 .login-h{
-    border-bottom: 2px solid #337AB7;/* 底部边框：2px 实线，蓝色（#337AB7 是 Bootstrap 主题蓝） */
-    text-align: center;/* 文本居中 */
-    letter-spacing: 2.5px;/* 字符间距 2.5px，增强标题感 */
+	border-bottom: 2px solid #337AB7;
+	text-align: center;
+	letter-spacing: 2.5px;
 }
 
 .login-f{
-    padding-top: 2rem !important;/* 顶部内边距 2rem（!important 强制覆盖默认样式） */
+	padding-top: 2rem !important;
 }
 
 .forminput{
-    height: 4rem;/* 输入框高度 4rem，统一表单元素尺寸 */
+	height: 4rem;
 }
 
 .main{
-    background: url('../img/pexels-photo-545049.jpg') no-repeat;/* 背景图：引用指定图片，不重复 */
-    background-repeat:no-repeat;/* 重复设置不重复（冗余保险） */
-    background-size: cover;/* 背景图自适应：覆盖整个容器，可能裁剪但保持比例 */
-    min-height: 40rem;/* 最小高度 40rem，确保内容区有足够高度 */
+	background: url('../img/pexels-photo-545049.jpg') no-repeat;
+	background-repeat:no-repeat;
+    background-size: cover;
+	min-height: 40rem;
 }
-/*文本输入框样式*/
+
 input[type="text"],
 input[type="password"]{
-    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%（显示用户名图标） */
+	text-indent:2.3rem;
+	font-weight:normal;
+	color:black;
+	background:url('../img/login-sprite.png') no-repeat white;
+	background-position:3% 10%;
 }
-/*密码框图标定位*/
+
 input[type="password"]{
-    background-position:3% 90%;  /* 密码框精灵图位置：水平 3%，垂直 90%（显示密码图标） */
+	background-position:3% 90%;
 }
-/*验证码输入框样式*/
+
 .inputcode{
-    background-position:3% 90% !important;/* 强制验证码输入框使用精灵图 90% 位置的图标（可能复用密码图标） */
+	background-position:3% 90% !important;
 }
-/*验证码区域样式*/
+
 .code{
-    height: 4rem;/* 高度 4rem，与输入框保持一致 */
-    width: 100%;/* 宽度 100%，适应父容器 */
-    border:1px solid #3D86ED;/* 边框：1px 实线，浅蓝色 */
-    border-radius: 5px;/* 圆角 5px，柔和边框 */
+	height: 4rem;
+	width: 100%;
+	border:1px solid #3D86ED;
+	border-radius: 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,118 +1,117 @@
-/*这段 CSS 代码主要用于设置网站导航栏、侧边栏和主内容区的样式，整体风格统一且带有交互效果。*/
 .navbar-default{
-    transition: all 0.6s; /* 所有样式变化添加0.6秒过渡动画（如hover效果、展开收起） */
-    background-color: #219ED8;/* 导航栏背景色：亮蓝色 */
-    border: 0;/* 取消默认边框 */
-    border-radius: 0;/* 取消默认圆角，改为直角 */
+	transition: all 0.6s;
+	background-color: #219ED8;
+	border: 0;
+	border-radius: 0;
 }
 
 
-.header{
-    text-align: center;/* 文本居中对齐 */
-    letter-spacing: 1rem;/* 字符间距1rem，增强标题的视觉松散感 */
+.header{                                       
+	text-align: center;
+	letter-spacing: 1rem;
 }
 
 .navbar{
-    min-height: 5.4rem !important;/* 导航栏最小高度5.4rem（!important强制覆盖默认值） */
+	min-height: 5.4rem !important;
 }
 
-/*大屏幕响应式布局*/
-@media screen and (min-width:1000px){ /* 屏幕宽度≥1000px时生效 */
 
-    .nav-con{/* 导航内容容器 */
-        padding: 0 12rem;/* 左右内边距12rem，让导航内容在大屏上两侧留白，居中展示 */
-    }
+@media screen and (min-width:1000px){
+
+.nav-con{
+	padding: 0 12rem;
+}
 
 }
 
 label{
-    display: none;/* 隐藏所有<label>标签（可能通过占位符或其他方式提示表单内容） */
+	display: none;
 }
 
-/*导航链接样式*/
+
 .navbar-default .navbar-nav>li>a {
-    color: white;/* 导航链接文字颜色：白色 */
+    color: white;
 }
 
 li.navli{
-    margin-right: 40px;/* 导航项右侧间距40px，避免链接挤在一起 */
+	margin-right: 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;/* 样式变化过渡动画0.6秒 */
-    transform: scale(1.0,1.2);/* Y轴拉伸1.2倍（纵向轻微放大，增强激活感） */
+	background: transparent;
+	color: white;
+	transition: all 0.6s;
+	transform: scale(1.0,1.2);
 }
 
-/*导航链接内边距*/
+
 .navbar-nav>li>a{
-    padding-top: 1.7rem;/* 导航链接顶部内边距1.7rem，控制文字在导航栏中的纵向位置 */
+	padding-top: 1.7rem;
 }
 
 
 .navbar-default .navbar-nav>li>a:hover{
-    color: white;/* 悬停时文字保持白色（默认是灰色） */
-    transition: all 0.6s;/* 过渡动画0.6秒（可配合其他hover样式平滑变化） */
+	color: white;
+	transition: all 0.6s;
 }
 
 .main{
-    margin-top: -20px;/* 顶部负外边距-20px，消除与导航栏之间的默认间距 */
+	margin-top: -20px;
 }
 
 .nopadding{
-    padding: 0;/* 清除元素所有内边距（通用工具类） */
+	padding: 0;
 }
 
 .navlist{
-    min-height: 58rem;/* 侧边栏最小高度58rem，确保高度足够容纳内容 */
-    background: #254552;/* 侧边栏背景色：深青灰色 */
+	min-height: 58rem;
+	background: #254552;
 }
-/*侧边栏链接样式*/
+
 a.list-group-item{
-    color: #C2D2CB;/* 链接文字颜色：浅灰绿色 */
-    padding-left: 3rem;/* 左侧内边距3rem，文字向右缩进，增强层级感 */
+	color: #C2D2CB;
+	padding-left: 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;/* 悬停/聚焦时背景仍透明（!important强制覆盖） */
-    color: #C2D2CB !important;/* 文字颜色保持不变（!important强制覆盖） */
+	background-color:transparent !important;
+	color: #C2D2CB !important;
 
 }
 
 .list-group-item.active,.list-group-item.active:hover{
-    background: #20343D  !important;/* 激活项背景色：更深的青灰色（!important强制覆盖） */
-    color:white !important; /* 激活项文字颜色：白色（突出显示） */
-    border: 0;/* 无边框 */
+	background: #20343D  !important;
+	color:white !important;
+	border: 0;
 }
-/*图标间距*/
+
 .glyphicon{
-    margin-right: 10px;/* 图标右侧间距10px，与文字分隔开 */
+	margin-right: 10px;
 }
-/*主内容框架*/
+
 .mainFrame{
-    width: 100%;/* 宽度100%，占满父容器 */
-    min-height: 60rem;/* 最小高度60rem，确保内容区有足够高度 */
+	width: 100%;
+	min-height: 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%;/* 宽度为父容器的50%（自适应父元素大小） */
-    border-radius: 50%;/* 圆角半径50%，将图片裁剪成圆形 */
-    border: 1px solid black; /* 1px黑色实线边框，勾勒出头像的轮廓 */
-    margin-left:25%;/* 左侧外边距25%（配合父容器宽度的25%），配合50%宽度实现水平居中 */
+	width: 50%;
+	border-radius: 50%;
+	border: 1px solid black;
+	margin-left:25%;
 }
-/*设置用户名的展示样式，通过居中和与头像的间距*/
+
 .username{
-    text-align: center; /* 文本水平居中（与头像对齐，保持布局一致性） */
-    margin-top: 20px; /* 顶部外边距20px，与上方头像保持距离，避免拥挤 */
-    font-size: 1.7rem;/* 字体大小1.7rem（相对单位，适配不同屏幕） */
+	text-align: center;
+	margin-top: 20px;
+	font-size: 1.7rem;
 }
 
 .glyphicon{
-    margin-right: 0;/* 清除图标图标右侧的默认外边距（重置为0） */
+	margin-right: 0;
 }
-/*定义数据项的通用样式。通过缩进、行高、底部边框等属性，实现数据项的整齐排列和分隔，提升信息展示的条理性。*/
+
 .fdata {
-    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;/* 左浮动，让多个数据项横向排列（或在父容器内靠左对齐） */
+    padding-left: 2%;
+    width: 100%;
+    margin: 0 auto;
+    line-height: 3.2;
+    border-bottom: 2px solid #e6e6e6;
+    overflow: hidden;
+    float: left;
 }
 
 .alterinfo{
-    margin-bottom: 20px !important;/* 底部外边距20px，且通过!important强制覆盖其他样式，确保与下方元素的间距 */
+	margin-bottom: 20px !important;
 }

src/main/resources/static/index.html

@@ -1,90 +1,100 @@
-<!-- 酒店管理系统的登录页面 前端结构-->
 <!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>Copyright © 2018 西安工业大学 All Rights Reserved</em>
+            <!-- 版权信息：标明开发主体和年份，符合项目规范 -->
+            <em>2025 合肥师范学院 软件工程</em>
         </p>
 
     </div>
@@ -93,7 +103,9 @@
 
 </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>
-<script type="text/javascript" src="js/index.js"></script><!--登录页面自定义脚本-->
-
+<!-- 引入登录页专属JS：实现验证码加载刷新、登录表单校验、登录请求提交等核心逻辑 -->
+<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("修改成功");
+	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();
 
-                }
-                else{
-                    alert("修改配置错误");
-                }
-                // 无论成功与否，刷新页面重新加载配置
-                window.location.reload();
+			},
+			 // 请求失败的回调函数
+			error:function(){
+				alert("修改配置发生错误")
+			}
 
-            },
-            // 请求失败的回调函数
-            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,306 +1,299 @@
-/**
- * 酒店客房管理系统前端JavaScript代码
- * 功能：房间列表展示、分页、增删改查操作
- */
-
-var pageNum=1;// 当前页码，默认为1
-var pageSize=8; // 每页显示的房间数量
-var l;// 当前页实际显示的房间数量
+var pageNum=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;// 如果有属性，返回0（非空）
-    return 1;// 没有属性，返回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;// 存储当前页的房间列表数据
+var list;
 // 从后端获取房间列表并展示
 function getroomList(){
-    $.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\">";
-                    }
-                    // 根据房间类型编码转换为文本
+	$.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\">";
+					}
+					// 根据房间类型编码转换为文本
 
-                    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,153 +36,147 @@ 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){
-                        //生成删除按钮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("获取员工列表失败");
-            }
+	$.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("获取员工列表失败");
+			}
+			
 
-
-        },
-        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("删除成功");
-                // 如果删除的是当前页最后一条，页码减1
-                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("删除成功");
+				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,13 +1,10 @@
 // 定义jQuery扩展方法：从URL参数中获取指定名称的值
 (function($){
-    //创建了一个$.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;
-    }
+	$.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参数中获取用户权限（power）和用户ID（userid）
 var power=$.getData('power');
@@ -15,40 +12,38 @@ 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(){
-    // 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)
-    });
+	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)
+	});
 }
 // 切换菜单选中状态（高亮当前点击的菜单，取消其他菜单的高亮）
 function changeColor(event){
-    var obj=event.target;//获取实际触发点击事件的DOM元素
-    var objSi=$(obj).siblings();//获取当前元素的所有同级元素
-    $(obj).attr("class","list-group-item active");//为被点击的菜单项添加active类
-    $(objSi).attr("class","list-group-item ");//移除其他菜单项的active类
+	var obj=event.target;
+	var objSi=$(obj).siblings();
+	$(obj).attr("class","list-group-item active");
+	$(objSi).attr("class","list-group-item ");
 }

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

@@ -1,207 +1,203 @@
-//清洁工管理的页面,分页获取清洁工列表、添加清洁工、删除清洁工
-var pageNum=1; // 当前页码，默认为第1页
+var pageNum=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=" "; // 用于累积生成表格行的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();
-            }
+	$.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();
+			}
+			
 
-
-        },
-        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"); // 从按钮的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("删除出现错误");
-        }
-    })
+	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("删除出现错误");
+		}
+	})
 
 }
 // 添加新清洁工
 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,183 +28,182 @@ 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=" "; // 用于拼接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();
-            }
+	$.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();
+			}
 
-        },
-        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");// 从按钮的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("修改信息出现错误");
-        }
-    })
+	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("修改信息出现错误");
+		}
+	})
 }
 // 跳转到指定页码
 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");// 从按钮的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("获取信息出现错误");
-        }
-    })
+	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("获取信息出现错误");
+		}
+	})
 }

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

@@ -1,54 +1,52 @@
-//酒店管理系统的员工订房页面
 // 定义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");// 当前登录员工的用户ID
+var staffid=$.getData("userid");
 var pageNum=1;
 var pageSize=8;
-var choose;// 存储用户选择的房间ID
+var choose;
 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();
+	});
 
 })
 
@@ -56,162 +54,158 @@ $(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=" ";// 用于拼接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();
-            }
+	$.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();
+			}
 
-        },
-        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");// 从按钮的data属性获取房间ID
-    // 保存选择的房间ID到全局变量
-    choose=roomid;
-    // 遍历房间列表，找到对应的房间信息
-    for(i in list){
-        if(list[i].roomid=roomid){
-            $("span").filter("#inputLocal").text(list[i].local);
-        }
-    }
+	var roomid=$(event.target).data("roomid");
+	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,74 +1,55 @@
-<!--员工信息管理页面前端结构-->
 <!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 框架的压缩版样式表，用于快速实现响应式布局（如表格、表单样式），避免重复编写基础 CSS。-->
+    <!-- 引入Bootstrap样式库：提供基础UI组件（表格、按钮、表单等）的样式支持 -->
     <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>
-<!--定义员工列表的外层容器，使用 Bootstrap 栅格类和自定义样式控制布局：
-col-md-11：在中等屏幕（≥992px）下占 11 列（Bootstrap 栅格共 12 列，留 1 列空白）；
-col-xs-11：在超小屏幕（<768px）下占 11 列，适配移动端；
-nopadding：自定义类（前文 CSS 定义），清除左右内边距；
-内联样式 padding-top:3rem：顶部内边距 3rem，与上方导航栏 / 页头拉开距离；
-内联样式 padding-left: 3rem：左侧内边距 3rem，避免内容贴左边缘。-->
+<!-- 主体内容容器：占11列（Bootstrap栅格系统），清除默认内边距，设置顶部和左侧内边距控制位置 -->
 <div class="col-md-11 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 3rem">
-    <!--Bootstrap 内置类，让表格在小屏幕下可横向滚动-->
+    <!-- 表格响应式容器：在小屏幕上自动出现横向滚动条，确保表格内容不溢出 -->
     <div class="table-responsive">
-        <!--定义员工列表表格，通过类和属性控制样式与标识：
-      table：Bootstrap 基础表格样式（默认边框、间距）；
-      table-bordered：为表格添加所有单元格的边框；
-      table-hover：鼠标悬停在表格行上时，行背景色变化；
-      内联样式 margin-top: 10px：顶部外边距 10px，与上方元素拉开微小距离；
-      id="staffList"：给表格设置唯一 ID，方便后续 JavaScript 操作。-->
+        <!-- 表格组件：边框样式、鼠标悬浮高亮，设置顶部间距，通过ID关联JS操作 -->
         <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>
-        <!--Bootstrap 栅格类，让分页控件在中等及以上屏幕下占 12 列（全屏宽度）-->
+        <!-- 分页控制区域：占12列（全屏宽度），使用内联表单布局 -->
         <div class="col-md-12">
-            <!--Bootstrap 行内表单类 form-inline，让表单元素（如下一页链接）横向排列-->
             <form class="form-inline">
-                <!--定义 “上一页” 分页按钮：
-          form-group：Bootstrap 表单组类，用于统一表单元素的间距和样式；
-          内联样式 margin-right: 10xp（疑似笔误，应为 10px）：右侧外边距 10px，与 “下一页” 拉开距离；
-          <a href="#">：空链接（默认不跳转），后续通过 JavaScript 绑定 “上一页” 点击事件；
-          id="pre"：唯一 ID，方便 JS 定位并添加分页逻辑。-->
-                <div class="form-group" style="margin-right: 10px">
+                <!-- 上一页按钮组：设置右侧间距，通过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>-->
-                <!--定义 “下一页” 分页按钮，与 “上一页” 对称：
-              内联样式 margin-left: 10px：左侧外边距 10px，与 “上一页”（或注释的跳转功能）拉开距离；
-              id="next"：唯一 ID，方便 JS 绑定 “下一页” 点击事件。-->
+                <!-- 下一页按钮组：设置左侧间距，通过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 请求（加载员工数据），是 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><!--引入自定义的员工管理脚本-->
+<!-- 引入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>

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

@@ -1,79 +1,91 @@
-<!--订单管理页面的前端结构-->
 <!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">
-	<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">
+    <!-- 引入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">
 
 </head>
 
 <body>
-
+<!-- 左侧订单列表区域：占9列（Bootstrap栅格），清除默认内边距，设置顶部和左侧内边距控制位置 -->
 <div class="col-md-9 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 2rem">
-  <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 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>
-      </form>
     </div>
-  </div>
 </div>
 
+<!-- 右侧数据统计区域：占3列（Bootstrap栅格），与左侧订单列表并列，展示核心运营数据 -->
 <div class="col-md-3 col-xs-11 nopadding" style="padding-top:3rem;padding-left: 20px">
-  <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>
+    <!-- 总交易额统计卡片：使用列表组样式，通过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>
 
 </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>
-      </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> <!-- 表格通过ID供JS动态渲染房间数据（如房间号、位置、价格） -->
+            </div>
+        </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/ad_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/ad_order.js"></script> <!-- 订单管理自定义JS：实现数据加载、分页、模态框交互等业务逻辑 -->

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

@@ -1,116 +1,73 @@
-<!--员工薪资配置管理页面的前端结构，-->
 <!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 框架的压缩版样式表，用于快速实现响应式布局（如表格、表单样式），避免重复编写基础 CSS。-->
+    <!-- 引入Bootstrap基础样式：提供表格、按钮、输入框等组件的默认样式，保证界面统一性 -->
     <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">
-        <!--“切换到编辑模式” 的按钮：
-  glyphicon glyphicon-pencil：Bootstrap 图标（铅笔图标，暗示编辑功能）；
-  文本 “更改配置” 明确功能；
-  id="showConfig"：JS 绑定点击事件，用于切换到编辑状态。-->
+        <!-- “更改配置”按钮：带铅笔图标，点击切换到编辑面板，通过ID绑定JS事件 -->
         <a href="#" id="showConfig" style="font-size:1.7rem">
-            <span class="glyphicon glyphicon-pencil"></span>
+            <span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，标识“编辑”功能 -->
             <span>更改配置</span>
         </a>
-        <!--展示薪资配置的表格（查看模式）：
-  table table-bordered table-hover：Bootstrap 表格样式（带边框、悬停高亮）；
-  表头包含 “职位”“底薪”“提成” 三列；
-  id="configList"：JS 动态填充数据（从后端加载当前配置）。-->
+        <!-- 配置展示表格：带边框、鼠标悬浮高亮效果，通过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>
     </div>
-    <!--结束 “查看配置” 区域容器。-->
 
-    <!--“编辑配置” 状态的容器，默认通过 display: none 隐藏；id="alterConfigDiv" 用于 JS 控制显示 / 隐藏。-->
+    <!-- 配置编辑面板（默认隐藏）：用于修改薪资配置，初始通过display: none隐藏 -->
     <div class="table-responsive" id="alterConfigDiv" style="display: none">
-        <!--   “返回查看模式” 的按钮：
-           图标与 “更改配置” 一致，文本改为 “返回”；
-           id="alterConfig"：JS 绑定点击事件，用于切换回查看状态。-->
+        <!-- “返回”按钮：点击切换回查看面板，通过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>
-            <!--经理职位的薪资编辑行：
-            input 输入框：用于修改底薪（id="inputMS"）和提成（id="inputM"）；
-            form-control：Bootstrap 输入框样式，确保美观和响应式。-->
+            <!-- 经理薪资编辑行：输入框通过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>
+                <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>
-        <!--提交修改的按钮：
-  float: right：右对齐，符合操作习惯；
-  btn btn-success：Bootstrap 成功样式按钮（绿色）；
-  id="alterConfigBtn"：JS 绑定点击事件，用于提交修改后的薪资配置。-->
+        <!-- 确认修改按钮：右对齐，绿色按钮突出“确认”操作，通过ID绑定JS提交事件 -->
         <input style="float: right" type="button" id="alterConfigBtn" class="btn btn-success" value="确定"/>
     </div>
-    <!--结束 “编辑配置” 区域容器。-->
-
 </div>
 
-
-
-
-
 </body>
-
 </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 点击事件，获取输入框值并提交到后端保存，成功后更新查看区域数据。-->
+
+<!-- 引入依赖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：实现面板切换、数据加载与提交 -->

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

@@ -1,222 +1,73 @@
-<!--用户信息管理页面的前端结构-->
 <!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>
-<!--页面最外层容器，占满整行（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>
-        <!--结束左侧头像区域容器。-->
+<!-- 主体内容容器：占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>
     </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>
-<!--：结束右侧信息区域和页面最外层容器。-->
-
-<!--头像修改弹窗，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><!--自定义用户信息管理脚本-->
+
+<!-- 引入依赖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：实现查看/编辑面板切换、数据加载与提交等业务逻辑 -->

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

@@ -1,69 +1,53 @@
-<!--清洁工视角的房间管理页面 前端结构-->
 <!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 框架的压缩版样式表，用于快速实现响应式布局（如表格、表单样式），避免重复编写基础 CSS。-->
+    <!-- 引入Bootstrap基础样式：提供表格、按钮、表单等组件的默认样式，保证界面美观统一 -->
     <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">
-        <!--定义房间列表表格，通过类和属性控制样式与标识：
-  table：Bootstrap 基础表格样式（默认间距、轻量边框）；
-  table-bordered：为所有单元格添加完整边框，清晰分隔行列；
-  table-hover：鼠标悬停在表格行上时背景色变化，提升交互体验；
-  内联样式 margin-top: 10px：顶部外边距 10px，与容器顶部轻微拉开距离；
-  id="roomList"：唯一 ID，方便后续 JavaScript 动态填充房间数据（如从后端加载房间列表）。-->
+        <!-- 房间列表表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染房间数据 -->
         <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">
-                <!--定义 “上一页” 按钮，用于加载前一页房间数据-->
-                <div class="form-group" style="margin-right: 10px">
+                <!-- 上一页按钮：设置右侧间距，通过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>
     </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,90 +1,76 @@
-<!-- 管理员视角的房间管理页面 -->
 <!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-toggle="modal" data-target="#addRoom"：Bootstrap 模态框触发属性，点击打开 id="addRoom" 的弹窗；
-  font-size:1.7rem：按钮文字放大，突出 “添加” 核心操作；
-  glyphicon glyphicon-pencil：铅笔图标，暗示 “编辑 / 新增” 功能；
-  文本 “添加房间” 明确功能，符合管理员操作场景。-->
+        <!-- “添加房间”按钮：带铅笔图标，点击通过data属性触发“添加房间”模态框 -->
         <a href="#" style="font-size:1.7rem" data-toggle="modal" data-target="#addRoom" >
-            <span class="glyphicon glyphicon-pencil"></span>
+            <span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，标识“新增”功能 -->
             <span>添加房间</span>
         </a>
-        <!--定义房间列表表格，通过类和属性控制样式与标识：
-  table：Bootstrap 基础表格样式；
-  table-bordered：为所有单元格添加边框，清晰分隔行列；
-  table-hover：鼠标悬停行时背景色变化，提升交互体验；
-  内联样式 margin-top: 10px：顶部外边距 10px，与 “添加房间” 按钮拉开距离；
-  id="roomList"：唯一 ID，方便后续 JS 动态填充房间数据（如从后端加载列表）。-->
+        <!-- 房间列表表格：带边框、鼠标悬浮高亮效果，固定列宽避免布局混乱，通过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">
-                <div class="form-group" style="margin-right: 10px">
+                <!-- 上一页按钮：设置右侧间距，通过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>
     </div>
-
-
 </div>
 
 </body>
-<!--结束表格容器和页面主容器。-->
 
-<!--添加房间” 弹窗-->
-<!--弹窗头部：modal fade：Bootstrap 弹窗基础样式 + 淡入淡出动画；
-关闭按钮：data-dismiss="modal" 内置关闭功能；
-标题 “添加房间” 明确弹窗用途。-->
+<!-- 新增房间模态框：隐藏状态，通过data-target="#addRoom"触发显示，用于录入新房间信息 -->
 <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>
-            <!--“房间位置” 输入项：form-group alterinfo：控制表单组样式（间距、对齐）-->
-            <div class="modal-body" style="width: 80%;padding-left:20%">
+            <div class="modal-body" style="width: 80%;padding-left:20%"> <!-- 模态框主体：表单区域，居中布局 -->
+                <!-- 房间位置输入项：标签+输入框，通过ID供JS获取输入值 -->
                 <div class="form-group alterinfo">请输入位置：
-                    <label for="inputLocal">inputPrice</label>
+                    <label for="inputLocal">inputPrice</label> <!-- 标签for属性与输入框ID关联，提升可访问性 -->
                     <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>
-                <!--“房间类型” 下拉选择框：选项值 1-4 对应不同房型，便于后端存储；id="inputType"：JS 获取选中的类型值。-->
+                <!-- 房间类型下拉选择项：预设单人间、双人间等选项，通过ID供JS获取选择值 -->
                 <div class="form-group alterinfo">请选择类型：
                     <select class="form-control" id="inputType">
                         <option value="1">单人间</option>
@@ -93,18 +79,16 @@ nopadding：自定义类，清除容器默认左右内边距；
                         <option value="4">套房</option>
                     </select>
                 </div>
-                <!--“确认添加” 按钮：
-               btn btn-success：Bootstrap 绿色成功样式按钮；
-               id="addRoomBtn"：JS 绑定点击事件，提交新增房间数据。-->
+                <!-- 确认添加按钮：绿色按钮突出“确认”操作，通过ID供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">
@@ -112,22 +96,22 @@ nopadding：自定义类，清除容器默认左右内边距；
                 <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>
@@ -136,16 +120,17 @@ nopadding：自定义类，清除容器默认左右内边距；
                         <option value="4">套房</option>
                     </select>
                 </div>
-                <!--“确认修改” 按钮，id="setRoomBtn" 绑定 JS 事件，提交修改后的房间数据。-->
+                <!-- 确认修改按钮：通过ID供JS绑定提交事件，提交修改后关闭模态框并刷新表格 -->
                 <div class="form-group alterinfo">
                     <input type="button" id="setRoomBtn" class="btn btn-success" value="确定"/>
                 </div>
             </div>
-
         </div>
     </div>
 </div>
 </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 组件，激活弹窗的显示 / 隐藏、动画等交互效果。-->
-<script type="text/javascript" src="../js/manage_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/manage_room.js"></script> <!-- 管理员房间管理自定义JS：实现房间数据加载、新增/修改/分页等核心逻辑 -->

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

@@ -1,90 +1,86 @@
-<!-- 管理员视角的员工管理页面前端结构-->
 <!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-toggle="modal" data-target="#addUser"：Bootstrap 模态框触发属性，点击打开 id="addUser" 的弹窗-->
+        <!-- “添加员工”按钮：带铅笔图标，通过data属性触发“添加员工”模态框，明确功能用途 -->
         <a href="#" style="font-size:1.7rem" data-toggle="modal" data-target="#addUser" >
-            <span class="glyphicon glyphicon-pencil"></span>
+            <span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，增强“新增”操作辨识度 -->
             <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">
-                <div class="form-group" style="margin-right: 10px">
+                <!-- 上一页按钮：设置右侧间距，通过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>
     </div>
-
-
 </div>
 
 </body>
-<!--定义 “添加员工” 弹窗，modal fade 是 Bootstrap 模态框基础样式（带淡入淡出动画），id="addUser" 用于触发显示。-->
+
+<!-- 新增员工模态框：隐藏状态，通过data-target="#addUser"触发显示，用于录入新员工基础信息 -->
 <div class="modal fade" id="addUser" tabindex="-1" role="dialog">
-    <!--弹窗头部：关闭按钮：data-dismiss="modal" 是 Bootstrap 内置属性，点击关闭弹窗-->
-    <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>
-            <!--弹窗主体区域，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="modal-body" style="width: 80%;padding-left:20%"> <!-- 模态框主体：表单区域，居中布局提升美观度 -->
+                <!-- 员工账号输入项：标签+输入框，通过ID供JS获取输入的账号（登录核心凭证） -->
                 <div class="form-group alterinfo">请输入账号：
-                    <label for="newAcc">newAcc</label>
+                    <label for="newAcc">newAcc</label> <!-- 标签for属性与输入框ID关联，提升可访问性（点击标签聚焦输入框） -->
                     <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>
-                <!--“确认添加” 按钮：btn btn-success：Bootstrap 绿色成功样式按钮，提示操作正向性；
-                  id="addUserBtn"：JS 绑定点击事件，验证并提交新增员工数据（账号、密码）。-->
+                <!-- 确认添加按钮：绿色按钮突出“确认”操作，通过ID供JS绑定提交事件 -->
                 <div class="form-group alterinfo">
                     <input type="button" id="addUserBtn" class="btn btn-success" value="确定"/>
                 </div>
             </div>
-
         </div>
     </div>
 </div>
 </html>
-<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><!--自定义员工管理脚本-->
+
+<!-- 引入依赖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：实现员工数据加载、新增、分页等核心逻辑 -->

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

@@ -1,76 +1,63 @@
-<!-- 酒店管理系统的主框架页面-->
 <!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">
-    <!--导航栏容器，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">
+    <div class="container-fluid nav-con"> <!-- 导航栏容器，通过自定义类控制样式 -->
+        <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>
-                <li class="navli"><a href="../index.html">退出</a></li>
+                <li class="navli"><a href="#">欢迎！</a></li> <!-- 动态显示当前登录用户名（需JS填充） -->
+                <li class="navli"><a href="../index.html">退出</a></li> <!-- 退出系统，跳转回登录页 -->
             </ul>
         </div>
     </div>
 </nav>
-<!--主内容区外层容器，col-md-12 占满整行，main 是自定义类，nopadding 清除默认内边距。-->
+
+<!-- 主体内容区：左右分栏布局，占满12列 -->
 <div class="col-md-12 main nopadding">
-    <!--左侧功能导航栏：
-        col-md-2：中等屏幕下占 2 列（总 12 列），宽度约 1/6，为右侧内容区留空间；
-        navlist：自定义类（控制导航栏样式，如深色背景、最小高度）；
-        list-group：Bootstrap 列表组样式，用于渲染导航项；
-        id="tagList"：空容器，后续通过 JS 动态填充系统模块（如 “员工管理”“房间管理”“订单管理”），实现导航项的灵活加载。-->
+    <!-- 左侧侧边栏：占2列，展示功能菜单列表 -->
     <div class="col-md-2 navlist nopadding">
         <div class="list-group" id="tagList">
-
+            <!-- 功能菜单通过JS动态生成（根据用户权限显示不同菜单，如管理员显示“员工管理”，清洁工显示“房间清洁”） -->
         </div>
-
-
     </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 设置默认加载页面-->
+
+    <!-- 右侧内容展示区：占10列，通过iframe加载具体功能页面 -->
     <div class="col-md-10 nopadding">
         <iframe frameborder="0" id="mainFrame" class="mainFrame" name="mainFrame" src=""></iframe>
+        <!-- iframe特性：页面切换时不刷新整体布局，仅加载内部内容，提升操作流畅度 -->
     </div>
-
 </div>
+
+<!-- 页脚（当前注释未启用）：预留系统版权、联系信息等内容展示区域 -->
 <!--
 <footer class="col-md-12 bs-docs-footer">
   <div class="col-md-12">
@@ -81,15 +68,16 @@
     <a href="#">诚征英才</a>
     <a href="#">联系我们</a>
     <a href="#">网站地图</a><br/><br/>
-    <em>Copyright © 2017 西安工业大学 All Rights Reserved</em>
+    <em>Copyright © 2025 合肥师范学院 All Rights Reserved</em>
     </p>
-
   </div>
-</footer>-->
-
+</footer>
+-->
 
 </body>
 </html>
-<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><!--自定义主框架脚本-->
+
+<!-- 引入依赖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加载、填充用户名等核心逻辑 -->

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

@@ -1,80 +1,86 @@
-<!-- 清洁工专项管理页面 的前端结构-->
 <!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>
+            <span class="glyphicon glyphicon-pencil"></span> <!-- Bootstrap内置图标，增强“新增”操作辨识度 -->
             <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">
-                <div class="form-group" style="margin-right: 10px">
+                <!-- 上一页按钮：设置右侧间距，通过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>
     </div>
-
-
 </div>
 
 </body>
-<!--定义 “添加清洁工” 的弹窗-->
+
+<!-- 新增清洁工模态框：隐藏状态，通过data-target="#addUser"触发显示，用于录入新清洁工基础信息 -->
 <div class="modal fade" id="addUser" tabindex="-1" role="dialog">
-    <!--弹窗头部区域，包含关闭按钮和标题：关闭按钮：data-dismiss="modal" 是 Bootstrap 内置属性，点击后直接关闭弹窗；&times; 是 “×” 符号，直观表示关闭功能；
-         标题 “添加清洁工”：明确弹窗用途，与按钮文字呼应-->
-    <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%">
-                <!--“清洁工账号” 输入项-->
+            <div class="modal-body" style="width: 80%;padding-left:20%"> <!-- 模态框主体：表单区域，居中布局提升美观度与操作便捷性 -->
+                <!-- 清洁工账号输入项：标签+输入框，账号为登录核心凭证，通过ID供JS获取输入值 -->
                 <div class="form-group alterinfo">请输入账号：
-                    <label for="newAcc">newAcc</label>
+                    <label for="newAcc">newAcc</label> <!-- 标签for属性与输入框ID关联，点击标签可聚焦输入框，提升可访问性 -->
                     <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>
-<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><!--清洁工专项管理的自定义脚本-->
+
+<!-- 引入依赖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：实现列表渲染、新增提交、分页等核心逻辑 -->

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

@@ -1,65 +1,70 @@
-<!--员工视角的订单管理页面前端结构-->
 <!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">
-                <div class="form-group" style="margin-right: 10px">
+                <!-- 上一页按钮：设置右侧间距，通过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>
     </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,97 +1,99 @@
-<!--员工视角的房间管理与订单生成页面 前端结构-->
 <!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="roomList"：唯一 ID，方便后续 JavaScript 动态填充房间数据（如从后端加载房间列表，区分 “空闲”“已入住” 等状态）-->
+        <!-- 房间列表表格：带边框、鼠标悬浮高亮效果，通过ID供JS动态渲染房间数据 -->
         <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">
-                <div class="form-group" style="margin-right: 10px">
+                <!-- 上一页按钮：设置右侧间距，通过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>
     </div>
-
-
 </div>
 
 </body>
-<!--定义 “为房间生成订单” 的弹窗-->
+
+<!-- 生成订单模态框：隐藏状态，点击房间“操作”列的“预订”按钮触发，用于录入客人信息并创建订单 -->
 <div class="modal fade" id="chooseRoom" tabindex="-1" role="dialog">
-    <!--弹窗头部区域：
-     关闭按钮：data-dismiss="modal" 是 Bootstrap 内置属性，点击关闭弹窗；&times; 为 “×” 符号，直观表示关闭；
-     标题 “生成订单”：明确弹窗用途，与房间列表 “操作” 列功能呼应。-->
-    <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="inputLocal" 由 JS 动态填充当前选中房间的位置。-->
+            <div class="modal-body" style="width: 80%;padding-left:20%"> <!-- 模态框主体：表单区域，居中布局提升操作便捷性 -->
+                <!-- 房间位置展示项：仅显示选中房间的位置，不可编辑，通过ID供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>
-<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><!--自定义房间管理与订单生成脚本-->
-
-
-
+<!-- 引入依赖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：实现房间列表渲染、订单生成、分页等核心逻辑 -->