zxy

.idea/misc.xml

@@ -8,9 +8,4 @@
     </option>
   </component>
   <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8" project-jdk-type="JavaSDK" />
-  <component name="SwUserDefinedSpecifications">
-    <option name="specTypeByUrl">
-      <map />
-    </option>
-  </component>
 </project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+    <component name="VcsDirectoryMappings">
+        <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    </component>
+</project>

back/src/main/java/com/SpringbootSchemaApplication.java

@@ -1,21 +1,54 @@
 package com;
 
+// 导入 MyBatis-Spring 框架提供的注解，用于扫描指定包下的 Mapper 接口
+// 扫描后 Spring 会自动为这些接口创建代理对象，从而实现数据库操作
 import org.mybatis.spring.annotation.MapperScan;
+// 导入 Spring Boot 应用启动相关的类，该类可用于启动 Spring Boot 应用
 import org.springframework.boot.SpringApplication;
+// 导入 Spring Boot 自动配置注解，启用 Spring Boot 的自动配置功能
+// 它会根据项目依赖自动配置 Spring 应用的各种组件
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+// 导入 Spring Boot 应用构建器类，用于构建 Spring Boot 应用实例
 import org.springframework.boot.builder.SpringApplicationBuilder;
+// 导入 Spring Boot 支持 Servlet 容器部署的初始化器类
+// 继承该类可使 Spring Boot 应用以 WAR 包形式部署到外部 Servlet 容器
 import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
 
+/**
+ * Spring Boot 应用的主类，作为整个应用的启动入口。
+ * 它整合了 Spring Boot 的自动配置功能和 MyBatis 的 Mapper 扫描功能，
+ * 并且支持将应用打包成 WAR 包部署到外部 Servlet 容器中。
+ */
 @SpringBootApplication
+// 此注解用于指定 MyBatis 要扫描的 Mapper 接口所在的包路径
+// 这里指定扫描 "com.dao" 包，Spring 会为该包下的 Mapper 接口生成代理实现
 @MapperScan(basePackages = {"com.dao"})
-public class SpringbootSchemaApplication extends SpringBootServletInitializer{
+public class SpringbootSchemaApplication extends SpringBootServletInitializer {
 
+	/**
+	 * 应用的主方法，是 Java 程序的入口点。
+	 * 当启动 Spring Boot 应用时，会调用此方法，
+	 * 通过 SpringApplication.run 方法启动 Spring Boot 应用上下文。
+	 *
+	 * @param args 命令行参数，可用于传递启动应用时的配置信息
+	 */
 	public static void main(String[] args) {
+		// 调用 SpringApplication 的 run 方法来启动 Spring Boot 应用
+		// 传入当前类的 Class 对象和命令行参数
 		SpringApplication.run(SpringbootSchemaApplication.class, args);
 	}
-	
+
+	/**
+	 * 重写 SpringBootServletInitializer 类的 configure 方法，
+	 * 该方法用于配置 Spring Boot 应用在外部 Servlet 容器中运行时的启动行为。
+	 * 当将应用打包成 WAR 包部署到外部 Servlet 容器（如 Tomcat）时会调用此方法。
+	 *
+	 * @param applicationBuilder SpringApplicationBuilder 对象，用于构建 Spring Boot 应用
+	 * @return 配置好的 SpringApplicationBuilder 对象，指定应用的主类为当前类
+	 */
 	@Override
-    protected SpringApplicationBuilder configure(SpringApplicationBuilder applicationBuilder) {
-        return applicationBuilder.sources(SpringbootSchemaApplication.class);
-    }
-}
+	protected SpringApplicationBuilder configure(SpringApplicationBuilder applicationBuilder) {
+		// 设置 Spring Boot 应用的主类为当前类，确保在外部 Servlet 容器中正确启动
+		return applicationBuilder.sources(SpringbootSchemaApplication.class);
+	}
+}

back/src/main/java/com/entity/ConfigEntity.java

@@ -1,53 +1,99 @@
+// 声明该类所在的包名为 com.entity，通常用于存放与数据库实体对应的 Java 类
 package com.entity;
 
+// 导入 Serializable 接口，实现该接口的类的对象可以被序列化和反序列化，
+// 便于在网络传输或存储时使用
 import java.io.Serializable;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于指定数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定该实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
 /**
-* 类说明 : 
-*/
+ * 类说明 :
+ */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "config"
 @TableName("config")
+// 定义 ConfigEntity 类，实现 Serializable 接口
 public class ConfigEntity implements Serializable{
-private static final long serialVersionUID = 1L;
-	
+	// 定义序列化版本号，用于在序列化和反序列化过程中确保类的版本一致性
+	private static final long serialVersionUID = 1L;
+	// 这里的注释 "测试" 可能是开发者在调试或开发过程中留下的临时信息，可根据实际情况修改或删除
+	// 测试
+	// 测试
+	// 使用 TableId 注解指定该字段为主键，并且主键的生成策略为自动递增（AUTO）
 	@TableId(type = IdType.AUTO)
+	// 定义一个 Long 类型的字段 id，作为数据库表的主键
 	private Long id;
-	
+
 	/**
 	 * key
+	 * 该字段用于存储配置项的键
 	 */
+	// 定义一个 String 类型的字段 name，用于存储配置项的键
 	private String name;
-	
+
 	/**
 	 * value
+	 * 该字段用于存储配置项的值
 	 */
+	// 定义一个 String 类型的字段 value，用于存储配置项的值
 	private String value;
 
+	/**
+	 * 获取主键 id 的值
+	 * @return 主键 id 的值
+	 */
+	// 定义 getId 方法，用于获取 id 字段的值
 	public Long getId() {
 		return id;
 	}
 
+	/**
+	 * 设置主键 id 的值
+	 * @param id 要设置的主键 id 的值
+	 */
+	// 定义 setId 方法，用于设置 id 字段的值
 	public void setId(Long id) {
 		this.id = id;
 	}
 
+	/**
+	 * 获取配置项的键
+	 * @return 配置项的键
+	 */
+	// 定义 getName 方法，用于获取 name 字段的值
 	public String getName() {
 		return name;
 	}
 
+	/**
+	 * 设置配置项的键
+	 * @param name 要设置的配置项的键
+	 */
+	// 定义 setName 方法，用于设置 name 字段的值
 	public void setName(String name) {
 		this.name = name;
 	}
 
+	/**
+	 * 获取配置项的值
+	 * @return 配置项的值
+	 */
+	// 定义 getValue 方法，用于获取 value 字段的值
 	public String getValue() {
 		return value;
 	}
 
+	/**
+	 * 设置配置项的值
+	 * @param value 要设置的配置项的值
+	 */
+	// 定义 setValue 方法，用于设置 value 字段的值
 	public void setValue(String value) {
 		this.value = value;
 	}
-	
-}
+}

back/src/main/java/com/entity/DiscussjiudianjianjieEntity.java

@@ -1,164 +1,255 @@
+// 声明该类所在的包名为 com.entity，通常用于存放与数据库实体对应的 Java 类
 package com.entity;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于指定数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定该实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 JSR-303 验证注解，NotBlank 用于验证字符串不为 null 且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 导入 JSR-303 验证注解，NotEmpty 用于验证集合、数组、字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 导入 JSR-303 验证注解，NotNull 用于验证对象不为 null
 import javax.validation.constraints.NotNull;
-
+// 导入 Jackson 库的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略某些属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射调用时可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可以被序列化和反序列化
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间
 import java.util.Date;
+// 导入 List 接口，用于表示一组对象
 import java.util.List;
-
+// 导入 Spring 框架的 DateTimeFormat 注解，用于指定日期在接收时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 库的 JsonFormat 注解，用于指定日期在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于进行 JavaBean 属性的复制操作
 import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 框架的 TableField 注解，用于指定字段在数据库表中的一些属性
 import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
 /**
  * 酒店简介评论表
  * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:05
  */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "discussjiudianjianjie"
 @TableName("discussjiudianjianjie")
+// 定义 DiscussjiudianjianjieEntity 类，使用泛型 T，实现 Serializable 接口
 public class DiscussjiudianjianjieEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中确保类的版本一致性
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，用于创建 DiscussjiudianjianjieEntity 对象时不传入任何参数的情况
 	public DiscussjiudianjianjieEntity() {
-		
+		// 构造函数体为空，目前没有需要初始化的额外操作
 	}
-	
+
+	/**
+	 * 带参数的构造函数，用于根据泛型对象 t 创建 DiscussjiudianjianjieEntity 对象
+	 * @param t 泛型对象，用于复制属性到当前 DiscussjiudianjianjieEntity 对象
+	 */
 	public DiscussjiudianjianjieEntity(T t) {
+		// 使用 try-catch 块捕获可能出现的异常
 		try {
+			// 调用 BeanUtils 的 copyProperties 方法，将 t 对象的属性复制到当前对象（this）中
+			// 此方法会自动匹配两个对象中相同名称的属性，并进行赋值操作
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 如果在复制属性过程中出现非法访问异常（IllegalAccessException）
+			// 或者反射调用目标方法时出现异常（InvocationTargetException），会进入此 catch 块
+			// 这里的 TODO 表示需要开发者后续根据实际情况完善异常处理逻辑
+			// 目前只是简单地打印异常堆栈信息，方便调试
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
-	
+
 	/**
 	 * 主键id
+	 * 用于唯一标识数据库表中的每一条记录
 	 */
+	// 使用 TableId 注解指定该字段为主键
 	@TableId
+	// 定义一个 Long 类型的字段 id，作为数据库表的主键
 	private Long id;
+
 	/**
 	 * 关联表id
+	 * 用于关联其他表的记录，可能表示与酒店简介相关的其他信息的标识
 	 */
-					
+	// 定义一个 Long 类型的字段 refid，用于存储关联表的 id
 	private Long refid;
-	
+
 	/**
 	 * 用户id
+	 * 用于唯一标识发表评论的用户
 	 */
-					
+	// 定义一个 Long 类型的字段 userid，用于存储用户的 id
 	private Long userid;
-	
+
 	/**
 	 * 用户名
+	 * 显示在评论中的用户昵称
 	 */
-					
+	// 定义一个 String 类型的字段 nickname，用于存储用户名
 	private String nickname;
-	
+
 	/**
 	 * 评论内容
+	 * 用户针对酒店简介发表的具体评论信息
 	 */
-					
+	// 定义一个 String 类型的字段 content，用于存储评论内容
 	private String content;
-	
+
 	/**
 	 * 回复内容
+	 * 针对用户评论的回复信息
 	 */
-					
+	// 定义一个 String 类型的字段 reply，用于存储回复内容
 	private String reply;
-	
-	
+
+	/**
+	 * 评论添加时间
+	 * 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
+	 * 使用 DateTimeFormat 注解，默认接收日期格式
+	 */
 	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
+	// 定义一个 Date 类型的字段 addtime，用于存储评论的添加时间
 	private Date addtime;
 
+	/**
+	 * 获取评论添加时间
+	 * @return 评论添加时间
+	 */
+	// 定义 getAddtime 方法，用于获取 addtime 字段的值
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	/**
+	 * 设置评论添加时间
+	 * @param addtime 要设置的评论添加时间
+	 */
+	// 定义 setAddtime 方法，用于设置 addtime 字段的值
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	/**
+	 * 获取主键 id
+	 * @return 主键 id
+	 */
+	// 定义 getId 方法，用于获取 id 字段的值
 	public Long getId() {
 		return id;
 	}
 
+	/**
+	 * 设置主键 id
+	 * @param id 要设置的主键 id
+	 */
+	// 定义 setId 方法，用于设置 id 字段的值
 	public void setId(Long id) {
 		this.id = id;
 	}
+
 	/**
-	 * 设置：关联表id
+	 * 设置关联表 id
+	 * @param refid 要设置的关联表 id
 	 */
+	// 定义 setRefid 方法，用于设置 refid 字段的值
 	public void setRefid(Long refid) {
 		this.refid = refid;
 	}
+
 	/**
-	 * 获取：关联表id
+	 * 获取关联表 id
+	 * @return 关联表 id
 	 */
+	// 定义 getRefid 方法，用于获取 refid 字段的值
 	public Long getRefid() {
 		return refid;
 	}
+
 	/**
-	 * 设置：用户id
+	 * 设置用户 id
+	 * @param userid 要设置的用户 id
 	 */
+	// 定义 setUserid 方法，用于设置 userid 字段的值
 	public void setUserid(Long userid) {
 		this.userid = userid;
 	}
+
 	/**
-	 * 获取：用户id
+	 * 获取用户 id
+	 * @return 用户 id
 	 */
+	// 定义 getUserid 方法，用于获取 userid 字段的值
 	public Long getUserid() {
 		return userid;
 	}
+
 	/**
-	 * 设置：用户名
+	 * 设置用户名
+	 * @param nickname 要设置的用户名
 	 */
+	// 定义 setNickname 方法，用于设置 nickname 字段的值
 	public void setNickname(String nickname) {
 		this.nickname = nickname;
 	}
+
 	/**
-	 * 获取：用户名
+	 * 获取用户名
+	 * @return 用户名
 	 */
+	// 定义 getNickname 方法，用于获取 nickname 字段的值
 	public String getNickname() {
 		return nickname;
 	}
+
 	/**
-	 * 设置：评论内容
+	 * 设置评论内容
+	 * @param content 要设置的评论内容
 	 */
+	// 定义 setContent 方法，用于设置 content 字段的值
 	public void setContent(String content) {
 		this.content = content;
 	}
+
 	/**
-	 * 获取：评论内容
+	 * 获取评论内容
+	 * @return 评论内容
 	 */
+	// 定义 getContent 方法，用于获取 content 字段的值
 	public String getContent() {
 		return content;
 	}
+
 	/**
-	 * 设置：回复内容
+	 * 设置回复内容
+	 * @param reply 要设置的回复内容
 	 */
+	// 定义 setReply 方法，用于设置 reply 字段的值
 	public void setReply(String reply) {
 		this.reply = reply;
 	}
+
 	/**
-	 * 获取：回复内容
+	 * 获取回复内容
+	 * @return 回复内容
 	 */
+	// 定义 getReply 方法，用于获取 reply 字段的值
 	public String getReply() {
 		return reply;
 	}
-
-}
+}

back/src/main/java/com/entity/DiscussjiudiankefangEntity.java

@@ -1,164 +1,251 @@
+// 定义该类所属的包，一般来说，实体类会被放在这个包路径下，方便管理和维护
 package com.entity;
 
+// 引入 MyBatis-Plus 框架的 TableId 注解，用于标记实体类中的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 引入 MyBatis-Plus 框架的 TableName 注解，用于指定实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 引入 JSR-303 验证注解，NotBlank 用于确保字符串字段不为 null 且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 引入 JSR-303 验证注解，NotEmpty 用于确保集合、数组、字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 引入 JSR-303 验证注解，NotNull 用于确保对象字段不为 null
 import javax.validation.constraints.NotNull;
-
+// 引入 Jackson 库的 JsonIgnoreProperties 注解，可在序列化和反序列化时忽略某些属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 引入反射调用时可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 引入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作，便于在网络传输或存储
 import java.io.Serializable;
+// 引入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
+// 引入 List 接口，用于表示一组对象的集合
 import java.util.List;
-
+// 引入 Spring 框架的 DateTimeFormat 注解，用于指定日期字段在接收参数时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 引入 Jackson 库的 JsonFormat 注解，用于指定日期字段在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 引入 Apache Commons BeanUtils 工具类，可用于复制 JavaBean 的属性
 import org.apache.commons.beanutils.BeanUtils;
+// 引入 MyBatis-Plus 框架的 TableField 注解，可用于指定字段在数据库表中的一些属性
 import com.baomidou.mybatisplus.annotations.TableField;
+// 引入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 引入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
 /**
  * 酒店客房评论表
  * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:05
  */
+// 使用 TableName 注解指定该实体类对应数据库中的 "discussjiudiankefang" 表
 @TableName("discussjiudiankefang")
+// 定义酒店客房评论表的实体类，使用泛型 T，实现 Serializable 接口
 public class DiscussjiudiankefangEntity<T> implements Serializable {
+	// 定义序列化版本号，保证在序列化和反序列化过程中，类的版本一致
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，当创建该类的对象且不传入参数时会调用此构造函数
 	public DiscussjiudiankefangEntity() {
-		
+		// 目前构造函数体为空，没有额外的初始化操作
 	}
-	
+
+	/**
+	 * 带参数的构造函数，用于将泛型对象 t 的属性复制到当前对象
+	 * @param t 要复制属性的泛型对象
+	 */
 	public DiscussjiudiankefangEntity(T t) {
 		try {
+			// 调用 BeanUtils 的 copyProperties 方法，将 t 对象的属性复制到当前对象
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 如果在属性复制过程中出现非法访问异常或者反射调用目标方法异常，进入此 catch 块
+			// 这里只是简单打印异常堆栈信息，开发者可根据实际情况完善异常处理逻辑
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
-	
+
 	/**
 	 * 主键id
+	 * 用于唯一标识数据库表中的每一条记录
 	 */
+	// 使用 TableId 注解标记该字段为主键
 	@TableId
+	// 定义 Long 类型的主键字段
 	private Long id;
+
 	/**
 	 * 关联表id
+	 * 可能用于关联其他相关表的记录，如酒店客房信息表
 	 */
-					
+	// 定义 Long 类型的关联表 id 字段
 	private Long refid;
-	
+
 	/**
 	 * 用户id
+	 * 用于唯一标识发表评论的用户
 	 */
-					
+	// 定义 Long 类型的用户 id 字段
 	private Long userid;
-	
+
 	/**
 	 * 用户名
+	 * 显示在评论中的用户昵称
 	 */
-					
+	// 定义 String 类型的用户名字段
 	private String nickname;
-	
+
 	/**
 	 * 评论内容
+	 * 用户针对酒店客房发表的具体评论信息
 	 */
-					
+	// 定义 String 类型的评论内容字段
 	private String content;
-	
+
 	/**
 	 * 回复内容
+	 * 针对用户评论的回复信息
 	 */
-					
+	// 定义 String 类型的回复内容字段
 	private String reply;
-	
-	
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+
+	/**
+	 * 评论添加时间
+	 * 使用 JsonFormat 注解指定日期序列化时的格式和时区
+	 * 使用 DateTimeFormat 注解指定日期接收时的格式
+	 */
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
+	// 定义 Date 类型的评论添加时间字段
 	private Date addtime;
 
+	/**
+	 * 获取评论添加时间
+	 * @return 评论添加时间
+	 */
+	// 定义获取评论添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	/**
+	 * 设置评论添加时间
+	 * @param addtime 要设置的评论添加时间
+	 */
+	// 定义设置评论添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	/**
+	 * 获取主键id
+	 * @return 主键id
+	 */
+	// 定义获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	/**
+	 * 设置主键id
+	 * @param id 要设置的主键id
+	 */
+	// 定义设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
+
 	/**
-	 * 设置：关联表id
+	 * 设置关联表id
+	 * @param refid 要设置的关联表id
 	 */
+	// 定义设置关联表 id 的方法
 	public void setRefid(Long refid) {
 		this.refid = refid;
 	}
+
 	/**
-	 * 获取：关联表id
+	 * 获取关联表id
+	 * @return 关联表id
 	 */
+	// 定义获取关联表 id 的方法
 	public Long getRefid() {
 		return refid;
 	}
+
 	/**
-	 * 设置：用户id
+	 * 设置用户id
+	 * @param userid 要设置的用户id
 	 */
+	// 定义设置用户 id 的方法
 	public void setUserid(Long userid) {
 		this.userid = userid;
 	}
+
 	/**
-	 * 获取：用户id
+	 * 获取用户id
+	 * @return 用户id
 	 */
+	// 定义获取用户 id 的方法
 	public Long getUserid() {
 		return userid;
 	}
+
 	/**
-	 * 设置：用户名
+	 * 设置用户名
+	 * @param nickname 要设置的用户名
 	 */
+	// 定义设置用户名的方法
 	public void setNickname(String nickname) {
 		this.nickname = nickname;
 	}
+
 	/**
-	 * 获取：用户名
+	 * 获取用户名
+	 * @return 用户名
 	 */
+	// 定义获取用户名的方法
 	public String getNickname() {
 		return nickname;
 	}
+
 	/**
-	 * 设置：评论内容
+	 * 设置评论内容
+	 * @param content 要设置的评论内容
 	 */
+	// 定义设置评论内容的方法
 	public void setContent(String content) {
 		this.content = content;
 	}
+
 	/**
-	 * 获取：评论内容
+	 * 获取评论内容
+	 * @return 评论内容
 	 */
+	// 定义获取评论内容的方法
 	public String getContent() {
 		return content;
 	}
+
 	/**
-	 * 设置：回复内容
+	 * 设置回复内容
+	 * @param reply 要设置的回复内容
 	 */
+	// 定义设置回复内容的方法
 	public void setReply(String reply) {
 		this.reply = reply;
 	}
+
 	/**
-	 * 获取：回复内容
+	 * 获取回复内容
+	 * @return 回复内容
 	 */
+	// 定义获取回复内容的方法
 	public String getReply() {
 		return reply;
 	}
-
-}
+}

back/src/main/java/com/entity/EIException.java

@@ -1,52 +1,73 @@
-
+// 声明该类所属的包为 com.entity
 package com.entity;
 
-/**
- * 自定义异常
- */
+// 自定义异常
+// 该类继承自 RuntimeException，表示这是一个运行时异常类。
+// 通常运行时异常是在程序运行过程中由于逻辑错误等原因导致的异常，不需要强制捕获处理。
 public class EIException extends RuntimeException {
+	// 定义序列化版本号，用于在序列化和反序列化过程中确保类的版本一致性。
+	// 当类的结构发生变化时，应该修改这个版本号，以避免反序列化错误。
 	private static final long serialVersionUID = 1L;
-	
-    private String msg;
-    private int code = 500;
-    
-    public EIException(String msg) {
+
+	// 用于存储异常的详细信息描述，比如错误提示消息。
+	private String msg;
+	// 用于存储异常的错误码，这里默认值为 500，通常 500 表示服务器内部错误。
+	private int code = 500;
+
+	// 构造函数，接受一个字符串类型的错误消息参数。
+	// 调用父类（RuntimeException）的构造函数，将错误消息传递给父类，
+	// 同时将错误消息赋值给当前类的 msg 字段。
+	public EIException(String msg) {
 		super(msg);
 		this.msg = msg;
 	}
-	
+
+	// 构造函数，接受一个字符串类型的错误消息参数和一个 Throwable 类型的异常对象参数。
+	// 调用父类（RuntimeException）的构造函数，将错误消息和异常对象传递给父类，
+	// 同时将错误消息赋值给当前类的 msg 字段。
+	// 这个构造函数通常用于在抛出异常时，将原始的异常信息一起传递下去。
 	public EIException(String msg, Throwable e) {
 		super(msg, e);
 		this.msg = msg;
 	}
-	
+
+	// 构造函数，接受一个字符串类型的错误消息参数和一个整数类型的错误码参数。
+	// 调用父类（RuntimeException）的构造函数，将错误消息传递给父类，
+	// 同时将错误消息赋值给当前类的 msg 字段，将错误码赋值给当前类的 code 字段。
+	// 这个构造函数可以用于自定义特定的错误码。
 	public EIException(String msg, int code) {
 		super(msg);
 		this.msg = msg;
 		this.code = code;
 	}
-	
+
+	// 构造函数，接受一个字符串类型的错误消息参数、一个整数类型的错误码参数和一个 Throwable 类型的异常对象参数。
+	// 调用父类（RuntimeException）的构造函数，将错误消息和异常对象传递给父类，
+	// 同时将错误消息赋值给当前类的 msg 字段，将错误码赋值给当前类的 code 字段。
+	// 这个构造函数综合了前面几个构造函数的功能，既可以传递错误消息和异常对象，又可以自定义错误码。
 	public EIException(String msg, int code, Throwable e) {
 		super(msg, e);
 		this.msg = msg;
 		this.code = code;
 	}
 
+	// 获取异常的错误消息。
 	public String getMsg() {
 		return msg;
 	}
 
+	// 设置异常的错误消息。
 	public void setMsg(String msg) {
 		this.msg = msg;
 	}
 
+	// 获取异常的错误码。
 	public int getCode() {
 		return code;
 	}
 
+	// 设置异常的错误码。
 	public void setCode(int code) {
 		this.code = code;
 	}
-	
-	
-}
+}

back/src/main/java/com/entity/JiudianjianjieEntity.java

@@ -1,200 +1,183 @@
+// 声明该类所在的包名为 com.entity，通常用于存放实体类相关代码
 package com.entity;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于标识数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 JSR-303 验证框架中的 NotBlank 注解，用于确保字符串字段不为空且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 导入 JSR-303 验证框架中的 NotEmpty 注解，用于确保集合、数组或字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 导入 JSR-303 验证框架中的 NotNull 注解，用于确保对象字段不为空
 import javax.validation.constraints.NotNull;
-
+// 导入 Jackson 库的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略指定属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射操作中可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
+// 导入 List 接口，用于表示一组对象的集合
 import java.util.List;
-
+// 导入 Spring 框架的 DateTimeFormat 注解，用于指定日期在接收参数时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 库的 JsonFormat 注解，用于指定日期在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于复制 JavaBean 的属性
 import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 框架的 TableField 注解，用于设置字段在数据库表中的相关属性
 import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
-/**
- * 酒店简介
- * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
- * @date 2022-04-04 00:20:04
- */
+// 该类表示酒店简介的数据库实体类，用于普通的增删改查操作
+// 作者信息暂未填写
+// 邮箱信息暂未填写
+// 创建日期为 2022-04-04 00:20:04
 @TableName("jiudianjianjie")
 public class JiudianjianjieEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中保持类的版本一致性
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，用于创建 JiudianjianjieEntity 对象时不传入任何参数
 	public JiudianjianjieEntity() {
-		
 	}
-	
+
+	// 带参数的构造函数，通过传入的泛型对象 t 复制属性到当前对象
 	public JiudianjianjieEntity(T t) {
 		try {
+			// 使用 BeanUtils 的 copyProperties 方法将 t 对象的属性复制到当前对象
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
+			// 如果在复制属性过程中出现非法访问异常或反射调用目标异常
+			// 简单打印异常堆栈信息，后续可根据实际情况完善异常处理逻辑
 			e.printStackTrace();
 		}
 	}
-	
-	/**
-	 * 主键id
-	 */
+
+	// 使用 TableId 注解标识该字段为主键
+	// 主键 id，用于唯一标识数据库表中的每条记录
 	@TableId
 	private Long id;
-	/**
-	 * 酒店名称
-	 */
-					
+
+	// 酒店名称字段，用于存储酒店的名称
 	private String jiudianmingcheng;
-	
-	/**
-	 * 类别
-	 */
-					
+
+	// 酒店类别字段，用于存储酒店所属的类别信息
 	private String leibie;
-	
-	/**
-	 * 星级
-	 */
-					
+
+	// 酒店星级字段，用于存储酒店的星级标识
 	private String xingji;
-	
-	/**
-	 * 酒店图片
-	 */
-					
+
+	// 酒店图片字段，用于存储酒店相关图片的信息（如图片路径等）
 	private String jiudiantupian;
-	
-	/**
-	 * 酒店地址
-	 */
-					
+
+	// 酒店地址字段，用于存储酒店的具体地址信息
 	private String jiudiandizhi;
-	
-	/**
-	 * 服务热线
-	 */
-					
+
+	// 服务热线字段，用于存储酒店的服务热线电话号码
 	private String fuwurexian;
-	
-	/**
-	 * 酒店介绍
-	 */
-					
+
+	// 酒店介绍字段，用于存储对酒店的详细介绍内容
 	private String jiudianjieshao;
-	
-	
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
 	private Date addtime;
 
+	// 获取记录添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	// 设置记录添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
-	/**
-	 * 设置：酒店名称
-	 */
+
+	// 设置酒店名称的方法
 	public void setJiudianmingcheng(String jiudianmingcheng) {
 		this.jiudianmingcheng = jiudianmingcheng;
 	}
-	/**
-	 * 获取：酒店名称
-	 */
+
+	// 获取酒店名称的方法
 	public String getJiudianmingcheng() {
 		return jiudianmingcheng;
 	}
-	/**
-	 * 设置：类别
-	 */
+
+	// 设置酒店类别的方法
 	public void setLeibie(String leibie) {
 		this.leibie = leibie;
 	}
-	/**
-	 * 获取：类别
-	 */
+
+	// 获取酒店类别的方法
 	public String getLeibie() {
 		return leibie;
 	}
-	/**
-	 * 设置：星级
-	 */
+
+	// 设置酒店星级的方法
 	public void setXingji(String xingji) {
 		this.xingji = xingji;
 	}
-	/**
-	 * 获取：星级
-	 */
+
+	// 获取酒店星级的方法
 	public String getXingji() {
 		return xingji;
 	}
-	/**
-	 * 设置：酒店图片
-	 */
+
+	// 设置酒店图片的方法
 	public void setJiudiantupian(String jiudiantupian) {
 		this.jiudiantupian = jiudiantupian;
 	}
-	/**
-	 * 获取：酒店图片
-	 */
+
+	// 获取酒店图片的方法
 	public String getJiudiantupian() {
 		return jiudiantupian;
 	}
-	/**
-	 * 设置：酒店地址
-	 */
+
+	// 设置酒店地址的方法
 	public void setJiudiandizhi(String jiudiandizhi) {
 		this.jiudiandizhi = jiudiandizhi;
 	}
-	/**
-	 * 获取：酒店地址
-	 */
+
+	// 获取酒店地址的方法
 	public String getJiudiandizhi() {
 		return jiudiandizhi;
 	}
-	/**
-	 * 设置：服务热线
-	 */
+
+	// 设置服务热线的方法
 	public void setFuwurexian(String fuwurexian) {
 		this.fuwurexian = fuwurexian;
 	}
-	/**
-	 * 获取：服务热线
-	 */
+
+	// 获取服务热线的方法
 	public String getFuwurexian() {
 		return fuwurexian;
 	}
-	/**
-	 * 设置：酒店介绍
-	 */
+
+	// 设置酒店介绍的方法
 	public void setJiudianjieshao(String jiudianjieshao) {
 		this.jiudianjieshao = jiudianjieshao;
 	}
-	/**
-	 * 获取：酒店介绍
-	 */
+
+	// 获取酒店介绍的方法
 	public String getJiudianjieshao() {
 		return jiudianjieshao;
 	}
-
-}
+}

back/src/main/java/com/entity/JiudiankefangEntity.java

@@ -1,254 +1,223 @@
+// 声明该类所属的包名为 com.entity，通常用于存放与数据库实体相关的类
 package com.entity;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于指定数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定该实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 JSR-303 验证注解，NotBlank 用于验证字符串不为 null 且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 导入 JSR-303 验证注解，NotEmpty 用于验证集合、数组、字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 导入 JSR-303 验证注解，NotNull 用于验证对象不为 null
 import javax.validation.constraints.NotNull;
-
+// 导入 Jackson 库的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略某些属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射调用时可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可以被序列化和反序列化
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间
 import java.util.Date;
+// 导入 List 接口，用于表示一组对象
 import java.util.List;
-
+// 导入 Spring 框架的 DateTimeFormat 注解，用于指定日期在接收时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 库的 JsonFormat 注解，用于指定日期在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于进行 JavaBean 属性的复制操作
 import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 框架的 TableField 注解，用于指定字段在数据库表中的一些属性
 import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
-/**
- * 酒店客房
- * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
- * @date 2022-04-04 00:20:04
- */
+// 该类表示酒店客房的数据库通用操作实体类，可进行普通的增删改查操作
+// @author 作者信息未填写
+// @email 邮箱信息未填写
+// @date 2022-04-04 00:20:04
 @TableName("jiudiankefang")
 public class JiudiankefangEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中确保类的版本一致性
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，用于创建 JiudiankefangEntity 对象时不传入任何参数
 	public JiudiankefangEntity() {
-		
 	}
-	
+
+	// 带参数的构造函数，通过传入的泛型对象 t 来复制属性到当前对象
 	public JiudiankefangEntity(T t) {
 		try {
+			// 调用 BeanUtils 的 copyProperties 方法，将 t 对象的属性复制到当前对象（this）中
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 如果在复制属性过程中出现非法访问异常或反射调用目标异常
+			// 此处仅简单打印异常堆栈信息，后续可根据实际情况完善异常处理逻辑
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
-	
-	/**
-	 * 主键id
-	 */
+
+	// 使用 TableId 注解指定该字段为主键
+	// 主键 id，用于唯一标识数据库表中的每一条记录
 	@TableId
 	private Long id;
-	/**
-	 * 客房名称
-	 */
-					
+
+	// 客房名称字段，用于存储客房的名称
 	private String kefangmingcheng;
-	
-	/**
-	 * 客房类型
-	 */
-					
+
+	// 客房类型字段，用于存储客房的类型信息
 	private String kefangleixing;
-	
-	/**
-	 * 客房图片
-	 */
-					
+
+	// 客房图片字段，用于存储客房相关图片的信息（如图片路径等）
 	private String kefangtupian;
-	
-	/**
-	 * 客房价格
-	 */
-					
+
+	// 客房价格字段，用于存储客房的价格，类型为 Float
 	private Float kefangjiage;
-	
-	/**
-	 * 数量
-	 */
-					
+
+	// 数量字段，用于存储客房的数量，类型为 Integer
 	private Integer shuliang;
-	
-	/**
-	 * 酒店名称
-	 */
-					
+
+	// 酒店名称字段，用于存储客房所属酒店的名称
 	private String jiudianmingcheng;
-	
-	/**
-	 * 酒店地址
-	 */
-					
+
+	// 酒店地址字段，用于存储客房所属酒店的地址
 	private String jiudiandizhi;
-	
-	/**
-	 * 客房设施
-	 */
-					
+
+	// 客房设施字段，用于存储客房所配备的设施信息
 	private String kefangsheshi;
-	
-	/**
-	 * 客房介绍
-	 */
-					
+
+	// 客房介绍字段，用于存储对客房的详细介绍内容
 	private String kefangjieshao;
-	
-	/**
-	 * 点击次数
-	 */
-					
+
+	// 点击次数字段，用于记录该客房被点击的次数，类型为 Integer
 	private Integer clicknum;
-	
-	
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于在处理日期相关数据时指定接收格式
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
 	private Date addtime;
 
+	// 获取记录添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	// 设置记录添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
-	/**
-	 * 设置：客房名称
-	 */
+
+	// 设置客房名称的方法
 	public void setKefangmingcheng(String kefangmingcheng) {
 		this.kefangmingcheng = kefangmingcheng;
 	}
-	/**
-	 * 获取：客房名称
-	 */
+
+	// 获取客房名称的方法
 	public String getKefangmingcheng() {
 		return kefangmingcheng;
 	}
-	/**
-	 * 设置：客房类型
-	 */
+
+	// 设置客房类型的方法
 	public void setKefangleixing(String kefangleixing) {
 		this.kefangleixing = kefangleixing;
 	}
-	/**
-	 * 获取：客房类型
-	 */
+
+	// 获取客房类型的方法
 	public String getKefangleixing() {
 		return kefangleixing;
 	}
-	/**
-	 * 设置：客房图片
-	 */
+
+	// 设置客房图片的方法
 	public void setKefangtupian(String kefangtupian) {
 		this.kefangtupian = kefangtupian;
 	}
-	/**
-	 * 获取：客房图片
-	 */
+
+	// 获取客房图片的方法
 	public String getKefangtupian() {
 		return kefangtupian;
 	}
-	/**
-	 * 设置：客房价格
-	 */
+
+	// 设置客房价格的方法
 	public void setKefangjiage(Float kefangjiage) {
 		this.kefangjiage = kefangjiage;
 	}
-	/**
-	 * 获取：客房价格
-	 */
+
+	// 获取客房价格的方法
 	public Float getKefangjiage() {
 		return kefangjiage;
 	}
-	/**
-	 * 设置：数量
-	 */
+
+	// 设置数量的方法
 	public void setShuliang(Integer shuliang) {
 		this.shuliang = shuliang;
 	}
-	/**
-	 * 获取：数量
-	 */
+
+	// 获取数量的方法
 	public Integer getShuliang() {
 		return shuliang;
 	}
-	/**
-	 * 设置：酒店名称
-	 */
+
+	// 设置酒店名称的方法
 	public void setJiudianmingcheng(String jiudianmingcheng) {
 		this.jiudianmingcheng = jiudianmingcheng;
 	}
-	/**
-	 * 获取：酒店名称
-	 */
+
+	// 获取酒店名称的方法
 	public String getJiudianmingcheng() {
 		return jiudianmingcheng;
 	}
-	/**
-	 * 设置：酒店地址
-	 */
+
+	// 设置酒店地址的方法
 	public void setJiudiandizhi(String jiudiandizhi) {
 		this.jiudiandizhi = jiudiandizhi;
 	}
-	/**
-	 * 获取：酒店地址
-	 */
+
+	// 获取酒店地址的方法
 	public String getJiudiandizhi() {
 		return jiudiandizhi;
 	}
-	/**
-	 * 设置：客房设施
-	 */
+
+	// 设置客房设施的方法
 	public void setKefangsheshi(String kefangsheshi) {
 		this.kefangsheshi = kefangsheshi;
 	}
-	/**
-	 * 获取：客房设施
-	 */
+
+	// 获取客房设施的方法
 	public String getKefangsheshi() {
 		return kefangsheshi;
 	}
-	/**
-	 * 设置：客房介绍
-	 */
+
+	// 设置客房介绍的方法
 	public void setKefangjieshao(String kefangjieshao) {
 		this.kefangjieshao = kefangjieshao;
 	}
-	/**
-	 * 获取：客房介绍
-	 */
+
+	// 获取客房介绍的方法
 	public String getKefangjieshao() {
 		return kefangjieshao;
 	}
-	/**
-	 * 设置：点击次数
-	 */
+
+	// 设置点击次数的方法
 	public void setClicknum(Integer clicknum) {
 		this.clicknum = clicknum;
 	}
-	/**
-	 * 获取：点击次数
-	 */
+
+	// 获取点击次数的方法
 	public Integer getClicknum() {
 		return clicknum;
 	}
-
-}
+}

back/src/main/java/com/entity/KefangleixingEntity.java

@@ -1,92 +1,110 @@
+// 声明该类所属的包为 com.entity，一般用于存放实体类相关代码
 package com.entity;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于标识数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 JSR-303 验证框架中的 NotBlank 注解，用于确保字符串字段不为空且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 导入 JSR-303 验证框架中的 NotEmpty 注解，用于确保集合、数组或字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 导入 JSR-303 验证框架中的 NotNull 注解，用于确保对象字段不为空
 import javax.validation.constraints.NotNull;
-
+// 导入 Jackson 库的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略指定属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射操作中可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
+// 导入 List 接口，用于表示一组对象的集合（虽然此处未实际使用，但导入了该包）
 import java.util.List;
-
+// 导入 Spring 框架的 DateTimeFormat 注解，用于指定日期在接收参数时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 库的 JsonFormat 注解，用于指定日期在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于复制 JavaBean 的属性
 import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 框架的 TableField 注解，用于设置字段在数据库表中的相关属性（虽然此处未实际使用，但导入了该包）
 import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略（虽然此处未实际使用，但导入了该包）
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
 /**
  * 客房类型
  * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
+ * @author 作者信息未填写
+ * @email 邮箱信息未填写
  * @date 2022-04-04 00:20:04
  */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "kefangleixing"
 @TableName("kefangleixing")
+// 定义 KefangleixingEntity 类，使用泛型 T，实现 Serializable 接口
 public class KefangleixingEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中保持类的版本一致性
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，用于创建 KefangleixingEntity 对象时不传入任何参数
 	public KefangleixingEntity() {
-		
 	}
-	
+
+	// 带参数的构造函数，通过传入的泛型对象 t 复制属性到当前对象
 	public KefangleixingEntity(T t) {
 		try {
+			// 使用 BeanUtils 的 copyProperties 方法将 t 对象的属性复制到当前对象
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
+			// 如果在复制属性过程中出现非法访问异常或反射调用目标异常
+			// 简单打印异常堆栈信息，后续可根据实际情况完善异常处理逻辑
 			e.printStackTrace();
 		}
 	}
-	
-	/**
-	 * 主键id
-	 */
+
+	// 使用 TableId 注解标识该字段为主键
+	// 主键 id，用于唯一标识数据库表中的每条记录
 	@TableId
 	private Long id;
-	/**
-	 * 客房类型
-	 */
-					
+
+	// 客房类型字段，用于存储客房的类型信息
 	private String kefangleixing;
-	
-	
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
 	private Date addtime;
 
+	// 获取记录添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	// 设置记录添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
-	/**
-	 * 设置：客房类型
-	 */
+
+	// 设置客房类型的方法
 	public void setKefangleixing(String kefangleixing) {
 		this.kefangleixing = kefangleixing;
 	}
-	/**
-	 * 获取：客房类型
-	 */
+
+	// 获取客房类型的方法
 	public String getKefangleixing() {
 		return kefangleixing;
 	}
-
-}
+}

back/src/main/java/com/entity/KefangyudingEntity.java

@@ -1,328 +1,282 @@
+// 声明该类所属的包名为 com.entity，一般用于存放实体类相关的代码
 package com.entity;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于标识数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 JSR-303 验证框架中的 NotBlank 注解，用于确保字符串字段不为空且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 导入 JSR-303 验证框架中的 NotEmpty 注解，用于确保集合、数组或字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 导入 JSR-303 验证框架中的 NotNull 注解，用于确保对象字段不为空
 import javax.validation.constraints.NotNull;
-
+// 导入 Jackson 库的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略指定属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射操作中可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
+// 导入 List 接口，用于表示一组对象的集合（虽然在当前代码中未实际使用该接口相关功能，但导入了对应的包）
 import java.util.List;
-
+// 导入 Spring 框架的 DateTimeFormat 注解，用于指定日期在接收参数时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 库的 JsonFormat 注解，用于指定日期在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于复制 JavaBean 的属性
 import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 框架的 TableField 注解，用于设置字段在数据库表中的相关属性（当前代码未实际使用该注解，但导入了对应的包）
 import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略（当前代码未实际使用该枚举，但导入了对应的包）
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
 /**
  * 客房预定
  * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
+ * @author 作者信息未填写
+ * @email 邮箱信息未填写
  * @date 2022-04-04 00:20:04
  */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "kefangyuding"
 @TableName("kefangyuding")
+// 定义 KefangyudingEntity 类，使用泛型 T，实现 Serializable 接口
 public class KefangyudingEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中保持类的版本一致性
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，用于创建 KefangyudingEntity 对象时不传入任何参数
 	public KefangyudingEntity() {
-		
 	}
-	
+
+	// 带参数的构造函数，通过传入的泛型对象 t 复制属性到当前对象
 	public KefangyudingEntity(T t) {
 		try {
+			// 使用 BeanUtils 的 copyProperties 方法将 t 对象的属性复制到当前对象
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
+			// 如果在复制属性过程中出现非法访问异常或反射调用目标异常
+			// 简单打印异常堆栈信息，后续可根据实际情况完善异常处理逻辑
 			e.printStackTrace();
 		}
 	}
-	
-	/**
-	 * 主键id
-	 */
+
+	// 使用 TableId 注解标识该字段为主键
+	// 主键 id，用于唯一标识数据库表中的每条记录
 	@TableId
 	private Long id;
-	/**
-	 * 预定编号
-	 */
-					
+
+	// 预定编号字段，用于存储客房预定的编号信息
 	private String yudingbianhao;
-	
-	/**
-	 * 客房名称
-	 */
-					
+
+	// 客房名称字段，用于存储所预定客房的名称
 	private String kefangmingcheng;
-	
-	/**
-	 * 客房类型
-	 */
-					
+
+	// 客房类型字段，用于存储所预定客房的类型
 	private String kefangleixing;
-	
-	/**
-	 * 客房价格
-	 */
-					
+
+	// 客房价格字段，用于存储所预定客房的价格，数据类型为 Float
 	private Float kefangjiage;
-	
-	/**
-	 * 数量
-	 */
-					
+
+	// 数量字段，用于存储预定客房的数量，数据类型为 Integer
 	private Integer shuliang;
-	
-	/**
-	 * 总金额
-	 */
-					
+
+	// 总金额字段，用于存储预定客房的总金额，数据类型为 Float
 	private Float zongjine;
-	
-	/**
-	 * 客房图片
-	 */
-					
+
+	// 客房图片字段，用于存储所预定客房相关图片的信息（如图片路径等）
 	private String kefangtupian;
-	
-	/**
-	 * 酒店名称
-	 */
-					
+
+	// 酒店名称字段，用于存储所预定客房所属酒店的名称
 	private String jiudianmingcheng;
-	
-	/**
-	 * 酒店地址
-	 */
-					
+
+	// 酒店地址字段，用于存储所预定客房所属酒店的地址
 	private String jiudiandizhi;
-	
-	/**
-	 * 用户名
-	 */
-					
+
+	// 用户名字段，用于存储进行客房预定的用户的用户名
 	private String yonghuming;
-	
-	/**
-	 * 姓名
-	 */
-					
+
+	// 姓名字段，用于存储进行客房预定的用户的姓名
 	private String xingming;
-	
-	/**
-	 * 手机号
-	 */
-					
+
+	// 手机号字段，用于存储进行客房预定的用户的手机号码
 	private String shoujihao;
-	
-	/**
-	 * 预定日期
-	 */
-				
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
-	@DateTimeFormat 		
+
+	// 预定日期字段，使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd")
+	@DateTimeFormat
 	private Date yudingriqi;
-	
-	/**
-	 * 是否支付
-	 */
-					
+
+	// 是否支付字段，用于标识该客房预定是否已经支付，数据类型为 String
 	private String ispay;
-	
-	
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+
+	// 记录添加时间字段，使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
 	private Date addtime;
 
+	// 获取记录添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	// 设置记录添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
-	/**
-	 * 设置：预定编号
-	 */
+
+	// 设置预定编号的方法
 	public void setYudingbianhao(String yudingbianhao) {
 		this.yudingbianhao = yudingbianhao;
 	}
-	/**
-	 * 获取：预定编号
-	 */
+
+	// 获取预定编号的方法
 	public String getYudingbianhao() {
 		return yudingbianhao;
 	}
-	/**
-	 * 设置：客房名称
-	 */
+
+	// 设置客房名称的方法
 	public void setKefangmingcheng(String kefangmingcheng) {
 		this.kefangmingcheng = kefangmingcheng;
 	}
-	/**
-	 * 获取：客房名称
-	 */
+
+	// 获取客房名称的方法
 	public String getKefangmingcheng() {
 		return kefangmingcheng;
 	}
-	/**
-	 * 设置：客房类型
-	 */
+
+	// 设置客房类型的方法
 	public void setKefangleixing(String kefangleixing) {
 		this.kefangleixing = kefangleixing;
 	}
-	/**
-	 * 获取：客房类型
-	 */
+
+	// 获取客房类型的方法
 	public String getKefangleixing() {
 		return kefangleixing;
 	}
-	/**
-	 * 设置：客房价格
-	 */
+
+	// 设置客房价格的方法
 	public void setKefangjiage(Float kefangjiage) {
 		this.kefangjiage = kefangjiage;
 	}
-	/**
-	 * 获取：客房价格
-	 */
+
+	// 获取客房价格的方法
 	public Float getKefangjiage() {
 		return kefangjiage;
 	}
-	/**
-	 * 设置：数量
-	 */
+
+	// 设置数量的方法
 	public void setShuliang(Integer shuliang) {
 		this.shuliang = shuliang;
 	}
-	/**
-	 * 获取：数量
-	 */
+
+	// 获取数量的方法
 	public Integer getShuliang() {
 		return shuliang;
 	}
-	/**
-	 * 设置：总金额
-	 */
+
+	// 设置总金额的方法
 	public void setZongjine(Float zongjine) {
 		this.zongjine = zongjine;
 	}
-	/**
-	 * 获取：总金额
-	 */
+
+	// 获取总金额的方法
 	public Float getZongjine() {
 		return zongjine;
 	}
-	/**
-	 * 设置：客房图片
-	 */
+
+	// 设置客房图片的方法
 	public void setKefangtupian(String kefangtupian) {
 		this.kefangtupian = kefangtupian;
 	}
-	/**
-	 * 获取：客房图片
-	 */
+
+	// 获取客房图片的方法
 	public String getKefangtupian() {
 		return kefangtupian;
 	}
-	/**
-	 * 设置：酒店名称
-	 */
+
+	// 设置酒店名称的方法
 	public void setJiudianmingcheng(String jiudianmingcheng) {
 		this.jiudianmingcheng = jiudianmingcheng;
 	}
-	/**
-	 * 获取：酒店名称
-	 */
+
+	// 获取酒店名称的方法
 	public String getJiudianmingcheng() {
 		return jiudianmingcheng;
 	}
-	/**
-	 * 设置：酒店地址
-	 */
+
+	// 设置酒店地址的方法
 	public void setJiudiandizhi(String jiudiandizhi) {
 		this.jiudiandizhi = jiudiandizhi;
 	}
-	/**
-	 * 获取：酒店地址
-	 */
+
+	// 获取酒店地址的方法
 	public String getJiudiandizhi() {
 		return jiudiandizhi;
 	}
-	/**
-	 * 设置：用户名
-	 */
+
+	// 设置用户名的方法
 	public void setYonghuming(String yonghuming) {
 		this.yonghuming = yonghuming;
 	}
-	/**
-	 * 获取：用户名
-	 */
+
+	// 获取用户名的方法
 	public String getYonghuming() {
 		return yonghuming;
 	}
-	/**
-	 * 设置：姓名
-	 */
+
+	// 设置姓名的方法
 	public void setXingming(String xingming) {
 		this.xingming = xingming;
 	}
-	/**
-	 * 获取：姓名
-	 */
+
+	// 获取姓名的方法
 	public String getXingming() {
 		return xingming;
 	}
-	/**
-	 * 设置：手机号
-	 */
+
+	// 设置手机号的方法
 	public void setShoujihao(String shoujihao) {
 		this.shoujihao = shoujihao;
 	}
-	/**
-	 * 获取：手机号
-	 */
+
+	// 获取手机号的方法
 	public String getShoujihao() {
 		return shoujihao;
 	}
-	/**
-	 * 设置：预定日期
-	 */
+
+	// 设置预定日期的方法
 	public void setYudingriqi(Date yudingriqi) {
 		this.yudingriqi = yudingriqi;
 	}
-	/**
-	 * 获取：预定日期
-	 */
+
+	// 获取预定日期的方法
 	public Date getYudingriqi() {
 		return yudingriqi;
 	}
-	/**
-	 * 设置：是否支付
-	 */
+
+	// 设置是否支付的方法
 	public void setIspay(String ispay) {
 		this.ispay = ispay;
 	}
-	/**
-	 * 获取：是否支付
-	 */
+
+	// 获取是否支付的方法
 	public String getIspay() {
 		return ispay;
 	}
-
-}
+}

back/src/main/java/com/entity/NewsEntity.java

@@ -1,146 +1,149 @@
+// 声明该类所属的包名为 com.entity，一般用于存放与数据库操作相关的实体类
 package com.entity;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于标识数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 JSR-303 验证框架中的 NotBlank 注解，用于确保字符串字段不为空且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 导入 JSR-303 验证框架中的 NotEmpty 注解，用于确保集合、数组或字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 导入 JSR-303 验证框架中的 NotNull 注解，用于确保对象字段不为空
 import javax.validation.constraints.NotNull;
-
+// 导入 Jackson 库的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略指定属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射操作中可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
+// 导入 List 接口，用于表示一组对象的集合（虽然当前代码未使用该接口相关功能，但导入了对应的包）
 import java.util.List;
-
+// 导入 Spring 框架的 DateTimeFormat 注解，用于指定日期在接收参数时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 库的 JsonFormat 注解，用于指定日期在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于复制 JavaBean 的属性
 import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 框架的 TableField 注解，用于设置字段在数据库表中的相关属性（当前代码未使用该注解，但导入了对应的包）
 import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略（当前代码未使用该枚举，但导入了对应的包）
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
 /**
  * 酒店公告
  * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
+ * @author 作者信息未填写
+ * @email 邮箱信息未填写
  * @date 2022-04-04 00:20:04
  */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "news"
 @TableName("news")
+// 定义 NewsEntity 类，使用泛型 T，实现 Serializable 接口
 public class NewsEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中保持类的版本一致性
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，用于创建 NewsEntity 对象时不传入任何参数
 	public NewsEntity() {
-		
 	}
-	
+
+	// 带参数的构造函数，通过传入的泛型对象 t 复制属性到当前对象
 	public NewsEntity(T t) {
 		try {
+			// 使用 BeanUtils 的 copyProperties 方法将 t 对象的属性复制到当前对象
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
+			// 如果在复制属性过程中出现非法访问异常或反射调用目标异常
+			// 简单打印异常堆栈信息，后续可根据实际情况完善异常处理逻辑
 			e.printStackTrace();
 		}
 	}
-	
-	/**
-	 * 主键id
-	 */
+
+	// 使用 TableId 注解标识该字段为主键
+	// 主键 id，用于唯一标识数据库表中的每条记录
 	@TableId
 	private Long id;
-	/**
-	 * 标题
-	 */
-					
+
+	// 标题字段，用于存储酒店公告的标题信息
 	private String title;
-	
-	/**
-	 * 简介
-	 */
-					
+
+	// 简介字段，用于存储酒店公告的简要介绍内容
 	private String introduction;
-	
-	/**
-	 * 图片
-	 */
-					
+
+	// 图片字段，用于存储酒店公告相关图片的信息（如图片路径等）
 	private String picture;
-	
-	/**
-	 * 内容
-	 */
-					
+
+	// 内容字段，用于存储酒店公告的具体内容
 	private String content;
-	
-	
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
 	private Date addtime;
 
+	// 获取记录添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	// 设置记录添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
-	/**
-	 * 设置：标题
-	 */
+
+	// 设置标题的方法
 	public void setTitle(String title) {
 		this.title = title;
 	}
-	/**
-	 * 获取：标题
-	 */
+
+	// 获取标题的方法
 	public String getTitle() {
 		return title;
 	}
-	/**
-	 * 设置：简介
-	 */
+
+	// 设置简介的方法
 	public void setIntroduction(String introduction) {
 		this.introduction = introduction;
 	}
-	/**
-	 * 获取：简介
-	 */
+
+	// 获取简介的方法
 	public String getIntroduction() {
 		return introduction;
 	}
-	/**
-	 * 设置：图片
-	 */
+
+	// 设置图片的方法
 	public void setPicture(String picture) {
 		this.picture = picture;
 	}
-	/**
-	 * 获取：图片
-	 */
+
+	// 获取图片的方法
 	public String getPicture() {
 		return picture;
 	}
-	/**
-	 * 设置：内容
-	 */
+
+	// 设置内容的方法
 	public void setContent(String content) {
 		this.content = content;
 	}
-	/**
-	 * 获取：内容
-	 */
+
+	// 获取内容的方法
 	public String getContent() {
 		return content;
 	}
-
-}
+}

back/src/main/java/com/entity/RuzhuanpaiEntity.java

@@ -1,272 +1,240 @@
+// 声明该类所属的包为 com.entity，通常用于存放数据库相关的实体类
 package com.entity;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于标识数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 JSR-303 验证框架中的 NotBlank 注解，用于确保字符串字段不为空且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 导入 JSR-303 验证框架中的 NotEmpty 注解，用于确保集合、数组或字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 导入 JSR-303 验证框架中的 NotNull 注解，用于确保对象字段不为空
 import javax.validation.constraints.NotNull;
-
+// 导入 Jackson 库的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略指定属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射操作中可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
+// 导入 List 接口，用于表示一组对象的集合（当前代码未实际使用该接口相关功能，但导入了对应的包）
 import java.util.List;
-
+// 导入 Spring 框架的 DateTimeFormat 注解，用于指定日期在接收参数时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 库的 JsonFormat 注解，用于指定日期在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于复制 JavaBean 的属性
 import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 框架的 TableField 注解，用于设置字段在数据库表中的相关属性（当前代码未实际使用该注解，但导入了对应的包）
 import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略（当前代码未实际使用该枚举，但导入了对应的包）
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
 /**
  * 入住安排
  * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
+ * @author 作者信息未填写
+ * @email 邮箱信息未填写
  * @date 2022-04-04 00:20:04
  */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "ruzhuanpai"
 @TableName("ruzhuanpai")
+// 定义 RuzhuanpaiEntity 类，使用泛型 T，实现 Serializable 接口
 public class RuzhuanpaiEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中保持类的版本一致性
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，用于创建 RuzhuanpaiEntity 对象时不传入任何参数
 	public RuzhuanpaiEntity() {
-		
 	}
-	
+
+	// 带参数的构造函数，通过传入的泛型对象 t 复制属性到当前对象
 	public RuzhuanpaiEntity(T t) {
 		try {
+			// 使用 BeanUtils 的 copyProperties 方法将 t 对象的属性复制到当前对象
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
+			// 如果在复制属性过程中出现非法访问异常或反射调用目标异常
+			// 简单打印异常堆栈信息，后续可根据实际情况完善异常处理逻辑
 			e.printStackTrace();
 		}
 	}
-	
-	/**
-	 * 主键id
-	 */
+
+	// 使用 TableId 注解标识该字段为主键
+	// 主键 id，用于唯一标识数据库表中的每条记录
 	@TableId
 	private Long id;
-	/**
-	 * 预定编号
-	 */
-					
+
+	// 预定编号字段，用于存储入住安排对应的预定编号
 	private String yudingbianhao;
-	
-	/**
-	 * 酒店名称
-	 */
-					
+
+	// 酒店名称字段，用于存储入住安排对应的酒店名称
 	private String jiudianmingcheng;
-	
-	/**
-	 * 房间类型
-	 */
-					
+
+	// 房间类型字段，用于存储入住的房间类型
 	private String fangjianleixing;
-	
-	/**
-	 * 数量
-	 */
-					
+
+	// 数量字段，用于存储入住房间的数量，数据类型为 Float
 	private Float shuliang;
-	
-	/**
-	 * 客房图片
-	 */
-					
+
+	// 客房图片字段，用于存储入住房间相关的图片信息（如图片路径等）
 	private String kefangtupian;
-	
-	/**
-	 * 用户名
-	 */
-					
+
+	// 用户名字段，用于存储入住安排对应的用户名
 	private String yonghuming;
-	
-	/**
-	 * 姓名
-	 */
-					
+
+	// 姓名字段，用于存储入住人的姓名
 	private String xingming;
-	
-	/**
-	 * 手机号
-	 */
-					
+
+	// 手机号字段，用于存储入住人或相关联系人的手机号码
 	private String shoujihao;
-	
-	/**
-	 * 房间号
-	 */
-					
+
+	// 房间号字段，用于存储入住的具体房间号
 	private String fangjianhao;
-	
-	/**
-	 * 跨表用户id
-	 */
-					
+
+	// 跨表用户 id 字段，用于关联其他表中的用户信息
 	private Long crossuserid;
-	
-	/**
-	 * 跨表主键id
-	 */
-					
+
+	// 跨表主键 id 字段，用于关联其他表中的主键信息
 	private Long crossrefid;
-	
-	
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
 	private Date addtime;
 
+	// 获取记录添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	// 设置记录添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
-	/**
-	 * 设置：预定编号
-	 */
+
+	// 设置预定编号的方法
 	public void setYudingbianhao(String yudingbianhao) {
 		this.yudingbianhao = yudingbianhao;
 	}
-	/**
-	 * 获取：预定编号
-	 */
+
+	// 获取预定编号的方法
 	public String getYudingbianhao() {
 		return yudingbianhao;
 	}
-	/**
-	 * 设置：酒店名称
-	 */
+
+	// 设置酒店名称的方法
 	public void setJiudianmingcheng(String jiudianmingcheng) {
 		this.jiudianmingcheng = jiudianmingcheng;
 	}
-	/**
-	 * 获取：酒店名称
-	 */
+
+	// 获取酒店名称的方法
 	public String getJiudianmingcheng() {
 		return jiudianmingcheng;
 	}
-	/**
-	 * 设置：房间类型
-	 */
+
+	// 设置房间类型的方法
 	public void setFangjianleixing(String fangjianleixing) {
 		this.fangjianleixing = fangjianleixing;
 	}
-	/**
-	 * 获取：房间类型
-	 */
+
+	// 获取房间类型的方法
 	public String getFangjianleixing() {
 		return fangjianleixing;
 	}
-	/**
-	 * 设置：数量
-	 */
+
+	// 设置数量的方法
 	public void setShuliang(Float shuliang) {
 		this.shuliang = shuliang;
 	}
-	/**
-	 * 获取：数量
-	 */
+
+	// 获取数量的方法
 	public Float getShuliang() {
 		return shuliang;
 	}
-	/**
-	 * 设置：客房图片
-	 */
+
+	// 设置客房图片的方法
 	public void setKefangtupian(String kefangtupian) {
 		this.kefangtupian = kefangtupian;
 	}
-	/**
-	 * 获取：客房图片
-	 */
+
+	// 获取客房图片的方法
 	public String getKefangtupian() {
 		return kefangtupian;
 	}
-	/**
-	 * 设置：用户名
-	 */
+
+	// 设置用户名的方法
 	public void setYonghuming(String yonghuming) {
 		this.yonghuming = yonghuming;
 	}
-	/**
-	 * 获取：用户名
-	 */
+
+	// 获取用户名的方法
 	public String getYonghuming() {
 		return yonghuming;
 	}
-	/**
-	 * 设置：姓名
-	 */
+
+	// 设置姓名的方法
 	public void setXingming(String xingming) {
 		this.xingming = xingming;
 	}
-	/**
-	 * 获取：姓名
-	 */
+
+	// 获取姓名的方法
 	public String getXingming() {
 		return xingming;
 	}
-	/**
-	 * 设置：手机号
-	 */
+
+	// 设置手机号的方法
 	public void setShoujihao(String shoujihao) {
 		this.shoujihao = shoujihao;
 	}
-	/**
-	 * 获取：手机号
-	 */
+
+	// 获取手机号的方法
 	public String getShoujihao() {
 		return shoujihao;
 	}
-	/**
-	 * 设置：房间号
-	 */
+
+	// 设置房间号的方法
 	public void setFangjianhao(String fangjianhao) {
 		this.fangjianhao = fangjianhao;
 	}
-	/**
-	 * 获取：房间号
-	 */
+
+	// 获取房间号的方法
 	public String getFangjianhao() {
 		return fangjianhao;
 	}
-	/**
-	 * 设置：跨表用户id
-	 */
+
+	// 设置跨表用户 id 的方法
 	public void setCrossuserid(Long crossuserid) {
 		this.crossuserid = crossuserid;
 	}
-	/**
-	 * 获取：跨表用户id
-	 */
+
+	// 获取跨表用户 id 的方法
 	public Long getCrossuserid() {
 		return crossuserid;
 	}
-	/**
-	 * 设置：跨表主键id
-	 */
+
+	// 设置跨表主键 id 的方法
 	public void setCrossrefid(Long crossrefid) {
 		this.crossrefid = crossrefid;
 	}
-	/**
-	 * 获取：跨表主键id
-	 */
+
+	// 获取跨表主键 id 的方法
 	public Long getCrossrefid() {
 		return crossrefid;
 	}
-
-}
+}

back/src/main/java/com/entity/StoreupEntity.java

@@ -1,200 +1,188 @@
+// 声明该类所属的包为 com.entity，通常用于存放数据库实体相关的类
 package com.entity;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于标识数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定该实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 JSR-303 验证框架中的 NotBlank 注解，用于确保字符串字段不为空且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 导入 JSR-303 验证框架中的 NotEmpty 注解，用于确保集合、数组或字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 导入 JSR-303 验证框架中的 NotNull 注解，用于确保对象字段不为空
 import javax.validation.constraints.NotNull;
-
+// 导入 Jackson 库的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略指定属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射操作中可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
+// 导入 List 接口，用于表示一组对象的集合（当前代码未实际使用该接口相关功能，但导入了对应的包）
 import java.util.List;
-
+// 导入 Spring 框架的 DateTimeFormat 注解，用于指定日期在接收参数时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 库的 JsonFormat 注解，用于指定日期在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于复制 JavaBean 的属性
 import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 框架的 TableField 注解，用于设置字段在数据库表中的相关属性（当前代码未实际使用该注解，但导入了对应的包）
 import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略（当前代码未实际使用该枚举，但导入了对应的包）
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
 /**
  * 收藏表
  * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
+ * @author 作者信息未填写
+ * @email 邮箱信息未填写
  * @date 2022-04-04 00:20:04
  */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "storeup"
 @TableName("storeup")
+// 定义 StoreupEntity 类，使用泛型 T，实现 Serializable 接口
 public class StoreupEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中保持类的版本一致性
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，用于创建 StoreupEntity 对象时不传入任何参数
 	public StoreupEntity() {
-		
 	}
-	
+
+	// 带参数的构造函数，通过传入的泛型对象 t 复制属性到当前对象
 	public StoreupEntity(T t) {
 		try {
+			// 使用 BeanUtils 的 copyProperties 方法将 t 对象的属性复制到当前对象
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
+			// 如果在复制属性过程中出现非法访问异常或反射调用目标异常
+			// 简单打印异常堆栈信息，后续可根据实际情况完善异常处理逻辑
 			e.printStackTrace();
 		}
 	}
-	
-	/**
-	 * 主键id
-	 */
+
+	// 使用 TableId 注解标识该字段为主键
+	// 主键 id，用于唯一标识数据库表中的每条记录
 	@TableId
 	private Long id;
-	/**
-	 * 用户id
-	 */
-					
+
+	// 用户 id 字段，用于存储收藏操作对应的用户的 id
 	private Long userid;
-	
-	/**
-	 * 收藏id
-	 */
-					
+
+	// 收藏 id 字段，用于标识被收藏的具体对象的 id
 	private Long refid;
-	
-	/**
-	 * 表名
-	 */
-					
+
+	// 表名字段，用于记录收藏对象所在的表名
 	private String tablename;
-	
-	/**
-	 * 收藏名称
-	 */
-					
+
+	// 收藏名称字段，用于存储被收藏对象的名称
 	private String name;
-	
-	/**
-	 * 收藏图片
-	 */
-					
+
+	// 收藏图片字段，用于存储与收藏对象相关的图片信息（如图片路径等）
 	private String picture;
-	
-	/**
-	 * 类型(1:收藏,21:赞,22:踩)
-	 */
-					
+
+	// 类型字段，用于标识操作类型（1:收藏,21:赞,22:踩）
 	private String type;
-	
-	/**
-	 * 推荐类型
-	 */
-					
+
+	// 推荐类型字段，用于记录收藏的推荐类型相关信息
 	private String inteltype;
-	
-	
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
 	private Date addtime;
 
+	// 获取记录添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	// 设置记录添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
-	/**
-	 * 设置：用户id
-	 */
+
+	// 设置用户 id 的方法
 	public void setUserid(Long userid) {
 		this.userid = userid;
 	}
-	/**
-	 * 获取：用户id
-	 */
+
+	// 获取用户 id 的方法
 	public Long getUserid() {
 		return userid;
 	}
-	/**
-	 * 设置：收藏id
-	 */
+
+	// 设置收藏 id 的方法
 	public void setRefid(Long refid) {
 		this.refid = refid;
 	}
-	/**
-	 * 获取：收藏id
-	 */
+
+	// 获取收藏 id 的方法
 	public Long getRefid() {
 		return refid;
 	}
-	/**
-	 * 设置：表名
-	 */
+
+	// 设置表名的方法
 	public void setTablename(String tablename) {
 		this.tablename = tablename;
 	}
-	/**
-	 * 获取：表名
-	 */
+
+	// 获取表名的方法
 	public String getTablename() {
 		return tablename;
 	}
-	/**
-	 * 设置：收藏名称
-	 */
+
+	// 设置收藏名称的方法
 	public void setName(String name) {
 		this.name = name;
 	}
-	/**
-	 * 获取：收藏名称
-	 */
+
+	// 获取收藏名称的方法
 	public String getName() {
 		return name;
 	}
-	/**
-	 * 设置：收藏图片
-	 */
+
+	// 设置收藏图片的方法
 	public void setPicture(String picture) {
 		this.picture = picture;
 	}
-	/**
-	 * 获取：收藏图片
-	 */
+
+	// 获取收藏图片的方法
 	public String getPicture() {
 		return picture;
 	}
-	/**
-	 * 设置：类型(1:收藏,21:赞,22:踩)
-	 */
+
+	// 设置类型的方法
 	public void setType(String type) {
 		this.type = type;
 	}
-	/**
-	 * 获取：类型(1:收藏,21:赞,22:踩)
-	 */
+
+	// 获取类型的方法
 	public String getType() {
 		return type;
 	}
-	/**
-	 * 设置：推荐类型
-	 */
+
+	// 设置推荐类型的方法
 	public void setInteltype(String inteltype) {
 		this.inteltype = inteltype;
 	}
-	/**
-	 * 获取：推荐类型
-	 */
+
+	// 获取推荐类型的方法
 	public String getInteltype() {
 		return inteltype;
 	}
-
-}
+}

back/src/main/java/com/entity/TokenEntity.java

@@ -1,122 +1,157 @@
+// 声明该类所属的包为 com.entity，通常用于存放与数据库实体相关的类
 package com.entity;
 
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于标识数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定该实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-/** 
+/**
  * token表
  */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "token"
 @TableName("token")
+// 定义 TokenEntity 类，实现 Serializable 接口
 public class TokenEntity implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中保持类的版本一致性
 	private static final long serialVersionUID = 1L;
-	
+
+	// 使用 TableId 注解标识该字段为主键，并指定主键生成策略为自动增长
 	@TableId(type = IdType.AUTO)
+	// 主键 id，用于唯一标识数据库表中的每条记录
 	private Long id;
-	
+
 	/**
 	 * 用户id
 	 */
+	// 存储拥有该 token 的用户的 id
 	private Long userid;
-	
+
 	/**
 	 * 用户名
 	 */
+	// 存储拥有该 token 的用户的用户名
 	private String username;
-	
+
 	/**
 	 * 表名
 	 */
+	// 存储与该 token 相关的表名
 	private String tablename;
-	
+
 	/**
 	 * 角色
 	 */
+	// 存储拥有该 token 的用户的角色
 	private String role;
-	
+
 	/**
 	 * token
 	 */
+	// 存储生成的 token 值
 	private String token;
-	
+
 	/**
 	 * 过期时间
 	 */
+	// 存储该 token 的过期时间
 	private Date expiratedtime;
-	
+
 	/**
 	 * 新增时间
 	 */
+	// 存储该 token 的新增时间
 	private Date addtime;
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
 
+	// 获取用户 id 的方法
 	public Long getUserid() {
 		return userid;
 	}
 
+	// 设置用户 id 的方法
 	public void setUserid(Long userid) {
 		this.userid = userid;
 	}
 
+	// 获取角色的方法
 	public String getRole() {
 		return role;
 	}
 
+	// 设置角色的方法
 	public void setRole(String role) {
 		this.role = role;
 	}
 
+	// 获取 token 的方法
 	public String getToken() {
 		return token;
 	}
 
+	// 获取表名的方法
 	public String getTablename() {
 		return tablename;
 	}
 
+	// 设置表名的方法
 	public void setTablename(String tablename) {
 		this.tablename = tablename;
 	}
 
+	// 设置 token 的方法
 	public void setToken(String token) {
 		this.token = token;
 	}
 
+	// 获取过期时间的方法
 	public Date getExpiratedtime() {
 		return expiratedtime;
 	}
 
+	// 设置过期时间的方法
 	public void setExpiratedtime(Date expiratedtime) {
 		this.expiratedtime = expiratedtime;
 	}
 
+	// 获取新增时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
 
+	// 设置新增时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取用户名的方法
 	public String getUsername() {
 		return username;
 	}
 
+	// 设置用户名的方法
 	public void setUsername(String username) {
 		this.username = username;
 	}
 
-	public TokenEntity(Long userid, String username, String tablename,String role, String token, Date expiratedtime) {
+	// 带参数的构造函数，用于创建 TokenEntity 对象时初始化部分属性
+	public TokenEntity(Long userid, String username, String tablename, String role, String token, Date expiratedtime) {
 		super();
 		this.userid = userid;
 		this.username = username;
@@ -125,8 +160,8 @@ public class TokenEntity implements Serializable {
 		this.token = token;
 		this.expiratedtime = expiratedtime;
 	}
-	
+
+	// 无参构造函数，用于创建 TokenEntity 对象时不传入任何参数
 	public TokenEntity() {
 	}
-	
-}
+}

back/src/main/java/com/entity/UserEntity.java

@@ -1,77 +1,101 @@
+// 声明该类所属的包为 com.entity，一般用于存放与数据库实体相关的类
 package com.entity;
 
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于标识数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定该实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-/** 
+/**
  * 用户
  */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "users"
 @TableName("users")
+// 定义 UserEntity 类，实现 Serializable 接口
 public class UserEntity implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中保持类的版本一致性
 	private static final long serialVersionUID = 1L;
-	
+
+	// 使用 TableId 注解标识该字段为主键，并指定主键生成策略为自动增长
 	@TableId(type = IdType.AUTO)
+	// 主键 id，用于唯一标识数据库表中的每条记录
 	private Long id;
-	
+
 	/**
 	 * 用户账号
 	 */
+	// 存储用户的账号信息
 	private String username;
-	
+
 	/**
 	 * 密码
 	 */
+	// 存储用户的密码信息
 	private String password;
-	
+
 	/**
 	 * 用户类型
 	 */
+	// 存储用户的类型，如普通用户、管理员等
 	private String role;
-	
+
+	// 记录用户的添加时间
 	private Date addtime;
 
+	// 获取用户账号的方法
 	public String getUsername() {
 		return username;
 	}
 
+	// 设置用户账号的方法
 	public void setUsername(String username) {
 		this.username = username;
 	}
 
+	// 获取用户密码的方法
 	public String getPassword() {
 		return password;
 	}
 
+	// 设置用户密码的方法
 	public void setPassword(String password) {
 		this.password = password;
 	}
 
+	// 获取用户类型的方法
 	public String getRole() {
 		return role;
 	}
 
+	// 设置用户类型的方法
 	public void setRole(String role) {
 		this.role = role;
 	}
 
+	// 获取用户添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
 
+	// 设置用户添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
-
-}
+}

back/src/main/java/com/entity/YonghuEntity.java

@@ -1,182 +1,175 @@
+// 声明该类所属的包为 com.entity，通常用于存放数据库实体相关的类
 package com.entity;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于标识数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定该实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 JSR-303 验证框架中的 NotBlank 注解，用于确保字符串字段不为空且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 导入 JSR-303 验证框架中的 NotEmpty 注解，用于确保集合、数组或字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 导入 JSR-303 验证框架中的 NotNull 注解，用于确保对象字段不为空
 import javax.validation.constraints.NotNull;
-
+// 导入 Jackson 库的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略指定属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射操作中可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
+// 导入 List 接口，用于表示一组对象的集合（当前代码未实际使用该接口相关功能，但导入了对应的包）
 import java.util.List;
-
+// 导入 Spring 框架的 DateTimeFormat 注解，用于指定日期在接收参数时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 库的 JsonFormat 注解，用于指定日期在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于复制 JavaBean 的属性
 import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 框架的 TableField 注解，用于设置字段在数据库表中的相关属性（当前代码未实际使用该注解，但导入了对应的包）
 import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略（当前代码未实际使用该枚举，但导入了对应的包）
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
 /**
  * 用户
  * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
+ * @author 作者信息未填写
+ * @email 邮箱信息未填写
  * @date 2022-04-04 00:20:04
  */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "yonghu"
 @TableName("yonghu")
+// 定义 YonghuEntity 类，使用泛型 T，实现 Serializable 接口
 public class YonghuEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中保持类的版本一致性
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，用于创建 YonghuEntity 对象时不传入任何参数
 	public YonghuEntity() {
-		
 	}
-	
+
+	// 带参数的构造函数，通过传入的泛型对象 t 复制属性到当前对象
 	public YonghuEntity(T t) {
 		try {
+			// 使用 BeanUtils 的 copyProperties 方法将 t 对象的属性复制到当前对象
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
+			// 如果在复制属性过程中出现非法访问异常或反射调用目标异常
+			// 简单打印异常堆栈信息，后续可根据实际情况完善异常处理逻辑
 			e.printStackTrace();
 		}
 	}
-	
-	/**
-	 * 主键id
-	 */
+
+	// 使用 TableId 注解标识该字段为主键
+	// 主键 id，用于唯一标识数据库表中的每条记录
 	@TableId
 	private Long id;
-	/**
-	 * 用户名
-	 */
-					
+
+	// 用户名字段，用于存储用户的用户名
 	private String yonghuming;
-	
-	/**
-	 * 姓名
-	 */
-					
+
+	// 姓名字段，用于存储用户的姓名
 	private String xingming;
-	
-	/**
-	 * 密码
-	 */
-					
+
+	// 密码字段，用于存储用户的密码
 	private String mima;
-	
-	/**
-	 * 性别
-	 */
-					
+
+	// 性别字段，用于存储用户的性别信息
 	private String xingbie;
-	
-	/**
-	 * 年龄
-	 */
-					
+
+	// 年龄字段，用于存储用户的年龄，数据类型为 Integer
 	private Integer nianling;
-	
-	/**
-	 * 手机号
-	 */
-					
+
+	// 手机号字段，用于存储用户的手机号码
 	private String shoujihao;
-	
-	
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
 	private Date addtime;
 
+	// 获取记录添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	// 设置记录添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
-	/**
-	 * 设置：用户名
-	 */
+
+	// 设置用户名的方法
 	public void setYonghuming(String yonghuming) {
 		this.yonghuming = yonghuming;
 	}
-	/**
-	 * 获取：用户名
-	 */
+
+	// 获取用户名的方法
 	public String getYonghuming() {
 		return yonghuming;
 	}
-	/**
-	 * 设置：姓名
-	 */
+
+	// 设置姓名的方法
 	public void setXingming(String xingming) {
 		this.xingming = xingming;
 	}
-	/**
-	 * 获取：姓名
-	 */
+
+	// 获取姓名的方法
 	public String getXingming() {
 		return xingming;
 	}
-	/**
-	 * 设置：密码
-	 */
+
+	// 设置密码的方法
 	public void setMima(String mima) {
 		this.mima = mima;
 	}
-	/**
-	 * 获取：密码
-	 */
+
+	// 获取密码的方法
 	public String getMima() {
 		return mima;
 	}
-	/**
-	 * 设置：性别
-	 */
+
+	// 设置性别的方法
 	public void setXingbie(String xingbie) {
 		this.xingbie = xingbie;
 	}
-	/**
-	 * 获取：性别
-	 */
+
+	// 获取性别的方法
 	public String getXingbie() {
 		return xingbie;
 	}
-	/**
-	 * 设置：年龄
-	 */
+
+	// 设置年龄的方法
 	public void setNianling(Integer nianling) {
 		this.nianling = nianling;
 	}
-	/**
-	 * 获取：年龄
-	 */
+
+	// 获取年龄的方法
 	public Integer getNianling() {
 		return nianling;
 	}
-	/**
-	 * 设置：手机号
-	 */
+
+	// 设置手机号的方法
 	public void setShoujihao(String shoujihao) {
 		this.shoujihao = shoujihao;
 	}
-	/**
-	 * 获取：手机号
-	 */
+
+	// 获取手机号的方法
 	public String getShoujihao() {
 		return shoujihao;
 	}
-
-}
+}

back/src/main/java/com/entity/YuangongEntity.java

@@ -1,220 +1,204 @@
+// 声明该类所属的包为 com.entity，通常用于存放与数据库实体相关的类
 package com.entity;
 
+// 导入 MyBatis-Plus 框架的 TableId 注解，用于标识数据库表的主键字段
 import com.baomidou.mybatisplus.annotations.TableId;
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定该实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 JSR-303 验证框架中的 NotBlank 注解，用于确保字符串字段不为空且去除首尾空格后长度大于 0
 import javax.validation.constraints.NotBlank;
+// 导入 JSR-303 验证框架中的 NotEmpty 注解，用于确保集合、数组或字符串等不为空
 import javax.validation.constraints.NotEmpty;
+// 导入 JSR-303 验证框架中的 NotNull 注解，用于确保对象字段不为空
 import javax.validation.constraints.NotNull;
-
+// 导入 Jackson 库的 JsonIgnoreProperties 注解，用于在序列化和反序列化时忽略指定属性
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+// 导入反射操作中可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可进行序列化和反序列化操作
 import java.io.Serializable;
+// 导入 Date 类，用于处理日期和时间相关的数据
 import java.util.Date;
+// 导入 List 接口，用于表示一组对象的集合（当前代码未实际使用该接口相关功能，但导入了对应的包）
 import java.util.List;
-
+// 导入 Spring 框架的 DateTimeFormat 注解，用于指定日期在接收参数时的格式
 import org.springframework.format.annotation.DateTimeFormat;
+// 导入 Jackson 库的 JsonFormat 注解，用于指定日期在序列化时的格式
 import com.fasterxml.jackson.annotation.JsonFormat;
+// 导入 Apache Commons BeanUtils 工具类，用于复制 JavaBean 的属性
 import org.apache.commons.beanutils.BeanUtils;
+// 导入 MyBatis-Plus 框架的 TableField 注解，用于设置字段在数据库表中的相关属性（当前代码未实际使用该注解，但导入了对应的包）
 import com.baomidou.mybatisplus.annotations.TableField;
+// 导入 MyBatis-Plus 框架的 FieldFill 枚举，用于指定字段的填充策略（当前代码未实际使用该枚举，但导入了对应的包）
 import com.baomidou.mybatisplus.enums.FieldFill;
+// 导入 MyBatis-Plus 框架的 IdType 枚举，用于指定主键的生成策略
 import com.baomidou.mybatisplus.enums.IdType;
 
-
 /**
  * 员工
  * 数据库通用操作实体类（普通增删改查）
- * @author 
- * @email 
+ * @author 作者信息未填写
+ * @email 邮箱信息未填写
  * @date 2022-04-04 00:20:04
  */
+// 使用 TableName 注解指定该实体类对应的数据库表名为 "yuangong"
 @TableName("yuangong")
+// 定义 YuangongEntity 类，使用泛型 T，实现 Serializable 接口
 public class YuangongEntity<T> implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中保持类的版本一致性
 	private static final long serialVersionUID = 1L;
 
-
+	// 无参构造函数，用于创建 YuangongEntity 对象时不传入任何参数
 	public YuangongEntity() {
-		
 	}
-	
+
+	// 带参数的构造函数，通过传入的泛型对象 t 复制属性到当前对象
 	public YuangongEntity(T t) {
 		try {
+			// 使用 BeanUtils 的 copyProperties 方法将 t 对象的属性复制到当前对象
 			BeanUtils.copyProperties(this, t);
 		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
+			// 如果在复制属性过程中出现非法访问异常或反射调用目标异常
+			// 简单打印异常堆栈信息，后续可根据实际情况完善异常处理逻辑
 			e.printStackTrace();
 		}
 	}
-	
-	/**
-	 * 主键id
-	 */
+
+	// 使用 TableId 注解标识该字段为主键
+	// 主键 id，用于唯一标识数据库表中的每条记录
 	@TableId
 	private Long id;
-	/**
-	 * 员工工号
-	 */
-					
+
+	// 员工工号字段，用于存储员工的工号信息
 	private String yuangonggonghao;
-	
-	/**
-	 * 员工姓名
-	 */
-					
+
+	// 员工姓名字段，用于存储员工的姓名
 	private String yuangongxingming;
-	
-	/**
-	 * 密码
-	 */
-					
+
+	// 密码字段，用于存储员工的密码
 	private String mima;
-	
-	/**
-	 * 性别
-	 */
-					
+
+	// 性别字段，用于存储员工的性别信息
 	private String xingbie;
-	
-	/**
-	 * 联系电话
-	 */
-					
+
+	// 联系电话字段，用于存储员工的联系电话
 	private String lianxidianhua;
-	
-	/**
-	 * 头像
-	 */
-					
+
+	// 头像字段，用于存储员工的头像相关信息（如图片路径等）
 	private String touxiang;
-	
-	/**
-	 * 入职时间
-	 */
-				
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
-	@DateTimeFormat 		
+
+	// 入职时间字段，使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd")
+	@DateTimeFormat
 	private Date ruzhishijian;
-	
-	/**
-	 * 职位
-	 */
-					
+
+	// 职位字段，用于存储员工的职位信息
 	private String zhiwei;
-	
-	
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
 	@DateTimeFormat
 	private Date addtime;
 
+	// 获取记录添加时间的方法
 	public Date getAddtime() {
 		return addtime;
 	}
+
+	// 设置记录添加时间的方法
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	// 获取主键 id 的方法
 	public Long getId() {
 		return id;
 	}
 
+	// 设置主键 id 的方法
 	public void setId(Long id) {
 		this.id = id;
 	}
-	/**
-	 * 设置：员工工号
-	 */
+
+	// 设置员工工号的方法
 	public void setYuangonggonghao(String yuangonggonghao) {
 		this.yuangonggonghao = yuangonggonghao;
 	}
-	/**
-	 * 获取：员工工号
-	 */
+
+	// 获取员工工号的方法
 	public String getYuangonggonghao() {
 		return yuangonggonghao;
 	}
-	/**
-	 * 设置：员工姓名
-	 */
+
+	// 设置员工姓名的方法
 	public void setYuangongxingming(String yuangongxingming) {
 		this.yuangongxingming = yuangongxingming;
 	}
-	/**
-	 * 获取：员工姓名
-	 */
+
+	// 获取员工姓名的方法
 	public String getYuangongxingming() {
 		return yuangongxingming;
 	}
-	/**
-	 * 设置：密码
-	 */
+
+	// 设置密码的方法
 	public void setMima(String mima) {
 		this.mima = mima;
 	}
-	/**
-	 * 获取：密码
-	 */
+
+	// 获取密码的方法
 	public String getMima() {
 		return mima;
 	}
-	/**
-	 * 设置：性别
-	 */
+
+	// 设置性别的方法
 	public void setXingbie(String xingbie) {
 		this.xingbie = xingbie;
 	}
-	/**
-	 * 获取：性别
-	 */
+
+	// 获取性别的方法
 	public String getXingbie() {
 		return xingbie;
 	}
-	/**
-	 * 设置：联系电话
-	 */
+
+	// 设置联系电话的方法
 	public void setLianxidianhua(String lianxidianhua) {
 		this.lianxidianhua = lianxidianhua;
 	}
-	/**
-	 * 获取：联系电话
-	 */
+
+	// 获取联系电话的方法
 	public String getLianxidianhua() {
 		return lianxidianhua;
 	}
-	/**
-	 * 设置：头像
-	 */
+
+	// 设置头像的方法
 	public void setTouxiang(String touxiang) {
 		this.touxiang = touxiang;
 	}
-	/**
-	 * 获取：头像
-	 */
+
+	// 获取头像的方法
 	public String getTouxiang() {
 		return touxiang;
 	}
-	/**
-	 * 设置：入职时间
-	 */
+
+	// 设置入职时间的方法
 	public void setRuzhishijian(Date ruzhishijian) {
 		this.ruzhishijian = ruzhishijian;
 	}
-	/**
-	 * 获取：入职时间
-	 */
+
+	// 获取入职时间的方法
 	public Date getRuzhishijian() {
 		return ruzhishijian;
 	}
-	/**
-	 * 设置：职位
-	 */
+
+	// 设置职位的方法
 	public void setZhiwei(String zhiwei) {
 		this.zhiwei = zhiwei;
 	}
-	/**
-	 * 获取：职位
-	 */
+
+	// 获取职位的方法
 	public String getZhiwei() {
 		return zhiwei;
 	}
-
-}
+}

back/src/main/java/com/entity/view/YonghuView.java

@@ -1,36 +1,53 @@
+// 声明该类所在的包名为 com.entity.view，通常用于存放视图相关的实体类
 package com.entity.view;
 
+// 导入 YonghuEntity 类，这是一个实体类，可能与数据库中的用户表相对应
 import com.entity.YonghuEntity;
 
+// 导入 MyBatis-Plus 框架的 TableName 注解，用于指定实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 Apache Commons BeanUtils 工具类，用于进行 JavaBean 属性的复制操作
 import org.apache.commons.beanutils.BeanUtils;
+// 导入反射调用时可能抛出的异常类，在使用 BeanUtils 复制属性时可能会用到
 import java.lang.reflect.InvocationTargetException;
-
+// 导入序列化接口，实现该接口的类的对象可以被序列化和反序列化，便于在网络传输或存储
 import java.io.Serializable;
- 
 
 /**
  * 用户
- * 后端返回视图实体辅助类   
+ * 后端返回视图实体辅助类
  * （通常后端关联的表或者自定义的字段需要返回使用）
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:04
  */
+// 使用 TableName 注解指定该视图实体类对应的数据库表名为 "yonghu"
 @TableName("yonghu")
+// 定义 YonghuView 类，它继承自 YonghuEntity 类，并且实现了 Serializable 接口
 public class YonghuView  extends YonghuEntity implements Serializable {
+	// 定义序列化版本号，用于在序列化和反序列化过程中确保类的版本一致性
 	private static final long serialVersionUID = 1L;
 
+	// 定义无参构造函数，当创建 YonghuView 对象时，如果不传入参数，会调用此构造函数
 	public YonghuView(){
+		// 无参构造函数体为空，这里没有额外的初始化操作
 	}
- 
- 	public YonghuView(YonghuEntity yonghuEntity){
- 	try {
+
+	// 定义带参数的构造函数，参数为 YonghuEntity 类型的对象
+	// 该构造函数的作用是将传入的 YonghuEntity 对象的属性复制到当前 YonghuView 对象中
+	public YonghuView(YonghuEntity yonghuEntity){
+		// 使用 try-catch 块捕获可能出现的异常
+		try {
+			// 调用 BeanUtils 的 copyProperties 方法，将 yonghuEntity 对象的属性复制到当前对象（this）中
+			// 此方法会自动匹配两个对象中相同名称的属性，并进行赋值操作
 			BeanUtils.copyProperties(this, yonghuEntity);
 		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 如果在复制属性过程中出现非法访问异常（IllegalAccessException）
+			// 或者反射调用目标方法时出现异常（InvocationTargetException），会进入此 catch 块
+			// 这里的 TODO 表示需要开发者后续根据实际情况完善异常处理逻辑
+			// 目前只是简单地打印异常堆栈信息，方便调试
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
- 		
 	}
 }

back/src/main/java/com/entity/view/YuangongView.java

@@ -1,36 +1,53 @@
+// 定义包名，表明该类属于 com.entity.view 包，此包通常用于存放后端返回视图实体辅助类
 package com.entity.view;
 
+// 导入 YuangongEntity 类，这是员工的实体类，可能与数据库中的员工表对应
 import com.entity.YuangongEntity;
 
+// 导入 MyBatis-Plus 的 TableName 注解，用于指定实体类对应的数据库表名
 import com.baomidou.mybatisplus.annotations.TableName;
+// 导入 Apache Commons BeanUtils 工具类，该类提供了复制 JavaBean 属性的功能
 import org.apache.commons.beanutils.BeanUtils;
+// 导入反射调用时可能抛出的 InvocationTargetException 异常类
 import java.lang.reflect.InvocationTargetException;
-
+// 导入 Serializable 接口，实现该接口的类的对象可以被序列化和反序列化
 import java.io.Serializable;
- 
 
 /**
  * 员工
  * 后端返回视图实体辅助类   
  * （通常后端关联的表或者自定义的字段需要返回使用）
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:04
  */
+// 使用 TableName 注解指定该类对应的数据库表名为 "yuangong"
 @TableName("yuangong")
+// 定义 YuangongView 类，继承自 YuangongEntity 类并实现 Serializable 接口
 public class YuangongView  extends YuangongEntity implements Serializable {
+	// 定义序列化版本号，保证序列化和反序列化过程中类的版本一致性
 	private static final long serialVersionUID = 1L;
 
+	// 无参构造函数，用于创建 YuangongView 类的对象时不传入任何参数的情况
 	public YuangongView(){
+		// 构造函数体为空，目前没有需要初始化的额外操作
 	}
- 
- 	public YuangongView(YuangongEntity yuangongEntity){
- 	try {
+
+	/**
+	 * 带参数的构造函数，用于根据 YuangongEntity 对象创建 YuangongView 对象
+	 * @param yuangongEntity 员工实体对象，用于复制属性到当前 YuangongView 对象
+	 */
+	public YuangongView(YuangongEntity yuangongEntity){
+		// 使用 try-catch 块捕获可能出现的异常
+		try {
+			// 调用 BeanUtils 的 copyProperties 方法，将 yuangongEntity 对象的属性复制到当前 YuangongView 对象
+			// 该方法会自动匹配两个对象中同名的属性并进行赋值
 			BeanUtils.copyProperties(this, yuangongEntity);
 		} catch (IllegalAccessException | InvocationTargetException e) {
+			// 当出现非法访问异常（IllegalAccessException）或反射调用目标方法异常（InvocationTargetException）时进入此块
+			// 这里只是简单打印异常堆栈信息，开发者可根据实际需求完善异常处理逻辑
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
- 		
 	}
-}
+}

back/src/main/java/com/interceptor/AuthorizationInterceptor.java

@@ -23,73 +23,88 @@ import com.service.TokenService;
 import com.utils.R;
 
 /**
- * 权限(Token)验证
+ * 权限(Token)验证拦截器
  */
 @Component
 public class AuthorizationInterceptor implements HandlerInterceptor {
 
+    // 定义用于在请求头中获取token的键名
     public static final String LOGIN_TOKEN_KEY = "Token";
 
+    // 自动注入TokenService，用于处理与token相关的业务逻辑
     @Autowired
     private TokenService tokenService;
-    
-	@Override
+
+    /**
+     * 预处理方法，在请求处理之前被调用
+     * @param request 当前的HttpServletRequest对象，包含请求的相关信息
+     * @param response 当前的HttpServletResponse对象，用于设置响应信息
+     * @param handler 被调用的处理器对象，可能是一个HandlerMethod或者其他类型
+     * @return true表示请求可以继续处理，false表示请求被拦截
+     * @throws Exception 处理过程中可能抛出的异常
+     */
+    @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
 
-		//支持跨域请求
+        // 支持跨域请求，设置相关的响应头信息
         response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
         response.setHeader("Access-Control-Max-Age", "3600");
         response.setHeader("Access-Control-Allow-Credentials", "true");
         response.setHeader("Access-Control-Allow-Headers", "x-requested-with,request-source,Token, Origin,imgType, Content-Type, cache-control,postman-token,Cookie, Accept,authorization");
         response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin"));
-	// 跨域时会首先发送一个OPTIONS请求，这里我们给OPTIONS请求直接返回正常状态
-	if (request.getMethod().equals(RequestMethod.OPTIONS.name())) {
-        	response.setStatus(HttpStatus.OK.value());
+
+        // 跨域时会首先发送一个OPTIONS请求，这里我们给OPTIONS请求直接返回正常状态
+        if (request.getMethod().equals(RequestMethod.OPTIONS.name())) {
+            response.setStatus(HttpStatus.OK.value());
             return false;
         }
-        
+
         IgnoreAuth annotation;
         if (handler instanceof HandlerMethod) {
+            // 从HandlerMethod中获取IgnoreAuth注解，如果存在则表示该方法不需要进行权限验证
             annotation = ((HandlerMethod) handler).getMethodAnnotation(IgnoreAuth.class);
         } else {
             return true;
         }
 
-        //从header中获取token
+        // 从请求头中获取token
         String token = request.getHeader(LOGIN_TOKEN_KEY);
-        
+
         /**
          * 不需要验证权限的方法直接放过
          */
-        if(annotation!=null) {
-        	return true;
+        if (annotation != null) {
+            return true;
         }
-        
+
         TokenEntity tokenEntity = null;
-        if(StringUtils.isNotBlank(token)) {
-        	tokenEntity = tokenService.getTokenEntity(token);
+        if (StringUtils.isNotBlank(token)) {
+            // 根据获取到的token，调用TokenService获取对应的TokenEntity对象
+            tokenEntity = tokenService.getTokenEntity(token);
         }
-        
-        if(tokenEntity != null) {
-        	request.getSession().setAttribute("userId", tokenEntity.getUserid());
-        	request.getSession().setAttribute("role", tokenEntity.getRole());
-        	request.getSession().setAttribute("tableName", tokenEntity.getTablename());
-        	request.getSession().setAttribute("username", tokenEntity.getUsername());
-        	return true;
+
+        if (tokenEntity != null) {
+            // 将tokenEntity中的相关信息存入当前请求的会话中，方便后续使用
+            request.getSession().setAttribute("userId", tokenEntity.getUserid());
+            request.getSession().setAttribute("role", tokenEntity.getRole());
+            request.getSession().setAttribute("tableName", tokenEntity.getTablename());
+            request.getSession().setAttribute("username", tokenEntity.getUsername());
+            return true;
+        }
+
+        PrintWriter writer = null;
+        response.setCharacterEncoding("UTF-8");
+        response.setContentType("application/json; charset=utf-8");
+        try {
+            writer = response.getWriter();
+            // 返回错误信息，提示用户需要先登录
+            writer.print(JSONObject.toJSONString(R.error(401, "请先登录")));
+        } finally {
+            if (writer != null) {
+                writer.close();
+            }
         }
-        
-		PrintWriter writer = null;
-		response.setCharacterEncoding("UTF-8");
-		response.setContentType("application/json; charset=utf-8");
-		try {
-		    writer = response.getWriter();
-		    writer.print(JSONObject.toJSONString(R.error(401, "请先登录")));
-		} finally {
-		    if(writer != null){
-		        writer.close();
-		    }
-		}
-//				throw new EIException("请先登录", 401);
-		return false;
+//        throw new EIException("请先登录", 401);
+        return false;
     }
-}
+}

back/src/main/java/com/service/CommonService.java

@@ -1,22 +1,35 @@
-package com.service;
+package com.service; // 声明该类所属的包为com.service
 
+// 导入List接口，用于表示有序的集合
 import java.util.List;
+// 导入Map接口，用于表示键值对的集合
 import java.util.Map;
 
+/**
+ * 通用服务接口，定义了一系列通用的数据操作方法
+ */
 public interface CommonService {
+	// 根据传入的参数Map查询选项列表，返回一个包含字符串的列表
 	List<String> getOption(Map<String, Object> params);
-	
+
+	// 根据传入的参数Map查询关联信息，返回一个包含键值对的Map
 	Map<String, Object> getFollowByOption(Map<String, Object> params);
-	
+
+	// 根据传入的参数Map执行更新操作，没有返回值
 	void sh(Map<String, Object> params);
-	
+
+	// 根据传入的参数Map统计提醒数量，返回一个整数
 	int remindCount(Map<String, Object> params);
-	
+
+	// 根据传入的参数Map进行统计计算，返回一个包含统计结果的Map
 	Map<String, Object> selectCal(Map<String, Object> params);
-	
+
+	// 根据传入的参数Map进行分组查询，返回一个包含多个键值对Map的列表
 	List<Map<String, Object>> selectGroup(Map<String, Object> params);
-	
+
+	// 根据传入的参数Map查询值列表，返回一个包含多个键值对Map的列表
 	List<Map<String, Object>> selectValue(Map<String, Object> params);
 
+	// 根据传入的参数Map进行时间统计查询，返回一个包含多个键值对Map的列表
 	List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params);
-}
+}

back/src/main/java/com/service/ConfigService.java

@@ -1,17 +1,24 @@
+package com.service; // 声明该类所在的包为com.service
 
-package com.service;
-
+// 导入Map接口，用于存储键值对，常作为方法的参数传递参数集合
 import java.util.Map;
 
+// 导入MyBatis-Plus的Wrapper类，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，这是MyBatis-Plus提供的通用服务接口
 import com.baomidou.mybatisplus.service.IService;
+// 导入实体类ConfigEntity，代表系统配置的实体对象
 import com.entity.ConfigEntity;
+// 导入自定义的分页工具类PageUtils，用于处理分页相关操作
 import com.utils.PageUtils;
 
-
 /**
  * 系统用户
  */
 public interface ConfigService extends IService<ConfigEntity> {
-	PageUtils queryPage(Map<String, Object> params,Wrapper<ConfigEntity> wrapper);
-}
+	// 定义一个查询分页数据的方法
+	// 参数params是一个Map，用于传递查询所需的参数，如页码、每页数量等
+	// 参数wrapper是一个Wrapper<ConfigEntity>对象，用于构建对ConfigEntity实体的查询条件
+	// 该方法返回一个PageUtils对象，包含了分页查询的结果信息
+	PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper);
+}

back/src/main/java/com/service/DiscussjiudianjianjieService.java

@@ -1,37 +1,47 @@
-package com.service;
+package com.service; // 声明该类所在的包为com.service
 
+// 导入MyBatis-Plus的Wrapper类，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，这是MyBatis-Plus提供的通用服务接口
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类PageUtils，用于处理分页相关操作
 import com.utils.PageUtils;
+// 导入酒店简介评论表的实体类
 import com.entity.DiscussjiudianjianjieEntity;
+// 导入List接口，用于存储多个元素
 import java.util.List;
+// 导入Map接口，用于存储键值对
 import java.util.Map;
+// 导入酒店简介评论表的VO（视图对象）类，用于封装特定视图所需的数据
 import com.entity.vo.DiscussjiudianjianjieVO;
+// 导入MyBatis的Param注解，用于指定参数名称
 import org.apache.ibatis.annotations.Param;
+// 导入酒店简介评论表的View（视图类），用于封装特定视图所需的数据
 import com.entity.view.DiscussjiudianjianjieView;
 
-
 /**
  * 酒店简介评论表
  *
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:05
  */
 public interface DiscussjiudianjianjieService extends IService<DiscussjiudianjianjieEntity> {
+	// 根据传入的参数进行分页查询，返回一个包含分页信息的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
 
-    PageUtils queryPage(Map<String, Object> params);
-    
-   	List<DiscussjiudianjianjieVO> selectListVO(Wrapper<DiscussjiudianjianjieEntity> wrapper);
-   	
-   	DiscussjiudianjianjieVO selectVO(@Param("ew") Wrapper<DiscussjiudianjianjieEntity> wrapper);
-   	
-   	List<DiscussjiudianjianjieView> selectListView(Wrapper<DiscussjiudianjianjieEntity> wrapper);
-   	
-   	DiscussjiudianjianjieView selectView(@Param("ew") Wrapper<DiscussjiudianjianjieEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<DiscussjiudianjianjieEntity> wrapper);
-   	
+	// 根据传入的查询条件Wrapper，查询出符合条件的酒店简介评论VO列表
+	List<DiscussjiudianjianjieVO> selectListVO(Wrapper<DiscussjiudianjianjieEntity> wrapper);
 
-}
+	// 根据传入的查询条件Wrapper，查询出符合条件的单个酒店简介评论VO对象
+	DiscussjiudianjianjieVO selectVO(@Param("ew") Wrapper<DiscussjiudianjianjieEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询出符合条件的酒店简介评论视图列表
+	List<DiscussjiudianjianjieView> selectListView(Wrapper<DiscussjiudianjianjieEntity> wrapper);
 
+	// 根据传入的查询条件Wrapper，查询出符合条件的单个酒店简介评论视图对象
+	DiscussjiudianjianjieView selectView(@Param("ew") Wrapper<DiscussjiudianjianjieEntity> wrapper);
+
+	// 根据传入的参数和查询条件Wrapper进行分页查询，返回一个包含分页信息的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<DiscussjiudianjianjieEntity> wrapper);
+}

back/src/main/java/com/service/DiscussjiudiankefangService.java

@@ -1,37 +1,48 @@
-package com.service;
+package com.service; // 声明该Java类所在的包为com.service
 
+// 导入MyBatis-Plus框架中的Wrapper类，用于构建动态查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架提供的通用IService接口，该接口包含了常见的增删改查等操作方法
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类，用于处理分页查询的相关逻辑
 import com.utils.PageUtils;
+// 导入酒店客房评论表对应的实体类，代表数据库中的酒店客房评论表记录
 import com.entity.DiscussjiudiankefangEntity;
+// 导入List接口，用于存储多个对象的集合
 import java.util.List;
+// 导入Map接口，用于存储键值对，通常用于传递查询参数等
 import java.util.Map;
+// 导入酒店客房评论表对应的VO（View Object）类，用于封装特定视图展示所需的数据
 import com.entity.vo.DiscussjiudiankefangVO;
+// 导入MyBatis的@Param注解，用于在Mapper方法中指定参数名称
 import org.apache.ibatis.annotations.Param;
+// 导入酒店客房评论表对应的View类，用于封装特定视图展示所需的数据
 import com.entity.view.DiscussjiudiankefangView;
 
-
 /**
  * 酒店客房评论表
  *
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:05
  */
+// 定义一个服务接口，继承自MyBatis-Plus的IService接口，泛型指定为酒店客房评论表实体类
 public interface DiscussjiudiankefangService extends IService<DiscussjiudiankefangEntity> {
+	// 根据传入的参数进行分页查询酒店客房评论记录，返回包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
 
-    PageUtils queryPage(Map<String, Object> params);
-    
-   	List<DiscussjiudiankefangVO> selectListVO(Wrapper<DiscussjiudiankefangEntity> wrapper);
-   	
-   	DiscussjiudiankefangVO selectVO(@Param("ew") Wrapper<DiscussjiudiankefangEntity> wrapper);
-   	
-   	List<DiscussjiudiankefangView> selectListView(Wrapper<DiscussjiudiankefangEntity> wrapper);
-   	
-   	DiscussjiudiankefangView selectView(@Param("ew") Wrapper<DiscussjiudiankefangEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<DiscussjiudiankefangEntity> wrapper);
-   	
+	// 根据传入的查询条件Wrapper，查询出符合条件的酒店客房评论VO列表，返回一个List集合
+	List<DiscussjiudiankefangVO> selectListVO(Wrapper<DiscussjiudiankefangEntity> wrapper);
 
-}
+	// 根据传入的查询条件Wrapper，查询出符合条件的单个酒店客房评论VO对象，@Param注解指定参数名称为"ew"
+	DiscussjiudiankefangVO selectVO(@Param("ew") Wrapper<DiscussjiudiankefangEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询出符合条件的酒店客房评论View列表，返回一个List集合
+	List<DiscussjiudiankefangView> selectListView(Wrapper<DiscussjiudiankefangEntity> wrapper);
 
+	// 根据传入的查询条件Wrapper，查询出符合条件的单个酒店客房评论View对象，@Param注解指定参数名称为"ew"
+	DiscussjiudiankefangView selectView(@Param("ew") Wrapper<DiscussjiudiankefangEntity> wrapper);
+
+	// 根据传入的参数和查询条件Wrapper进行分页查询酒店客房评论记录，返回包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<DiscussjiudiankefangEntity> wrapper);
+}

back/src/main/java/com/service/JiudianjianjieService.java

@@ -1,37 +1,48 @@
-package com.service;
+package com.service; // 声明该类属于com.service包
 
+// 导入MyBatis-Plus的Wrapper类，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，提供通用的CRUD操作
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类
 import com.utils.PageUtils;
+// 导入酒店简介实体类
 import com.entity.JiudianjianjieEntity;
+// 导入List接口，用于存储多个元素
 import java.util.List;
+// 导入Map接口，用于存储键值对
 import java.util.Map;
+// 导入酒店简介的VO类，用于封装特定视图的数据
 import com.entity.vo.JiudianjianjieVO;
+// 导入MyBatis的@Param注解，用于指定参数名
 import org.apache.ibatis.annotations.Param;
+// 导入酒店简介的View类，用于封装特定视图的数据
 import com.entity.view.JiudianjianjieView;
 
-
 /**
  * 酒店简介
  *
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:04
  */
+// 定义一个服务接口，继承自IService<JiudianjianjieEntity>，具备对酒店简介实体的通用操作能力
 public interface JiudianjianjieService extends IService<JiudianjianjieEntity> {
+	// 根据传入的参数进行分页查询，返回分页结果
+	PageUtils queryPage(Map<String, Object> params);
 
-    PageUtils queryPage(Map<String, Object> params);
-    
-   	List<JiudianjianjieVO> selectListVO(Wrapper<JiudianjianjieEntity> wrapper);
-   	
-   	JiudianjianjieVO selectVO(@Param("ew") Wrapper<JiudianjianjieEntity> wrapper);
-   	
-   	List<JiudianjianjieView> selectListView(Wrapper<JiudianjianjieEntity> wrapper);
-   	
-   	JiudianjianjieView selectView(@Param("ew") Wrapper<JiudianjianjieEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<JiudianjianjieEntity> wrapper);
-   	
+	// 根据传入的查询条件Wrapper，查询符合条件的酒店简介VO列表
+	List<JiudianjianjieVO> selectListVO(Wrapper<JiudianjianjieEntity> wrapper);
 
-}
+	// 根据传入的查询条件Wrapper，查询符合条件的单个酒店简介VO对象
+	JiudianjianjieVO selectVO(@Param("ew") Wrapper<JiudianjianjieEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的酒店简介View列表
+	List<JiudianjianjieView> selectListView(Wrapper<JiudianjianjieEntity> wrapper);
 
+	// 根据传入的查询条件Wrapper，查询符合条件的单个酒店简介View对象
+	JiudianjianjieView selectView(@Param("ew") Wrapper<JiudianjianjieEntity> wrapper);
+
+	// 根据传入的参数和查询条件Wrapper进行分页查询，返回分页结果
+	PageUtils queryPage(Map<String, Object> params, Wrapper<JiudianjianjieEntity> wrapper);
+}

back/src/main/java/com/service/JiudiankefangService.java

@@ -1,37 +1,48 @@
-package com.service;
+package com.service; // 声明该类所在的包为com.service
 
+// 导入MyBatis-Plus的Wrapper类，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，提供通用的CRUD服务方法
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类，用于处理分页查询结果
 import com.utils.PageUtils;
+// 导入酒店客房实体类，代表数据库中的酒店客房表记录
 import com.entity.JiudiankefangEntity;
+// 导入List接口，用于存储多个对象
 import java.util.List;
+// 导入Map接口，用于存储键值对，可作为查询参数
 import java.util.Map;
+// 导入酒店客房值对象类，用于封装特定视图展示所需的数据
 import com.entity.vo.JiudiankefangVO;
+// 导入MyBatis的@Param注解，用于在Mapper方法中指定参数名称
 import org.apache.ibatis.annotations.Param;
+// 导入酒店客房视图类，用于封装特定视图展示所需的数据
 import com.entity.view.JiudiankefangView;
 
-
 /**
  * 酒店客房
  *
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:04
  */
+// 定义一个服务接口，继承自IService<JiudiankefangEntity>，具备对酒店客房实体的基本CRUD操作能力
 public interface JiudiankefangService extends IService<JiudiankefangEntity> {
+	// 根据传入的参数进行分页查询，返回包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的酒店客房VO列表，返回List集合
+	List<JiudiankefangVO> selectListVO(Wrapper<JiudiankefangEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的单个酒店客房VO对象，@Param注解指定参数名称为"ew"
+	JiudiankefangVO selectVO(@Param("ew") Wrapper<JiudiankefangEntity> wrapper);
 
-    PageUtils queryPage(Map<String, Object> params);
-    
-   	List<JiudiankefangVO> selectListVO(Wrapper<JiudiankefangEntity> wrapper);
-   	
-   	JiudiankefangVO selectVO(@Param("ew") Wrapper<JiudiankefangEntity> wrapper);
-   	
-   	List<JiudiankefangView> selectListView(Wrapper<JiudiankefangEntity> wrapper);
-   	
-   	JiudiankefangView selectView(@Param("ew") Wrapper<JiudiankefangEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<JiudiankefangEntity> wrapper);
-   	
+	// 根据传入的查询条件Wrapper，查询符合条件的酒店客房View列表，返回List集合
+	List<JiudiankefangView> selectListView(Wrapper<JiudiankefangEntity> wrapper);
 
-}
+	// 根据传入的查询条件Wrapper，查询符合条件的单个酒店客房View对象，@Param注解指定参数名称为"ew"
+	JiudiankefangView selectView(@Param("ew") Wrapper<JiudiankefangEntity> wrapper);
 
+	// 根据传入的参数和查询条件Wrapper进行分页查询，返回包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<JiudiankefangEntity> wrapper);
+}

back/src/main/java/com/service/KefangleixingService.java

@@ -1,37 +1,49 @@
-package com.service;
+package com.service; // 声明该类所属的包为com.service
 
+// 导入MyBatis-Plus的Wrapper类，用于构建动态查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，提供通用的服务层基础方法（如增删改查）
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类，用于处理分页查询结果
 import com.utils.PageUtils;
+// 导入客房类型实体类，代表数据库中客房类型表的记录
 import com.entity.KefangleixingEntity;
+// 导入List接口，用于存储多个对象的集合
 import java.util.List;
+// 导入Map接口，用于存储键值对，可作为查询参数传递
 import java.util.Map;
+// 导入客房类型的值对象类，通常用于封装特定视图展示所需的数据
 import com.entity.vo.KefangleixingVO;
+// 导入MyBatis的@Param注解，用于在Mapper方法中指定参数名称
 import org.apache.ibatis.annotations.Param;
+// 导入客房类型的视图类，用于封装特定视图展示所需的数据
 import com.entity.view.KefangleixingView;
 
-
 /**
  * 客房类型
  *
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:04
  */
+// 定义客房类型服务接口，继承自IService<KefangleixingEntity>，意味着具备对客房类型实体的基本CRUD操作能力
 public interface KefangleixingService extends IService<KefangleixingEntity> {
 
-    PageUtils queryPage(Map<String, Object> params);
-    
-   	List<KefangleixingVO> selectListVO(Wrapper<KefangleixingEntity> wrapper);
-   	
-   	KefangleixingVO selectVO(@Param("ew") Wrapper<KefangleixingEntity> wrapper);
-   	
-   	List<KefangleixingView> selectListView(Wrapper<KefangleixingEntity> wrapper);
-   	
-   	KefangleixingView selectView(@Param("ew") Wrapper<KefangleixingEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<KefangleixingEntity> wrapper);
-   	
-
-}
+	// 根据传入的参数进行分页查询，返回一个包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据传入的查询条件Wrapper，查询出符合条件的客房类型VO列表，返回一个List集合
+	List<KefangleixingVO> selectListVO(Wrapper<KefangleixingEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询出符合条件的单个客房类型VO对象，@Param注解指定参数名为"ew"
+	KefangleixingVO selectVO(@Param("ew") Wrapper<KefangleixingEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询出符合条件的客房类型View列表，返回一个List集合
+	List<KefangleixingView> selectListView(Wrapper<KefangleixingEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询出符合条件的单个客房类型View对象，@Param注解指定参数名为"ew"
+	KefangleixingView selectView(@Param("ew") Wrapper<KefangleixingEntity> wrapper);
 
+	// 根据传入的参数和查询条件Wrapper进行分页查询，返回一个包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<KefangleixingEntity> wrapper);
+}

back/src/main/java/com/service/KefangyudingService.java

@@ -1,37 +1,49 @@
-package com.service;
+package com.service; // 声明该Java类所在的包为com.service
 
+// 导入MyBatis-Plus的Wrapper类，用于构建动态查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，它提供了通用的CRUD（创建、读取、更新、删除）操作方法
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类PageUtils，用于处理分页查询结果
 import com.utils.PageUtils;
+// 导入客房预定实体类，代表数据库中客房预定表的记录
 import com.entity.KefangyudingEntity;
+// 导入List接口，用于存储多个对象的集合
 import java.util.List;
+// 导入Map接口，用于存储键值对，通常用于传递查询参数
 import java.util.Map;
+// 导入客房预定的值对象类，用于封装特定视图展示所需的数据
 import com.entity.vo.KefangyudingVO;
+// 导入MyBatis的@Param注解，用于在Mapper方法中指定参数名称
 import org.apache.ibatis.annotations.Param;
+// 导入客房预定的视图类，用于封装特定视图展示所需的数据
 import com.entity.view.KefangyudingView;
 
-
 /**
  * 客房预定
  *
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:04
  */
+// 定义客房预定服务接口，继承自IService<KefangyudingEntity>，意味着它拥有对KefangyudingEntity实体的基本CRUD操作能力
 public interface KefangyudingService extends IService<KefangyudingEntity> {
 
-    PageUtils queryPage(Map<String, Object> params);
-    
-   	List<KefangyudingVO> selectListVO(Wrapper<KefangyudingEntity> wrapper);
-   	
-   	KefangyudingVO selectVO(@Param("ew") Wrapper<KefangyudingEntity> wrapper);
-   	
-   	List<KefangyudingView> selectListView(Wrapper<KefangyudingEntity> wrapper);
-   	
-   	KefangyudingView selectView(@Param("ew") Wrapper<KefangyudingEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<KefangyudingEntity> wrapper);
-   	
+	// 根据传入的参数进行分页查询，返回一个包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
 
-}
+	// 根据传入的查询条件Wrapper，查询符合条件的客房预定VO列表，返回一个List集合
+	List<KefangyudingVO> selectListVO(Wrapper<KefangyudingEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的单个客房预定VO对象，@Param注解指定参数名称为"ew"
+	KefangyudingVO selectVO(@Param("ew") Wrapper<KefangyudingEntity> wrapper);
 
+	// 根据传入的查询条件Wrapper，查询符合条件的客房预定View列表，返回一个List集合
+	List<KefangyudingView> selectListView(Wrapper<KefangyudingEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的单个客房预定View对象，@Param注解指定参数名称为"ew"
+	KefangyudingView selectView(@Param("ew") Wrapper<KefangyudingEntity> wrapper);
+
+	// 根据传入的参数和查询条件Wrapper进行分页查询，返回一个包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<KefangyudingEntity> wrapper);
+}

back/src/main/java/com/service/NewsService.java

@@ -1,37 +1,48 @@
-package com.service;
+package com.service; // 声明该类所属的包为com.service
 
+// 导入MyBatis-Plus的Wrapper类，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，为通用的服务层接口，提供了基本的CRUD操作
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类，用于处理分页查询的结果
 import com.utils.PageUtils;
+// 导入酒店公告实体类，对应数据库中的酒店公告表
 import com.entity.NewsEntity;
+// 导入List接口，用于存储多个元素的集合
 import java.util.List;
+// 导入Map接口，用于存储键值对，通常作为查询参数
 import java.util.Map;
+// 导入酒店公告的值对象类，用于封装特定视图展示所需的数据
 import com.entity.vo.NewsVO;
+// 导入MyBatis的@Param注解，用于在Mapper方法中指定参数名称
 import org.apache.ibatis.annotations.Param;
+// 导入酒店公告的视图类，用于封装特定视图展示所需的数据
 import com.entity.view.NewsView;
 
-
 /**
  * 酒店公告
  *
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:04
  */
+// 定义酒店公告服务接口，继承自IService<NewsEntity>，具备对酒店公告实体的基本CRUD操作能力
 public interface NewsService extends IService<NewsEntity> {
+	// 根据传入的参数进行分页查询酒店公告数据，返回包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的酒店公告VO列表，返回一个List集合
+	List<NewsVO> selectListVO(Wrapper<NewsEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的单个酒店公告VO对象，@Param注解指定参数名为"ew"
+	NewsVO selectVO(@Param("ew") Wrapper<NewsEntity> wrapper);
 
-    PageUtils queryPage(Map<String, Object> params);
-    
-   	List<NewsVO> selectListVO(Wrapper<NewsEntity> wrapper);
-   	
-   	NewsVO selectVO(@Param("ew") Wrapper<NewsEntity> wrapper);
-   	
-   	List<NewsView> selectListView(Wrapper<NewsEntity> wrapper);
-   	
-   	NewsView selectView(@Param("ew") Wrapper<NewsEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<NewsEntity> wrapper);
-   	
+	// 根据传入的查询条件Wrapper，查询符合条件的酒店公告View列表，返回一个List集合
+	List<NewsView> selectListView(Wrapper<NewsEntity> wrapper);
 
-}
+	// 根据传入的查询条件Wrapper，查询符合条件的单个酒店公告View对象，@Param注解指定参数名为"ew"
+	NewsView selectView(@Param("ew") Wrapper<NewsEntity> wrapper);
 
+	// 根据传入的参数和查询条件Wrapper进行分页查询酒店公告数据，返回包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<NewsEntity> wrapper);
+}

back/src/main/java/com/service/RuzhuanpaiService.java

@@ -1,37 +1,51 @@
 package com.service;
+// 声明当前接口所属的包为com.service，用于组织和管理相关的类和接口
 
+// 导入MyBatis-Plus的Wrapper类，用于构建复杂的查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，提供通用的CRUD（增删改查）操作方法
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类PageUtils，用于处理分页查询结果
 import com.utils.PageUtils;
+// 导入入住安排的实体类RuzhuanpaiEntity，对应数据库中的表记录
 import com.entity.RuzhuanpaiEntity;
+// 导入List接口，用于存储多个对象的集合
 import java.util.List;
+// 导入Map接口，用于存储键值对，通常用于传递查询参数
 import java.util.Map;
+// 导入入住安排的值对象类RuzhuanpaiVO，用于封装特定视图展示所需的数据
 import com.entity.vo.RuzhuanpaiVO;
+// 导入MyBatis的@Param注解，用于在Mapper方法中指定参数名称
 import org.apache.ibatis.annotations.Param;
+// 导入入住安排的视图类RuzhuanpaiView，用于封装特定视图展示所需的数据
 import com.entity.view.RuzhuanpaiView;
 
-
 /**
  * 入住安排
  *
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:04
  */
+// 定义一个名为RuzhuanpaiService的接口，继承自IService<RuzhuanpaiEntity>
+// 表示该接口具备对RuzhuanpaiEntity实体的基本CRUD操作能力，并且可以扩展自定义的业务方法
 public interface RuzhuanpaiService extends IService<RuzhuanpaiEntity> {
 
-    PageUtils queryPage(Map<String, Object> params);
-    
-   	List<RuzhuanpaiVO> selectListVO(Wrapper<RuzhuanpaiEntity> wrapper);
-   	
-   	RuzhuanpaiVO selectVO(@Param("ew") Wrapper<RuzhuanpaiEntity> wrapper);
-   	
-   	List<RuzhuanpaiView> selectListView(Wrapper<RuzhuanpaiEntity> wrapper);
-   	
-   	RuzhuanpaiView selectView(@Param("ew") Wrapper<RuzhuanpaiEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<RuzhuanpaiEntity> wrapper);
-   	
+	// 根据传入的参数进行分页查询入住安排数据，返回包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
 
-}
+	// 根据传入的查询条件Wrapper，查询符合条件的入住安排VO列表，返回一个List集合
+	List<RuzhuanpaiVO> selectListVO(Wrapper<RuzhuanpaiEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper（参数名为"ew"），查询符合条件的单个入住安排VO对象
+	RuzhuanpaiVO selectVO(@Param("ew") Wrapper<RuzhuanpaiEntity> wrapper);
 
+	// 根据传入的查询条件Wrapper，查询符合条件的入住安排View列表，返回一个List集合
+	List<RuzhuanpaiView> selectListView(Wrapper<RuzhuanpaiEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper（参数名为"ew"），查询符合条件的单个入住安排View对象
+	RuzhuanpaiView selectView(@Param("ew") Wrapper<RuzhuanpaiEntity> wrapper);
+
+	// 根据传入的参数和查询条件Wrapper进行分页查询入住安排数据，返回包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<RuzhuanpaiEntity> wrapper);
+}

back/src/main/java/com/service/StoreupService.java

@@ -1,37 +1,48 @@
-package com.service;
+package com.service; // 声明该类所属的包为com.service，方便对代码进行模块化管理
 
+// 导入MyBatis-Plus中的Wrapper类，用于构建动态的查询条件，可灵活定制查询逻辑
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus提供的IService接口，它封装了常见的增删改查等通用操作方法
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类，用于处理分页查询的结果，方便展示数据
 import com.utils.PageUtils;
+// 导入收藏表对应的实体类，该实体类与数据库中的收藏表结构相对应
 import com.entity.StoreupEntity;
+// 导入List接口，用于存储多个对象，可用于存放查询结果集
 import java.util.List;
+// 导入Map接口，用于存储键值对，常作为查询参数的容器
 import java.util.Map;
+// 导入收藏表的值对象类，通常用于封装特定业务场景下需要展示的数据
 import com.entity.vo.StoreupVO;
+// 导入MyBatis的@Param注解，用于在Mapper方法中指定参数名称，增强代码的可读性和可维护性
 import org.apache.ibatis.annotations.Param;
+// 导入收藏表的视图类，用于封装特定视图展示所需的数据
 import com.entity.view.StoreupView;
 
-
 /**
  * 收藏表
  *
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:04
  */
+// 定义一个服务接口，继承自IService<StoreupEntity>，表明该接口具备对收藏表实体的基本操作能力
 public interface StoreupService extends IService<StoreupEntity> {
+	// 根据传入的参数进行分页查询，返回一个包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
 
-    PageUtils queryPage(Map<String, Object> params);
-    
-   	List<StoreupVO> selectListVO(Wrapper<StoreupEntity> wrapper);
-   	
-   	StoreupVO selectVO(@Param("ew") Wrapper<StoreupEntity> wrapper);
-   	
-   	List<StoreupView> selectListView(Wrapper<StoreupEntity> wrapper);
-   	
-   	StoreupView selectView(@Param("ew") Wrapper<StoreupEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<StoreupEntity> wrapper);
-   	
+	// 根据传入的查询条件Wrapper，查询出符合条件的收藏表VO列表，返回一个List集合
+	List<StoreupVO> selectListVO(Wrapper<StoreupEntity> wrapper);
 
-}
+	// 根据传入的查询条件Wrapper，查询出符合条件的单个收藏表VO对象，@Param注解指定参数名称为"ew"
+	StoreupVO selectVO(@Param("ew") Wrapper<StoreupEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询出符合条件的收藏表View列表，返回一个List集合
+	List<StoreupView> selectListView(Wrapper<StoreupEntity> wrapper);
 
+	// 根据传入的查询条件Wrapper，查询出符合条件的单个收藏表View对象，@Param注解指定参数名称为"ew"
+	StoreupView selectView(@Param("ew") Wrapper<StoreupEntity> wrapper);
+
+	// 根据传入的参数和查询条件Wrapper进行分页查询，返回一个包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<StoreupEntity> wrapper);
+}

back/src/main/java/com/service/TokenService.java

@@ -1,26 +1,43 @@
+package com.service; // 声明该类所属的包为com.service
 
-package com.service;
-
+// 导入List接口，用于存储多个对象的集合
 import java.util.List;
+// 导入Map接口，用于存储键值对，通常用于传递参数
 import java.util.Map;
 
+// 导入MyBatis-Plus的Wrapper类，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，提供通用的CRUD操作方法
 import com.baomidou.mybatisplus.service.IService;
+// 导入Token实体类，对应数据库中的token表
 import com.entity.TokenEntity;
+// 导入自定义的分页工具类，用于处理分页查询结果
 import com.utils.PageUtils;
 
-
 /**
  * token
  */
+// 定义TokenService接口，继承自IService<TokenEntity>，具备对TokenEntity的基本CRUD操作能力
 public interface TokenService extends IService<TokenEntity> {
- 	PageUtils queryPage(Map<String, Object> params);
-    
-   	List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<TokenEntity> wrapper);
-	
-   	String generateToken(Long userid,String username,String tableName, String role);
-   	
-   	TokenEntity getTokenEntity(String token);
-}
+	// 根据传入的参数进行分页查询，返回一个包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的Token实体列表，返回一个List集合
+	List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper);
+
+	// 根据传入的参数和查询条件Wrapper进行分页查询，返回一个包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<TokenEntity> wrapper);
+
+	// 根据用户ID、用户名、表名和角色生成一个token字符串
+	// 参数userid为用户的ID
+	// 参数username为用户的名称
+	// 参数tableName为相关表的名称
+	// 参数role为用户的角色
+	// 返回生成的token字符串
+	String generateToken(Long userid, String username, String tableName, String role);
+
+	// 根据传入的token字符串，查询对应的Token实体对象
+	// 参数token为要查询的token字符串
+	// 返回查询到的Token实体对象，如果未找到则可能返回null
+	TokenEntity getTokenEntity(String token);
+}

back/src/main/java/com/service/UserService.java

@@ -1,25 +1,35 @@
 
-package com.service;
+package com.service; // 声明该Java类所属的包为com.service
 
+// 导入List接口，用于存储多个对象的集合，后续会用于存储查询结果
 import java.util.List;
+// 导入Map接口，用于存储键值对，通常用于传递查询参数等
 import java.util.Map;
 
+// 导入MyBatis的@Param注解，用于在Mapper方法中指定参数名称，增强代码可读性
 import org.apache.ibatis.annotations.Param;
 
+// 导入MyBatis-Plus的Wrapper类，用于构建动态查询条件，可灵活定制查询逻辑
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，它提供了通用的CRUD（创建、读取、更新、删除）操作方法
 import com.baomidou.mybatisplus.service.IService;
+// 导入系统用户实体类，代表数据库中系统用户表的记录
 import com.entity.UserEntity;
+// 导入自定义的分页工具类，用于处理分页查询结果，方便实现分页展示数据
 import com.utils.PageUtils;
 
-
 /**
  * 系统用户
  */
+// 定义一个名为UserService的接口，继承自IService<UserEntity>
+// 这意味着该接口具备了IService提供的对UserEntity实体的基本CRUD操作能力
 public interface UserService extends IService<UserEntity> {
- 	PageUtils queryPage(Map<String, Object> params);
-    
-   	List<UserEntity> selectListView(Wrapper<UserEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<UserEntity> wrapper);
-	   	
-}
+	// 根据传入的参数进行分页查询系统用户数据，返回一个包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的系统用户实体列表，返回一个List集合
+	List<UserEntity> selectListView(Wrapper<UserEntity> wrapper);
+
+	// 根据传入的参数和查询条件Wrapper进行分页查询系统用户数据，返回一个包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<UserEntity> wrapper);
+}

back/src/main/java/com/service/YonghuService.java

@@ -1,13 +1,22 @@
-package com.service;
+package com.service; // 声明该类所属的包为com.service
 
+// 导入MyBatis-Plus的Wrapper类，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，提供通用的CRUD操作
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类
 import com.utils.PageUtils;
+// 导入用户实体类
 import com.entity.YonghuEntity;
+// 导入List接口，用于存储多个对象
 import java.util.List;
+// 导入Map接口，用于存储键值对
 import java.util.Map;
+// 导入用户值对象类
 import com.entity.vo.YonghuVO;
+// 导入MyBatis的@Param注解，用于指定参数名
 import org.apache.ibatis.annotations.Param;
+// 导入用户视图对象类
 import com.entity.view.YonghuView;
 
 /**
@@ -17,6 +26,7 @@ import com.entity.view.YonghuView;
  * @email
  * @date 2022-04-04 00:20:04
  */
+// 定义用户服务接口，继承IService<YonghuEntity>，具备基本CRUD能力
 public interface YonghuService extends IService<YonghuEntity> {
 
 	/**
@@ -25,6 +35,7 @@ public interface YonghuService extends IService<YonghuEntity> {
 	 * @param params 包含分页信息的参数映射，例如当前页码、每页记录数等。
 	 * @return 返回一个 PageUtils 对象，其中封装了分页查询的结果，方便前端进行分页展示。
 	 */
+	// 根据参数进行分页查询用户数据
 	PageUtils queryPage(Map<String, Object> params);
 
 	/**
@@ -34,6 +45,7 @@ public interface YonghuService extends IService<YonghuEntity> {
 	 * @param wrapper 包含具体查询条件的包装器，用于构建数据库查询语句的 WHERE 部分。
 	 * @return 满足条件的用户 YonghuVO 对象的列表，如果没有符合条件的数据，则返回空列表。
 	 */
+	// 根据查询条件查询用户VO列表
 	List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper);
 
 	/**
@@ -43,6 +55,7 @@ public interface YonghuService extends IService<YonghuEntity> {
 	 * @param wrapper 包含查询条件的包装器，用于精确筛选出符合条件的记录。
 	 * @return 满足条件的单个用户 YonghuVO 对象，如果没有符合条件的数据，则返回 null。
 	 */
+	// 根据查询条件查询单个用户VO对象
 	YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
 
 	/**
@@ -52,6 +65,7 @@ public interface YonghuService extends IService<YonghuEntity> {
 	 * @param wrapper 包含查询条件的包装器，用于筛选出符合要求的用户视图数据。
 	 * @return 满足条件的用户 YonghuView 对象的列表，如果没有符合条件的数据，则返回空列表。
 	 */
+	// 根据查询条件查询用户View列表
 	List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper);
 
 	/**
@@ -61,6 +75,7 @@ public interface YonghuService extends IService<YonghuEntity> {
 	 * @param wrapper 包含查询条件的包装器，用于精确筛选出符合条件的记录。
 	 * @return 满足条件的单个用户 YonghuView 对象，如果没有符合条件的数据，则返回 null。
 	 */
+	// 根据查询条件查询单个用户View对象
 	YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper);
 
 	/**
@@ -70,6 +85,6 @@ public interface YonghuService extends IService<YonghuEntity> {
 	 * @param wrapper 包含具体查询条件的包装器，用于构建数据库查询语句的 WHERE 部分。
 	 * @return 返回一个 PageUtils 对象，其中封装了分页查询的结果，方便前端进行分页展示。
 	 */
+	// 根据参数和查询条件进行分页查询用户数据
 	PageUtils queryPage(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
-}
-
+}

back/src/main/java/com/service/YuangongService.java

@@ -1,37 +1,48 @@
-package com.service;
+package com.service; // 声明该类所在的包为com.service
 
+// 导入MyBatis-Plus的Wrapper类，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的IService接口，提供通用的CRUD操作方法
 import com.baomidou.mybatisplus.service.IService;
+// 导入自定义的分页工具类，用于处理分页查询结果
 import com.utils.PageUtils;
+// 导入员工实体类，对应数据库中的员工表
 import com.entity.YuangongEntity;
+// 导入List接口，用于存储多个元素的集合
 import java.util.List;
+// 导入Map接口，用于存储键值对，可作为查询参数
 import java.util.Map;
+// 导入员工值对象类，通常用于封装特定业务场景下需要展示的数据
 import com.entity.vo.YuangongVO;
+// 导入MyBatis的@Param注解，用于在Mapper方法中指定参数名称
 import org.apache.ibatis.annotations.Param;
+// 导入员工视图类，用于封装特定视图展示所需的数据
 import com.entity.view.YuangongView;
 
-
 /**
  * 员工
  *
- * @author 
- * @email 
+ * @author
+ * @email
  * @date 2022-04-04 00:20:04
  */
+// 定义员工服务接口，继承自IService<YuangongEntity>，具备对员工实体的基本CRUD操作能力
 public interface YuangongService extends IService<YuangongEntity> {
+	// 根据传入的参数进行分页查询员工数据，返回包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的员工VO列表，返回一个List集合
+	List<YuangongVO> selectListVO(Wrapper<YuangongEntity> wrapper);
+
+	// 根据传入的查询条件Wrapper，查询符合条件的单个员工VO对象，@Param注解指定参数名为"ew"
+	YuangongVO selectVO(@Param("ew") Wrapper<YuangongEntity> wrapper);
 
-    PageUtils queryPage(Map<String, Object> params);
-    
-   	List<YuangongVO> selectListVO(Wrapper<YuangongEntity> wrapper);
-   	
-   	YuangongVO selectVO(@Param("ew") Wrapper<YuangongEntity> wrapper);
-   	
-   	List<YuangongView> selectListView(Wrapper<YuangongEntity> wrapper);
-   	
-   	YuangongView selectView(@Param("ew") Wrapper<YuangongEntity> wrapper);
-   	
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<YuangongEntity> wrapper);
-   	
+	// 根据传入的查询条件Wrapper，查询符合条件的员工View列表，返回一个List集合
+	List<YuangongView> selectListView(Wrapper<YuangongEntity> wrapper);
 
-}
+	// 根据传入的查询条件Wrapper，查询符合条件的单个员工View对象，@Param注解指定参数名为"ew"
+	YuangongView selectView(@Param("ew") Wrapper<YuangongEntity> wrapper);
 
+	// 根据传入的参数和查询条件Wrapper进行分页查询员工数据，返回包含分页信息和查询结果的PageUtils对象
+	PageUtils queryPage(Map<String, Object> params, Wrapper<YuangongEntity> wrapper);
+}

back/src/main/java/com/service/impl/CommonServiceImpl.java

@@ -1,64 +1,92 @@
 
 package com.service.impl;
 
+// 导入用于处理Java中List集合的接口，这里用于定义方法返回值或参数中涉及集合的情况
+
+
 
 import java.util.List;
+// 导入用于处理Java中Map集合的接口，在方法参数和返回值中用于传递和处理键值对数据
 import java.util.Map;
 
+// 导入Spring框架中用于自动装配Bean的注解，用于将符合条件的Bean自动注入到当前类中
 import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架中用于声明服务层组件的注解，将当前类声明为一个服务组件
 import org.springframework.stereotype.Service;
 
+// 导入自定义的CommonDao接口，该接口可能定义了与数据库交互的方法
 import com.dao.CommonDao;
+// 导入自定义的CommonService接口，当前类实现该接口以提供具体的业务逻辑实现
 import com.service.CommonService;
 
-
-/**
- * 系统用户
- */
+// 实现通用业务逻辑的服务类，这里可理解为处理与系统用户相关部分业务（从注释“系统用户”推测）
 @Service("commonService")
 public class CommonServiceImpl implements CommonService {
-	
+
+	// 自动注入CommonDao，用于执行与数据库交互的操作
 	@Autowired
 	private CommonDao commonDao;
 
+	// 根据传入的参数获取选项列表
+	// @param params 包含查询条件等信息的Map集合
+	// @return 包含选项的字符串列表
 	@Override
 	public List<String> getOption(Map<String, Object> params) {
 		return commonDao.getOption(params);
 	}
-	
+
+	// 根据选项相关参数获取相关的后续内容（具体含义需根据业务确定）
+	// @param params 包含查询条件等信息的Map集合
+	// @return 包含相关后续内容的Map集合
 	@Override
 	public Map<String, Object> getFollowByOption(Map<String, Object> params) {
 		return commonDao.getFollowByOption(params);
 	}
-	
+
+	// 执行名为“sh”的业务操作（具体业务含义需根据实际情况确定）
+	// @param params 包含操作所需参数的Map集合
 	@Override
 	public void sh(Map<String, Object> params) {
-		commonDao.sh(params); 
+		commonDao.sh(params);
 	}
 
+	// 根据参数统计提醒的数量
+	// @param params 包含统计条件等信息的Map集合
+	// @return 提醒的数量
 	@Override
 	public int remindCount(Map<String, Object> params) {
 		return commonDao.remindCount(params);
 	}
 
+	// 根据参数执行计算相关的查询操作（具体计算内容需根据业务确定）
+	// @param params 包含查询条件等信息的Map集合
+	// @return 包含计算结果的Map集合
 	@Override
 	public Map<String, Object> selectCal(Map<String, Object> params) {
 		return commonDao.selectCal(params);
 	}
-	
+
+	// 根据参数进行分组查询操作
+	// @param params 包含查询条件、分组条件等信息的Map集合
+	// @return 包含分组查询结果的Map集合列表
 	@Override
 	public List<Map<String, Object>> selectGroup(Map<String, Object> params) {
 		return commonDao.selectGroup(params);
 	}
-	
+
+	// 根据参数进行取值相关的查询操作（具体取值逻辑需根据业务确定）
+	// @param params 包含查询条件等信息的Map集合
+	// @return 包含取值查询结果的Map集合列表
 	@Override
 	public List<Map<String, Object>> selectValue(Map<String, Object> params) {
 		return commonDao.selectValue(params);
 	}
 
+	// 根据参数进行按时间统计取值的查询操作
+	// @param params 包含查询条件、时间范围等信息的Map集合
+	// @return 包含按时间统计取值查询结果的Map集合列表
 	@Override
 	public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params) {
 		return commonDao.selectTimeStatValue(params);
 	}
-
-}
+}

back/src/main/java/com/service/impl/ConfigServiceImpl.java

@@ -1,33 +1,47 @@
-
 package com.service.impl;
 
-
+// 导入用于处理键值对数据的Map接口，常用于方法参数传递和数据处理
 import java.util.Map;
 
+// 导入Spring框架中用于声明服务层组件的注解，将当前类标记为一个服务组件
 import org.springframework.stereotype.Service;
 
+// 导入MyBatis-Plus框架中用于构建实体包装器的类，可用于构建查询条件
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架中包装器的接口，是EntityWrapper等包装器类的接口
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架中用于分页的Page类，用于处理分页相关操作
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架中ServiceImpl类，提供了一些基础的服务层实现方法
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的数据访问对象接口，用于对配置数据进行数据库操作
 import com.dao.ConfigDao;
+// 导入自定义的配置实体类，用于表示配置相关的数据
 import com.entity.ConfigEntity;
+// 导入自定义的配置服务接口，当前类实现该接口以提供具体的配置业务逻辑
 import com.service.ConfigService;
+// 导入自定义的工具类，用于处理分页相关的工具方法
 import com.utils.PageUtils;
+// 导入自定义的工具类，用于构建查询相关的操作
 import com.utils.Query;
 
-
-/**
- * 系统用户
- */
+// 配置相关业务的服务实现类，这里可理解为处理与系统配置相关的业务（从注释“系统用户”推测不太准确，根据类名推测是配置相关）
 @Service("configService")
+// 当前类继承自ServiceImpl，并实现了ConfigService接口，指定了数据访问对象为ConfigDao和实体类为ConfigEntity
 public class ConfigServiceImpl extends ServiceImpl<ConfigDao, ConfigEntity> implements ConfigService {
+
+	// 根据传入的参数和包装器进行分页查询配置数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为ConfigEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
 	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<ConfigEntity> wrapper) {
+		// 使用MyBatis-Plus的selectPage方法进行分页查询，传入构建好的分页对象和查询条件包装器
 		Page<ConfigEntity> page = this.selectPage(
-                new Query<ConfigEntity>(params).getPage(),
-                wrapper
-        );
-        return new PageUtils(page);
+				new Query<ConfigEntity>(params).getPage(),
+				wrapper
+		);
+		// 将查询得到的Page对象转换为自定义的PageUtils对象并返回
+		return new PageUtils(page);
 	}
-}
+}

back/src/main/java/com/service/impl/DiscussjiudianjianjieServiceImpl.java

@@ -1,63 +1,99 @@
 package com.service.impl;
 
+// 导入Spring框架中用于声明服务层组件的注解，将当前类标记为一个服务组件
 import org.springframework.stereotype.Service;
+// 导入用于处理键值对数据的Map接口，常用于方法参数传递和数据处理
 import java.util.Map;
+// 导入用于处理一组对象的List接口，常用于方法返回值或参数中涉及集合的情况
 import java.util.List;
 
+// 导入MyBatis-Plus框架中包装器的接口，是EntityWrapper等包装器类的接口
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架中用于构建实体包装器的类，可用于构建查询条件
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架中用于分页的Page类，用于处理分页相关操作
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架中ServiceImpl类，提供了一些基础的服务层实现方法
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的工具类，用于处理分页相关的工具方法
 import com.utils.PageUtils;
+// 导入自定义的工具类，用于构建查询相关的操作
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对酒店介绍评论数据进行数据库操作
 import com.dao.DiscussjiudianjianjieDao;
+// 导入自定义的酒店介绍评论实体类，用于表示酒店介绍评论相关的数据
 import com.entity.DiscussjiudianjianjieEntity;
+// 导入自定义的酒店介绍评论服务接口，当前类实现该接口以提供具体的酒店介绍评论业务逻辑
 import com.service.DiscussjiudianjianjieService;
+// 导入自定义的酒店介绍评论值对象类，用于特定业务场景下的数据传输和展示
 import com.entity.vo.DiscussjiudianjianjieVO;
+// 导入自定义的酒店介绍评论视图类，用于展示特定格式的酒店介绍评论数据
 import com.entity.view.DiscussjiudianjianjieView;
 
+// 酒店介绍评论相关业务的服务实现类
 @Service("discussjiudianjianjieService")
+// 当前类继承自ServiceImpl，并实现了DiscussjiudianjianjieService接口，指定了数据访问对象为DiscussjiudianjianjieDao和实体类为DiscussjiudianjianjieEntity
 public class DiscussjiudianjianjieServiceImpl extends ServiceImpl<DiscussjiudianjianjieDao, DiscussjiudianjianjieEntity> implements DiscussjiudianjianjieService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<DiscussjiudianjianjieEntity> page = this.selectPage(
-                new Query<DiscussjiudianjianjieEntity>(params).getPage(),
-                new EntityWrapper<DiscussjiudianjianjieEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 根据传入的参数进行分页查询酒店介绍评论数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 使用MyBatis-Plus的selectPage方法进行分页查询，传入构建好的分页对象和默认的实体包装器
+		Page<DiscussjiudianjianjieEntity> page = this.selectPage(
+				new Query<DiscussjiudianjianjieEntity>(params).getPage(),
+				new EntityWrapper<DiscussjiudianjianjieEntity>()
+		);
+		// 将查询得到的Page对象转换为自定义的PageUtils对象并返回
+		return new PageUtils(page);
+	}
+
+	// 根据传入的参数和包装器进行分页查询酒店介绍评论视图数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为DiscussjiudianjianjieEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<DiscussjiudianjianjieEntity> wrapper) {
-		  Page<DiscussjiudianjianjieView> page =new Query<DiscussjiudianjianjieView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 获取构建好的分页对象，指定类型为DiscussjiudianjianjieView
+		Page<DiscussjiudianjianjieView> page = new Query<DiscussjiudianjianjieView>(params).getPage();
+		// 设置分页对象的记录为根据传入的包装器查询得到的结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 创建PageUtils对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 根据传入的包装器查询酒店介绍评论值对象列表的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为DiscussjiudianjianjieEntity的包装器
+	// @return 酒店介绍评论值对象列表
+	@Override
 	public List<DiscussjiudianjianjieVO> selectListVO(Wrapper<DiscussjiudianjianjieEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 根据传入的包装器查询单个酒店介绍评论值对象的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为DiscussjiudianjianjieEntity的包装器
+	// @return 酒店介绍评论值对象
 	@Override
 	public DiscussjiudianjianjieVO selectVO(Wrapper<DiscussjiudianjianjieEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 根据传入的包装器查询酒店介绍评论视图列表的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为DiscussjiudianjianjieEntity的包装器
+	// @return 酒店介绍评论视图列表
 	@Override
 	public List<DiscussjiudianjianjieView> selectListView(Wrapper<DiscussjiudianjianjieEntity> wrapper) {
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 根据传入的包装器查询单个酒店介绍评论视图的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为DiscussjiudianjianjieEntity的包装器
+	// @return 酒店介绍评论视图
 	@Override
 	public DiscussjiudianjianjieView selectView(Wrapper<DiscussjiudianjianjieEntity> wrapper) {
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/DiscussjiudiankefangServiceImpl.java

@@ -1,63 +1,92 @@
+// 声明该类所在的包，通常用于组织和管理相关的服务实现类
 package com.service.impl;
 
+// 导入Spring框架的Service注解，用于将该类标记为服务层组件
 import org.springframework.stereotype.Service;
+// 导入Java中的Map接口，用于处理键值对数据，常用于方法参数传递
 import java.util.Map;
+// 导入Java中的List接口，用于处理一组有序的数据，常用于方法返回值
 import java.util.List;
 
+// 导入MyBatis-Plus的Wrapper接口，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的EntityWrapper类，用于构建实体查询条件
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus的Page类，用于分页查询
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus的ServiceImpl类，提供了一些基础的服务层实现方法
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的PageUtils类，用于处理分页结果
 import com.utils.PageUtils;
+// 导入自定义的Query类，用于构建查询参数
 import com.utils.Query;
 
-
+// 导入酒店客房评论的数据访问对象接口
 import com.dao.DiscussjiudiankefangDao;
+// 导入酒店客房评论的实体类
 import com.entity.DiscussjiudiankefangEntity;
+// 导入酒店客房评论的服务接口
 import com.service.DiscussjiudiankefangService;
+// 导入酒店客房评论的值对象类
 import com.entity.vo.DiscussjiudiankefangVO;
+// 导入酒店客房评论的视图类
 import com.entity.view.DiscussjiudiankefangView;
 
+// 使用Service注解将该类注册为Spring的服务组件，名称为"discussjiudiankefangService"
 @Service("discussjiudiankefangService")
+// 继承ServiceImpl类，指定数据访问对象和实体类，实现酒店客房评论的服务接口
 public class DiscussjiudiankefangServiceImpl extends ServiceImpl<DiscussjiudiankefangDao, DiscussjiudiankefangEntity> implements DiscussjiudiankefangService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<DiscussjiudiankefangEntity> page = this.selectPage(
-                new Query<DiscussjiudiankefangEntity>(params).getPage(),
-                new EntityWrapper<DiscussjiudiankefangEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写查询分页方法，根据参数进行分页查询
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query类从参数中提取分页信息
+		Page<DiscussjiudiankefangEntity> page = this.selectPage(
+				new Query<DiscussjiudiankefangEntity>(params).getPage(),
+				// 创建实体包装器，用于构建查询条件
+				new EntityWrapper<DiscussjiudiankefangEntity>()
+		);
+		// 使用PageUtils类将分页结果封装返回
+		return new PageUtils(page);
+	}
+
+	// 重写查询分页方法，根据参数和查询条件进行分页查询
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<DiscussjiudiankefangEntity> wrapper) {
-		  Page<DiscussjiudiankefangView> page =new Query<DiscussjiudiankefangView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用Query类从参数中提取分页信息
+		Page<DiscussjiudiankefangView> page = new Query<DiscussjiudiankefangView>(params).getPage();
+		// 设置分页对象的记录，通过数据访问对象的selectListView方法查询
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils类将分页结果封装返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写查询列表VO的方法，根据查询条件查询酒店客房评论的值对象列表
+	@Override
 	public List<DiscussjiudiankefangVO> selectListVO(Wrapper<DiscussjiudiankefangEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的selectListVO方法进行查询
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写查询单个VO的方法，根据查询条件查询酒店客房评论的值对象
 	@Override
 	public DiscussjiudiankefangVO selectVO(Wrapper<DiscussjiudiankefangEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的selectVO方法进行查询
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写查询列表视图的方法，根据查询条件查询酒店客房评论的视图列表
 	@Override
 	public List<DiscussjiudiankefangView> selectListView(Wrapper<DiscussjiudiankefangEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法进行查询
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写查询单个视图的方法，根据查询条件查询酒店客房评论的视图
 	@Override
 	public DiscussjiudiankefangView selectView(Wrapper<DiscussjiudiankefangEntity> wrapper) {
+		// 调用数据访问对象的selectView方法进行查询
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/JiudianjianjieServiceImpl.java

@@ -1,63 +1,92 @@
+// 定义类所在的包，通常用于组织服务实现类
 package com.service.impl;
 
+// 引入Spring的Service注解，将该类标记为服务层组件
 import org.springframework.stereotype.Service;
+// 引入Java的Map接口，用于处理键值对数据，常作为方法参数
 import java.util.Map;
+// 引入Java的List接口，用于处理有序集合数据，常作为方法返回值
 import java.util.List;
 
+// 引入MyBatis-Plus的Wrapper接口，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 引入MyBatis-Plus的EntityWrapper类，用于创建实体查询条件
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 引入MyBatis-Plus的Page类，用于分页查询
 import com.baomidou.mybatisplus.plugins.Page;
+// 引入MyBatis-Plus的ServiceImpl类，提供基础的服务层实现
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 引入自定义的PageUtils类，用于处理分页结果
 import com.utils.PageUtils;
+// 引入自定义的Query类，用于构建查询参数
 import com.utils.Query;
 
-
+// 引入酒店介绍的数据访问对象接口
 import com.dao.JiudianjianjieDao;
+// 引入酒店介绍的实体类
 import com.entity.JiudianjianjieEntity;
+// 引入酒店介绍的服务接口
 import com.service.JiudianjianjieService;
+// 引入酒店介绍的值对象类
 import com.entity.vo.JiudianjianjieVO;
+// 引入酒店介绍的视图类
 import com.entity.view.JiudianjianjieView;
 
+// 使用Service注解将该类注册为Spring服务，名称为"jiudianjianjieService"
 @Service("jiudianjianjieService")
+// 继承ServiceImpl类，指定数据访问对象和实体类，实现酒店介绍服务接口
 public class JiudianjianjieServiceImpl extends ServiceImpl<JiudianjianjieDao, JiudianjianjieEntity> implements JiudianjianjieService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<JiudianjianjieEntity> page = this.selectPage(
-                new Query<JiudianjianjieEntity>(params).getPage(),
-                new EntityWrapper<JiudianjianjieEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写查询分页方法，根据参数进行分页查询
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，从参数中提取分页信息
+		Page<JiudianjianjieEntity> page = this.selectPage(
+				new Query<JiudianjianjieEntity>(params).getPage(),
+				// 创建实体查询条件包装器
+				new EntityWrapper<JiudianjianjieEntity>()
+		);
+		// 封装分页结果并返回
+		return new PageUtils(page);
+	}
+
+	// 重写查询分页方法，根据参数和查询条件进行分页查询
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<JiudianjianjieEntity> wrapper) {
-		  Page<JiudianjianjieView> page =new Query<JiudianjianjieView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，从参数中提取分页信息
+		Page<JiudianjianjieView> page = new Query<JiudianjianjieView>(params).getPage();
+		// 设置分页对象的记录，通过数据访问对象查询
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 封装分页结果并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写查询列表VO的方法，根据查询条件查询酒店介绍值对象列表
+	@Override
 	public List<JiudianjianjieVO> selectListVO(Wrapper<JiudianjianjieEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的方法查询列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写查询单个VO的方法，根据查询条件查询酒店介绍值对象
 	@Override
 	public JiudianjianjieVO selectVO(Wrapper<JiudianjianjieEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的方法查询单个对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写查询列表视图的方法，根据查询条件查询酒店介绍视图列表
 	@Override
 	public List<JiudianjianjieView> selectListView(Wrapper<JiudianjianjieEntity> wrapper) {
+		// 调用数据访问对象的方法查询列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写查询单个视图的方法，根据查询条件查询酒店介绍视图
 	@Override
 	public JiudianjianjieView selectView(Wrapper<JiudianjianjieEntity> wrapper) {
+		// 调用数据访问对象的方法查询单个对象
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/JiudiankefangServiceImpl.java

@@ -1,63 +1,92 @@
+// 声明该类所属的包，用于组织和管理服务实现类
 package com.service.impl;
 
+// 导入Spring框架的Service注解，用于将该类标记为服务层组件
 import org.springframework.stereotype.Service;
+// 导入Java的Map接口，用于处理键值对数据，常用于方法参数传递
 import java.util.Map;
+// 导入Java的List接口，用于处理有序集合数据，常用于方法返回值
 import java.util.List;
 
+// 导入MyBatis-Plus的Wrapper接口，用于构建查询条件
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的EntityWrapper类，用于创建实体的查询条件包装器
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus的Page类，用于处理分页查询
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus的ServiceImpl类，提供基础的服务层实现方法
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的PageUtils类，用于处理分页结果的工具类
 import com.utils.PageUtils;
+// 导入自定义的Query类，用于从参数中提取分页信息
 import com.utils.Query;
 
-
+// 导入酒店客房的数据访问对象接口
 import com.dao.JiudiankefangDao;
+// 导入酒店客房的实体类
 import com.entity.JiudiankefangEntity;
+// 导入酒店客房的服务接口
 import com.service.JiudiankefangService;
+// 导入酒店客房的值对象类，用于特定业务场景下的数据传输
 import com.entity.vo.JiudiankefangVO;
+// 导入酒店客房的视图类，用于展示特定格式的数据
 import com.entity.view.JiudiankefangView;
 
+// 使用Service注解将该类注册为Spring服务组件，名称为"jiudiankefangService"
 @Service("jiudiankefangService")
+// 继承ServiceImpl类，指定数据访问对象和实体类，实现酒店客房服务接口
 public class JiudiankefangServiceImpl extends ServiceImpl<JiudiankefangDao, JiudiankefangEntity> implements JiudiankefangService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<JiudiankefangEntity> page = this.selectPage(
-                new Query<JiudiankefangEntity>(params).getPage(),
-                new EntityWrapper<JiudiankefangEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写查询分页方法，根据传入的参数进行分页查询
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，从参数中提取分页信息
+		Page<JiudiankefangEntity> page = this.selectPage(
+				new Query<JiudiankefangEntity>(params).getPage(),
+				// 创建实体查询条件包装器
+				new EntityWrapper<JiudiankefangEntity>()
+		);
+		// 使用PageUtils类封装分页结果并返回
+		return new PageUtils(page);
+	}
+
+	// 重写查询分页方法，根据传入的参数和查询条件进行分页查询
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<JiudiankefangEntity> wrapper) {
-		  Page<JiudiankefangView> page =new Query<JiudiankefangView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，从参数中提取分页信息，指定为视图类的分页
+		Page<JiudiankefangView> page = new Query<JiudiankefangView>(params).getPage();
+		// 设置分页对象的记录，通过数据访问对象的方法查询
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils类封装分页结果并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写查询值对象列表的方法，根据查询条件查询酒店客房值对象列表
+	@Override
 	public List<JiudiankefangVO> selectListVO(Wrapper<JiudiankefangEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的方法查询列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写查询单个值对象的方法，根据查询条件查询酒店客房值对象
 	@Override
 	public JiudiankefangVO selectVO(Wrapper<JiudiankefangEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的方法查询单个对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写查询视图列表的方法，根据查询条件查询酒店客房视图列表
 	@Override
 	public List<JiudiankefangView> selectListView(Wrapper<JiudiankefangEntity> wrapper) {
+		// 调用数据访问对象的方法查询列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写查询单个视图的方法，根据查询条件查询酒店客房视图
 	@Override
 	public JiudiankefangView selectView(Wrapper<JiudiankefangEntity> wrapper) {
+		// 调用数据访问对象的方法查询单个对象
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/KefangleixingServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所属的包，通常用于组织服务实现类，这里表明该类在com.service.impl包下
 package com.service.impl;
 
+// 导入Spring框架的Service注解，用于将该类标记为一个服务组件，使其能被Spring容器管理
 import org.springframework.stereotype.Service;
+// 导入Java中的Map接口，用于处理键值对数据，常用于方法参数传递和数据存储等场景
 import java.util.Map;
+// 导入Java中的List接口，用于处理一组有序的数据集合，常用于方法的返回值或参数中
 import java.util.List;
 
+// 导入MyBatis-Plus框架中的Wrapper接口，用于构建查询条件的包装器
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架中的EntityWrapper类，用于创建基于实体类的查询条件包装器
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架中的Page类，用于处理分页查询，存储分页相关的数据
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架中的ServiceImpl类，提供了基础的服务层实现方法和通用功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的PageUtils工具类，用于处理分页结果，将MyBatis-Plus的Page对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的Query工具类，用于从参数Map中构建分页查询所需的参数和Page对象
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对客房类型数据进行数据库操作
 import com.dao.KefangleixingDao;
+// 导入自定义的客房类型实体类，用于表示数据库中客房类型表的记录
 import com.entity.KefangleixingEntity;
+// 导入自定义的客房类型服务接口，当前类实现该接口以提供具体的客房类型业务逻辑
 import com.service.KefangleixingService;
+// 导入自定义的客房类型值对象类，用于在特定业务场景下传输和处理客房类型相关的数据
 import com.entity.vo.KefangleixingVO;
+// 导入自定义的客房类型视图类，用于以特定的视图形式展示客房类型相关的数据
 import com.entity.view.KefangleixingView;
 
+// 使用Service注解将该类注册为Spring的服务组件，服务名称为"kefangleixingService"
 @Service("kefangleixingService")
+// 继承ServiceImpl类，并指定数据访问对象为KefangleixingDao和实体类为KefangleixingEntity，实现KefangleixingService接口
 public class KefangleixingServiceImpl extends ServiceImpl<KefangleixingDao, KefangleixingEntity> implements KefangleixingService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<KefangleixingEntity> page = this.selectPage(
-                new Query<KefangleixingEntity>(params).getPage(),
-                new EntityWrapper<KefangleixingEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写queryPage方法，根据传入的参数进行分页查询客房类型实体数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
+		Page<KefangleixingEntity> page = this.selectPage(
+				new Query<KefangleixingEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<KefangleixingEntity>()
+		);
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
+	}
+
+	// 重写queryPage方法，根据传入的参数和查询条件进行分页查询客房类型视图数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangleixingEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<KefangleixingEntity> wrapper) {
-		  Page<KefangleixingView> page =new Query<KefangleixingView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为KefangleixingView
+		Page<KefangleixingView> page = new Query<KefangleixingView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写selectListVO方法，根据传入的查询条件查询客房类型值对象列表
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangleixingEntity的包装器
+	// @return 包含客房类型值对象的List集合
+	@Override
 	public List<KefangleixingVO> selectListVO(Wrapper<KefangleixingEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的selectListVO方法，传入查询条件包装器，获取客房类型值对象列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写selectVO方法，根据传入的查询条件查询单个客房类型值对象
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangleixingEntity的包装器
+	// @return 单个客房类型值对象
 	@Override
 	public KefangleixingVO selectVO(Wrapper<KefangleixingEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的selectVO方法，传入查询条件包装器，获取单个客房类型值对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写selectListView方法，根据传入的查询条件查询客房类型视图列表
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangleixingEntity的包装器
+	// @return 包含客房类型视图的List集合
 	@Override
 	public List<KefangleixingView> selectListView(Wrapper<KefangleixingEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，传入查询条件包装器，获取客房类型视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写selectView方法，根据传入的查询条件查询单个客房类型视图
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangleixingEntity的包装器
+	// @return 单个客房类型视图
 	@Override
 	public KefangleixingView selectView(Wrapper<KefangleixingEntity> wrapper) {
+		// 调用数据访问对象的selectView方法，传入查询条件包装器，获取单个客房类型视图
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/KefangyudingServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所属的包，通常用于组织和管理服务实现类相关代码
 package com.service.impl;
 
+// 导入Spring框架的Service注解，用于将当前类标记为一个服务组件，使其能被Spring容器管理和识别
 import org.springframework.stereotype.Service;
+// 导入Java标准库中的Map接口，用于处理键值对形式的数据，常用于方法参数传递等场景
 import java.util.Map;
+// 导入Java标准库中的List接口，用于处理一组有序的对象集合，常用于方法的返回值或参数中
 import java.util.List;
 
+// 导入MyBatis-Plus框架的Wrapper接口，它是构建查询条件的基础接口
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架的EntityWrapper类，用于创建基于实体类的查询条件包装器
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架的Page类，用于处理分页查询相关的数据和操作
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架的ServiceImpl类，提供了基础的服务层实现方法和功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的PageUtils工具类，用于将MyBatis-Plus的Page对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的Query工具类，用于构建查询参数和获取分页的Page对象
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对客房预订数据进行数据库操作
 import com.dao.KefangyudingDao;
+// 导入自定义的客房预订实体类，用于表示数据库中客房预订表的记录
 import com.entity.KefangyudingEntity;
+// 导入自定义的客房预订服务接口，当前类实现该接口以提供具体的客房预订业务逻辑
 import com.service.KefangyudingService;
+// 导入自定义的客房预订值对象类，用于在业务逻辑中传输和处理特定格式的客房预订数据
 import com.entity.vo.KefangyudingVO;
+// 导入自定义的客房预订视图类，用于以特定的视图形式展示客房预订相关的数据
 import com.entity.view.KefangyudingView;
 
+// 使用Service注解将该类注册为Spring的服务组件，服务名称为"kefangyudingService"
 @Service("kefangyudingService")
+// 继承ServiceImpl类，并指定数据访问对象为KefangyudingDao和实体类为KefangyudingEntity，实现KefangyudingService接口
 public class KefangyudingServiceImpl extends ServiceImpl<KefangyudingDao, KefangyudingEntity> implements KefangyudingService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<KefangyudingEntity> page = this.selectPage(
-                new Query<KefangyudingEntity>(params).getPage(),
-                new EntityWrapper<KefangyudingEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写queryPage方法，根据传入的参数进行分页查询客房预订实体数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
+		Page<KefangyudingEntity> page = this.selectPage(
+				new Query<KefangyudingEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<KefangyudingEntity>()
+		);
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
+	}
+
+	// 重写queryPage方法，根据传入的参数和查询条件进行分页查询客房预订视图数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangyudingEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<KefangyudingEntity> wrapper) {
-		  Page<KefangyudingView> page =new Query<KefangyudingView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为KefangyudingView
+		Page<KefangyudingView> page = new Query<KefangyudingView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写selectListVO方法，根据传入的查询条件查询客房预订值对象列表
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangyudingEntity的包装器
+	// @return 包含客房预订值对象的List集合
+	@Override
 	public List<KefangyudingVO> selectListVO(Wrapper<KefangyudingEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的selectListVO方法，传入查询条件包装器，获取客房预订值对象列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写selectVO方法，根据传入的查询条件查询单个客房预订值对象
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangyudingEntity的包装器
+	// @return 单个客房预订值对象
 	@Override
 	public KefangyudingVO selectVO(Wrapper<KefangyudingEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的selectVO方法，传入查询条件包装器，获取单个客房预订值对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写selectListView方法，根据传入的查询条件查询客房预订视图列表
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangyudingEntity的包装器
+	// @return 包含客房预订视图的List集合
 	@Override
 	public List<KefangyudingView> selectListView(Wrapper<KefangyudingEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，传入查询条件包装器，获取客房预订视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写selectView方法，根据传入的查询条件查询单个客房预订视图
+	// @param wrapper 用于构建查询条件的包装器，类型为KefangyudingEntity的包装器
+	// @return 单个客房预订视图
 	@Override
 	public KefangyudingView selectView(Wrapper<KefangyudingEntity> wrapper) {
+		// 调用数据访问对象的selectView方法，传入查询条件包装器，获取单个客房预订视图
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/NewsServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所在的包为com.service.impl，通常用于组织服务实现类
 package com.service.impl;
 
+// 导入Spring框架中用于声明服务层组件的注解，将当前类标记为一个服务组件
 import org.springframework.stereotype.Service;
+// 导入Java标准库中的Map接口，用于处理键值对数据，常用于方法参数传递
 import java.util.Map;
+// 导入Java标准库中的List接口，用于处理一组有序的数据，常用于方法返回值
 import java.util.List;
 
+// 导入MyBatis-Plus框架中用于构建查询条件的包装器接口
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架中用于构建实体包装器的类，可用于构建实体相关的查询条件
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架中用于分页的Page类，用于处理分页查询操作
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架中提供基础服务层实现的ServiceImpl类
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的工具类，用于处理分页结果，将MyBatis-Plus的Page对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的工具类，用于构建查询相关的操作，如分页参数的处理等
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对新闻数据进行数据库操作
 import com.dao.NewsDao;
+// 导入自定义的新闻实体类，用于表示数据库中新闻表的记录
 import com.entity.NewsEntity;
+// 导入自定义的新闻服务接口，当前类实现该接口以提供具体的新闻业务逻辑
 import com.service.NewsService;
+// 导入自定义的新闻值对象类，用于在特定业务场景下传输和处理新闻相关的数据
 import com.entity.vo.NewsVO;
+// 导入自定义的新闻视图类，用于以特定的格式展示新闻相关的数据
 import com.entity.view.NewsView;
 
+// 使用Service注解将该类注册为Spring的服务组件，名称为"newsService"
 @Service("newsService")
+// 当前类继承自ServiceImpl，并实现了NewsService接口，指定了数据访问对象为NewsDao和实体类为NewsEntity
 public class NewsServiceImpl extends ServiceImpl<NewsDao, NewsEntity> implements NewsService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<NewsEntity> page = this.selectPage(
-                new Query<NewsEntity>(params).getPage(),
-                new EntityWrapper<NewsEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 根据传入的参数进行分页查询新闻实体数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中提取分页信息
+		Page<NewsEntity> page = this.selectPage(
+				new Query<NewsEntity>(params).getPage(),
+				// 创建一个空的实体包装器，用于查询所有符合条件的新闻实体（未添加具体条件）
+				new EntityWrapper<NewsEntity>()
+		);
+		// 将查询得到的Page对象转换为自定义的PageUtils对象并返回
+		return new PageUtils(page);
+	}
+
+	// 根据传入的参数和包装器进行分页查询新闻视图数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为NewsEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<NewsEntity> wrapper) {
-		  Page<NewsView> page =new Query<NewsView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用Query工具类从参数中提取分页信息，指定类型为NewsView
+		Page<NewsView> page = new Query<NewsView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法查询
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 创建PageUtils对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 根据传入的包装器查询新闻值对象列表的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为NewsEntity的包装器
+	// @return 新闻值对象列表
+	@Override
 	public List<NewsVO> selectListVO(Wrapper<NewsEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的selectListVO方法查询
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 根据传入的包装器查询单个新闻值对象的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为NewsEntity的包装器
+	// @return 单个新闻值对象
 	@Override
 	public NewsVO selectVO(Wrapper<NewsEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的selectVO方法查询
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 根据传入的包装器查询新闻视图列表的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为NewsEntity的包装器
+	// @return 新闻视图列表
 	@Override
 	public List<NewsView> selectListView(Wrapper<NewsEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法查询
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 根据传入的包装器查询单个新闻视图的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为NewsEntity的包装器
+	// @return 单个新闻视图
 	@Override
 	public NewsView selectView(Wrapper<NewsEntity> wrapper) {
+		// 调用数据访问对象的selectView方法查询
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/RuzhuanpaiServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所属的包，用于组织和管理服务实现类，这里是 com.service.impl 包
 package com.service.impl;
 
+// 导入 Spring 框架的 Service 注解，用于将当前类标记为一个服务组件，使其能被 Spring 容器管理
 import org.springframework.stereotype.Service;
+// 导入 Java 标准库中的 Map 接口，用于处理键值对数据，常用于方法参数传递等场景
 import java.util.Map;
+// 导入 Java 标准库中的 List 接口，用于处理一组有序的对象集合，常用于方法的返回值或参数中
 import java.util.List;
 
+// 导入 MyBatis-Plus 框架的 Wrapper 接口，用于构建查询条件的包装器
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入 MyBatis-Plus 框架的 EntityWrapper 类，用于创建基于实体类的查询条件包装器
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入 MyBatis-Plus 框架的 Page 类，用于处理分页查询，存储分页相关的数据
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入 MyBatis-Plus 框架的 ServiceImpl 类，提供了基础的服务层实现方法和通用功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的 PageUtils 工具类，用于处理分页结果，将 MyBatis-Plus 的 Page 对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的 Query 工具类，用于从参数 Map 中构建分页查询所需的参数和 Page 对象
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对如转派（根据类名推测）相关数据进行数据库操作
 import com.dao.RuzhuanpaiDao;
+// 导入自定义的如转派实体类，用于表示数据库中如转派表的记录
 import com.entity.RuzhuanpaiEntity;
+// 导入自定义的如转派服务接口，当前类实现该接口以提供具体的如转派业务逻辑
 import com.service.RuzhuanpaiService;
+// 导入自定义的如转派值对象类，用于在特定业务场景下传输和处理如转派相关的数据
 import com.entity.vo.RuzhuanpaiVO;
+// 导入自定义的如转派视图类，用于以特定的视图形式展示如转派相关的数据
 import com.entity.view.RuzhuanpaiView;
 
+// 使用 Service 注解将该类注册为 Spring 的服务组件，服务名称为 "ruzhuanpaiService"
 @Service("ruzhuanpaiService")
+// 继承 ServiceImpl 类，并指定数据访问对象为 RuzhuanpaiDao 和实体类为 RuzhuanpaiEntity，实现 RuzhuanpaiService 接口
 public class RuzhuanpaiServiceImpl extends ServiceImpl<RuzhuanpaiDao, RuzhuanpaiEntity> implements RuzhuanpaiService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<RuzhuanpaiEntity> page = this.selectPage(
-                new Query<RuzhuanpaiEntity>(params).getPage(),
-                new EntityWrapper<RuzhuanpaiEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写 queryPage 方法，根据传入的参数进行分页查询如转派实体数据
+	// @param params 包含查询条件、分页参数等信息的 Map 集合
+	// @return PageUtils 对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用 Query 工具类从参数中构建分页参数并获取 Page 对象
+		Page<RuzhuanpaiEntity> page = this.selectPage(
+				new Query<RuzhuanpaiEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<RuzhuanpaiEntity>()
+		);
+		// 使用 PageUtils 工具类将 MyBatis-Plus 的 Page 对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
+	}
+
+	// 重写 queryPage 方法，根据传入的参数和查询条件进行分页查询如转派视图数据
+	// @param params 包含查询条件、分页参数等信息的 Map 集合
+	// @param wrapper 用于构建查询条件的包装器，类型为 RuzhuanpaiEntity 的包装器
+	// @return PageUtils 对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<RuzhuanpaiEntity> wrapper) {
-		  Page<RuzhuanpaiView> page =new Query<RuzhuanpaiView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用 Query 工具类从参数中构建分页参数并获取 Page 对象，指定类型为 RuzhuanpaiView
+		Page<RuzhuanpaiView> page = new Query<RuzhuanpaiView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的 selectListView 方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用 PageUtils 工具类将 MyBatis-Plus 的 Page 对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写 selectListVO 方法，根据传入的查询条件查询如转派值对象列表
+	// @param wrapper 用于构建查询条件的包装器，类型为 RuzhuanpaiEntity 的包装器
+	// @return 包含如转派值对象的 List 集合
+	@Override
 	public List<RuzhuanpaiVO> selectListVO(Wrapper<RuzhuanpaiEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的 selectListVO 方法，传入查询条件包装器，获取如转派值对象列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写 selectVO 方法，根据传入的查询条件查询单个如转派值对象
+	// @param wrapper 用于构建查询条件的包装器，类型为 RuzhuanpaiEntity 的包装器
+	// @return 单个如转派值对象
 	@Override
 	public RuzhuanpaiVO selectVO(Wrapper<RuzhuanpaiEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的 selectVO 方法，传入查询条件包装器，获取单个如转派值对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写 selectListView 方法，根据传入的查询条件查询如转派视图列表
+	// @param wrapper 用于构建查询条件的包装器，类型为 RuzhuanpaiEntity 的包装器
+	// @return 包含如转派视图的 List 集合
 	@Override
 	public List<RuzhuanpaiView> selectListView(Wrapper<RuzhuanpaiEntity> wrapper) {
+		// 调用数据访问对象的 selectListView 方法，传入查询条件包装器，获取如转派视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写 selectView 方法，根据传入的查询条件查询单个如转派视图
+	// @param wrapper 用于构建查询条件的包装器，类型为 RuzhuanpaiEntity 的包装器
+	// @return 单个如转派视图
 	@Override
 	public RuzhuanpaiView selectView(Wrapper<RuzhuanpaiEntity> wrapper) {
+		// 调用数据访问对象的 selectView 方法，传入查询条件包装器，获取单个如转派视图
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/StoreupServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所属的包，用于组织和管理服务实现类相关代码
 package com.service.impl;
 
+// 导入Spring框架的Service注解，将当前类标记为服务层组件，使其可被Spring容器管理
 import org.springframework.stereotype.Service;
+// 导入Java标准库中的Map接口，用于处理键值对数据，常用于方法参数传递等场景
 import java.util.Map;
+// 导入Java标准库中的List接口，用于处理一组有序的数据集合，常用于方法的返回值或参数中
 import java.util.List;
 
+// 导入MyBatis-Plus框架的Wrapper接口，是构建查询条件包装器的基础接口
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架的EntityWrapper类，用于创建基于实体类的查询条件包装器
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架的Page类，用于处理分页查询，存储分页相关的数据
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架的ServiceImpl类，提供基础的服务层实现方法和功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的PageUtils工具类，用于将MyBatis-Plus的Page对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的Query工具类，用于从参数Map中构建分页查询所需的参数和Page对象
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对收藏（根据类名推测）相关数据进行数据库操作
 import com.dao.StoreupDao;
+// 导入自定义的收藏实体类，用于表示数据库中收藏表的记录
 import com.entity.StoreupEntity;
+// 导入自定义的收藏服务接口，当前类实现该接口以提供具体的收藏业务逻辑
 import com.service.StoreupService;
+// 导入自定义的收藏值对象类，用于在特定业务场景下传输和处理收藏相关的数据
 import com.entity.vo.StoreupVO;
+// 导入自定义的收藏视图类，用于以特定的视图形式展示收藏相关的数据
 import com.entity.view.StoreupView;
 
+// 使用Service注解将该类注册为Spring的服务组件，服务名称为"storeupService"
 @Service("storeupService")
+// 继承ServiceImpl类，并指定数据访问对象为StoreupDao和实体类为StoreupEntity，实现StoreupService接口
 public class StoreupServiceImpl extends ServiceImpl<StoreupDao, StoreupEntity> implements StoreupService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<StoreupEntity> page = this.selectPage(
-                new Query<StoreupEntity>(params).getPage(),
-                new EntityWrapper<StoreupEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写queryPage方法，根据传入的参数进行分页查询收藏实体数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
+		Page<StoreupEntity> page = this.selectPage(
+				new Query<StoreupEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<StoreupEntity>()
+		);
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
+	}
+
+	// 重写queryPage方法，根据传入的参数和查询条件进行分页查询收藏视图数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为StoreupEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<StoreupEntity> wrapper) {
-		  Page<StoreupView> page =new Query<StoreupView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为StoreupView
+		Page<StoreupView> page = new Query<StoreupView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写selectListVO方法，根据传入的查询条件查询收藏值对象列表
+	// @param wrapper 用于构建查询条件的包装器，类型为StoreupEntity的包装器
+	// @return 包含收藏值对象的List集合
+	@Override
 	public List<StoreupVO> selectListVO(Wrapper<StoreupEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的selectListVO方法，传入查询条件包装器，获取收藏值对象列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写selectVO方法，根据传入的查询条件查询单个收藏值对象
+	// @param wrapper 用于构建查询条件的包装器，类型为StoreupEntity的包装器
+	// @return 单个收藏值对象
 	@Override
 	public StoreupVO selectVO(Wrapper<StoreupEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的selectVO方法，传入查询条件包装器，获取单个收藏值对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写selectListView方法，根据传入的查询条件查询收藏视图列表
+	// @param wrapper 用于构建查询条件的包装器，类型为StoreupEntity的包装器
+	// @return 包含收藏视图的List集合
 	@Override
 	public List<StoreupView> selectListView(Wrapper<StoreupEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，传入查询条件包装器，获取收藏视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写selectView方法，根据传入的查询条件查询单个收藏视图
+	// @param wrapper 用于构建查询条件的包装器，类型为StoreupEntity的包装器
+	// @return 单个收藏视图
 	@Override
 	public StoreupView selectView(Wrapper<StoreupEntity> wrapper) {
+		// 调用数据访问对象的selectView方法，传入查询条件包装器，获取单个收藏视图
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/service/impl/TokenServiceImpl.java

@@ -1,7 +1,5 @@
-
 package com.service.impl;
 
-
 import java.util.Calendar;
 import java.util.Date;
 import java.util.List;
@@ -15,65 +13,101 @@ import com.baomidou.mybatisplus.plugins.Page;
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
 import com.dao.TokenDao;
 import com.entity.TokenEntity;
-import com.entity.TokenEntity;
 import com.service.TokenService;
 import com.utils.CommonUtil;
 import com.utils.PageUtils;
 import com.utils.Query;
 
-
 /**
- * token
+ * 处理token相关业务逻辑的服务实现类
  */
 @Service("tokenService")
+// 继承ServiceImpl类，指定数据访问对象为TokenDao和实体类为TokenEntity，实现TokenService接口
 public class TokenServiceImpl extends ServiceImpl<TokenDao, TokenEntity> implements TokenService {
 
+	// 根据传入的参数进行分页查询Token实体数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
 	@Override
 	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
 		Page<TokenEntity> page = this.selectPage(
-                new Query<TokenEntity>(params).getPage(),
-                new EntityWrapper<TokenEntity>()
-        );
-        return new PageUtils(page);
+				new Query<TokenEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<TokenEntity>()
+		);
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
 	}
 
+	// 根据传入的查询条件包装器查询Token实体视图列表的方法
+	// @param wrapper 用于构建查询条件的包装器，类型为TokenEntity的包装器
+	// @return 包含Token实体视图的List集合
 	@Override
 	public List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，传入查询条件包装器，获取Token实体视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 根据传入的参数和查询条件进行分页查询Token实体数据的方法
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为TokenEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
 	@Override
 	public PageUtils queryPage(Map<String, Object> params,
-			Wrapper<TokenEntity> wrapper) {
-		 Page<TokenEntity> page =new Query<TokenEntity>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
+							   Wrapper<TokenEntity> wrapper) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
+		Page<TokenEntity> page = new Query<TokenEntity>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
 	}
 
+	// 生成Token的方法，根据用户ID、用户名、表名和角色生成并处理Token相关信息
+	// @param userid 用户ID
+	// @param username 用户名
+	// @param tableName 表名
+	// @param role 角色
+	// @return 生成的Token字符串
 	@Override
-	public String generateToken(Long userid,String username, String tableName, String role) {
+	public String generateToken(Long userid, String username, String tableName, String role) {
+		// 根据用户ID和角色查询Token实体，判断是否已存在对应的Token记录
 		TokenEntity tokenEntity = this.selectOne(new EntityWrapper<TokenEntity>().eq("userid", userid).eq("role", role));
+		// 生成32位的随机字符串作为Token
 		String token = CommonUtil.getRandomString(32);
-		Calendar cal = Calendar.getInstance();   
-    	cal.setTime(new Date());   
-    	cal.add(Calendar.HOUR_OF_DAY, 1);
-		if(tokenEntity!=null) {
+		// 获取当前时间的日历对象
+		Calendar cal = Calendar.getInstance();
+		// 设置日历的时间为当前时间
+		cal.setTime(new Date());
+		// 将时间增加1小时，设置Token的过期时间
+		cal.add(Calendar.HOUR_OF_DAY, 1);
+		// 如果Token实体已存在，则更新其Token和过期时间
+		if (tokenEntity != null) {
 			tokenEntity.setToken(token);
 			tokenEntity.setExpiratedtime(cal.getTime());
 			this.updateById(tokenEntity);
 		} else {
-			this.insert(new TokenEntity(userid,username, tableName, role, token, cal.getTime()));
+			// 如果Token实体不存在，则插入一条新的Token记录
+			this.insert(new TokenEntity(userid, username, tableName, role, token, cal.getTime()));
 		}
+		// 返回生成的Token
 		return token;
 	}
 
+	// 根据Token获取Token实体的方法，并检查Token是否过期
+	// @param token Token字符串
+	// @return TokenEntity对象，如果Token无效或已过期则返回null
 	@Override
 	public TokenEntity getTokenEntity(String token) {
+		// 根据Token查询Token实体
 		TokenEntity tokenEntity = this.selectOne(new EntityWrapper<TokenEntity>().eq("token", token));
-		if(tokenEntity == null || tokenEntity.getExpiratedtime().getTime()<new Date().getTime()) {
+		// 如果Token实体不存在或者Token已过期（过期时间早于当前时间），则返回null
+		if (tokenEntity == null || tokenEntity.getExpiratedtime().getTime() < new Date().getTime()) {
 			return null;
 		}
+		// 返回有效的Token实体
 		return tokenEntity;
 	}
-}
+}

back/src/main/java/com/service/impl/UserServiceImpl.java

@@ -1,49 +1,83 @@
-
+// 声明该类所在的包，通常用于组织服务实现类
 package com.service.impl;
 
-
+// 导入用于存储和操作列表的List接口
 import java.util.List;
+// 导入用于存储键值对的Map接口
 import java.util.Map;
 
+// 导入Spring的Service注解，用于将该类标记为服务层组件
 import org.springframework.stereotype.Service;
 
+// 导入MyBatis-Plus的EntityWrapper类，用于构建实体查询条件
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus的Wrapper接口，是构建查询条件的基础接口
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus的Page类，用于处理分页查询
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus的ServiceImpl类，提供基础的服务层实现功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入用户数据访问对象接口，用于与数据库交互
 import com.dao.UserDao;
+// 导入用户实体类，用于表示数据库中的用户记录
 import com.entity.UserEntity;
+// 导入用户服务接口，该类将实现此接口的方法
 import com.service.UserService;
+// 导入自定义的分页工具类，用于封装分页查询结果
 import com.utils.PageUtils;
+// 导入自定义的查询工具类，用于从参数中构建查询条件和分页信息
 import com.utils.Query;
 
-
 /**
- * 系统用户
+ * 系统用户服务实现类，处理系统用户相关的业务逻辑
  */
 @Service("userService")
+// 继承ServiceImpl类并实现UserService接口
 public class UserServiceImpl extends ServiceImpl<UserDao, UserEntity> implements UserService {
 
+	/**
+	 * 根据传入的参数进行分页查询用户实体数据
+	 * @param params 包含查询条件、分页参数等信息的Map集合
+	 * @return PageUtils对象，包含分页查询结果的相关信息
+	 */
 	@Override
 	public PageUtils queryPage(Map<String, Object> params) {
+		// 使用Query工具类从参数中构建分页信息，获取Page对象
 		Page<UserEntity> page = this.selectPage(
-                new Query<UserEntity>(params).getPage(),
-                new EntityWrapper<UserEntity>()
-        );
-        return new PageUtils(page);
+				new Query<UserEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，查询所有用户记录
+				new EntityWrapper<UserEntity>()
+		);
+		// 使用PageUtils工具类封装分页查询结果
+		return new PageUtils(page);
 	}
 
+	/**
+	 * 根据传入的查询条件包装器查询用户实体列表
+	 * @param wrapper 用于构建查询条件的包装器
+	 * @return 包含用户实体的列表
+	 */
 	@Override
 	public List<UserEntity> selectListView(Wrapper<UserEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，根据查询条件包装器查询用户实体列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	/**
+	 * 根据传入的参数和查询条件进行分页查询用户实体数据
+	 * @param params 包含查询条件、分页参数等信息的Map集合
+	 * @param wrapper 用于构建查询条件的包装器
+	 * @return PageUtils对象，包含分页查询结果的相关信息
+	 */
 	@Override
 	public PageUtils queryPage(Map<String, Object> params,
-			Wrapper<UserEntity> wrapper) {
-		 Page<UserEntity> page =new Query<UserEntity>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
+							   Wrapper<UserEntity> wrapper) {
+		// 使用Query工具类从参数中构建分页信息，获取Page对象
+		Page<UserEntity> page = new Query<UserEntity>(params).getPage();
+		// 调用数据访问对象的selectListView方法，根据分页信息和查询条件包装器查询用户实体列表，并设置到Page对象中
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类封装分页查询结果
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
 	}
-}
+}

back/src/main/java/com/service/impl/YonghuServiceImpl.java

@@ -16,7 +16,7 @@ import com.entity.YonghuEntity;
 import com.service.YonghuService;
 import com.entity.vo.YonghuVO;
 import com.entity.view.YonghuView;
-
+//test
 // 将该类标记为一个服务组件，名为"yonghuService"，用于处理与用户相关的业务逻辑
 @Service("yonghuService")
 // YonghuServiceImpl类继承自ServiceImpl<YonghuDao, YonghuEntity>，并实现了YonghuService接口

back/src/main/java/com/service/impl/YuangongServiceImpl.java

@@ -1,63 +1,105 @@
+// 声明该类所在的包，通常用于组织服务实现类
 package com.service.impl;
 
+// 导入Spring框架的Service注解，用于将当前类标记为一个服务组件
 import org.springframework.stereotype.Service;
+// 导入Java标准库中的Map接口，用于处理键值对数据，常用于方法参数传递等场景
 import java.util.Map;
+// 导入Java标准库中的List接口，用于处理一组有序的数据集合，常用于方法的返回值或参数中
 import java.util.List;
 
+// 导入MyBatis-Plus框架的Wrapper接口，用于构建查询条件的包装器
 import com.baomidou.mybatisplus.mapper.Wrapper;
+// 导入MyBatis-Plus框架的EntityWrapper类，用于创建基于实体类的查询条件包装器
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+// 导入MyBatis-Plus框架的Page类，用于处理分页查询，存储分页相关的数据
 import com.baomidou.mybatisplus.plugins.Page;
+// 导入MyBatis-Plus框架的ServiceImpl类，提供了基础的服务层实现方法和通用功能
 import com.baomidou.mybatisplus.service.impl.ServiceImpl;
+// 导入自定义的PageUtils工具类，用于处理分页结果，将MyBatis-Plus的Page对象转换为自定义的分页工具对象
 import com.utils.PageUtils;
+// 导入自定义的Query工具类，用于从参数Map中构建分页查询所需的参数和Page对象
 import com.utils.Query;
 
-
+// 导入自定义的数据访问对象接口，用于对员工相关数据进行数据库操作
 import com.dao.YuangongDao;
+// 导入自定义的员工实体类，用于表示数据库中员工表的记录
 import com.entity.YuangongEntity;
+// 导入自定义的员工服务接口，当前类实现该接口以提供具体的员工业务逻辑
 import com.service.YuangongService;
+// 导入自定义的员工值对象类，用于在特定业务场景下传输和处理员工相关的数据
 import com.entity.vo.YuangongVO;
+// 导入自定义的员工视图类，用于以特定的视图形式展示员工相关的数据
 import com.entity.view.YuangongView;
 
+// 使用Service注解将该类注册为Spring的服务组件，服务名称为"yuangongService"
 @Service("yuangongService")
+// 继承ServiceImpl类，并指定数据访问对象为YuangongDao和实体类为YuangongEntity，实现YuangongService接口
 public class YuangongServiceImpl extends ServiceImpl<YuangongDao, YuangongEntity> implements YuangongService {
-	
-	
-    @Override
-    public PageUtils queryPage(Map<String, Object> params) {
-        Page<YuangongEntity> page = this.selectPage(
-                new Query<YuangongEntity>(params).getPage(),
-                new EntityWrapper<YuangongEntity>()
-        );
-        return new PageUtils(page);
-    }
-    
-    @Override
+
+	// 重写queryPage方法，根据传入的参数进行分页查询员工实体数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
+	@Override
+	public PageUtils queryPage(Map<String, Object> params) {
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
+		Page<YuangongEntity> page = this.selectPage(
+				new Query<YuangongEntity>(params).getPage(),
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
+				new EntityWrapper<YuangongEntity>()
+		);
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		return new PageUtils(page);
+	}
+
+	// 重写queryPage方法，根据传入的参数和查询条件进行分页查询员工视图数据
+	// @param params 包含查询条件、分页参数等信息的Map集合
+	// @param wrapper 用于构建查询条件的包装器，类型为YuangongEntity的包装器
+	// @return PageUtils对象，包含了分页查询结果的相关信息
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<YuangongEntity> wrapper) {
-		  Page<YuangongView> page =new Query<YuangongView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
-	    	PageUtils pageUtil = new PageUtils(page);
-	    	return pageUtil;
- 	}
-    
-    @Override
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为YuangongView
+		Page<YuangongView> page = new Query<YuangongView>(params).getPage();
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
+	}
+
+	// 重写selectListVO方法，根据传入的查询条件查询员工值对象列表
+	// @param wrapper 用于构建查询条件的包装器，类型为YuangongEntity的包装器
+	// @return 包含员工值对象的List集合
+	@Override
 	public List<YuangongVO> selectListVO(Wrapper<YuangongEntity> wrapper) {
- 		return baseMapper.selectListVO(wrapper);
+		// 调用数据访问对象的selectListVO方法，传入查询条件包装器，获取员工值对象列表
+		return baseMapper.selectListVO(wrapper);
 	}
-	
+
+	// 重写selectVO方法，根据传入的查询条件查询单个员工值对象
+	// @param wrapper 用于构建查询条件的包装器，类型为YuangongEntity的包装器
+	// @return 单个员工值对象
 	@Override
 	public YuangongVO selectVO(Wrapper<YuangongEntity> wrapper) {
- 		return baseMapper.selectVO(wrapper);
+		// 调用数据访问对象的selectVO方法，传入查询条件包装器，获取单个员工值对象
+		return baseMapper.selectVO(wrapper);
 	}
-	
+
+	// 重写selectListView方法，根据传入的查询条件查询员工视图列表
+	// @param wrapper 用于构建查询条件的包装器，类型为YuangongEntity的包装器
+	// @return 包含员工视图的List集合
 	@Override
 	public List<YuangongView> selectListView(Wrapper<YuangongEntity> wrapper) {
+		// 调用数据访问对象的selectListView方法，传入查询条件包装器，获取员工视图列表
 		return baseMapper.selectListView(wrapper);
 	}
 
+	// 重写selectView方法，根据传入的查询条件查询单个员工视图
+	// @param wrapper 用于构建查询条件的包装器，类型为YuangongEntity的包装器
+	// @return 单个员工视图
 	@Override
 	public YuangongView selectView(Wrapper<YuangongEntity> wrapper) {
+		// 调用数据访问对象的selectView方法，传入查询条件包装器，获取单个员工视图
 		return baseMapper.selectView(wrapper);
 	}
-
-
-}
+}

back/src/main/java/com/utils/BaiduUtil.java

@@ -10,72 +10,85 @@ import java.util.Map;
 
 import org.json.JSONObject;
 
-
 /**
-* 类说明 : 
-*/
-
+ * 类说明 : 该类是一个工具类，提供了与百度地图相关的工具方法，如根据经纬度获取省市区信息、获取百度 API 访问 token 等。
+ */
 public class BaiduUtil {
-	
+
     /**
      * 根据经纬度获得省市区信息
-     * @param lon 纬度
-     * @param lat 经度
-     * @param coordtype 经纬度坐标系
-     * @return
+     *
+     * @param key   百度地图 API 的访问密钥（ak）
+     * @param lng   经度
+     * @param lat   纬度
+     * @return 包含省、市、区、街道信息的 Map，如果获取失败则返回 null
      */
     public static Map<String, String> getCityByLonLat(String key, String lng, String lat) {
+        // 将纬度和经度拼接成百度地图 API 所需的 location 格式
         String location = lat + "," + lng;
         try {
-            //拼装url
-            String url = "http://api.map.baidu.com/reverse_geocoding/v3/?ak="+key+"&output=json&coordtype=wgs84ll&location="+location;
+            // 拼装请求 URL，包含 API 密钥、输出格式、经纬度坐标系和经纬度信息
+            String url = "http://api.map.baidu.com/reverse_geocoding/v3/?ak=" + key + "&output=json&coordtype=wgs84ll&location=" + location;
+            // 发送 GET 请求并获取结果
             String result = HttpClientUtils.doGet(url);
+            // 将结果解析为 JSONObject 对象
             JSONObject o = new JSONObject(result);
+            // 创建一个 Map 用于存储省市区街道信息
             Map<String, String> area = new HashMap<>();
-			area.put("province", o.getJSONObject("result").getJSONObject("addressComponent").getString("province"));
-			area.put("city", o.getJSONObject("result").getJSONObject("addressComponent").getString("city"));
-			area.put("district", o.getJSONObject("result").getJSONObject("addressComponent").getString("district"));
-			area.put("street", o.getJSONObject("result").getJSONObject("addressComponent").getString("street"));
+            // 从 JSONObject 中提取省份信息并放入 Map
+            area.put("province", o.getJSONObject("result").getJSONObject("addressComponent").getString("province"));
+            // 从 JSONObject 中提取城市信息并放入 Map
+            area.put("city", o.getJSONObject("result").getJSONObject("addressComponent").getString("city"));
+            // 从 JSONObject 中提取区信息并放入 Map
+            area.put("district", o.getJSONObject("result").getJSONObject("addressComponent").getString("district"));
+            // 从 JSONObject 中提取街道信息并放入 Map
+            area.put("street", o.getJSONObject("result").getJSONObject("addressComponent").getString("street"));
             return area;
-        }catch (Exception e) {
+        } catch (Exception e) {
             e.printStackTrace();
         }
         return null;
     }
 
     /**
-	     * 获取API访问token
-	     * 该token有一定的有效期，需要自行管理，当失效时需重新获取.
-	     * @param ak - 百度云官网获取的 API Key
-	     * @param sk - 百度云官网获取的 Securet Key
-	     * @return assess_token
-	     */
+     * 获取 API 访问 token
+     * 该 token 有一定的有效期，需要自行管理，当失效时需重新获取.
+     *
+     * @param ak 百度云官网获取的 API Key
+     * @param sk 百度云官网获取的 Securet Key
+     * @return access_token，如果获取失败则返回 null
+     */
     public static String getAuth(String ak, String sk) {
-        // 获取token地址
+        // 获取 token 的地址
         String authHost = "https://aip.baidubce.com/oauth/2.0/token?";
+        // 拼接完整的获取 token 的 URL，包含授权类型、API Key 和 Secret Key
         String getAccessTokenUrl = authHost
-                // 1. grant_type为固定参数
+                // 1. grant_type 为固定参数
                 + "grant_type=client_credentials"
                 // 2. 官网获取的 API Key
                 + "&client_id=" + ak
                 // 3. 官网获取的 Secret Key
                 + "&client_secret=" + sk;
         try {
+            // 创建 URL 对象
             URL realUrl = new URL(getAccessTokenUrl);
-            // 打开和URL之间的连接
+            // 打开和 URL 之间的连接
             HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
+            // 设置请求方法为 GET
             connection.setRequestMethod("GET");
+            // 建立连接
             connection.connect();
             // 获取所有响应头字段
             Map<String, List<String>> map = connection.getHeaderFields();
-            // 遍历所有的响应头字段
+            // 遍历所有的响应头字段并打印（调试用）
             for (String key : map.keySet()) {
                 System.err.println(key + "--->" + map.get(key));
             }
-            // 定义 BufferedReader输入流来读取URL的响应
+            // 定义 BufferedReader 输入流来读取 URL 的响应
             BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
             String result = "";
             String line;
+            // 逐行读取响应内容并拼接
             while ((line = in.readLine()) != null) {
                 result += line;
             }
@@ -83,14 +96,15 @@ public class BaiduUtil {
              * 返回结果示例
              */
             System.err.println("result:" + result);
+            // 将响应结果解析为 JSONObject 对象
             org.json.JSONObject jsonObject = new org.json.JSONObject(result);
+            // 从 JSONObject 中提取 access_token 并返回
             String access_token = jsonObject.getString("access_token");
             return access_token;
         } catch (Exception e) {
-            System.err.printf("获取token失败！");
+            System.err.printf("获取 token 失败！");
             e.printStackTrace(System.err);
         }
         return null;
     }
-
 }

back/src/main/java/com/utils/CommonUtil.java

@@ -7,69 +7,91 @@ import org.apache.poi.ss.usermodel.Cell;
 import java.text.DecimalFormat;
 import java.util.Objects;
 
+// 使用 Spring 的 @Component 注解，将该类标记为一个组件，以便在 Spring 容器中进行管理
 @Component
 public class CommonUtil {
-	/**
+
+    /**
      * 获取随机字符串
      *
-     * @param num
-     * @return
+     * @param num 生成的随机字符串的长度
+     * @return 生成的指定长度的随机字符串
      */
     public static String getRandomString(Integer num) {
+        // 定义包含小写字母和数字的字符集
         String base = "abcdefghijklmnopqrstuvwxyz0123456789";
+        // 创建一个 Random 实例用于生成随机数
         Random random = new Random();
+        // 使用 StringBuffer 来构建随机字符串
         StringBuffer sb = new StringBuffer();
+        // 循环生成指定长度的随机字符串
         for (int i = 0; i < num; i++) {
+            // 生成一个在字符集范围内的随机索引
             int number = random.nextInt(base.length());
+            // 将随机索引对应的字符添加到 StringBuffer 中
             sb.append(base.charAt(number));
         }
+        // 将 StringBuffer 转换为字符串并返回
         return sb.toString();
     }
 
-	/**
-	 * 获取随机验证码
-	 *
-	 * @param num
-	 * @return
-	 */
-	public static String getRandomNumber(Integer num) {
-	    String base = "0123456789";
-	    Random random = new Random();
-	    StringBuffer sb = new StringBuffer();
-	    for (int i = 0; i < num; i++) {
-	        int number = random.nextInt(base.length());
-	        sb.append(base.charAt(number));
-	    }
-	    return sb.toString();
-	}
+    /**
+     * 获取随机验证码
+     *
+     * @param num 生成的随机验证码的长度
+     * @return 生成的指定长度的随机验证码（仅包含数字）
+     */
+    public static String getRandomNumber(Integer num) {
+        // 定义仅包含数字的字符集
+        String base = "0123456789";
+        // 创建一个 Random 实例用于生成随机数
+        Random random = new Random();
+        // 使用 StringBuffer 来构建随机验证码
+        StringBuffer sb = new StringBuffer();
+        // 循环生成指定长度的随机验证码
+        for (int i = 0; i < num; i++) {
+            // 生成一个在字符集范围内的随机索引
+            int number = random.nextInt(base.length());
+            // 将随机索引对应的字符添加到 StringBuffer 中
+            sb.append(base.charAt(number));
+        }
+        // 将 StringBuffer 转换为字符串并返回
+        return sb.toString();
+    }
 
     public static String getCellValue(Cell cell) {
+        // 初始化结果值为空字符串
         String resultValue = "";
-        // 判空
+        // 检查单元格是否为空
         if (Objects.isNull(cell)) {
+            // 如果单元格为空，直接返回空字符串
             return resultValue;
         }
 
-        // 拿到单元格类型
+        // 获取单元格的类型
         int cellType = cell.getCellType();
+        // 根据单元格类型进行处理
         switch (cellType) {
-            // 字符串类型
+            // 如果是字符串类型的单元格
             case Cell.CELL_TYPE_STRING:
-                resultValue = StringUtils.isEmpty(cell.getStringCellValue()) ? "" : cell.getStringCellValue().trim();
+                // 获取字符串值并去除两端空格，如果值为空则返回空字符串
+                resultValue = StringUtils.isEmpty(cell.getStringCellValue())? "" : cell.getStringCellValue().trim();
                 break;
-            // 布尔类型
+            // 如果是布尔类型的单元格
             case Cell.CELL_TYPE_BOOLEAN:
+                // 将布尔值转换为字符串
                 resultValue = String.valueOf(cell.getBooleanCellValue());
                 break;
-            // 数值类型
+            // 如果是数值类型的单元格
             case Cell.CELL_TYPE_NUMERIC:
+                // 使用 DecimalFormat 格式化数值，保留六位小数
                 resultValue = new DecimalFormat("#.######").format(cell.getNumericCellValue());
                 break;
-            // 取空串
+            // 其他情况（默认），不做处理，结果值仍为空字符串
             default:
                 break;
         }
+        // 返回处理后的单元格值
         return resultValue;
     }
-
-}
+}

back/src/main/java/com/utils/FileUtil.java

@@ -7,21 +7,33 @@ import java.io.IOException;
 import java.io.InputStream;
 
 /**
-* 类说明 : 
-*/
-
+ * 类说明 : 该类是一个文件处理工具类，提供了将文件转换为字节数组的方法。
+ */
 public class FileUtil {
+
+	/**
+	 * 将指定的文件转换为字节数组。
+	 *
+	 * @param file 要转换的文件对象
+	 * @return 包含文件内容的字节数组
+	 * @throws IOException 如果在读取文件或处理流时发生 I/O 错误
+	 */
 	public static byte[] FileToByte(File file) throws IOException {
-		// 将数据转为流
+		// 将文件数据转换为输入流，这里使用 FileInputStream 来读取文件内容
 		@SuppressWarnings("resource")
 		InputStream content = new FileInputStream(file);
+		// 创建一个 ByteArrayOutputStream 用于存储从文件中读取的数据
 		ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
+		// 创建一个字节缓冲区，用于每次从输入流中读取数据
 		byte[] buff = new byte[100];
+		// 用于存储每次读取的字节数
 		int rc = 0;
+		// 循环读取文件内容，直到读取完所有数据（read 方法返回 -1 表示读取到文件末尾）
 		while ((rc = content.read(buff, 0, 100)) > 0) {
+			// 将读取到的字节写入到 ByteArrayOutputStream 中
 			swapStream.write(buff, 0, rc);
 		}
-		// 获得二进制数组
+		// 将 ByteArrayOutputStream 中的数据转换为字节数组并返回
 		return swapStream.toByteArray();
 	}
-}
+}

back/src/main/java/com/utils/HttpClientUtils.java

@@ -5,38 +5,49 @@ import java.io.InputStreamReader;
 import java.net.HttpURLConnection;
 import java.net.URL;
 
-
 /**
  * HttpClient工具类
+ * 该类提供了执行HTTP GET请求的方法，用于从指定的URL获取数据。
  */
 public class HttpClientUtils {
 
     /**
-     * @param uri
-     * @return String
-     * @description get请求方式
+     * 执行HTTP GET请求并获取响应结果。
+     *
+     * @param uri 要请求的URL地址，是一个字符串形式的URI。
+     * @return 返回从服务器获取的响应内容，如果请求失败或出现异常则返回null。
+     * @description 该方法通过创建URL对象和HttpURLConnection连接，
+     *              然后从连接的输入流中读取服务器返回的数据，并将其拼接成字符串返回。
      * @author: long.he01
      */
     public static String doGet(String uri) {
-
+        // 使用StringBuilder来构建最终的响应结果字符串，因为频繁的字符串拼接操作使用StringBuilder效率更高
         StringBuilder result = new StringBuilder();
         try {
+            // 用于存储每一行读取到的响应数据
             String res = "";
+            // 根据传入的URI创建URL对象
             URL url = new URL(uri);
+            // 打开与URL的连接，并将其强转为HttpURLConnection类型，以便进行HTTP相关的操作
             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+            // 创建一个BufferedReader，用于从连接的输入流中读取数据，指定字符编码为UTF-8
             BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
+            // 用于存储从输入流中读取的每一行数据
             String line;
+            // 循环读取输入流中的数据，直到读取到文件末尾（readLine()返回null表示文件末尾）
             while ((line = in.readLine()) != null) {
-                res += line+"\n";
+                // 将读取到的每一行数据拼接起来，并添加换行符
+                res += line + "\n";
             }
+            // 关闭BufferedReader，释放资源
             in.close();
+            // 返回拼接好的响应结果字符串
             return res;
-        }catch (Exception e) {
+        } catch (Exception e) {
+            // 如果在请求过程中发生异常，打印异常堆栈信息
             e.printStackTrace();
+            // 请求失败，返回null
             return null;
         }
-
     }
-
-}
-
+}

back/src/main/java/com/utils/JQPageInfo.java

@@ -1,54 +1,98 @@
 package com.utils;
 
-public class JQPageInfo{
+/**
+ * JQPageInfo 类用于封装分页查询所需的参数信息，常与前端使用 jQuery 相关插件（如 jqGrid）
+ * 进行分页交互时使用，方便在前后端之间传递分页和排序信息。
+ */
+public class JQPageInfo {
+	// 当前页码，通常从 1 开始，代表用户当前查看的页面
 	private Integer page;
-	
+	// 每页显示的记录数量，用于控制每页展示的数据量
 	private Integer limit;
-	
+	// 排序字段，指定按照数据库表中的哪个字段进行排序操作
 	private String sidx;
-	
+	// 排序顺序，一般取值为 "asc"（升序）或 "desc"（降序）
 	private String order;
-	
-	private  Integer offset;
+	// 偏移量，用于数据库查询时定位从哪条记录开始获取数据，通常由 (page - 1) * limit 计算得出
+	private Integer offset;
 
+	/**
+	 * 获取当前页码
+	 * @return 当前页码
+	 */
 	public Integer getPage() {
 		return page;
 	}
 
+	/**
+	 * 设置当前页码
+	 * @param page 要设置的页码
+	 */
 	public void setPage(Integer page) {
 		this.page = page;
 	}
 
+	/**
+	 * 获取每页显示的记录数量
+	 * @return 每页显示的记录数量
+	 */
 	public Integer getLimit() {
 		return limit;
 	}
 
+	/**
+	 * 设置每页显示的记录数量
+	 * @param limit 要设置的每页记录数
+	 */
 	public void setLimit(Integer limit) {
 		this.limit = limit;
 	}
 
+	/**
+	 * 获取排序字段
+	 * @return 排序字段
+	 */
 	public String getSidx() {
 		return sidx;
 	}
 
+	/**
+	 * 设置排序字段
+	 * @param sidx 要设置的排序字段
+	 */
 	public void setSidx(String sidx) {
 		this.sidx = sidx;
 	}
-	
+
+	/**
+	 * 获取排序顺序
+	 * @return 排序顺序（"asc" 或 "desc"）
+	 */
 	public String getOrder() {
 		return order;
 	}
 
+	/**
+	 * 设置排序顺序
+	 * @param order 要设置的排序顺序
+	 */
 	public void setOrder(String order) {
 		this.order = order;
 	}
 
+	/**
+	 * 获取偏移量
+	 * @return 偏移量
+	 */
 	public Integer getOffset() {
 		return offset;
 	}
 
+	/**
+	 * 设置偏移量
+	 * @param offset 要设置的偏移量
+	 */
 	public void setOffset(Integer offset) {
 		this.offset = offset;
 	}
-	
-}
+}

back/src/main/java/com/utils/MD5Util.java

@@ -1,19 +1,25 @@
 package com.utils;
 
+// 引入Hutool工具包中的DigestUtil类，该类提供了各种摘要算法工具，用于实现MD5加密
 import cn.hutool.crypto.digest.DigestUtil;
 
+/**
+ * MD5Util类用于实现MD5加密功能，借助Hutool工具包中的DigestUtil类完成。
+ */
 public class MD5Util {
-    
+
 	/**
-	 * @param text明文
-	 * @param key密钥
-	 * @return 密文
+	 * 此方法用于对传入的明文进行MD5加密。
+	 *
+	 * @param text 待加密的明文，是一个字符串类型的数据。
+	 * @return 返回经过MD5加密后的十六进制字符串形式的密文。
 	 */
-	// 带秘钥加密
+	// 带秘钥加密，不过此方法当前未使用密钥，仅对文本进行MD5加密
 	public static String md5(String text) {
+		// 利用DigestUtil类的md5Hex方法对传入的明文进行MD5加密，并将加密结果以十六进制字符串形式存储
 		// 加密后的字符串
 		String md5str = DigestUtil.md5Hex(text);
+		// 返回加密后的十六进制字符串
 		return md5str;
 	}
-
-}
+}

back/src/main/java/com/utils/MPUtil.java

@@ -13,132 +13,218 @@ import com.baomidou.mybatisplus.mapper.Wrapper;
 
 /**
  * Mybatis-Plus工具类
+ * 该类提供了一系列与MyBatis-Plus相关的工具方法，用于简化常见的数据库操作，
+ * 如构建查询条件、对象属性处理以及字符串格式转换等。
  */
 public class MPUtil {
 	public static final char UNDERLINE = '_';
 
-	
-	//mybatis plus allEQ 表达式转换
-		public static Map allEQMapPre(Object bean,String pre) {
-		   Map<String, Object> map =BeanUtil.beanToMap(bean);
-		  return camelToUnderlineMap(map,pre);
-	   }
-
-		//mybatis plus allEQ 表达式转换
-		public static Map allEQMap(Object bean) {
-		   Map<String, Object> map =BeanUtil.beanToMap(bean);
-		   return camelToUnderlineMap(map,"");
-	   }
-
-		public static Wrapper allLikePre(Wrapper wrapper,Object bean,String pre) {
-			   Map<String, Object> map =BeanUtil.beanToMap(bean);
-			   Map result = camelToUnderlineMap(map,pre);
-			 
-			return genLike(wrapper,result);
-		}
-	
-		public static Wrapper allLike(Wrapper wrapper,Object bean) {
-			  Map result = BeanUtil.beanToMap(bean, true, true);			 
-			return genLike(wrapper,result);
+	/**
+	 * 将对象的属性转换为MyBatis-Plus的allEQ表达式形式，并为键添加指定前缀。
+	 * 先使用BeanUtil将对象转换为Map，然后将Map的键从驼峰格式转换为下划线格式，
+	 * 最后返回带有前缀的新Map。
+	 *
+	 * @param bean 要转换的对象
+	 * @param pre  要添加的前缀
+	 * @return 转换后的Map，键为下划线格式并带有前缀，值为对象属性值
+	 */
+	public static Map allEQMapPre(Object bean, String pre) {
+		Map<String, Object> map = BeanUtil.beanToMap(bean);
+		return camelToUnderlineMap(map, pre);
+	}
+
+	/**
+	 * 将对象的属性转换为MyBatis-Plus的allEQ表达式形式，不添加前缀。
+	 * 先使用BeanUtil将对象转换为Map，然后将Map的键从驼峰格式转换为下划线格式，
+	 * 最后返回转换后的新Map。
+	 *
+	 * @param bean 要转换的对象
+	 * @return 转换后的Map，键为下划线格式，值为对象属性值
+	 */
+	public static Map allEQMap(Object bean) {
+		Map<String, Object> map = BeanUtil.beanToMap(bean);
+		return camelToUnderlineMap(map, "");
+	}
+
+	/**
+	 * 根据对象属性构建MyBatis-Plus的Wrapper的like条件，并为键添加指定前缀。
+	 * 先将对象转换为Map，再将Map的键转换为下划线格式并添加前缀，
+	 * 然后使用转换后的Map生成like条件并返回Wrapper。
+	 *
+	 * @param wrapper MyBatis-Plus的Wrapper对象
+	 * @param bean    包含条件属性的对象
+	 * @param pre     要添加的前缀
+	 * @return 配置了like条件的Wrapper对象
+	 */
+	public static Wrapper allLikePre(Wrapper wrapper, Object bean, String pre) {
+		Map<String, Object> map = BeanUtil.beanToMap(bean);
+		Map result = camelToUnderlineMap(map, pre);
+		return genLike(wrapper, result);
+	}
+
+	/**
+	 * 根据对象属性构建MyBatis-Plus的Wrapper的like条件，不添加前缀。
+	 * 直接将对象转换为Map，然后使用转换后的Map生成like条件并返回Wrapper。
+	 *
+	 * @param wrapper MyBatis-Plus的Wrapper对象
+	 * @param bean    包含条件属性的对象
+	 * @return 配置了like条件的Wrapper对象
+	 */
+	public static Wrapper allLike(Wrapper wrapper, Object bean) {
+		Map result = BeanUtil.beanToMap(bean, true, true);
+		return genLike(wrapper, result);
+	}
+
+	/**
+	 * 根据Map参数构建MyBatis-Plus的Wrapper的like条件。
+	 * 遍历Map，对每个键值对设置like条件，多个条件之间使用and连接。
+	 *
+	 * @param wrapper MyBatis-Plus的Wrapper对象
+	 * @param param   包含条件键值对的Map
+	 * @return 配置了like条件的Wrapper对象
+	 */
+	public static Wrapper genLike(Wrapper wrapper, Map param) {
+		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
+		int i = 0;
+		while (it.hasNext()) {
+			if (i > 0) wrapper.and();
+			Map.Entry<String, Object> entry = it.next();
+			String key = entry.getKey();
+			String value = (String) entry.getValue();
+			wrapper.like(key, value);
+			i++;
 		}
-	
-	
-		public static Wrapper genLike( Wrapper wrapper,Map param) {
-			Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
-			int i=0;
-			while (it.hasNext()) {
-				if(i>0) wrapper.and();
-				Map.Entry<String, Object> entry = it.next();
-				String key = entry.getKey();
-				String value = (String) entry.getValue();
-				wrapper.like(key, value);
-				i++;
+		return wrapper;
+	}
+
+	/**
+	 * 根据对象属性构建MyBatis-Plus的Wrapper的like或eq条件。
+	 * 先将对象转换为Map，然后根据Map中值是否包含"%"来决定设置like或eq条件。
+	 *
+	 * @param wrapper MyBatis-Plus的Wrapper对象
+	 * @param bean    包含条件属性的对象
+	 * @return 配置了like或eq条件的Wrapper对象
+	 */
+	public static Wrapper likeOrEq(Wrapper wrapper, Object bean) {
+		Map result = BeanUtil.beanToMap(bean, true, true);
+		return genLikeOrEq(wrapper, result);
+	}
+
+	/**
+	 * 根据Map参数构建MyBatis-Plus的Wrapper的like或eq条件。
+	 * 遍历Map，根据值中是否包含"%"来决定设置like或eq条件，多个条件之间使用and连接。
+	 *
+	 * @param wrapper MyBatis-Plus的Wrapper对象
+	 * @param param   包含条件键值对的Map
+	 * @return 配置了like或eq条件的Wrapper对象
+	 */
+	public static Wrapper genLikeOrEq(Wrapper wrapper, Map param) {
+		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
+		int i = 0;
+		while (it.hasNext()) {
+			if (i > 0) wrapper.and();
+			Map.Entry<String, Object> entry = it.next();
+			String key = entry.getKey();
+			if (entry.getValue().toString().contains("%")) {
+				wrapper.like(key, entry.getValue().toString().replace("%", ""));
+			} else {
+				wrapper.eq(key, entry.getValue());
 			}
-			return wrapper;
+			i++;
 		}
-		
-		public static Wrapper likeOrEq(Wrapper wrapper,Object bean) {
-			  Map result = BeanUtil.beanToMap(bean, true, true);			 
-			return genLikeOrEq(wrapper,result);
+		return wrapper;
+	}
+
+	/**
+	 * 根据对象属性构建MyBatis-Plus的Wrapper的eq条件。
+	 * 先将对象转换为Map，然后使用转换后的Map生成eq条件并返回Wrapper。
+	 *
+	 * @param wrapper MyBatis-Plus的Wrapper对象
+	 * @param bean    包含条件属性的对象
+	 * @return 配置了eq条件的Wrapper对象
+	 */
+	public static Wrapper allEq(Wrapper wrapper, Object bean) {
+		Map result = BeanUtil.beanToMap(bean, true, true);
+		return genEq(wrapper, result);
+	}
+
+	/**
+	 * 根据Map参数构建MyBatis-Plus的Wrapper的eq条件。
+	 * 遍历Map，对每个键值对设置eq条件，多个条件之间使用and连接。
+	 *
+	 * @param wrapper MyBatis-Plus的Wrapper对象
+	 * @param param   包含条件键值对的Map
+	 * @return 配置了eq条件的Wrapper对象
+	 */
+	public static Wrapper genEq(Wrapper wrapper, Map param) {
+		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
+		int i = 0;
+		while (it.hasNext()) {
+			if (i > 0) wrapper.and();
+			Map.Entry<String, Object> entry = it.next();
+			String key = entry.getKey();
+			wrapper.eq(key, entry.getValue());
+			i++;
 		}
-		
-		public static Wrapper genLikeOrEq( Wrapper wrapper,Map param) {
-			Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
-			int i=0;
-			while (it.hasNext()) {
-				if(i>0) wrapper.and();
-				Map.Entry<String, Object> entry = it.next();
-				String key = entry.getKey();
-				if(entry.getValue().toString().contains("%")) {
-					wrapper.like(key, entry.getValue().toString().replace("%", ""));
-				} else {
-					wrapper.eq(key, entry.getValue());
+		return wrapper;
+	}
+
+	/**
+	 * 根据Map参数构建MyBatis-Plus的Wrapper的between条件。
+	 * 遍历Map，根据键名是否以"_start"或"_end"结尾来决定设置ge（大于等于）或le（小于等于）条件。
+	 *
+	 * @param wrapper MyBatis-Plus的Wrapper对象
+	 * @param params  包含条件键值对的Map
+	 * @return 配置了between条件的Wrapper对象
+	 */
+	public static Wrapper between(Wrapper wrapper, Map<String, Object> params) {
+		for (String key : params.keySet()) {
+			String columnName = "";
+			if (key.endsWith("_start")) {
+				columnName = key.substring(0, key.indexOf("_start"));
+				if (StringUtils.isNotBlank(params.get(key).toString())) {
+					wrapper.ge(columnName, params.get(key));
 				}
-				i++;
 			}
-			return wrapper;
-		}
-		
-		public static Wrapper allEq(Wrapper wrapper,Object bean) {
-			  Map result = BeanUtil.beanToMap(bean, true, true);			 
-			return genEq(wrapper,result);
-		}
-	
-	
-		public static Wrapper genEq( Wrapper wrapper,Map param) {
-			Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
-			int i=0;
-			while (it.hasNext()) {
-				if(i>0) wrapper.and();
-				Map.Entry<String, Object> entry = it.next();
-				String key = entry.getKey();
-				wrapper.eq(key, entry.getValue());
-				i++;
-			}
-			return wrapper;
-		}
-	
-	
-		public static Wrapper between(Wrapper wrapper,Map<String, Object> params) {
-			for(String key : params.keySet()) {
-				String columnName = "";
-				if(key.endsWith("_start")) {
-					columnName = key.substring(0, key.indexOf("_start"));
-					if(StringUtils.isNotBlank(params.get(key).toString())) {
-						wrapper.ge(columnName, params.get(key));
-					}
-				}
-				if(key.endsWith("_end")) {
-					columnName = key.substring(0, key.indexOf("_end"));
-					if(StringUtils.isNotBlank(params.get(key).toString())) {
-						wrapper.le(columnName, params.get(key));
-					}
+			if (key.endsWith("_end")) {
+				columnName = key.substring(0, key.indexOf("_end"));
+				if (StringUtils.isNotBlank(params.get(key).toString())) {
+					wrapper.le(columnName, params.get(key));
 				}
 			}
-			return wrapper;
 		}
-	
-		public static Wrapper sort(Wrapper wrapper,Map<String, Object> params) {
-			String order = "";
-			if(params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {
-				order = params.get("order").toString();
-			}
-			if(params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) {
-				if(order.equalsIgnoreCase("desc")) {
-					wrapper.orderDesc(Arrays.asList(params.get("sort")));
-				} else {
-					wrapper.orderAsc(Arrays.asList(params.get("sort")));
-				}
+		return wrapper;
+	}
+
+	/**
+	 * 根据Map参数为MyBatis-Plus的Wrapper设置排序条件。
+	 * 根据"order"和"sort"参数的值设置升序或降序排序。
+	 *
+	 * @param wrapper MyBatis-Plus的Wrapper对象
+	 * @param params  包含排序相关键值对的Map，如"order"（排序方向）和"sort"（排序字段）
+	 * @return 配置了排序条件的Wrapper对象
+	 */
+	public static Wrapper sort(Wrapper wrapper, Map<String, Object> params) {
+		String order = "";
+		if (params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {
+			order = params.get("order").toString();
+		}
+		if (params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) {
+			if (order.equalsIgnoreCase("desc")) {
+				wrapper.orderDesc(Arrays.asList(params.get("sort")));
+			} else {
+				wrapper.orderAsc(Arrays.asList(params.get("sort")));
 			}
-			return wrapper;
 		}
-	
-	
+		return wrapper;
+	}
+
 	/**
-	 * 驼峰格式字符串转换为下划线格式字符串
-	 * 
-	 * @param param
-	 * @return
+	 * 将驼峰格式字符串转换为下划线格式字符串。
+	 * 遍历字符串，若字符为大写，则在其前添加下划线并转换为小写，否则直接添加字符。
+	 *
+	 * @param param 要转换的驼峰格式字符串
+	 * @return 转换后的下划线格式字符串
 	 */
 	public static String camelToUnderline(String param) {
 		if (param == null || "".equals(param.trim())) {
@@ -161,9 +247,16 @@ public class MPUtil {
 	public static void main(String[] ages) {
 		System.out.println(camelToUnderline("ABCddfANM"));
 	}
-	
-	public static Map camelToUnderlineMap(Map param, String pre) {
 
+	/**
+	 * 将Map的键从驼峰格式转换为下划线格式，并根据前缀进行处理。
+	 * 遍历Map，将每个键转换为下划线格式，然后根据前缀的情况将键值对添加到新的Map中。
+	 *
+	 * @param param 要转换的Map
+	 * @param pre   前缀
+	 * @return 转换后的Map，键为下划线格式，根据前缀处理后的值
+	 */
+	public static Map camelToUnderlineMap(Map param, String pre) {
 		Map<String, Object> newMap = new HashMap<String, Object>();
 		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
 		while (it.hasNext()) {
@@ -175,10 +268,9 @@ public class MPUtil {
 			} else if (StringUtils.isEmpty(pre)) {
 				newMap.put(newKey, entry.getValue());
 			} else {
-
 				newMap.put(pre + "." + newKey, entry.getValue());
 			}
 		}
 		return newMap;
 	}
-}
+}

back/src/main/java/com/utils/PageUtils.java

@@ -1,4 +1,3 @@
-
 package com.utils;
 
 import java.io.Serializable;
@@ -9,37 +8,45 @@ import com.baomidou.mybatisplus.plugins.Page;
 
 /**
  * 分页工具类
+ * 该类用于封装分页相关的信息，方便在业务层和表现层之间传递分页数据。
  */
 public class PageUtils implements Serializable {
+	// 用于实现序列化版本控制，确保不同版本的类在反序列化时的兼容性
 	private static final long serialVersionUID = 1L;
-	//总记录数
+	// 总记录数，即满足查询条件的所有记录的数量
 	private long total;
-	//每页记录数
+	// 每页记录数，指定每一页显示的记录数量
 	private int pageSize;
-	//总页数
+	// 总页数，根据总记录数和每页记录数计算得出的总页数
 	private long totalPage;
-	//当前页数
+	// 当前页数，标识当前处于第几页
 	private int currPage;
-	//列表数据
+	// 列表数据，存储当前页的具体数据记录
 	private List<?> list;
-	
+
 	/**
-	 * 分页
-	 * @param list        列表数据
-	 * @param totalCount  总记录数
-	 * @param pageSize    每页记录数
-	 * @param currPage    当前页数
+	 * 分页构造函数
+	 * 根据提供的列表数据、总记录数、每页记录数和当前页数来初始化分页工具类。
+	 *
+	 * @param list        列表数据，包含当前页的具体记录
+	 * @param totalCount  总记录数，满足查询条件的所有记录的数量
+	 * @param pageSize    每页记录数，指定每一页显示的记录数量
+	 * @param currPage    当前页数，标识当前处于第几页
 	 */
 	public PageUtils(List<?> list, int totalCount, int pageSize, int currPage) {
 		this.list = list;
 		this.total = totalCount;
 		this.pageSize = pageSize;
 		this.currPage = currPage;
-		this.totalPage = (int)Math.ceil((double)totalCount/pageSize);
+		// 计算总页数，使用向上取整的方式确保所有记录都能被包含在某一页中
+		this.totalPage = (int) Math.ceil((double) totalCount / pageSize);
 	}
 
 	/**
-	 * 分页
+	 * 分页构造函数
+	 * 根据MyBatis-Plus的Page对象来初始化分页工具类，提取Page对象中的相关信息。
+	 *
+	 * @param page MyBatis-Plus的Page对象，包含了分页相关的各种信息
 	 */
 	public PageUtils(Page<?> page) {
 		this.list = page.getRecords();
@@ -48,54 +55,66 @@ public class PageUtils implements Serializable {
 		this.currPage = page.getCurrent();
 		this.totalPage = page.getPages();
 	}
-	
-	/*
-	 * 空数据的分页
+
+	/**
+	 * 空数据的分页构造函数
+	 * 根据传入的参数Map来构建一个新的分页对象，这里使用了Query类来处理参数并获取Page对象。
+	 *
+	 * @param params 包含分页相关参数的Map，例如当前页数、每页记录数等
 	 */
 	public PageUtils(Map<String, Object> params) {
- 		Page page =new Query(params).getPage();
+		Page page = new Query(params).getPage();
+		// 使用获取到的Page对象再次调用另一个构造函数来初始化分页工具类
 		new PageUtils(page);
 	}
 
-	 
+	// 获取每页记录数
 	public int getPageSize() {
 		return pageSize;
 	}
 
+	// 设置每页记录数
 	public void setPageSize(int pageSize) {
 		this.pageSize = pageSize;
 	}
 
+	// 获取当前页数
 	public int getCurrPage() {
 		return currPage;
 	}
 
+	// 设置当前页数
 	public void setCurrPage(int currPage) {
 		this.currPage = currPage;
 	}
 
+	// 获取列表数据
 	public List<?> getList() {
 		return list;
 	}
 
+	// 设置列表数据
 	public void setList(List<?> list) {
 		this.list = list;
 	}
 
+	// 获取总页数
 	public long getTotalPage() {
 		return totalPage;
 	}
 
+	// 设置总页数
 	public void setTotalPage(long totalPage) {
 		this.totalPage = totalPage;
 	}
 
+	// 获取总记录数
 	public long getTotal() {
 		return total;
 	}
 
+	// 设置总记录数
 	public void setTotal(long total) {
 		this.total = total;
 	}
-	
-}
+}

back/src/main/java/com/utils/Query.java

@@ -1,4 +1,3 @@
-
 package com.utils;
 
 import java.util.LinkedHashMap;
@@ -9,90 +8,114 @@ import org.apache.commons.lang3.StringUtils;
 import com.baomidou.mybatisplus.plugins.Page;
 
 /**
- * 查询参数
+ * 查询参数类，继承自LinkedHashMap<String, Object>，用于封装查询相关的参数信息，
+ * 并且处理分页和排序等操作，同时对可能存在SQL注入风险的参数进行过滤。
  */
 public class Query<T> extends LinkedHashMap<String, Object> {
-	private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;
     /**
-     * mybatis-plus分页参数
+     * mybatis-plus分页参数对象，用于进行分页查询操作。
      */
     private Page<T> page;
     /**
-     * 当前页码
+     * 当前页码，默认为1。
      */
     private int currPage = 1;
     /**
-     * 每页条数
+     * 每页条数，默认为10。
      */
     private int limit = 10;
 
+    /**
+     * 构造函数，根据JQPageInfo对象来初始化查询参数。
+     *
+     * @param pageInfo 包含分页和排序信息的JQPageInfo对象。
+     */
     public Query(JQPageInfo pageInfo) {
-    	//分页参数
-        if(pageInfo.getPage()!= null){
+        // 处理分页参数
+        if (pageInfo.getPage() != null) {
             currPage = pageInfo.getPage();
         }
-        if(pageInfo.getLimit()!= null){
+        if (pageInfo.getLimit() != null) {
             limit = pageInfo.getLimit();
         }
 
-    
-        //防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
+        // 防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
         String sidx = SQLFilter.sqlInject(pageInfo.getSidx());
         String order = SQLFilter.sqlInject(pageInfo.getOrder());
-        
 
-        //mybatis-plus分页
+        // 创建mybatis-plus分页对象
         this.page = new Page<>(currPage, limit);
 
-        //排序
-        if(StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)){
+        // 进行排序设置
+        if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) {
             this.page.setOrderByField(sidx);
             this.page.setAsc("ASC".equalsIgnoreCase(order));
         }
     }
-    
-    
-    public Query(Map<String, Object> params){
+
+    /**
+     * 构造函数，根据Map类型的参数来初始化查询参数。
+     *
+     * @param params 包含查询参数的Map，可能包含分页、排序等信息。
+     */
+    public Query(Map<String, Object> params) {
+        // 将传入的参数Map中的所有键值对放入当前对象中
         this.putAll(params);
 
-        //分页参数
-        if(params.get("page") != null){
-            currPage = Integer.parseInt((String)params.get("page"));
+        // 处理分页参数
+        if (params.get("page") != null) {
+            currPage = Integer.parseInt((String) params.get("page"));
         }
-        if(params.get("limit") != null){
-            limit = Integer.parseInt((String)params.get("limit"));
+        if (params.get("limit") != null) {
+            limit = Integer.parseInt((String) params.get("limit"));
         }
 
+        // 计算偏移量，并将分页相关参数放入当前对象中
         this.put("offset", (currPage - 1) * limit);
         this.put("page", currPage);
         this.put("limit", limit);
 
-        //防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
-        String sidx = SQLFilter.sqlInject((String)params.get("sidx"));
-        String order = SQLFilter.sqlInject((String)params.get("order"));
+        // 防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
+        String sidx = SQLFilter.sqlInject((String) params.get("sidx"));
+        String order = SQLFilter.sqlInject((String) params.get("order"));
         this.put("sidx", sidx);
         this.put("order", order);
 
-        //mybatis-plus分页
+        // 创建mybatis-plus分页对象
         this.page = new Page<>(currPage, limit);
 
-        //排序
-        if(StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)){
+        // 进行排序设置
+        if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) {
             this.page.setOrderByField(sidx);
             this.page.setAsc("ASC".equalsIgnoreCase(order));
         }
-
     }
 
+    /**
+     * 获取mybatis-plus的分页对象。
+     *
+     * @return mybatis-plus的Page对象。
+     */
     public Page<T> getPage() {
         return page;
     }
 
+    /**
+     * 获取当前页码。
+     *
+     * @return 当前页码。
+     */
     public int getCurrPage() {
         return currPage;
     }
 
+    /**
+     * 获取每页条数。
+     *
+     * @return 每页条数。
+     */
     public int getLimit() {
         return limit;
     }
-}
+}

back/src/main/java/com/utils/R.java

@@ -4,23 +4,46 @@ import java.util.HashMap;
 import java.util.Map;
 
 /**
- * 返回数据
+ * 返回数据类，继承自HashMap<String, Object>，用于封装和返回各种类型的响应数据，
+ * 通常在Web应用中用于构建API的响应结果。
  */
 public class R extends HashMap<String, Object> {
+	// 用于实现序列化版本控制，确保不同版本的类在反序列化时的兼容性
 	private static final long serialVersionUID = 1L;
-	
+
+	/**
+	 * 构造函数，初始化一个默认的响应对象，设置默认的状态码为0（通常表示成功）。
+	 */
 	public R() {
 		put("code", 0);
 	}
-	
+
+	/**
+	 * 静态方法，返回一个表示错误的响应对象，默认状态码为500，错误信息为“未知异常，请联系管理员”。
+	 *
+	 * @return 表示错误的R对象。
+	 */
 	public static R error() {
 		return error(500, "未知异常，请联系管理员");
 	}
-	
+
+	/**
+	 * 静态方法，返回一个表示错误的响应对象，状态码为500，错误信息为传入的msg。
+	 *
+	 * @param msg 错误信息。
+	 * @return 表示错误的R对象。
+	 */
 	public static R error(String msg) {
 		return error(500, msg);
 	}
-	
+
+	/**
+	 * 静态方法，返回一个表示错误的响应对象，状态码为传入的code，错误信息为传入的msg。
+	 *
+	 * @param code 错误状态码。
+	 * @param msg  错误信息。
+	 * @return 表示错误的R对象。
+	 */
 	public static R error(int code, String msg) {
 		R r = new R();
 		r.put("code", code);
@@ -28,24 +51,49 @@ public class R extends HashMap<String, Object> {
 		return r;
 	}
 
+	/**
+	 * 静态方法，返回一个表示成功的响应对象，包含传入的成功信息msg。
+	 *
+	 * @param msg 成功信息。
+	 * @return 表示成功的R对象。
+	 */
 	public static R ok(String msg) {
 		R r = new R();
 		r.put("msg", msg);
 		return r;
 	}
-	
+
+	/**
+	 * 静态方法，返回一个表示成功的响应对象，将传入的Map中的键值对添加到响应对象中。
+	 *
+	 * @param map 包含响应数据的Map。
+	 * @return 表示成功的R对象。
+	 */
 	public static R ok(Map<String, Object> map) {
 		R r = new R();
 		r.putAll(map);
 		return r;
 	}
-	
+
+	/**
+	 * 静态方法，返回一个表示成功的默认响应对象，只包含默认的状态码0。
+	 *
+	 * @return 表示成功的R对象。
+	 */
 	public static R ok() {
 		return new R();
 	}
 
+	/**
+	 * 重写put方法，将键值对添加到响应对象中，并返回当前对象，
+	 * 方便进行链式调用（例如r.put("key1", value1).put("key2", value2)）。
+	 *
+	 * @param key   键。
+	 * @param value 值。
+	 * @return 当前的R对象。
+	 */
 	public R put(String key, Object value) {
 		super.put(key, value);
 		return this;
 	}
-}
+}

back/src/main/java/com/utils/SQLFilter.java

@@ -1,4 +1,3 @@
-
 package com.utils;
 
 import org.apache.commons.lang3.StringUtils;
@@ -6,37 +5,45 @@ import org.apache.commons.lang3.StringUtils;
 import com.entity.EIException;
 
 /**
- * SQL过滤
+ * SQL过滤类，用于对输入的字符串进行SQL注入相关的过滤操作，
+ * 防止恶意的SQL注入攻击。
  */
 public class SQLFilter {
 
     /**
-     * SQL注入过滤
-     * @param str  待验证的字符串
+     * SQL注入过滤方法，对传入的字符串进行一系列的检查和处理，
+     * 以防止其中包含可能导致SQL注入的非法字符或关键字。
+     *
+     * @param str 待验证和过滤的字符串，通常是用户输入的内容，可能会用于SQL语句中。
+     * @return 经过过滤处理后的字符串，如果输入字符串为空则返回null；
+     *         如果字符串包含非法字符，则会抛出EIException异常。
      */
-    public static String sqlInject(String str){
-        if(StringUtils.isBlank(str)){
+    public static String sqlInject(String str) {
+        // 检查输入字符串是否为空或只包含空白字符
+        if (StringUtils.isBlank(str)) {
             return null;
         }
-        //去掉'|"|;|\字符
+        // 去掉字符串中的单引号、双引号、分号和反斜杠字符，这些字符在SQL中可能用于构造恶意语句
         str = StringUtils.replace(str, "'", "");
         str = StringUtils.replace(str, "\"", "");
         str = StringUtils.replace(str, ";", "");
         str = StringUtils.replace(str, "\\", "");
 
-        //转换成小写
+        // 将字符串转换为小写，方便统一检查非法关键字，不区分大小写
         str = str.toLowerCase();
 
-        //非法字符
+        // 定义一个包含常见非法SQL关键字的数组，这些关键字可能被用于恶意的SQL操作
         String[] keywords = {"master", "truncate", "insert", "select", "delete", "update", "declare", "alter", "drop"};
 
-        //判断是否包含非法字符
-        for(String keyword : keywords){
-            if(str.indexOf(keyword) != -1){
+        // 遍历非法关键字数组，检查字符串中是否包含这些关键字
+        for (String keyword : keywords) {
+            if (str.indexOf(keyword) != -1) {
+                // 如果包含非法关键字，则抛出EIException异常，提示包含非法字符
                 throw new EIException("包含非法字符");
             }
         }
 
+        // 如果字符串不包含非法字符和关键字，则返回过滤后的字符串
         return str;
     }
-}
+}

back/src/main/java/com/utils/SpringContextUtils.java

@@ -1,4 +1,3 @@
-
 package com.utils;
 
 import org.springframework.beans.BeansException;
@@ -6,38 +5,78 @@ import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.stereotype.Component;
 
-
 /**
  * Spring Context 工具类
+ * 该类实现了 ApplicationContextAware 接口，用于在 Spring 应用中获取 ApplicationContext 实例，
+ * 从而可以在非 Spring 管理的类中方便地获取 Spring 容器中的 Bean。
  */
 @Component
 public class SpringContextUtils implements ApplicationContextAware {
-	public static ApplicationContext applicationContext; 
-	 
+	// 静态的 ApplicationContext 实例，用于存储 Spring 应用上下文
+	public static ApplicationContext applicationContext;
+
+	/**
+	 * 实现 ApplicationContextAware 接口的方法，Spring 容器会在启动时自动调用该方法，
+	 * 将 ApplicationContext 实例注入到本类中。
+	 *
+	 * @param applicationContext Spring 应用上下文实例
+	 * @throws BeansException 如果在设置 ApplicationContext 时发生错误
+	 */
 	@Override
 	public void setApplicationContext(ApplicationContext applicationContext)
 			throws BeansException {
 		SpringContextUtils.applicationContext = applicationContext;
 	}
 
+	/**
+	 * 根据 Bean 的名称从 Spring 容器中获取 Bean 实例。
+	 *
+	 * @param name Bean 的名称
+	 * @return 对应的 Bean 实例
+	 */
 	public static Object getBean(String name) {
 		return applicationContext.getBean(name);
 	}
 
+	/**
+	 * 根据 Bean 的名称和类型从 Spring 容器中获取指定类型的 Bean 实例。
+	 *
+	 * @param name         Bean 的名称
+	 * @param requiredType Bean 的类型
+	 * @param <T>          Bean 的泛型类型
+	 * @return 对应的 Bean 实例
+	 */
 	public static <T> T getBean(String name, Class<T> requiredType) {
 		return applicationContext.getBean(name, requiredType);
 	}
 
+	/**
+	 * 检查 Spring 容器中是否包含指定名称的 Bean。
+	 *
+	 * @param name Bean 的名称
+	 * @return 如果包含返回 true，否则返回 false
+	 */
 	public static boolean containsBean(String name) {
 		return applicationContext.containsBean(name);
 	}
 
+	/**
+	 * 检查指定名称的 Bean 是否为单例模式。
+	 *
+	 * @param name Bean 的名称
+	 * @return 如果是单例返回 true，否则返回 false
+	 */
 	public static boolean isSingleton(String name) {
 		return applicationContext.isSingleton(name);
 	}
 
+	/**
+	 * 获取指定名称的 Bean 的类型。
+	 *
+	 * @param name Bean 的名称
+	 * @return Bean 的类型
+	 */
 	public static Class<? extends Object> getType(String name) {
 		return applicationContext.getType(name);
 	}
-
 }

back/src/main/java/com/utils/ValidatorUtils.java

@@ -1,7 +1,5 @@
-
 package com.utils;
 
-
 import java.util.Set;
 
 import javax.validation.ConstraintViolation;
@@ -12,28 +10,41 @@ import com.entity.EIException;
 
 /**
  * hibernate-validator校验工具类
+ * 该类借助Hibernate Validator框架，为对象提供校验功能。
+ * 当对象不符合预先定义的约束条件时，会抛出EIException异常。
  */
 public class ValidatorUtils {
+    // 静态的Validator对象，用于执行校验操作。
+    // 由于Validator是线程安全的，使用静态变量可以在整个应用程序中共享同一个实例，提高性能。
     private static Validator validator;
 
+    // 静态代码块，在类加载时执行，确保Validator对象只被初始化一次。
+    // 通过Validation类构建默认的验证工厂，然后从工厂中获取Validator实例。
     static {
         validator = Validation.buildDefaultValidatorFactory().getValidator();
     }
 
     /**
-     * 校验对象
-     * @param object        待校验对象
-     * @param groups        待校验的组
-     * @throws EIException  校验不通过，则报EIException异常
+     * 校验对象的方法
+     *
+     * @param object 待校验的对象，该对象需要使用Hibernate Validator的注解来定义约束条件。
+     * @param groups 待校验的组，可用于指定在不同场景下应用不同的约束条件。
+     * @throws EIException 若校验不通过，即对象存在违反约束的情况，会抛出EIException异常。
+     *                      异常信息为第一个违反约束的详细描述。
      */
     public static void validateEntity(Object object, Class<?>... groups)
             throws EIException {
+        // 调用Validator的validate方法对对象进行校验，根据指定的组应用相应的约束条件。
+        // 该方法会返回一个包含所有违反约束信息的Set集合。
         Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups);
+
+        // 检查约束违反集合是否为空，若不为空则表示存在校验不通过的情况。
         if (!constraintViolations.isEmpty()) {
-        	ConstraintViolation<Object> constraint = (ConstraintViolation<Object>)constraintViolations.iterator().next();
+            // 获取集合中的第一个违反约束的信息。
+            // 这里仅取第一个违反约束的信息作为异常信息抛出，可能会忽略其他违反约束的情况。
+            ConstraintViolation<Object> constraint = (ConstraintViolation<Object>)constraintViolations.iterator().next();
+            // 抛出EIException异常，将违反约束的详细信息作为异常消息。
             throw new EIException(constraint.getMessage());
         }
     }
-    
-    
 }

back/src/main/resources/front/front/index.html

@@ -1,329 +1,319 @@
 <!-- 首页 -->
 <!DOCTYPE html>
 <html>
-	<head>
-		<meta charset="utf-8">
-		<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-		<title>首页</title>
-		<link rel="stylesheet" href="./layui/css/layui.css">
-		<link rel="stylesheet" href="./xznstatic/css/common.css"/>
-		<link rel="stylesheet" href="./xznstatic/css/style.css"/>
-	</head>
-	<style type="text/css">
-		html, body {
-			height: 100%;
-		}
-		#iframe {
-			width: 100%;
-			margin-top: 50px;
-						padding-top: 64px;
-					}
-		#header {
-			height: auto;
-			background: #fff;
-			border-bottom: 0;
-			position: fixed;
-			top: 0;
-			left: 0;
-			width: 100%;
-			z-index: 1;
-		}
+<head>
+	<!-- 设置字符编码为 UTF-8 -->
+	<meta charset="utf-8">
+	<!-- 设置视口，用于响应式布局，宽度等于设备宽度，初始缩放比例为 1，最大缩放比例为 1 -->
+	<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
+	<title>首页</title>
+	<!-- 引入 layui 的 CSS 样式文件 -->
+	<link rel="stylesheet" href="./layui/css/layui.css">
+	<!-- 引入自定义的 common.css 样式文件 -->
+	<link rel="stylesheet" href="./xznstatic/css/common.css"/>
+	<!-- 引入自定义的 style.css 样式文件 -->
+	<link rel="stylesheet" href="./xznstatic/css/style.css"/>
+</head>
+<style type="text/css">
+	html, body {
+		height: 100%;
+	}
+	/* 定义 id 为 iframe 的元素样式，宽度 100%，上边距 50px，内边距顶部 64px */
+	#iframe {
+		width: 100%;
+		margin-top: 50px;
+		padding-top: 64px;
+	}
+	/* 定义 id 为 header 的元素样式，高度自适应，白色背景，固定定位在顶部，宽度 100%，z 轴层级为 1 */
+	#header {
+		height: auto;
+		background: #fff;
+		border-bottom: 0;
+		position: fixed;
+		top: 0;
+		left: 0;
+		width: 100%;
+		z-index: 1;
+	}
 
-		#header .nav-top {
-			display: flex;
-			align-items: center;
-			padding: 0 20px;
-			font-size: 16px;
-			color: #2a8a15;
-			box-sizing: border-box;
-			height: 50px;
-			background: #CB945C;
-			box-shadow: 0 0px 0px rgba(0,0,0,.3);
-			justify-content: center;
-			position: relative;
-			z-index: 1;
-		}
+	/* 定义 id 为 header 下的.nav-top 类元素样式，弹性布局，水平居中对齐，设置字体大小、颜色等 */
+	#header .nav-top {
+		display: flex;
+		align-items: center;
+		padding: 0 20px;
+		font-size: 16px;
+		color: #2a8a15;
+		box-sizing: border-box;
+		height: 50px;
+		background: #CB945C;
+		box-shadow: 0 0px 0px rgba(0, 0, 0,.3);
+		justify-content: center;
+		position: relative;
+		z-index: 1;
+	}
 
-		#header .nav-top-img {
-			width: 124px;
-			height: 40px;
-			padding: 0;
-			margin: 0;
-			border-radius: 6px;
-			border-width: 0;
-			border-style: solid;
-			border-color: rgba(0,0,0,.3);
-			box-shadow: 0 0 6px rgba(0,0,0,.3);
-		}
+	/* 定义 id 为 header 下的.nav-top-img 类元素样式，设置宽度、高度、边框等 */
+	#header .nav-top-img {
+		width: 124px;
+		height: 40px;
+		padding: 0;
+		margin: 0;
+		border-radius: 6px;
+		border-width: 0;
+		border-style: solid;
+		border-color: rgba(0, 0, 0,.3);
+		box-shadow: 0 0 6px rgba(0, 0, 0,.3);
+	}
 
-		#header .nav-top-title {
-			line-height: 40px;
-			font-size: 20px;
-			color: rgba(255, 255, 255, 1);
-			padding: 0 10px;
-			margin: 0 10px;
-			border-radius: 6px;
-			border-width: 0;
-			border-style: solid;
-			border-color: rgba(0,0,0,.3);
-						background-color: rgba(0,0,0,0);
-						box-shadow: 0 0 0px rgba(0,0,0,.3);
-		}
-
-		#header .nav-top-tel {
-			line-height: 40px;
-			font-size: 16px;
-			color: #333;
-			padding: 0 10px;
-			margin: 0;
-			border-radius: 6px;
-			border-width: 0;
-			border-style: solid;
-			border-color: rgba(0,0,0,.3);
-			box-shadow: 0 0 6px rgba(0,0,0,.3);
-		}
+	/* 定义 id 为 header 下的.nav-top-title 类元素样式，设置行高、字体大小、颜色、背景等 */
+	#header .nav-top-title {
+		line-height: 40px;
+		font-size: 20px;
+		color: rgba(255, 255, 255, 1);
+		padding: 0 10px;
+		margin: 0 10px;
+		border-radius: 6px;
+		border-width: 0;
+		border-style: solid;
+		border-color: rgba(0, 0, 0,.3);
+		background-color: rgba(0, 0, 0, 0);
+		box-shadow: 0 0 0px rgba(0, 0, 0,.3);
+	}
 
-		#header .navs {
-			display: flex;
-			padding: 0 20px;
-			align-items: center;
-			box-sizing: border-box;
-			height: 64px;
-			background: #F2F2F2;
-			box-shadow: 0 1px 6px rgba(0,0,0,0);
-			justify-content: center;
-		}
-		#header .navs1 {
-			width: 200px;
-			height: 100vh;
-			background: darkgoldenrod;
-			position: absolute;
-			top: 0;
-			display: block;
-			padding: 0;
-			overflow-y: scroll;
-			scrollbar-width: none;
-			-ms-overflow-style: none;
-		}
-		
-		#header .navs.navs1::-webkit-scrollbar {
-			display: none;
-		}
-		
-		#header .navs1 .list {
-			display: flex;
-			flex-direction: column;
-		}
-		#header .navs .title {
-			width: auto;
-			line-height: 40px;
-			font-size: 16px;
-			color: #333;
-			padding: 0 10px;
-			margin: 0 5px;
-			border-radius: 6px;
-			border-width: 0;
-			border-style: solid;
-			border-color: rgba(0,0,0,.3);
-						background-color: rgba(0,0,0,0);
-						box-shadow: 0 0 6px rgba(0,0,0,0);
-		}
-		#header .navs li {
-			display: inline-block;
-			width: auto;
-			line-height: 34px;
-			padding: 0 20px;
-			margin: 0 5px;
-			color: rgba(0, 0, 0, 1);
-			font-size: 16px;
-			border-radius: 10px;
-			border-width: 10px 0 0;
-			border-style: solid;
-			border-color: rgba(143, 143, 143, 1);
-			background-color: rgba(217, 217, 217, 1);
-			box-shadow: 0 0 0px rgba(0,0,0,.1);
-			text-align: center;
-			box-sizing: border-box;
-			cursor: pointer;
-		}
-		#header .navs li a{
-			color: inherit;
-		}
-		#header .navs li.current a{
-			color: inherit;
-		}
-		#header .navs li a:hover{
-			color: inherit;
-		}
-		#header .navs li.current {
-			color: rgba(0, 0, 0, 1);
-			font-size: 16px;
-			border-radius: 10px;
-			border-width: 10px 0 0;
-			border-style: solid;
-			border-color: rgba(213, 169, 122, 1);
-			background-color: rgba(223, 195, 153, 1);
-			box-shadow: 0 0 0px rgba(255,0,0,.8);
-		}
-		#header .navs li:hover {
-			color: rgba(0, 0, 0, 1);
-			font-size: 16px;
-			border-radius: 10px;
-			border-width: 10px 0 0;
-			border-style: solid;
-			border-color: rgba(213, 169, 122, 1);
-			background-color: rgba(223, 195, 153, 1);
-			box-shadow: 0 0 0px rgba(0,0,0,.3);
-		}
-	</style>
-	<body>
-		<!-- start 顶部导航栏 -->
-		<div id="header">
-			<div v-if='true' class="nav-top">
-			  <img v-if='false' class="nav-top-img" src='http://codegen.caihongy.cn/20220207/32e8fb282bd04ae883c7a780558e97f8.png'>
-			  <div v-if="true" class="nav-top-title">{{projectName}}</div>
-			  <div class="nav-top-tel"></div>
-			</div>
-					    <div class="navs">
-		    	<!-- <div class="logo" style="font-size: 20px;top: 32px;color: #fff;font-weight: bold;margin-left: -200px;width: 240px;" v-text="projectName"></div> -->
-				<div class="title" v-if="false" v-text="projectName"></div>
-				<div class="list">
-					<ul>
-						<li class='current'><a href="javascript:navPage('./pages/home/home.html')" class="menumain"><i v-if="false" class="layui-icon layui-icon-home"></i>首页</a></li>
-						<li v-for="(item,index) in indexNav" v-bind:key="index"><a :href="'javascript:navPage(\''+item.url+'\')'" class="menumain" style="cursor: pointer;"><i v-if="false" class="layui-icon" :class="iconArr[index]"></i>{{item.name}}</a></li>
-						<li><a href="javascript:centerPage();" class="menumain"><i v-if="false" class="layui-icon layui-icon-username"></i>个人中心</a></li>
-						<li><a :href="adminurl" target="_blank" class="menumain" style="cursor: pointer;"><i v-if="false" class="layui-icon layui-icon-link"></i>后台管理</a></li>
-					</ul>
-				</div>
-		    </div>
-								</div>
-		<!-- end 顶部导航栏 -->
+	/* 定义 id 为 header 下的.nav-top-tel 类元素样式，设置行高、字体大小、颜色、边框等 */
+	#header .nav-top-tel {
+		line-height: 40px;
+		font-size: 16px;
+		color: #333;
+		padding: 0 10px;
+		margin: 0;
+		border-radius: 6px;
+		border-width: 0;
+		border-style: solid;
+		border-color: rgba(0, 0, 0,.3);
+		box-shadow: 0 0 6px rgba(0, 0, 0,.3);
+	}
 
-		<iframe src="./pages/home/home.html" id="iframe" frameborder="0" scrolling="no" width="100%" onload="changeFrameHeight"></iframe>
+	/* 定义 id 为 header 下的.navs 类元素样式，弹性布局，设置高度、背景、阴影等 */
+	#header .navs {
+		display: flex;
+		padding: 0 20px;
+		align-items: center;
+		box-sizing: border-box;
+		height: 64px;
+		background: #F2F2F2;
+		box-shadow: 0 1px 6px rgba(0, 0, 0, 0);
+		justify-content: center;
+	}
+	/* 定义 id 为 header 下的.navs1 类元素样式，设置宽度、高度、背景、定位等 */
+	#header .navs1 {
+		width: 200px;
+		height: 100vh;
+		background: darkgoldenrod;
+		position: absolute;
+		top: 0;
+		display: block;
+		padding: 0;
+		overflow-y: scroll;
+		scrollbar-width: none;
+		-ms-overflow-style: none;
+	}
 
-		<script src="./xznstatic/js/jquery-1.11.3.min.js"></script>
-		<script src="./layui/layui.js"></script>
-		<script src="./js/vue.js"></script>
-		<script src="./js/config.js"></script>
+	/* 隐藏 id 为 header 下的.navs1 类元素的滚动条（webkit 内核浏览器） */
+	#header .navs.navs1::-webkit-scrollbar {
+		display: none;
+	}
 
-		<script>
-      var vue1 = new Vue({el: '#tabbar'})
+	/* 定义 id 为 header 下的.navs1 类元素下的.list 类元素样式，设置为弹性列布局 */
+	#header .navs1 .list {
+		display: flex;
+		flex-direction: column;
+	}
 
-			var vue = new Vue({
-				el: '#header',
-				data: {
-					iconArr: ['layui-icon-gift','layui-icon-email','layui-icon-logout','layui-icon-transfer','layui-icon-slider','layui-icon-print','layui-icon-cols','layui-icon-snowflake','layui-icon-note','layui-icon-flag','layui-icon-theme','layui-icon-website','layui-icon-console','layui-icon-face-surprised','layui-icon-template-1','layui-icon-app','layui-icon-read','layui-icon-component','layui-icon-file-b','layui-icon-unlink','layui-icon-tabs','layui-icon-form','layui-icon-chat'],
-					indexNav: indexNav,
-					cartFlag: cartFlag,
-					adminurl: adminurl,
-					chatFlag: chatFlag,
-					projectName: projectName,
-				},
-				mounted: function() {
-					this.bindClickOnLi();
-				},
-				created() {
-					this.iconArr.sort(()=>{
-					  return (0.5-Math.random())
-					})
-				},
-				methods: {
-					jump(url) {
-						jump(url)
-					},
-					bindClickOnLi() {
-						let list = document.getElementsByTagName("li");
-						for(var i = 0;i<list.length;i++){
-							list[i].onclick = function(){
-								$(this).addClass("current").siblings().removeClass("current");
-                                localStorage.setItem("checkedLiIndex",$(this).index());
-							}
-						}
-					}
-				}
-			});
+	/* 定义 id 为 header 下的.navs 类元素下的.title 类元素样式，设置行高、字体大小、颜色、边框等 */
+	#header .navs .title {
+		width: auto;
+		line-height: 40px;
+		font-size: 16px;
+		color: #333;
+		padding: 0 10px;
+		margin: 0 5px;
+		border-radius: 6px;
+		border-width: 0;
+		border-style: solid;
+		border-color: rgba(0, 0, 0,.3);
+		background-color: rgba(0, 0, 0, 0);
+		box-shadow: 0 0 6px rgba(0, 0, 0, 0);
+	}
 
-			layui.use(['element','layer'], function() {
-				var element = layui.element;
-				var layer = layui.layer;
-			});
+	/* 定义 id 为 header 下的.navs 类元素下的 li 元素样式，设置为行内块元素，设置行高、颜色、字体大小、边框等 */
+	#header .navs li {
+		display: inline-block;
+		width: auto;
+		line-height: 34px;
+		padding: 0 20px;
+		margin: 0 5px;
+		color: rgba(0, 0, 0, 1);
+		font-size: 16px;
+		border-radius: 10px;
+		border-width: 10px 0 0;
+		border-style: solid;
+		border-color: rgba(143, 143, 143, 1);
+		background-color: rgba(217, 217, 217, 1);
+		box-shadow: 0 0 0px rgba(0, 0, 0,.1);
+		text-align: center;
+		box-sizing: border-box;
+		cursor: pointer;
+	}
 
-			function chatTap(){
-				var userTable = localStorage.getItem('userTable');
-				if (userTable) {
-					layui.layer.open({
-						type: 2,
-						title: '客服',
-						area: ['600px', '600px'],
-						content: './pages/chat/chat.html'
-					});
-				} else {
-					window.location.href = './pages/login/login.html'
-				}
-			}
+	/* 定义 id 为 header 下的.navs 类元素下的 li 元素内的 a 元素样式，设置颜色继承 */
+	#header .navs li a {
+		color: inherit;
+	}
 
-			// 导航栏跳转
-			function navPage(url) {
-				localStorage.setItem('iframeUrl', url);
-				document.getElementById('iframe').src = url;
-			}
+	/* 定义 id 为 header 下的.navs 类元素下的 li 元素带有 current 类时的 a 元素样式，设置颜色继承 */
+	#header .navs li.current a {
+		color: inherit;
+	}
 
-			// 跳转到个人中心也
-			function centerPage() {
-				var userTable = localStorage.getItem('userTable');
-				if (userTable) {
-					localStorage.setItem('iframeUrl', './pages/' + userTable + '/center.html');
-					document.getElementById('iframe').src = './pages/' + userTable + '/center.html';
-				} else {
-					window.location.href = './pages/login/login.html'
-				}
-			}
+	/* 定义 id 为 header 下的.navs 类元素下的 li 元素内的 a 元素鼠标悬停时的样式，设置颜色继承 */
+	#header .navs li a:hover {
+		color: inherit;
+	}
 
-			var iframeUrl = localStorage.getItem('iframeUrl');
-			document.getElementById('iframe').src = iframeUrl  || './pages/home/home.html';
+	/* 定义 id 为 header 下的.navs 类元素下的 li 元素带有 current 类时的样式，设置颜色、字体大小、边框等 */
+	#header .navs li.current {
+		color: rgba(0, 0, 0, 1);
+		font-size: 16px;
+		border-radius: 10px;
+		border-width: 10px 0 0;
+		border-style: solid;
+		border-color: rgba(213, 169, 122, 1);
+		background-color: rgba(223, 195, 153, 1);
+		box-shadow: 0 0 0px rgba(255, 0, 0,.8);
+	}
 
-            let list = document.getElementsByTagName("li");
-            for(var i = 0;i<list.length;i++){
-                if(i==localStorage.getItem("checkedLiIndex")) {
-                    $(list[i]).addClass("current").siblings().removeClass("current");
-                }
-            }
+	/* 定义 id 为 header 下的.navs 类元素下的 li 元素鼠标悬停时的样式，设置颜色、字体大小、边框等 */
+	#header .navs li:hover {
+		color: rgba(0, 0, 0, 1);
+		font-size: 16px;
+		border-radius: 10px;
+		border-width: 10px 0 0;
+		border-style: solid;
+		border-color: rgba(213, 169, 122, 1);
+		background-color: rgba(223, 195, 153, 1);
+		box-shadow: 0 0 0px rgba(0, 0, 0,.3);
+	}
+</style>
+<body>
+<!-- start 顶部导航栏 -->
+<div id="header">
+	<!-- 根据条件 v-if 显示或隐藏.nav-top 类元素 -->
+	<div v-if='true' class="nav-top">
+		<!-- 根据条件 v-if 显示或隐藏.nav-top-img 类元素 -->
+		<img v-if='false' class="nav-top-img" src='http://codegen.caihongy.cn/20220207/32e8fb282bd04ae883c7a780558e97f8.png'>
+		<!-- 根据条件 v-if 显示或隐藏.nav-top-title 类元素，并绑定 Vue 数据 projectName -->
+		<div v-if="true" class="nav-top-title">{{projectName}}</div>
+		<div class="nav-top-tel"></div>
+	</div>
+	<div class="navs">
+		<!-- <div class="logo" style="font-size: 20px;top: 32px;color: #fff;font-weight: bold;margin-left: -200px;width: 240px;" v-text="projectName"></div> -->
+		<!-- 根据条件 v-if 显示或隐藏.title 类元素，并绑定 Vue 数据 projectName -->
+		<div class="title" v-if="false" v-text="projectName"></div>
+		<div class="list">
+			<ul>
+				<!-- 带有 current 类的 li 元素，表示当前选中项，点击时调用 navPage 函数跳转到指定页面 -->
+				<li class='current'><a href="javascript:navPage('./pages/home/home.html')" class="menumain"><i v-if="false" class="layui-icon layui-icon-home"></i>首页</a></li>
+				<!-- 循环渲染 li 元素，根据 indexNav 数组的数据生成导航项，点击时调用 navPage 函数跳转到指定页面 -->
+				<li v-for="(item, index) in indexNav" v-bind:key="index"><a :href="'javascript:navPage(\'' + item.url + '\')'" class="menumain" style="cursor: pointer;"><i v-if="false" class="layui-icon" :class="iconArr[index]"></i>{{item.name}}</a></li>
+				<!-- 点击时调用 centerPage 函数跳转到个人中心页面，根据条件判断是否显示图标 -->
+				<li><a href="javascript:centerPage();" class="menumain"><i v-if="false" class="layui-icon layui-icon-username"></i>个人中心</a></li>
+				<!-- 点击时在新窗口打开后台管理页面，根据数据绑定生成 href 属性 -->
+				<li><a :href="adminurl" target="_blank" class="menumain" style="cursor: pointer;"><i v-if="false" class="layui-icon layui-icon-link"></i>后台管理</a></li>
+			</ul>
+		</div>
+	</div>
+</div>
+<!-- end 顶部导航栏 -->
 
-      // var i = 0;
-      setInterval(function(){
-        // i++;
-        // if(i<50) changeFrameHeight();
-        changeFrameHeight();
-      },200)
+<!-- 引入一个 iframe 元素，初始加载指定页面，id 为 iframe，无边框，不显示滚动条，宽度 100%，加载完成时调用 changeFrameHeight 函数 -->
+<iframe src="./pages/home/home.html" id="iframe" frameborder="0" scrolling="no" width="100%" onload="changeFrameHeight"></iframe>
 
-      function changeFrameHeight() {
-        var iframe = document.getElementById('iframe');
-        // iframe.height = 'auto';
-          if (iframe) {
-              var iframeWin = iframe.contentWindow || iframe.contentDocument.parentWindow;
-              if (iframeWin.document.body) {
-                  iframe.height = iframeWin.document.body.scrollHeight;
-              }
-          }
-      };
+<!-- 引入 jQuery 库文件 -->
+<script src="./xznstatic/js/jquery-1.11.3.min.js"></script>
+<!-- 引入 layui 的 JavaScript 文件 -->
+<script src="./layui/layui.js"></script>
+<!-- 引入 Vue 库文件 -->
+<script src="./js/vue.js"></script>
+<!-- 引入自定义的 config.js 文件 -->
+<script src="./js/config.js"></script>
 
-			//  窗口变化时候iframe自适应
-			// function changeFrameHeight() {
-				// var header = document.getElementById('header').scrollHeight;
-    //     let isshow = false
-    //     var tabbar = 0
-    //     if(isshow) {
-    //       tabbar = document.getElementById('tabbar').scrollHeight
-    //     }
-				// var ifm = document.getElementById("iframe");
-				// ifm.height = document.documentElement.clientHeight - header - tabbar;
-				// ifm.width = document.documentElement.clientWidth;
-			// }
+<script>
+	// 创建一个 Vue 实例，绑定到 id 为 tabbar 的元素上（当前代码中未看到该元素，可能是代码不完整）
+	var vue1 = new Vue({
+		el: '#tabbar'
+	})
 
-			// reasize 事件 窗口大小变化后执行的方法
-			window.onresize = function() {
-				changeFrameHeight();
+	// 创建一个 Vue 实例，绑定到 id 为 header 的元素上
+	var vue = new Vue({
+		el: '#header',
+		data: {
+			// 图标类名数组，用于循环渲染图标
+			iconArr: ['layui-icon-gift', 'layui-icon-email', 'layui-icon-logout', 'layui-icon-transfer', 'layui-icon-slider', 'layui-icon-print', 'layui-icon-cols', 'layui-icon-snowflake', 'layui-icon-note', 'layui-icon-flag', 'layui-icon-theme', 'layui-icon-website', 'layui-icon-console', 'layui-icon-face-surprised', 'layui-icon-template-1', 'layui-icon-app', 'layui-icon-read', 'layui-icon-component', 'layui-icon-file-b', 'layui-icon-unlink', 'layui-icon-tabs', 'layui-icon-form', 'layui-icon-chat'],
+			// 导航项数据数组，用于循环渲染导航栏的项
+			indexNav: indexNav,
+			// 购物车标志（未看到具体使用逻辑，可能是代码不完整）
+			cartFlag: cartFlag,
+			// 后台管理页面的 URL
+			adminurl: adminurl,
+			// 聊天标志（未看到具体使用逻辑，可能是代码不完整）
+			chatFlag: chatFlag,
+			// 项目名称，用于显示在导航栏
+			projectName: projectName,
+		},
+		mounted: function () {
+			// 页面挂载完成后，调用 bindClickOnLi 方法绑定 li 元素的点击事件
+			this.bindClickOnLi();
+		},
+		created() {
+			// 在实例创建时，对 iconArr 数组进行随机排序
+			this.iconArr.sort(() => {
+				return (0.5 - Math.random())
+			})
+		},
+		methods: {
+			// 跳转方法，调用外部的 jump 函数（未看到具体实现，可能是代码不完整）
+			jump(url) {
+				jump(url)
+			},
+			// 绑定 li 元素点击事件的方法，添加或移除 current 类
+			bindClickOnLi() {
+				let list = document.getElementsByTagName("li");
+				for (var i = 0; i < list.length; i++) {
+					list[i].onclick = function () {
+						$(this).addClass("current").siblings().removeClass("current");
+						localStorage.setItem("checkedLiIndex", $(this).index());
+					}
+				}
 			}
-		</script>
-	</body>
-</html>
+		}
+	});
+
+	// 加载 layui 的 element 和 layer 模块
+	layui.use(['element', 'layer'], function () {
+		var element = layui.element;
+		var layer = layui.layer;
+	});
+
+	// 聊天点击事件处理函数，根据用户登录状态决定是打开聊天窗口还是跳转到登录页面
+	function chatTap() {
+		var userTable = localStorage.getItem('userTable');
+		if (userTable) {
+			layui.layer.open({
+				type: 2,
+				title: '客服',
+				area: ['600px', '600px'],
+				content: './pages/chat/chat.html'
+			});
+		} else {
+			window.location.href = './pages/login

back/src/main/resources/mapper/CommonDao.xml

@@ -1,70 +1,104 @@
 <?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">
 
+<!-- 定义命名空间，对应 DAO 接口 -->
 <mapper namespace="com.dao.CommonDao">
+	<!-- 查询指定列的不重复值，排除空值和空字符串 -->
+	<!-- 可根据 level 和 parent 条件进行筛选 -->
 	<select id="getOption" resultType="String" >
-		SELECT distinct ${column} FROM ${table} 
-			where ${column} is not null and ${column} !=''
-			<if test = "level != null"> 
-			and level=#{level} 
-			</if>
-			<if test = "parent != null"> 
-			and parent=#{parent} 
-			</if>
+		<!-- 查询指定表中指定列的不重复值 -->
+		SELECT distinct ${column} FROM ${table}
+		<!-- 排除列值为 null 和空字符串的情况 -->
+		where ${column} is not null and ${column} !=''
+		<!-- 如果 level 参数不为空，添加 level 条件 -->
+		<if test = "level != null">
+			and level=#{level}
+		</if>
+		<!-- 如果 parent 参数不为空，添加 parent 条件 -->
+		<if test = "parent != null">
+			and parent=#{parent}
+		</if>
 	</select>
-	
+
+	<!-- 根据指定列的值查询表中的所有列 -->
 	<select id="getFollowByOption" resultType="map" >
+		<!-- 查询指定表中指定列等于指定值的所有记录 -->
 		SELECT * FROM ${table} where ${column}=#{columnValue}
 	</select>
-	
+
+	<!-- 根据 id 更新表中的 sfsh 字段 -->
 	<update id="sh">
+		<!-- 更新指定表中 id 等于指定值的记录的 sfsh 字段 -->
 		UPDATE ${table} set sfsh=#{sfsh} where id=#{id}
 	</update>
-	
+
+	<!-- 根据不同条件统计记录数量 -->
 	<select id="remindCount" resultType="int" >
-		SELECT count(1) FROM ${table} 
-			where 1=1 
-			<if test = "type == 1 ">
-				<if test = " remindstart != null ">
-				     and ${column} &gt;= #{remindstart}
-				</if>
-				<if test = " remindend != null ">
-				     and ${column} &lt;= #{remindend}
-				</if>
+		<!-- 统计指定表中的记录数量 -->
+		SELECT count(1) FROM ${table}
+		<!-- 基础条件，始终为真 -->
+		where 1=1
+		<!-- 如果 type 为 1 -->
+		<if test = "type == 1 ">
+			<!-- 如果 remindstart 参数不为空，添加大于等于条件 -->
+			<if test = " remindstart != null ">
+				and ${column} &gt;= #{remindstart}
+			</if>
+			<!-- 如果 remindend 参数不为空，添加小于等于条件 -->
+			<if test = " remindend != null ">
+				and ${column} &lt;= #{remindend}
 			</if>
-			<if test = "type == 2 ">
-				<if test = " remindstart != null ">
-				     and ${column} &gt;= str_to_date(#{remindstart},'%Y-%m-%d')
-				</if>
-				<if test = " remindend != null ">
-				     and ${column} &lt;= str_to_date(#{remindend},'%Y-%m-%d')
-				</if>
+		</if>
+		<!-- 如果 type 为 2 -->
+		<if test = "type == 2 ">
+			<!-- 如果 remindstart 参数不为空，添加大于等于日期转换后的条件 -->
+			<if test = " remindstart != null ">
+				and ${column} &gt;= str_to_date(#{remindstart},'%Y-%m-%d')
 			</if>
+			<!-- 如果 remindend 参数不为空，添加小于等于日期转换后的条件 -->
+			<if test = " remindend != null ">
+				and ${column} &lt;= str_to_date(#{remindend},'%Y-%m-%d')
+			</if>
+		</if>
 	</select>
-	
+
+	<!-- 对指定列进行聚合计算，包括求和、最大值、最小值和平均值 -->
 	<select id="selectCal" resultType="map" >
+		<!-- 对指定表中的指定列进行求和、求最大值、求最小值和求平均值 -->
 		SELECT sum(${column}) sum,max(${column}) max,min(${column}) min,avg(${column}) avg FROM ${table}
 	</select>
-	
+
+	<!-- 对指定列进行分组统计，统计每组的记录数量 -->
 	<select id="selectGroup" resultType="map" >
+		<!-- 对指定表中的指定列进行分组，并统计每组的记录数量 -->
 		SELECT ${column} , count(1) total FROM ${table} group by ${column}
 	</select>
-	
+
+	<!-- 对指定的 x 列和 y 列进行分组统计，统计每组 y 列的总和 -->
 	<select id="selectValue" resultType="map" >
+		<!-- 对指定表中的 x 列进行分组，并统计每组 y 列的总和 -->
 		SELECT ${xColumn}, sum(${yColumn}) total FROM ${table} group by ${xColumn}
 	</select>
 
-        <select id="selectTimeStatValue" resultType="map" >
-                <if test = 'timeStatType == "日"'>
-                        SELECT DATE_FORMAT(${xColumn},'%Y-%m-%d') ${xColumn}, sum(${yColumn}) total FROM ${table} group by DATE_FORMAT(${xColumn},'%Y-%m-%d')
-                </if>
-                <if test = 'timeStatType == "月"'>
-                        SELECT DATE_FORMAT(${xColumn},'%Y-%m') ${xColumn}, sum(${yColumn}) total FROM ${table} group by DATE_FORMAT(${xColumn},'%Y-%m')
-                </if>
-                <if test = 'timeStatType == "年"'>
-                        SELECT DATE_FORMAT(${xColumn},'%Y') ${xColumn}, sum(${yColumn}) total FROM ${table} group by DATE_FORMAT(${xColumn},'%Y')
-                </if>
-        </select>
-    <select id="getFollowByOption2" resultType="java.lang.String"></select>
+	<!-- 根据不同的时间统计类型对指定的 x 列和 y 列进行分组统计，统计每组 y 列的总和 -->
+	<select id="selectTimeStatValue" resultType="map" >
+		<!-- 如果时间统计类型为日 -->
+		<if test = 'timeStatType == "日"'>
+			<!-- 按日对指定表中的 x 列进行分组，并统计每组 y 列的总和 -->
+			SELECT DATE_FORMAT(${xColumn},'%Y-%m-%d') ${xColumn}, sum(${yColumn}) total FROM ${table} group by DATE_FORMAT(${xColumn},'%Y-%m-%d')
+		</if>
+		<!-- 如果时间统计类型为月 -->
+		<if test = 'timeStatType == "月"'>
+			<!-- 按月对指定表中的 x 列进行分组，并统计每组 y 列的总和 -->
+			SELECT DATE_FORMAT(${xColumn},'%Y-%m') ${xColumn}, sum(${yColumn}) total FROM ${table} group by DATE_FORMAT(${xColumn},'%Y-%m')
+		</if>
+		<!-- 如果时间统计类型为年 -->
+		<if test = 'timeStatType == "年"'>
+			<!-- 按年对指定表中的 x 列进行分组，并统计每组 y 列的总和 -->
+			SELECT DATE_FORMAT(${xColumn},'%Y') ${xColumn}, sum(${yColumn}) total FROM ${table} group by DATE_FORMAT(${xColumn},'%Y')
+		</if>
+	</select>
+	<!-- 此查询方法未实现具体的 SQL 逻辑 -->
+	<select id="getFollowByOption2" resultType="java.lang.String"></select>
 
-</mapper>
+</mapper>

back/src/main/resources/mapper/ConfigDao.xml

@@ -1,5 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- 定义 XML 文档的版本和字符编码 -->
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 引入 MyBatis Mapper 的 DTD 定义，以确保 XML 文件格式符合 MyBatis 的要求 -->
 
 <mapper namespace="com.dao.ConfigDao">
+    <!-- 定义一个 MyBatis 的 Mapper 命名空间，该命名空间对应一个 DAO 接口，这里是 com.dao.ConfigDao -->
+    <!-- 后续可以在这个命名空间下定义 SQL 语句映射 -->
 </mapper>

back/src/main/resources/mapper/DiscussjiudianjianjieDao.xml

@@ -1,40 +1,67 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- 声明 XML 文档的版本和字符编码 -->
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<!-- 引入 MyBatis Mapper 的 DTD 定义，确保 XML 文件符合 MyBatis 的规范 -->
 
 <mapper namespace="com.dao.DiscussjiudianjianjieDao">
+	<!-- 定义 Mapper 的命名空间，对应 DAO 接口 com.dao.DiscussjiudianjianjieDao -->
 
 	<!-- 可根据自己的需求，是否要使用 -->
-    <resultMap type="com.entity.DiscussjiudianjianjieEntity" id="discussjiudianjianjieMap">
-        <result property="refid" column="refid"/>
-        <result property="userid" column="userid"/>
-        <result property="nickname" column="nickname"/>
-        <result property="content" column="content"/>
-        <result property="reply" column="reply"/>
-    </resultMap>
+	<resultMap type="com.entity.DiscussjiudianjianjieEntity" id="discussjiudianjianjieMap">
+		<!-- 定义一个结果映射，将数据库查询结果映射到 com.entity.DiscussjiudianjianjieEntity 实体类 -->
+		<!-- 映射实体类的 refid 属性到数据库表的 refid 列 -->
+		<result property="refid" column="refid"/>
+		<!-- 映射实体类的 userid 属性到数据库表的 userid 列 -->
+		<result property="userid" column="userid"/>
+		<!-- 映射实体类的 nickname 属性到数据库表的 nickname 列 -->
+		<result property="nickname" column="nickname"/>
+		<!-- 映射实体类的 content 属性到数据库表的 content 列 -->
+		<result property="content" column="content"/>
+		<!-- 映射实体类的 reply 属性到数据库表的 reply 列 -->
+		<result property="reply" column="reply"/>
+	</resultMap>
 
 	<select id="selectListVO"
-		resultType="com.entity.vo.DiscussjiudianjianjieVO" >
-		SELECT * FROM discussjiudianjianjie  discussjiudianjianjie         
-        <where> 1=1 ${ew.sqlSegment}</where>
+			resultType="com.entity.vo.DiscussjiudianjianjieVO">
+		<!-- 定义一个查询语句，ID 为 selectListVO，用于查询数据列表 -->
+		<!-- 查询结果将映射到 com.entity.vo.DiscussjiudianjianjieVO 视图对象 -->
+		SELECT * FROM discussjiudianjianjie  discussjiudianjianjie
+		<where> 1=1 ${ew.sqlSegment}</where>
+		<!-- 使用 <where> 标签动态生成 WHERE 子句 -->
+		<!-- 1=1 是一个恒成立的条件，方便后续拼接其他条件 -->
+		<!-- ${ew.sqlSegment} 是动态 SQL 片段，可根据具体情况拼接查询条件 -->
 	</select>
-	
+
 	<select id="selectVO"
-		resultType="com.entity.vo.DiscussjiudianjianjieVO" >
-		SELECT  discussjiudianjianjie.* FROM discussjiudianjianjie  discussjiudianjianjie 	
- 		<where> 1=1 ${ew.sqlSegment}</where>
+			resultType="com.entity.vo.DiscussjiudianjianjieVO">
+		<!-- 定义一个查询语句，ID 为 selectVO，用于查询单个数据 -->
+		<!-- 查询结果将映射到 com.entity.vo.DiscussjiudianjianjieVO 视图对象 -->
+		SELECT  discussjiudianjianjie.* FROM discussjiudianjianjie  discussjiudianjianjie
+		<where> 1=1 ${ew.sqlSegment}</where>
+		<!-- 使用 <where> 标签动态生成 WHERE 子句 -->
+		<!-- 1=1 是一个恒成立的条件，方便后续拼接其他条件 -->
+		<!-- ${ew.sqlSegment} 是动态 SQL 片段，可根据具体情况拼接查询条件 -->
 	</select>
 
-    <select id="selectListView"
-		resultType="com.entity.view.DiscussjiudianjianjieView" >
-
-		SELECT  discussjiudianjianjie.* FROM discussjiudianjianjie  discussjiudianjianjie 	        
-        <where> 1=1 ${ew.sqlSegment}</where>
+	<select id="selectListView"
+			resultType="com.entity.view.DiscussjiudianjianjieView">
+		<!-- 定义一个查询语句，ID 为 selectListView，用于查询数据列表 -->
+		<!-- 查询结果将映射到 com.entity.view.DiscussjiudianjianjieView 视图对象 -->
+		SELECT  discussjiudianjianjie.* FROM discussjiudianjianjie  discussjiudianjianjie
+		<where> 1=1 ${ew.sqlSegment}</where>
+		<!-- 使用 <where> 标签动态生成 WHERE 子句 -->
+		<!-- 1=1 是一个恒成立的条件，方便后续拼接其他条件 -->
+		<!-- ${ew.sqlSegment} 是动态 SQL 片段，可根据具体情况拼接查询条件 -->
 	</select>
-	
+
 	<select id="selectView"
-		resultType="com.entity.view.DiscussjiudianjianjieView" >
+			resultType="com.entity.view.DiscussjiudianjianjieView">
+		<!-- 定义一个查询语句，ID 为 selectView，用于查询单个数据 -->
+		<!-- 查询结果将映射到 com.entity.view.DiscussjiudianjianjieView 视图对象 -->
 		SELECT * FROM discussjiudianjianjie  discussjiudianjianjie <where> 1=1 ${ew.sqlSegment}</where>
+		<!-- 使用 <where> 标签动态生成 WHERE 子句 -->
+		<!-- 1=1 是一个恒成立的条件，方便后续拼接其他条件 -->
+		<!-- ${ew.sqlSegment} 是动态 SQL 片段，可根据具体情况拼接查询条件 -->
 	</select>
-	
 
-</mapper>
+</mapper>

back/src/main/resources/mapper/DiscussjiudiankefangDao.xml

@@ -14,27 +14,27 @@
 
 	<select id="selectListVO"
 		resultType="com.entity.vo.DiscussjiudiankefangVO" >
-		SELECT * FROM discussjiudiankefang  discussjiudiankefang         
+		SELECT * FROM discussjiudiankefang  discussjiudiankefang
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectVO"
 		resultType="com.entity.vo.DiscussjiudiankefangVO" >
-		SELECT  discussjiudiankefang.* FROM discussjiudiankefang  discussjiudiankefang 	
+		SELECT  discussjiudiankefang.* FROM discussjiudiankefang  discussjiudiankefang
  		<where> 1=1 ${ew.sqlSegment}</where>
 	</select>
 
     <select id="selectListView"
 		resultType="com.entity.view.DiscussjiudiankefangView" >
 
-		SELECT  discussjiudiankefang.* FROM discussjiudiankefang  discussjiudiankefang 	        
+		SELECT  discussjiudiankefang.* FROM discussjiudiankefang  discussjiudiankefang
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectView"
 		resultType="com.entity.view.DiscussjiudiankefangView" >
 		SELECT * FROM discussjiudiankefang  discussjiudiankefang <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 
 </mapper>

back/src/main/resources/mapper/JiudianjianjieDao.xml

@@ -16,27 +16,27 @@
 
 	<select id="selectListVO"
 		resultType="com.entity.vo.JiudianjianjieVO" >
-		SELECT * FROM jiudianjianjie  jiudianjianjie         
+		SELECT * FROM jiudianjianjie  jiudianjianjie
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectVO"
 		resultType="com.entity.vo.JiudianjianjieVO" >
-		SELECT  jiudianjianjie.* FROM jiudianjianjie  jiudianjianjie 	
+		SELECT  jiudianjianjie.* FROM jiudianjianjie  jiudianjianjie
  		<where> 1=1 ${ew.sqlSegment}</where>
 	</select>
 
     <select id="selectListView"
 		resultType="com.entity.view.JiudianjianjieView" >
 
-		SELECT  jiudianjianjie.* FROM jiudianjianjie  jiudianjianjie 	        
+		SELECT  jiudianjianjie.* FROM jiudianjianjie  jiudianjianjie
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectView"
 		resultType="com.entity.view.JiudianjianjieView" >
 		SELECT * FROM jiudianjianjie  jiudianjianjie <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 
 </mapper>

back/src/main/resources/mapper/KefangleixingDao.xml

@@ -10,27 +10,27 @@
 
 	<select id="selectListVO"
 		resultType="com.entity.vo.KefangleixingVO" >
-		SELECT * FROM kefangleixing  kefangleixing         
+		SELECT * FROM kefangleixing  kefangleixing
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectVO"
 		resultType="com.entity.vo.KefangleixingVO" >
-		SELECT  kefangleixing.* FROM kefangleixing  kefangleixing 	
+		SELECT  kefangleixing.* FROM kefangleixing  kefangleixing
  		<where> 1=1 ${ew.sqlSegment}</where>
 	</select>
 
     <select id="selectListView"
 		resultType="com.entity.view.KefangleixingView" >
 
-		SELECT  kefangleixing.* FROM kefangleixing  kefangleixing 	        
+		SELECT  kefangleixing.* FROM kefangleixing  kefangleixing
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectView"
 		resultType="com.entity.view.KefangleixingView" >
 		SELECT * FROM kefangleixing  kefangleixing <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 
 </mapper>

back/src/main/resources/mapper/KefangyudingDao.xml

@@ -23,27 +23,27 @@
 
 	<select id="selectListVO"
 		resultType="com.entity.vo.KefangyudingVO" >
-		SELECT * FROM kefangyuding  kefangyuding         
+		SELECT * FROM kefangyuding  kefangyuding
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectVO"
 		resultType="com.entity.vo.KefangyudingVO" >
-		SELECT  kefangyuding.* FROM kefangyuding  kefangyuding 	
+		SELECT  kefangyuding.* FROM kefangyuding  kefangyuding
  		<where> 1=1 ${ew.sqlSegment}</where>
 	</select>
 
     <select id="selectListView"
 		resultType="com.entity.view.KefangyudingView" >
 
-		SELECT  kefangyuding.* FROM kefangyuding  kefangyuding 	        
+		SELECT  kefangyuding.* FROM kefangyuding  kefangyuding
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectView"
 		resultType="com.entity.view.KefangyudingView" >
 		SELECT * FROM kefangyuding  kefangyuding <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 
 </mapper>

back/src/main/resources/mapper/NewsDao.xml

@@ -13,27 +13,27 @@
 
 	<select id="selectListVO"
 		resultType="com.entity.vo.NewsVO" >
-		SELECT * FROM news  news         
+		SELECT * FROM news  news
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectVO"
 		resultType="com.entity.vo.NewsVO" >
-		SELECT  news.* FROM news  news 	
+		SELECT  news.* FROM news  news
  		<where> 1=1 ${ew.sqlSegment}</where>
 	</select>
 
     <select id="selectListView"
 		resultType="com.entity.view.NewsView" >
 
-		SELECT  news.* FROM news  news 	        
+		SELECT  news.* FROM news  news
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectView"
 		resultType="com.entity.view.NewsView" >
 		SELECT * FROM news  news <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 
 </mapper>

back/src/main/resources/mapper/RuzhuanpaiDao.xml

@@ -20,27 +20,27 @@
 
 	<select id="selectListVO"
 		resultType="com.entity.vo.RuzhuanpaiVO" >
-		SELECT * FROM ruzhuanpai  ruzhuanpai         
+		SELECT * FROM ruzhuanpai  ruzhuanpai
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectVO"
 		resultType="com.entity.vo.RuzhuanpaiVO" >
-		SELECT  ruzhuanpai.* FROM ruzhuanpai  ruzhuanpai 	
+		SELECT  ruzhuanpai.* FROM ruzhuanpai  ruzhuanpai
  		<where> 1=1 ${ew.sqlSegment}</where>
 	</select>
 
     <select id="selectListView"
 		resultType="com.entity.view.RuzhuanpaiView" >
 
-		SELECT  ruzhuanpai.* FROM ruzhuanpai  ruzhuanpai 	        
+		SELECT  ruzhuanpai.* FROM ruzhuanpai  ruzhuanpai
         <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 	<select id="selectView"
 		resultType="com.entity.view.RuzhuanpaiView" >
 		SELECT * FROM ruzhuanpai  ruzhuanpai <where> 1=1 ${ew.sqlSegment}</where>
 	</select>
-	
+
 
 </mapper>