p4vb9jpo3
/
homestay
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

注释--wx

Browse Source
pull/3/head
wangxin 3 months ago
parent 2545d38280
commit dc7542bc88
15 changed files with 2524 additions and 1849 deletions
Show Stats Download Patch File Download Diff File

512
minsu/minsuguanliw/src/main/java/com/controller/FangjianController.java
Unescape View File

@ -35,297 +35,407 @@ import com.alibaba.fastjson.*;
/**
* 房间信息
* 后端接口
* @author
* @email
*/
@RestController
@Controller
@RequestMapping("/fangjian")
* @author [作者姓名，此处未给出具体值]
* @email [作者邮箱，此处未给出具体值]
*/
@RestController // 表明这个类是一个基于RESTful风格的控制器，返回的数据会直接以JSON等格式响应给客户端，无需额外配置视图解析器等
@Controller // 标识这是一个Spring MVC的控制器类
@RequestMapping("/fangjian") // 定义该控制器类的基础请求路径，所有该类下的接口路径都以此为前缀
public class FangjianController {
// 创建一个日志记录器对象，用于记录该类中的相关操作日志，方便调试和问题排查
private static final Logger logger = LoggerFactory.getLogger(FangjianController.class);
// 自动注入FangjianService，用于处理与房间相关的业务逻辑，比如查询、保存、更新等操作
@Autowired
private FangjianService fangjianService;
// 自动注入TokenService，可能用于处理用户认证相关的令牌操作，具体功能需看该服务的实现
@Autowired
private TokenService tokenService;
// 自动注入DictionaryService，大概率用于对字典表数据进行转换等相关操作，比如将某些字段值转换为更友好的展示形式
@Autowired
private DictionaryService dictionaryService;
//级联表service
// 自动注入YonghuService，可能是与用户相关的服务，也许用于处理房间信息和用户信息之间的关联等级联操作（从名字推测，“Yonghu”可能表示“用户”）
@Autowired
private YonghuService yonghuService;
/**
* 后端列表
*/
* 后端列表
* 用于获取房间信息列表，支持分页、排序以及根据用户角色添加特定查询条件等功能
*
* @param params 包含查询参数的Map，例如分页参数、排序字段、筛选条件等
* @param request HttpServletRequest对象，用于获取会话中的用户相关信息等
* @return 返回一个R类型的对象，包含操作结果信息以及查询到的房间信息列表数据（封装在PageUtils中）
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录page方法的调试日志，输出控制器类名和传入的查询参数信息（将参数转换为JSON字符串格式记录）
logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 从会话中获取用户角色信息，并转换为字符串类型
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永不会进入");
else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId"));
if(params.get("orderBy")==null || params.get("orderBy")==""){
params.put("orderBy","id");
// 此处条件永远为假，应该是预留的一个逻辑分支，暂时不会进入该分支执行
if (false)
return R.error(511, "永不会进入");
// 如果用户角色是“用户”，则在查询参数中添加当前用户的ID，可能用于筛选该用户相关的房间信息
else if ("用户".equals(role))
params.put("yonghuId", request.getSession().getAttribute("userId"));
// 如果没有指定排序字段，则默认按照“id”字段进行排序
if (params.get("orderBy") == null || params.get("orderBy") == "") {
params.put("orderBy", "id");
}
// 调用FangjianService的queryPage方法，根据传入的参数查询房间信息列表，并返回分页结果（封装在PageUtils对象中）
PageUtils page = fangjianService.queryPage(params);
//字典表数据转换
List<FangjianView> list =(List<FangjianView>)page.getList();
for(FangjianView c:list){
//修改对应字典表字段
// 获取分页结果中的房间信息列表（转换为FangjianView类型的列表），准备进行字典表数据转换操作
List<FangjianView> list = (List<FangjianView>) page.getList();
// 遍历房间信息列表，对每个房间信息对象进行字典表数据转换操作
for (FangjianView c : list) {
// 调用DictionaryService的dictionaryConvert方法，根据请求信息对房间信息对象中的相关字段进行字典表数据转换
dictionaryService.dictionaryConvert(c, request);
}
// 返回操作成功的结果信息，并将包含转换后数据的分页结果放入返回数据中
return R.ok().put("data", page);
}
/**
* 后端详情
*/
* 后端详情
* 根据传入的房间ID获取具体的房间详细信息，包括将实体对象转换为视图对象以及字典表数据转换等操作
*
* @param id 要查询的房间ID
* @param request HttpServletRequest对象，用于获取会话信息等，可能在字典表数据转换中会用到
* @return 返回一个R类型的对象，包含操作结果信息以及查询到的房间详细信息（封装在FangjianView对象中）
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
public R info(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录info方法的调试日志，输出控制器类名和要查询的房间ID信息
logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用FangjianService的selectById方法，根据传入的ID查询房间实体信息
FangjianEntity fangjian = fangjianService.selectById(id);
if(fangjian !=null){
//entity转view
// 如果查询到了房间实体信息
if (fangjian!= null) {
// 创建一个FangjianView对象，用于存放转换后的房间信息，以便返回给前端展示更合适的数据格式
FangjianView view = new FangjianView();
BeanUtils.copyProperties( fangjian , view );//把实体数据重构到view中
// 使用Spring的BeanUtils工具类，将房间实体对象中的属性值复制到视图对象中，实现对象属性的转换
BeanUtils.copyProperties(fangjian, view);
//修改对应字典表字段
// 调用DictionaryService的dictionaryConvert方法，对视图对象中的相关字段进行字典表数据转换，使其展示更友好的格式
dictionaryService.dictionaryConvert(view, request);
// 返回操作成功的结果信息，并将包含转换后数据的视图对象放入返回数据中
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
} else {
// 如果没有查询到对应的房间信息，则返回错误结果信息，提示“查不到数据”
return R.error(511, "查不到数据");
}
}
/**
* 后端保存
*/
* 后端保存
* 用于保存新的房间信息到数据库，在保存前会先检查是否已有相同数据存在
*
* @param fangjian 包含房间信息的FangjianEntity对象，通过请求体传入（@RequestBody注解表示接收JSON格式的请求体数据并转换为对应的Java对象）
* @param request HttpServletRequest对象，用于获取会话中的用户角色等信息，此处暂未看到具体使用场景，但可能后续会扩展相关逻辑
* @return 返回一个R类型的对象，保存成功返回操作成功信息，若已有相同数据则返回错误信息提示“表中有相同数据”
*/
@RequestMapping("/save")
public R save(@RequestBody FangjianEntity fangjian, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,fangjian:{}",this.getClass().getName(),fangjian.toString());
public R save(@RequestBody FangjianEntity fangjian, HttpServletRequest request) {
// 记录save方法的调试日志，输出控制器类名和要保存的房间信息对象的字符串表示（调用toString方法）
logger.debug("save方法:,,Controller:{},,fangjian:{}", this.getClass().getName(), fangjian.toString());
// 从会话中获取用户角色信息，并转换为字符串类型
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永远不会进入");
// 此处条件永远为假，应该是预留的一个逻辑分支，暂时不会进入该分支执行
if (false)
return R.error(511, "永远不会进入");
// 创建一个EntityWrapper对象，用于构建数据库查询条件，此处构建了一系列基于房间信息各个字段的相等条件，用于查询是否已存在相同数据的记录
Wrapper<FangjianEntity> queryWrapper = new EntityWrapper<FangjianEntity>()
.eq("fangjian_name", fangjian.getFangjianName())
.eq("fangjian_tese", fangjian.getFangjianTese())
.eq("fangjian_peizhi", fangjian.getFangjianPeizhi())
.eq("fangjian_shangpin", fangjian.getFangjianShangpin())
.eq("fangjian_fuwu", fangjian.getFangjianFuwu())
.eq("fangjian_types", fangjian.getFangjianTypes())
.eq("fangjian_number", fangjian.getFangjianNumber())
.eq("fangjian_clicknum", fangjian.getFangjianClicknum())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
.eq("fangjian_name", fangjian.getFangjianName())
.eq("fangjian_tese", fangjian.getFangjianTese())
.eq("fangjian_peizhi", fangjian.getFangjianPeizhi())
.eq("fangjian_shangpin", fangjian.getFangjianShangpin())
.eq("fangjian_fuwu", fangjian.getFangjianFuwu())
.eq("fangjian_types", fangjian.getFangjianTypes())
.eq("fangjian_number", fangjian.getFangjianNumber())
.eq("fangjian_clicknum", fangjian.getFangjianClicknum());
// 记录构建的查询条件对应的SQL语句片段，方便调试查看查询条件是否正确
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用FangjianService的selectOne方法，根据构建的查询条件查询是否已存在相同数据的房间记录
FangjianEntity fangjianEntity = fangjianService.selectOne(queryWrapper);
if(fangjianEntity==null){
// 如果不存在相同数据的记录
if (fangjianEntity == null) {
// 设置房间的点击次数初始值为1
fangjian.setFangjianClicknum(1);
// 设置房间的创建时间为当前时间
fangjian.setCreateTime(new Date());
// 调用FangjianService的insert方法，将房间信息保存到数据库中
fangjianService.insert(fangjian);
// 返回操作成功的结果信息
return R.ok();
}else {
return R.error(511,"表中有相同数据");
} else {
// 如果已存在相同数据的记录，则返回错误结果信息，提示“表中有相同数据”
return R.error(511, "表中有相同数据");
}
}
/**
* 后端修改
*/
* 后端修改
* 用于更新已存在的房间信息，更新前会检查是否存在除自身外相同数据的记录，并可处理房间图片相关字段为空的情况
*
* @param fangjian 包含更新后的房间信息的FangjianEntity对象，通过请求体传入
* @param request HttpServletRequest对象，用于获取会话信息等，此处暂未看到具体使用场景，但可能后续会扩展相关逻辑
* @return 返回一个R类型的对象，更新成功返回操作成功信息，若存在相同数据则返回错误信息提示“表中有相同数据”
*/
@RequestMapping("/update")
public R update(@RequestBody FangjianEntity fangjian, HttpServletRequest request){
logger.debug("update方法:,,Controller:{},,fangjian:{}",this.getClass().getName(),fangjian.toString());
public R update(@RequestBody FangjianEntity fangjian, HttpServletRequest request) {
// 记录update方法的调试日志，输出控制器类名和要更新的房间信息对象的字符串表示
logger.debug("update方法:,,Controller:{},,fangjian:{}", this.getClass().getName(), fangjian.toString());
// 从会话中获取用户角色信息，并转换为字符串类型
String role = String.valueOf(request.getSession().getAttribute("role"));
// if(false)
// return R.error(511,"永远不会进入");
//根据字段查询是否有相同数据
//if (false)
//return R.error(511, "永远不会进入");
// 创建一个EntityWrapper对象，用于构建数据库查询条件，此处构建了一系列基于房间信息各个字段的相等条件，同时排除自身（通过notIn条件排除传入的房间ID），用于查询是否已存在相同数据的其他记录
Wrapper<FangjianEntity> queryWrapper = new EntityWrapper<FangjianEntity>()
.notIn("id",fangjian.getId())
.andNew()
.eq("fangjian_name", fangjian.getFangjianName())
.eq("fangjian_tese", fangjian.getFangjianTese())
.eq("fangjian_peizhi", fangjian.getFangjianPeizhi())
.eq("fangjian_shangpin", fangjian.getFangjianShangpin())
.eq("fangjian_fuwu", fangjian.getFangjianFuwu())
.eq("fangjian_types", fangjian.getFangjianTypes())
.eq("fangjian_number", fangjian.getFangjianNumber())
.eq("fangjian_clicknum", fangjian.getFangjianClicknum())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
.notIn("id", fangjian.getId())
.andNew()
.eq("fangjian_name", fangjian.getFangjianName())
.eq("fangjian_tese", fangjian.getFangjianTese())
.eq("fangjian_peizhi", fangjian.getFangjianPeizhi())
.eq("fangjian_shangpin", fangjian.getFangjianShangpin())
.eq("fangjian_fuwu", fangjian.getFangjianFuwu())
.eq("fangjian_types", fangjian.getFangjianTypes())
.eq("fangjian_number", fangjian.getFangjianNumber())
.eq("fangjian_clicknum", fangjian.getFangjianClicknum());
// 记录构建的查询条件对应的SQL语句片段，方便调试查看查询条件是否正确
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用FangjianService的selectOne方法，根据构建的查询条件查询是否已存在相同数据的其他房间记录
FangjianEntity fangjianEntity = fangjianService.selectOne(queryWrapper);
if("".equals(fangjian.getFangjianPhoto()) || "null".equals(fangjian.getFangjianPhoto())){
fangjian.setFangjianPhoto(null);
// 如果房间图片相关字段为空字符串或“null”字符串，则将房间图片字段设置为null，可能是为了在数据库中正确处理空值情况
if ("".equals(fangjian.getFangjianPhoto()) || "null".equals(fangjian.getFangjianPhoto())) {
fangjian.setFangjianPhoto(null);
}
if(fangjianEntity==null){
fangjianService.updateById(fangjian);//根据id更新
// 如果不存在相同数据的其他记录
if (fangjianEntity == null) {
// 调用FangjianService的updateById方法，根据传入的房间信息对象的ID更新对应的房间信息到数据库中
fangjianService.updateById(fangjian);
// 返回操作成功的结果信息
return R.ok();
}else {
return R.error(511,"表中有相同数据");
} else {
// 如果存在相同数据的其他记录，则返回错误结果信息，提示“表中有相同数据”
return R.error(511, "表中有相同数据");
}
}
/**
* 删除
*/
* 删除
* 根据传入的房间ID数组，批量删除对应的房间信息记录
*
* @param ids 包含要删除的房间ID的整数数组，通过请求体传入
* @return 返回一个R类型的对象，表示操作结果信息，删除成功返回操作成功信息
*/
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
public R delete(@RequestBody Integer[] ids) {
// 记录delete方法的调试日志，输出控制器类名和要删除的房间ID数组的字符串表示
logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
// 调用FangjianService的deleteBatchIds方法，传入要删除的房间ID列表，批量删除对应的房间信息记录
fangjianService.deleteBatchIds(Arrays.asList(ids));
// 返回操作成功的结果信息
return R.ok();
}
/**
* 批量上传
* 用于从指定的Excel文件（仅支持后缀为.xls的文件）中读取房间信息数据，并批量插入到数据库中，同时会进行一些数据格式校验和异常处理
*
* @param fileName 要上传的文件名，从请求参数中获取
* @param request HttpServletRequest对象，用于获取当前用户的ID等信息，可能用于关联插入的房间信息与用户信息
* @return 返回一个R类型的对象，表示操作结果信息，成功返回操作成功信息，若出现异常则返回相应的错误提示信息
*/
@RequestMapping("/batchInsert")
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
public R save(String fileName, HttpServletRequest request) {
// 记录batchInsert方法的调试日志，输出控制器类名和要上传的文件名信息
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
// 从会话中获取当前用户的ID，并转换为整数类型（先将获取到的属性值转换为字符串，再转换为整数）
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
// 创建一个SimpleDateFormat对象，用于格式化日期，此处指定日期格式为“yyyy-MM-dd HH:mm:ss”
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
List<FangjianEntity> fangjianList = new ArrayList<>();//上传的东西
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
// 创建一个FangjianEntity类型的列表，用于存放从Excel文件中读取并解析后的房间信息对象，准备批量插入到数据库中
List<FangjianEntity> fangjianList = new ArrayList<>();
// 创建一个Map对象，用于存放要查询是否重复的字段信息（具体使用方式需看后续代码逻辑，此处从变量名推测是这个用途）
Map<String, List<String>> seachFields = new HashMap<>();
// 获取当前系统时间，可能用于设置房间信息的创建时间等字段（虽然当前代码中未看到完整使用场景）
Date date = new Date();
// 获取文件名中最后一个点（.）的索引位置，用于判断文件后缀
int lastIndexOf = fileName.lastIndexOf(".");
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀");
}else{
// 如果文件名中没有点，即没有后缀
if (lastIndexOf == -1) {
// 返回错误结果信息，提示“该文件没有后缀”
return R.error(511, "该文件没有后缀");
} else {
// 获取文件名的后缀部分（从最后一个点开始截取后面的字符串）
String suffix = fileName.substring(lastIndexOf);
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件");
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
// 如果后缀不是“.xls”，说明文件格式不符合要求
if (!".xls".equals(suffix)) {
// 返回错误结果信息，提示“只支持后缀为xls的excel文件”
return R.error(511, "只支持后缀为xls的excel文件");
} else {
// 通过类加载器获取指定文件名对应的文件资源路径，并转换为URL对象
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
// 创建一个File对象，参数是通过resource.getFile()获取的文件路径，这里可能是用于后续判断文件是否存在等操作
File file = new File(resource.getFile());
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员");
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
dataList.remove(0);//删除第一行，因为第一行是提示
for(List<String> data:dataList){
//循环
if (!file.exists()) {
// 如果文件不存在，返回一个错误信息给前端，错误码是511，提示找不到上传文件，并告知联系管理员
return R.error(511, "找不到上传文件，请联系管理员");
} else {
// 通过PoiUtil工具类的poiImport方法读取指定路径的xls文件，将读取到的数据存放在List<List<String>>类型的dataList中
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());
// 删除dataList中的第一行数据，因为第一行可能是提示信息之类的，在后续处理中不需要
dataList.remove(0);
for (List<String> data : dataList) {
// 循环处理dataList中每一行的数据（每一行数据也是一个List<String>）
FangjianEntity fangjianEntity = new FangjianEntity();
// fangjianEntity.setFangjianName(data.get(0)); //房间名称 要改的
// fangjianEntity.setFangjianPhoto("");//详情和图片
// fangjianEntity.setFangjianTese(data.get(0)); //房间特色 要改的
// fangjianEntity.setFangjianPeizhi(data.get(0)); //房间配置 要改的
// fangjianEntity.setFangjianShangpin(data.get(0)); //提供的商品 要改的
// fangjianEntity.setFangjianFuwu(data.get(0)); //提供的服务 要改的
// fangjianEntity.setFangjianMoney(data.get(0)); //价格（天） 要改的
// fangjianEntity.setFangjianTypes(Integer.valueOf(data.get(0))); //房间类型 要改的
// fangjianEntity.setFangjianNumber(Integer.valueOf(data.get(0))); //房间剩余数量 要改的
// fangjianEntity.setFangjianClicknum(Integer.valueOf(data.get(0))); //点击次数 要改的
// fangjianEntity.setFangjianContent("");//详情和图片
// fangjianEntity.setCreateTime(date);//时间
// 以下这几行代码原本是用于设置FangjianEntity对象的各个属性值，但目前都是设置为固定值或者取了错误的数据索引（都取的data.get(0)），后续应该根据实际需求修改正确的获取数据的索引和赋值逻辑
// 设置房间名称，此处应该根据实际表格数据的对应列索引来获取正确的值，当前写法有误（都取的data.get(0)），要改的
fangjianEntity.setFangjianName(data.get(0));
// 设置房间图片，暂时设置为空字符串，可能后续需要完善获取图片的逻辑，比如从文件中读取或者根据路径获取等，详情和图片相关
fangjianEntity.setFangjianPhoto("");
// 设置房间特色，同样这里取值有误（取的data.get(0)），应该按实际情况修改获取对应列数据的索引，要改的
fangjianEntity.setFangjianTese(data.get(0));
// 设置房间配置，取值也存在问题（取的data.get(0)），需按正确的表格列索引来获取对应数据，要改的
fangjianEntity.setFangjianPeizhi(data.get(0));
// 设置提供的商品，此处也是错误的取值方式（取的data.get(0)），需要改成对应正确的数据获取逻辑，要改的
fangjianEntity.setFangjianShangpin(data.get(0));
// 设置提供的服务，同样是取值错误（取的data.get(0)），后续要根据实际情况修改，要改的
fangjianEntity.setFangjianFuwu(data.get(0));
// 设置价格（天），错误的取值（取的data.get(0)），要按照实际价格所在的表格列来获取数据，要改的
fangjianEntity.setFangjianMoney(data.get(0));
// 设置房间类型，将表格中对应列的数据转换为Integer类型并设置，但当前取值有误（取的data.get(0)），要修改为正确的索引获取数据，要改的
fangjianEntity.setFangjianTypes(Integer.valueOf(data.get(0)));
// 设置房间剩余数量，把表格对应列数据转成Integer后设置，不过当前取值不对（取的data.get(0)），需改成正确的索引获取，要改的
fangjianEntity.setFangjianNumber(Integer.valueOf(data.get(0)));
// 设置点击次数，将表格对应列数据转为Integer后设置，目前取值错误（取的data.get(0)），要按正确的方式获取数据，要改的
fangjianEntity.setFangjianClicknum(Integer.valueOf(data.get(0)));
// 设置房间详情，暂时设置为空字符串，详情和图片相关，可能后续要完善获取详情内容的逻辑
fangjianEntity.setFangjianContent("");
// 设置创建时间，这里假设date变量在外部已经正确初始化，用于记录该房间数据的创建时间
fangjianEntity.setCreateTime(date);
fangjianList.add(fangjianEntity);
// 把要查询是否重复的字段放入map中（代码中此处未看到具体放入map的实现逻辑，可能后续要补充完整）
//把要查询是否重复的字段放入map中
}
//查询是否重复
// 调用fangjianService的insertBatch方法批量插入fangjianList中的房间数据到数据库中
fangjianService.insertBatch(fangjianList);
// 如果批量插入成功，返回成功的响应给前端
return R.ok();
}
} catch(Exception e){
// 如果在上述操作过程中出现异常，打印异常堆栈信息方便排查问题
e.printStackTrace();
// 返回一个错误信息给前端，错误码是511，提示批量插入数据异常，并告知联系管理员
return R.error(511, "批量插入数据异常，请联系管理员");
}
}
}catch (Exception e){
e.printStackTrace();
return R.error(511,"批量插入数据异常，请联系管理员");
}
}
/**
* 前端列表
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
// 没有指定排序字段就默认id倒序
if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
params.put("orderBy","id");
}
PageUtils page = fangjianService.queryPage(params);
//字典表数据转换
List<FangjianView> list =(List<FangjianView>)page.getList();
for(FangjianView c:list)
dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
return R.ok().put("data", page);
}
/**
* 前端详情
*/
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
FangjianEntity fangjian = fangjianService.selectById(id);
if(fangjian !=null){
//点击数量加1
fangjian.setFangjianClicknum(fangjian.getFangjianClicknum()+1);
fangjianService.updateById(fangjian);
//entity转view
FangjianView view = new FangjianView();
BeanUtils.copyProperties( fangjian , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
/**
* 前端列表
*/
// 前端列表相关的方法，被标注了 @IgnoreAuth 表示这个方法不需要进行权限认证，通过@RequestMapping("/list")指定了该方法处理的请求路径为 /list
@IgnoreAuth
@RequestMapping("/list")
public R list (@RequestParam Map < String, Object > params, HttpServletRequest request){
// 使用日志记录器记录debug级别的日志信息，记录当前执行的list方法所在的类名以及传入的参数信息（将参数转为JSON字符串格式记录）
logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 判断传入的参数中是否指定了排序字段，如果没有指定（即获取到的orderBy参数为空字符串）
if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) {
// 就默认按照id字段倒序排序，将orderBy参数设置为id
params.put("orderBy", "id");
}
// 调用fangjianService的queryPage方法，根据传入的参数查询并获取分页数据，存放在PageUtils对象中
PageUtils page = fangjianService.queryPage(params);
// 获取分页数据中的数据列表，这里强制转换为List<FangjianView>类型，假设这个列表中的数据是需要展示在前端的房间相关视图数据
List<FangjianView> list = (List<FangjianView>) page.getList();
for (FangjianView c : list)
// 循环调用dictionaryService的dictionaryConvert方法，用于对每个FangjianView对象中的对应字典表字段进行转换（可能是将字典表中的编码转换为对应的文字描述等操作），传入当前的HttpServletRequest对象可能是用于获取一些上下文相关信息等
dictionaryService.dictionaryConvert(c, request);
// 返回成功的响应给前端，并将包含处理好的分页数据的PageUtils对象放入响应中，前端可以根据此数据进行展示等操作
return R.ok().put("data", page);
}
}
/**
* 前端保存
*/
@RequestMapping("/add")
public R add(@RequestBody FangjianEntity fangjian, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,fangjian:{}",this.getClass().getName(),fangjian.toString());
Wrapper<FangjianEntity> queryWrapper = new EntityWrapper<FangjianEntity>()
.eq("fangjian_name", fangjian.getFangjianName())
.eq("fangjian_tese", fangjian.getFangjianTese())
.eq("fangjian_peizhi", fangjian.getFangjianPeizhi())
.eq("fangjian_shangpin", fangjian.getFangjianShangpin())
.eq("fangjian_fuwu", fangjian.getFangjianFuwu())
.eq("fangjian_types", fangjian.getFangjianTypes())
.eq("fangjian_number", fangjian.getFangjianNumber())
.eq("fangjian_clicknum", fangjian.getFangjianClicknum())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
FangjianEntity fangjianEntity = fangjianService.selectOne(queryWrapper);
if(fangjianEntity==null){
fangjian.setCreateTime(new Date());
fangjianService.insert(fangjian);
return R.ok();
}else {
return R.error(511,"表中有相同数据");
}
}
/**
* 前端详情
*/
// 前端详情相关的方法，通过@RequestMapping("/detail/{id}")指定了该方法处理的请求路径为 /detail/{id}，其中{id}是一个路径变量，表示要查询详情的房间的唯一标识
@RequestMapping("/detail/{id}")
public R detail (@PathVariable("id") Long id, HttpServletRequest request){
// 使用日志记录器记录debug级别的日志信息，记录当前执行的detail方法所在的类名以及传入的房间id参数
logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用fangjianService的selectById方法，根据传入的房间id从数据库中查询对应的FangjianEntity对象（代表房间实体数据）
FangjianEntity fangjian = fangjianService.selectById(id);
if (fangjian != null) {
// 如果查询到了对应的房间数据，将该房间的点击次数加1，用于记录该房间被查看的次数统计
fangjian.setFangjianClicknum(fangjian.getFangjianClicknum() + 1);
// 调用fangjianService的updateById方法，将更新后的房间数据（点击次数已加1）更新到数据库中
fangjianService.updateById(fangjian);
// 创建一个FangjianView对象，用于将从数据库查询到的FangjianEntity实体数据转换为适合前端展示的视图数据格式
FangjianView view = new FangjianView();
// 使用BeanUtils工具类的copyProperties方法，将fangjian对象的属性值复制到view对象中，实现实体数据到视图数据的转换（前提是FangjianEntity和FangjianView的属性有对应关系）
BeanUtils.copyProperties(fangjian, view);
// 调用dictionaryService的dictionaryConvert方法，对转换后的FangjianView对象中的对应字典表字段进行转换（类似前面list方法中的转换操作），传入当前的HttpServletRequest对象用于获取上下文相关信息等
dictionaryService.dictionaryConvert(view, request);
// 返回成功的响应给前端，并将包含处理好的房间详情视图数据的FangjianView对象放入响应中，前端可以据此展示房间详情信息
return R.ok().put("data", view);
} else {
// 如果根据传入的id没有查询到对应的房间数据，返回一个错误信息给前端，错误码是511，提示查不到数据
return R.error(511, "查不到数据");
}
}
}
/**
* 前端保存
*/
// 前端保存相关的方法，通过@RequestMapping("/add")指定了该方法处理的请求路径为 /add，并且使用@RequestBody注解表示接收前端传来的JSON格式的请求体数据，并将其转换为FangjianEntity对象
@RequestMapping("/add")
public R add (@RequestBody FangjianEntity fangjian, HttpServletRequest request){
// 使用日志记录器记录debug级别的日志信息，记录当前执行的add方法所在的类名以及传入的FangjianEntity对象信息（将对象转为字符串格式记录）
logger.debug("add方法:,,Controller:{},,fangjian:{}", this.getClass().getName(), fangjian.toString());
// 创建一个EntityWrapper对象，用于构建数据库查询的条件，这里根据FangjianEntity对象的多个属性（房间名称、特色、配置等）来构建相等条件的查询语句，用于查询数据库中是否已经存在相同数据的记录
Wrapper<FangjianEntity> queryWrapper = new EntityWrapper<FangjianEntity>()
.eq("fangjian_name", fangjian.getFangjianName())
.eq("fangjian_tese", fangjian.getFangjianTese())
.eq("fangjian_peizhi", fangjian.getFangjianPeizhi())
.eq("fangjian_shangpin", fangjian.getFangjianShangpin())
.eq("fangjian_fuwu", fangjian.getFangjianFuwu())
.eq("fangjian_types", fangjian.getFangjianTypes())
.eq("fangjian_number", fangjian.getFangjianNumber())
.eq("fangjian_clicknum", fangjian.getFangjianClicknum());
// 记录构建好的查询语句对应的SQL片段信息，方便调试查看具体的查询条件
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用fangjianService的selectOne方法，根据构建好的查询条件从数据库中查询是否存在满足条件的FangjianEntity对象（即是否存在相同数据的记录）
FangjianEntity fangjianEntity = fangjianService.selectOne(queryWrapper);
if (fangjianEntity == null) {
// 如果查询结果为null，表示数据库中不存在相同数据的记录，设置当前要保存的FangjianEntity对象的创建时间为当前系统时间（new Date()获取当前时间）
fangjian.setCreateTime(new Date());
// 调用fangjianService的insert方法，将当前的FangjianEntity对象插入到数据库中
fangjianService.insert(fangjian);
// 如果插入成功，返回成功的响应给前端
return R.ok();
} else {
// 如果查询到了相同数据的记录，返回一个错误信息给前端，错误码是511，提示表中有相同数据
return R.error(511, "表中有相同数据");
}
}
}

403
minsu/minsuguanliw/src/main/java/com/controller/FangjianLiuyanController.java
Unescape View File

@ -1,4 +1,3 @@
package com.controller;
import java.io.File;
@ -35,203 +34,281 @@ import com.alibaba.fastjson.*;
/**
* 房间评论/投诉
* 后端接口
* @author
* @email
*/
* @author （这里应该是作者相关信息，但没具体内容）
* @email （这里应该是作者邮箱相关信息，但没具体内容）
*/
// 表明这是一个RESTful风格的控制器，组合了 @Controller 和 @ResponseBody 注解的功能，返回的数据直接以JSON等格式响应给客户端
@RestController
// 标识这是一个Spring管理的Bean，是一个控制器类
@Controller
// 定义该控制器处理的基础请求路径
@RequestMapping("/fangjianLiuyan")
public class FangjianLiuyanController {
// 创建一个日志记录器对象，用于记录该类相关操作的日志信息，方便调试和排查问题，日志级别等配置通常在项目的日志配置文件中设置
private static final Logger logger = LoggerFactory.getLogger(FangjianLiuyanController.class);
// 使用Spring的依赖注入，自动装配FangjianLiuyanService，方便在该控制器中调用其相关业务逻辑方法
@Autowired
private FangjianLiuyanService fangjianLiuyanService;
// 使用Spring的依赖注入，自动装配TokenService，可能用于处理用户认证相关的令牌操作等（具体看该服务的实际功能）
@Autowired
private TokenService tokenService;
// 使用Spring的依赖注入，自动装配DictionaryService，用于字典表相关的数据转换操作（比如将字典表中的编码转换为对应的文字描述等）
@Autowired
private DictionaryService dictionaryService;
//级联表service
// 使用Spring的依赖注入，自动装配FangjianService，用于和房间相关的业务逻辑操作（比如查询房间信息等），可能是级联表相关的服务调用
@Autowired
private FangjianService fangjianService;
// 使用Spring的依赖注入，自动装配YonghuService，用于和用户相关的业务逻辑操作（比如查询用户信息等），可能是级联表相关的服务调用
@Autowired
private YonghuService yonghuService;
/**
* 后端列表
*/
* 后端列表
* 用于获取房间评论/投诉信息的分页列表数据，根据传入的参数进行查询和处理
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的page方法所在的类名以及传入的参数信息（将参数转为JSON字符串格式记录），方便调试查看请求参数情况
logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 从当前请求的会话中获取用户角色信息，并转换为字符串类型，可能用于后续根据不同角色进行不同的数据查询逻辑判断
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永不会进入");
else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId"));
if(params.get("orderBy")==null || params.get("orderBy")==""){
params.put("orderBy","id");
// 此处条件永远为假，所以下面的代码块永远不会执行，可能是预留的逻辑或者后续需要修改调整的地方
if (false)
return R.error(511, "永不会进入");
// 如果用户角色是"用户"，则将当前登录用户的ID设置到查询参数中，可能用于查询该用户相关的评论/投诉信息，限制查询范围
else if ("用户".equals(role))
params.put("yonghuId", request.getSession().getAttribute("userId"));
// 判断传入的参数中是否指定了排序字段，如果没有指定（即获取到的orderBy参数为空字符串）
if (params.get("orderBy") == null || params.get("orderBy") == "") {
// 就默认按照id字段倒序排序，将orderBy参数设置为id
params.put("orderBy", "id");
}
// 调用fangjianLiuyanService的queryPage方法，根据传入的参数查询并获取分页数据，存放在PageUtils对象中
PageUtils page = fangjianLiuyanService.queryPage(params);
//字典表数据转换
List<FangjianLiuyanView> list =(List<FangjianLiuyanView>)page.getList();
for(FangjianLiuyanView c:list){
//修改对应字典表字段
// 获取分页数据中的数据列表，这里强制转换为List<FangjianLiuyanView>类型，这些视图对象可能是用于在后端展示或者传递给前端的评论/投诉相关视图数据
List<FangjianLiuyanView> list = (List<FangjianLiuyanView>) page.getList();
for (FangjianLiuyanView c : list) {
// 循环调用dictionaryService的dictionaryConvert方法，用于对每个FangjianLiuyanView对象中的对应字典表字段进行转换（比如将字典编码转换为对应的文字描述等），传入当前的HttpServletRequest对象可能是用于获取一些上下文相关信息等
dictionaryService.dictionaryConvert(c, request);
}
// 返回成功的响应给前端，并将包含处理好的分页数据的PageUtils对象放入响应中，前端可以根据此数据进行展示等操作
return R.ok().put("data", page);
}
/**
* 后端详情
*/
* 后端详情
* 根据传入的评论/投诉ID获取对应的详细信息，包括关联的房间、用户等相关信息，并进行数据转换和处理后返回给前端
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
public R info(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的info方法所在的类名以及传入的评论/投诉ID参数，方便调试查看请求参数情况
logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用fangjianLiuyanService的selectById方法，根据传入的评论/投诉ID从数据库中查询对应的FangjianLiuyanEntity对象（代表评论/投诉实体数据）
FangjianLiuyanEntity fangjianLiuyan = fangjianLiuyanService.selectById(id);
if(fangjianLiuyan !=null){
//entity转view
if (fangjianLiuyan!= null) {
// 创建一个FangjianLiuyanView对象，用于将从数据库查询到的FangjianLiuyanEntity实体数据转换为适合前端展示的视图数据格式
FangjianLiuyanView view = new FangjianLiuyanView();
BeanUtils.copyProperties( fangjianLiuyan , view );//把实体数据重构到view中
// 使用BeanUtils工具类的copyProperties方法，将fangjianLiuyan对象的属性值复制到view对象中，实现实体数据到视图数据的转换（前提是FangjianLiuyanEntity和FangjianLiuyanView的属性有对应关系）
BeanUtils.copyProperties(fangjianLiuyan, view);
// 以下是处理级联表相关的数据，获取评论/投诉对应的房间信息，并添加到视图对象中（排除一些不需要的字段，如id、创建时间等字段）
// 调用fangjianService的selectById方法，根据评论/投诉实体中关联的房间ID获取对应的FangjianEntity对象（代表房间实体数据）
FangjianEntity fangjian = fangjianService.selectById(fangjianLiuyan.getFangjianId());
if (fangjian!= null) {
// 使用BeanUtils工具类的copyProperties方法，将fangjian对象的部分属性值复制到view对象中（排除指定的字段），把级联的房间数据添加到视图中
BeanUtils.copyProperties(fangjian, view, new String[]{"id", "createTime", "insertTime", "updateTime"});
// 设置视图对象中的房间ID，确保房间ID能正确传递给前端展示或者后续使用
view.setFangjianId(fangjian.getId());
}
//级联表
FangjianEntity fangjian = fangjianService.selectById(fangjianLiuyan.getFangjianId());
if(fangjian != null){
BeanUtils.copyProperties( fangjian , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setFangjianId(fangjian.getId());
}
//级联表
YonghuEntity yonghu = yonghuService.selectById(fangjianLiuyan.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setYonghuId(yonghu.getId());
}
//修改对应字典表字段
// 以下是处理级联表相关的数据，获取评论/投诉对应的用户信息，并添加到视图对象中（排除一些不需要的字段，如id、创建时间等字段）
// 调用yonghuService的selectById方法，根据评论/投诉实体中关联的用户ID获取对应的YonghuEntity对象（代表用户实体数据）
YonghuEntity yonghu = yonghuService.selectById(fangjianLiuyan.getYonghuId());
if (yonghu!= null) {
// 使用BeanUtils工具类的copyProperties方法，将yonghu对象的部分属性值复制到view对象中（排除指定的字段），把级联的用户数据添加到视图中
BeanUtils.copyProperties(yonghu, view, new String[]{"id", "createTime", "insertTime", "updateTime"});
// 设置视图对象中的用户ID，确保用户ID能正确传递给前端展示或者后续使用
view.setYonghuId(yonghu.getId());
}
// 调用dictionaryService的dictionaryConvert方法，对转换后的FangjianLiuyanView对象中的对应字典表字段进行转换（类似前面page方法中的转换操作），传入当前的HttpServletRequest对象用于获取上下文相关信息等
dictionaryService.dictionaryConvert(view, request);
// 返回成功的响应给前端，并将包含处理好的评论/投诉详情视图数据的FangjianLiuyanView对象放入响应中，前端可以据此展示详细信息
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
} else {
// 如果根据传入的ID没有查询到对应的评论/投诉数据，返回一个错误信息给前端，错误码是511，提示查不到数据
return R.error(511, "查不到数据");
}
}
/**
* 后端保存
*/
* 后端保存
* 用于保存新的房间评论/投诉信息，设置相关时间字段并插入到数据库中
*/
@RequestMapping("/save")
public R save(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,fangjianLiuyan:{}",this.getClass().getName(),fangjianLiuyan.toString());
public R save(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的save方法所在的类名以及传入的FangjianLiuyanEntity对象信息（将对象转为字符串格式记录），方便调试查看请求数据情况
logger.debug("save方法:,,Controller:{},,fangjianLiuyan:{}", this.getClass().getName(), fangjianLiuyan.toString());
// 从当前请求的会话中获取用户角色信息，并转换为字符串类型，可能用于后续根据不同角色进行不同的数据处理逻辑判断
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永远不会进入");
else if("用户".equals(role))
// 此处条件永远为假，所以下面的代码块永远不会执行，可能是预留的逻辑或者后续需要修改调整的地方
if (false)
return R.error(511, "永远不会进入");
// 如果用户角色是"用户"，则将当前登录用户的ID设置到评论/投诉实体对象中，关联该评论/投诉与当前用户
else if ("用户".equals(role))
fangjianLiuyan.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
// 设置评论/投诉信息的插入时间为当前系统时间，用于记录该评论/投诉的创建时间
fangjianLiuyan.setInsertTime(new Date());
// 设置评论/投诉信息的创建时间为当前系统时间，与插入时间可能在业务上表示不同含义（具体看业务需求）
fangjianLiuyan.setCreateTime(new Date());
// 调用fangjianLiuyanService的insert方法，将当前的FangjianLiuyanEntity对象插入到数据库中
fangjianLiuyanService.insert(fangjianLiuyan);
// 如果插入成功，返回成功的响应给前端
return R.ok();
}
/**
* 后端修改
*/
* 后端修改
* 用于更新已存在的房间评论/投诉信息，先根据条件判断是否有重复数据，然后更新数据库中的对应记录
*/
@RequestMapping("/update")
public R update(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request){
logger.debug("update方法:,,Controller:{},,fangjianLiuyan:{}",this.getClass().getName(),fangjianLiuyan.toString());
public R update(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的update方法所在的类名以及传入的FangjianLiuyanEntity对象信息（将对象转为字符串格式记录），方便调试查看请求数据情况
logger.debug("update方法:,,Controller:{},,fangjianLiuyan:{}", this.getClass().getName(), fangjianLiuyan.toString());
// 从当前请求的会话中获取用户角色信息，并转换为字符串类型，可能用于后续根据不同角色进行不同的数据处理逻辑判断（当前部分代码被注释掉了，可能是之前的逻辑或者后续需要调整补充的地方）
String role = String.valueOf(request.getSession().getAttribute("role"));
// if(false)
// return R.error(511,"永远不会进入");
// else if("用户".equals(role))
// if (false)
// return R.error(511, "永远不会进入");
// else if ("用户".equals(role))
// fangjianLiuyan.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
//根据字段查询是否有相同数据
// 根据字段查询是否有相同数据，这里构建了一个EntityWrapper对象用于设置查询条件，目前只设置了id为0的条件（可能需要根据实际业务修改正确的判断重复数据的条件）
Wrapper<FangjianLiuyanEntity> queryWrapper = new EntityWrapper<FangjianLiuyanEntity>()
.eq("id",0)
;
.eq("id", 0);
logger.info("sql语句:"+queryWrapper.getSqlSegment());
// 记录构建好的查询语句对应的SQL片段信息，方便调试查看具体的查询条件
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用fangjianLiuyanService的selectOne方法，根据构建好的查询条件从数据库中查询是否存在满足条件的FangjianLiuyanEntity对象（即是否存在相同数据的记录，当前条件可能不准确，需完善）
FangjianLiuyanEntity fangjianLiuyanEntity = fangjianLiuyanService.selectOne(queryWrapper);
// 设置评论/投诉信息的更新时间为当前系统时间，用于记录该评论/投诉的最后更新时间
fangjianLiuyan.setUpdateTime(new Date());
if(fangjianLiuyanEntity==null){
fangjianLiuyanService.updateById(fangjianLiuyan);//根据id更新
if (fangjianLiuyanEntity == null) {
// 如果查询结果为null，表示不存在相同数据的记录，调用fangjianLiuyanService的updateById方法，根据传入的评论/投诉实体对象的ID更新数据库中的对应记录
fangjianLiuyanService.updateById(fangjianLiuyan);
// 如果更新成功，返回成功的响应给前端
return R.ok();
}else {
return R.error(511,"表中有相同数据");
} else {
// 如果查询到了相同数据的记录，返回一个错误信息给前端，错误码是511，提示表中有相同数据
return R.error(511, "表中有相同数据");
}
}
/**
* 删除
*/
* 删除
* 根据传入的评论/投诉ID数组，批量删除对应的评论/投诉记录
*/
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
public R delete(@RequestBody Integer[] ids) {
// 记录debug级别的日志信息，记录当前执行的delete方法所在的类名以及传入的评论/投诉ID数组信息（将数组转为字符串格式记录），方便调试查看请求参数情况
logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
// 调用fangjianLiuyanService的deleteBatchIds方法，传入要删除的评论/投诉ID列表，批量删除数据库中对应的记录
fangjianLiuyanService.deleteBatchIds(Arrays.asList(ids));
// 如果删除成功，返回成功的响应给前端
return R.ok();
}
/**
* 批量上传
* 用于批量上传房间评论/投诉信息，从指定的Excel文件（仅支持后缀为.xls的文件）中读取数据，进行处理后批量插入到数据库中
*/
@RequestMapping("/batchInsert")
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
public R save(String fileName, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的batchInsert方法所在的类名以及传入的文件名参数，方便调试查看请求参数情况
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
// 从当前请求的会话中获取当前登录用户的ID，并转换为Integer类型，可能用于关联上传的评论/投诉信息与当前用户
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
// 创建一个SimpleDateFormat对象，用于格式化日期时间，这里指定的格式是 "yyyy-MM-dd HH:mm:ss"，可能用于后续日期时间相关的处理
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
List<FangjianLiuyanEntity> fangjianLiuyanList = new ArrayList<>();//上传的东西
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
// 创建一个列表，用于存放从文件中读取并解析后要批量插入的FangjianLiuyanEntity对象（代表房间评论/投诉实体数据）
List<FangjianLiuyanEntity> fangjianLiuyanList = new ArrayList<>();
// 创建一个Map，用于存放要查询是否重复的字段信息（目前代码中未看到具体使用逻辑，可能需要完善，比如后续根据这些字段判断数据是否重复等）
Map<String, List<String>> seachFields = new HashMap<>();
// 获取当前系统时间，可能用于设置评论/投诉信息的相关时间字段
Date date = new Date();
// 获取文件名中最后一个点的索引位置，用于判断文件后缀名
int lastIndexOf = fileName.lastIndexOf(".");
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀");
}else{
if (lastIndexOf == -1) {
// 如果没有找到点（即没有后缀名），返回一个错误信息给前端，错误码是511，提示该文件没有后缀
return R.error(511, "该文件没有后缀");
} else {
// 获取文件名中最后一个点（.）之后的后缀部分，用于后续判断文件类型是否符合要求
String suffix = fileName.substring(lastIndexOf);
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件");
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
// 判断后缀名是否不等于 ".xls"，如果不是该后缀的文件，说明不符合当前方法支持的文件类型要求
if (!".xls".equals(suffix)) {
// 返回一个错误信息给前端，错误码是511，并提示只支持后缀为xls的excel文件，告知前端操作不符合要求
return R.error(511, "只支持后缀为xls的excel文件");
} else {
// 通过当前类的类加载器获取指定文件（位于 "static/upload/" 目录下，文件名由传入的fileName指定）的资源路径，返回一个URL对象
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
// 根据获取到的URL对象对应的文件路径创建一个File对象，用于后续判断文件是否存在以及读取文件内容等操作
File file = new File(resource.getFile());
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员");
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
dataList.remove(0);//删除第一行，因为第一行是提示
for(List<String> data:dataList){
//循环
// 判断该文件是否不存在，如果不存在，则执行下面的返回错误信息的逻辑
if (!file.exists()) {
// 返回一个错误信息给前端，错误码是511，提示找不到上传文件，并告知前端联系管理员来解决该问题
return R.error(511, "找不到上传文件，请联系管理员");
} else {
// 调用PoiUtil工具类的poiImport方法，传入文件的路径，读取该.xls文件内容，返回的数据结构是一个嵌套的List，外层List表示行，内层List的每个元素表示每行中的单元格数据，存放在dataList中
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());
// 删除dataList中的第一行数据，通常是因为第一行可能是标题行、提示信息之类的内容，在后续将数据转换为实体对象时不需要这一行数据
dataList.remove(0);
// 遍历dataList中剩余的每一行数据（每一行数据也是一个List<String>类型，表示该行各个单元格的数据）
for (List<String> data : dataList) {
// 创建一个FangjianLiuyanEntity对象，用于将从Excel文件中读取到的每行数据转换为对应的实体对象，后续可插入到数据库中
FangjianLiuyanEntity fangjianLiuyanEntity = new FangjianLiuyanEntity();
// fangjianLiuyanEntity.setFangjianId(Integer.valueOf(data.get(0))); //房间 要改的
// fangjianLiuyanEntity.setYonghuId(Integer.valueOf(data.get(0))); //用户 要改的
// fangjianLiuyanEntity.setFangjianLiuyanText(data.get(0)); //评论/投诉内容 要改的
// fangjianLiuyanEntity.setReplyText(data.get(0)); //回复内容 要改的
// fangjianLiuyanEntity.setInsertTime(date);//时间
// fangjianLiuyanEntity.setUpdateTime(sdf.parse(data.get(0))); //回复时间 要改的
// fangjianLiuyanEntity.setCreateTime(date);//时间
// 以下这几行代码原本是用于设置FangjianLiuyanEntity对象的各个属性值，但目前都是设置为固定值或者取了错误的数据索引（都取的data.get(0)），后续应该根据实际Excel文件中数据的列顺序修改正确的获取数据的索引和赋值逻辑
// 设置房间ID，此处应该根据实际Excel文件中房间ID所在列的索引来获取正确的值，当前写法有误（都取的data.get(0)），要改的
fangjianLiuyanEntity.setFangjianId(Integer.valueOf(data.get(0)));
// 设置用户ID，同样这里取值有误（取的data.get(0)），应该按实际Excel文件中用户ID所在列来获取对应数据，要改的
fangjianLiuyanEntity.setYonghuId(Integer.valueOf(data.get(0)));
// 设置评论/投诉内容，也是错误的取值方式（取的data.get(0)），需要改成对应正确的数据获取逻辑，要改的
fangjianLiuyanEntity.setFangjianLiuyanText(data.get(0));
// 设置回复内容，同样取值错误（取的data.get(0)），后续要根据实际Excel文件中回复内容所在列来获取数据，要改的
fangjianLiuyanEntity.setReplyText(data.get(0));
// 设置插入时间，将前面获取的当前系统时间date设置为该评论/投诉信息的插入时间，用于记录插入数据库的时间点
fangjianLiuyanEntity.setInsertTime(date);
// 设置更新时间，通过SimpleDateFormat对象sdf将Excel文件中对应列的数据（当前取值错误，应该按正确列索引获取，且要保证数据格式符合解析要求）解析为Date类型后设置为更新时间，要改的
fangjianLiuyanEntity.setUpdateTime(sdf.parse(data.get(0)));
// 设置创建时间，将前面获取的当前系统时间date设置为该评论/投诉信息的创建时间，用于记录该信息创建的时间点
fangjianLiuyanEntity.setCreateTime(date);
// 将设置好属性的FangjianLiuyanEntity对象添加到fangjianLiuyanList列表中，后续将批量插入这些对象到数据库
fangjianLiuyanList.add(fangjianLiuyanEntity);
// 把要查询是否重复的字段放入seachFields这个Map中（代码中此处未看到具体放入map的实现逻辑，可能后续要补充完整，比如根据业务需求确定哪些字段用于判断重复，以及如何组织这些字段数据放入map等）
//把要查询是否重复的字段放入map中
}
//查询是否重复
// 调用fangjianLiuyanService的insertBatch方法，将fangjianLiuyanList中的多个FangjianLiuyanEntity对象批量插入到数据库中，实现批量保存评论/投诉信息的功能
fangjianLiuyanService.insertBatch(fangjianLiuyanList);
// 如果批量插入操作成功，返回一个表示成功的响应给前端，告知前端数据已成功插入
return R.ok();
}
}
} catch (Exception e) {
// 如果在上述文件读取、数据处理或者批量插入等操作过程中出现异常，打印异常堆栈信息，方便开发人员排查问题所在，定位错误原因
e.printStackTrace();
// 返回一个错误信息给前端，错误码是511，提示批量插入数据异常，并告知前端联系管理员来处理该异常情况
return R.error(511, "批量插入数据异常，请联系管理员");
}
}catch (Exception e){
e.printStackTrace();
return R.error(511,"批量插入数据异常，请联系管理员");
}
}
@ -241,70 +318,92 @@ public class FangjianLiuyanController {
/**
* 前端列表
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
// 没有指定排序字段就默认id倒序
if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
params.put("orderBy","id");
// 前端列表相关的方法，被标注了 @IgnoreAuth 表示这个方法不需要进行权限认证，通过@RequestMapping("/list")指定了该方法处理的请求路径为 /list，用于获取房间评论/投诉信息的分页列表数据并返回给前端展示
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 使用日志记录器记录debug级别的日志信息，记录当前执行的list方法所在的类名以及传入的参数信息（将参数转为JSON字符串格式记录），方便调试查看请求参数情况
logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 判断传入的参数中是否指定了排序字段，如果没有指定（即获取到的orderBy参数为空字符串）
if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) {
// 就默认按照id字段倒序排序，将orderBy参数设置为id，确定数据返回给前端展示时的排序规则
params.put("orderBy", "id");
}
// 调用fangjianLiuyanService的queryPage方法，根据传入的参数查询并获取分页数据，存放在PageUtils对象中，该对象包含了分页相关的各种信息以及实际的数据列表等
PageUtils page = fangjianLiuyanService.queryPage(params);
// 获取分页数据中的数据列表，这里强制转换为List<FangjianLiuyanView>类型，这些视图对象是适合前端展示的评论/投诉相关数据格式，可能经过了一定的数据处理和转换
List<FangjianLiuyanView> list = (List<FangjianLiuyanView>) page.getList();
for (FangjianLiuyanView c : list) {
// 循环调用dictionaryService的dictionaryConvert方法，用于对每个FangjianLiuyanView对象中的对应字典表字段进行转换（比如将字典编码转换为对应的文字描述等），传入当前的HttpServletRequest对象可能是用于获取一些上下文相关信息等，确保前端展示的数据是友好可读的格式
dictionaryService.dictionaryConvert(c, request);
}
// 返回成功的响应给前端，并将包含处理好的分页数据的PageUtils对象放入响应中，前端可以根据此数据进行展示等操作，例如在页面上分页展示评论/投诉列表信息
return R.ok().put("data", page);
}
PageUtils page = fangjianLiuyanService.queryPage(params);
//字典表数据转换
List<FangjianLiuyanView> list =(List<FangjianLiuyanView>)page.getList();
for(FangjianLiuyanView c:list)
dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
return R.ok().put("data", page);
}
/**
* 前端详情
*/
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
FangjianLiuyanEntity fangjianLiuyan = fangjianLiuyanService.selectById(id);
if(fangjianLiuyan !=null){
//entity转view
// 前端详情相关的方法，通过@RequestMapping("/detail/{id}")指定了该方法处理的请求路径为 /detail/{id}，其中{id}是一个路径变量，表示要查询详情的房间评论/投诉的唯一标识，用于获取指定评论/投诉的详细信息并返回给前端展示
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request) {
// 使用日志记录器记录debug级别的日志信息，记录当前执行的detail方法所在的类名以及传入的评论/投诉ID参数，方便调试查看请求参数情况
logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用fangjianLiuyanService的selectById方法，根据传入的评论/投诉ID从数据库中查询对应的FangjianLiuyanEntity对象（代表评论/投诉实体数据）
FangjianLiuyanEntity fangjianLiuyan = fangjianLiuyanService.selectById(id);
if (fangjianLiuyan!= null) {
// 创建一个FangjianLiuyanView对象，用于将从数据库查询到的FangjianLiuyanEntity实体数据转换为适合前端展示的视图数据格式
FangjianLiuyanView view = new FangjianLiuyanView();
BeanUtils.copyProperties( fangjianLiuyan , view );//把实体数据重构到view中
// 使用BeanUtils工具类的copyProperties方法，将fangjianLiuyan对象的属性值复制到view对象中，实现实体数据到视图数据的转换（前提是FangjianLiuyanEntity和FangjianLiuyanView的属性有对应关系）
BeanUtils.copyProperties(fangjianLiuyan, view);
//级联表
FangjianEntity fangjian = fangjianService.selectById(fangjianLiuyan.getFangjianId());
if(fangjian != null){
BeanUtils.copyProperties( fangjian , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
// 以下是处理级联表相关的数据，获取评论/投诉对应的房间信息，并添加到视图对象中（排除一些不需要的字段，如id、创建时间等字段）
// 调用fangjianService的selectById方法，根据评论/投诉实体中关联的房间ID获取对应的FangjianEntity对象（代表房间实体数据）
FangjianEntity fangjian = fangjianService.selectById(fangjianLiuyan.getFangjianId());
if (fangjian!= null) {
// 使用BeanUtils工具类的copyProperties方法，将fangjian对象的部分属性值复制到view对象中（排除指定的字段），把级联的房间数据添加到视图中，确保传递给前端的房间相关数据是符合需求且不冗余的
BeanUtils.copyProperties(fangjian, view, new String[]{"id", "createDate"});
// 设置视图对象中的房间ID，保证前端能正确获取和展示关联的房间ID信息
view.setFangjianId(fangjian.getId());
}
//级联表
YonghuEntity yonghu = yonghuService.selectById(fangjianLiuyan.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
// 以下是处理级联表相关的数据，获取评论/投诉对应的用户信息，并添加到视图对象中（排除一些不需要的字段，如id、创建时间等字段）
// 调用yonghuService的selectById方法，根据评论/投诉实体中关联的用户ID获取对应的YonghuEntity对象（代表用户实体数据）
YonghuEntity yonghu = yonghuService.selectById(fangjianLiuyan.getYonghuId());
if (yonghu!= null) {
// 使用BeanUtils工具类的copyProperties方法，将yonghu对象的部分属性值复制到view对象中（排除指定的字段），把级联的用户数据添加到视图中，确保传递给前端的用户相关数据是符合需求且不冗余的
BeanUtils.copyProperties(yonghu, view, new String[]{"id", "createDate"});
// 设置视图对象中的用户ID，保证前端能正确获取和展示关联的用户ID信息
view.setYonghuId(yonghu.getId());
}
//修改对应字典表字段
// 调用dictionaryService的dictionaryConvert方法，对转换后的FangjianLiuyanView对象中的对应字典表字段进行转换（类似前面list方法中的转换操作），传入当前的HttpServletRequest对象用于获取上下文相关信息等，使前端展示的数据更友好可读
dictionaryService.dictionaryConvert(view, request);
// 返回成功的响应给前端，并将包含处理好的评论/投诉详情视图数据的FangjianLiuyanView对象放入响应中，前端可以据此展示详细的评论/投诉信息
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
} else {
// 如果根据传入的ID没有查询到对应的评论/投诉数据，返回一个错误信息给前端，错误码是511，提示查不到数据，告知前端请求的详情数据不存在
return R.error(511, "查不到数据");
}
}
}
/**
* 前端保存
*/
@RequestMapping("/add")
public R add(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,fangjianLiuyan:{}",this.getClass().getName(),fangjianLiuyan.toString());
fangjianLiuyan.setInsertTime(new Date());
fangjianLiuyan.setCreateTime(new Date());
fangjianLiuyanService.insert(fangjianLiuyan);
return R.ok();
// 前端保存相关的方法，通过@RequestMapping("/add")指定了该方法处理的请求路径为 /add，并且使用@RequestBody注解表示接收前端传来的JSON格式的请求体数据，并将其转换为FangjianLiuyanEntity对象，用于保存新的房间评论/投诉信息到数据库中
@RequestMapping("/add")
public R add(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request) {
// 使用日志记录器记录debug级别的日志信息，记录当前执行的add方法所在的类名以及传入的FangjianLiuyanEntity对象信息（将对象转为字符串格式记录），方便调试查看请求数据情况
logger.debug("add方法:,,Controller:{},,fangjianLiuyan:{}", this.getClass().getName(), fangjianLiuyan.toString());
// 设置评论/投诉信息的插入时间为当前系统时间，用于记录该评论/投诉的创建时间，确定其插入数据库时的时间点
fangjianLiuyan.setInsertTime(new Date());
// 设置评论/投诉信息的创建时间为当前系统时间，与插入时间在业务上可能有不同含义（具体看业务需求），这里统一设置为当前时间
fangjianLiuyan.setCreateTime(new Date());
// 调用fangjianLiuyanService的insert方法，将当前的FangjianLiuyanEntity对象插入到数据库中，实现保存新评论/投诉信息的功能
fangjianLiuyanService.insert(fangjianLiuyan);
// 如果插入操作成功，返回一个表示成功的响应给前端，告知前端数据已成功保存
return R.ok();
}
}

603
minsu/minsuguanliw/src/main/java/com/controller/FangjianOrderController.java
Unescape View File

@ -1,4 +1,3 @@
package com.controller;
import java.io.File;
@ -35,377 +34,499 @@ import com.alibaba.fastjson.*;
/**
* 房间预约
* 后端接口
* @author
* @email
*/
* @author （此处应填写作者相关信息，但代码中未给出具体内容）
* @email （此处应填写作者邮箱相关信息，但代码中未给出具体内容）
*/
// 结合了 @Controller 和 @ResponseBody 的功能，表明这是一个RESTful风格的控制器，返回的数据会直接转换为JSON等格式响应给客户端
@RestController
// 标识这是一个Spring管理的Bean，是一个控制器类
@Controller
// 定义该控制器处理的基础请求路径，所有该控制器下的接口路径都以此为前缀
@RequestMapping("/fangjianOrder")
public class FangjianOrderController {
// 创建一个日志记录器对象，用于记录该类相关操作的日志信息，方便后续调试和排查问题，日志级别等配置通常在项目的日志配置文件中设置
private static final Logger logger = LoggerFactory.getLogger(FangjianOrderController.class);
// 使用Spring的依赖注入，自动装配FangjianOrderService，方便在该控制器中调用其提供的与房间预约相关的业务逻辑方法
@Autowired
private FangjianOrderService fangjianOrderService;
// 使用Spring的依赖注入，自动装配TokenService，可能用于处理用户认证相关的令牌操作等（具体功能需看该服务的实际实现）
@Autowired
private TokenService tokenService;
// 使用Spring的依赖注入，自动装配DictionaryService，用于对字典表相关的数据进行转换操作，比如将字典表中的编码转换为对应的文字描述等，方便前端展示友好的数据格式
@Autowired
private DictionaryService dictionaryService;
//级联表service
// 使用Spring的依赖注入，自动装配FangjianService，用于和房间相关的业务逻辑操作（例如查询房间详细信息等），在处理级联表数据或者关联房间信息时会用到，属于级联表相关的服务调用
@Autowired
private FangjianService fangjianService;
// 使用Spring的依赖注入，自动装配YonghuService，用于和用户相关的业务逻辑操作（例如查询用户信息等），在处理级联表数据或者关联用户信息时会用到，属于级联表相关的服务调用
@Autowired
private YonghuService yonghuService;
/**
* 后端列表
*/
* 后端列表
* 用于获取房间预约信息的分页列表数据，根据传入的参数进行相应的查询和数据处理后返回给前端
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的page方法所在的类名以及传入的参数信息（将参数转为JSON字符串格式记录），方便调试时查看请求参数的具体情况
logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 从当前请求的会话中获取用户角色信息，并转换为字符串类型，可能用于后续根据不同角色进行不同的数据查询逻辑判断
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永不会进入");
else if("用户".equals(role))
params.put("yonghuId",request.getSession().getAttribute("userId"));
if(params.get("orderBy")==null || params.get("orderBy")==""){
params.put("orderBy","id");
// 此处条件永远为假，所以下面的代码块永远不会执行，可能是预留的逻辑或者后续需要修改调整的地方
if (false)
return R.error(511, "永不会进入");
// 如果用户角色是"用户"，则将当前登录用户的ID设置到查询参数中，可能用于查询该用户相关的房间预约信息，限制查询范围
else if ("用户".equals(role))
params.put("yonghuId", request.getSession().getAttribute("userId"));
// 判断传入的参数中是否指定了排序字段，如果没有指定（即获取到的orderBy参数为空字符串）
if (params.get("orderBy") == null || params.get("orderBy") == "") {
// 就默认按照id字段倒序排序，将orderBy参数设置为id，确定返回数据的默认排序规则
params.put("orderBy", "id");
}
// 调用fangjianOrderService的queryPage方法，根据传入的参数查询并获取分页数据，存放在PageUtils对象中，该对象包含了分页相关的各种信息以及实际的数据列表等
PageUtils page = fangjianOrderService.queryPage(params);
//字典表数据转换
List<FangjianOrderView> list =(List<FangjianOrderView>)page.getList();
for(FangjianOrderView c:list){
//修改对应字典表字段
// 获取分页数据中的数据列表，这里强制转换为List<FangjianOrderView>类型，这些视图对象是适合前端展示的房间预约相关数据格式，可能经过了一定的数据处理和转换
List<FangjianOrderView> list = (List<FangjianOrderView>) page.getList();
for (FangjianOrderView c : list) {
// 循环调用dictionaryService的dictionaryConvert方法，用于对每个FangjianOrderView对象中的对应字典表字段进行转换（比如将字典编码转换为对应的文字描述等），传入当前的HttpServletRequest对象可能是用于获取一些上下文相关信息等，确保前端展示的数据是友好可读的格式
dictionaryService.dictionaryConvert(c, request);
}
// 返回成功的响应给前端，并将包含处理好的分页数据的PageUtils对象放入响应中，前端可以根据此数据进行展示等操作，例如在页面上分页展示房间预约列表信息
return R.ok().put("data", page);
}
/**
* 后端详情
*/
* 后端详情
* 根据传入的房间预约ID获取对应的详细信息，包括关联的房间、用户等相关信息，并进行数据转换和处理后返回给前端
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
public R info(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的info方法所在的类名以及传入的房间预约ID参数，方便调试查看请求参数情况
logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用fangjianOrderService的selectById方法，根据传入的房间预约ID从数据库中查询对应的FangjianOrderEntity对象（代表房间预约实体数据）
FangjianOrderEntity fangjianOrder = fangjianOrderService.selectById(id);
if(fangjianOrder !=null){
//entity转view
if (fangjianOrder != null) {
// 创建一个FangjianOrderView对象，用于将从数据库查询到的FangjianOrderEntity实体数据转换为适合前端展示的视图数据格式
FangjianOrderView view = new FangjianOrderView();
BeanUtils.copyProperties( fangjianOrder , view );//把实体数据重构到view中
// 使用BeanUtils工具类的copyProperties方法，将fangjianOrder对象的属性值复制到view对象中，实现实体数据到视图数据的转换（前提是FangjianOrderEntity和FangjianOrderView的属性有对应关系）
BeanUtils.copyProperties(fangjianOrder, view);
// 以下是处理级联表相关的数据，获取房间预约对应的房间信息，并添加到视图对象中（排除一些不需要的字段，如id、创建时间等字段）
// 调用fangjianService的selectById方法，根据房间预约实体中关联的房间ID获取对应的FangjianEntity对象（代表房间实体数据）
FangjianEntity fangjian = fangjianService.selectById(fangjianOrder.getFangjianId());
if (fangjian != null) {
// 使用BeanUtils工具类的copyProperties方法，将fangjian对象的部分属性值复制到view对象中（排除指定的字段），把级联的房间数据添加到视图中，确保传递给前端的房间相关数据是符合需求且不冗余的
BeanUtils.copyProperties(fangjian, view, new String[]{"id", "createTime", "insertTime", "updateTime"});
// 设置视图对象中的房间ID，保证前端能正确获取和展示关联的房间ID信息
view.setFangjianId(fangjian.getId());
}
//级联表
FangjianEntity fangjian = fangjianService.selectById(fangjianOrder.getFangjianId());
if(fangjian != null){
BeanUtils.copyProperties( fangjian , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setFangjianId(fangjian.getId());
}
//级联表
YonghuEntity yonghu = yonghuService.selectById(fangjianOrder.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setYonghuId(yonghu.getId());
}
//修改对应字典表字段
// 以下是处理级联表相关的数据，获取房间预约对应的用户信息，并添加到视图对象中（排除一些不需要的字段，如id、创建时间等字段）
// 调用yonghuService的selectById方法，根据房间预约实体中关联的用户ID获取对应的YonghuEntity对象（代表用户实体数据）
YonghuEntity yonghu = yonghuService.selectById(fangjianOrder.getYonghuId());
if (yonghu != null) {
// 使用BeanUtils工具类的copyProperties方法，将yonghu对象的部分属性值复制到view对象中（排除指定的字段），把级联的用户数据添加到视图中，确保传递给前端的用户相关数据是符合需求且不冗余的
BeanUtils.copyProperties(yonghu, view, new String[]{"id", "createTime", "insertTime", "updateTime"});
// 设置视图对象中的用户ID，保证前端能正确获取和展示关联的用户ID信息
view.setYonghuId(yonghu.getId());
}
// 调用dictionaryService的dictionaryConvert方法，对转换后的FangjianOrderView对象中的对应字典表字段进行转换（类似前面page方法中的转换操作），传入当前的HttpServletRequest对象用于获取上下文相关信息等，使前端展示的数据更友好可读
dictionaryService.dictionaryConvert(view, request);
// 返回成功的响应给前端，并将包含处理好的房间预约详情视图数据的FangjianOrderView对象放入响应中，前端可以据此展示详细的房间预约信息
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
} else {
// 如果根据传入的ID没有查询到对应的房间预约数据，返回一个错误信息给前端，错误码是511，提示查不到数据，告知前端请求的详情数据不存在
return R.error(511, "查不到数据");
}
}
/**
* 后端保存
*/
* 后端保存
* 用于保存新的房间预约信息，设置相关时间字段并插入到数据库中
*/
@RequestMapping("/save")
public R save(@RequestBody FangjianOrderEntity fangjianOrder, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,fangjianOrder:{}",this.getClass().getName(),fangjianOrder.toString());
public R save(@RequestBody FangjianOrderEntity fangjianOrder, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的save方法所在的类名以及传入的FangjianOrderEntity对象信息（将对象转为字符串格式记录），方便调试查看请求数据情况
logger.debug("save方法:,,Controller:{},,fangjianOrder:{}", this.getClass().getName(), fangjianOrder.toString());
// 从当前请求的会话中获取用户角色信息，并转换为字符串类型，可能用于后续根据不同角色进行不同的数据处理逻辑判断
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永远不会进入");
else if("用户".equals(role))
// 此处条件永远为假，所以下面的代码块永远不会执行，可能是预留的逻辑或者后续需要修改调整的地方
if (false)
return R.error(511, "永远不会进入");
// 如果用户角色是"用户"，则将当前登录用户的ID设置到房间预约实体对象中，关联该房间预约与当前用户
else if ("用户".equals(role))
fangjianOrder.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
// 设置房间预约信息的创建时间为当前系统时间，用于记录该房间预约的创建时间点
fangjianOrder.setCreateTime(new Date());
// 调用fangjianOrderService的insert方法，将当前的FangjianOrderEntity对象插入到数据库中，实现保存新房间预约信息的功能
fangjianOrderService.insert(fangjianOrder);
// 如果插入操作成功，返回一个表示成功的响应给前端，告知前端数据已成功保存
return R.ok();
}
/**
* 后端修改
*/
* 后端修改
* 用于更新已存在的房间预约信息，先根据条件判断是否有重复数据，然后更新数据库中的对应记录
*/
@RequestMapping("/update")
public R update(@RequestBody FangjianOrderEntity fangjianOrder, HttpServletRequest request){
logger.debug("update方法:,,Controller:{},,fangjianOrder:{}",this.getClass().getName(),fangjianOrder.toString());
public R update(@RequestBody FangjianOrderEntity fangjianOrder, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的update方法所在的类名以及传入的FangjianOrderEntity对象信息（将对象转为字符串格式记录），方便调试查看请求数据情况
logger.debug("update方法:,,Controller:{},,fangjianOrder:{}", this.getClass().getName(), fangjianOrder.toString());
// 从当前请求的会话中获取用户角色信息，并转换为字符串类型，可能用于后续根据不同角色进行不同的数据处理逻辑判断（当前部分代码被注释掉了，可能是之前的逻辑或者后续需要调整补充的地方）
String role = String.valueOf(request.getSession().getAttribute("role"));
// if(false)
// return R.error(511,"永远不会进入");
// else if("用户".equals(role))
// if (false)
// return R.error(511, "永远不会进入");
// else if ("用户".equals(role))
// fangjianOrder.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
//根据字段查询是否有相同数据
// 根据字段查询是否有相同数据，这里构建了一个EntityWrapper对象用于设置查询条件，目前只设置了id为0的条件（可能需要根据实际业务修改正确的判断重复数据的条件）
Wrapper<FangjianOrderEntity> queryWrapper = new EntityWrapper<FangjianOrderEntity>()
.eq("id",0)
;
.eq("id", 0);
logger.info("sql语句:"+queryWrapper.getSqlSegment());
// 记录构建好的查询语句对应的SQL片段信息，方便调试查看具体的查询条件
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用fangjianOrderService的selectOne方法，根据构建好的查询条件从数据库中查询是否存在满足条件的FangjianOrderEntity对象（即是否存在相同数据的记录，当前条件可能不准确，需完善）
FangjianOrderEntity fangjianOrderEntity = fangjianOrderService.selectOne(queryWrapper);
if(fangjianOrderEntity==null){
fangjianOrderService.updateById(fangjianOrder);//根据id更新
if (fangjianOrderEntity == null) {
// 如果查询结果为null，表示不存在相同数据的记录，调用fangjianOrderService的updateById方法，根据传入的房间预约实体对象的ID更新数据库中的对应记录
fangjianOrderService.updateById(fangjianOrder);
// 如果更新操作成功，返回一个表示成功的响应给前端，告知前端数据已成功更新
return R.ok();
}else {
return R.error(511,"表中有相同数据");
} else {
// 如果查询到了相同数据的记录，返回一个错误信息给前端，错误码是511，提示表中有相同数据，告知前端更新操作因数据重复而失败
return R.error(511, "表中有相同数据");
}
}
/**
* 删除
*/
* 删除
* 根据传入的房间预约ID数组，批量删除对应的房间预约记录
*/
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
public R delete(@RequestBody Integer[] ids) {
// 记录debug级别的日志信息，记录当前执行的delete方法所在的类名以及传入的房间预约ID数组信息（将数组转为字符串格式记录），方便调试查看请求参数情况
logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
// 调用fangjianOrderService的deleteBatchIds方法，传入要删除的房间预约ID列表，批量删除数据库中对应的记录
fangjianOrderService.deleteBatchIds(Arrays.asList(ids));
// 如果删除操作成功，返回一个表示成功的响应给前端，告知前端数据已成功删除
return R.ok();
}
/**
* 批量上传
* 用于批量上传房间预约信息，从指定的Excel文件（仅支持后缀为.xls的文件）中读取数据，进行处理后批量插入到数据库中
*/
@RequestMapping("/batchInsert")
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
public R save(String fileName, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的batchInsert方法所在的类名以及传入的文件名参数，方便调试查看请求参数情况
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
// 从当前请求的会话中获取当前登录用户的ID，并转换为Integer类型，可能用于关联上传的房间预约信息与当前用户
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
// 创建一个SimpleDateFormat对象，用于格式化日期时间，这里指定的格式是 "yyyy-MM-dd HH:mm:ss"，可能用于后续日期时间相关的处理
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
List<FangjianOrderEntity> fangjianOrderList = new ArrayList<>();//上传的东西
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
// 创建一个列表，用于存放从文件中读取并解析后要批量插入的FangjianOrderEntity对象（代表房间预约实体数据）
List<FangjianOrderEntity> fangjianOrderList = new ArrayList<>();
// 创建一个Map，用于存放要查询是否重复的字段信息（目前代码中未看到具体使用逻辑，可能需要完善，比如后续根据这些字段判断数据是否重复等）
Map<String, List<String>> seachFields = new HashMap<>();
// 获取当前系统时间，可能用于设置房间预约信息的相关时间字段
Date date = new Date();
// 获取文件名中最后一个点（.）的索引位置，用于判断文件后缀名
int lastIndexOf = fileName.lastIndexOf(".");
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀");
}else{
if (lastIndexOf == -1) {
// 如果文件名没有后缀，返回一个错误响应给前端，错误码为511，并提示“该文件没有后缀”，告知前端上传的文件不符合要求
return R.error(511, "该文件没有后缀");
} else {
// 获取文件名中从最后一个点（.）开始到结尾的字符串，即文件后缀名
String suffix = fileName.substring(lastIndexOf);
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件");
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
// 判断后缀名是否不等于 ".xls"，如果不是 ".xls" 后缀的文件，说明不符合当前方法支持的文件类型要求
if (!".xls".equals(suffix)) {
// 返回一个错误信息给前端，错误码是511，并提示“只支持后缀为xls的excel文件”，告知前端上传的文件格式不正确
return R.error(511, "只支持后缀为xls的excel文件");
} else {
// 通过当前类的类加载器获取指定文件（位于 "static/upload/" 目录下，文件名由传入的fileName指定）的资源路径，返回一个URL对象
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
// 根据获取到的URL对象对应的文件路径创建一个File对象，用于后续判断文件是否存在以及读取文件内容等操作
File file = new File(resource.getFile());
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员");
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
dataList.remove(0);//删除第一行，因为第一行是提示
for(List<String> data:dataList){
//循环
// 判断该文件是否不存在，如果不存在，则执行下面的返回错误信息的逻辑
if (!file.exists()) {
// 返回一个错误信息给前端，错误码是511，提示“找不到上传文件，请联系管理员”，告知前端文件未找到，需要联系管理员解决
return R.error(511, "找不到上传文件，请联系管理员");
} else {
// 调用PoiUtil工具类的poiImport方法，传入文件的路径，读取该.xls文件内容，返回的数据结构是一个嵌套的List，外层List表示行，内层List的每个元素表示每行中的单元格数据，存放在dataList中
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());
// 删除dataList中的第一行数据，通常是因为第一行可能是标题行、提示信息之类的内容，在后续将数据转换为实体对象时不需要这一行数据
dataList.remove(0);
// 遍历dataList中剩余的每一行数据（每一行数据也是一个List<String>类型，表示该行各个单元格的数据）
for (List<String> data : dataList) {
// 创建一个FangjianOrderEntity对象，用于将从Excel文件中读取到的每行数据转换为对应的实体对象，后续可插入到数据库中
FangjianOrderEntity fangjianOrderEntity = new FangjianOrderEntity();
// fangjianOrderEntity.setFangjianId(Integer.valueOf(data.get(0))); //房间 要改的
// fangjianOrderEntity.setYonghuId(Integer.valueOf(data.get(0))); //用户 要改的
// fangjianOrderEntity.setFangjianOrderTime(sdf.parse(data.get(0))); //预约日期 要改的
// fangjianOrderEntity.setFangjianOrderText(data.get(0)); //预约备注 要改的
// fangjianOrderEntity.setFangjianOrderTypes(Integer.valueOf(data.get(0))); //订单状态 要改的
// fangjianOrderEntity.setCreateTime(date);//时间
// 以下这几行代码原本是用于设置FangjianOrderEntity对象的各个属性值，但目前都是设置为固定值或者取了错误的数据索引（都取的data.get(0)），后续应该根据实际Excel文件中数据的列顺序修改正确的获取数据的索引和赋值逻辑
// 设置房间ID，此处应该根据实际Excel文件中房间ID所在列的索引来获取正确的值，当前写法有误（都取的data.get(0)），要改的
fangjianOrderEntity.setFangjianId(Integer.valueOf(data.get(0)));
// 设置用户ID，同样这里取值有误（取的data.get(0)），应该按实际Excel文件中用户ID所在列来获取对应数据，要改的
fangjianOrderEntity.setYonghuId(Integer.valueOf(data.get(0)));
// 设置预约日期，通过SimpleDateFormat对象sdf将Excel文件中对应列的数据（当前取值错误，应该按正确列索引获取，且要保证数据格式符合解析要求）解析为Date类型后设置为预约日期，要改的
fangjianOrderEntity.setFangjianOrderTime(sdf.parse(data.get(0)));
// 设置预约备注，也是错误的取值方式（取的data.get(0)），需要改成对应正确的数据获取逻辑，要改的
fangjianOrderEntity.setFangjianOrderText(data.get(0));
// 设置订单状态，将Excel文件中对应列的数据转换为Integer类型后设置为订单状态（当前取值错误，应按正确列索引获取），要改的
fangjianOrderEntity.setFangjianOrderTypes(Integer.valueOf(data.get(0)));
// 设置创建时间，将前面获取的当前系统时间date设置为该房间预约信息的创建时间，用于记录创建的时间点
fangjianOrderEntity.setCreateTime(date);
// 将设置好属性的FangjianOrderEntity对象添加到fangjianOrderList列表中，后续将批量插入这些对象到数据库
fangjianOrderList.add(fangjianOrderEntity);
// 把要查询是否重复的字段放入seachFields这个Map中（代码中此处未看到具体放入map的实现逻辑，可能后续要补充完整，比如根据业务需求确定哪些字段用于判断重复，以及如何组织这些字段数据放入map等）
//把要查询是否重复的字段放入map中
}
//查询是否重复
// 调用fangjianOrderService的insertBatch方法，将fangjianOrderList中的多个FangjianOrderEntity对象批量插入到数据库中，实现批量保存房间预约信息的功能
fangjianOrderService.insertBatch(fangjianOrderList);
// 如果批量插入操作成功，返回一个表示成功的响应给前端，告知前端数据已成功插入
return R.ok();
}
}
}
}catch (Exception e){
} catch (Exception e) {
// 如果在上述文件读取、数据处理或者批量插入等操作过程中出现异常，打印异常堆栈信息，方便开发人员排查问题所在，定位错误原因
e.printStackTrace();
return R.error(511,"批量插入数据异常，请联系管理员");
// 返回一个错误信息给前端，错误码是511，提示“批量插入数据异常，请联系管理员”，告知前端出现异常情况，需要联系管理员处理
return R.error(511, "批量插入数据异常，请联系管理员");
}
}
/**
* 前端列表
*/
* 前端列表
* 用于获取房间预约信息的分页列表数据，不需要进行权限认证（通过 @IgnoreAuth 注解标识），根据传入的参数进行相应的查询和数据处理后返回给前端展示
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
// 没有指定排序字段就默认id倒序
if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
params.put("orderBy","id");
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的list方法所在的类名以及传入的参数信息（将参数转为JSON字符串格式记录），方便调试时查看请求参数的具体情况
logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 判断传入的参数中是否指定了排序字段，如果没有指定（即获取到的orderBy参数为空字符串）
if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) {
// 就默认按照id字段倒序排序，将orderBy参数设置为id，确定返回数据的默认排序规则
params.put("orderBy", "id");
}
// 调用fangjianOrderService的queryPage方法，根据传入的参数查询并获取分页数据，存放在PageUtils对象中，该对象包含了分页相关的各种信息以及实际的数据列表等
PageUtils page = fangjianOrderService.queryPage(params);
//字典表数据转换
List<FangjianOrderView> list =(List<FangjianOrderView>)page.getList();
for(FangjianOrderView c:list)
dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
// 获取分页数据中的数据列表，这里强制转换为List<FangjianOrderView>类型，这些视图对象是适合前端展示的房间预约相关数据格式，可能经过了一定的数据处理和转换
List<FangjianOrderView> list = (List<FangjianOrderView>) page.getList();
for (FangjianOrderView c : list) {
// 循环调用dictionaryService的dictionaryConvert方法，用于对每个FangjianOrderView对象中的对应字典表字段进行转换（比如将字典编码转换为对应的文字描述等），传入当前的HttpServletRequest对象可能是用于获取一些上下文相关信息等，确保前端展示的数据是友好可读的格式
dictionaryService.dictionaryConvert(c, request);
}
// 返回成功的响应给前端，并将包含处理好的分页数据的PageUtils对象放入响应中，前端可以根据此数据进行展示等操作，例如在页面上分页展示房间预约列表信息
return R.ok().put("data", page);
}
/**
* 前端详情
*/
* 前端详情
* 根据传入的房间预约ID获取对应的详细信息，包括关联的房间、用户等相关信息，并进行数据转换和处理后返回给前端展示
*/
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
public R detail(@PathVariable("id") Long id, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的detail方法所在的类名以及传入的房间预约ID参数，方便调试查看请求参数情况
logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用fangjianOrderService的selectById方法，根据传入的房间预约ID从数据库中查询对应的FangjianOrderEntity对象（代表房间预约实体数据）
FangjianOrderEntity fangjianOrder = fangjianOrderService.selectById(id);
if(fangjianOrder !=null){
//entity转view
FangjianOrderView view = new FangjianOrderView();
BeanUtils.copyProperties( fangjianOrder , view );//把实体数据重构到view中
if (fangjianOrder != null) {
// 创建一个FangjianOrderView对象，用于将从数据库查询到的FangjianOrderEntity实体数据转换为适合前端展示的视图数据格式
FangjianOrderView view = new FangjianOrderView();
// 使用BeanUtils工具类的copyProperties方法，将fangjianOrder对象的属性值复制到view对象中，实现实体数据到视图数据的转换（前提是FangjianOrderEntity和FangjianOrderView的属性有对应关系）
BeanUtils.copyProperties(fangjianOrder, view);
// 以下是处理级联表相关的数据，获取房间预约对应的房间信息，并添加到视图对象中（排除一些不需要的字段，如id、创建时间等字段）
// 调用fangjianService的selectById方法，根据房间预约实体中关联的房间ID获取对应的FangjianEntity对象（代表房间实体数据）
FangjianEntity fangjian = fangjianService.selectById(fangjianOrder.getFangjianId());
if (fangjian != null) {
// 使用BeanUtils工具类的copyProperties方法，将fangjian对象的部分属性值复制到view对象中（排除指定的字段），把级联的房间数据添加到视图中，确保传递给前端的房间相关数据是符合需求且不冗余的
BeanUtils.copyProperties(fangjian, view, new String[]{"id", "createDate"});
// 设置视图对象中的房间ID，保证前端能正确获取和展示关联的房间ID信息
view.setFangjianId(fangjian.getId());
}
//级联表
FangjianEntity fangjian = fangjianService.selectById(fangjianOrder.getFangjianId());
if(fangjian != null){
BeanUtils.copyProperties( fangjian , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setFangjianId(fangjian.getId());
}
//级联表
YonghuEntity yonghu = yonghuService.selectById(fangjianOrder.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setYonghuId(yonghu.getId());
}
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
// 以下是处理级联表相关的数据，获取房间预约对应的用户信息，并添加到视图对象中（排除一些不需要的字段，如id、创建时间等字段）
// 调用yonghuService的selectById方法，根据房间预约实体中关联的用户ID获取对应的YonghuEntity对象（代表用户实体数据）
YonghuEntity yonghu = yonghuService.selectById(fangjianOrder.getYonghuId());
if (yonghu != null) {
// 使用BeanUtils工具类的copyProperties方法，将yonghu对象的部分属性值复制到view对象中（排除指定的字段），把级联的用户数据添加到视图中，确保传递给前端的用户相关数据是符合需求且不冗余的
BeanUtils.copyProperties(yonghu, view, new String[]{"id", "createDate"});
// 设置视图对象中的用户ID，保证前端能正确获取和展示关联的用户ID信息
view.setYonghuId(yonghu.getId());
}
}
// 调用dictionaryService的dictionaryConvert方法，对转换后的FangjianOrderView对象中的对应字典表字段进行转换（类似前面list方法中的转换操作），传入当前的HttpServletRequest对象用于获取上下文相关信息等，使前端展示的数据更友好可读
dictionaryService.dictionaryConvert(view, request);
// 返回成功的响应给前端，并将包含处理好的房间预约详情视图数据的FangjianOrderView对象放入响应中，前端可以据此展示详细的房间预约信息
return R.ok().put("data", view);
} else {
// 如果根据传入的ID没有查询到对应的房间预约数据，返回一个错误信息给前端，错误码是511，提示“查不到数据”，告知前端请求的详情数据不存在
return R.error(511, "查不到数据");
}
}
/**
* 前端保存
*/
* 前端保存
* 用于处理前端提交的房间预约信息保存请求，进行相关业务逻辑判断（如房间是否存在、用户余额是否足够等）后，将预约信息保存到数据库，并更新相关用户信息
*/
@RequestMapping("/add")
public R add(@RequestBody FangjianOrderEntity fangjianOrder, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,fangjianOrder:{}",this.getClass().getName(),fangjianOrder.toString());
FangjianEntity fangjianEntity = fangjianService.selectById(fangjianOrder.getFangjianId());
if(fangjianEntity == null){
return R.error(511,"查不到该房间信息");
}
// Double fangjianNewMoney = fangjianEntity.getFangjianMoney();
public R add(@RequestBody FangjianOrderEntity fangjianOrder, HttpServletRequest request) {
// 记录debug级别的日志信息，记录当前执行的add方法所在的类名以及传入的FangjianOrderEntity对象信息（将对象转为字符串格式记录），方便调试查看请求数据情况
logger.debug("add方法:,,Controller:{},,fangjianOrder:{}", this.getClass().getName(), fangjianOrder.toString());
// 根据传入的房间预约信息中的房间ID，调用fangjianService的selectById方法查询对应的FangjianEntity对象（代表房间实体数据），用于后续判断房间是否存在以及获取房间价格等操作
FangjianEntity fangjianEntity = fangjianService.selectById(fangjianOrder.getFangjianId());
if (fangjianEntity == null) {
// 如果没有查询到对应的房间信息，返回一个错误信息给前端，错误码是511，提示“查不到该房间信息”，告知前端房间不存在，无法进行预约操作
return R.error(511, "查不到该房间信息");
}
// 以下这行代码被注释掉了，原本可能是用于获取房间的新价格（具体用途需结合业务逻辑确定），目前代码中未使用该变量
// Double fangjianNewMoney = fangjianEntity.getFangjianMoney();
if(false){
}
// 此处条件永远为假，可能是预留的逻辑或者后续需要修改调整的地方，目前没有实际执行的代码块
if (false) {
}
//计算所获得积分
Double buyJifen =0.0;
Integer userId = (Integer) request.getSession().getAttribute("userId");
YonghuEntity yonghuEntity = yonghuService.selectById(userId);
if(yonghuEntity == null)
return R.error(511,"用户不能为空");
if(yonghuEntity.getNewMoney() == null)
return R.error(511,"用户金额不能为空");
double balance = yonghuEntity.getNewMoney() - fangjianEntity.getFangjianMoney()*1;//余额
if(balance<0)
return R.error(511,"余额不够支付");
fangjianOrder.setFangjianOrderTypes(1); //设置订单状态为已支付
fangjianOrder.setYonghuId(userId); //设置订单支付人id
fangjianOrder.setCreateTime(new Date());
fangjianOrderService.insert(fangjianOrder);//新增订单
yonghuEntity.setNewMoney(balance);//设置金额
yonghuService.updateById(yonghuEntity);
return R.ok();
// 初始化用于存储所获得积分的变量，初始值设为0.0，后续可能根据业务规则计算实际获得的积分（目前代码中计算逻辑部分可能还不完善）
Double buyJifen = 0.0;
// 从当前请求的会话中获取当前登录用户的ID，并转换为Integer类型，用于后续关联房间预约信息与当前用户以及获取用户相关信息等操作
Integer userId = (Integer) request.getSession().getAttribute("userId");
// 根据获取到的用户ID，调用yonghuService的selectById方法查询对应的YonghuEntity对象（代表用户实体数据），用于后续判断用户是否存在以及获取用户金额等操作
YonghuEntity yonghuEntity = yonghuService.selectById(userId);
if (yonghuEntity == null) {
// 如果没有查询到对应的用户信息，返回一个错误信息给前端，错误码是511，提示“用户不能为空”，告知前端需要先登录用户或者用户信息不存在，无法进行预约操作
return R.error(511, "用户不能为空");
}
if (yonghuEntity.getNewMoney() == null) {
// 如果用户的金额信息为空，返回一个错误信息给前端，错误码是511，提示“用户金额不能为空”，告知前端无法进行金额相关的业务操作（如判断余额是否足够等）
return R.error(511, "用户金额不能为空");
}
// 计算用户余额，用用户当前的金额（yonghuEntity.getNewMoney()）减去房间的价格（fangjianEntity.getFangjianMoney() * 1，这里乘以1可能表示按原价计算，具体看业务需求），得到支付后的余额
double balance = yonghuEntity.getNewMoney() - fangjianEntity.getFangjianMoney() * 1;
if (balance < 0) {
// 如果余额小于0，说明用户余额不够支付房间费用，返回一个错误信息给前端，错误码是511，提示“余额不够支付”，告知前端无法完成预约操作
return R.error(511, "余额不够支付");
}
// 设置房间预约信息的订单状态为已支付（可能在业务中用1表示已支付状态），更新房间预约实体对象中的订单状态字段
fangjianOrder.setFangjianOrderTypes(1);
// 设置房间预约信息的用户ID为当前登录用户的ID，将预约信息与当前用户关联起来，更新房间预约实体对象中的用户ID字段
fangjianOrder.setYonghuId(userId);
// 设置房间预约信息的创建时间为当前系统时间，用于记录该房间预约的创建时间点，更新房间预约实体对象中的创建时间字段
fangjianOrder.setCreateTime(new Date());
// 调用fangjianOrderService的insert方法，将当前的FangjianOrderEntity对象插入到数据库中，实现保存新房间预约信息的功能
fangjianOrderService.insert(fangjianOrder);
// 更新用户的金额信息，将用户的金额设置为支付后的余额，通过调用yonghuService的updateById方法更新数据库中对应的用户信息记录
yonghuEntity.setNewMoney(balance);
yonghuService.updateById(yonghuEntity);
// 如果整个保存操作（包括预约信息插入和用户信息更新）成功，返回一个表示成功的响应给前端，告知前端房间预约操作已成功完成
return R.ok();
}
/**
* 退款
*/
* 退款
* 根据传入的房间预约ID处理退款相关业务逻辑，包括判断相关信息是否存在、计算退款金额、更新订单状态以及相关的房间和用户信息等操作
*/
@RequestMapping("/refund")
public R refund(Integer id, HttpServletRequest request){
logger.debug("refund方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
public R refund(Integer id, HttpServletRequest request) {
// 记录debug级别的日志信息，输出当前执行的"refund"方法所在的类名以及传入的房间预约ID参数，方便后续调试时查看具体的调用情况和参数值
logger.debug("refund方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 从当前请求的会话中获取用户角色信息，并转换为字符串类型，不过从后续代码来看，暂时没有基于这个角色信息做进一步的业务逻辑处理（可能是预留的功能或者后续待完善的部分）
String role = String.valueOf(request.getSession().getAttribute("role"));
FangjianOrderEntity fangjianOrder = fangjianOrderService.selectById(id);
Integer buyNumber = 1;
Integer fangjianOrderPaymentTypes = 1;
Integer fangjianId = fangjianOrder.getFangjianId();
if(fangjianId == null)
return R.error(511,"查不到该房间信息");
FangjianEntity fangjianEntity = fangjianService.selectById(fangjianId);
if(fangjianEntity == null)
return R.error(511,"查不到该房间信息");
Double fangjianNewMoney = fangjianEntity.getFangjianMoney();
if(fangjianNewMoney == null)
return R.error(511,"房间信息价格不能为空");
Integer userId = (Integer) request.getSession().getAttribute("userId");
YonghuEntity yonghuEntity = yonghuService.selectById(userId);
if(yonghuEntity == null)
return R.error(511,"用户不能为空");
if(yonghuEntity.getNewMoney() == null)
return R.error(511,"用户金额不能为空");
Double zhekou = 1.0;
//判断是什么支付方式 1代表余额 2代表积分
if(fangjianOrderPaymentTypes == 1){//余额支付
//计算金额
Double money = fangjianEntity.getFangjianMoney() * buyNumber * zhekou;
//计算所获得积分
Double buyJifen = 0.0;
yonghuEntity.setNewMoney(yonghuEntity.getNewMoney() + money); //设置金额
}
// 根据传入的房间预约ID，调用fangjianOrderService的selectById方法从数据库中查询对应的FangjianOrderEntity对象（代表该房间预约的实体数据），用于后续获取该预约的相关信息进行退款相关逻辑处理
FangjianOrderEntity fangjianOrder = fangjianOrderService.selectById(id);
// 初始化购买数量变量，这里设置为1，可能表示此次退款操作对应的购买数量（具体含义需结合业务场景确定，也许后续会根据实际业务修改这个值）
Integer buyNumber = 1;
// 定义并初始化房间预约支付方式类型变量，这里设置为1，根据后续代码注释可知，1代表余额支付方式（可能在业务中有多种支付方式，通过这个变量来区分）
Integer fangjianOrderPaymentTypes = 1;
// 获取房间预约对应的房间ID，从前面查询到的FangjianOrderEntity对象中获取关联的房间ID，用于后续查询房间详细信息等操作
Integer fangjianId = fangjianOrder.getFangjianId();
// 判断房间ID是否为null，如果是null，说明没有找到对应的房间信息，返回一个错误信息给前端，错误码是511，并提示“查不到该房间信息”，告知前端无法进行退款操作，因为找不到对应的房间记录
if (fangjianId == null)
return R.error(511, "查不到该房间信息");
// 根据获取到的房间ID，调用fangjianService的selectById方法从数据库中查询对应的FangjianEntity对象（代表房间实体数据），用于获取房间的价格等信息进行退款金额计算等操作
FangjianEntity fangjianEntity = fangjianService.selectById(fangjianId);
// 判断房间实体对象是否为null，如果是null，说明没有查询到对应的房间信息，返回一个错误信息给前端，错误码是511，并提示“查不到该房间信息”，告知前端无法进行退款操作，因为房间信息不存在
if (fangjianEntity == null)
return R.error(511, "查不到该房间信息");
// 获取房间的价格信息，从FangjianEntity对象中获取房间的金额（可能表示房间的费用等，具体含义看业务定义），用于后续退款金额计算等操作
Double fangjianNewMoney = fangjianEntity.getFangjianMoney();
// 判断房间价格是否为null，如果是null，说明房间价格信息缺失，返回一个错误信息给前端，错误码是511，并提示“房间信息价格不能为空”，告知前端无法进行退款金额相关的计算操作，因为缺少房间价格数据
if (fangjianNewMemory == null)
return R.error(511, "房间信息价格不能为空");
// 从当前请求的会话中获取当前登录用户的ID，并转换为Integer类型，用于后续关联退款操作与当前用户以及获取用户相关信息等操作
Integer userId = (Integer) request.getSession().getAttribute("userId");
// 根据获取到的用户ID，调用yonghuService的selectById方法从数据库中查询对应的YonghuEntity对象（代表用户实体数据），用于获取用户的金额等信息进行退款后金额更新等操作
YonghuEntity yonghuEntity = yonghuService.selectById(userId);
// 判断用户实体对象是否为null，如果是null，说明没有查询到对应的用户信息，返回一个错误信息给前端，错误码是511，并提示“用户不能为空”，告知前端无法进行退款操作，因为用户信息不存在
if (yonghuEntity == null)
return R.error(511, "用户不能为空");
// 判断用户的金额信息是否为null，如果是null，说明用户金额信息缺失，返回一个错误信息给前端，错误码是511，并提示“用户金额不能为空”，告知前端无法进行退款后金额更新等操作，因为缺少用户金额数据
if (yonghuEntity.getNewMoney() == null)
return R.error(511, "用户金额不能为空");
// 定义并初始化折扣变量，这里设置为1.0，表示没有折扣（具体折扣相关逻辑可能根据业务需求后续完善，也许不同情况会有不同的折扣值）
Double zhekou = 1.0;
// 判断房间预约的支付方式类型，如果是1（根据前面定义代表余额支付方式），则进入以下余额支付的退款相关逻辑处理
if (fangjianOrderPaymentTypes == 1) {
// 计算退款金额，根据房间价格（fangjianEntity.getFangjianMoney()）、购买数量（buyNumber）以及折扣（zhekou）相乘计算得出应退款的金额，这里目前只是简单的乘法计算，实际业务中可能会更复杂（比如涉及不同的计价规则等）
Double money = fangjianEntity.getFangjianMoney() * buyNumber * zhekou;
// 初始化用于存储所获得积分的变量，这里设置为0.0，可能在业务中有根据退款操作获取积分的规则（目前代码中计算逻辑部分可能还不完善，只是简单赋值）
Double buyJifen = 0.0;
// 更新用户的金额信息，将用户当前的金额（yonghuEntity.getNewMoney()）加上计算得出的退款金额（money），实现把退款金额退还到用户账户余额中的操作，通过调用yonghuService的updateById方法后续会更新数据库中对应的用户信息记录
yonghuEntity.setNewMoney(yonghuEntity.getNewMoney() + money);
}
fangjianOrder.setFangjianOrderTypes(2);//设置订单状态为退款
fangjianOrderService.updateById(fangjianOrder);//根据id更新
yonghuService.updateById(yonghuEntity);//更新用户信息
fangjianService.updateById(fangjianEntity);//更新订单中房间信息的信息
return R.ok();
// 设置房间预约信息的订单状态为退款（可能在业务中用2表示退款状态），更新房间预约实体对象中的订单状态字段，用于标记该订单已进入退款状态
fangjianOrder.setFangjianOrderTypes(2);
// 调用fangjianOrderService的updateById方法，根据传入的房间预约实体对象（包含已更新的订单状态等信息）的ID更新数据库中的对应记录，将订单状态修改为退款状态保存到数据库中
fangjianOrderService.updateById(fangjianOrder);
// 调用yonghuService的updateById方法，根据传入的用户实体对象（包含已更新的金额等信息）更新数据库中的对应用户记录，将用户信息更新保存到数据库中，比如更新用户余额等信息
yonghuService.updateById(yonghuEntity);
// 调用fangjianService的updateById方法，根据传入的房间实体对象（虽然代码中目前没有对房间实体对象做额外修改，也许后续会有相关逻辑完善）更新数据库中的对应房间记录，将房间相关信息更新保存到数据库中
fangjianService.updateById(fangjianEntity);
// 如果整个退款操作（包括订单状态更新、用户信息更新、房间信息更新等）成功，返回一个表示成功的响应给前端，告知前端退款操作已成功完成
return R.ok();
}
/**
* 发货
* 此方法根据传入的房间预约ID，将对应的房间预约订单状态设置为已发货状态（代码中设置为3表示发货状态），并更新到数据库中，如果更新失败则返回错误信息给前端
*/
@RequestMapping("/deliver")
public R deliver(Integer id ){
logger.debug("refund:,,Controller:{},,ids:{}",this.getClass().getName(),id.toString());
FangjianOrderEntity fangjianOrderEntity = new FangjianOrderEntity();;
public R deliver(Integer id) {
// 记录debug级别的日志信息，输出当前执行的"deliver"方法所在的类名以及传入的房间预约ID参数，方便后续调试时查看具体的调用情况和参数值，不过这里日志输出的方法名有误，应该是"deliver"而不是"refund"（可能是代码书写小失误）
logger.debug("refund:,,Controller:{},,ids:{}", this.getClass().getName(), id.toString());
// 创建一个FangjianOrderEntity对象，用于后续设置要更新的房间预约相关信息，这里先初始化一个空对象
FangjianOrderEntity fangjianOrderEntity = new FangjianOrderEntity();
// 设置FangjianOrderEntity对象的ID为传入的房间预约ID，用于确定要更新的是哪条房间预约记录
fangjianOrderEntity.setId(id);
// 设置FangjianOrderEntity对象的订单状态为已发货状态（这里假设业务中用3表示发货状态，具体看业务定义），准备更新该订单的状态信息到数据库中
fangjianOrderEntity.setFangjianOrderTypes(3);
boolean b = fangjianOrderService.updateById( fangjianOrderEntity);
if(!b){
// 调用fangjianOrderService的updateById方法，根据设置好的FangjianOrderEntity对象（包含要更新的ID和订单状态信息）更新数据库中的对应记录，返回一个布尔值表示更新操作是否成功
boolean b = fangjianOrderService.updateById(fangjianOrderEntity);
// 判断更新操作是否失败，如果b为false，说明更新数据库记录时出现问题，返回一个错误信息给前端，提示“操作出错”，告知前端发货操作未能成功执行
if (!b) {
return R.error("操作出错");
}
// 如果更新操作成功，返回一个表示成功的响应给前端，告知前端发货操作已成功完成
return R.ok();
}
}
}

295
minsu/minsuguanliw/src/main/java/com/entity/FangjianEntity.java
Unescape View File

@ -1,343 +1,374 @@
package com.entity;
// 导入MyBatis Plus中用于标识主键的注解，通过设置其type属性可以指定主键的生成策略，例如这里设置为IdType.AUTO表示自动增长
import com.baomidou.mybatisplus.annotations.TableId;
// 导入MyBatis Plus中用于指定实体类对应的数据库表名的注解，使得框架能将该实体类与数据库中的相应表进行关联操作
import com.baomidou.mybatisplus.annotations.TableName;
// 导入用于验证字段不能为空的注解，确保对应属性在使用时有值，常用于参数校验场景，比如在接收前端传入的数据时验证是否符合要求
import javax.validation.constraints.NotBlank;
// 导入用于验证集合类型字段不能为空的注解，强调对应的集合属性不能为null且不能是空集合，常用于对列表等数据结构的校验
import javax.validation.constraints.NotEmpty;
// 导入用于验证基本数据类型字段不能为空的注解，保证对应属性有具体的非空值，防止出现空指针等问题
import javax.validation.constraints.NotNull;
// 导入Jackson框架的注解，用于指定在序列化和反序列化过程中忽略某些属性，常用于处理一些不需要展示或者不需要参与数据交互的属性
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入用于处理Java反射机制中方法调用异常的相关类，在使用反射相关操作时可能会抛出此类异常，需要进行捕获处理以保证程序稳定运行
import java.lang.reflect.InvocationTargetException;
// 导入Java的序列化接口，表明该类的对象可以被序列化和反序列化，方便在网络传输、持久化存储等场景下对该类的实例进行操作，例如在前后端数据交互或者保存对象状态到文件等情况中使用
import java.io.Serializable;
// 导入Java中的日期类，用于处理可能涉及到的创建时间等日期相关属性，便于记录实体对象在数据库中的创建时间等信息
import java.util.Date;
// 导入Java的集合类框架中的List接口，虽然在当前代码中未看到明显使用场景，但可能用于后续扩展该实体类与其他集合类型数据的关联，比如房间关联的多个评论列表等情况
import java.util.List;
// 导入Spring框架的日期格式化注解，用于在接收前端传入的日期参数或者向前端返回日期数据时，按照指定格式进行转换处理，使日期数据的格式符合业务要求
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson框架的另一个注解，用于在序列化和反序列化日期类型数据时，按照指定的格式（如这里配置的"yyyy-MM-dd HH:mm:ss"）进行处理，确保日期格式的一致性和准确性
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Apache Commons BeanUtils工具类，其提供了方便的方法来进行Java对象之间属性的复制操作，在本类的构造函数中会使用它来进行属性赋值操作
import org.apache.commons.beanutils.BeanUtils;
// 导入MyBatis Plus中用于标识字段与数据库表字段映射关系的注解，同时可以设置一些额外属性，如这里的fill属性用于指定字段在插入或更新时的自动填充策略
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus中用于定义字段填充策略的枚举类型，这里使用的FieldFill.INSERT表示在插入数据时自动填充指定字段，常用于创建时间等字段的自动赋值
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入MyBatis Plus中用于定义主键生成类型的枚举类型，之前提到的IdType.AUTO就是其中一种表示自动增长的类型
import com.baomidou.mybatisplus.enums.IdType;
/**
* 房间信息
* 该类用于表示房间相关的各种信息，是与数据库中"fangjian"表对应的实体类，包含了房间的基本属性以及对应的访问器（getter）和修改器（setter）方法，同时实现了Serializable接口以支持对象的序列化和反序列化操作，方便在不同场景下使用该对象传递和存储数据。
*
* @author
* @email
* @author // 此处应该填写作者相关信息，可能是开发人员的姓名等，但代码中未明确给出具体值
* @email // 同样，此处应该填写作者的邮箱信息，代码中也未给出具体内容，用于标识代码的归属或者方便联系作者等用途
*/
@TableName("fangjian")
public class FangjianEntity<T> implements Serializable {
// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化（如添加、删除字段等）时，可以通过修改这个版本号来避免反序列化出错，初始值设为1L，在类相对稳定的情况下一般不需要改动
private static final long serialVersionUID = 1L;
// 默认构造函数，用于创建FangjianEntity类的实例对象，在一些情况下（比如通过反射等方式创建对象时）可能会用到，它会创建一个默认状态的对象实例，各个属性会使用其对应类型的默认值初始化（如基本数据类型的默认初始值等）
public FangjianEntity() {
public FangjianEntity() {
}
public FangjianEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
// 构造函数，接收一个泛型类型参数t，用于将传入的对象（其类型由泛型T指定）的属性值复制到当前FangjianEntity对象中，通过BeanUtils工具类来实现属性复制，方便基于已有的同类型或者兼容类型的数据构建FangjianEntity对象，不过在复制过程中可能会抛出异常，所以进行了异常捕获处理
public FangjianEntity(T t) {
try {
// 使用BeanUtils的copyProperties方法，将t对象的属性值复制到当前对象（this）中，实现属性的赋值操作，但该方法可能会抛出IllegalAccessException（访问权限异常）和InvocationTargetException（方法调用异常），所以需要进行异常捕获处理
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 如果在属性复制过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，确定是哪里出现了访问权限问题或者方法调用出错等情况
e.printStackTrace();
}
}
/**
* 主键
* 用于唯一标识数据库中的每条房间记录，在数据库表中通常是一个自增长的整数类型字段，通过@TableId注解指定了其主键生成策略为自动增长（IdType.AUTO），并通过@TableField注解明确了对应的数据库表字段名为"id"。
*/
@TableId(type = IdType.AUTO)
@TableField(value = "id")
private Integer id;
/**
* 房间名称
* 用于存储房间的具体名称，例如"标准间"、"豪华套房"等，通过@TableField注解指定了其在数据库表中对应的字段名为"fangjian_name"，方便在数据库操作时进行数据的映射和存储。
*/
@TableField(value = "fangjian_name")
private String fangjianName;
/**
* 房间图片
* 用于存储房间相关图片的路径或者图片的标识信息（具体取决于业务中图片存储和引用的方式），通过@TableField注解与数据库表中的"fangjian_photo"字段进行映射关联，以便在数据持久化和查询时正确处理房间图片相关的数据。
*/
@TableField(value = "fangjian_photo")
private String fangjianPhoto;
/**
* 房间特色
* 用于描述房间具有的独特特点，比如"海景房"的海景特色、"主题房"的主题特色等，通过@TableField注解对应数据库表中的"fangjian_tese"字段，使得在数据库操作时能准确获取和更新房间特色相关信息。
*/
@TableField(value = "fangjian_tese")
private String fangjianTese;
/**
* 房间配置
* 用于列举房间内配备的各种设施设备等信息，像"有电视、空调、独立卫生间"等，通过@TableField注解与数据库表的"fangjian_peizhi"字段相关联，便于在数据库层面进行房间配置信息的存储和查询操作。
*/
@TableField(value = "fangjian_peizhi")
private String fangjianPeizhi;
/**
* 提供的商品
* 用于说明房间为住客额外提供的商品信息，例如"提供免费的矿泉水、洗漱用品"等，借助@TableField注解映射到数据库表中的"fangjian_shangpin"字段，以保证在数据持久化过程中提供的商品信息能正确存储和读取。
*/
@TableField(value = "fangjian_shangpin")
private String fangjianShangpin;
/**
* 提供的服务
* 用于介绍房间配套提供的服务项目，比如"包含早餐服务"、"提供免费的客房清洁服务"等，通过@TableField注解与数据库表的"fangjian_fuwu"字段建立联系，方便在数据库操作中处理房间服务相关的数据。
*/
@TableField(value = "fangjian_fuwu")
private String fangjianFuwu;
/**
* 价格（天）
* 用于存储房间每天的出租价格，通过@TableField注解对应数据库表中的"fangjian_money"字段，使得在数据库的插入、查询、更新等操作中能准确处理房间价格信息，方便后续业务根据价格进行各种计算和展示等操作。
*/
@TableField(value = "fangjian_money")
private Double fangjianMoney;
/**
* 房间类型
* 用于区分不同种类的房间，可能通过数字或其他编码方式对应不同的房型分类，例如1表示单人间，2表示双人间等，通过@TableField注解关联数据库表中的"fangjian_types"字段，便于在数据库中对不同房型进行分类管理和数据操作。
*/
@TableField(value = "fangjian_types")
private Integer fangjianTypes;
/**
* 房间剩余数量
* 用于记录当前房间还可预订的剩余数量，实时反映房间的预订余量情况，通过@TableField注解与数据库表的"fangjian_number"字段相对应，方便在数据库操作时更新和查询房间剩余数量信息，为预订业务提供数据支持。
*/
@TableField(value = "fangjian_number")
private Integer fangjianNumber;
/**
* 点击次数
* 用于统计房间信息被查看的次数，可用于分析房间的受欢迎程度等，通过@TableField注解关联到数据库表的"fangjian_clicknum"字段，以便在数据库层面准确记录和更新房间的点击次数数据。
*/
@TableField(value = "fangjian_clicknum")
private Integer fangjianClicknum;
/**
* 房间详情
* 用于存储更详细的关于房间的描述信息，可能包含房间的布局、面积大小、装修风格等更全面的介绍内容，通过@TableField注解对应数据库表中的"fangjian_content"字段，使得在数据库操作中能完整地存储和获取房间详情信息，方便在前端展示等业务场景中使用。
*/
@TableField(value = "fangjian_content")
private String fangjianContent;
/**
* 创建时间
* 用于记录房间信息在数据库中首次创建的时间，通过@JsonFormat注解指定了在序列化和反序列化时的日期格式为"yyyy-MM-dd HH:mm:ss"，并且设置了时区为"GMT+8"（东八区，符合中国等地区的时间标准），同时利用@DateTimeFormat注解用于在接收前端传入的日期参数时进行格式处理，通过@TableField注解结合FieldFill.INSERT设置了该字段在插入数据时会自动填充当前时间，方便准确记录房间信息的创建时间点。
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time",fill = FieldFill.INSERT)
@JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
/**
* 设置：主键
*/
* 设置：主键
* 这是按照JavaBean规范定义的修改器（setter）方法，用于设置主键（id）属性的值，外部代码（比如在进行数据库插入或更新操作时，需要为房间对象设置主键值的相关业务逻辑代码）可以调用这个方法，传入相应的整数值来更新该属性的值。
*/
public Integer getId() {
return id;
}
/**
* 获取：主键
*/
/**
* 获取：主键
* 这是按照JavaBean规范定义的访问器（getter）方法，用于获取主键（id）属性的值，外部代码（例如在查询数据库中的房间记录后，需要获取房间主键信息用于后续业务处理，如根据主键进行关联查询等相关业务逻辑代码）可以调用这个方法，获取当前对象的主键值。
*/
public void setId(Integer id) {
this.id = id;
}
/**
* 设置：房间名称
*/
* 设置：房间名称
* 定义了设置房间名称（fangjianName）属性值的方法，遵循JavaBean规范中的属性修改器（setter）方法定义，外部代码在需要对房间名称进行更新时（比如酒店对房间重新命名，或者发现之前名称录入有误需要修改等情况），可以调用这个方法，传入相应的字符串内容作为新的房间名称，以此来改变该属性的值。
*/
public String getFangjianName() {
return fangjianName;
}
/**
* 获取：房间名称
*/
/**
* 获取：房间名称
* 按照JavaBean规范定义的访问器（getter）方法，用于获取房间名称（fangjianName）属性的值，外部代码（例如在构建前端页面展示房间相关信息的业务逻辑中，或者处理数据展示交互的代码等）可以调用这个方法，获取当前对象所代表房间的名称信息，然后将其展示给用户或者用于其他业务处理。
*/
public void setFangjianName(String fangjianName) {
this.fangjianName = fangjianName;
}
/**
* 设置：房间图片
*/
* 设置：房间图片
* 此为设置房间图片（fangjianPhoto）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，外部代码在出现诸如房间图片更新（比如更换了新的宣传图片，或者图片存储路径发生变化等情况），需要更新房间图片相关信息时，可以调用这个方法，传入新的图片相关信息（如更新后的图片路径等），来更新该属性的值。
*/
public String getFangjianPhoto() {
return fangjianPhoto;
}
/**
* 获取：房间图片
*/
/**
* 获取：房间图片
* 这是依据JavaBean规范定义的访问器（getter）方法，用于获取房间图片（fangjianPhoto）属性的值，外部代码（像是在前端展示房间信息时，需要呈现房间外观、内部布置等图片信息的相关代码逻辑中）可以调用此方法，获取到当前对象记录的房间图片相关信息，例如图片的路径等，方便在前端页面展示给用户查看。
*/
public void setFangjianPhoto(String fangjianPhoto) {
this.fangjianPhoto = fangjianPhoto;
}
/**
* 设置：房间特色
*/
* 设置：房间特色
* 定义了设置房间特色（fangjianTese）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，外部代码在有新增房间特色、修改已有的房间特色描述（比如对特色的描述更详细准确等情况）等业务场景下，需要更新房间特色的相关描述内容时，可以调用这个方法，传入对应的字符串内容，以此来更新该属性的值。
*/
public String getFangjianTese() {
return fangjianTese;
}
/**
* 获取：房间特色
*/
/**
* 获取：房间特色
* 按照JavaBean规范定义的访问器（getter）方法，用于获取房间特色（fangjianTese）属性的值，外部代码（例如在前端展示房间详情页面，需要告知用户该房间具备哪些特色的相关业务逻辑代码中）可以调用这个方法，获取当前对象注明的房间特色信息，像房间是否有独特的景观、主题风格等内容，便于在前端展示给用户知晓。
*/
public void setFangjianTese(String fangjianTese) {
this.fangjianTese = fangjianTese;
}
/**
* 设置：房间配置
*/
* 设置：房间配置
* 这是遵循JavaBean规范定义的用于设置房间配置（fangjianPeizhi）属性值的方法，属于属性修改器（setter）方法，外部代码在诸如房间设施配备发生变化（比如新添加了某种设施设备，或者原有的设施被更换等更新房间设施配备情况），或者根据实际的业务场景需要对已记录的配置信息文本进行修改（比如纠正之前配置信息录入的错误等）时，可以调用这个方法，传入新的描述房间配置的字符串内容，来更新该属性的值。
*/
public String getFangjianPeizhi() {
return fangjianPeizhi;
}
/**
* 获取：房间配置
*/
/**
* 获取：房间配置
* 按照JavaBean的属性访问器规范定义的方法，用于获取房间配置（fangjianPeizhi）属性的值，外部代码（在前端展示房间信息时，为了让用户清楚房间内部配备了哪些设施设备等具体情况的相关业务逻辑代码中）可以调用这个方法，获取到当前对象记录的房间内的硬件配置信息，例如房间里有哪些电器、家具等设施配备情况，方便在前端页面展示给用户。
*/
public void setFangjianPeizhi(String fangjianPeizhi) {
this.fangjianPeizhi = fangjianPeizhi;
}
/**
* 设置：提供的商品
* 定义了设置提供的商品（fangjianShangpin）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，外部代码在有新增商品种类、修改已提供商品的相关描述（比如商品品牌更换等情况）等业务场景下 /**
* 设置：提供的商品
*/
// 获取：提供的商品
// 按照JavaBean规范定义的访问器（getter）方法，用于获取提供的商品（fangjianShangpin）属性的值。
// 外部代码（例如在前端展示房间详情页面，需要告知用户该房间原本为住客提供哪些商品的相关业务逻辑代码中）可以调用这个方法，获取当前对象注明的房间提供的商品信息，像房间是否提供免费的矿泉水、洗漱用品等内容，便于在前端展示给用户知晓，从而帮助用户更好地理解房间相关情况。
public String getFangjianShangpin() {
return fangjianShangpin;
}
/**
* 获取：提供的商品
*/
// 设置：提供的商品
// 这是遵循JavaBean规范定义的用于设置提供的商品（fangjianShangpin）属性值的方法，属于属性修改器（setter）方法。
// 外部代码在有新增商品种类、修改已提供商品的相关描述（比如商品品牌更换等情况）等业务场景下，需要更新房间提供商品的相关描述内容时，可以调用这个方法，传入对应的字符串内容作为新的商品描述信息，以此来更新该属性的值，确保前端展示的房间提供商品信息是最新且准确的。
public void setFangjianShangpin(String fangjianShangpin) {
this.fangjianShangpin = fangjianShangpin;
}
/**
* 设置：提供的服务
*/
// 获取：提供的服务
// 依据JavaBean规范定义的访问器（getter）方法，用于获取提供的服务（fangjianFuwu）属性的值。
// 外部代码（在前端展示房间信息时，为了让用户从服务角度更好地理解相关房间情况，需要获取房间配套提供的服务项目信息的相关业务逻辑代码中）可以调用这个方法，获取当前对象列出的房间提供的服务信息，例如房间是否包含早餐服务、有没有免费的客房清洁服务等内容，方便在前端展示给用户，辅助用户从服务方面去理解房间相关情况。
public String getFangjianFuwu() {
return fangjianFuwu;
}
/**
* 获取：提供的服务
*/
// 设置：提供的服务
// 定义了设置提供的服务（fangjianFuwu）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则。
// 外部代码在业务运营过程中，当对房间配套的服务项目进行调整（比如新增了某项服务，或者取消了原有的某项服务等情况），或者根据业务需求修改服务介绍的相关文本（比如对服务内容描述进行优化等）时，可以调用这个方法，传入新的描述房间提供服务的字符串内容，来更新该属性的值，保证前端展示的房间提供服务信息与实际情况一致。
public void setFangjianFuwu(String fangjianFuwu) {
this.fangjianFuwu = fangjianFuwu;
}
/**
* 设置：价格（天）
*/
// 获取：价格（天）
// 按照JavaBean规范定义的访问器（getter）方法，用于获取价格（fangjianMoney）属性的值，该价格指的是房间每天的出租价格。
// 外部代码（比如在前端展示房间信息时，为了让用户从性价比等角度综合考虑相关房间情况，需要获取房间价格信息的相关业务逻辑代码中）可以调用这个方法，获取当前对象对应的房间每天的出租价格信息，方便在前端展示给用户查看，使得用户能够结合价格情况以及房间的其他配置、服务等信息，来全面评估房间是否符合自己的需求，比如判断价格是否符合自己的预算等。
public Double getFangjianMoney() {
return fangjianMoney;
}
/**
* 获取：价格（天）
*/
// 设置：价格（天）
// 定义了设置价格（fangjianMoney）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，用于设置房间每天的出租价格。
// 外部代码在诸如酒店进行价格调整（根据市场行情、淡旺季等因素改变房间价格），或者根据不同的业务场景（比如针对特定客户群体设置优惠价格等情况）设定价格时，可以调用这个方法，传入相应的价格数值，以此来更新该属性的值，确保前端展示的房间价格信息是准确且符合实际业务设定的。
public void setFangjianMoney(Double fangjianMoney) {
this.fangjianMoney = fangjianMoney;
}
/**
* 设置：房间类型
*/
// 获取：房间类型
// 此为按照JavaBean规范定义的访问器（getter）方法，用于获取房间类型（fangjianTypes）属性的值，这里的房间类型通常是通过特定的标识（如数字、代码等方式）来区分不同种类的房间。
// 外部代码（在前端展示房间信息时，为了便于进行房间分类展示，以及方便用户根据房型对房间进行分类查看和理解的相关业务逻辑代码中）可以调用这个方法，获取当前对象表示的房间类型信息，例如用1表示单人间，2表示双人间等，便于前端根据不同的房型分类展示对应的房间信息，使用户能够更高效地查找和查看自己关注的房型相关信息。
public Integer getFangjianTypes() {
return fangjianTypes;
}
/**
* 获取：房间类型
*/
// 设置：房间类型
// 这是遵循JavaBean规范定义的用于设置房间类型（fangjianTypes）属性值的方法，属于属性修改器（setter）方法，用于设置房间的类型标识。
// 外部代码在诸如酒店新增了一种房型，需要对其设定相应的类型标识，或者根据业务运营需要对已有的房间分类进行修改（比如重新调整房型分类标准等情况）时，可以调用这个方法，传入对应的房间类型标识数值，来更新该属性的值，保证前端展示的房间类型信息与实际的房型分类情况相符。
public void setFangjianTypes(Integer fangjianTypes) {
this.fangjianTypes = fangjianTypes;
}
/**
* 设置：房间剩余数量
*/
// 获取：房间剩余数量
// 按照JavaBean规范定义的访问器（getter）方法，用于获取房间剩余数量（fangjianNumber）属性的值，该属性记录的是当前房间还可预订的剩余数量。
// 外部代码（在前端展示房间信息时，为了展示房间的热门程度等相关背景信息，让用户了解房间的预订余量情况的相关业务逻辑代码中）可以调用这个方法，获取当前对象记录的房间可预订剩余数量信息，例如剩余数量少可能意味着房间比较热门，用户可以结合这个信息以及其他房间相关情况，来综合考虑是否预订该房间等情况。
public Integer getFangjianNumber() {
return fangjianNumber;
}
/**
* 获取：房间剩余数量
*/
// 设置：房间剩余数量
// 这是遵循JavaBean规范定义的用于设置房间剩余数量（fangjianNumber）属性值的方法，属于属性修改器（setter）方法，用于设置房间剩余可预订的数量。
// 外部代码在出现诸如有新预订、取消预订等操作后（这些操作会导致房间剩余可预订数量发生变化），需要更新相应数值，使前端展示的信息保持准确时，可以调用这个方法，传入新的剩余数量数值，来更新该属性的值，保证前端展示的房间剩余数量信息与实际可预订情况相符。
public void setFangjianNumber(Integer fangjianNumber) {
this.fangjianNumber = fangjianNumber;
}
/**
* 设置：点击次数
*/
// 获取：点击次数
// 依据JavaBean规范定义的访问器（getter）方法，用于获取房间的点击次数属性（fangjianClicknum）的值，点击次数用于统计房间信息被查看的次数。
// 外部代码（比如展示房间相关信息的业务逻辑代码或者前端交互代码等，特别是在需要呈现房间受关注程度相关情况的场景下）可以调用这个方法，来获取当前对象所代表的房间被查看的次数信息，以便根据点击次数情况进行相应的展示（比如在前端页面展示房间的热门程度排序等）或业务处理（比如基于点击次数分析房间的受欢迎程度等），辅助用户了解该房间的关注度情况。
public Integer getFangjianClicknum() {
return fangjianClicknum;
}
/**
* 获取：点击次数
*/
// 设置：点击次数
// 这是遵循JavaBean规范定义的修改器（setter）方法，用于设置房间的点击次数属性（fangjianClicknum）的值。
// 外部代码在需要更新房间的点击次数信息时（例如每次有用户查看房间详情页面后，按照业务逻辑通常会对点击次数进行累加更新等情况），可以调用这个方法，传入相应的整数值（一般是在原有的点击次数基础上进行增加等操作）来改变该属性的值，确保点击次数数据能准确反映房间被查看的实际情况。
public void setFangjianClicknum(Integer fangjianClicknum) {
this.fangjianClicknum = fangjianClicknum;
}
/**
* 设置：房间详情
*/
// 获取：房间详情
// 按照JavaBean的属性访问器规范定义的方法，用于获取房间详情属性（fangjianContent）的值，该属性存储的是关于房间更全面、详细的描述信息。
// 外部代码（在展示房间相关信息时，为了同时向用户呈现房间的详细情况，帮助用户更好地理解房间的具体情况的相关业务逻辑代码中）可以调用这个方法，获取到像房间布局、面积大小、装修风格等更全面的介绍内容，使得用户在考虑预订等操作时能结合房间详情信息，更深入地了解具体情况，比如判断房间是否满足自己对住宿环境等方面的需求。
public String getFangjianContent() {
return fangjianContent;
}
/**
* 获取：房间详情
*/
// 设置：房间详情
// 遵循JavaBean规范的属性修改器方法，用于设置房间详情属性（fangjianContent）的值。
// 当需要更新房间的详细描述信息时（比如完善房间介绍、修改房间详情中的部分内容等业务场景，例如酒店重新装修后需要更新房间布局、风格等相关描述信息），外部代码可以调用这个方法，传入新的字符串内容来更新该属性的值，确保房间详情信息的准确性和及时性，使前端展示给用户的房间详情与实际情况一致。
public void setFangjianContent(String fangjianContent) {
this.fangjianContent = fangjianContent;
}
/**
* 设置：创建时间
*/
// 获取：创建时间
// 这是按照JavaBean规范定义的访问器（getter）方法，用于获取创建时间（createTime）属性的值，该属性用于记录房间信息在数据库中首次创建的时间。
// 外部代码（例如在进行数据统计分析，查看房间信息的创建时间分布情况，或者在一些业务逻辑中需要根据创建时间来判断房间相关业务的先后顺序等场景下）可以调用这个方法，获取当前对象对应的房间创建时间信息，方便进行后续的业务处理和分析。
public Date getCreateTime() {
return createTime;
}
/**
* 获取：创建时间
*/
// 设置：创建时间
// 定义了设置创建时间（createTime）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，用于设置房间信息在数据库中首次创建的时间值。
// 不过通常情况下，由于该属性在代码中设置了自动填充（通过@TableField(value = "create_time", fill = FieldFill.INSERT)注解指定在插入数据时自动填充当前时间），所以外部代码直接调用这个方法来设置创建时间的情况相对较少，更多是由框架在合适的时机自动赋值，但在某些特殊业务场景下（比如数据迁移、数据修复等情况）可能会用到手动设置创建时间的操作。
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 重写了toString()方法，用于返回一个包含FangjianEntity类所有属性信息的字符串表示形式。
// 当需要将FangjianEntity对象以字符串形式展示（比如在调试过程中打印对象信息、在日志中记录对象内容等场景）时，会自动调用这个方法，返回的字符串格式如"Fangjian{" + "id=" + id +...}"，方便开发人员直观地查看对象各个属性的具体值情况。
@Override
public String toString() {
return "Fangjian{" +
"id=" + id +
", fangjianName=" + fangjianName +
", fangjianPhoto=" + fangjianPhoto +
", fangjianTese=" + fangjianTese +
", fangjianPeizhi=" + fangjianPeizhi +
", fangjianShangpin=" + fangjianShangpin +
", fangjianFuwu=" + fangjianFuwu +
", fangjianMoney=" + fangjianMoney +
", fangjianTypes=" + fangjianTypes +
", fangjianNumber=" + fangjianNumber +
", fangjianClicknum=" + fangjianClicknum +
", fangjianContent=" + fangjianContent +
", createTime=" + createTime +
"}";
}
}
"id=" + id +
", fangjianName=" + fangjianName +
", fangjianPhoto=" + fangjianPhoto +
", fangjianTese=" + fangjianTese +
", fangjianPeizhi=" + fangjianPeizhi +
", fangjianShangpin=" + fangjianShangpin +
", fangjianFuwu=" + fangjianFuwu +
", fangjianMoney=" + fangjianMoney +
", fangjianTypes=" + fangjianTypes +
", fangjianNumber=" + fangjianNumber +
", fangjianClicknum=" + fangjianClicknum +
", fangjianContent=" + fangjianContent +
", createTime=" + createTime +
"}";
}

219
minsu/minsuguanliw/src/main/java/com/entity/FangjianLiuyanEntity.java
Unescape View File

@ -1,237 +1,266 @@
package com.entity;
// 导入MyBatis Plus中用于标识主键的注解，通过设置其type属性可以指定主键的生成策略，这里设置为IdType.AUTO表示主键为自动增长类型
import com.baomidou.mybatisplus.annotations.TableId;
// 导入MyBatis Plus中用于指定实体类对应的数据库表名的注解，使得框架能将该实体类与数据库中的相应表进行关联操作，此处表明该类对应数据库中的"fangjian_liuyan"表
import com.baomidou.mybatisplus.annotations.TableName;
// 导入用于验证字段不能为空的注解，确保对应属性在使用时有值，常用于参数校验场景，比如在接收前端传入的数据时验证是否符合要求，这里强调对应属性不能为空白（包含空字符串、空格等情况）
import javax.validation.constraints.NotBlank;
// 导入用于验证集合类型字段不能为空的注解，强调对应的集合属性不能为null且不能是空集合，常用于对列表等数据结构的校验，不过在当前类中暂时未看到明显相关使用场景
import javax.validation.constraints.NotEmpty;
// 导入用于验证基本数据类型字段不能为空的注解，保证对应属性有具体的非空值，防止出现空指针等问题，用于确保基本数据类型属性有实际值
import javax.validation.constraints.NotNull;
// 导入Jackson框架的注解，用于指定在序列化和反序列化过程中忽略某些属性，常用于处理一些不需要展示或者不需要参与数据交互的属性，不过此处未明确配置忽略的属性列表
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入用于处理Java反射机制中方法调用异常的相关类，在使用反射相关操作（如通过BeanUtils复制属性时）可能会抛出此类异常，需要进行捕获处理以保证程序稳定运行
import java.lang.reflect.InvocationTargetException;
// 导入Java的序列化接口，表明该类的对象可以被序列化和反序列化，方便在网络传输、持久化存储等场景下对该类的实例进行操作，例如在前后端数据交互或者保存对象状态到文件等情况中使用
import java.io.Serializable;
// 导入Java中的日期类，用于处理评论/投诉相关的时间属性，如评论/投诉时间、回复时间、创建时间等，方便记录对应操作发生的具体时间点
import java.util.Date;
// 导入Java的集合类框架中的List接口，虽然在当前代码中未看到明显使用场景，但可能用于后续扩展该实体类与其他集合类型数据的关联，比如可能关联多条相关回复记录等情况
import java.util.List;
// 导入Spring框架的日期格式化注解，用于在接收前端传入的日期参数或者向前端返回日期数据时，按照指定格式进行转换处理，使日期数据的格式符合业务要求
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson框架的另一个注解，用于在序列化和反序列化日期类型数据时，按照指定的格式（如这里配置的"yyyy-MM-dd HH:mm:ss"）进行处理，确保日期格式的一致性和准确性
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Apache Commons BeanUtils工具类，其提供了方便的方法来进行Java对象之间属性的复制操作，在本类的构造函数中会使用它来进行属性赋值操作，将传入对象的属性复制到当前对象中
import org.apache.commons.beanutils.BeanUtils;
// 导入MyBatis Plus中用于标识字段与数据库表字段映射关系的注解，同时可以设置一些额外属性，如这里的fill属性用于指定字段在插入或更新时的自动填充策略
import com.baomidou.mybatisplus.annotations.TableField;
// 导入MyBatis Plus中用于定义字段填充策略的枚举类型，此处使用的FieldFill.INSERT表示在插入数据时自动填充指定字段，常用于创建时间等字段的自动赋值；FieldFill.UPDATE表示在更新数据时自动填充指定字段
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入MyBatis Plus中用于定义主键生成类型的枚举类型，之前提到的IdType.AUTO就是其中一种表示自动增长的类型
import com.baomidou.mybatisplus.enums.IdType;
/**
* 房间评论/投诉
* 该类用于表示房间相关的评论或投诉信息，是与数据库中"fangjian_liuyan"表对应的实体类，包含了评论/投诉涉及的各项关键信息以及对应的访问器（getter）和修改器（setter）方法，同时实现了Serializable接口以支持对象的序列化和反序列化操作，方便在不同场景下使用该对象传递和存储数据。
*
* @author
* @email
* @author // 此处应该填写作者相关信息，可能是开发人员的姓名等，但代码中未明确给出具体值
* @email // 同样，此处应该填写作者的邮箱信息，代码中也未给出具体内容，用于标识代码的归属或者方便联系作者等用途
*/
@TableName("fangjian_liuyan")
public class FangjianLiuyanEntity<T> implements Serializable {
// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化（如添加、删除字段等）时，可以通过修改这个版本号来避免反序列化出错，初始值设为1L，在类相对稳定的情况下一般不需要改动
private static final long serialVersionUID = 1L;
// 默认构造函数，用于创建FangjianLiuyanEntity类的实例对象，在一些情况下（比如通过反射等方式创建对象时）可能会用到，它会创建一个默认状态的对象实例，各个属性会使用其对应类型的默认值初始化（如基本数据类型的默认初始值等）
public FangjianLiuyanEntity() {
public FangjianLiuyanEntity() {
}
public FangjianLiuyanEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
// 构造函数，接收一个泛型类型参数t，用于将传入的对象（其类型由泛型T指定）的属性值复制到当前FangjianLiuyanEntity对象中，通过BeanUtils工具类来实现属性复制，方便基于已有的同类型或者兼容类型的数据构建FangjianLiuyanEntity对象，不过在复制过程中可能会抛出异常，所以进行了异常捕获处理
public FangjianLiuyanEntity(T t) {
try {
// 使用BeanUtils的copyProperties方法，将t对象的属性值复制到当前对象（this）中，实现属性的赋值操作，但该方法可能会抛出IllegalAccessException（访问权限异常）和InvocationTargetException（方法调用异常），所以需要进行异常捕获处理
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 如果在属性复制过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，确定是哪里出现了访问权限问题或者方法调用出错等情况
e.printStackTrace();
}
}
/**
* 主键
* 用于唯一标识数据库中的每条房间评论/投诉记录，在数据库表中通常是一个自增长的整数类型字段，通过@TableId注解指定了其主键生成策略为自动增长（IdType.AUTO），并通过@TableField注解明确了对应的数据库表字段名为"id"，方便在数据库操作时进行数据的关联和查询等操作。
*/
@TableId(type = IdType.AUTO)
@TableField(value = "id")
private Integer id;
/**
* 房间
* 用于存储关联的房间的唯一标识（通常是房间在数据库中的主键值），通过@TableField注解指定了其在数据库表中对应的字段名为"fangjian_id"，这样在进行数据库查询、关联等操作时，可以准确找到对应的房间信息，例如获取该房间的详细情况来辅助处理评论/投诉相关业务。
*/
@TableField(value = "fangjian_id")
private Integer fangjianId;
/**
* 用户
* 用于存储发起评论/投诉的用户的唯一标识（一般是用户在数据库中的主键值），通过@TableField注解与数据库表中的"yonghu_id"字段进行映射关联，便于后续根据用户标识查找用户的详细信息，比如获取用户的联系方式以便对评论/投诉进行沟通回复等操作。
*/
@TableField(value = "yonghu_id")
private Integer yonghuId;
/**
* 评论/投诉内容
* 用于存储用户实际输入的关于房间的评论或投诉的具体文本内容，通过@TableField注解对应数据库表中的"fangjian_liuyan_text"字段，使得在数据持久化和查询时能准确获取和更新评论/投诉的详细文字信息，方便业务处理和展示给相关人员查看。
*/
@TableField(value = "fangjian_liuyan_text")
private String fangjianLiuyanText;
/**
* 回复内容
* 用于存储针对用户评论/投诉所给出的回复的文本内容，通过@TableField注解关联到数据库表中的"reply_text"字段，以便在数据库操作中准确记录和获取回复的具体信息，在业务中可以展示给用户查看回复情况，或者用于后续分析回复的质量等操作。
*/
@TableField(value = "reply_text")
private String replyText;
/**
* 评论/投诉时间
* 用于记录用户发起评论/投诉操作的具体时间，通过@JsonFormat注解指定了在序列化和反序列化时的日期格式为"yyyy-MM-dd HH:mm:ss"，并且设置了时区为"GMT+8"（东八区，符合中国等地区的时间标准），同时利用@DateTimeFormat注解用于在接收前端传入的日期参数时进行格式处理，通过@TableField注解结合FieldFill.INSERT设置了该字段在插入数据时会自动填充当前时间，准确记录评论/投诉发生的时间点，方便后续按时间顺序查看、统计相关评论/投诉情况。
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "insert_time",fill = FieldFill.INSERT)
@JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "insert_time", fill = FieldFill.INSERT)
private Date insertTime;
/**
* 回复时间
* 用于记录针对评论/投诉给出回复的具体时间，同样通过@JsonFormat、@DateTimeFormat注解来规范日期格式以及处理前端传入的日期参数格式，通过@TableField注解结合FieldFill.UPDATE设置了该字段在更新数据（这里通常指添加回复内容时更新记录）时会自动填充当前时间，方便准确记录回复操作的时间，便于后续查看回复的及时性等业务分析。
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "update_time",fill = FieldFill.UPDATE)
@JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "update_time", fill = FieldFill.UPDATE)
private Date updateTime;
/**
* 创建时间
* 用于记录该条评论/投诉记录在数据库中首次创建的时间，通过相关日期格式注解来确保格式的一致性，利用@TableField注解结合FieldFill.INSERT实现插入数据时自动填充当前时间，便于后续对记录创建时间进行统计分析等操作，比如查看不同时间段的评论/投诉量变化情况等。
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time",fill = FieldFill.INSERT)
@JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
/**
* 设置：主键
*/
* 设置：主键
* 这是按照JavaBean规范定义的修改器（setter）方法，用于设置主键（id）属性的值，外部代码（比如在进行数据库插入或更新操作时，需要为房间评论/投诉对象设置主键值的相关业务逻辑代码）可以调用这个方法，传入相应的整数值来更新该属性的值。
*/
public Integer getId() {
return id;
}
/**
* 获取：主键
*/
/**
* 获取：主键
* 这是按照JavaBean规范定义的访问器（getter）方法，用于获取主键（id）属性的值，外部代码（例如在查询数据库中的房间评论/投诉记录后，需要获取记录主键信息用于后续业务处理，如根据主键进行关联查询等相关业务逻辑代码）可以调用这个方法，获取当前对象的主键值。
*/
public void setId(Integer id) {
this.id = id;
}
/**
* 设置：房间
*/
* 设置：房间
* 定义了设置房间（fangjianId）属性值的方法，遵循JavaBean规范中的属性修改器（setter）方法定义，外部代码在需要关联不同房间的评论/投诉记录（比如发现记录关联的房间有误，需要修改为正确的房间标识等情况）时，可以调用这个方法，传入相应的房间标识整数值，以此来改变该属性的值，确保与正确的房间相关联。
*/
public Integer getFangjianId() {
return fangjianId;
}
/**
* 获取：房间
*/
/**
* 获取：房间
* 按照JavaBean规范定义的访问器（getter）方法，用于获取房间（fangjianId）属性的值，外部代码（例如在处理评论/投诉相关业务时，需要获取关联的房间信息，以便展示房间详情、分析房间相关问题等业务逻辑代码）可以调用这个方法，获取当前对象所关联房间的标识值，进而去获取更多房间相关的详细信息。
*/
public void setFangjianId(Integer fangjianId) {
this.fangjianId = fangjianId;
}
/**
* 设置：用户
*/
* 设置：用户
* 此为设置用户（yonghuId）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，外部代码在出现诸如需要将评论/投诉记录关联到正确的用户（比如原记录用户标识有误，或者进行数据迁移等情况需要重新设置用户关联），可以调用这个方法，传入相应的用户标识整数值，来更新该属性的值，保证与正确的用户相关联。
*/
public Integer getYonghuId() {
return yonghuId;
}
/**
* 获取：用户
*/
/**
* 获取：用户
* 这是依据JavaBean规范定义的访问器（getter）方法，用于获取用户（yonghuId）属性的值，外部代码（像是在处理评论/投诉相关业务时，需要获取发起评论/投诉的用户的详细信息，比如联系用户、查看用户历史评论等相关代码逻辑中）可以调用此方法，获取到当前对象记录的用户标识值，便于进一步查找用户的具体情况。
*/
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
/**
* 设置：评论/投诉内容
*/
* 设置：评论/投诉内容
* 定义了设置评论/投诉内容（fangjianLiuyanText）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，外部代码在有修改评论/投诉内容的需求（比如用户申请修改自己之前的评论/投诉内容，且业务允许修改的情况下）时，可以调用这个方法，传入新的评论/投诉文本内容，以此来更新该属性的值，确保记录的内容是最新且准确的。
*/
public String getFangjianLiuyanText() {
return fangjianLiuyanText;
}
/**
* 获取：评论/投诉内容
*/
/**
* 获取：评论/投诉内容
* 按照JavaBean规范定义的访问器（getter）方法，用于获取评论/投诉内容（fangjianLiuyanText）属性的值，外部代码（例如在展示评论/投诉详情页面，需要将用户输入的具体内容展示出来的相关业务逻辑代码中）可以调用这个方法，获取当前对象注明的评论/投诉的具体文本信息，便于展示给相关人员查看。
*/
public void setFangjianLiuyanText(String fangjianLiuyanText) {
this.fangjianLiuyanText = fangjianLiuyanText;
}
/**
* 设置：回复内容
*/
* 设置：回复内容
* 这是遵循JavaBean规范定义的用于设置回复内容（replyText）属性值的方法，属于属性修改器（setter）方法，外部代码在需要更新回复的文本内容（比如工作人员发现之前回复有误，需要重新修改回复内容等情况）时，可以调用这个方法，传入新的回复文本内容，来更新该属性的值，保证记录的回复信息是准确的。
*/
public String getReplyText() {
return replyText;
}
/**
* 获取：回复内容
*/
/**
* 获取：回复内容
* 依据JavaBean规范定义的访问器（getter）方法，用于获取回复内容（replyText）属性的值，外部代码（在展示评论/投诉的回复情况，需要将回复的具体文本展示给用户查看的相关业务逻辑代码中）可以调用这个方法，获取当前对象记录的回复的具体文本信息，方便用户了解回复的详细内容。
*/
public void setReplyText(String replyText) {
this.replyText = replyText;
}
/**
* 设置：评论/投诉时间
*/
* 设置：评论/投诉时间
* 定义了设置评论/投诉时间（insertTime）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，不过通常情况下该字段是由框架自动填充（插入记录时），外部代码直接调用此方法设置时间的情况较少，但在一些特殊业务场景（比如数据迁移、时间数据修复等）下可能会用到手动设置时间值，传入相应的Date类型的时间对象来更新该属性的值。
*/
public Date getInsertTime() {
return insertTime;
}
/**
* 获取：评论/投诉时间
*/
/**
* 获取：评论/投诉时间
* 按照JavaBean规范定义的访问器（getter）方法，用于获取评论/投诉时间（insertTime）属性的值，外部代码（例如在按时间顺序查看评论/投诉记录、统计不同时间段的评论/投诉数量等相关业务逻辑代码中）可以调用这个方法，获取当前对象对应的评论/投诉发生的具体时间信息，方便进行后续的业务处理和分析。
*/
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
/**
* 设置：回复时间
*/
// 获取：回复时间
// 按照JavaBean规范定义的访问器（getter）方法，用于获取回复时间（updateTime）属性的值。
// 外部代码（比如在展示房间评论/投诉相关信息时，需要呈现针对该评论/投诉的回复具体是何时做出的相关业务逻辑代码中，或者在分析回复及时性等业务场景下）可以调用这个方法，获取当前对象记录的回复操作发生的时间信息，方便进行展示以及后续的时间相关分析，例如查看回复是否及时等情况。
public Date getUpdateTime() {
return updateTime;
}
/**
* 获取：回复时间
*/
// 设置：回复时间
// 定义了设置回复时间（updateTime）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则。
// 通常情况下，该属性会通过框架在更新数据（例如添加或修改回复内容时）自动填充当前时间（通过@TableField(value = "update_time", fill = FieldFill.UPDATE)注解配置实现自动填充），不过在一些特殊业务场景下（比如数据迁移、时间数据修复等情况），外部代码（如负责数据维护相关的业务逻辑代码）可以调用这个方法，传入相应的Date类型的时间对象来更新该属性的值，确保回复时间记录的准确性。
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
/**
* 设置：创建时间
*/
// 获取：创建时间
// 这是按照JavaBean规范定义的访问器（getter）方法，用于获取创建时间（createTime）属性的值，该属性用于记录这条房间评论/投诉记录在数据库中首次被创建的时间点。
// 外部代码（例如在进行数据统计分析，查看不同时间段内房间评论/投诉记录的创建数量变化情况，或者在一些业务逻辑中需要根据创建时间来判断相关业务的先后顺序等场景下）可以调用这个方法，获取当前对象对应的创建时间信息，方便进行后续的业务处理和分析操作。
public Date getCreateTime() {
return createTime;
}
/**
* 获取：创建时间
*/
// 设置：创建时间
// 遵循JavaBean规范里的属性修改器（setter）规则定义的方法，用于设置房间评论/投诉记录的创建时间（createTime）属性值。
// 一般来说，该属性会在插入数据时由框架自动填充当前时间（通过@TableField(value = "create_time", fill = FieldFill.INSERT)注解配置实现自动填充），不过在特定的业务需求场景下（比如数据迁移、历史数据修复等），外部代码（例如负责数据处理的相关业务逻辑代码）可以调用这个方法，传入对应的Date类型的时间对象来改变该属性的值，以保证创建时间数据的准确性和符合实际业务要求。
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
// 重写了toString()方法，用于返回一个包含FangjianLiuyanEntity类所有属性信息的字符串表示形式。
// 当需要将FangjianLiuyanEntity对象以字符串形式展示（比如在调试过程中打印对象信息、在日志中记录对象内容等场景）时，会自动调用这个方法，按照指定的格式（如"FangjianLiuyan{" + "id=" + id +...}"）返回包含各个属性值的字符串，方便开发人员直观地查看对象各个属性的具体值情况，有助于快速定位和排查对象数据相关的问题。
@Override
public String toString() {
return "FangjianLiuyan{" +
"id=" + id +
", fangjianId=" + fangjianId +
", yonghuId=" + yonghuId +
", fangjianLiuyanText=" + fangjianLiuyanText +
", replyText=" + replyText +
", insertTime=" + insertTime +
", updateTime=" + updateTime +
", createTime=" + createTime +
"}";
}
}
"id=" + id +
", fangjianId=" + fangjianId +
", yonghuId=" + yonghuId +
", fangjianLiuyanText=" + fangjianLiuyanText +
", replyText=" + replyText +
", insertTime=" + insertTime +
", updateTime=" + updateTime +
", createTime=" + createTime +
"}";
}

199
minsu/minsuguanliw/src/main/java/com/entity/FangjianOrderEntity.java
Unescape View File

@ -1,213 +1,248 @@
package com.entity;
// 导入MyBatis Plus中用于标识主键的注解，通过设置其type属性可以指定主键的生成策略，这里设置为IdType.AUTO表示主键是自动增长类型，方便数据库为每条记录自动分配唯一的标识符
import com.baomidou.mybatisplus.annotations.TableId;
// 导入MyBatis Plus中用于指定实体类对应的数据库表名的注解，使得框架能将该实体类与数据库中的相应表进行关联操作，此处表明该类对应数据库中的"fangjian_order"表，即房间预约相关的数据表
import com.baomidou.mybatisplus.annotations.TableName;
// 导入用于验证字段不能为空的注解，确保对应属性在使用时有值，常用于参数校验场景，比如在接收前端传入的数据时验证是否符合要求，防止出现空值导致后续业务逻辑出错
import javax.validation.constraints.NotBlank;
// 导入用于验证集合类型字段不能为空的注解，强调对应的集合属性不能为null且不能是空集合，不过在当前类中暂时未看到明显与之相关的使用场景，更多是针对集合属性的校验保障
import javax.validation.constraints.NotEmpty;
// 导入用于验证基本数据类型字段不能为空的注解，保证对应属性有具体的非空值，避免因基本数据类型属性为空引发空指针等异常情况，保障业务逻辑的正常执行
import javax.validation.constraints.NotNull;
// 导入Jackson框架的注解，用于指定在序列化和反序列化过程中忽略某些属性，常用于处理一些不需要展示或者不需要参与数据交互的属性，可根据业务需求灵活配置忽略的属性列表，但此处未明确具体要忽略的属性
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
// 导入用于处理Java反射机制中方法调用异常的相关类，在使用反射相关操作（比如通过BeanUtils进行属性复制时）可能会抛出此类异常，所以需要进行捕获处理以保证程序稳定运行，避免因异常导致程序崩溃
import java.lang.reflect.InvocationTargetException;
// 导入Java的序列化接口，表明该类的对象可以被序列化和反序列化，方便在网络传输、持久化存储等场景下对该类的实例进行操作，例如在前后端数据交互或者保存对象状态到文件等情况中使用，确保数据能以合适的方式进行传递和保存
import java.io.Serializable;
// 导入Java中的日期类，用于处理与房间预约相关的各种时间属性，如预约日期、创建时间等，方便准确记录和操作不同时间节点的信息，满足业务对时间数据的需求
import java.util.Date;
// 导入Java的集合类框架中的List接口，虽然在当前代码中未看到明显使用场景，但可能用于后续扩展该实体类与其他集合类型数据的关联，比如可能关联多条同房间不同时间段的预约记录等情况
import java.util.List;
// 导入Spring框架的日期格式化注解，用于在接收前端传入的日期参数或者向前端返回日期数据时，按照指定格式进行转换处理，使日期数据的格式符合业务要求，确保数据在交互过程中的格式一致性和准确性
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson框架的另一个注解，用于在序列化和反序列化日期类型数据时，按照指定的格式（如这里配置的不同格式，有的是"yyyy-MM-dd"用于预约日期，有的是"yyyy-MM-dd HH:mm:ss"用于创建时间等）进行处理，保证日期数据在不同操作中的格式规范统一
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Apache Commons BeanUtils工具类，其提供了方便的方法来进行Java对象之间属性的复制操作，在本类的构造函数中会使用它来进行属性赋值操作，将传入对象的属性复制到当前对象中，实现对象间属性值的快速传递
import org.apache.commons.beanutils.BeanUtils;
// 导入MyBatis Plus中用于标识字段与数据库表字段映射关系的注解，同时可以设置一些额外属性，如这里的fill属性用于指定字段在插入或更新时的自动填充策略，便于在数据库操作时自动处理一些字段值的赋值情况
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.enums.FieldFill;
// 导入MyBatis Plus中用于定义字段填充策略的枚举类型，此处使用的FieldFill.INSERT表示在插入数据时自动填充指定字段（常用于创建时间等字段的自动赋值），方便记录关键时间信息
import com.baomidou.myatisplus.enums.FieldFill;
// 导入MyBatis Plus中用于定义主键生成类型的枚举类型，之前提到的IdType.AUTO就是其中一种表示自动增长的类型，清晰定义主键的生成规则
import com.baomidou.mybatisplus.enums.IdType;
/**
* 房间预约
* 该类用于表示房间预约相关的各种信息，是与数据库中"fangjian_order"表对应的实体类，包含了预约涉及的关键属性以及对应的访问器（getter）和修改器（setter）方法，同时实现了Serializable接口以支持对象的序列化和反序列化操作，方便在不同场景下（如前后端数据交互、数据持久化存储等）使用该对象传递和存储数据，满足房间预约业务的需求。
*
* @author
* @email
* @author // 此处应该填写作者相关信息，可能是开发人员的姓名等，但代码中未明确给出具体值，用于标识代码的创作者
* @email // 同样，此处应该填写作者的邮箱信息，代码中也未给出具体内容，可用于方便联系作者或者明确代码归属等用途
*/
@TableName("fangjian_order")
public class FangjianOrderEntity<T> implements Serializable {
// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化（如添加、删除字段等）时，可以通过修改这个版本号来避免反序列化出错，初始值设为1L，在类相对稳定的情况下一般不需要改动，维持对象序列化的稳定性
private static final long serialVersionUID = 1L;
// 默认构造函数，用于创建FangjianOrderEntity类的实例对象，在一些情况下（比如通过反射等方式创建对象时）可能会用到，它会创建一个默认状态的对象实例，各个属性会使用其对应类型的默认值初始化（如基本数据类型的默认初始值等），为对象的创建提供一种基础方式
public FangjianOrderEntity() {
public FangjianOrderEntity() {
}
public FangjianOrderEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
// 构造函数，接收一个泛型类型参数t，用于将传入的对象（其类型由泛型T指定）的属性值复制到当前FangjianOrderEntity对象中，通过BeanUtils工具类来实现属性复制，方便基于已有的同类型或者兼容类型的数据构建FangjianOrderEntity对象，不过在复制过程中可能会抛出异常，所以进行了异常捕获处理，保障属性复制操作的稳定性
public FangjianOrderEntity(T t) {
try {
// 使用BeanUtils的copyProperties方法，将t对象的属性值复制到当前对象（this）中，实现属性的赋值操作，但该方法可能会抛出IllegalAccessException（访问权限异常）和InvocationTargetException（方法调用异常），所以需要进行异常捕获处理，确保属性复制过程遇到问题能妥善处理
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// 如果在属性复制过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，确定是哪里出现了访问权限问题或者方法调用出错等情况，辅助定位和解决异常
e.printStackTrace();
}
}
/**
* 主键
* 用于唯一标识数据库中的每条房间预约记录，在数据库表中通常是一个自增长的整数类型字段，通过@TableId注解指定了其主键生成策略为自动增长（IdType.AUTO），并通过@TableField注解明确了对应的数据库表字段名为"id"，方便在数据库操作时进行数据的关联、查询、更新等操作，确保每条预约记录都能被准确识别和处理。
*/
@TableId(type = IdType.AUTO)
@TableField(value = "id")
private Integer id;
/**
* 房间
* 用于存储预约的房间的唯一标识（通常是房间在数据库中的主键值），通过@TableField注解指定了其在数据库表中对应的字段名为"fangjian_id"，这样在进行数据库查询、关联等操作时，可以准确找到对应的房间信息，例如获取房间的详细配置、剩余数量等情况来辅助处理预约相关业务，保证预约操作与正确的房间相关联。
*/
@TableField(value = "fangjian_id")
private Integer fangjianId;
/**
* 用户
* 用于存储发起预约的用户的唯一标识（一般是用户在数据库中的主键值），通过@TableField注解与数据库表中的"yonghu_id"字段进行映射关联，便于后续根据用户标识查找用户的详细信息，比如获取用户的联系方式以便进行预约确认、通知等操作，确保预约记录与正确的用户对应起来。
*/
@TableField(value = "yonghu_id")
private Integer yonghuId;
/**
* 预约日期
* 用于记录用户预约房间的具体日期，通过@JsonFormat注解指定了在序列化和反序列化时的日期格式为"yyyy-MM-dd"，并且设置了时区为"GMT+8"（东八区，符合中国等地区的时间标准），同时利用@DateTimeFormat注解用于在接收前端传入的日期参数时进行格式处理，通过@TableField注解对应数据库表中的"fangjian_order_time"字段，使得在数据持久化和查询时能准确获取和更新预约日期信息，方便业务根据日期进行房间资源安排等操作。
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd")
@DateTimeFormat
@JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd")
@DateTimeFormat
@TableField(value = "fangjian_order_time")
private Date fangjianOrderTime;
/**
* 预约备注
* 用于存储用户在预约房间时添加的一些额外说明信息，比如特殊要求、期望的房间布置等内容，通过@TableField注解关联到数据库表中的"fangjian_order_text"字段，以便在数据库操作中准确记录和获取预约备注的具体信息，在业务处理中可以查看并根据备注内容满足用户的特殊需求等。
*/
@TableField(value = "fangjian_order_text")
private String fangjianOrderText;
/**
* 订单状态
* 用于表示房间预约订单当前所处的状态，例如可能用不同的数字或代码表示已预约、已支付、已取消等不同状态，通过@TableField注解对应数据库表中的"fangjian_order_types"字段，方便在数据库操作时更新和查询订单状态信息，便于业务根据状态进行相应的处理和流程控制，比如根据已支付状态安排房间入住等操作。
*/
@TableField(value = "fangjian_order_types")
private Integer fangjianOrderTypes;
/**
* 创建时间
* 用于记录该条房间预约记录在数据库中首次创建的时间，通过@JsonFormat注解指定了在序列化和反序列化时的日期格式为"yyyy-MM-dd HH:mm:ss"，并且设置了时区为"GMT+8"（东八区，符合中国等地区的时间标准），同时利用@DateTimeFormat注解用于在接收前端传入的日期参数时进行格式处理，通过@TableField注解结合FieldFill.INSERT设置了该字段在插入数据时会自动填充当前时间，便于准确记录预约记录的创建时间点，方便后续对预约记录的创建情况进行统计分析等操作。
*/
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time",fill = FieldFill.INSERT)
@JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
/**
* 设置：主键
*/
* 设置：主键
* 这是按照JavaBean规范定义的修改器（setter）方法，用于设置主键（id）属性的值，外部代码（比如在进行数据库插入或更新操作时，需要为房间预约对象设置主键值的相关业务逻辑代码，不过通常主键是自动增长，手动设置情况较少）可以调用这个方法，传入相应的整数值来更新该属性的值，确保主键值的准确性和可修改性（尽管实际应用中手动修改主键情况不多见）。
*/
public Integer getId() {
return id;
}
/**
* 获取：主键
*/
/**
* 获取：主键
* 这是按照JavaBean规范定义的访问器（getter）方法，用于获取主键（id）属性的值，外部代码（例如在查询数据库中的房间预约记录后，需要获取记录主键信息用于后续业务处理，如根据主键进行关联查询、数据传递等相关业务逻辑代码）可以调用这个方法，获取当前对象的主键值，方便在不同业务场景下使用主键进行相关操作。
*/
public void setId(Integer id) {
this.id = id;
}
/**
* 设置：房间
*/
* 设置：房间
* 定义了设置房间（fangjianId）属性值的方法，遵循JavaBean规范中的属性修改器（setter）方法定义，外部代码在需要关联不同房间的预约记录（比如发现记录关联的房间有误，需要修改为正确的房间标识等情况）时，可以调用这个方法，传入相应的房间标识整数值，以此来改变该属性的值，确保预约记录与正确的房间相关联，保障预约业务的准确性。
*/
public Integer getFangjianId() {
return fangjianId;
}
/**
* 获取：房间
*/
/**
* 获取：房间
* 按照JavaBean规范定义的访问器（getter）方法，用于获取房间（fangjianId）属性的值，外部代码（例如在处理房间预约相关业务时，需要获取预约的房间信息，以便展示房间详情、查看房间剩余数量等业务逻辑代码）可以调用这个方法，获取当前对象所关联房间的标识值，进而去获取更多房间相关的详细信息来辅助业务处理。
*/
public void setFangjianId(Integer fangjianId) {
this.fangjianId = fangjianId;
}
/**
* 设置：用户
*/
* 设置：用户
* 此为设置用户（yonghuId）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，外部代码在出现诸如需要将预约记录关联到正确的用户（比如原记录用户标识有误，或者进行数据迁移等情况需要重新设置用户关联）时，可以调用这个方法，传入相应的用户标识整数值，来更新该属性的值，保证预约记录与正确的用户对应起来，避免因用户关联错误导致业务问题。
*/
public Integer getYonghuId() {
return yonghuId;
}
/**
* 获取：用户
*/
/**
* 获取：用户
* 这是依据JavaBean规范定义的访问器（getter）方法，用于获取用户（yonghuId）属性的值，外部代码（像是在处理房间预约相关业务时，需要获取发起预约的用户的详细信息，比如联系用户进行预约确认、查看用户历史预约记录等相关代码逻辑中）可以调用此方法，获取到当前对象记录的用户标识值，便于进一步查找用户的具体情况来满足业务需求。
*/
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
/**
* 设置：预约日期
*/
* 设置：预约日期
* 定义了设置预约日期（fangjianOrderTime）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，外部代码在有修改预约日期的需求（比如用户申请变更预约时间，且业务允许修改的情况下）时，可以调用这个方法，传入新的Date类型的日期对象作为预约日期，以此来更新该属性的值，确保预约日期记录的准确性，满足业务中日期变更的需求。
*/
public Date getFangjianOrderTime() {
return fangjianOrderTime;
}
/**
* 获取：预约日期
*/
/**
* 获取：预约日期
* 按照JavaBean规范定义的访问器（getter）方法，用于获取预约日期（fangjianOrderTime）属性的值，外部代码（例如在展示预约详情页面，需要告知用户预约的具体日期，或者在业务逻辑中根据预约日期进行房间资源调配等相关业务逻辑代码中）可以调用这个方法，获取当前对象记录的预约日期信息，方便进行展示以及后续的业务处理操作。
*/
public void setFangjianOrderTime(Date fangjianOrderTime) {
this.fangjianOrderTime = fangjianOrderTime;
}
/**
* 设置：预约备注
*/
* 设置：预约备注
* 这是遵循JavaBean规范定义的用于设置预约备注（fangjianOrderText）属性值的方法，属于属性修改器（setter）方法，外部代码在需要更新预约备注的文本内容（比如用户想要补充或修改之前添加的备注信息，且业务允许修改的情况下）时，可以调用这个方法，传入新的备注文本内容，来更新该属性的值，保证记录的预约备注信息是最新且准确的，以便更好地满足用户的特殊需求。
*/
public String getFangjianOrderText() {
return fangjianOrderText;
}
/**
* 获取：预约备注
*/
/**
* 获取：预约备注
* 依据JavaBean规范定义的访问器（getter）方法，用于获取预约备注（fangjianOrderText）属性的值，外部代码（在展示预约详情页面，需要将用户添加的备注信息展示出来的相关业务逻辑代码中）可以调用这个方法，获取当前对象记录的预约备注的具体文本信息，方便展示给用户查看，使其知晓之前添加的备注内容。
*/
public void setFangjianOrderText(String fangjianOrderText) {
this.fangjianOrderText = fangjianOrderText;
}
/**
* 设置：订单状态
*/
* 设置：订单状态
* 定义了设置订单状态（fangjianOrderTypes）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则。
* 外部代码在业务流程中，当房间预约订单的状态发生变化时（比如用户完成支付，业务逻辑需要将订单状态从已预约改为已支付；或者用户取消预约，将状态改为已取消；又或者因其他业务规则触发状态变更，像超时未支付自动变更为已失效等情况），可以调用这个方法，传入相应的表示新状态的整数值（通常不同的整数值对应不同的预定义状态，具体的映射关系由业务决定），以此来更新该属性的值，确保订单状态能准确反映当前预约业务的实际进展情况，方便后续依据不同状态进行相应的业务处理和流程控制。
*/
public Integer getFangjianOrderTypes() {
// 按照JavaBean规范定义的访问器（getter）方法，用于获取订单状态（fangjianOrderTypes）属性的值。
// 外部代码（例如在展示预约订单详情页面，需要告知用户当前订单处于何种状态，或者在业务逻辑中根据订单状态决定下一步操作，像已支付状态则安排后续入住流程等相关业务逻辑代码中）可以调用这个方法，获取当前对象记录的订单状态信息，方便进行展示以及后续的业务处理操作。
return fangjianOrderTypes;
}
/**
* 获取：订单状态
*/
* 获取：订单状态
*/
public void setFangjianOrderTypes(Integer fangjianOrderTypes) {
// 将传入的参数值（代表新的订单状态的整数值）赋值给当前对象的fangjianOrderTypes属性，完成对订单状态属性值的更新操作。
// 这样就能使订单状态在业务流程变化时及时得到准确修改，保证整个预约业务系统中订单状态信息的准确性和时效性，以便后续各环节能依据正确的状态进行相应处理。
this.fangjianOrderTypes = fangjianOrderTypes;
}
/**
* 设置：创建时间
*/
* 设置：创建时间
* 遵循JavaBean规范里的属性修改器（setter）规则定义的方法，用于设置房间预约记录的创建时间（createTime）属性值。
* 一般来说，该属性会在插入数据时由框架自动填充当前时间（通过@TableField(value = "create_time", fill = FieldFill.INSERT)注解配置实现自动填充），不过在特定的业务需求场景下（比如数据迁移、历史数据修复等），外部代码（例如负责数据处理的相关业务逻辑代码）可以调用这个方法，传入对应的Date类型的时间对象来改变该属性的值，以保证创建时间数据的准确性和符合实际业务要求。
*/
public Date getCreateTime() {
// 按照JavaBean规范定义的访问器（getter）方法，用于获取创建时间（createTime）属性的值，该属性用于记录这条房间预约记录在数据库中首次被创建的时间点。
// 外部代码（例如在进行数据统计分析，查看不同时间段内房间预约记录的创建数量变化情况，或者在一些业务逻辑中需要根据创建时间来判断相关业务的先后顺序等场景下）可以调用这个方法，获取当前对象对应的创建时间信息，方便进行后续的业务处理和分析操作。
return createTime;
}
/**
* 获取：创建时间
*/
* 获取：创建时间
*/
public void setCreateTime(Date createTime) {
// 将传入的Date类型的时间对象赋值给当前对象的createTime属性，完成对创建时间属性值的更新操作。
// 主要用于特殊业务场景下对创建时间的手动调整，确保其能准确反映预约记录真实的创建时间情况，保障基于创建时间相关的业务逻辑和数据分析的准确性。
this.createTime = createTime;
}
@Override
public String toString() {
// 重写了toString()方法，用于返回一个包含FangjianOrderEntity类所有属性信息的字符串表示形式。
// 当需要将FangjianOrderEntity对象以字符串形式展示（比如在调试过程中打印对象信息、在日志中记录对象内容等场景）时，会自动调用这个方法，按照指定的格式（如"FangjianOrder{" + "id=" + id +...}"）返回包含各个属性值的字符串，方便开发人员直观地查看对象各个属性的具体值情况，有助于快速定位和排查对象数据相关的问题。
return "FangjianOrder{" +
"id=" + id +
", fangjianId=" + fangjianId +
", yonghuId=" + yonghuId +
", fangjianOrderTime=" + fangjianOrderTime +
", fangjianOrderText=" + fangjianOrderText +
", fangjianOrderTypes=" + fangjianOrderTypes +
", createTime=" + createTime +
"}";
}
}
"id=" + id +
", fangjianId=" + fangjianId +
", yonghuId=" + yonghuId +
", fangjianOrderTime=" + fangjianOrderTime +
", fangjianOrderText=" + fangjianOrderText +
", fangjianOrderTypes=" + fangjianOrderTypes +
", createTime=" + createTime +
"}";
}

140
minsu/minsuguanliw/src/main/java/com/entity/model/FangjianLiuyanModel.java
Unescape View File

@ -1,191 +1,209 @@
package com.entity.model;
// 导入房间评论/投诉对应的实体类，可能在后续代码中会基于这个实体类进行一些关联操作或者属性继承等（具体看业务需求）
import com.entity.FangjianLiuyanEntity;
// 导入MyBatis Plus的注解，用于指定该实体类对应的数据库表名，方便在数据持久化操作时进行表名的映射
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson框架的注解，用于在序列化和反序列化日期类型数据时，按照指定的格式进行处理，这里指定了中文环境（"zh"）、东八区时区（"GMT+8"）以及具体的日期时间格式（"yyyy-MM-dd HH:mm:ss"）
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java中的日期类，用于表示日期时间相关的属性，比如评论/投诉时间、回复时间、创建时间等
import java.util.Date;
// 导入Spring框架的日期格式化注解，用于在接收前端传入的日期参数或者向前端返回日期数据时，进行格式转换的配置（通常和 @JsonFormat 配合使用来处理日期相关的输入输出格式）
import org.springframework.format.annotation.DateTimeFormat;
// 导入Java的序列化接口，表明该类的对象可以被序列化和反序列化，方便在网络传输、持久化存储等场景中使用
import java.io.Serializable;
/**
* 房间评论/投诉
* 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* （实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView 的model名称
* 该类主要用于接收前端传递过来的与房间评论/投诉相关的参数，作为一种数据载体，方便在业务逻辑层和表现层之间传递数据，同时定义了对应属性的获取和设置方法
*/
public class FangjianLiuyanModel implements Serializable {
// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化时（如添加、删除字段等），可以通过修改这个版本号来避免反序列化出错
private static final long serialVersionUID = 1L;
/**
* 主键
* 用于唯一标识一条房间评论/投诉记录，在数据库中通常对应表的主键字段，通过这个ID可以对特定的评论/投诉记录进行查询、更新、删除等操作
*/
private Integer id;
/**
* 房间
* 用于关联对应的房间信息，存储的是房间的唯一标识（通常是房间ID），通过这个ID可以关联到具体的房间实体，获取房间的详细信息，比如房间号、房间类型等
*/
private Integer fangjianId;
/**
* 用户
* 用于关联发表评论/投诉的用户信息，存储的是用户的唯一标识（通常是用户ID），通过这个ID可以关联到具体的用户实体，获取用户的相关信息，比如用户名、用户联系方式等
*/
private Integer yonghuId;
/**
* 评论/投诉内容
* 用于存储用户针对房间发表的具体评论或投诉的文字内容，是体现用户反馈信息的核心字段
*/
private String fangjianLiuyanText;
/**
* 回复内容
* 用于存储针对用户的评论/投诉所做出的回复文字内容，当有相关工作人员对用户反馈进行回应时，回复内容会存储在此字段中
*/
private String replyText;
/**
* 评论/投诉时间
* 用于记录用户发表评论/投诉的具体时间点，通过 @JsonFormat 和 @DateTimeFormat 注解来指定其在序列化和反序列化过程中的日期时间格式，确保在与前端交互以及存储到数据库时格式的一致性
*/
@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 insertTime;
/**
* 回复时间
* 用于记录对用户的评论/投诉进行回复的具体时间点，同样通过相关注解来规范其日期时间格式处理，方便在不同场景下正确展示和使用该时间数据
*/
@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 updateTime;
/**
* 创建时间
* 用于记录该条房间评论/投诉记录在系统中创建的时间点，例如在插入数据库时自动获取当前时间作为创建时间，也通过注解保证日期时间格式的正确处理
*/
@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 createTime;
/**
* 获取：主键
*/
* 获取：主键
* 定义了获取主键（id）属性值的方法，外部代码可以通过调用这个方法获取该对象的主键值，符合JavaBean规范中对属性访问器（getter方法）的要求
*/
public Integer getId() {
return id;
}
/**
* 设置：主键
*/
* 设置：主键
* 定义了设置主键（id）属性值的方法，外部代码可以通过调用这个方法为该对象的主键属性赋值，符合JavaBean规范中对属性修改器（setter方法）的要求
*/
public void setId(Integer id) {
this.id = id;
}
/**
* 获取：房间
*/
* 获取：房间
* 定义了获取房间（fangjianId）属性值的方法，用于获取该对象关联的房间标识，方便在其他地方根据这个标识进一步获取房间详细信息等操作
*/
public Integer getFangjianId() {
return fangjianId;
}
/**
* 设置：房间
*/
* 设置：房间
* 定义了设置房间（fangjianId）属性值的方法，外部代码可以通过调用这个方法为该对象关联的房间标识赋值，比如在创建新的评论/投诉记录时设置对应的房间ID
*/
public void setFangjianId(Integer fangjianId) {
this.fangjianId = fangjianId;
}
/**
* 获取：用户
*/
* 获取：用户
* 定义了获取用户（yonghuId）属性值的方法，用于获取该对象关联的用户标识，便于后续根据此标识获取用户相关信息等操作
*/
public Integer getYonghuId() {
return yonghuId;
}
/**
* 设置：用户
*/
* 设置：用户
* 定义了设置用户（yonghuId）属性值的方法，外部代码可以通过调用这个方法为该对象关联的用户标识赋值，例如在保存评论/投诉记录时确定是哪个用户发表的反馈
*/
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
/**
* 获取：评论/投诉内容
*/
* 获取：评论/投诉内容
* 定义了获取评论/投诉内容（fangjianLiuyanText）属性值的方法，外部代码可以通过调用这个方法获取用户具体的评论或投诉文字信息，比如在展示评论详情时使用
*/
public String getFangjianLiuyanText() {
return fangjianLiuyanText;
}
/**
* 设置：评论/投诉内容
*/
* 设置：评论/投诉内容
* 定义了设置评论/投诉内容（fangjianLiuyanText）属性值的方法，外部代码可以通过调用这个方法为该对象设置用户发表的评论或投诉文字内容，例如在创建或更新评论/投诉记录时赋值
*/
public void setFangjianLiuyanText(String fangjianLiuyanText) {
this.fangjianLiuyanText = fangjianLiuyanText;
}
/**
* 获取：回复内容
*/
* 获取：回复内容
* 定义了获取回复内容（replyText）属性值的方法，外部代码可以通过调用这个方法获取针对评论/投诉所做出的回复文字信息，比如在展示评论及回复详情时使用
*/
public String getReplyText() {
return replyText;
}
/**
* 设置：回复内容
*/
* 设置：回复内容
* 定义了设置回复内容（replyText）属性值的方法，外部代码可以通过调用这个方法为该对象设置回复的文字内容，例如在工作人员回复用户评论/投诉后更新该字段的值
*/
public void setReplyText(String replyText) {
this.replyText = replyText;
}
/**
* 获取：评论/投诉时间
*/
* 获取：评论/投诉时间
* 定义了获取评论/投诉时间（insertTime）属性值的方法，外部代码可以通过调用这个方法获取用户发表评论/投诉的具体时间，比如在按照时间排序展示评论列表等场景中使用
*/
public Date getInsertTime() {
return insertTime;
}
/**
* 设置：评论/投诉时间
*/
* 设置：评论/投诉时间
* 定义了设置评论/投诉时间（insertTime）属性值的方法，外部代码可以通过调用这个方法为该对象设置用户发表评论/投诉的时间，例如在创建评论/投诉记录时根据当前时间进行赋值等操作
*/
public void setInsertTime(Date insertTime) {
this.insertTime = insertTime;
}
/**
* 获取：回复时间
*/
* 获取：回复时间
* 定义了获取回复时间（updateTime）属性值的方法，外部代码可以通过调用这个方法获取针对评论/投诉进行回复的具体时间，可用于展示回复的时效性等相关信息
*/
public Date getUpdateTime() {
return updateTime;
}
/**
* 设置：回复时间
*/
* 设置：回复时间
* 定义了设置回复时间（updateTime）属性值的方法，外部代码可以通过调用这个方法为该对象设置回复评论/投诉的时间，例如在工作人员回复后更新该字段的值
*/
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
/**
* 获取：创建时间
*/
* 获取：创建时间
* 定义了获取创建时间（createTime）属性值的方法，外部代码可以通过调用这个方法获取该条评论/投诉记录创建的具体时间，比如在记录数据创建历史等场景中使用
*/
public Date getCreateTime() {
return createTime;
}
/**
* 设置：创建时间
*/
* 设置：创建时间
* 定义了设置创建时间（createTime）属性值的方法，外部代码可以通过调用这个方法为该对象设置记录创建的时间，例如在插入数据库时自动获取当前时间赋值给该字段
*/
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}
}

212
minsu/minsuguanliw/src/main/java/com/entity/model/FangjianModel.java
Unescape View File

@ -1,287 +1,319 @@
package com.entity.model;
// 导入房间实体类，可能后续会基于该实体类与本模型类进行关联操作，比如获取房间的其他详细信息等（具体取决于业务逻辑）
import com.entity.FangjianEntity;
// 导入MyBatis Plus的注解，用于指定该实体类对应的数据库表名，方便在数据持久化操作时进行表名的映射，使得在与数据库交互时能准确地找到对应的表来执行增删改查等操作
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson框架的注解，用于在序列化（将对象转换为便于存储或传输的字节流等形式）和反序列化（将字节流等还原为对象）日期类型数据时，按照指定的格式进行处理，这里指定了符合中文习惯的环境（"zh"）、东八区时区（"GMT+8"）以及具体的日期时间格式（"yyyy-MM-dd HH:mm:ss"），确保日期数据在不同场景下格式统一且符合业务需求
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java中的日期类，用于表示创建时间这个日期时间相关的属性，方便记录和操作房间信息记录创建的具体时间点
import java.util.Date;
// 导入Spring框架的日期格式化注解，用于在接收前端传入的日期参数或者向前端返回日期数据时，进行格式转换的配置（通常和 @JsonFormat 配合使用来处理日期相关的输入输出格式，保证数据交互过程中日期格式的一致性）
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 导入Java的序列化接口，表明该类的对象可以被序列化和反序列化，这样在网络传输（例如在分布式系统中不同服务间传递数据）、持久化存储（如保存到文件或数据库）等场景下，该类的对象能够正常使用
import java.io.Serializable;
/**
* 房间信息
* 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* （实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView 的model名称
* 该类主要作为接收前端传递的与房间相关参数的载体，用于在不同的业务层之间传递房间信息数据，同时定义了各属性对应的获取和设置方法，符合JavaBean规范，方便在业务逻辑处理过程中对这些属性进行操作与访问。
*/
public class FangjianModel implements Serializable {
// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化时（如添加、删除字段等），可以通过修改这个版本号来避免反序列化出错，初始值设为1L，在类结构稳定的情况下通常不需要改动
private static final long serialVersionUID = 1L;
/**
* 主键
* 用于唯一标识一条房间信息记录，在数据库中通常对应表的主键字段，通过这个唯一的ID，数据库操作（如查询、更新、删除等）能够精准地定位到特定的房间记录，保证数据的准确性和操作的针对性。
*/
private Integer id;
/**
* 房间名称
* 用于存储房间的具体名称，方便用户直观地识别和区分不同的房间，例如“标准间”“豪华套房”等具有明确含义的名称，便于用户在预订、查看房间信息等操作时进行选择和辨别。
*/
private String fangjianName;
/**
* 房间图片
* 用于存储房间相关图片的路径或者图片的标识信息（具体取决于业务中图片存储和引用的方式），以便在前端展示房间外观、内部布置等直观的图片内容，帮助用户更形象地了解房间的实际情况，增强对房间的认知。
*/
private String fangjianPhoto;
/**
* 房间特色
* 用于描述房间具有的独特特点，比如“海景房”的海景特色、“主题房”的主题特色等，通过这些特色描述能让用户快速了解房间的与众不同之处，在吸引用户预订、展示房间亮点等方面起着重要作用。
*/
private String fangjianTese;
/**
* 房间配置
* 用于列举房间内配备的各种设施设备等信息，像“有电视、空调、独立卫生间”等，清晰地告知用户房间的硬件配置情况，方便用户根据自身需求判断房间是否满足使用要求。
*/
private String fangjianPeizhi;
/**
* 提供的商品
* 用于说明房间为住客额外提供的商品信息，例如“提供免费的矿泉水、洗漱用品”等，这些信息体现了房间服务包含的商品内容，让用户知晓入住后可享受到的额外物品提供情况。
*/
private String fangjianShangpin;
/**
* 提供的服务
* 用于介绍房间配套提供的服务项目，比如“包含早餐服务”“提供免费的客房清洁服务”等，明确告知用户能享受到的服务内容，是用户评估房间性价比和服务质量的重要依据之一。
*/
private String fangjianFuwu;
/**
* 价格（天）
* 用于存储房间每天的出租价格，方便用户了解住宿该房间的费用情况，是用户进行预订决策的关键参考因素之一，用户可以根据价格来衡量是否符合自己的预算以及对比不同房间的性价比。
*/
private Double fangjianMoney;
/**
* 房间类型
* 用于区分不同种类的房间，可能通过数字或其他编码方式对应不同的房型分类，例如1表示单人间，2表示双人间等，便于进行房间分类管理（如按类型统计数量、筛选特定类型房间等）和查询筛选操作，以满足不同用户的住宿需求。
*/
private Integer fangjianTypes;
/**
* 房间剩余数量
* 用于记录当前房间还可预订的剩余数量，实时反映房间的预订余量情况，在预订业务逻辑中可依据此数量来控制预订操作，避免出现超订（预订数量超过实际可提供数量）等异常情况，保证房间资源的合理分配。
*/
private Integer fangjianNumber;
/**
* 点击次数
* 用于统计房间信息被查看的次数，可用于分析房间的受欢迎程度等情况，比如热门房间往往点击次数较高，通过对点击次数的统计分析，能为运营决策（如调整房间推荐策略、优化房价等）提供有价值的数据支持。
*/
private Integer fangjianClicknum;
/**
* 房间详情
* 用于存储更详细的关于房间的描述信息，可能包含房间的布局、面积大小、装修风格等更全面的介绍内容，让用户能够更深入、细致地了解房间情况，辅助用户做出更准确的预订决策。
*/
private String fangjianContent;
/**
* 创建时间 show1 show2 photoShow
* 用于记录该条房间信息记录在系统中创建的时间点，通过 @JsonFormat 和 @DateTimeFormat 注解来指定其在序列化和反序列化过程中的日期时间格式，确保在与前端交互（如向前端展示创建时间或接收前端基于时间的筛选条件等）以及存储到数据库时格式的一致性，show1、show2、photoShow 可能是在某些特定展示场景下与之相关的标识（不过从这段代码看不太明确具体作用，可能是遗留的注释或者待完善的相关逻辑）。
*/
@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 createTime;
/**
* 获取：主键
*/
* 获取：主键
* 定义了获取主键（id）属性值的方法，符合JavaBean规范中对属性访问器（getter方法）的要求，外部代码可以通过调用这个方法获取该对象的主键值，方便在其他业务逻辑中（如关联查询、数据验证等）使用这个主键进行相关操作，确保数据操作的准确性和关联性。
*/
public Integer getId() {
return id;
}
/**
* 设置：主键
*/
* 设置：主键
* 定义了设置主键（id）属性值的方法，遵循JavaBean规范中对属性修改器（setter方法）的要求，外部代码可以通过调用这个方法为该对象的主键属性赋值，例如在创建新的房间信息记录时，根据数据库生成的主键值或自定义的主键规则来设置对应的主键值，确保每条记录有唯一标识。
*/
public void setId(Integer id) {
this.id = id;
}
/**
* 获取：房间名称
*/
* 获取：房间名称
* 定义了获取房间名称（fangjianName）属性值的方法，按照JavaBean规范的属性访问器规则定义，外部代码调用此方法可获取该对象对应的房间名称信息，便于在展示房间详细信息、进行搜索筛选（如按名称查找房间）等场景中使用该名称信息进行相应操作。
*/
public String getFangjianName() {
return fangjianName;
}
/**
* 设置：房间名称
*/
* 设置：房间名称
* 定义了设置房间名称（fangjianName）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间的名称，比如在更新房间信息（用户修改房间名称后保存）或者创建新房间时确定房间的具体称呼，保证房间名称的准确性和及时性。
*/
public void setFangjianName(String fangjianName) {
this.fangjianName = fangjianName;
}
/**
* 获取：房间图片
*/
* 获取：房间图片
* 定义了获取房间图片（fangjianPhoto）属性值的方法，符合JavaBean规范的属性访问器要求，外部代码调用此方法可获取该对象关联的房间图片相关信息，可用于在前端页面展示房间的图片内容，为用户提供直观的视觉展示，增强用户体验。
*/
public String getFangjianPhoto() {
return fangjianPhoto;
}
/**
* 设置：房间图片
*/
* 设置：房间图片
* 定义了设置房间图片（fangjianPhoto）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间图片的相关信息，例如在更新房间图片（用户上传新图片替换旧图片）或者初次添加房间信息时指定图片路径等，确保房间图片信息的准确性和有效性。
*/
public void setFangjianPhoto(String fangjianPhoto) {
this.fangjianPhoto = fangjianPhoto;
}
/**
* 获取：房间特色
*/
* 获取：房间特色
* 定义了获取房间特色（fangjianTese）属性值的方法，按照JavaBean规范的属性访问器规则定义，外部代码调用此方法可获取该对象描述的房间特色信息，有助于在展示房间亮点、吸引用户预订等方面发挥作用，让用户更清楚房间的独特之处，提高预订意愿。
*/
public String getFangjianTese() {
return fangjianTese;
}
/**
* 设置：房间特色
*/
* 设置：房间特色
* 定义了设置房间特色（fangjianTese）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间的特色描述内容，比如在完善房间信息（补充或修改特色介绍）或者根据业务需求调整特色描述时更新相应文本，保证特色信息的准确性和吸引力。
*/
public void setFangjianTese(String fangjianTese) {
this.fangjianTese = fangjianTese;
}
/**
* 获取：房间配置
*/
* 获取：房间配置
* 定义了获取房间配置（fangjianPeizhi）属性值的方法，符合JavaBean规范的属性访问器要求，外部代码调用此方法可获取该对象记录的房间内部配置信息，方便用户了解房间硬件设施情况，便于用户根据自身对设施的需求进行房间选择。
*/
public String getFangjianPeizhi() {
return fangjianPeizhi;
}
/**
* 设置：房间配置
*/
* 设置：房间配置
* 定义了设置房间配置（fangjianPeizhi）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间的配置描述内容，例如在更新房间设施配备情况（新增或移除某些设施）或者根据实际情况修改配置信息时更新相应文本，确保配置信息如实反映房间实际情况。
*/
public void setFangjianPeizhi(String fangjianPeizhi) {
this.fangjianPeizhi = fangjianPeizhi;
}
/**
* 获取：提供的商品
*/
* 获取：提供的商品
* 定义了获取提供的商品（fangjianShangpin）属性值的方法，按照JavaBean规范的属性访问器规则定义，外部代码调用此方法可获取该对象注明的房间提供商品信息，让用户知晓可享受的额外商品服务，这也是用户评估房间服务质量和性价比的一个方面。
*/
public String getFangjianShangpin() {
return fangjianShangpin;
}
/**
* 设置：提供的商品
*/
* 设置：提供的商品
* 定义了设置提供的商品（fangjianShangpin）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间提供的商品相关描述内容，比如在新增或修改提供的商品种类（如增加新的免费物品或更换洗漱用品品牌等）时更新相应文本，保证商品信息的准确性和及时性。
*/
public void setFangjianShangpin(String fangjianShangpin) {
this.fangjianShangpin = fangjianShangpin;
}
/**
* 获取：提供的服务
*/
* 获取：提供的服务
* 定义了获取提供的服务（fangjianFuwu）属性值的方法，符合JavaBean规范的属性访问器要求，外部代码调用此方法可获取该对象列出的房间提供服务信息，帮助用户了解能享受到的服务项目，是用户选择房间的重要参考依据之一。
*/
public String getFangjianFuwu() {
return fangjianFuwu;
}
/**
* 设置：提供的服务
*/
* 设置：提供的服务
* 定义了设置提供的服务（fangjianFuwu）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间提供的服务相关描述内容，例如在调整服务项目（新增或取消某项服务）或者根据业务需求修改服务介绍时更新相应文本，确保服务信息准确反映实际提供的服务情况。
*/
public void setFangjianFuwu(String fangjianFuwu) {
this.fangjianFuwu = fangjianFuwu;
}
/**
* 获取：价格（天）
*/
* 获取：价格（天）
* 定义了获取价格（fangjianMoney）属性值的方法，按照JavaBean规范的属性访问器规则定义，外部代码调用此方法可获取该对象对应的房间每天的出租价格信息，是展示房间费用情况以及进行费用相关计算（如计算预订多天的总价等）的重要依据，方便用户直观了解住宿成本。
*/
public Double getFangjianMoney() {
return fangjianMoney;
}
/**
* 设置：价格（天）
*/
* 设置：价格（天）
* 定义了设置价格（fangjianMoney）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间每天的出租价格，比如在调整房价（因季节、市场等因素变动价格）或者初次设定价格时更新相应数值，确保价格信息的准确性和时效性。
*/
public void setFangjianMoney(Double fangjianMoney) {
this.fangjianMoney = fangjianMoney;
}
/**
* 获取：房间类型
*/
* 获取：房间类型
* 定义了获取房间类型（fangjianTypes）属性值的方法，符合JavaBean规范的属性访问器要求，外部代码调用此方法可获取该对象表示的房间类型信息，便于进行房间分类查找（如查找所有单人间）、筛选预订（根据用户需求选择特定类型房间）等操作，方便用户根据自身住宿人数等需求选择合适房间。
*/
public Integer getFangjianTypes() {
return fangjianTypes;
}
/**
* 设置：房间类型
*/
* 设置：房间类型
* 定义了设置房间类型（fangjianTypes）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间的类型标识，例如在新增房间（确定新房间的类型分类）或者修改房间分类（如房间重新装修后房型改变）时更新相应数值，保证房间类型信息的准确性和一致性。
*/
public void setFangjianTypes(Integer fangjianTypes) {
this.fangjianTypes = fangjianTypes;
}
/**
* 获取：房间剩余数量
*/
* 获取：房间剩余数量
* 定义了获取房间剩余数量（fangjianNumber）属性值的方法，按照JavaBean规范的属性访问器规则定义，外部代码调用此方法可获取该对象记录的房间可预订剩余数量信息，用于判断房间是否还有余量可供预订等业务逻辑处理，避免出现预订冲突等问题。
*/
public Integer getFangjianNumber() {
return fangjianNumber;
}
/**
* 设置：房间剩余数量
*/
* 设置：房间剩余数量
* 定义了设置房间剩余数量（fangjianNumber）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间剩余可预订的数量，比如在有新预订、取消预订等操作后更新相应数值，确保剩余数量信息实时准确反映房间预订情况。
*/
public void setFangjianNumber(Integer fangjianNumber) {
this.fangjianNumber = fangjianNumber;
}
/**
* 获取：点击次数
*/
public Integer getFangjianClicknum() {
return fangjianClicknum;
}
/**
* 获取：点击次数
* 定义了获取点击次数（fangjianClicknum）属性值的方法，外部代码可以通过调用这个方法获取该对象统计的房间信息被查看的次数信息，可用于分析房间的关注度等情况。
*/
public Integer getFangjianClicknum() {
return fangjianClicknum;
}
/**
* 设置：点击次数
*/
* 设置：点击次数
* 定义了设置点击次数（fangjianClicknum）属性值的方法，外部代码可以通过调用这个方法为该对象设置房间信息被查看的次数，例如在每次有用户查看房间详情页面等操作后进行相应的计数更新。
*/
public void setFangjianClicknum(Integer fangjianClicknum) {
this.fangjianClicknum = fangjianClicknum;
}
/**
* 获取：房间详情
*/
* 获取：房间详情
* 定义了获取房间详情（fangjianContent）属性值的方法，外部代码可以通过调用这个方法获取该对象包含的更全面详细的房间描述信息，用于向用户展示房间的详细情况。
*/
public String getFangjianContent() {
return fangjianContent;
}
/**
* 设置：房间详情
*/
* 设置：房间详情
* 定义了设置房间详情（fangjianContent）属性值的方法，外部代码可以通过调用这个方法为该对象设置房间的详细描述内容，比如在完善房间介绍或者修改详情信息时更新相应文本。
*/
public void setFangjianContent(String fangjianContent) {
this.fangjianContent = fangjianContent;
}
/**
* 获取：创建时间 show1 show2 photoShow
*/
* 获取：创建时间 show1 show2 photoShow
* 定义了获取创建时间（createTime）属性值的方法，外部代码可以通过调用这个方法获取该对象记录的房间信息创建时间点信息，可用于记录数据历史、按时间排序等操作，show1、show2、photoShow 相关的含义不太明确（如前面所述，可能是特定展示相关的遗留注释或者待完善逻辑）。
*/
public Date getCreateTime() {
return createTime;
}
/**
* 设置：创建时间 show1 show2 photoShow
*/
* 设置：创建时间 show1 show2 photoShow
* 定义了设置创建时间（createTime）属性值的方法，外部代码可以通过调用这个方法为该对象设置房间信息的创建时间，例如在初次插入数据库记录时根据当前时间进行赋值等操作。
*/
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}
}

155
minsu/minsuguanliw/src/main/java/com/entity/model/FangjianOrderModel.java
Unescape View File

@ -1,169 +1,216 @@
package com.entity.model;
// 导入房间预约对应的实体类FangjianOrderEntity，可能后续会基于这个实体类进行一些拓展或者关联操作，例如在某些业务逻辑中需要获取实体类中的其他属性或方法等
// 比如可能基于FangjianOrderEntity中的一些通用属性进行复用，或者在复杂业务场景下调用其相关业务方法来完善房间预约功能相关逻辑。
import com.entity.FangjianOrderEntity;
// 导入MyBatis Plus的注解，用于指定该实体类对应的数据库表名，方便在进行数据库操作（如数据持久化、查询等）时，能准确地将实体类与数据库表进行映射
// 通过这个注解，MyBatis Plus框架就能知道该实体类对应数据库中的哪张表，确保数据操作的准确性，避免操作到错误的表。
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Jackson框架的注解，用于在序列化（将对象转换为字节流等形式以便存储或传输）和反序列化（将字节流等转换回对象）日期类型数据时，按照指定的格式（中文环境、东八区时区以及具体的日期时间格式）进行处理
// 这样在将该实体类对象传输（比如通过网络发送给其他服务或者前端）或者从存储中读取还原对象时，日期类型的属性能够以正确的格式呈现和解析，保证数据的一致性和正确性。
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java中的日期类，用于表示像预约日期、创建时间等与时间相关的属性，这些属性在业务中需要精确地记录具体的时间点
// 方便后续基于时间进行各种业务判断、统计以及展示等操作，例如判断预约是否过期、统计每天的预约量等。
import java.util.Date;
// 导入Spring框架的日期格式化注解，用于在接收前端传入的日期参数或者向前端返回日期数据时，进行格式转换的配置，常和 @JsonFormat 注解配合使用，确保日期数据在不同交互场景下格式统一
// 比如前端传入的日期格式可能不规范，通过这个注解可以将其转换为符合后端业务要求的格式，同时返回给前端时也能以统一的格式展示，提升数据交互的兼容性和准确性。
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
// 导入Java的序列化接口，表明该类的对象可以被序列化和反序列化，使得该类的实例能够在网络传输、持久化存储等场景中正常使用，比如在分布式系统中传递该对象或者将其保存到文件等情况
// 遵循这个接口规范，对象就能在不同的运行环境和存储场景下顺利转换和传递，保障系统间数据交互的可行性。
import java.io.Serializable;
/**
* 房间预约
* 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* （实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView 的model名称
* 这个类主要用于接收前端传递过来的与房间预约相关的参数，作为一种数据载体，在业务逻辑层与表现层之间传递数据，同时按照JavaBean规范定义了属性以及对应的获取和设置方法，方便在不同业务场景下对这些属性进行操作和访问。
*/
public class FangjianOrderModel implements Serializable {
// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性。当类的结构发生变化（比如添加、删除字段等情况）时，可以通过修改这个版本号来避免反序列化出现错误，初始值设为1L，在类结构稳定时通常不需要改动。
// 它就像是类的一个版本标识，在对象序列化存储后，如果类结构改变了，通过调整这个版本号来提示反序列化机制进行相应的兼容处理，确保数据能正确还原。
private static final long serialVersionUID = 1L;
/**
* 主键
* 用于唯一标识一条房间预约记录，在数据库层面，它通常对应着表中的主键字段，通过这个唯一的标识，可以方便地在数据库中对特定的房间预约记录进行查询、更新、删除等操作，保证数据的准确性和可管理性。
* 例如，当需要查找某一次特定的预约信息时，通过这个主键就能精准定位到对应的数据库记录，进行相应的数据操作，防止出现数据混淆或错误操作其他预约记录的情况。
*/
private Integer id;
/**
* 房间
* 用于存储房间的唯一标识（一般是房间ID），通过这个标识可以关联到具体的房间信息，比如房间的具体类型、配置、价格等详细信息，明确此次预约是针对哪个具体的房间进行的。
* 当展示预约详情给用户或者进行与房间相关的业务逻辑处理（如判断房间是否满足预约条件等）时，可以根据这个房间ID去获取更详细的房间属性信息，提供更全面的服务和展示。
*/
private Integer fangjianId;
/**
* 用户
* 用于存储进行房间预约操作的用户的唯一标识（通常是用户ID），借助这个标识能够关联到用户的详细信息，例如用户名、联系方式、会员等级等，以此确定是哪位用户发起的此次房间预约。
* 在后续的业务流程中，比如需要通知用户预约状态变更、根据会员等级给予不同优惠等操作时，就可以通过这个用户ID去获取对应的用户详细信息来进行相应处理。
*/
private Integer yonghuId;
/**
* 预约日期
* 用于记录用户预约房间的具体时间点，通过 @JsonFormat 和 @DateTimeFormat 这两个注解来规范其在序列化和反序列化过程中的日期时间格式，确保无论是在与前端交互（接收前端传入的预约时间或者返回给前端展示预约时间），还是存储到数据库时，日期时间的格式都保持一致且符合业务要求（格式为 "yyyy-MM-dd HH:mm:ss"，采用中文环境、东八区时区）。
* 这样能保证在整个系统中，预约日期这个重要信息的格式统一，避免因格式不一致导致的时间解析错误，同时也方便用户直观地看到和设置预约时间，符合日常使用习惯。
*/
@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 fangjianOrderTime;
/**
* 预约备注
* 用于存放用户在预约房间时额外添加的一些说明信息，比如用户可能有特殊的入住要求（如需要额外准备某些物品、指定房间的朝向等），或者对此次预约有其他特殊情况需要备注说明，方便相关服务人员查看并满足用户的个性化需求。
* 服务人员可以依据这些备注信息为用户提供更贴心、符合特殊要求的服务，提升用户体验，同时也让预约信息更加完整和详细。
*/
private String fangjianOrderText;
/**
* 订单状态
* 用于表示房间预约订单当前所处的状态，一般会通过不同的整数值来对应不同的业务状态，例如可能用1表示已预约但未支付、2表示已支付、3表示已入住、4表示已退房等，便于系统根据订单状态执行相应的业务逻辑，如针对已支付的订单进行后续的入住准备工作等，同时也方便在前端展示给用户直观的订单状态信息。
* 通过这种状态标识，系统能自动根据不同状态进行相应的流程处理，减少人工干预，提高业务处理效率，并且用户也能清晰了解自己预约的进展情况。
*/
private Integer fangjianOrderTypes;
/**
* 创建时间
* 用于记录这条房间预约记录在系统中创建的具体时间点，同样借助 @JsonFormat 和 @DateTimeFormat 注解来保证其在各种数据交互和存储场景下日期时间格式的准确性和一致性，该时间信息可以用于记录预约的创建历史、按照时间顺序查询预约记录等业务操作，也能让用户了解自己预约的发起时间。
* 例如可以统计每天的预约量、查看某个时间段内的预约趋势等，对业务分析和运营管理有一定帮助，同时也让用户清楚知道自己是什么时候进行的预约操作。
*/
@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 createTime;
/**
* 获取：主键
*/
* 获取：主键
* 定义了获取主键（id）属性值的方法，符合JavaBean规范中对属性访问器（getter方法）的要求，外部代码可以通过调用这个方法获取该对象的主键值，方便在其他业务逻辑中使用这个主键进行诸如查询关联数据、判断记录唯一性等操作。
* 其他业务类或者展示层代码等，若需要用到这个房间预约记录的主键（比如关联查询用户的其他预约记录等情况），就可以调用这个方法获取主键值来进行相应操作。
*/
public Integer getId() {
return id;
}
/**
* 设置：主键
*/
* 设置：主键
* 定义了设置主键（id）属性值的方法，遵循JavaBean规范中对属性修改器（setter方法）的规定，外部代码可以通过调用这个方法为该对象的主键属性赋值，例如在创建新的房间预约记录时设置对应的主键值，或者在某些特殊业务场景下修改主键值（不过主键通常很少修改）。
* 比如在向数据库插入一条新的预约记录时，要为其生成一个唯一的主键值并通过这个方法设置进去，确保数据的完整性和可标识性，特殊情况下（虽然少见）如需修改主键，也能通过这个方法进行操作。
*/
public void setId(Integer id) {
this.id = id;
}
/**
* 获取：房间
*/
* 获取：房间
* 定义了获取房间（fangjianId）属性值的方法，按照JavaBean的属性访问器规范定义，外部代码调用此方法可获取该对象关联的房间标识，后续可以基于这个标识去获取更详细的房间信息，比如在展示预约详情时展示对应的房间具体情况。
* 当要向用户展示预约的具体房间相关信息（如房间类型、配置等）时，先通过这个方法获取房间ID，再依据ID去查询并展示详细的房间属性内容，让用户清楚了解预约的是哪个房间。
*/
public Integer getFangjianId() {
return fangjianId;
}
/**
* 设置：房间
*/
* 设置：房间
* 定义了设置房间（fangjianId）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象关联的房间标识赋值，例如在创建预约记录时指定要预约的房间ID，或者在修改预约信息涉及更换房间时更新该字段的值。
* 比如用户最初预约了A房间，后来想更换为B房间，就可以通过调用这个方法将房间ID修改为B房间对应的ID值，实现房间更换的业务逻辑。
*/
public void setFangjianId(Integer fangjianId) {
this.fangjianId = fangjianId;
}
/**
* 获取：用户
*/
* 获取：用户
* 定义了获取用户（yonghuId）属性值的方法，符合JavaBean的属性访问器要求，外部代码调用此方法能够获取该对象关联的用户标识，进而可以依据该标识获取用户的相关详细信息，比如在展示预约详情时显示预约用户的相关信息。
* 在展示预约详情页面时，可以通过调用这个方法获取用户ID，再根据ID去获取并展示用户的姓名、联系方式等详细信息，让查看预约信息的人清楚知道是谁进行的预约。
*/
public Integer getYonghuId() {
return yonghuId;
}
/**
* 设置：用户
*/
* 设置：用户
* 定义了设置用户（yonghuId）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用该方法可以为该对象关联的用户标识赋值，例如在创建预约记录时确定发起预约的用户ID，或者在某些特殊业务场景下（如转让预约给其他用户等）修改该字段的值。
* 例如，用户A想把自己的预约转让给用户B，就可以通过调用这个方法将用户ID修改为用户B的ID，实现预约转让的相关业务逻辑操作。
*/
public void setYonghuId(Integer yonghuId) {
this.yonghuId = yonghuId;
}
/**
* 获取：预约日期
*/
* 获取：预约日期
* 定义了获取预约日期（fangjianOrderTime）属性值的方法，按照JavaBean的属性访问器规则定义，外部代码调用此方法可获取该对象记录的房间预约的具体时间信息，在业务逻辑中可用于判断预约是否有效、展示预约时间安排给用户等操作，以及在与前端交互时准确地传递预约时间数据。
* 比如在判断用户预约是否已经过期（与当前时间对比），或者在前端页面展示给用户明确的预约入住和退房时间等场景下，都需要调用这个方法获取预约日期信息来进行相应处理。
*/
public Date getFangjianOrderTime() {
return fangjianOrderTime;
}
/**
* 设置：预约日期
*/
* 设置：预约日期
* 定义了设置预约日期（fangjianOrderTime）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间预约的时间，比如用户在修改预约时间或者初次创建预约记录时确定具体的预约日期和时间点。
* 例如用户原本预约了明天的房间，后来想改到后天，就可以通过调用这个方法传入新的日期时间值来更新预约日期，实现时间修改的业务逻辑。
*/
public void setFangjianOrderTime(Date fangjianOrderTime) {
this.fangjianOrderTime = fangjianOrderTime;
}
/**
* 获取：预约备注
*/
* 获取：预约备注
* 定义了获取预约备注（fangjianOrderText）属性值的方法，符合JavaBean的属性访问器要求，外部代码调用此方法可获取该对象记录的用户预约房间时添加的备注信息，方便在业务逻辑中相关服务人员查看并处理用户的特殊需求，也能在展示预约详情时将备注信息展示给用户。
* 在客服人员查看预约信息准备为用户提供服务时，或者在前端页面展示预约详情给用户查看自己备注内容时，都可以通过调用这个方法获取备注信息来进行相应展示和处理。
*/
public String getFangjianOrderText() {
return fangjianOrderText;
}
/**
* 设置：预约备注
*/
* 设置：预约备注
* 定义了设置预约备注（fangjianOrderText）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用该方法可以为该对象设置用户预约房间时添加的备注内容，例如在用户补充或修改备注信息时更新该字段的值。
* 比如用户想起还有其他特殊要求，就可以通过前端页面调用这个方法传入新的备注内容，来更新预约备注信息，以便服务人员更好地满足其需求。
*/
public void setFangjianOrderText(String fangjianOrderText) {
this.fangjianOrderText = fangjianOrderText;
}
/**
* 获取：订单状态
*/
* 获取：订单状态
* 定义了获取订单状态（fangjianOrderTypes）属性值的方法，按照JavaBean的属性访问器规则定义，外部代码调用此方法可获取该对象表示的房间预约订单的当前状态信息，便于系统根据不同的状态执行相应的业务逻辑，比如针对已支付的订单进行入住准备工作等，同时也能在前端展示给用户对应的订单状态提示信息。
* 例如在后台业务逻辑中，当定时任务检查到有已支付的订单时，通过调用这个方法获取订单状态，然后执行相应的入住准备操作（如通知客房部打扫房间等），同时在前端用户界面也能展示出准确的订单状态（如显示“已支付”等字样）给用户查看。
*/
public Integer getFangjianOrderTypes() {
return fangjianOrderTypes;
}
/**
* 设置：订单状态
*/
* 设置：订单状态
* 定义了设置订单状态（fangjianOrderTypes）属性值的方法，遵循JavaBean的属性修改器规范，外部代码调用它可以为该对象设置房间预约订单的状态，例如在用户完成支付后将订单状态更新为已支付状态，或者在用户取消预约后将状态更新为已取消状态等，以此来准确反映订单在业务流程中的实际进展情况。
* 比如用户在前端页面点击“支付”按钮成功支付后，系统后台会调用这个方法将订单状态设置为已支付，以更新订单状态并触发后续相关业务流程，确保业务流程的准确性和连贯性。
*/
public void setFangjianOrderTypes(Integer fangjianOrderTypes) {
this.fangjianOrderTypes = fangjianOrderTypes;
}
/**
* 获取：创建时间
*/
* 获取：创建时间
* 定义了获取创建时间（createTime）属性值的方法，符合JavaBean的属性访问器要求，外部代码调用此方法可获取该对象记录的房间预约记录创建的具体时间信息，在业务逻辑中可用于记录预约创建的历史情况、按照时间顺序查询预约记录、统计不同时间段的预约量等操作，也能在展示预约详情时向用户展示预约创建的时间点。
* 例如运营人员可以通过获取创建时间来统计每天的预约量变化趋势，或者在用户查看预约详情时展示预约是什么时候创建的，让用户了解预约的发起时间等信息。
*/
public Date getCreateTime() {
return createTime;
}
/**
* 设置：创建时间
*/
// 设置：创建时间
// 定义了设置 `createTime` 属性值的方法，遵循JavaBean的属性修改器（setter）规范。
// 外部代码（例如在业务逻辑层进行数据处理，或者在与数据库交互的相关代码中）可以调用这个方法，为当前 `FangjianOrderModel` 对象的 `createTime` 属性赋予具体的日期时间值。
// 例如在初次向数据库插入一条新的房间预约记录时，通常会获取当前系统时间，并通过调用这个方法将获取到的时间值传递进来，以此准确记录该房间预约记录创建的时间点，保证数据的完整性以及后续基于时间相关的业务逻辑（如按照创建时间排序、统计不同时间段的预约数量等）能够正确执行。
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
}
}

714
minsu/minsuguanliw/src/main/java/com/entity/view/FangjianLiuyanView.java
Unescape View File

@ -1,378 +1,418 @@
package com.entity.view;
// 导入房间评论/投诉对应的实体类，可能后续会基于这个实体类进行一些属性的继承或者数据的关联操作等，以构建视图实体类所需的数据内容
// 例如可能继承实体类中的部分基础属性，或者通过关联操作获取实体类中与评论/投诉相关联的其他有用数据，丰富视图类展示的信息。
import com.entity.FangjianLiuyanEntity;
// 导入MyBatis Plus的注解，用于指定该实体类对应的数据库表名，方便在数据持久化操作等场景下进行表名的映射关联
// 这样在与数据库进行交互（如插入、查询、更新、删除数据等操作）时，框架能准确知道该视图类对应数据库中的哪张表，确保数据操作的准确性。
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类，用于方便地进行Java对象之间属性的复制操作，在构造函数中会使用它来复制相关实体类的属性到当前视图类中
// 避免手动逐个设置属性值的繁琐过程，提高代码的复用性和开发效率，使得基于已有实体对象构建视图对象时更加便捷。
import org.apache.commons.beanutils.BeanUtils;
// 导入异常处理相关的类，用于捕获在使用BeanUtils进行属性复制操作时可能抛出的异常，保证程序的稳定性，避免因异常导致程序崩溃
// 因为BeanUtils的copyProperties方法在一些情况下（如属性的访问权限问题、源对象或目标对象的方法调用出现错误等）可能会抛出异常，通过捕获这些异常可以进行相应的处理（如记录日志、提示错误信息等）。
import java.lang.reflect.InvocationTargetException;
// 导入Spring框架的日期格式化注解，用于在接收前端传入的日期参数或者向前端返回日期数据时，进行格式转换的配置（通常和其他日期处理注解配合使用）
// 确保前端传入的日期数据能被后端正确解析并转换为合适的格式进行处理，同时向前端返回的日期数据格式也符合前端展示的要求，增强数据交互的兼容性。
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson框架的注解，用于在序列化和反序列化日期类型数据时，按照指定的格式进行处理，保证日期数据在传输和存储过程中的格式一致性
// 例如在将对象转换为JSON格式传输（序列化）或者从JSON数据还原为对象（反序列化）时，日期属性能够按照设定的格式（如指定的时区、日期时间格式等）进行正确处理，避免出现日期格式错乱的问题。
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的序列化接口，表明该类的对象可以被序列化和反序列化，方便在网络传输、持久化存储等场景中使用该类的实例对象
// 比如在分布式系统中，需要将该视图类的对象通过网络发送给其他服务进行处理，或者将对象保存到文件、数据库等存储介质中时，序列化和反序列化机制就能正常工作。
import java.io.Serializable;
// 导入Java中的日期类，用于处理可能涉及到的日期相关属性（虽然在当前代码片段中未明确看到使用场景，但作为通用的日期处理类引入）
// 以备后续在业务逻辑扩展或者其他相关功能开发中，如果需要记录与房间评论/投诉相关的时间信息（如评论时间、投诉处理时间等）时可以直接使用该类来表示日期数据。
import java.util.Date;
/**
* 房间评论/投诉
* 后端返回视图实体辅助类
* （通常后端关联的表或者自定义的字段需要返回使用）
* 该类继承自FangjianLiuyanEntity类，主要用于构建一个适合后端返回给前端展示的视图实体类，包含了与房间评论/投诉相关的一些额外关联信息（如房间详情、用户信息等），通过提供相应的属性和访问器（getter）、修改器（setter）方法来方便数据的传递和展示。
* 它起到了一个数据整合和适配的作用，将后端不同来源的数据（来自实体类以及可能关联的其他表等）整合到一起，以一种更符合前端展示需求的形式呈现给用户界面。
*/
@TableName("fangjian_liuyan")
public class FangjianLiuyanView extends FangjianLiuyanEntity implements Serializable {
private static final long serialVersionUID = 1L;
//级联表 fangjian
/**
* 房间名称
*/
private String fangjianName;
/**
* 房间图片
*/
private String fangjianPhoto;
/**
* 房间特色
*/
private String fangjianTese;
/**
* 房间配置
*/
private String fangjianPeizhi;
/**
* 提供的商品
*/
private String fangjianShangpin;
/**
* 提供的服务
*/
private String fangjianFuwu;
/**
* 价格（天）
*/
private Double fangjianMoney;
/**
* 房间类型
*/
private Integer fangjianTypes;
/**
* 房间类型的值
*/
private String fangjianValue;
/**
* 房间剩余数量
*/
private Integer fangjianNumber;
/**
* 点击次数
*/
private Integer fangjianClicknum;
/**
* 房间详情
*/
private String fangjianContent;
//级联表 yonghu
/**
* 用户姓名
*/
private String yonghuName;
/**
* 头像
*/
private String yonghuPhoto;
/**
* 手机号
*/
private String yonghuPhone;
/**
* 电子邮箱
*/
private String yonghuEmail;
/**
* 余额
*/
private Double newMoney;
/**
* 假删
*/
private Integer yonghuDelete;
// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化时（如添加、删除字段等），可以通过修改这个版本号来避免反序列化出错，初始值设为1L，在类相对稳定的情况下一般不需要改动
// 它类似于一个标识，在对象进行序列化存储后，如果类的结构发生了改变（比如添加了新属性、修改了属性类型等），反序列化时会根据这个版本号来判断是否能够正确还原对象，若版本号不匹配可能会导致反序列化失败，通过手动修改它可以尝试进行兼容处理。
private static final long serialVersionUID = 1L;
// 以下是级联表 fangjian 相关的属性定义，用于存储房间的各种详细信息，方便在展示房间评论/投诉信息时，同时向前端提供对应的房间具体情况，增强信息的完整性和展示效果
// 房间名称
// 用于存储房间的具体名称，方便用户更直观地识别和区分不同的房间，例如“标准间”“豪华套房”等，在前端展示评论/投诉信息时可一并展示房间名称，让用户清楚是针对哪个房间的反馈
// 这样用户在查看评论或投诉内容时，能快速了解所涉及的具体房间，有助于更好地理解反馈的针对性和关联性。
private String fangjianName;
// 房间图片
// 用于存储房间相关图片的路径或者图片的标识信息（具体取决于业务中图片存储和引用的方式），以便在前端展示房间外观、内部布置等图片信息，结合评论/投诉内容能让用户更全面了解房间情况
// 例如，若评论提到房间的装修风格，同时展示房间的图片可以让用户更直观地感受装修的实际效果，增强对评论/投诉内容的理解。
private String fangjianPhoto;
// 房间特色
// 用于描述房间具有的独特特点，比如“海景房”的海景特色、“主题房”的主题特色等，在展示评论/投诉时展示房间特色有助于用户更好地理解反馈背景
// 比如用户投诉房间的海景视野不好，知道这是海景房这个特色后，就能更清楚问题所在以及影响的程度等情况。
private String fangjianTese;
// 房间配置
// 用于列举房间内配备的各种设施设备等信息，像“有电视、空调、独立卫生间”等，使前端能展示房间的硬件配置情况，辅助用户了解评论/投诉所涉及的房间设施相关内容
// 如果评论提到房间内某个设施出现故障等问题，通过展示房间配置信息，用户能明确知道是哪种设施出了状况，便于后续的处理和理解。
private String fangjianPeizhi;
// 提供的商品
// 用于说明房间为住客额外提供的商品信息，例如“提供免费的矿泉水、洗漱用品”等，在展示评论/投诉信息时告知用户房间原本提供的商品情况，便于更好地理解反馈内容
// 例如用户投诉没有提供应有的免费矿泉水，通过展示提供的商品信息就能直观判断是否确实存在该问题。
private String fangjianShangpin;
// 提供的服务
// 用于介绍房间配套提供的服务项目，比如“包含早餐服务”“提供免费的客房清洁服务”等，让前端能展示房间配套的服务内容，帮助用户从服务角度理解评论/投诉相关情况
// 比如用户投诉客房清洁服务不及时，知道房间有该项服务后，就能更准确地评估问题的合理性以及影响程度等。
private String fangjianFuwu;
// 价格（天）
// 用于存储房间每天的出租价格，方便用户了解住宿该房间的费用情况，在展示评论/投诉时展示价格信息可让用户从性价比等角度综合考虑相关反馈
// 例如用户评论房间价格过高，通过展示价格信息，其他用户可以结合房间配置、服务等情况来判断这个价格是否确实不合理，从更全面的角度看待评论内容。
private Double fangjianMoney;
// 房间类型
// 用于区分不同种类的房间，可能通过数字或其他编码方式对应不同的房型分类，例如1表示单人间，2表示双人间等，便于前端进行房间分类展示以及用户根据房型对评论/投诉进行分类查看和理解
// 不同房型的特点和用户期望可能不同，这样分类展示能让用户更方便地筛选和查看与自己关注的房型相关的评论/投诉内容，提高信息查找的效率。
private Integer fangjianTypes;
// 房间类型的值
// 可能用于存储房间类型对应的更具体的描述性值（比如房间类型代码对应的具体文字描述等），方便在前端更友好地展示房间类型相关信息，辅助用户理解评论/投诉涉及的房间类型情况
// 例如对于一些复杂的房型分类，仅用数字或代码表示不够直观，通过这个具体描述性值（如“豪华海景双人房”等）能让用户更清晰地知晓房型情况，更好地理解相关评论/投诉。
private String fangjianValue;
// 房间剩余数量
// 用于记录当前房间还可预订的剩余数量，实时反映房间的预订余量情况，在展示评论/投诉时展示剩余数量可让用户了解房间的热门程度等相关背景信息
// 如果一个房间剩余数量很少但评论较多，可能说明该房间比较热门，用户可以从这个角度进一步思考评论内容的参考价值等。
private Integer fangjianNumber;
// 点击次数
// 用于统计房间信息被查看的次数，可用于分析房间的受欢迎程度等，在展示评论/投诉时展示点击次数能让用户知晓房间的关注度情况，辅助理解反馈的重要性等
// 一般来说，点击次数高的房间关注度高，其评论/投诉可能更受关注，用户可以根据这个关注度情况来判断评论/投诉内容的影响力和参考价值。
private Integer fangjianClicknum;
// 房间详情
// 用于存储更详细的关于房间的描述信息，可能包含房间的布局、面积大小、装修风格等更全面的介绍内容，在前端展示评论/投诉时一并展示详细内容能让用户更深入了解房间情况及反馈背景
// 例如用户投诉房间空间小，通过查看房间详情里的面积大小等信息，能更准确地判断这个投诉是否合理，帮助用户更全面地理解评论/投诉的具体情况。
private String fangjianContent;
// 以下是级联表 yonghu 相关的属性定义，用于存储发表评论/投诉的用户的各种详细信息，方便在展示房间评论/投诉信息时，同时向前端提供对应的用户具体情况，增强信息的完整性和展示效果
// 用户姓名
// 用于存储发表评论/投诉的用户的姓名，方便在前端展示评论/投诉信息时明确反馈者身份，增强信息的可读性和关联性
// 知道是谁发表的评论/投诉，能让其他用户更直观地判断反馈的可信度以及可能的针对性等情况，使信息展示更人性化。
private String yonghuName;
// 头像
// 用于存储用户的头像相关信息（比如头像图片的路径或者标识等），以便在前端展示用户头像，使展示的评论/投诉信息更具个性化和直观性
// 展示头像可以让用户界面更生动，同时也有助于用户快速识别不同的反馈者，增强信息展示的辨识度。
private String yonghuPhoto;
// 手机号
// 用于存储用户的手机号码，可能在某些业务场景下（如需要联系用户核实评论/投诉内容等）会用到该信息，同时在前端展示也能增加用户信息的完整性
// 虽然一般不会直接在前端完全展示手机号，但在特定情况下（如管理员有相应权限查看并联系用户），手机号信息的存在能确保业务流程的连贯性，方便进行相关操作。
private String yonghuPhone;
// 电子邮箱
// 用于存储用户的电子邮箱地址，同样在一些业务相关操作（如发送反馈处理结果等）或者增强前端展示信息完整性方面有作用
// 比如后台处理完评论/投诉后，可以通过电子邮箱向用户发送处理结果通知，完善了整个业务的信息交互环节。
private String yonghuEmail;
// 余额
// 用于存储用户账户的余额信息，虽然在房间评论/投诉场景下可能关联性不是特别紧密，但作为用户的整体信息一部分，在一些综合业务展示场景下可能会涉及到
// 例如在展示用户的综合账户情况或者涉及到一些与消费、优惠等相关联且和余额有关的业务拓展场景下，余额信息可能会一同展示出来。
private Double newMoney;
// 假删
// 可能用于表示用户是否被标记为假删除状态（具体含义需结合业务逻辑确定），在前端展示用户相关信息时可体现该状态情况
// 比如在一些数据管理场景下，用户可能只是被标记为假删除（并非真正从系统中删除），在前端展示相关信息时显示这个状态可以让管理员等清楚用户数据的实际处理情况。
private Integer yonghuDelete;
// 默认构造函数，用于创建FangjianLiuyanView类的实例对象，在一些情况下（比如通过反射等方式创建对象时）可能会用到
// 当使用某些框架或机制需要创建该类的对象，但又没有明确的参数传入时，就会调用这个默认构造函数来创建一个默认初始化的对象实例。
public FangjianLiuyanView() {
}
// 构造函数，接收一个FangjianLiuyanEntity对象作为参数，用于将传入的实体类对象的属性值复制到当前视图类对象中，通过BeanUtils工具类来实现属性复制，方便基于已有的实体数据构建视图对象
// 这种方式可以复用已有的实体类数据，快速构建出符合前端展示需求的视图对象，避免重复设置各个属性值，提高了代码的复用性和开发效率。
public FangjianLiuyanView(FangjianLiuyanEntity fangjianLiuyanEntity) {
try {
// 使用BeanUtils的copyProperties方法，将fangjianLiuyanEntity对象的属性值复制到当前对象（this）中，实现属性的赋值操作，但该方法可能会抛出IllegalAccessException（访问权限异常）和InvocationTargetException（方法调用异常），所以需要进行异常捕获处理
// 因为在复制属性过程中，可能存在源对象的某些属性没有对应的访问权限（如私有属性且没有提供合适的访问方法等情况），或者在调用属性的 setter 方法时出现异常（比如 setter 方法内部逻辑错误等），都可能导致这两个异常被抛出。
BeanUtils.copyProperties(this, fangjianLiuyanEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 如果在属性复制过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，确定是哪里出现了访问权限问题或者方法调用出错等情况
// 通过查看堆栈信息，可以追溯到具体是哪个属性的复制出现了问题，有助于快速定位和修复代码中的错误。
e.printStackTrace();
}
}
// 以下是级联表 fangjian 相关属性的访问器（getter）和修改器（setter）方法定义，遵循JavaBean规范，方便外部代码获取和设置这些属性的值，用于数据的传递和操作
// 获取： 房间名称
// 定义了获取房间名称（fangjianName）属性值的方法，外部代码可以通过调用这个方法获取该对象对应的房间名称信息，便于在前端展示房间评论/投诉信息时展示对应的房间名称
// 例如在前端页面的评论/投诉详情展示模块中，通过调用这个方法获取房间名称并展示在相应位置，让用户清楚反馈对应的具体房间。
public String getFangjianName() {
return fangjianName;
}
// 设置： 房间名称
// 定义了设置房间名称（fangjianName）属性值的方法，外部代码可以通过调用这个方法为该对象设置房间的名称，例如在从数据库查询数据构建视图对象后，根据实际情况更新房间名称等场景下使用
// 比如数据库中房间名称有更新，通过调用这个方法可以将新的房间名称设置到视图对象中，确保前端展示的信息是最新的。
public void setFangjianName(String fangjianName) {
this.fangjianName = fangjianName;
}
// 获取： 房间图片
// 定义了获取房间图片（fangjianPhoto）属性值的方法，外部代码可以通过调用这个方法获取该对象关联的房间图片相关信息，用于在前端展示房间评论/投诉时展示相应的房间图片内容
// 在前端页面渲染评论/投诉信息时，可以调用这个方法获取图片信息并展示出来，让用户更直观地看到房间的样子，辅助理解评论/投诉内容。
public String getFangjianPhoto() {
return fangjianPhoto;
}
// 设置： 房间图片
// 定义了设置房间图片（fangjianPhoto）属性值的方法，外部代码可以通过调用这个方法为该对象设置房间图片的相关信息，比如在更新房间图片信息或者根据不同业务场景设置图片路径等情况时使用
// 例如房间重新上传了新的宣传图片，通过调用这个方法可以更新视图对象中的图片信息，使前端展示的图片是最新的。
public void setFangjianPhoto(String fangjianPhoto) {
this.fangjianPhoto = fangjianPhoto;
}
// 获取： 房间特色
// 这是按照JavaBean规范定义的访问器（getter）方法，用于获取房间特色（fangjianTese）属性的值。
// 外部代码（例如在构建前端页面展示房间评论/投诉相关信息的业务逻辑中，或者处理数据展示交互的代码等）可以调用这个方法，获取当前对象所代表房间具备的特色信息，然后将其展示给用户，帮助用户更好地理解该房间在评论/投诉中所涉及的相关背景情况，比如房间具有的独特卖点或者与众不同之处等内容。
public String getFangjianTese() {
return fangjianTese;
}
// 设置： 房间特色
// 定义了设置房间特色（fangjianTese）属性值的方法，遵循JavaBean规范中的属性修改器（setter）方法定义。
// 外部代码在需要对房间特色的描述内容进行更新时（比如酒店对房间进行了新的装修，增添了新的特色元素，需要完善房间信息；或者根据业务运营需求，对房间特色介绍文案进行调整修改等情况），可以调用这个方法，传入相应的字符串内容作为新的房间特色描述，以此来改变该属性的值，确保在前端展示给用户的房间特色信息是准确且符合实际情况的。
public void setFangjianTese(String fangjianTese) {
this.fangjianTese = fangjianTese;
}
// 获取： 房间配置
// 按照JavaBean的属性访问器规范定义的方法，用于获取房间配置（fangjianPeizhi）属性的值。
// 外部代码（像是在前端展示房间评论/投诉信息时，需要呈现房间内部配备的设施设备等具体情况的相关代码逻辑中）可以调用此方法，获取到当前对象记录的房间内的硬件配置信息，例如房间里有哪些电器、家具等设施配备情况，方便在前端页面展示给用户，辅助用户更清晰地理解评论/投诉中涉及到的关于房间设施方面的相关内容，比如用户投诉某个设施不好用，通过查看配置信息能更明确具体是哪项设施的问题。
public String getFangjianPeizhi() {
return fangjianPeizhi;
}
// 设置： 房间配置
// 这是遵循JavaBean规范定义的用于设置房间配置（fangjianPeizhi）属性值的方法，属于属性修改器（setter）方法。
// 外部代码在出现诸如房间设施配备发生变化（比如新添加了某种设施设备，或者原有的设施被更换等更新房间设施配备情况），或者根据实际的业务场景需要对已记录的配置信息文本进行修改（比如纠正之前配置信息录入的错误等）时，可以调用这个方法，传入新的描述房间配置的字符串内容，来更新该属性的值，保证前端展示的房间配置信息与实际情况相符。
public void setFangjianPeizhi(String fangjianPeizhi) {
this.fangjianPeizhi = fangjianPeizhi;
}
// 获取： 提供的商品
// 依据JavaBean规范定义的访问器（getter）方法，用于获取提供的商品（fangjianShangpin）属性的值。
// 外部代码（例如在前端展示房间评论/投诉详情页面，需要告知用户该房间原本为住客提供哪些商品的相关业务逻辑代码中）可以调用这个方法，获取当前对象注明的房间提供的商品信息，像房间是否提供免费的矿泉水、洗漱用品等内容，便于在前端展示给用户知晓，从而帮助用户更好地理解评论/投诉中涉及到的与房间提供商品相关的情况，比如用户投诉没收到应有的商品，通过查看提供的商品信息就能判断是否合理。
public String getFangjianShangpin() {
return fangjianShangpin;
}
// 设置： 提供的商品
// 定义了设置提供的商品（fangjianShangpin）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则。
// 外部代码在有新增商品种类、修改已提供商品的相关描述（比如商品品牌更换等情况）等业务场景下，需要更新房间提供商品的相关描述内容时，可以调用这个方法，传入对应的字符串内容，以此来更新该属性的值，确保前端展示的房间提供商品信息是最新且准确的。
public void setFangjianShangpin(String fangjianShangpin) {
this.fangjianShangpin = fangjianShangpin;
}
// 获取： 提供的服务
// 按照JavaBean规范定义的访问器（getter）方法，用于获取提供的服务（fangjianFuwu）属性的值。
// 外部代码（在前端展示房间评论/投诉信息时，为了让用户从服务角度更好地理解相关反馈情况，需要获取房间配套提供的服务项目信息的相关代码逻辑中）可以调用这个方法，获取当前对象列出的房间提供的服务信息，例如房间是否包含早餐服务、有没有免费的客房清洁服务等内容，方便在前端展示给用户，辅助用户从服务方面去理解评论/投诉所涉及的相关情况，比如用户投诉服务不到位，通过查看提供的服务信息能更清楚具体是哪项服务出现了问题。
public String getFangjianFuwu() {
return fangjianFuwu;
}
// 设置： 提供的服务
// 这是遵循JavaBean规范定义的用于设置提供的服务（fangjianFuwu）属性值的方法，属于属性修改器（setter）方法。
// 外部代码在业务运营过程中，当对房间配套的服务项目进行调整（比如新增了某项服务，或者取消了原有的某项服务等情况），或者根据业务需求修改服务介绍的相关文本（比如对服务内容描述进行优化等）时，可以调用这个方法，传入新的描述房间提供服务的字符串内容，来更新该属性的值，保证前端展示的房间提供服务信息与实际情况一致。
public void setFangjianFuwu(String fangjianFuwu) {
this.fangjianFuwu = fangjianFuwu;
}
// 获取： 价格（天）
// 按照JavaBean规范定义的访问器（getter）方法，用于获取价格（fangjianMoney）属性的值，该价格指的是房间每天的出租价格。
// 外部代码（比如在前端展示房间评论/投诉信息时，为了让用户从性价比等角度综合考虑相关反馈，需要获取房间价格信息的相关业务逻辑代码中）可以调用这个方法，获取当前对象对应的房间每天的出租价格信息，方便在前端展示给用户查看，使得用户能够结合价格情况以及房间的其他配置、服务等信息，来全面评估评论/投诉内容中关于价格方面的合理性等情况，比如用户评价价格过高，通过展示价格信息，其他用户可以对比判断是否确实如此。
public Double getFangjianMoney() {
return fangjianMoney;
}
// 设置： 价格（天）
// 定义了设置价格（fangjianMoney）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，用于设置房间每天的出租价格。
// 外部代码在诸如酒店进行价格调整（根据市场行情、淡旺季等因素改变房间价格），或者根据不同的业务场景（比如针对特定客户群体设置优惠价格等情况）设定价格时，可以调用这个方法，传入相应的价格数值，以此来更新该属性的值，确保前端展示的房间价格信息是准确且符合实际业务设定的。
public void setFangjianMoney(Double fangjianMoney) {
this.fangjianMoney = fangjianMoney;
}
// 获取： 房间类型
// 依据JavaBean规范定义的访问器（getter）方法，用于获取房间类型（fangjianTypes）属性的值，这里的房间类型通常是通过特定的标识（如数字、代码等方式）来区分不同种类的房间。
// 外部代码（在前端展示房间评论/投诉信息时，为了便于进行房间分类展示，以及方便用户根据房型对评论/投诉进行分类查看和理解的相关业务逻辑代码中）可以调用这个方法，获取当前对象表示的房间类型信息，例如用1表示单人间，2表示双人间等，便于前端根据不同的房型分类展示对应的评论/投诉内容，使用户能够更高效地查找和查看自己关注的房型相关的反馈信息。
public Integer getFangjianTypes() {
return fangjianTypes;
}
// 设置： 房间类型
// 这是遵循JavaBean规范定义的用于设置房间类型（fangjianTypes）属性值的方法，属于属性修改器（setter）方法，用于设置房间的类型标识。
// 外部代码在诸如酒店新增了一种房型，需要对其设定相应的类型标识，或者根据业务运营需要对已有的房间分类进行修改（比如重新调整房型分类标准等情况）时，可以调用这个方法，传入对应的房间类型标识数值，来更新该属性的值，保证前端展示的房间类型信息与实际的房型分类情况相符。
public void setFangjianTypes(Integer fangjianTypes) {
this.fangjianTypes = fangjianTypes;
}
// 获取： 房间类型的值
// 按照JavaBean规范定义的访问器（getter）方法，用于获取房间类型的值（fangjianValue）属性的值，该属性存储的是房间类型对应的更具体的描述性值（比如房间类型代码对应的具体文字描述等内容）。
// 外部代码（在前端展示房间评论/投诉信息时，为了更友好、直观地展示房间类型相关信息，辅助用户更好地理解评论/投诉涉及的房间类型情况的相关业务逻辑代码中）可以调用这个方法，获取当前对象存储的房间类型对应的具体描述性值，例如对于“2”这个房间类型标识，对应的具体描述性值可能是“豪华海景双人房”，这样能让用户更清晰地知晓房型情况，更准确地理解相关评论/投诉内容。
public String getFangjianValue() {
return fangjianValue;
}
//级联表的get和set fangjian
/**
* 获取： 房间名称
*/
public String getFangjianName() {
return fangjianName;
}
/**
* 设置： 房间名称
*/
public void setFangjianName(String fangjianName) {
this.fangjianName = fangjianName;
}
/**
* 获取： 房间图片
*/
public String getFangjianPhoto() {
return fangjianPhoto;
}
/**
* 设置： 房间图片
*/
public void setFangjianPhoto(String fangjianPhoto) {
this.fangjianPhoto = fangjianPhoto;
}
/**
* 获取： 房间特色
*/
public String getFangjianTese() {
return fangjianTese;
}
/**
* 设置： 房间特色
*/
public void setFangjianTese(String fangjianTese) {
this.fangjianTese = fangjianTese;
}
/**
* 获取： 房间配置
*/
public String getFangjianPeizhi() {
return fangjianPeizhi;
}
/**
* 设置： 房间配置
*/
public void setFangjianPeizhi(String fangjianPeizhi) {
this.fangjianPeizhi = fangjianPeizhi;
}
/**
* 获取： 提供的商品
*/
public String getFangjianShangpin() {
return fangjianShangpin;
}
/**
* 设置： 提供的商品
*/
public void setFangjianShangpin(String fangjianShangpin) {
this.fangjianShangpin = fangjianShangpin;
}
/**
* 获取： 提供的服务
*/
public String getFangjianFuwu() {
return fangjianFuwu;
}
/**
* 设置： 提供的服务
*/
public void setFangjianFuwu(String fangjianFuwu) {
this.fangjianFuwu = fangjianFuwu;
}
/**
* 获取： 价格（天）
*/
public Double getFangjianMoney() {
return fangjianMoney;
}
/**
* 设置： 价格（天）
*/
public void setFangjianMoney(Double fangjianMoney) {
this.fangjianMoney = fangjianMoney;
}
/**
* 获取： 房间类型
*/
public Integer getFangjianTypes() {
return fangjianTypes;
}
/**
* 设置： 房间类型
*/
public void setFangjianTypes(Integer fangjianTypes) {
this.fangjianTypes = fangjianTypes;
}
/**
* 获取： 房间类型的值
*/
public String getFangjianValue() {
return fangjianValue;
}
/**
* 设置： 房间类型的值
*/
public void setFangjianValue(String fangjianValue) {
this.fangjianValue = fangjianValue;
}
/**
* 获取： 房间剩余数量
*/
public Integer getFangjianNumber() {
return fangjianNumber;
}
/**
* 设置： 房间剩余数量
*/
public void setFangjianNumber(Integer fangjianNumber) {
this.fangjianNumber = fangjianNumber;
}
/**
* 获取： 点击次数
*/
public Integer getFangjianClicknum() {
return fangjianClicknum;
}
/**
* 设置： 点击次数
*/
public void setFangjianClicknum(Integer fangjianClicknum) {
this.fangjianClicknum = fangjianClicknum;
}
/**
* 获取： 房间详情
*/
public String getFangjianContent() {
return fangjianContent;
}
/**
* 设置： 房间详情
*/
public void setFangjianContent(String fangjianContent) {
this.fangjianContent = fangjianContent;
}
//级联表的get和set yonghu
/**
* 获取： 用户姓名
*/
public String getYonghuName() {
return yonghuName;
}
/**
* 设置： 用户姓名
*/
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
/**
* 获取： 头像
*/
public String getYonghuPhoto() {
return yonghuPhoto;
}
/**
* 设置： 头像
*/
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
/**
* 获取： 手机号
*/
public String getYonghuPhone() {
return yonghuPhone;
}
/**
* 设置： 手机号
*/
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
/**
* 获取： 电子邮箱
*/
public String getYonghuEmail() {
return yonghuEmail;
}
/**
* 设置： 电子邮箱
*/
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
/**
* 获取： 余额
*/
public Double getNewMoney() {
return newMoney;
}
/**
* 设置： 余额
*/
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
/**
* 获取： 假删
*/
public Integer getYonghuDelete() {
return yonghuDelete;
}
/**
* 设置： 假删
*/
public void setYonghuDelete(Integer yonghuDelete) {
this.yonghuDelete = yonghuDelete;
}
// 设置： 房间类型的值
// 定义了设置房间类型的值（fangjianValue）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，用于设置房间类型对应的具体描述性值。
// 外部代码在诸如更新房间类型对应的文字描述（比如对房型的命名进行优化、修改，使其更符合实际情况或者更通俗易懂等情况）时，可以调用这个方法，传入新的描述性字符串内容，以此来更新该属性的值，确保前端展示的房间类型具体描述信息是准确且易于用户理解的。
public void setFangjianValue(String fangjianValue) {
this.fangjianValue = fangjianValue;
}
// 获取： 房间剩余数量
// 依据JavaBean规范定义的访问器（getter）方法，用于获取房间剩余数量（fangjianNumber）属性的值，该属性记录的是当前房间还可预订的剩余数量。
// 外部代码（在前端展示房间评论/投诉信息时，为了展示房间的热门程度等相关背景信息，让用户了解房间的预订余量情况的相关业务逻辑代码中）可以调用这个方法，获取当前对象记录的房间可预订剩余数量信息，例如剩余数量少可能意味着房间比较热门，用户可以结合这个信息以及评论/投诉内容，从不同角度来综合考虑相关反馈的参考价值等情况。
public Integer getFangjianNumber() {
return fangjianNumber;
}
}
// 设置： 房间剩余数量
// 这是遵循JavaBean规范定义的用于设置房间剩余数量（fangjianNumber）属性值的方法，属于属性修改器（setter）方法，用于设置房间剩余可预订的数量。
// 外部代码在出现诸如有新预订、取消预订等操作后（这些操作会导致房间剩余可预订数量发生变化），需要更新相应数值，使前端展示的信息保持准确时，可以调用这个方法，传入新的剩余数量数值，来更新该属性的值，保证前端展示的房间剩余数量信息与实际可预订情况相符。
public void setFangjianNumber(Integer fangjianNumber) {
this.fangjianNumber = fangjianNumber;
}
// 获取： 点击次数
// 此方法是按照JavaBean规范定义的访问器（getter）方法，用于获取房间的点击次数属性（fangjianClicknum）的值，点击次数用于统计房间信息被查看的次数。
// 外部代码（比如展示房间相关信息的业务逻辑代码或者前端交互代码等，特别是在需要呈现房间受关注程度相关情况的场景下）可以调用这个方法，来获取当前对象所代表的房间被查看的次数信息，以便根据点击次数情况进行相应的展示（比如在前端页面展示房间的热门程度排序等）或业务处理（比如基于点击次数分析房间的受欢迎程度等）。
public Integer getFangjianClicknum() {
return fangjianClicknum;
}
// 设置： 点击次数
// 这是遵循JavaBean规范定义的修改器（setter）方法，用于设置房间的点击次数属性（fangjianClicknum）的值。
// 外部代码在需要更新房间的点击次数信息时（例如每次有用户查看房间详情页面后，按照业务逻辑通常会对点击次数进行累加更新等情况），可以调用这个方法，传入相应的整数值（一般是在原有的点击次数基础上进行增加等操作）来改变该属性的值，确保点击次数数据能准确反映房间被查看的实际情况。
public void setFangjianClicknum(Integer fangjianClicknum) {
this.fangjianClicknum = fangjianClicknum;
}
// 获取： 房间详情
// 按照JavaBean的属性访问器规范定义的方法，用于获取房间详情属性（fangjianContent）的值，该属性存储的是关于房间更全面、详细的描述信息。
// 外部代码（在展示房间相关的评论/投诉信息时，为了同时向用户呈现房间的详细情况，帮助用户更好地理解评论/投诉的背景的相关业务逻辑代码中）可以调用这个方法，获取到像房间布局、面积大小、装修风格等更全面的介绍内容，使得用户在查看评论/投诉时能结合房间详情信息，更深入地了解具体情况，比如用户投诉房间空间小，通过查看房间详情里的面积大小等信息，就能更准确地判断这个投诉是否合理。
public String getFangjianContent() {
return fangjianContent;
}
// 设置： 房间详情
// 遵循JavaBean规范的属性修改器方法，用于设置房间详情属性（fangjianContent）的值。
// 当需要更新房间的详细描述信息时（比如完善房间介绍、修改房间详情中的部分内容等业务场景，例如酒店重新装修后需要更新房间布局、风格等相关描述信息），外部代码可以调用这个方法，传入新的字符串内容来更新该属性的值，确保房间详情信息的准确性和及时性，使前端展示给用户的房间详情与实际情况一致。
public void setFangjianContent(String fangjianContent) {
this.fangjianContent = fangjianContent;
}
// 以下是级联表 yonghu 的相关get和set方法部分，用于对与用户相关的各个属性进行访问和修改操作，方便在处理房间评论/投诉相关业务时，获取和更新对应的用户信息。
// 获取： 用户姓名
// 按照JavaBean规范定义的访问器方法，用于获取用户姓名属性（yonghuName）的值，该属性存储的是发表评论/投诉的用户的姓名。
// 在展示房间评论/投诉信息时，通过调用这个方法可以获取发表该评论/投诉的用户的姓名，从而明确反馈者身份，增强信息展示的完整性和可读性，方便前端进行相应的展示处理，比如在前端页面评论/投诉详情区域展示用户姓名，让其他用户能清楚知道是谁发表的反馈内容，提高信息的可信度和关联性。
public String getYonghuName() {
return yonghuName;
}
// 设置： 用户姓名
// 遵循JavaBean规范的修改器方法，用于设置用户姓名属性（yonghuName）的值。
// 例如在从数据库查询到用户信息并构建当前视图对象后，若发现用户姓名需要更新（如用户修改了昵称等情况），外部代码可以调用这个方法传入新的姓名值来更新该属性，确保前端展示的用户姓名信息是最新且准确的，符合用户实际情况。
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
// 获取： 头像
// 这是用于获取用户头像属性（yonghuPhoto）值的访问器方法，符合JavaBean规范，该属性存储的是用户头像相关的信息（比如头像图片的路径或者标识等内容）。
// 外部代码调用它可以获取到用户头像相关的信息，便于在前端展示评论/投诉信息时同时展示用户头像，使展示效果更具个性化和直观性，比如在前端页面评论/投诉展示区域旁边展示用户头像图片，让用户界面更生动形象，也有助于用户快速识别不同的反馈者，增强信息展示的辨识度。
public String getYonghuPhoto() {
return yonghuPhoto;
}
// 设置： 头像
// 按照JavaBean的属性修改器规范定义的方法，用于设置用户头像属性（yonghuPhoto）的值。
// 当用户更新了头像信息（比如更换了头像图片）后，外部代码可以调用这个方法，传入新的头像相关信息（如更新后的图片路径等）来更新该属性的值，保证前端展示的头像信息是最新的，与用户实际的头像情况相符。
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
// 获取： 手机号
// 这是按照JavaBean规范定义的访问器（getter）方法，用于获取用户手机号属性（yonghuPhone）的值。
// 外部代码（比如在涉及到需要获取用户联系方式相关的业务逻辑中，像后台管理员在特定情况下需要联系用户核实评论/投诉内容，或者系统要向用户发送重要通知等场景下对应的代码部分）可以调用这个方法，获取到当前对象所关联用户的手机号码信息，以便进行后续相应的操作，不过出于隐私保护，通常不会随意将手机号展示给所有用户，只是在有对应权限和必要的业务场景下使用该信息。
public String getYonghuPhone() {
return yonghuPhone;
}
// 设置： 手机号
// 遵循JavaBean规范定义的用于设置用户手机号属性（yonghuPhone）值的修改器（setter）方法。
// 当用户的手机号码发生了变更（例如用户更换了新的手机号码，在前端进行相应手机号修改操作并提交到后端后），外部代码（如处理用户信息更新的业务逻辑代码）可以调用这个方法，传入新的手机号作为参数，来更新该属性的值，以此保证在系统中存储以及后续使用的用户手机号信息是准确无误的，与用户实际的联系方式保持一致。
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
// 获取： 电子邮箱
// 按照JavaBean规范定义的访问器方法，用于获取用户电子邮箱属性（yonghuEmail）的值。
// 外部代码（在业务流程中，像是后台业务逻辑里需要向用户发送反馈处理结果，或者要与用户进行一些关于评论/投诉相关的沟通、发送系统通知等通过邮件形式交互的业务场景对应的代码部分）调用该方法后，能够获取到当前对象所关联用户的电子邮箱地址，从而可以利用这个邮箱地址进行邮件的发送操作，同时也有助于完善前端展示的用户信息内容，尽管不一定直接展示邮箱地址给所有用户，但它作为用户信息的一部分能让整体信息更加完整。
public String getYonghuEmail() {
return yonghuEmail;
}
// 设置： 电子邮箱
// 遵循JavaBean规范的修改器方法，用于设置用户电子邮箱属性（yonghuEmail）的值。
// 当用户更新了自己的电子邮箱地址（比如用户在个人信息设置页面修改了邮箱，相关操作请求传递到后端）后，外部代码（例如负责处理用户信息修改保存的业务逻辑代码）可以调用这个方法，传入新的邮箱地址作为参数，来更新该属性的值，确保在后续的各种业务操作（如发送邮件等）中使用的邮箱信息是最新且准确的，符合用户实际的邮箱设置情况。
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
// 获取： 余额
// 这是用于获取用户余额属性（newMoney）值的访问器（getter）方法，符合JavaBean规范。
// 外部代码（在一些综合业务展示页面（比如展示用户的综合账户信息详情时），或者涉及到用户资金相关的扩展业务场景（如判断用户是否满足某些优惠活动条件、分析用户消费能力等情况对应的业务逻辑代码）中）调用它可以获取到用户账户的余额信息，虽然在房间评论/投诉的主要业务场景下，余额信息关联性可能不是特别紧密，但在更全面的业务范畴内，该信息可能会起到一定的作用，有助于对用户进行更全面的了解和相关业务分析。
public Double getNewMoney() {
return newMoney;
}
// 设置： 余额
// 按照JavaBean的属性修改器规范定义的方法，用于设置用户余额属性（newMoney）的值。
// 例如在用户进行了充值、消费等操作（比如用户通过线上支付渠道进行充值，或者在酒店内使用房间相关服务产生消费等情况发生后，对应的业务逻辑处理代码）导致余额发生变化后，外部代码可以调用这个方法，传入新的余额数值作为参数，来更新该属性的值，以此保证系统中记录的用户余额信息始终是准确的，能够真实反映用户账户的资金情况。
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
// 获取： 假删
// 此为获取用户假删属性（yonghuDelete）值的访问器（getter）方法，遵循JavaBean规范。
// 该属性可能用于表示用户是否被标记为假删除状态（具体含义需结合业务逻辑确定，比如可能是在数据管理过程中，为了保留用户数据但又暂时不让其在某些常规展示场景下出现等情况而设置的一种特殊状态标识），外部代码（比如在前端展示用户相关信息时，需要根据用户状态进行不同展示效果处理的业务逻辑代码）调用这个方法可以获取到这个状态信息，以便在前端展示用户相关信息时体现该状态情况，让管理员或者相关人员清楚了解用户数据的实际处理状态。
public Integer getYonghuDelete() {
return yonghuDelete;
}
// 设置： 假删
// 遵循JavaBean规范定义的用于设置用户假删属性（yonghuDelete）值的修改器（setter）方法。
// 当用户的假删状态发生变化（比如从正常状态变为假删除状态，可能是因为某些业务规则触发，如用户长时间未活跃等情况需要将其标记为假删除；或者反之，从假删除状态恢复为正常状态，例如用户重新激活账号等情况）时，外部代码（如负责处理用户状态变更的业务逻辑代码）可以调用这个方法，传入相应的整数值（通常是代表不同状态的特定数值，如0表示正常，1表示假删除等，具体看业务定义）来更新该属性的值，确保用户的假删状态在系统中能准确记录和体现。
public void setYonghuDelete(Integer yonghuDelete) {
this.yonghuDelete = yonghuDelete;
}
}

786
minsu/minsuguanliw/src/main/java/com/entity/view/FangjianOrderView.java
Unescape View File

@ -1,394 +1,460 @@
package com.entity.view;
// 导入房间预约对应的实体类，后续可能基于该实体类进行属性继承、数据关联等操作，以构建适合后端返回给前端展示的视图实体类所需的数据内容
import com.entity.FangjianOrderEntity;
// 导入MyBatis Plus的注解，用于指定该实体类对应的数据库表名，方便在与数据库进行数据持久化操作（如查询、插入、更新、删除等）时进行表名的映射关联
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类，用于方便地进行Java对象之间属性的复制操作，在构造函数中会使用它来将相关实体类的属性复制到当前视图类中
import org.apache.commons.beanutils.BeanUtils;
// 导入异常处理相关的类，用于捕获在使用BeanUtils进行属性复制操作时可能抛出的异常，保证程序的稳定性，避免因异常导致程序崩溃
import java.lang.reflect.InvocationTargetException;
// 导入Spring框架的日期格式化注解，用于在接收前端传入的日期参数或者向前端返回日期数据时，进行格式转换的配置（通常和其他日期处理注解配合使用）
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson框架的注解，用于在序列化和反序列化日期类型数据时，按照指定的格式进行处理，保证日期数据在传输和存储过程中的格式一致性
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的序列化接口，表明该类的对象可以被序列化和反序列化，方便在网络传输、持久化存储等场景中使用该类的实例对象
import java.io.Serializable;
// 导入Java中的日期类，用于处理可能涉及到的日期相关属性（虽然在当前代码片段中未明确看到使用场景，但作为通用的日期处理类引入）
import java.util.Date;
/**
* 房间预约
* 后端返回视图实体辅助类
* （通常后端关联的表或者自定义的字段需要返回使用）
* 该类继承自FangjianOrderEntity类，主要用于构建一个适合后端返回给前端展示的视图实体类，包含了与房间预约相关的一些额外关联信息（如房间详情、用户信息等），通过提供相应的属性和访问器（getter）、修改器（setter）方法来方便数据的传递和展示。
*/
@TableName("fangjian_order")
public class FangjianOrderView extends FangjianOrderEntity implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 订单状态的值
*/
private String fangjianOrderValue;
//级联表 fangjian
/**
* 房间名称
*/
private String fangjianName;
/**
* 房间图片
*/
private String fangjianPhoto;
/**
* 房间特色
*/
private String fangjianTese;
/**
* 房间配置
*/
private String fangjianPeizhi;
/**
* 提供的商品
*/
private String fangjianShangpin;
/**
* 提供的服务
*/
private String fangjianFuwu;
/**
* 价格（天）
*/
private Double fangjianMoney;
/**
* 房间类型
*/
private Integer fangjianTypes;
/**
* 房间类型的值
*/
private String fangjianValue;
/**
* 房间剩余数量
*/
private Integer fangjianNumber;
/**
* 点击次数
*/
private Integer fangjianClicknum;
/**
* 房间详情
*/
private String fangjianContent;
//级联表 yonghu
/**
* 用户姓名
*/
private String yonghuName;
/**
* 头像
*/
private String yonghuPhoto;
/**
* 手机号
*/
private String yonghuPhone;
/**
* 电子邮箱
*/
private String yonghuEmail;
/**
* 余额
*/
private Double newMoney;
/**
* 假删
*/
private Integer yonghuDelete;
// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化时（如添加、删除字段等），可以通过修改这个版本号来避免反序列化出错，初始值设为1L，在类相对稳定的情况下一般不需要改动
private static final long serialVersionUID = 1L;
/**
* 订单状态的值
* 用于存储房间预约订单状态对应的具体描述性值（比如订单状态代码对应的具体文字描述等），方便在前端更友好地展示订单状态相关信息，辅助用户理解房间预约相关情况涉及的订单状态情况。
*/
private String fangjianOrderValue;
// 级联表 fangjian相关属性定义，用于存储房间的各种详细信息，方便在展示房间预约信息时，同时向前端提供对应的房间具体情况，增强信息的完整性和展示效果
/**
* 房间名称
* 用于存储房间的具体名称，方便用户更直观地识别和区分不同的房间，例如“标准间”“豪华套房”等，在前端展示房间预约信息时可一并展示房间名称，让用户清楚是针对哪个房间的预约。
*/
private String fangjianName;
/**
* 房间图片
* 用于存储房间相关图片的路径或者图片的标识信息（具体取决于业务中图片存储和引用的方式），以便在前端展示房间外观、内部布置等图片信息，结合房间预约信息能让用户更全面了解房间情况。
*/
private String fangjianPhoto;
/**
* 房间特色
* 用于描述房间具有的独特特点，比如“海景房”的海景特色、“主题房”的主题特色等，在展示房间预约信息时展示房间特色有助于用户更好地理解预约背景。
*/
private String fangjianTese;
/**
* 房间配置
* 用于列举房间内配备的各种设施设备等信息，像“有电视、空调、独立卫生间”等，使前端能展示房间的硬件配置情况，辅助用户了解房间预约所涉及的房间设施相关内容。
*/
private String fangjianPeizhi;
/**
* 提供的商品
* 用于说明房间为住客额外提供的商品信息，例如“提供免费的矿泉水、洗漱用品”等，在展示房间预约信息时告知用户房间原本提供的商品情况，便于更好地理解预约相关内容。
*/
private String fangjianShangpin;
/**
* 提供的服务
* 用于介绍房间配套提供的服务项目，比如“包含早餐服务”“提供免费的客房清洁服务”等，让前端能展示房间配套的服务内容，帮助用户从服务角度理解房间预约相关情况。
*/
private String fangjianFuwu;
/**
* 价格（天）
* 用于存储房间每天的出租价格，方便用户了解住宿该房间的费用情况，在展示房间预约信息时展示价格信息可让用户从性价比等角度综合考虑相关预约情况。
*/
private Double fangjianMoney;
/**
* 房间类型
* 用于区分不同种类的房间，可能通过数字或其他编码方式对应不同的房型分类，例如1表示单人间，2表示双人间等，便于前端进行房间分类展示以及用户根据房型对预约进行分类查看和理解。
*/
private Integer fangjianTypes;
/**
* 房间类型的值
* 可能用于存储房间类型对应的更具体的描述性值（比如房间类型代码对应的具体文字描述等），方便在前端更友好地展示房间类型相关信息，辅助用户理解房间预约涉及的房间类型情况。
*/
private String fangjianValue;
/**
* 房间剩余数量
* 用于记录当前房间还可预订的剩余数量，实时反映房间的预订余量情况，在展示房间预约信息时展示剩余数量可让用户了解房间的热门程度等相关背景信息。
*/
private Integer fangjianNumber;
/**
* 点击次数
* 用于统计房间信息被查看的次数，可用于分析房间的受欢迎程度等，在展示房间预约信息时展示点击次数能让用户知晓房间的关注度情况，辅助理解预约的重要性等。
*/
private Integer fangjianClicknum;
/**
* 房间详情
* 用于存储更详细的关于房间的描述信息，可能包含房间的布局、面积大小、装修风格等更全面的介绍内容，在前端展示房间预约信息时一并展示详细内容能让用户更深入了解房间情况及预约背景。
*/
private String fangjianContent;
// 级联表 yonghu相关属性定义，用于存储进行房间预约的用户的各种详细信息，方便在展示房间预约信息时，同时向前端提供对应的用户具体情况，增强信息的完整性和展示效果
/**
* 用户姓名
* 用于存储进行房间预约的用户的姓名，方便在前端展示房间预约信息时明确预约者身份，增强信息的可读性和关联性。
*/
private String yonghuName;
/**
* 头像
* 用于存储用户的头像相关信息（比如头像图片的路径或者标识等），以便在前端展示用户头像，使展示的房间预约信息更具个性化和直观性。
*/
private String yonghuPhoto;
/**
* 手机号
* 用于存储用户的手机号码，可能在某些业务场景下（如需要联系用户确认预约信息、进行预约相关通知等）会用到该信息，同时在前端展示也能增加用户信息的完整性。
*/
private String yonghuPhone;
/**
* 电子邮箱
* 用于存储用户的电子邮箱地址，同样在一些业务相关操作（如发送预约确认、提醒等邮件，或者处理预约变更等情况与用户沟通）或者增强前端展示信息完整性方面有作用。
*/
private String yonghuEmail;
/**
* 余额
* 用于存储用户账户的余额信息，虽然在房间预约的主要业务场景下，余额信息关联性可能不是特别紧密，但作为用户的整体信息一部分，在一些综合业务展示场景下可能会涉及到。
*/
private Double newMoney;
/**
* 假删
* 可能用于表示用户是否被标记为假删除状态（具体含义需结合业务逻辑确定），在前端展示用户相关信息时可体现该状态情况。
*/
private Integer yonghuDelete;
// 默认构造函数，用于创建FangjianOrderView类的实例对象，在一些情况下（比如通过反射等方式创建对象时）可能会用到
public FangjianOrderView() {
}
// 构造函数，接收一个FangjianOrderEntity对象作为参数，用于将传入的实体类对象的属性值复制到当前视图类对象中，通过BeanUtils工具类来实现属性复制，方便基于已有的实体数据构建视图对象
public FangjianOrderView(FangjianOrderEntity fangjianOrderEntity) {
try {
// 使用BeanUtils的copyProperties方法，将fangjianOrderEntity对象的属性值复制到当前对象（this）中，实现属性的赋值操作，但该方法可能会抛出IllegalAccessException（访问权限异常）和InvocationTargetException（方法调用异常），所以需要进行异常捕获处理
BeanUtils.copyProperties(this, fangjianOrderEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 如果在属性复制过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，确定是哪里出现了访问权限问题或者方法调用出错等情况
e.printStackTrace();
}
}
/**
* 获取： 订单状态的值
* 这是按照JavaBean规范定义的访问器（getter）方法，用于获取订单状态的值（fangjianOrderValue）属性的值。
* 外部代码（比如展示房间预约相关信息的业务逻辑代码或者前端交互代码等）可以调用这个方法，获取当前对象所代表的房间预约订单状态对应的具体描述性值，以便进行相应的展示或业务处理，帮助用户更好地理解预约的具体状态情况。
*/
public String getFangjianOrderValue() {
return fangjianOrderValue;
}
/**
* 设置： 订单状态的值
* 定义了设置订单状态的值（fangjianOrderValue）属性值的方法，遵循JavaBean规范中的属性修改器（setter）方法定义。
* 外部代码在需要更新订单状态的具体描述信息时（比如订单状态发生变化，需要将对应的文字描述更新为新的合适内容等情况），可以调用这个方法，传入相应的字符串内容作为新的订单状态描述，以此来改变该属性的值，确保在前端展示的订单状态信息是准确且符合实际情况的。
*/
public void setFangjianOrderValue(String fangjianOrderValue) {
this.fangjianOrderValue = fangjianOrderValue;
}
// 级联表的get和set fangjian
/**
* 获取： 房间名称
* 这是按照JavaBean规范定义的访问器（getter）方法，用于获取房间名称（fangjianName）属性的值。
* 外部代码（例如在构建前端页面展示房间预约相关信息的业务逻辑中，或者处理数据展示交互的代码等）可以调用这个方法，获取当前对象所代表房间的名称信息，然后将其展示给用户，帮助用户更好地识别预约的是哪个具体房间，辅助理解房间预约相关情况。
*/
public String getFangjianName() {
return fangjianName;
}
/**
* 设置： 房间名称
* 定义了设置房间名称（fangjianName）属性值的方法，遵循JavaBean规范中的属性修改器（setter）方法定义。
* 外部代码在需要对房间名称进行更新时（比如酒店对房间重新命名，或者发现之前名称录入有误需要修改等情况），可以调用这个方法，传入相应的字符串内容作为新的房间名称，以此来改变该属性的值，确保在前端展示给用户的房间名称信息是准确且符合实际情况的。
*/
public void setFangjianName(String fangjianName) {
this.fangjianName = fangjianName;
}
/**
* 获取： 房间图片
* 按照JavaBean规范定义的访问器（getter）方法，用于获取房间图片（fangjianPhoto）属性的值。
* 外部代码（像是在前端展示房间预约信息时，需要呈现房间外观、内部布置等图片信息的相关代码逻辑中）可以调用此方法，获取到当前对象记录的房间图片相关信息，例如图片的路径等，方便在前端页面展示给用户查看，使他们能更直观地了解房间的实际样子，辅助理解房间预约相关情况。
*/
public String getFangjianPhoto() {
return fangjianPhoto;
}
/**
* 获取： 订单状态的值
*/
public String getFangjianOrderValue() {
return fangjianOrderValue;
}
/**
* 设置： 订单状态的值
*/
public void setFangjianOrderValue(String fangjianOrderValue) {
this.fangjianOrderValue = fangjianOrderValue;
}
//级联表的get和set fangjian
/**
* 获取： 房间名称
*/
public String getFangjianName() {
return fangjianName;
}
/**
* 设置： 房间名称
*/
public void setFangjianName(String fangjianName) {
this.fangjianName = fangjianName;
}
/**
* 获取： 房间图片
*/
public String getFangjianPhoto() {
return fangjianPhoto;
}
/**
* 设置： 房间图片
*/
public void setFangjianPhoto(String fangjianPhoto) {
this.fangjianPhoto = fangjianPhoto;
}
/**
* 获取： 房间特色
*/
public String getFangjianTese() {
return fangjianTese;
}
/**
* 设置： 房间特色
*/
public void setFangjianTese(String fangjianTese) {
this.fangjianTese = fangjianTese;
}
/**
* 获取： 房间配置
*/
public String getFangjianPeizhi() {
return fangjianPeizhi;
}
/**
* 设置： 房间配置
*/
public void setFangjianPeizhi(String fangjianPeizhi) {
this.fangjianPeizhi = fangjianPeizhi;
}
/**
* 获取： 提供的商品
*/
public String getFangjianShangpin() {
return fangjianShangpin;
}
/**
* 设置： 提供的商品
*/
public void setFangjianShangpin(String fangjianShangpin) {
this.fangjianShangpin = fangjianShangpin;
}
/**
* 获取： 提供的服务
*/
public String getFangjianFuwu() {
return fangjianFuwu;
}
/**
* 设置： 提供的服务
*/
public void setFangjianFuwu(String fangjianFuwu) {
this.fangjianFuwu = fangjianFuwu;
}
/**
* 获取： 价格（天）
*/
public Double getFangjianMoney() {
return fangjianMoney;
}
/**
* 设置： 价格（天）
*/
public void setFangjianMoney(Double fangjianMoney) {
this.fangjianMoney = fangjianMoney;
}
/**
* 获取： 房间类型
*/
public Integer getFangjianTypes() {
return fangjianTypes;
}
/**
* 设置： 房间类型
*/
public void setFangjianTypes(Integer fangjianTypes) {
this.fangjianTypes = fangjianTypes;
}
/**
* 获取： 房间类型的值
*/
public String getFangjianValue() {
return fangjianValue;
}
/**
* 设置： 房间类型的值
*/
public void setFangjianValue(String fangjianValue) {
this.fangjianValue = fangjianValue;
}
/**
* 获取： 房间剩余数量
*/
public Integer getFangjianNumber() {
return fangjianNumber;
}
/**
* 设置： 房间剩余数量
*/
public void setFangjianNumber(Integer fangjianNumber) {
this.fangjianNumber = fangjianNumber;
}
/**
* 获取： 点击次数
*/
public Integer getFangjianClicknum() {
return fangjianClicknum;
}
/**
* 设置： 点击次数
*/
public void setFangjianClicknum(Integer fangjianClicknum) {
this.fangjianClicknum = fangjianClicknum;
}
/**
* 获取： 房间详情
*/
public String getFangjianContent() {
return fangjianContent;
}
/**
* 设置： 房间详情
*/
public void setFangjianContent(String fangjianContent) {
this.fangjianContent = fangjianContent;
}
//级联表的get和set yonghu
/**
* 获取： 用户姓名
*/
public String getYonghuName() {
return yonghuName;
}
/**
* 设置： 用户姓名
*/
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
/**
* 获取： 头像
*/
public String getYonghuPhoto() {
return yonghuPhoto;
}
/**
* 设置： 头像
*/
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
/**
* 获取： 手机号
*/
public String getYonghuPhone() {
return yonghuPhone;
}
/**
* 设置： 手机号
*/
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
/**
* 获取： 电子邮箱
*/
public String getYonghuEmail() {
return yonghuEmail;
}
/**
* 设置： 电子邮箱
*/
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
/**
* 获取： 余额
*/
public Double getNewMoney() {
return newMoney;
}
/**
* 设置： 余额
*/
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
/**
* 获取： 假删
*/
public Integer getYonghuDelete() {
return yonghuDelete;
}
/**
* 设置： 假删
*/
public void setYonghuDelete(Integer yonghuDelete) {
this.yonghuDelete = yonghuDelete;
}
/**
* 设置： 房间图片
* 这是遵循JavaBean规范定义的用于设置房间图片（fangjianPhoto）属性值的方法，属于属性修改器（setter）方法。
* 外部代码在出现诸如房间图片更新（比如更换了新的宣传图片，或者图片存储路径发生变化等情况），需要更新房间图片相关信息时，可以调用这个方法，传入新的图片相关信息（如更新后的图片路径等），来更新该属性的值，保证前端展示的房间图片信息与实际情况相符。
*/
public void setFangjianPhoto(String fangjianPhoto) {
this.fangjianPhoto = fangjianPhoto;
}
/**
* 获取： 房间特色
* 依据JavaBean规范定义的访问器（getter）方法，用于获取房间特色（fangjianTese）属性的值。
* 外部代码（例如在前端展示房间预约详情页面，需要告知用户该房间具备哪些特色的相关业务逻辑代码中）可以调用这个方法，获取当前对象注明的房间特色信息，像房间是否有独特的景观、主题风格等内容，便于在前端展示给用户知晓，从而帮助用户更好地理解房间预约中涉及到的与房间特色相关的情况，比如为什么选择这个有特定特色的房间进行预约等。
*/
public String getFangjianTese() {
return fangjianTese;
}
/**
* 设置： 房间特色
* 定义了设置房间特色（fangjianTese）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则。
* 外部代码在有新增房间特色、修改已有的房间特色描述（比如对特色的描述更详细准确等情况）等业务场景下，需要更新房间特色的相关描述内容时，可以调用这个方法，传入对应的字符串内容，以此来更新该属性的值，确保前端展示的房间特色信息是最新且准确的。
*/
public void setFangjianTese(String fangjianTese) {
this.fangjianTese = fangjianTese;
}
/**
* 获取： 房间配置
* 按照JavaBean的属性访问器规范定义的方法，用于获取房间配置（fangjianPeizhi）属性的值。
* 外部代码（在前端展示房间预约信息时，为了让用户清楚房间内部配备了哪些设施设备等具体情况的相关业务逻辑代码中）可以调用这个方法，获取到当前对象记录的房间内的硬件配置信息，例如房间里有哪些电器、家具等设施配备情况，方便在前端页面展示给用户，辅助用户更清晰地理解房间预约中涉及到的关于房间设施方面的相关内容，比如是否满足自己对设施的需求等。
*/
public String getFangjianPeizhi() {
return fangjianPeizhi;
}
/**
* 设置： 房间配置
* 这是遵循JavaBean规范定义的用于设置房间配置（fangjianPeizhi）属性值的方法，属于属性修改器（setter）方法。
* 外部代码在诸如房间设施配备发生变化（比如新添加了某种设施设备，或者原有的设施被更换等更新房间设施配备情况），或者根据实际的业务场景需要对已记录的配置信息文本进行修改（比如纠正之前配置信息录入的错误等）时，可以调用这个方法，传入新的描述房间配置的字符串内容，来更新该属性的值，保证前端展示的房间配置信息与实际情况相符。
*/
public void setFangjianPeizhi(String fangjianPeizhi) {
this.fangjianPeizhi = fangjianPeizhi;
}
/**
* 获取： 提供的商品
* 依据JavaBean规范定义的访问器（getter）方法，用于获取提供的商品（fangjianShangpin）属性的值。
* 外部代码（例如在前端展示房间预约详情页面，需要告知用户该房间原本为住客提供哪些商品的相关业务逻辑代码中）可以调用这个方法，获取当前对象注明的房间提供的商品信息，像房间是否提供免费的矿泉水、洗漱用品等内容，便于在前端展示给用户知晓，从而帮助用户更好地理解房间预约中涉及到的与房间提供商品相关的情况，比如自己是否需要这些商品等。
*/
public String getFangjianShangpin() {
return fangjianShangpin;
}
// 设置： 提供的商品
// 这是遵循JavaBean规范定义的用于设置提供的商品（fangjianShangpin）属性值的方法，属于属性修改器（setter）方法。
// 外部代码在有新增商品种类、修改已提供商品的相关描述（比如商品品牌更换等情况）等业务场景下，需要更新房间提供商品的相关描述内容时，可以调用这个方法，传入对应的字符串内容作为新的商品描述信息，以此来更新该属性的值，确保前端展示的房间提供商品信息是最新且准确的。
public void setFangjianShangpin(String fangjianShangpin) {
this.fangjianShangpin = fangjianShangpin;
}
// 获取： 提供的服务
// 按照JavaBean规范定义的访问器（getter）方法，用于获取提供的服务（fangjianFuwu）属性的值。
// 外部代码（在前端展示房间预约信息时，为了让用户从服务角度更好地理解相关预约情况，需要获取房间配套提供的服务项目信息的相关业务逻辑代码中）可以调用这个方法，获取当前对象列出的房间提供的服务信息，例如房间是否包含早餐服务、有没有免费的客房清洁服务等内容，方便在前端展示给用户，辅助用户从服务方面去理解房间预约所涉及的相关情况，比如是否满足自己对服务的期望等。
public String getFangjianFuwu() {
return fangjianFuwu;
}
// 设置： 提供的服务
// 定义了设置提供的服务（fangjianFuwu）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则。
// 外部代码在业务运营过程中，当对房间配套的服务项目进行调整（比如新增了某项服务，或者取消了原有的某项服务等情况），或者根据业务需求修改服务介绍的相关文本（比如对服务内容描述进行优化等）时，可以调用这个方法，传入新的描述房间提供服务的字符串内容，来更新该属性的值，保证前端展示的房间提供服务信息与实际情况一致。
public void setFangjianFuwu(String fangjianFuwu) {
this.fangjianFuwu = fangjianFuwu;
}
// 获取： 价格（天）
// 按照JavaBean规范定义的访问器（getter）方法，用于获取价格（fangjianMoney）属性的值，该价格指的是房间每天的出租价格。
// 外部代码（比如在前端展示房间预约信息时，为了让用户从性价比等角度综合考虑相关预约情况，需要获取房间价格信息的相关业务逻辑代码中）可以调用这个方法，获取当前对象对应的房间每天的出租价格信息，方便在前端展示给用户查看，使得用户能够结合价格情况以及房间的其他配置、服务等信息，来全面评估预约该房间是否合适，比如判断价格是否符合自己的预算等。
public Double getFangjianMoney() {
return fangjianMoney;
}
// 设置： 价格（天）
// 定义了设置价格（fangjianMoney）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，用于设置房间每天的出租价格。
// 外部代码在诸如酒店进行价格调整（根据市场行情、淡旺季等因素改变房间价格），或者根据不同的业务场景（比如针对特定客户群体设置优惠价格等情况）设定价格时，可以调用这个方法，传入相应的价格数值，以此来更新该属性的值，确保前端展示的房间价格信息是准确且符合实际业务设定的。
public void setFangjianMoney(Double fangjianMoney) {
this.fangjianMoney = fangjianMoney;
}
// 获取： 房间类型
// 依据JavaBean规范定义的访问器（getter）方法，用于获取房间类型（fangjianTypes）属性的值，这里的房间类型通常是通过特定的标识（如数字、代码等方式）来区分不同种类的房间。
// 外部代码（在前端展示房间预约信息时，为了便于进行房间分类展示，以及方便用户根据房型对预约进行分类查看和理解的相关业务逻辑代码中）可以调用这个方法，获取当前对象表示的房间类型信息，例如用1表示单人间，2表示双人间等，便于前端根据不同的房型分类展示对应的预约内容，使用户能够更高效地查找和查看自己关注的房型相关的预约信息。
public Integer getFangjianTypes() {
return fangjianTypes;
}
// 设置： 房间类型
// 这是遵循JavaBean规范定义的用于设置房间类型（fangjianTypes）属性值的方法，属于属性修改器（setter）方法，用于设置房间的类型标识。
// 外部代码在诸如酒店新增了一种房型，需要对其设定相应的类型标识，或者根据业务运营需要对已有的房间分类进行修改（比如重新调整房型分类标准等情况）时，可以调用这个方法，传入对应的房间类型标识数值，来更新该属性的值，保证前端展示的房间类型信息与实际的房型分类情况相符。
public void setFangjianTypes(Integer fangjianTypes) {
this.fangjianTypes = fangjianTypes;
}
// 获取： 房间类型的值
// 按照JavaBean规范定义的访问器（getter）方法，用于获取房间类型的值（fangjianValue）属性的值，该属性存储的是房间类型对应的更具体的描述性值（比如房间类型代码对应的具体文字描述等内容）。
// 外部代码（在前端展示房间预约信息时，为了更友好、直观地展示房间类型相关信息，辅助用户更好地理解预约涉及的房间类型情况的相关业务逻辑代码中）可以调用这个方法，获取当前对象存储的房间类型对应的具体描述性值，例如对于“2”这个房间类型标识，对应的具体描述性值可能是“豪华海景双人房”，这样能让用户更清晰地知晓房型情况，更准确地理解相关预约内容。
public String getFangjianValue() {
return fangjianValue;
}
// 设置： 房间类型的值
// 定义了设置房间类型的值（fangjianValue）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，用于设置房间类型对应的具体描述性值。
// 外部代码在诸如更新房间类型对应的文字描述（比如对房型的命名进行优化、修改，使其更符合实际情况或者更通俗易懂等情况）时，可以调用这个方法，传入新的描述性字符串内容，以此来更新该属性的值，确保前端展示的房间类型具体描述信息是准确且易于用户理解的。
public void setFangjianValue(String fangjianValue) {
this.fangjianValue = fangjianValue;
}
// 获取： 房间剩余数量
// 依据JavaBean规范定义的访问器（getter）方法，用于获取房间剩余数量（fangjianNumber）属性的值，该属性记录的是当前房间还可预订的剩余数量。
// 外部代码（在前端展示房间预约信息时，为了展示房间的热门程度等相关背景信息，让用户了解房间的预订余量情况的相关业务逻辑代码中）可以调用这个方法，获取当前对象记录的房间可预订剩余数量信息，例如剩余数量少可能意味着房间比较热门，用户可以结合这个信息以及其他房间相关情况，来综合考虑是否进行预约等情况。
public Integer getFangjianNumber() {
return fangjianNumber;
}
// 设置： 房间剩余数量
// 这是遵循JavaBean规范定义的用于设置房间剩余数量（fangjianNumber）属性值的方法，属于属性修改器（setter）方法，用于设置房间剩余可预订的数量。
// 外部代码在出现诸如有新预订、取消预订等操作后（这些操作会导致房间剩余可预订数量发生变化），需要更新相应数值，使前端展示的信息保持准确时，可以调用这个方法，传入新的剩余数量数值，来更新该属性的值，保证前端展示的房间剩余数量信息与实际可预订情况相符。
public void setFangjianNumber(Integer fangjianNumber) {
this.fangjianNumber = fangjianNumber;
}
// 获取： 点击次数
// 此方法是按照JavaBean规范定义的访问器（getter）方法，用于获取房间的点击次数属性（fangjianClicknum）的值，点击次数用于统计房间信息被查看的次数。
// 外部代码（比如展示房间相关信息的业务逻辑代码或者前端交互代码等，特别是在需要呈现房间受关注程度相关情况的场景下）可以调用这个方法，来获取当前对象所代表的房间被查看的次数信息，以便根据点击次数情况进行相应的展示（比如在前端页面展示房间的热门程度排序等）或业务处理（比如基于点击次数分析房间的受欢迎程度等），辅助用户了解该房间的关注度情况，进而考虑是否预约该房间。
public Integer getFangjianClicknum() {
return fangjianClicknum;
}
// 设置： 点击次数
// 这是遵循JavaBean规范定义的修改器（setter）方法，用于设置房间的点击次数属性（fangjianClicknum）的值。
// 外部代码在需要更新房间的点击次数信息时（例如每次有用户查看房间详情页面后，按照业务逻辑通常会对点击次数进行累加更新等情况），可以调用这个方法，传入相应的整数值（一般是在原有的点击次数基础上进行增加等操作）来改变该属性的值，确保点击次数数据能准确反映房间被查看的实际情况。
public void setFangjianClicknum(Integer fangjianClicknum) {
this.fangjianClicknum = fangjianClicknum;
}
// 获取： 房间详情
// 按照JavaBean的属性访问器规范定义的方法，用于获取房间详情属性（fangjianContent）的值，该属性存储的是关于房间更全面、详细的描述信息。
// 外部代码（在展示房间相关的预约信息时，为了同时向用户呈现房间的详细情况，帮助用户更好地理解预约的背景的相关业务逻辑代码中）可以调用这个方法，获取到像房间布局、面积大小、装修风格等更全面的介绍内容，使得用户在进行预约操作时能结合房间详情信息，更深入地了解具体情况，比如判断房间是否满足自己对住宿环境等方面的需求。
public String getFangjianContent() {
return fangjianContent;
}
// 设置： 房间详情
// 遵循JavaBean规范的属性修改器方法，用于设置房间详情属性（fangjianContent）的值。
// 当需要更新房间的详细描述信息时（比如完善房间介绍、修改房间详情中的部分内容等业务场景，例如酒店重新装修后需要更新房间布局、风格等相关描述信息），外部代码可以调用这个方法，传入新的字符串内容来更新该属性的值，确保房间详情信息的准确性和及时性，使前端展示给用户的房间详情与实际情况一致。
public void setFangjianContent(String fangjianContent) {
this.fangjianContent = fangjianContent;
}
// 级联表的get和set yonghu
// 获取： 用户姓名
// 按照JavaBean规范定义的访问器方法，用于获取用户姓名属性（yonghuName）的值，该属性存储的是进行房间预约的用户的姓名。
// 在展示房间预约信息时，通过调用这个方法可以获取进行预约操作的用户的姓名，从而明确预约者身份，增强信息展示的完整性和可读性，方便前端进行相应的展示处理，比如在前端页面预约详情区域展示用户姓名，让其他用户能清楚知道是谁进行的预约，提高信息的可信度和关联性。
public String getYonghuName() {
return yonghuName;
}
// 设置： 用户姓名
// 遵循JavaBean规范的修改器方法，用于设置用户姓名属性（yonghuName）的值。
// 例如在从数据库查询到用户信息并构建当前视图对象后，若发现用户姓名需要更新（如用户修改了昵称等情况），外部代码可以调用这个方法传入新的姓名值来更新该属性，确保前端展示的用户姓名信息是最新且准确的，符合用户实际情况。
public void setYonghuName(String yonghuName) {
this.yonghuName = yonghuName;
}
// 获取： 头像
// 这是用于获取用户头像属性（yonghuPhoto）值的访问器方法，符合JavaBean规范，该属性存储的是用户头像相关的信息（比如头像图片的路径或者标识等内容）。
// 外部代码调用它可以获取到用户头像相关的信息，便于在前端展示房间预约信息时同时展示用户头像，使展示效果更具个性化和直观性，比如在前端页面预约展示区域旁边展示用户头像图片，让用户界面更生动形象，也有助于用户快速识别不同的预约者，增强信息展示的辨识度。
public String getYonghuPhoto() {
return yonghuPhoto;
}
// 设置： 头像
// 按照JavaBean的属性修改器规范定义的方法，用于设置用户头像属性（yonghuPhoto）的值。
// 当用户更新了头像信息（比如更换了头像图片）后，外部代码可以调用这个方法，传入新的头像相关信息（如更新后的图片路径等）来更新该属性的值，保证前端展示的头像信息是最新的，与用户实际的头像情况相符。
public void setYonghuPhoto(String yonghuPhoto) {
this.yonghuPhoto = yonghuPhoto;
}
// 获取： 手机号
// 此为获取用户手机号属性（yonghuPhone）值的访问器方法，遵循JavaBean规范，该属性存储的是用户的手机号码信息。
// 外部代码通过调用这个方法可以获取到用户的手机号码信息，在一些业务场景下（比如需要联系用户确认预约信息、进行预约相关通知等情况）可能会用到该手机号信息，同时也能增加前端展示用户信息的完整性，不过出于隐私保护，一般不会直接完全展示手机号给所有用户，可能只有特定权限的人员（如管理员等）在必要时可见。
public String getYonghuPhone() {
return yonghuPhone;
}
// 设置： 手机号
// 遵循JavaBean规范定义的用于设置用户手机号属性（yonghuPhone）值的修改器方法。
// 若用户的手机号码发生了变更，外部代码（如处理用户信息更新的业务逻辑代码）可以调用这个方法，传入新的手机号作为参数，来更新该属性的值，以此保证在系统中存储以及后续使用的用户手机号信息是准确无误的，与用户实际的联系方式保持一致。
public void setYonghuPhone(String yonghuPhone) {
this.yonghuPhone = yonghuPhone;
}
// 获取： 电子邮箱
// 按照JavaBean规范定义的访问器方法，用于获取用户电子邮箱属性（yonghuEmail）的值。
// 外部代码调用该方法可以获取用户的电子邮箱地址，在业务中可能用于发送预约确认、提醒等邮件，或者处理预约变更等情况与用户沟通等通过邮件形式交互的业务场景，也有助于完善前端展示的用户信息内容，尽管不一定直接展示邮箱地址给所有用户，但它作为用户信息的一部分能让整体信息更加完整。
public String getYonghuEmail() {
return yonghuEmail;
}
// 设置： 电子邮箱
// 遵循JavaBean规范的修改器方法，用于设置用户电子邮箱属性（yonghuEmail）的值。
// 当用户更新了自己的电子邮箱地址（比如用户在个人信息设置页面修改了邮箱，相关操作请求传递到后端）后，外部代码（例如负责处理用户信息修改保存的业务逻辑代码）可以调用这个方法，传入新的邮箱地址作为参数，来更新该属性的值，确保在后续的各种业务操作（如发送邮件等）中使用的邮箱信息是最新且准确的，符合用户实际的邮箱设置情况。
public void setYonghuEmail(String yonghuEmail) {
this.yonghuEmail = yonghuEmail;
}
// 获取： 余额
// 这是用于获取用户余额属性（newMoney）值的访问器（getter）方法，符合JavaBean规范。
// 外部代码（在一些综合业务展示页面（比如展示用户的综合账户信息详情时），或者涉及到用户资金相关的扩展业务场景（如判断用户是否满足某些优惠活动条件、分析用户消费能力等情况对应的业务逻辑代码）中）调用它可以获取到用户账户的余额信息，虽然在房间预约的主要业务场景下，余额信息关联性可能不是特别紧密，但在更全面的业务范畴内，该信息可能会起到一定的作用，有助于对用户进行更全面的了解和相关业务分析。
public Double getNewMoney() {
return newMoney;
}
// 设置： 余额
// 按照JavaBean的属性修改器规范定义的方法，用于设置用户余额属性（newMoney）的值。
// 例如在用户进行了充值、消费等操作（比如用户通过线上支付渠道进行充值，或者在酒店内使用房间相关服务产生消费等情况发生后，对应的业务逻辑处理代码）导致余额发生变化后，外部代码可以调用这个方法，传入新的余额数值作为参数，来更新该属性的值，以此保证系统中记录的用户余额信息始终是准确的，能够真实反映用户账户的资金情况。
public void setNewMoney(Double newMoney) {
this.newMoney = newMoney;
}
// 获取： 假删
// 此为获取用户假删属性（yonghuDelete）值的访问器（getter）方法，遵循JavaBean规范。
// 该属性可能用于表示用户是否被标记为假删除状态（具体含义需结合业务逻辑确定，比如可能是在数据管理过程中，为了保留用户数据但又暂时不让其在某些常规展示场景下出现等情况而设置的一种特殊状态标识），外部代码（比如在前端展示用户相关信息时，需要根据用户状态进行不同展示效果处理的业务逻辑代码）调用这个方法可以获取到这个状态信息，以便在前端展示用户相关信息时体现该状态情况，让管理员或者相关人员清楚了解用户数据的实际处理状态。
public Integer getYonghuDelete() {
return yonghuDelete;
}
// 设置： 假删
// 遵循JavaBean规范定义的用于设置用户假删属性（yonghuDelete）值的修改器（setter）方法。
// 当用户的假删状态发生变化（比如从正常状态变为假删除状态，可能是因为某些业务规则触发，如用户长时间未活跃等情况需要将其标记为假删除；或者反之，从假删除状态恢复为正常状态，例如用户重新激活账号等情况）时，外部代码（如负责处理用户状态变更的业务逻辑代码）可以调用这个方法，传入相应的整数值（通常是代表不同状态的特定数值，如0表示正常，1表示假删除等，具体看业务定义）来更新该属性的值，确保用户的假删状态在系统中能准确记录和体现，使得系统对用户数据的处理状态与实际业务情况相符。
public void setYonghuDelete(Integer yonghuDelete) {
// 将传入的参数值赋值给当前对象的yonghuDelete属性，完成对用户假删属性值的更新操作
this.yonghuDelete = yonghuDelete;
}
}
// 最后的右花括号，用于结束FangjianOrderView类的定义，表示该类的代码块范围到此结束
}

72
minsu/minsuguanliw/src/main/java/com/entity/view/FangjianView.java
Unescape View File

@ -1,65 +1,73 @@
package com.entity.view;
// 导入房间实体类（FangjianEntity），该类可能包含了与房间相关的基础属性及对应的数据库操作逻辑等，
// 这里的FangjianView类会基于它来扩展或调整相关属性，以满足后端返回给前端视图展示的需求
import com.entity.FangjianEntity;
// 导入MyBatis Plus的注解，用于指定该实体类对应的数据库表名，使得在与数据库交互时，框架能准确地知道该类关联的是哪张数据表
import com.baomidou.mybatisplus.annotations.TableName;
// 导入Apache Commons BeanUtils工具类，其提供了方便的方法来进行Java对象之间属性的复制操作，
// 本类中会使用它来将FangjianEntity对象的属性复制到FangjianView对象中
import org.apache.commons.beanutils.BeanUtils;
// 导入异常处理相关的类，用于捕获在使用BeanUtils进行属性复制操作时可能抛出的异常，保证程序在出现异常情况时也能稳定运行，避免因异常导致程序崩溃
import java.lang.reflect.InvocationTargetException;
// 导入Spring框架的日期格式化注解，用于在接收前端传入的日期参数或者向前端返回日期数据时，按照指定格式进行转换处理，使日期数据的格式符合业务要求
import org.springframework.format.annotation.DateTimeFormat;
// 导入Jackson框架的注解，用于在序列化和反序列化日期类型数据时，控制其格式，确保在数据传输和存储过程中日期格式的一致性与准确性
import com.fasterxml.jackson.annotation.JsonFormat;
// 导入Java的序列化接口，表明该类的对象可以被序列化和反序列化，方便在网络传输、持久化存储等场景下对该类的实例进行操作，比如在前后端数据交互或者保存对象状态到文件等情况中使用
import java.io.Serializable;
// 导入Java中的日期类，用于处理可能涉及到的日期相关属性（虽然在当前代码片段中未明确看到使用场景，但作为通用的日期处理类引入，以备后续业务扩展可能会用到）
import java.util.Date;
/**
* 房间信息
* 后端返回视图实体辅助类
* （通常后端关联的表或者自定义的字段需要返回使用）
* 该类继承自FangjianEntity类，是专门为了构建适合后端返回给前端展示房间信息的视图实体类而创建的。
* 它可以添加一些额外的属性或者对继承自父类的属性进行调整、扩展，以满足前端展示房间信息的各种需求，同时通过实现Serializable接口保证对象的可序列化特性。
*/
@TableName("fangjian")
public class FangjianView extends FangjianEntity implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 房间类型的值
*/
private String fangjianValue;
// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化（如添加、删除字段等）时，可以通过修改这个版本号来避免反序列化出错，初始值设为1L，在类相对稳定的情况下一般不需要改动
private static final long serialVersionUID = 1L;
/**
* 房间类型的值
* 用于存储房间类型对应的更具体的描述性值（比如房间类型代码对应的具体文字描述等内容），方便在前端更友好、直观地展示房间类型相关信息，辅助用户更好地理解房间的具体类型情况。
*/
private String fangjianValue;
// 默认构造函数，用于创建FangjianView类的实例对象，在一些情况下（比如通过反射等方式创建对象时）可能会用到，它会创建一个默认状态的对象实例
public FangjianView() {
}
// 构造函数，接收一个FangjianEntity对象作为参数，用于将传入的实体类对象的属性值复制到当前视图类对象中，通过BeanUtils工具类来实现属性复制，方便基于已有的实体数据构建视图对象
public FangjianView(FangjianEntity fangjianEntity) {
try {
// 使用BeanUtils的copyProperties方法，将fangjianEntity对象的属性值复制到当前对象（this）中，实现属性的赋值操作，但该方法可能会抛出IllegalAccessException（访问权限异常）和InvocationTargetException（方法调用异常），所以需要进行异常捕获处理
BeanUtils.copyProperties(this, fangjianEntity);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
// 如果在属性复制过程中出现异常，打印异常堆栈信息，方便开发人员排查问题，确定是哪里出现了访问权限问题或者方法调用出错等情况
e.printStackTrace();
}
}
/**
* 获取： 房间类型的值
* 这是按照JavaBean规范定义的访问器（getter）方法，用于获取房间类型的值（fangjianValue）属性的值。
* 外部代码（比如展示房间相关信息的业务逻辑代码或者前端交互代码等）可以调用这个方法，获取当前对象所代表的房间类型对应的具体描述性值，以便进行相应的展示或业务处理，帮助用户更清晰地了解房间的类型特点。
*/
public String getFangjianValue() {
return fangjianValue;
}
/**
* 获取： 房间类型的值
*/
public String getFangjianValue() {
return fangjianValue;
}
/**
* 设置： 房间类型的值
*/
public void setFangjianValue(String fangjianValue) {
this.fangjianValue = fangjianValue;
}
}
/**
* 设置： 房间类型的值
* 定义了设置房间类型的值（fangjianValue）属性值的方法，遵循JavaBean规范中的属性修改器（setter）方法定义。
* 外部代码在需要更新房间类型的具体描述信息时（比如对房型的命名进行优化、修改，使其更符合实际情况或者更通俗易懂等情况），可以调用这个方法，传入相应的字符串内容作为新的房间类型描述，以此来改变该属性的值，确保在前端展示的房间类型信息是准确且符合实际情况的。
*/
public void setFangjianValue(String fangjianValue) {
this.fangjianValue = fangjianValue;
}
}

20
minsu/minsuguanliw/src/main/java/com/service/FangjianLiuyanService.java
Unescape View File

@ -1,19 +1,31 @@
package com.service;
// 导入MyBatis Plus中定义的服务层接口基础类，IService接口提供了一系列通用的数据库操作方法（如增删改查等基础操作）的定义，
// 这里让FangjianLiuyanService接口继承它，意味着FangjianLiuyanService可以直接使用或重写这些通用方法，以满足房间评论/投诉相关业务逻辑中的数据库操作需求
import com.baomidou.mybatisplus.service.IService;
// 导入自定义的工具类，用于处理分页相关的功能，比如构建分页查询的参数、获取分页结果等操作，方便在查询房间评论/投诉数据时实现分页展示效果
import com.utils.PageUtils;
// 导入房间评论/投诉对应的实体类，该实体类包含了房间评论/投诉相关的各种属性信息，服务层接口中的方法操作基本都是围绕这个实体类对应的数据库表记录来进行的
import com.entity.FangjianLiuyanEntity;
// 导入Java中的Map接口，用于存储键值对形式的查询参数，在查询房间评论/投诉数据时，可以通过Map来传递各种不同的查询条件（如按用户ID查询、按时间范围查询等），灵活性较高
import java.util.Map;
// 导入用于处理HTTP请求相关的类，在服务层的方法中可能会根据请求对象获取一些额外的信息（比如从请求头获取用户信息等，虽然当前代码中未体现明显使用场景，但预留了使用的可能性），辅助业务逻辑处理
import javax.servlet.http.HttpServletRequest;
/**
* 房间评论/投诉 服务类
* 该接口定义了针对房间评论/投诉相关业务的服务方法，继承自IService接口，意味着它具备了一些基础的数据库操作能力，
* 同时又可以在此基础上添加符合房间评论/投诉业务特定需求的方法，是连接业务逻辑层与数据持久层的重要接口，方便对房间评论/投诉相关数据进行各种操作和管理。
*/
public interface FangjianLiuyanService extends IService<FangjianLiuyanEntity> {
/**
* @param params 查询参数
* @return 带分页的查询出来的数据
*/
PageUtils queryPage(Map<String, Object> params);
* @param params 查询参数
* 该参数用于接收一个Map类型的对象，其中键为查询条件的名称（比如"user_id"表示按用户ID查询时的键，"start_time"和"end_time"表示按时间范围查询时的起始和结束时间键等），
* 值则为对应的具体查询条件值（如具体的用户ID数值、具体的日期对象等），通过这个参数可以灵活地传递各种不同的查询条件，以满足多样化的查询需求。
*
* @return 带分页的查询出来的数据
* 返回值类型为PageUtils，这是一个自定义的工具类对象，它封装了分页查询后得到的相关数据，包括当前页的数据列表（通常是包含房间评论/投诉实体对象的列表）、总记录数、总页数等信息，方便前端进行分页展示以及相关业务逻辑处理。
*/
PageUtils queryPage(Map<String, Object> params);
}

19
minsu/minsuguanliw/src/main/java/com/service/FangjianOrderService.java
Unescape View File

@ -1,19 +1,30 @@
package com.service;
// 导入MyBatis Plus中定义的服务层接口基础类，IService接口提供了如增删改查等一系列通用的数据库操作方法的定义，
// 此处让FangjianOrderService接口继承它，意味着FangjianOrderService接口能借助这些已定义好的通用操作，同时也可根据房间预约业务的特殊需求去拓展或重写相关方法，方便与数据库进行交互来处理房间预约相关的数据操作。
import com.baomidou.mybatisplus.service.IService;
// 导入自定义的工具类，用于处理分页相关的功能，比如组织分页查询所需的参数、整合分页查询后的结果等，目的是在对房间预约信息进行查询时，能够按照分页的形式来展示和处理数据，提升用户查看数据的体验以及方便数据管理。
import com.utils.PageUtils;
// 导入房间预约对应的实体类，FangjianOrderEntity类包含了房间预约业务中涉及的各项关键属性（如预约房间的ID、预约用户的ID、预约时间等），服务层接口里的各种方法操作基本都是围绕这个实体类所对应的数据库表记录来展开的。
import com.entity.FangjianOrderEntity;
// 导入Java中的Map接口，通过它可以创建键值对形式的对象，用于存储各种查询参数。在查询房间预约信息时，可将不同的查询条件（例如按照预约日期范围查询，键可以是“start_date”和“end_date”，对应的值就是具体的日期范围；或者按照用户ID查询，键为“user_id”，值就是具体的用户ID数值等）以键值对形式放入Map中传递给查询方法，使得查询条件的传递更加灵活多样。
import java.util.Map;
// 导入用于处理HTTP请求相关的类，在实际的业务场景中，服务层的方法可能会依据HTTP请求对象获取一些额外有用的信息（比如从请求头里获取用户的登录状态、权限信息等来辅助判断能否进行相关预约操作等，虽然当前代码里没体现出明显使用场景，但预留了这样的扩展可能性），以便更好地处理业务逻辑。
import javax.servlet.http.HttpServletRequest;
/**
* 房间预约 服务类
* 此接口作为针对房间预约相关业务的服务层接口，继承自IService接口，具备了IService提供的通用数据库操作能力，同时又能依据房间预约业务独有的特点和需求，定义特定的业务方法，起到了承上启下的作用，连接着上层的业务逻辑调用与底层的数据持久化操作，便于对房间预约相关的数据进行有效管理和操作。
*/
public interface FangjianOrderService extends IService<FangjianOrderEntity> {
/**
* @param params 查询参数
* @return 带分页的查询出来的数据
*/
PageUtils queryPage(Map<String, Object> params);
* @param params 查询参数
* 这里的params参数是一个Map类型的变量，用于接收从外部传入的查询条件信息，其内部以键值对的形式组织数据。键代表查询条件的具体名称（例如“room_id”可以表示按房间编号查询时的条件名，“order_status”可作为按订单状态查询的条件名等），
* 值则对应具体的查询条件内容（像房间编号的具体数值、订单状态对应的具体状态值等），这样可以灵活地设置各种不同的查询需求，以适应复杂多样的业务查询场景，比如根据不同用户、不同时间段、不同房间来查询预约信息等。
*
* @return 带分页的查询出来的数据
* 该方法的返回值类型是PageUtils，这是一个自定义的工具类，它里面封装了分页查询后所得到的一系列相关数据，包含了当前页所展示的房间预约记录列表（通常是FangjianOrderEntity类型的对象列表，每条记录对应一条预约信息）、总的记录条数（用于计算总页数以及给用户提示数据总量等情况）以及总页数等重要信息，方便前端页面进行分页展示，也利于后续业务逻辑根据这些分页数据做进一步的处理，例如实现翻页功能、根据总记录数进行统计分析等操作。
*/
PageUtils queryPage(Map<String, Object> params);
}

24
minsu/minsuguanliw/src/main/java/com/service/FangjianService.java
Unescape View File

@ -1,19 +1,35 @@
package com.service;
// 导入MyBatis Plus中定义的服务层接口基础类。IService接口提供了一系列通用的数据库操作方法定义，例如常见的增删改查等操作方法的规范，
// 此处让FangjianService接口继承它，意味着FangjianService可以复用这些通用的数据库操作逻辑，同时也能够根据房间信息业务特有的需求，去扩展或者重写相应的方法，方便与数据库进行交互，处理和房间信息相关的数据操作。
import com.baomidou.mybatisplus.service.IService;
// 导入自定义的工具类，主要用于处理分页相关功能，像构建分页查询所需的参数、整合分页查询后得到的结果数据等操作，
// 其目的是在对房间信息进行查询时，能够按照分页的形式来展示和处理数据，便于前端更好地展示大量的房间信息，也方便用户查看不同页面的内容，提升交互体验。
import com.utils.PageUtils;
// 导入房间信息对应的实体类，FangjianEntity类包含了描述房间各种属性的字段，例如房间名称、房间图片、价格、配置等信息，
// 服务层接口中的各个方法基本都是围绕这个实体类所对应的数据库表记录来开展操作的，例如查询、更新房间信息等都是针对这些实体数据进行。
import com.entity.FangjianEntity;
// 导入Java中的Map接口，它可以用来存储键值对形式的数据，在这里用于存放各种查询参数。比如可以通过键值对来表示不同的查询条件，像以"room_type"为键，对应的房型值为值来查询特定房型的房间；或者以"price_min"和"price_max"为键，分别存放价格区间的最小值和最大值来查询符合价格范围的房间等，使得查询条件的设置更加灵活多样。
import java.util.Map;
// 导入用于处理HTTP请求相关的类，虽然在当前代码中没有明显体现出具体使用场景，但在实际的业务逻辑中，服务层的方法可能会依据HTTP请求对象获取一些额外的有用信息，
// 例如从请求头中获取用户的权限信息，以此判断用户是否有权限查询某些房间信息；或者获取用户的地理位置信息，来推荐距离较近的房间等，为业务处理提供更多的辅助信息。
import javax.servlet.http.HttpServletRequest;
/**
* 房间信息 服务类
* 该接口定义了针对房间信息相关业务的服务层接口，它继承自IService接口，具备了IService所提供的通用数据库操作能力，同时又能够依据房间信息业务自身的特点和需求，
* 定义出符合实际业务场景的特定方法，在整个系统架构中起到了连接上层业务逻辑与底层数据持久化层的桥梁作用，方便对房间信息相关的数据进行有效的管理和操作。
*/
public interface FangjianService extends IService<FangjianEntity> {
/**
* @param params 查询参数
* @return 带分页的查询出来的数据
*/
PageUtils queryPage(Map<String, Object> params);
* @param params 查询参数
* 这里的params参数是一个Map类型的变量，其作用是接收从外部传入的各种查询条件信息，这些信息以键值对的形式进行组织。其中，键表示具体的查询条件名称，例如“room_name”可以用来表示按照房间名称进行查询的条件，“create_time_start”和“create_time_end”可以分别表示按照创建时间范围来查询房间的起始时间和结束时间等；
* 值则对应着具体的查询条件内容，比如对于“room_name”这个键，值可能就是具体的房间名称字符串；对于时间范围相关的键，值就是对应的具体日期对象等。通过这样的方式，可以灵活地传递各种不同的查询要求，满足多样化的业务查询需求，比如查找特定名称、特定时间段内创建的房间等。
*
* @return 带分页的查询出来的数据
* 该方法返回值类型为PageUtils，这是一个自定义的工具类，它里面封装了分页查询后所得到的一系列相关数据，主要包括当前页所展示的房间信息记录列表（通常是FangjianEntity类型的对象列表，每个对象代表一条房间信息记录）、总的记录条数（可以用于计算总页数、提示用户数据总量等情况）以及总页数等关键信息，
* 方便前端页面进行分页展示，也便于后续业务逻辑根据这些分页数据做进一步的处理，例如实现分页导航、根据总记录数进行统计分析等操作，从而更好地展示和处理房间信息数据。
*/
PageUtils queryPage(Map<String, Object> params);
}
Write Preview
Loading…
Cancel
Save