lxy5

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/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);
 	}
-
+}
-
-}