Merge branch 'master' into feature/zxy

.idea/vcs.xml

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

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 
+ * @author
- * @email 
+ * @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 
+ * @author
- * @email 
+ * @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;
+	private String msg;
-    
+	// 用于存储异常的错误码，这里默认值为 500，通常 500 表示服务器内部错误。
-    public EIException(String msg) {
+	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;
 
-
+// 该类表示酒店简介的数据库实体类，用于普通的增删改查操作
-/**
+// 作者信息暂未填写
- * 酒店简介
+// 邮箱信息暂未填写
- * 数据库通用操作实体类（普通增删改查）
+// 创建日期为 2022-04-04 00:20:04
- * @author 
- * @email 
- * @date 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();
 		}
 	}
-	
+
-	/**
+	// 使用 TableId 注解标识该字段为主键
-	 * 主键id
+	// 主键 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 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	// 使用 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();
 		}
 	}
-	
+
-	/**
+	// 使用 TableId 注解指定该字段为主键
-	 * 主键id
+	// 主键 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 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	// 使用 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 
+ * @author 作者信息未填写
- * @email 
+ * @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();
 		}
 	}
-	
+
-	/**
+	// 使用 TableId 注解标识该字段为主键
-	 * 主键id
+	// 主键 id，用于唯一标识数据库表中的每条记录
-	 */
 	@TableId
 	private Long id;
-	/**
+
-	 * 客房类型
+	// 客房类型字段，用于存储客房的类型信息
-	 */
-					
 	private String kefangleixing;
-	
+
-	
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	// 使用 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 
+ * @author 作者信息未填写
- * @email 
+ * @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();
 		}
 	}
-	
+
-	/**
+	// 使用 TableId 注解标识该字段为主键
-	 * 主键id
+	// 主键 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 注解指定日期在序列化时的格式为 "yyyy-MM-dd"，时区为 GMT+8
-	 * 预定日期
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
-	 */
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd")
-				
+	@DateTimeFormat
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
-	@DateTimeFormat 		
 	private Date yudingriqi;
-	
+
-	/**
+	// 是否支付字段，用于标识该客房预定是否已经支付，数据类型为 String
-	 * 是否支付
-	 */
-					
 	private String ispay;
-	
+
-	
+	// 记录添加时间字段，使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	// 使用 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 
+ * @author 作者信息未填写
- * @email 
+ * @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();
 		}
 	}
-	
+
-	/**
+	// 使用 TableId 注解标识该字段为主键
-	 * 主键id
+	// 主键 id，用于唯一标识数据库表中的每条记录
-	 */
 	@TableId
 	private Long id;
-	/**
+
-	 * 标题
+	// 标题字段，用于存储酒店公告的标题信息
-	 */
-					
 	private String title;
-	
+
-	/**
+	// 简介字段，用于存储酒店公告的简要介绍内容
-	 * 简介
-	 */
-					
 	private String introduction;
-	
+
-	/**
+	// 图片字段，用于存储酒店公告相关图片的信息（如图片路径等）
-	 * 图片
-	 */
-					
 	private String picture;
-	
+
-	/**
+	// 内容字段，用于存储酒店公告的具体内容
-	 * 内容
-	 */
-					
 	private String content;
-	
+
-	
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	// 使用 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 
+ * @author 作者信息未填写
- * @email 
+ * @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();
 		}
 	}
-	
+
-	/**
+	// 使用 TableId 注解标识该字段为主键
-	 * 主键id
+	// 主键 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 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	// 使用 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 
+ * @author 作者信息未填写
- * @email 
+ * @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();
 		}
 	}
-	
+
-	/**
+	// 使用 TableId 注解标识该字段为主键
-	 * 主键id
+	// 主键 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 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	// 使用 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 
+ * @author 作者信息未填写
- * @email 
+ * @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();
 		}
 	}
-	
+
-	/**
+	// 使用 TableId 注解标识该字段为主键
-	 * 主键id
+	// 主键 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 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	// 使用 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 
+ * @author 作者信息未填写
- * @email 
+ * @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();
 		}
 	}
-	
+
-	/**
+	// 使用 TableId 注解标识该字段为主键
-	 * 主键id
+	// 主键 id，用于唯一标识数据库表中的每条记录
-	 */
 	@TableId
 	private Long id;
-	/**
+
-	 * 员工工号
+	// 员工工号字段，用于存储员工的工号信息
-	 */
-					
 	private String yuangonggonghao;
-	
+
-	/**
+	// 员工姓名字段，用于存储员工的姓名
-	 * 员工姓名
-	 */
-					
 	private String yuangongxingming;
-	
+
-	/**
+	// 密码字段，用于存储员工的密码
-	 * 密码
-	 */
-					
 	private String mima;
-	
+
-	/**
+	// 性别字段，用于存储员工的性别信息
-	 * 性别
-	 */
-					
 	private String xingbie;
-	
+
-	/**
+	// 联系电话字段，用于存储员工的联系电话
-	 * 联系电话
-	 */
-					
 	private String lianxidianhua;
-	
+
-	/**
+	// 头像字段，用于存储员工的头像相关信息（如图片路径等）
-	 * 头像
-	 */
-					
 	private String touxiang;
-	
+
-	/**
+	// 入职时间字段，使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd"，时区为 GMT+8
-	 * 入职时间
+	// 使用 DateTimeFormat 注解，用于处理日期格式相关的转换
-	 */
+	@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd")
-				
+	@DateTimeFormat
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
-	@DateTimeFormat 		
 	private Date ruzhishijian;
-	
+
-	/**
+	// 职位字段，用于存储员工的职位信息
-	 * 职位
-	 */
-					
 	private String zhiwei;
-	
+
-	
+	// 使用 JsonFormat 注解指定日期在序列化时的格式为 "yyyy-MM-dd HH:mm:ss"，时区为 GMT+8
-	@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+	// 使用 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 
+ * @author
- * @email 
+ * @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){
+	// 定义带参数的构造函数，参数为 YonghuEntity 类型的对象
- 	try {
+	// 该构造函数的作用是将传入的 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 
+ * @author
- * @email 
+ * @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())) {
+        // 跨域时会首先发送一个OPTIONS请求，这里我们给OPTIONS请求直接返回正常状态
-        	response.setStatus(HttpStatus.OK.value());
+        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) {
+        if (annotation != null) {
-        	return true;
+            return true;
         }
-        
+
         TokenEntity tokenEntity = null;
-        if(StringUtils.isNotBlank(token)) {
+        if (StringUtils.isNotBlank(token)) {
-        	tokenEntity = tokenService.getTokenEntity(token);
+            // 根据获取到的token，调用TokenService获取对应的TokenEntity对象
+            tokenEntity = tokenService.getTokenEntity(token);
         }
-        
+
-        if(tokenEntity != null) {
+        if (tokenEntity != null) {
-        	request.getSession().setAttribute("userId", tokenEntity.getUserid());
+            // 将tokenEntity中的相关信息存入当前请求的会话中，方便后续使用
-        	request.getSession().setAttribute("role", tokenEntity.getRole());
+            request.getSession().setAttribute("userId", tokenEntity.getUserid());
-        	request.getSession().setAttribute("tableName", tokenEntity.getTablename());
+            request.getSession().setAttribute("role", tokenEntity.getRole());
-        	request.getSession().setAttribute("username", tokenEntity.getUsername());
+            request.getSession().setAttribute("tableName", tokenEntity.getTablename());
-        	return true;
+            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();
+            }
         }
-        
+//        throw new EIException("请先登录", 401);
-		PrintWriter writer = null;
+        return false;
-		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;
     }
-}
+}

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(),
+				new Query<ConfigEntity>(params).getPage(),
-                wrapper
+				wrapper
-        );
+		);
-        return new PageUtils(page);
+		// 将查询得到的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
+	// @param params 包含查询条件、分页参数等信息的Map集合
-    public PageUtils queryPage(Map<String, Object> params) {
+	// @return PageUtils对象，包含了分页查询结果的相关信息
-        Page<DiscussjiudianjianjieEntity> page = this.selectPage(
+	@Override
-                new Query<DiscussjiudianjianjieEntity>(params).getPage(),
+	public PageUtils queryPage(Map<String, Object> params) {
-                new EntityWrapper<DiscussjiudianjianjieEntity>()
+		// 使用MyBatis-Plus的selectPage方法进行分页查询，传入构建好的分页对象和默认的实体包装器
-        );
+		Page<DiscussjiudianjianjieEntity> page = this.selectPage(
-        return new PageUtils(page);
+				new Query<DiscussjiudianjianjieEntity>(params).getPage(),
-    }
+				new EntityWrapper<DiscussjiudianjianjieEntity>()
-    
+		);
-    @Override
+		// 将查询得到的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();
+		// 获取构建好的分页对象，指定类型为DiscussjiudianjianjieView
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<DiscussjiudianjianjieView> page = new Query<DiscussjiudianjianjieView>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录为根据传入的包装器查询得到的结果
-	    	return pageUtil;
+		page.setRecords(baseMapper.selectListView(page, wrapper));
- 	}
+		// 创建PageUtils对象并返回
-    
+		PageUtils pageUtil = new PageUtils(page);
-    @Override
+		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
+	@Override
-    public PageUtils queryPage(Map<String, Object> params) {
+	public PageUtils queryPage(Map<String, Object> params) {
-        Page<DiscussjiudiankefangEntity> page = this.selectPage(
+		// 创建分页对象，使用Query类从参数中提取分页信息
-                new Query<DiscussjiudiankefangEntity>(params).getPage(),
+		Page<DiscussjiudiankefangEntity> page = this.selectPage(
-                new EntityWrapper<DiscussjiudiankefangEntity>()
+				new Query<DiscussjiudiankefangEntity>(params).getPage(),
-        );
+				// 创建实体包装器，用于构建查询条件
-        return new PageUtils(page);
+				new EntityWrapper<DiscussjiudiankefangEntity>()
-    }
+		);
-    
+		// 使用PageUtils类将分页结果封装返回
-    @Override
+		return new PageUtils(page);
+	}
+
+	// 重写查询分页方法，根据参数和查询条件进行分页查询
+	@Override
 	public PageUtils queryPage(Map<String, Object> params, Wrapper<DiscussjiudiankefangEntity> wrapper) {
-		  Page<DiscussjiudiankefangView> page =new Query<DiscussjiudiankefangView>(params).getPage();
+		// 创建分页对象，使用Query类从参数中提取分页信息
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<DiscussjiudiankefangView> page = new Query<DiscussjiudiankefangView>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录，通过数据访问对象的selectListView方法查询
-	    	return pageUtil;
+		page.setRecords(baseMapper.selectListView(page, wrapper));
- 	}
+		// 使用PageUtils类将分页结果封装返回
-    
+		PageUtils pageUtil = new PageUtils(page);
-    @Override
+		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
+	@Override
-    public PageUtils queryPage(Map<String, Object> params) {
+	public PageUtils queryPage(Map<String, Object> params) {
-        Page<JiudianjianjieEntity> page = this.selectPage(
+		// 创建分页对象，从参数中提取分页信息
-                new Query<JiudianjianjieEntity>(params).getPage(),
+		Page<JiudianjianjieEntity> page = this.selectPage(
-                new EntityWrapper<JiudianjianjieEntity>()
+				new Query<JiudianjianjieEntity>(params).getPage(),
-        );
+				// 创建实体查询条件包装器
-        return new PageUtils(page);
+				new EntityWrapper<JiudianjianjieEntity>()
-    }
+		);
-    
+		// 封装分页结果并返回
-    @Override
+		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));
+		Page<JiudianjianjieView> page = new Query<JiudianjianjieView>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录，通过数据访问对象查询
-	    	return pageUtil;
+		page.setRecords(baseMapper.selectListView(page, wrapper));
- 	}
+		// 封装分页结果并返回
-    
+		PageUtils pageUtil = new PageUtils(page);
-    @Override
+		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
+	@Override
-    public PageUtils queryPage(Map<String, Object> params) {
+	public PageUtils queryPage(Map<String, Object> params) {
-        Page<JiudiankefangEntity> page = this.selectPage(
+		// 创建分页对象，从参数中提取分页信息
-                new Query<JiudiankefangEntity>(params).getPage(),
+		Page<JiudiankefangEntity> page = this.selectPage(
-                new EntityWrapper<JiudiankefangEntity>()
+				new Query<JiudiankefangEntity>(params).getPage(),
-        );
+				// 创建实体查询条件包装器
-        return new PageUtils(page);
+				new EntityWrapper<JiudiankefangEntity>()
-    }
+		);
-    
+		// 使用PageUtils类封装分页结果并返回
-    @Override
+		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));
+		Page<JiudiankefangView> page = new Query<JiudiankefangView>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录，通过数据访问对象的方法查询
-	    	return pageUtil;
+		page.setRecords(baseMapper.selectListView(page, wrapper));
- 	}
+		// 使用PageUtils类封装分页结果并返回
-    
+		PageUtils pageUtil = new PageUtils(page);
-    @Override
+		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 {
-	
+
-	
+	// 重写queryPage方法，根据传入的参数进行分页查询客房类型实体数据
-    @Override
+	// @param params 包含查询条件、分页参数等信息的Map集合
-    public PageUtils queryPage(Map<String, Object> params) {
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
-        Page<KefangleixingEntity> page = this.selectPage(
+	@Override
-                new Query<KefangleixingEntity>(params).getPage(),
+	public PageUtils queryPage(Map<String, Object> params) {
-                new EntityWrapper<KefangleixingEntity>()
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
-        );
+		Page<KefangleixingEntity> page = this.selectPage(
-        return new PageUtils(page);
+				new Query<KefangleixingEntity>(params).getPage(),
-    }
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
-    
+				new EntityWrapper<KefangleixingEntity>()
-    @Override
+		);
+		// 使用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();
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为KefangleixingView
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<KefangleixingView> page = new Query<KefangleixingView>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
-	    	return pageUtil;
+		page.setRecords(baseMapper.selectListView(page, wrapper));
- 	}
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
-    
+		PageUtils pageUtil = new PageUtils(page);
-    @Override
+		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 {
-	
+
-	
+	// 重写queryPage方法，根据传入的参数进行分页查询客房预订实体数据
-    @Override
+	// @param params 包含查询条件、分页参数等信息的Map集合
-    public PageUtils queryPage(Map<String, Object> params) {
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
-        Page<KefangyudingEntity> page = this.selectPage(
+	@Override
-                new Query<KefangyudingEntity>(params).getPage(),
+	public PageUtils queryPage(Map<String, Object> params) {
-                new EntityWrapper<KefangyudingEntity>()
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
-        );
+		Page<KefangyudingEntity> page = this.selectPage(
-        return new PageUtils(page);
+				new Query<KefangyudingEntity>(params).getPage(),
-    }
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
-    
+				new EntityWrapper<KefangyudingEntity>()
-    @Override
+		);
+		// 使用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();
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为KefangyudingView
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<KefangyudingView> page = new Query<KefangyudingView>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
-	    	return pageUtil;
+		page.setRecords(baseMapper.selectListView(page, wrapper));
- 	}
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
-    
+		PageUtils pageUtil = new PageUtils(page);
-    @Override
+		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
+	// @param params 包含查询条件、分页参数等信息的Map集合
-    public PageUtils queryPage(Map<String, Object> params) {
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
-        Page<NewsEntity> page = this.selectPage(
+	@Override
-                new Query<NewsEntity>(params).getPage(),
+	public PageUtils queryPage(Map<String, Object> params) {
-                new EntityWrapper<NewsEntity>()
+		// 创建分页对象，使用Query工具类从参数中提取分页信息
-        );
+		Page<NewsEntity> page = this.selectPage(
-        return new PageUtils(page);
+				new Query<NewsEntity>(params).getPage(),
-    }
+				// 创建一个空的实体包装器，用于查询所有符合条件的新闻实体（未添加具体条件）
-    
+				new EntityWrapper<NewsEntity>()
-    @Override
+		);
+		// 将查询得到的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();
+		// 创建分页对象，使用Query工具类从参数中提取分页信息，指定类型为NewsView
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<NewsView> page = new Query<NewsView>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法查询
-	    	return pageUtil;
+		page.setRecords(baseMapper.selectListView(page, wrapper));
- 	}
+		// 创建PageUtils对象并返回
-    
+		PageUtils pageUtil = new PageUtils(page);
-    @Override
+		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 {
-	
+
-	
+	// 重写 queryPage 方法，根据传入的参数进行分页查询如转派实体数据
-    @Override
+	// @param params 包含查询条件、分页参数等信息的 Map 集合
-    public PageUtils queryPage(Map<String, Object> params) {
+	// @return PageUtils 对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
-        Page<RuzhuanpaiEntity> page = this.selectPage(
+	@Override
-                new Query<RuzhuanpaiEntity>(params).getPage(),
+	public PageUtils queryPage(Map<String, Object> params) {
-                new EntityWrapper<RuzhuanpaiEntity>()
+		// 创建分页对象，使用 Query 工具类从参数中构建分页参数并获取 Page 对象
-        );
+		Page<RuzhuanpaiEntity> page = this.selectPage(
-        return new PageUtils(page);
+				new Query<RuzhuanpaiEntity>(params).getPage(),
-    }
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
-    
+				new EntityWrapper<RuzhuanpaiEntity>()
-    @Override
+		);
+		// 使用 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();
+		// 创建分页对象，使用 Query 工具类从参数中构建分页参数并获取 Page 对象，指定类型为 RuzhuanpaiView
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<RuzhuanpaiView> page = new Query<RuzhuanpaiView>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录，通过调用数据访问对象的 selectListView 方法，传入分页对象和查询条件包装器获取结果
-	    	return pageUtil;
+		page.setRecords(baseMapper.selectListView(page, wrapper));
- 	}
+		// 使用 PageUtils 工具类将 MyBatis-Plus 的 Page 对象转换为自定义的分页工具对象并返回
-    
+		PageUtils pageUtil = new PageUtils(page);
-    @Override
+		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 {
-	
+
-	
+	// 重写queryPage方法，根据传入的参数进行分页查询收藏实体数据
-    @Override
+	// @param params 包含查询条件、分页参数等信息的Map集合
-    public PageUtils queryPage(Map<String, Object> params) {
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
-        Page<StoreupEntity> page = this.selectPage(
+	@Override
-                new Query<StoreupEntity>(params).getPage(),
+	public PageUtils queryPage(Map<String, Object> params) {
-                new EntityWrapper<StoreupEntity>()
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
-        );
+		Page<StoreupEntity> page = this.selectPage(
-        return new PageUtils(page);
+				new Query<StoreupEntity>(params).getPage(),
-    }
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
-    
+				new EntityWrapper<StoreupEntity>()
-    @Override
+		);
+		// 使用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();
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为StoreupView
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<StoreupView> page = new Query<StoreupView>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
-	    	return pageUtil;
+		page.setRecords(baseMapper.selectListView(page, wrapper));
- 	}
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
-    
+		PageUtils pageUtil = new PageUtils(page);
-    @Override
+		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 Query<TokenEntity>(params).getPage(),
-                new EntityWrapper<TokenEntity>()
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
-        );
+				new EntityWrapper<TokenEntity>()
-        return new PageUtils(page);
+		);
+		// 使用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) {
+							   Wrapper<TokenEntity> wrapper) {
-		 Page<TokenEntity> page =new Query<TokenEntity>(params).getPage();
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<TokenEntity> page = new Query<TokenEntity>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
-	    	return pageUtil;
+		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());   
+		Calendar cal = Calendar.getInstance();
-    	cal.add(Calendar.HOUR_OF_DAY, 1);
+		// 设置日历的时间为当前时间
-		if(tokenEntity!=null) {
+		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 Query<UserEntity>(params).getPage(),
-                new EntityWrapper<UserEntity>()
+				// 创建一个空的实体查询条件包装器，查询所有用户记录
-        );
+				new EntityWrapper<UserEntity>()
-        return new PageUtils(page);
+		);
+		// 使用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) {
+							   Wrapper<UserEntity> wrapper) {
-		 Page<UserEntity> page =new Query<UserEntity>(params).getPage();
+		// 使用Query工具类从参数中构建分页信息，获取Page对象
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<UserEntity> page = new Query<UserEntity>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 调用数据访问对象的selectListView方法，根据分页信息和查询条件包装器查询用户实体列表，并设置到Page对象中
-	    	return pageUtil;
+		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 {
-	
+
-	
+	// 重写queryPage方法，根据传入的参数进行分页查询员工实体数据
-    @Override
+	// @param params 包含查询条件、分页参数等信息的Map集合
-    public PageUtils queryPage(Map<String, Object> params) {
+	// @return PageUtils对象，包含了分页查询结果的相关信息，如总记录数、当前页码等
-        Page<YuangongEntity> page = this.selectPage(
+	@Override
-                new Query<YuangongEntity>(params).getPage(),
+	public PageUtils queryPage(Map<String, Object> params) {
-                new EntityWrapper<YuangongEntity>()
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象
-        );
+		Page<YuangongEntity> page = this.selectPage(
-        return new PageUtils(page);
+				new Query<YuangongEntity>(params).getPage(),
-    }
+				// 创建一个空的实体查询条件包装器，即查询所有符合条件的记录（这里未添加具体条件）
-    
+				new EntityWrapper<YuangongEntity>()
-    @Override
+		);
+		// 使用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();
+		// 创建分页对象，使用Query工具类从参数中构建分页参数并获取Page对象，指定类型为YuangongView
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<YuangongView> page = new Query<YuangongView>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 设置分页对象的记录，通过调用数据访问对象的selectListView方法，传入分页对象和查询条件包装器获取结果
-	    	return pageUtil;
+		page.setRecords(baseMapper.selectListView(page, wrapper));
- 	}
+		// 使用PageUtils工具类将MyBatis-Plus的Page对象转换为自定义的分页工具对象并返回
-    
+		PageUtils pageUtil = new PageUtils(page);
-    @Override
+		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);
 	}
-
+}
-
-}