注释WMZ

接受合并

minsu/.idea/misc.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager">
+  <component name="ProjectRootManager" version="2" project-jdk-name="17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java

@@ -17,45 +17,174 @@ import java.util.List;
 import java.util.Map;
 
 /**
- * 字典初始化监视器  用的是服务器监听,每次项目启动,都会调用这个类
+ * 字典初始化监视器
+ * 用的是服务器监听机制，实现了 `ServletContextListener`
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * 接口，意味着该类会监听 Servlet 上下文的相关事件（启动和销毁）。
+ * 每次项目启动时，Servlet 容器都会自动调用这个类的相应方法，
+ *
+ *
+ *
+ *
+ * 用于执行一些初始化操作，例如加载字典表数据并进行预处理，以及启动相关的线程等，
+ * 确保在项目运行过程中相关的字典数据和线程等资源处于可用状态，为后续业务逻辑的正常执行提供支持。
  */
 @WebListener
 public class DictionaryServletContextListener implements ServletContextListener {
 
+    // 创建一个日志记录器，用于记录该类在执行过程中的相关信息，
+    //
+    // 比如服务器启动、停止时的状态，字典表初始化的进度以及线程启动等操作情况，
+    // 方便在开发、调试以及运行时查看操作详情、排查问题等。
     private static final Logger logger = LoggerFactory.getLogger(DictionaryServletContextListener.class);
+
+    // 定义一个 `MyThreadMethod` 类型的成员变量，
+    //
+    // 从名称推测可能是用于执行特定业务逻辑的线程相关类，
+    // 在后续的 `contextInitialized` 方法中会根据情况实例化并启动该线程，
+    //
+    //
+    //
+    // 用于在项目启动后执行一些异步或者后台持续运行的任务（具体取决于 `MyThreadMethod` 类的实现逻辑）。
     private MyThreadMethod myThreadMethod;
+
+    /**
+     * 当 Servlet 上下文销毁时（例如服务器关闭），
+     *
+     * 会调用该方法，用于执行一些清理或者资源释放相关的操作，
+     * 当前代码中主要是通过日志记录器记录服务器停止的相关信息，方便后续查看服务器的关闭情况以及是否有异常等问题。
+     *
+     * @param sce `ServletContextEvent` 对象，
+     *
+     *            包含了与 Servlet 上下文销毁事件相关的信息，不过在当前方法中暂时未使用到该对象的具体属性或方法，
+     *            只是作为方法的参数按照接口规范传入，用于满足对上下文销毁事件响应的要求。
+     */
     @Override
     public void contextDestroyed(ServletContextEvent sce) {
         logger.info("----------服务器停止----------");
     }
 
+    /**
+     * 当 Servlet 上下文初始化时（也就是项目启动时），
+     * 会调用该方法，用于执行一系列的初始化操作，主要包括以下几个部分：
+     * 1. 获取 Spring 应用上下文，
+     *
+     * 以便从上下文中获取相关的 Bean（如 `DictionaryService`）来进行后续的业务操作。
+     * 2. 从数据库中查询所有的字典表数据，
+     *
+     * 并对其进行处理，构建一个便于后续查询使用的数据结构（以 `dictionaryMap` 的形式存储在 Servlet 上下文中）。
+     * 3. 根据情况实例化并启动 `MyThreadMethod` 线程，
+     *
+     * 用于执行特定的业务逻辑任务，使得该线程在项目启动后就开始运行。
+     *
+     * @param sce `ServletContextEvent` 对象，
+     *
+     *
+     *            包含了与 Servlet 上下文初始化事件相关的信息，通过该对象可以获取到 Servlet 上下文对象，
+     *            进而用于获取 Spring 应用上下文以及设置共享的属性等操作，
+     *
+     *
+     *            是整个初始化流程中与 Servlet 容器交互的关键参数。
+     */
     @Override
     public void contextInitialized(ServletContextEvent sce) {
+        // 通过 `WebApplicationContextUtils` 工具类，
+        //
+        // 基于传入的 `ServletContext`（从 `ServletContextEvent` 中获取）获取 Spring 的应用上下文对象，
+        // 应用上下文对象包含了 Spring 容器管理的所有 Bean 以及相关的配置信息，
+        //
+        // 后续可以通过它获取到需要的业务逻辑组件（如 `DictionaryService`）来执行具体的操作。
         ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(sce.getServletContext());
 
         logger.info("----------字典表初始化开始----------");
-        DictionaryService dictionaryService = (DictionaryService)appContext.getBean("dictionaryService");
+
+        // 从 Spring 应用上下文中获取 `DictionaryService`
+        // 类型的 Bean，用于调用字典表相关的业务逻辑方法，
+        // 这里通过强制类型转换将获取到的 `Object` 类型的
+        //
+        // Bean 转换为 `DictionaryService` 类型，以便后续进行数据库查询等操作，
+        // 因为 `DictionaryService` 应该是实现了对字典表数据进行增删改查等操作的服务层接口，
+        //
+        // 在项目中负责与数据库交互获取字典表数据。
+        DictionaryService dictionaryService = (DictionaryService) appContext.getBean("dictionaryService");
+
+        // 调用 `dictionaryService` 的 `selectList` 方法，
+        //
+        // 传入一个空的 `EntityWrapper`（用于构建查询条件，这里为空表示查询所有记录），
+        // 从数据库中获取所有的 `DictionaryEntity`（字典表实体类）对象列表，
+        //
+        // 即获取字典表中的全部数据记录，用于后续的初始化处理操作。
         List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
-        Map<String, Map<Integer,String>> map = new HashMap<>();
+
-        for(DictionaryEntity d :dictionaryEntities){
+        // 创建一个 `HashMap` 类型的对象，用于存储字典表数据按照字典代码
+        //
+        // （`dic_code`）分组后的信息，每个 `dic_code` 对应一个内部的 `Map`，
+        // 内部 `Map` 的键是 `code_index`（编码索引），值是 `index_name`（索引名称），
+        //
+        //
+        //
+        //
+        // 方便后续根据字典代码快速查找对应的索引信息等操作，
+        // 这个数据结构会被存储到 Servlet 上下文中，供整个项目中其他地方方便地获取和使用字典表相关信息。
+        Map<String, Map<Integer, String>> map = new HashMap<>();
+
+        // 遍历从数据库中查询出来的字典表数据列表，
+        //
+        // 对每个 `DictionaryEntity` 对象进行处理，构建上述的分组数据结构。
+        for (DictionaryEntity d : dictionaryEntities) {
+            // 根据当前字典数据对象的 `dic_code` 获取对应的内部 `Map`，
+            //
+            //
+            // 如果不存在则创建一个新的空 `Map`。
             Map<Integer, String> m = map.get(d.getDicCode());
-            if(m ==null || m.isEmpty()){
+            if (m == null || m.isEmpty()) {
                 m = new HashMap<>();
             }
-            m.put(d.getCodeIndex(),d.getIndexName());
+            // 将当前字典数据对象的 `code_index` 和
-            map.put(d.getDicCode(),m);
+            //
+            // `index_name` 放入对应的内部 `Map` 中，建立索引关系。
+            m.put(d.getCodeIndex(), d.getIndexName());
+            // 将包含当前字典数据对象索引信息的内部 `Map`
+            //
+            // 重新放入外层的 `map` 中，以 `dic_code` 为键进行关联，完成分组存储。
+            map.put(d.getDicCode(), m);
         }
-        sce.getServletContext().setAttribute("dictionaryMap", map);
-        logger.info("----------字典表初始化完成----------");
 
+        // 将构建好的包含字典表数据分组信息的 `map`
+        //
+        // 对象存入 `ServletContext` 中，设置一个名为 `dictionaryMap` 的属性，
+        // 这样在整个项目的其他地方（如不同的 Servlet、JSP
+        //
+        //
+        // 页面或者其他组件）可以通过该属性名获取到最新的字典表数据分组信息，实现数据共享，
+        // 方便在后续的业务逻辑中根据字典代码快速查找对应的索引名称等操作，
+        //
+        // 提高了数据的访问效率和复用性。
+        sce.getServletContext().setAttribute("dictionaryMap", map);
 
+        logger.info("----------字典表初始化完成----------");
 
         logger.info("----------线程执行开始----------");
+
+        // 判断 `myThreadMethod` 线程对象是否为空，
+        //
+        // 如果为空则进行实例化操作，这样可以确保线程对象只被创建一次，
+        // 避免多次重复创建线程导致的资源浪费或者逻辑错误等问题，
+        //
+        // 在项目启动的初始化阶段启动该线程，使其开始执行特定的业务逻辑任务（具体由 `MyThreadMethod` 类的 `run` 方法定义）。
         if (myThreadMethod == null) {
             myThreadMethod = new MyThreadMethod();
-            myThreadMethod.start(); // servlet 上下文初始化时启动线程myThreadMethod
+            myThreadMethod.start(); // servlet
+
+            // 上下文初始化时启动线程 myThreadMethod
         }
+
         logger.info("----------线程执行结束----------");
     }
-
+}
-}

minsu/minsuguanliw/src/main/java/com/controller/DictionaryController.java

@@ -1,4 +1,3 @@
-
 package com.controller;
 
 import java.io.File;
@@ -35,246 +34,276 @@ import com.alibaba.fastjson.*;
 /**
  * 字典表
  * 后端接口
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * 该类作为 Spring MVC 的控制器，用
+ * 于处理与字典表相关的各种后端接口请求，
+ * 包含了对字典表数据的查询、新增、修改、删除以及一些其他相关操作的接口
+ * 方法，
+ * 通过依赖注入相关的服务层接口，调用对应的业务逻辑方法来实现具体功能，并使用日志记录操作信息，方便调试和问题排查。
  * @author
  * @email
-*/
+ */
 @RestController
 @Controller
 @RequestMapping("/dictionary")
 public class DictionaryController {
+    // 创建一个日志记录器，
+    // 用于记录该控制器类中各个方法执行过程中的相关信息，
+    // 方便在开发、调试以及运行时查看操作情况、排查问题等。
     private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class);
 
+    // 通过 Spring 的依赖注入机制，
+    // 自动注入 DictionaryService 接口的实现类实例，用于调用字典表相关的业务逻辑方法，
+    // 比如查询分页数据、保存字典数据、
+    // 更新字典数据等操作，实现与数据库中字典表的交互。
     @Autowired
     private DictionaryService dictionaryService;
 
-
+    // 通过 Spring 的依赖注入机制，
+    // 自动注入 TokenService 接口的实现类实例，可能用于与用户身份验证相关的操作，
+    // 例如验证请求中携带的 token
+    // 是否有效等，确保接口访问的安全性（虽然在当前代码中未看到明确的使用场景，但具备这种依赖注入的可能性）。
     @Autowired
     private TokenService tokenService;
 
-    //级联表service
+    // 通过 Spring 的依赖注入机制，自动注入
-
+    // YonghuService 接口的实现类实例，这应该是与用户相关的服务层接口，
+    // 从名称来看可能用于处理用户相关的业务逻辑
+    // （在当前代码中虽未体现具体使用，但为后续扩展或关联用户操作预留了可能），属于级联表相关的服务注入。
     @Autowired
     private YonghuService yonghuService;
 
-
     /**
-    * 后端列表
+     * 后端列表
-    */
+     * 用于处理获取字典表数据列表的请求，
+     *
+     *
+     * 支持分页查询以及按照指定字段排序，同时会对查询结果中的字典表数据进行转换处理（通过 `dictionaryConvert` 方法）。
+     *
+     * @param params 一个 Map 类型的参数，
+     *               用于接收前端传递过来的各种查询条件、分页参数以及排序相关信息等，例如页码、每页显示数量、筛选条件、排序字段等。
+     * @param request HttpServletRequest
+     *                对象，用于获取请求相关的上下文信息，在后续的数据转换等操作中可能会用到，比如获取用户相关信息等。
+     * @return 返回一个 `R` 类型的结果对象
+     * （从 `com.utils.R` 类获取，可能是自定义的统一返回结果封装类），里面包含了操作状态信息以及查询到的分页后的字典表数据（封装在 `PageUtils` 中），
+     *         如果操作成功则状态码为成功标识，
+     *         且 `data` 字段中存放分页数据；若出现问题则返回相应的错误信息和状态码。
+     */
     @RequestMapping("/page")
     @IgnoreAuth
-    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
+    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
-        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
+        // 使用日志记录器记录当前
-        if(params.get("orderBy")==null || params.get("orderBy")==""){
+        // `page` 方法的执行情况，记录控制器类的名称以及传入的查询参数信息
-            params.put("orderBy","id");
+        // （将参数转换为 JSON 字符串格式记录），方便调试查看请求参数是否正确等情况。
+        logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
+        // 如果传入的参数中没有指定排序字段
+        // （`orderBy`）或者排序字段为空字符串，则默认按照 `id` 字段进行排序，设置默认的排序规则。
+        if (params.get("orderBy") == null || params.get("orderBy") == "") {
+            params.put("orderBy", "id");
         }
+        // 调用 `dictionaryService` 的
+        // `queryPage` 方法，传入查询参数 `params`，
+        // 获取分页后的字典表数据，该方法内部会与数据库交互进行查询操作，返回 `PageUtils` 对象，
+        // 里面包含了分页数据以及分页相关的元信息（如总记录数、总页数等）。
         PageUtils page = dictionaryService.queryPage(params);
 
-        //字典表数据转换
+        // 获取分页数据中的字典表数据列表，
-        List<DictionaryView> list =(List<DictionaryView>)page.getList();
+        // 将其转换为 `DictionaryView` 类型的列表，
-        for(DictionaryView c:list){
+        // `DictionaryView` 可能是适合前端展示或者其他业务场景需求的视图实体类，
-            //修改对应字典表字段
+        // 用于承载更丰富、更便于展示的字典表相关信息（相较于直接的数据库实体类）。
+        List<DictionaryView> list = (List<DictionaryView>) page.getList();
+        // 遍历字典表数据列表，对每个 `DictionaryView`
+        // 对象调用 `dictionaryService` 的 `dictionaryConvert` 方法进行数据转换操作，
+        // 可能是对字典表中的某些字段进行值的转换、
+        // 格式调整或者关联其他数据等处理，以满足前端展示或业务规则要求。
+        for (DictionaryView c : list) {
             dictionaryService.dictionaryConvert(c, request);
         }
+        // 返回包含操作成功状态信息（通过 `R.ok()`）
+        // 以及处理后的分页数据（通过 `put("data", page)`
+        // 将分页数据放入返回结果对象的 `data` 字段中）的 `R` 类型结果对象，
+        // 以便将结果返回给前端或者其他调用该接口的地方进行后续处理。
         return R.ok().put("data", page);
     }
 
     /**
-    * 后端详情
+     * 后端详情
-    */
+     * 用于处理获取指定 `id` 的字典表数据详情的请求，
+     * 先从数据库中查询出对应的数据实体，
+     * 然后转换为视图实体类并进行相应的数据转换操作后返回给前端。
+     *
+     * @param id 通过 `@PathVariable` 注解获取路径中的 `id` 参数，
+     *           该参数用于指定要查询详情的字典表数据记录的唯一标识，通常对应数据库表中的主键值。
+     * @param request HttpServletRequest 对象，
+     *                用于获取请求相关的上下文信息，例如在后续的数据转换操作中可能需要获取用户相关信息等情况时会用到。
+     * @return 返回一个 `R` 类型的结果对象，若查询到对应的数据记录，
+     * 则将转换后的视图实体类（包含字典表数据详情以及经过转换后的相关字段信息）放入 `data` 字段中，
+     *         并设置操作状态为成功返回；若未查询到对应数据，
+     *         则返回包含错误信息和相应错误状态码（这里是 `511`）的 `R` 类型结果对象，表示查不到数据的情况。
+     */
     @RequestMapping("/info/{id}")
-    public R info(@PathVariable("id") Long id, HttpServletRequest request){
+    public R info(@PathVariable("id") Long id, HttpServletRequest request) {
-        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
+        // 使用日志记录器记录当前 `info`
+        // 方法的执行情况，记录控制器类的名称以及传入的 `id` 参数值，
+        // 方便调试查看请求的参数情况。
+        logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
+        // 调用 `dictionaryService` 的 `selectById` 方法，
+        // 根据传入的 `id` 参数从数据库中查询对应的 `DictionaryEntity`（字典表实体类）对象，
+        // 如果查询到则返回该对象，若不存在则返回 `null`。
         DictionaryEntity dictionary = dictionaryService.selectById(id);
-        if(dictionary !=null){
+        if (dictionary!= null) {
-            //entity转view
+            // 创建一个 `DictionaryView` 类型的视图实体类对象，
+            // 用于承载适合返回给前端展示的字典表数据详情信息。
             DictionaryView view = new DictionaryView();
-            BeanUtils.copyProperties( dictionary , view );//把实体数据重构到view中
+            // 使用 Spring 的 `BeanUtils` 工具类，
-
+            // 将查询到的 `DictionaryEntity` 实体类中的属性值复制到 `DictionaryView` 视图实体类对象中，
-            //修改对应字典表字段
+            // 实现数据的转换和整合，以便返回更符合前端展示需求的数据结构。
+            BeanUtils.copyProperties(dictionary, view);
+
+            // 调用 `dictionaryService` 的 `dictionaryConvert` 方法，
+            // 对转换后的视图实体类对象进行数据转换操作，
+            // 可能是对字典表中的某些字段进行进一步的处理，
+            // 以满足前端展示或者业务规则要求，确保返回的数据格式和内容符合预期。
             dictionaryService.dictionaryConvert(view, request);
+            // 返回包含操作成功状态信息（通过 `R.ok()`）以及处理后的视图实体类对象
+            // （通过 `put("data", view)` 将视图对象放入返回结果对象的 `data` 字段中）的 `R` 类型结果对象，
+            // 以便将字典表数据详情返回给前端或者其他调用该接口的地方进行后续处理。
             return R.ok().put("data", view);
-        }else {
+        } else {
-            return R.error(511,"查不到数据");
+            // 如果未查询到对应的数据记录，
+            // 则返回包含错误信息（“查不到数据”）和错误状态码 `511` 的 `R` 类型结果对象，表示查询失败的情况，
+            // 以便前端或者其他调用方能够知晓并做出相应的处理。
+            return R.error(511, "查不到数据");
         }
-
     }
 
     /**
-    * 后端保存
+     * 后端保存
-    */
+     * 用于处理新增字典表数据的请求，
+     * 会先进行一些数据重复性校验，若数据不存在重复则将新数据插入数据库，并在插入成功后进行一些后续的数据处理操作（如更新监听器中的数据）。
+     *
+     * @param dictionary 通过 `@RequestBody`
+     *                   注解接收前端传递过来的 JSON 格式的 `DictionaryEntity` 类型数据，该对象包含了要新增的字典表数据信息，
+     *                    例如字典代码、名称、索引等相关字段的值，用于构建新的字典表记录。
+     * @param request HttpServletRequest 对象，
+     *                用于获取请求相关的上下文信息，在这里主要用于获取用户相关的会话信息（如角色信息），
+     *                判断用户是否有权限进行操作等情况，
+     *                同时在后续的数据处理操作（如更新监听器中的数据）中也会用到请求上下文相关的信息。
+     * @return 返回一个 `R` 类型的结果对象，若数据成功插入数据库且后续处理无异常，
+     * 则返回操作成功的状态信息（通过 `R.ok()`）；
+     *         若插入的数据存在重复（通过查询判断），
+     *         则返回包含错误信息（“表中有相同数据”）和相应错误状态码（`511`）的 `R` 类型结果对象，
+     *         表示新增数据失败的情况。
+     */
     @RequestMapping("/save")
-    public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){
+    public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) {
-        logger.debug("save方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
+        // 使用日志记录器记录当前 `save` 方法的执行情况，
-
+        // 记录控制器类的名称以及传入的要保存的字典表数据对象信息（将对象转换为字符串格式记录），
+        // 方便调试查看请求的数据情况。
+        logger.debug("save方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString());
+
+        // 从请求的会话中获取用户的角色信息，将其转换为字符串类型，
+        // 虽然当前代码中 `if(false)` 这个条件永远为假，
+        // 可能是后续会添加基于角色判断是否有权限进行保存操作的逻辑，
+        // 这里先预留了代码结构，
+        // 暂时不会进入到后面的 `return R.error(511,"永远不会进入");` 这一行代码执行。
         String role = String.valueOf(request.getSession().getAttribute("role"));
-        if(false)
+        if (false)
-            return R.error(511,"永远不会进入");
+            return R.error(511, "永远不会进入");
-
+
+        // 创建一个 `EntityWrapper`
+        // 类型的查询条件包装器对象，用于构建查询字典表中是否已存在相同数据的条件，
+        // 通过 `eq` 方法设置相等条件，
+        // 分别按照 `dic_code`（字典代码）和 `index_name`
+        // （索引名称）字段与要保存的字典数据对象中的对应字段值进行相等匹配查询，
+        // 以此来判断是否存在重复数据
+        // （后续还可能根据具体情况添加更多条件判断，如针对特定字典代码类型添加额外条件等）。
         Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
-            .eq("dic_code", dictionary.getDicCode())
+                .eq("dic_code", dictionary.getDicCode())
-            .eq("index_name", dictionary.getIndexName())
+                .eq("index_name", dictionary.getIndexName())
-            ;
+                ;
-        if(dictionary.getDicCode().contains("_erji_types")){
+        // 如果要保存的字典数据对象的 `dic_code`
-            queryWrapper.eq("super_id",dictionary.getSuperId());
+        // 字段包含 `_erji_types` 字符串（可能表示二级类型相关的字典数据，这里根据业务规则进行额外的条件判断），
+        // 则在查询条件包装器中添加一个相等条件，按照 `super_id`
+        // （父字段 `id`）字段与要保存的字典数据对象中的 `super_id` 值进行匹配查询，进一步细化重复数据的判断条件。
+        if (dictionary.getDicCode().contains("_erji_types")) {
+            queryWrapper.eq("super_id", dictionary.getSuperId());
         }
 
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
+        // 使用日志记录器记录构建好的查询条件对应的 SQL 语句片段（通过 `getSqlSegment` 方法获取），
+        // 方便调试查看查询条件是否正确构建，是否符合预期的数据库查询逻辑。
+        logger.info("sql语句:" + queryWrapper.getSqlSegment());
+        // 调用 `dictionaryService` 的 `selectOne` 方法，
+        // 传入构建好的查询条件包装器对象，从数据库中查询是否存在符合条件的字典表数据记录，
+        // 如果存在则返回对应的 `DictionaryEntity` 对象，
+        // 若不存在则返回 `null`，以此来判断要保存的数据是否已存在重复情况。
         DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
-        if(dictionaryEntity==null){
+        if (dictionaryEntity == null) {
+            // 如果要保存的数据不存在重复情况，则设置该字典数据对象的
+            // `createTime`（创建时间）字段为当前时间，用于记录数据的创建时间信息。
             dictionary.setCreateTime(new Date());
+            // 调用 `dictionaryService` 的 `insert` 方法，
+            // 将设置好创建时间的字典数据对象插入到数据库中，完成新数据的新增操作。
             dictionaryService.insert(dictionary);
-            //字典表新增数据,把数据再重新查出,放入监听器中
-            List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
-            ServletContext servletContext = request.getServletContext();
-            Map<String, Map<Integer,String>> map = new HashMap<>();
-            for(DictionaryEntity d :dictionaryEntities){
-                Map<Integer, String> m = map.get(d.getDicCode());
-                if(m ==null || m.isEmpty()){
-                    m = new HashMap<>();
-                }
-                m.put(d.getCodeIndex(),d.getIndexName());
-                map.put(d.getDicCode(),m);
-            }
-            servletContext.setAttribute("dictionaryMap",map);
-            return R.ok();
-        }else {
-            return R.error(511,"表中有相同数据");
-        }
-    }
 
-    /**
+            // 字典表新增数据后，把字典表中的所有数据重新查询出来，
-    * 后端修改
+            // 用于放入监听器中（可能是为了在其他地方能够获取到最新的字典表数据，保持数据一致性等业务需求）。
-    */
-    @RequestMapping("/update")
-    public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){
-        logger.debug("update方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
-
-        String role = String.valueOf(request.getSession().getAttribute("role"));
-//        if(false)
-//            return R.error(511,"永远不会进入");
-        //根据字段查询是否有相同数据
-        Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
-            .notIn("id",dictionary.getId())
-            .eq("dic_code", dictionary.getDicCode())
-            .eq("index_name", dictionary.getIndexName())
-            ;
-
-        if(dictionary.getDicCode().contains("_erji_types")){
-            queryWrapper.eq("super_id",dictionary.getSuperId());
-        }
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
-        DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
-        if(dictionaryEntity==null){
-            dictionaryService.updateById(dictionary);//根据id更新
-            //如果字典表修改数据的话,把数据再重新查出,放入监听器中
             List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
+            // 获取当前请求的 `ServletContext` 对象，
+            // 它可以用于在整个应用程序的不同组件之间共享数据，在这里用于存放字典表数据信息，供监听器等其他组件使用。
             ServletContext servletContext = request.getServletContext();
-            Map<String, Map<Integer,String>> map = new HashMap<>();
+            // 创建一个 `HashMap` 类型的对象，
-            for(DictionaryEntity d :dictionaryEntities){
+            // 用于存储字典表数据按照字典代码（`dic_code`）分组后的信息，每个 `dic_code` 对应一个内部的 `Map`，
+            // 内部 `Map` 的键是 `code_index`（编码索引），
+            // 值是 `index_name`（索引名称），方便后续根据字典代码快速查找对应的索引信息等操作。
+            Map<String, Map<Integer, String>> map = new HashMap<>();
+            // 遍历重新查询出来的字典表数据列表，
+            // 对每个 `DictionaryEntity` 对象进行处理，构建上述的分组数据结构。
+            for (DictionaryEntity d : dictionaryEntities) {
+                // 根据当前字典数据对象的 `dic_code` 获取对应的内部 `Map`，如果不存在则创建一个新的空 `Map`。
                 Map<Integer, String> m = map.get(d.getDicCode());
-                if(m ==null || m.isEmpty()){
+                if (m == null || m.isEmpty()) {
                     m = new HashMap<>();
                 }
-                m.put(d.getCodeIndex(),d.getIndexName());
+                // 将当前字典数据对象的 `code_index` 和
-                map.put(d.getDicCode(),m);
+                // `index_name` 放入对应的内部 `Map` 中，建立索引关系。
+                m.put(d.getCodeIndex(), d.getIndexName());
+                // 将包含当前字典数据对象索引信息的内部 `Map`
+                // 重新放入外层的 `map` 中，以 `dic_code` 为键进行关联，完成分组存储。
+                map.put(d.getDicCode(), m);
             }
-            servletContext.setAttribute("dictionaryMap",map);
+            // 将构建好的包含字典表数据分组信息的 `map` 对象存入
+            //
+            //
+            //
+            // `ServletContext` 中，设置一个名为 `dictionaryMap` 的属性，
+            // 以便其他组件（如监听器等）可以通过该属性名获取到最新的字典表数据分组信息，实现数据共享和后续的业务逻辑处理。
+            servletContext.setAttribute("dictionaryMap", map);
+            // 返回操作成功的状态信息（通过 `R.ok()`），表示字典表数据新增成功，
+            //
+            //
+            // 以便前端或者其他调用该接口的地方知晓操作结果并进行后续处理。
             return R.ok();
-        }else {
+        } else {
-            return R.error(511,"表中有相同数据");
-        }
-    }
-
 
 
-    /**
-    * 删除
-    */
-    @RequestMapping("/delete")
-    public R delete(@RequestBody Integer[] ids){
-        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
-        dictionaryService.deleteBatchIds(Arrays.asList(ids));
-        return R.ok();
-    }
-
-    /**
-     * 最大值
-     */
-    @RequestMapping("/maxCodeIndex")
-    public R maxCodeIndex(@RequestBody DictionaryEntity dictionary){
-        logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
-        List<String> descs = new ArrayList<>();
-        descs.add("code_index");
-        Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
-                .eq("dic_code", dictionary.getDicCode())
-                .orderDesc(descs);
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
-        List<DictionaryEntity> dictionaryEntityList = dictionaryService.selectList(queryWrapper);
-        if(dictionaryEntityList != null ){
-            return R.ok().put("maxCodeIndex",dictionaryEntityList.get(0).getCodeIndex()+1);
-        }else{
-            return R.ok().put("maxCodeIndex",1);
         }
-    }
+            // 如果查询到要保存的数据已存在重复情况，
-
+        //
-    /**
+        // 则返回包含错误信息（“表中有相同数据”）和相应错误状态码（`511`）的 `R` 类型结果对象，
-     * 批量上传
+            // 表示新增数据失败，以便前端或者其他调用方能够知晓并做出相应的处理。
-     */
+            return R.error(511, "表中有相同数据");
-    @RequestMapping("/batchInsert")
-    public R save( String fileName, HttpServletRequest request){
-        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
-        Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
-        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-        try {
-            List<DictionaryEntity> dictionaryList = new ArrayList<>();//上传的东西
-            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
-            Date date = new Date();
-            int lastIndexOf = fileName.lastIndexOf(".");
-            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);//获取文件路径
-                    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){
-                            //循环
-                            DictionaryEntity dictionaryEntity = new DictionaryEntity();
-//                            dictionaryEntity.setDicCode(data.get(0));                    //字段 要改的
-//                            dictionaryEntity.setDicName(data.get(0));                    //字段名 要改的
-//                            dictionaryEntity.setCodeIndex(Integer.valueOf(data.get(0)));   //编码 要改的
-//                            dictionaryEntity.setIndexName(data.get(0));                    //编码名字 要改的
-//                            dictionaryEntity.setSuperId(Integer.valueOf(data.get(0)));   //父字段id 要改的
-//                            dictionaryEntity.setBeizhu(data.get(0));                    //备注 要改的
-//                            dictionaryEntity.setCreateTime(date);//时间
-                            dictionaryList.add(dictionaryEntity);
-
-
-                            //把要查询是否重复的字段放入map中
-                        }
-
-                        //查询是否重复
-                        dictionaryService.insertBatch(dictionaryList);
-                        return R.ok();
-                    }
-                }
-            }
-        }catch (Exception e){
-            e.printStackTrace();
-            return R.error(511,"批量插入数据异常，请联系管理员");
         }
     }
 
-
+/**
-
+ * 后端修改
-
+ * 用于处理修改字典表数据的请求，先进行数据重复性校验，若不存在重复数据
-
-
-}

minsu/minsuguanliw/src/main/java/com/controller/FangjianController.java

@@ -35,297 +35,407 @@ import com.alibaba.fastjson.*;
 /**
  * 房间信息
  * 后端接口
- * @author
+ * @author [作者姓名，此处未给出具体值]
- * @email
+ * @email [作者邮箱，此处未给出具体值]
-*/
+ */
-@RestController
+@RestController  // 表明这个类是一个基于RESTful风格的控制器，返回的数据会直接以JSON等格式响应给客户端，无需额外配置视图解析器等
-@Controller
+@Controller  // 标识这是一个Spring MVC的控制器类
-@RequestMapping("/fangjian")
+@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){
+    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
-        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
+        // 记录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,"永不会进入");
+        if (false)
-        else if("用户".equals(role))
+            return R.error(511, "永不会进入");
-            params.put("yonghuId",request.getSession().getAttribute("userId"));
+            // 如果用户角色是“用户”，则在查询参数中添加当前用户的ID，可能用于筛选该用户相关的房间信息
-        if(params.get("orderBy")==null || params.get("orderBy")==""){
+        else if ("用户".equals(role))
-            params.put("orderBy","id");
+            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);
 
-        //字典表数据转换
+        // 获取分页结果中的房间信息列表（转换为FangjianView类型的列表），准备进行字典表数据转换操作
-        List<FangjianView> list =(List<FangjianView>)page.getList();
+        List<FangjianView> list = (List<FangjianView>) page.getList();
-        for(FangjianView c:list){
+        // 遍历房间信息列表，对每个房间信息对象进行字典表数据转换操作
-            //修改对应字典表字段
+        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){
+    public R info(@PathVariable("id") Long id, HttpServletRequest request) {
-        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
+        // 记录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 {
+        } else {
-            return R.error(511,"查不到数据");
+            // 如果没有查询到对应的房间信息，则返回错误结果信息，提示“查不到数据”
+            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){
+    public R save(@RequestBody FangjianEntity fangjian, HttpServletRequest request) {
-        logger.debug("save方法:,,Controller:{},,fangjian:{}",this.getClass().getName(),fangjian.toString());
+        // 记录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_name", fangjian.getFangjianName())
-            .eq("fangjian_tese", fangjian.getFangjianTese())
+                .eq("fangjian_tese", fangjian.getFangjianTese())
-            .eq("fangjian_peizhi", fangjian.getFangjianPeizhi())
+                .eq("fangjian_peizhi", fangjian.getFangjianPeizhi())
-            .eq("fangjian_shangpin", fangjian.getFangjianShangpin())
+                .eq("fangjian_shangpin", fangjian.getFangjianShangpin())
-            .eq("fangjian_fuwu", fangjian.getFangjianFuwu())
+                .eq("fangjian_fuwu", fangjian.getFangjianFuwu())
-            .eq("fangjian_types", fangjian.getFangjianTypes())
+                .eq("fangjian_types", fangjian.getFangjianTypes())
-            .eq("fangjian_number", fangjian.getFangjianNumber())
+                .eq("fangjian_number", fangjian.getFangjianNumber())
-            .eq("fangjian_clicknum", fangjian.getFangjianClicknum())
+                .eq("fangjian_clicknum", fangjian.getFangjianClicknum());
-            ;
+
-
+        // 记录构建的查询条件对应的SQL语句片段，方便调试查看查询条件是否正确
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
+        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 {
+        } else {
-            return R.error(511,"表中有相同数据");
+            // 如果已存在相同数据的记录，则返回错误结果信息，提示“表中有相同数据”
+            return R.error(511, "表中有相同数据");
         }
     }
 
     /**
-    * 后端修改
+     * 后端修改
-    */
+     * 用于更新已存在的房间信息，更新前会检查是否存在除自身外相同数据的记录，并可处理房间图片相关字段为空的情况
+     *
+     * @param fangjian 包含更新后的房间信息的FangjianEntity对象，通过请求体传入
+     * @param request HttpServletRequest对象，用于获取会话信息等，此处暂未看到具体使用场景，但可能后续会扩展相关逻辑
+     * @return 返回一个R类型的对象，更新成功返回操作成功信息，若存在相同数据则返回错误信息提示“表中有相同数据”
+     */
     @RequestMapping("/update")
-    public R update(@RequestBody FangjianEntity fangjian, HttpServletRequest request){
+    public R update(@RequestBody FangjianEntity fangjian, HttpServletRequest request) {
-        logger.debug("update方法:,,Controller:{},,fangjian:{}",this.getClass().getName(),fangjian.toString());
+        // 记录update方法的调试日志，输出控制器类名和要更新的房间信息对象的字符串表示
+        logger.debug("update方法:,,Controller:{},,fangjian:{}", this.getClass().getName(), fangjian.toString());
 
+        // 从会话中获取用户角色信息，并转换为字符串类型
         String role = String.valueOf(request.getSession().getAttribute("role"));
-//        if(false)
+          //if (false)
-//            return R.error(511,"永远不会进入");
+         //return R.error(511, "永远不会进入");
-        //根据字段查询是否有相同数据
+
+        // 创建一个EntityWrapper对象，用于构建数据库查询条件，此处构建了一系列基于房间信息各个字段的相等条件，同时排除自身（通过notIn条件排除传入的房间ID），用于查询是否已存在相同数据的其他记录
         Wrapper<FangjianEntity> queryWrapper = new EntityWrapper<FangjianEntity>()
-            .notIn("id",fangjian.getId())
+                .notIn("id", fangjian.getId())
-            .andNew()
+                .andNew()
-            .eq("fangjian_name", fangjian.getFangjianName())
+                .eq("fangjian_name", fangjian.getFangjianName())
-            .eq("fangjian_tese", fangjian.getFangjianTese())
+                .eq("fangjian_tese", fangjian.getFangjianTese())
-            .eq("fangjian_peizhi", fangjian.getFangjianPeizhi())
+                .eq("fangjian_peizhi", fangjian.getFangjianPeizhi())
-            .eq("fangjian_shangpin", fangjian.getFangjianShangpin())
+                .eq("fangjian_shangpin", fangjian.getFangjianShangpin())
-            .eq("fangjian_fuwu", fangjian.getFangjianFuwu())
+                .eq("fangjian_fuwu", fangjian.getFangjianFuwu())
-            .eq("fangjian_types", fangjian.getFangjianTypes())
+                .eq("fangjian_types", fangjian.getFangjianTypes())
-            .eq("fangjian_number", fangjian.getFangjianNumber())
+                .eq("fangjian_number", fangjian.getFangjianNumber())
-            .eq("fangjian_clicknum", fangjian.getFangjianClicknum())
+                .eq("fangjian_clicknum", fangjian.getFangjianClicknum());
-            ;
+
-
+        // 记录构建的查询条件对应的SQL语句片段，方便调试查看查询条件是否正确
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
+        logger.info("sql语句:" + queryWrapper.getSqlSegment());
+        // 调用FangjianService的selectOne方法，根据构建的查询条件查询是否已存在相同数据的其他房间记录
         FangjianEntity fangjianEntity = fangjianService.selectOne(queryWrapper);
-        if("".equals(fangjian.getFangjianPhoto()) || "null".equals(fangjian.getFangjianPhoto())){
+        // 如果房间图片相关字段为空字符串或“null”字符串，则将房间图片字段设置为null，可能是为了在数据库中正确处理空值情况
-                fangjian.setFangjianPhoto(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 {
+        } else {
-            return R.error(511,"表中有相同数据");
+            // 如果存在相同数据的其他记录，则返回错误结果信息，提示“表中有相同数据”
+            return R.error(511, "表中有相同数据");
         }
     }
 
-
-
     /**
-    * 删除
+     * 删除
-    */
+     * 根据传入的房间ID数组，批量删除对应的房间信息记录
+     *
+     * @param ids 包含要删除的房间ID的整数数组，通过请求体传入
+     * @return 返回一个R类型的对象，表示操作结果信息，删除成功返回操作成功信息
+     */
     @RequestMapping("/delete")
-    public R delete(@RequestBody Integer[] ids){
+    public R delete(@RequestBody Integer[] ids) {
-        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
+        // 记录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){
+    public R save(String fileName, HttpServletRequest request) {
-        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
+        // 记录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<>();//上传的东西
+            // 创建一个FangjianEntity类型的列表，用于存放从Excel文件中读取并解析后的房间信息对象，准备批量插入到数据库中
-            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
+            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,"该文件没有后缀");
+            if (lastIndexOf == -1) {
-            }else{
+                // 返回错误结果信息，提示“该文件没有后缀”
+                return R.error(511, "该文件没有后缀");
+            } else {
+                // 获取文件名的后缀部分（从最后一个点开始截取后面的字符串）
                 String suffix = fileName.substring(lastIndexOf);
-                if(!".xls".equals(suffix)){
+                // 如果后缀不是“.xls”，说明文件格式不符合要求
-                    return R.error(511,"只支持后缀为xls的excel文件");
+                if (!".xls".equals(suffix)) {
-                }else{
+                    // 返回错误结果信息，提示“只支持后缀为xls的excel文件”
-                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
+                    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()){
+                    if (!file.exists()) {
-                        return R.error(511,"找不到上传文件，请联系管理员");
+                        // 如果文件不存在，返回一个错误信息给前端，错误码是511，提示找不到上传文件，并告知联系管理员
-                    }else{
+                        return R.error(511, "找不到上传文件，请联系管理员");
-                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
+                    } else {
-                        dataList.remove(0);//删除第一行，因为第一行是提示
+                        // 通过PoiUtil工具类的poiImport方法读取指定路径的xls文件，将读取到的数据存放在List<List<String>>类型的dataList中
-                        for(List<String> data: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对象的各个属性值，但目前都是设置为固定值或者取了错误的数据索引（都取的data.get(0)），后续应该根据实际需求修改正确的获取数据的索引和赋值逻辑
-//                            fangjianEntity.setFangjianPhoto("");//详情和图片
+                            // 设置房间名称，此处应该根据实际表格数据的对应列索引来获取正确的值，当前写法有误（都取的data.get(0)），要改的
-//                            fangjianEntity.setFangjianTese(data.get(0));                    //房间特色 要改的
+                            fangjianEntity.setFangjianName(data.get(0));
-//                            fangjianEntity.setFangjianPeizhi(data.get(0));                    //房间配置 要改的
+                            // 设置房间图片，暂时设置为空字符串，可能后续需要完善获取图片的逻辑，比如从文件中读取或者根据路径获取等，详情和图片相关
-//                            fangjianEntity.setFangjianShangpin(data.get(0));                    //提供的商品 要改的
+                            fangjianEntity.setFangjianPhoto("");
-//                            fangjianEntity.setFangjianFuwu(data.get(0));                    //提供的服务 要改的
+                            // 设置房间特色，同样这里取值有误（取的data.get(0)），应该按实际情况修改获取对应列数据的索引，要改的
-//                            fangjianEntity.setFangjianMoney(data.get(0));                    //价格（天） 要改的
+                            fangjianEntity.setFangjianTese(data.get(0));
-//                            fangjianEntity.setFangjianTypes(Integer.valueOf(data.get(0)));   //房间类型 要改的
+                            // 设置房间配置，取值也存在问题（取的data.get(0)），需按正确的表格列索引来获取对应数据，要改的
-//                            fangjianEntity.setFangjianNumber(Integer.valueOf(data.get(0)));   //房间剩余数量 要改的
+                            fangjianEntity.setFangjianPeizhi(data.get(0));
-//                            fangjianEntity.setFangjianClicknum(Integer.valueOf(data.get(0)));   //点击次数 要改的
+                            // 设置提供的商品，此处也是错误的取值方式（取的data.get(0)），需要改成对应正确的数据获取逻辑，要改的
-//                            fangjianEntity.setFangjianContent("");//详情和图片
+                            fangjianEntity.setFangjianShangpin(data.get(0));
-//                            fangjianEntity.setCreateTime(date);//时间
+                            // 设置提供的服务，同样是取值错误（取的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")指定了该方法处理的请求路径为 /list
-    */
+            @IgnoreAuth
-    @IgnoreAuth
+            @RequestMapping("/list")
-    @RequestMapping("/list")
+            public R list (@RequestParam Map < String, Object > params, HttpServletRequest request){
-    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
+                // 使用日志记录器记录debug级别的日志信息，记录当前执行的list方法所在的类名以及传入的参数信息（将参数转为JSON字符串格式记录）
-        logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
+                logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
-
+
-        // 没有指定排序字段就默认id倒序
+                // 判断传入的参数中是否指定了排序字段，如果没有指定（即获取到的orderBy参数为空字符串）
-        if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
+                if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) {
-            params.put("orderBy","id");
+                    // 就默认按照id字段倒序排序，将orderBy参数设置为id
-        }
+                    params.put("orderBy", "id");
-        PageUtils page = fangjianService.queryPage(params);
+                }
-
+                // 调用fangjianService的queryPage方法，根据传入的参数查询并获取分页数据，存放在PageUtils对象中
-        //字典表数据转换
+                PageUtils page = fangjianService.queryPage(params);
-        List<FangjianView> list =(List<FangjianView>)page.getList();
+
-        for(FangjianView c:list)
+                // 获取分页数据中的数据列表，这里强制转换为List<FangjianView>类型，假设这个列表中的数据是需要展示在前端的房间相关视图数据
-            dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
+                List<FangjianView> list = (List<FangjianView>) page.getList();
-        return R.ok().put("data", page);
+                for (FangjianView c : list)
-    }
+                    // 循环调用dictionaryService的dictionaryConvert方法，用于对每个FangjianView对象中的对应字典表字段进行转换（可能是将字典表中的编码转换为对应的文字描述等操作），传入当前的HttpServletRequest对象可能是用于获取一些上下文相关信息等
-
+                    dictionaryService.dictionaryConvert(c, request);
-    /**
+                // 返回成功的响应给前端，并将包含处理好的分页数据的PageUtils对象放入响应中，前端可以根据此数据进行展示等操作
-    * 前端详情
+                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,"查不到数据");
             }
-    }
-
-
-    /**
-    * 前端保存
-    */
-    @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, "表中有相同数据");
+                }
+            }
+        }

minsu/minsuguanliw/src/main/java/com/controller/FangjianLiuyanController.java

@@ -1,4 +1,3 @@
-
 package com.controller;
 
 import java.io.File;
@@ -35,203 +34,281 @@ import com.alibaba.fastjson.*;
 /**
  * 房间评论/投诉
  * 后端接口
- * @author
+ * @author （这里应该是作者相关信息，但没具体内容）
- * @email
+ * @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){
+    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
-        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
+        // 记录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,"永不会进入");
+        if (false)
-        else if("用户".equals(role))
+            return R.error(511, "永不会进入");
-            params.put("yonghuId",request.getSession().getAttribute("userId"));
+            // 如果用户角色是"用户"，则将当前登录用户的ID设置到查询参数中，可能用于查询该用户相关的评论/投诉信息，限制查询范围
-        if(params.get("orderBy")==null || params.get("orderBy")==""){
+        else if ("用户".equals(role))
-            params.put("orderBy","id");
+            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<FangjianLiuyanView> list =(List<FangjianLiuyanView>)page.getList();
+        List<FangjianLiuyanView> list = (List<FangjianLiuyanView>) page.getList();
-        for(FangjianLiuyanView c:list){
+        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){
+    public R info(@PathVariable("id") Long id, HttpServletRequest request) {
-        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
+        // 记录debug级别的日志信息，记录当前执行的info方法所在的类名以及传入的评论/投诉ID参数，方便调试查看请求参数情况
+        logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
+        // 调用fangjianLiuyanService的selectById方法，根据传入的评论/投诉ID从数据库中查询对应的FangjianLiuyanEntity对象（代表评论/投诉实体数据）
         FangjianLiuyanEntity fangjianLiuyan = fangjianLiuyanService.selectById(id);
-        if(fangjianLiuyan !=null){
+        if (fangjianLiuyan!= null) {
-            //entity转view
+            // 创建一个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());
+            }
 
-                //级联表
+            // 以下是处理级联表相关的数据，获取评论/投诉对应的用户信息，并添加到视图对象中（排除一些不需要的字段，如id、创建时间等字段）
-                FangjianEntity fangjian = fangjianService.selectById(fangjianLiuyan.getFangjianId());
+            // 调用yonghuService的selectById方法，根据评论/投诉实体中关联的用户ID获取对应的YonghuEntity对象（代表用户实体数据）
-                if(fangjian != null){
+            YonghuEntity yonghu = yonghuService.selectById(fangjianLiuyan.getYonghuId());
-                    BeanUtils.copyProperties( fangjian , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
+            if (yonghu!= null) {
-                    view.setFangjianId(fangjian.getId());
+                // 使用BeanUtils工具类的copyProperties方法，将yonghu对象的部分属性值复制到view对象中（排除指定的字段），把级联的用户数据添加到视图中
-                }
+                BeanUtils.copyProperties(yonghu, view, new String[]{"id", "createTime", "insertTime", "updateTime"});
-                //级联表
+                // 设置视图对象中的用户ID，确保用户ID能正确传递给前端展示或者后续使用
-                YonghuEntity yonghu = yonghuService.selectById(fangjianLiuyan.getYonghuId());
+                view.setYonghuId(yonghu.getId());
-                if(yonghu != null){
+            }
-                    BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
+
-                    view.setYonghuId(yonghu.getId());
+            // 调用dictionaryService的dictionaryConvert方法，对转换后的FangjianLiuyanView对象中的对应字典表字段进行转换（类似前面page方法中的转换操作），传入当前的HttpServletRequest对象用于获取上下文相关信息等
-                }
-            //修改对应字典表字段
             dictionaryService.dictionaryConvert(view, request);
+            // 返回成功的响应给前端，并将包含处理好的评论/投诉详情视图数据的FangjianLiuyanView对象放入响应中，前端可以据此展示详细信息
             return R.ok().put("data", view);
-        }else {
+        } else {
-            return R.error(511,"查不到数据");
+            // 如果根据传入的ID没有查询到对应的评论/投诉数据，返回一个错误信息给前端，错误码是511，提示查不到数据
+            return R.error(511, "查不到数据");
         }
-
     }
 
     /**
-    * 后端保存
+     * 后端保存
-    */
+     * 用于保存新的房间评论/投诉信息，设置相关时间字段并插入到数据库中
+     */
     @RequestMapping("/save")
-    public R save(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request){
+    public R save(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request) {
-        logger.debug("save方法:,,Controller:{},,fangjianLiuyan:{}",this.getClass().getName(),fangjianLiuyan.toString());
+        // 记录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,"永远不会进入");
+        if (false)
-        else if("用户".equals(role))
+            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){
+    public R update(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request) {
-        logger.debug("update方法:,,Controller:{},,fangjianLiuyan:{}",this.getClass().getName(),fangjianLiuyan.toString());
+        // 记录debug级别的日志信息，记录当前执行的update方法所在的类名以及传入的FangjianLiuyanEntity对象信息（将对象转为字符串格式记录），方便调试查看请求数据情况
+        logger.debug("update方法:,,Controller:{},,fangjianLiuyan:{}", this.getClass().getName(), fangjianLiuyan.toString());
 
+        // 从当前请求的会话中获取用户角色信息，并转换为字符串类型，可能用于后续根据不同角色进行不同的数据处理逻辑判断（当前部分代码被注释掉了，可能是之前的逻辑或者后续需要调整补充的地方）
         String role = String.valueOf(request.getSession().getAttribute("role"));
-//        if(false)
+//        if (false)
-//            return R.error(511,"永远不会进入");
+//            return R.error(511, "永远不会进入");
-//        else if("用户".equals(role))
+//        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){
+        if (fangjianLiuyanEntity == null) {
-            fangjianLiuyanService.updateById(fangjianLiuyan);//根据id更新
+            // 如果查询结果为null，表示不存在相同数据的记录，调用fangjianLiuyanService的updateById方法，根据传入的评论/投诉实体对象的ID更新数据库中的对应记录
+            fangjianLiuyanService.updateById(fangjianLiuyan);
+            // 如果更新成功，返回成功的响应给前端
             return R.ok();
-        }else {
+        } else {
-            return R.error(511,"表中有相同数据");
+            // 如果查询到了相同数据的记录，返回一个错误信息给前端，错误码是511，提示表中有相同数据
+            return R.error(511, "表中有相同数据");
         }
     }
 
-
-
     /**
-    * 删除
+     * 删除
-    */
+     * 根据传入的评论/投诉ID数组，批量删除对应的评论/投诉记录
+     */
     @RequestMapping("/delete")
-    public R delete(@RequestBody Integer[] ids){
+    public R delete(@RequestBody Integer[] ids) {
-        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
+        // 记录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){
+    public R save(String fileName, HttpServletRequest request) {
-        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
+        // 记录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<>();//上传的东西
+            // 创建一个列表，用于存放从文件中读取并解析后要批量插入的FangjianLiuyanEntity对象（代表房间评论/投诉实体数据）
-            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
+            List<FangjianLiuyanEntity> fangjianLiuyanList = new ArrayList<>();
+            // 创建一个Map，用于存放要查询是否重复的字段信息（目前代码中未看到具体使用逻辑，可能需要完善，比如后续根据这些字段判断数据是否重复等）
+            Map<String, List<String>> seachFields = new HashMap<>();
+            // 获取当前系统时间，可能用于设置评论/投诉信息的相关时间字段
             Date date = new Date();
+            // 获取文件名中最后一个点的索引位置，用于判断文件后缀名
             int lastIndexOf = fileName.lastIndexOf(".");
-            if(lastIndexOf == -1){
+            if (lastIndexOf == -1) {
-                return R.error(511,"该文件没有后缀");
+                // 如果没有找到点（即没有后缀名），返回一个错误信息给前端，错误码是511，提示该文件没有后缀
-            }else{
+                return R.error(511, "该文件没有后缀");
+            } else {
+                // 获取文件名中最后一个点（.）之后的后缀部分，用于后续判断文件类型是否符合要求
                 String suffix = fileName.substring(lastIndexOf);
-                if(!".xls".equals(suffix)){
+// 判断后缀名是否不等于 ".xls"，如果不是该后缀的文件，说明不符合当前方法支持的文件类型要求
-                    return R.error(511,"只支持后缀为xls的excel文件");
+                if (!".xls".equals(suffix)) {
-                }else{
+                    // 返回一个错误信息给前端，错误码是511，并提示只支持后缀为xls的excel文件，告知前端操作不符合要求
-                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
+                    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,"找不到上传文件，请联系管理员");
+                    if (!file.exists()) {
-                    }else{
+                        // 返回一个错误信息给前端，错误码是511，提示找不到上传文件，并告知前端联系管理员来解决该问题
-                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
+                        return R.error(511, "找不到上传文件，请联系管理员");
-                        dataList.remove(0);//删除第一行，因为第一行是提示
+                    } else {
-                        for(List<String> data:dataList){
+                        // 调用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对象的各个属性值，但目前都是设置为固定值或者取了错误的数据索引（都取的data.get(0)），后续应该根据实际Excel文件中数据的列顺序修改正确的获取数据的索引和赋值逻辑
-//                            fangjianLiuyanEntity.setYonghuId(Integer.valueOf(data.get(0)));   //用户 要改的
+                            // 设置房间ID，此处应该根据实际Excel文件中房间ID所在列的索引来获取正确的值，当前写法有误（都取的data.get(0)），要改的
-//                            fangjianLiuyanEntity.setFangjianLiuyanText(data.get(0));                    //评论/投诉内容 要改的
+                            fangjianLiuyanEntity.setFangjianId(Integer.valueOf(data.get(0)));
-//                            fangjianLiuyanEntity.setReplyText(data.get(0));                    //回复内容 要改的
+                            // 设置用户ID，同样这里取值有误（取的data.get(0)），应该按实际Excel文件中用户ID所在列来获取对应数据，要改的
-//                            fangjianLiuyanEntity.setInsertTime(date);//时间
+                            fangjianLiuyanEntity.setYonghuId(Integer.valueOf(data.get(0)));
-//                            fangjianLiuyanEntity.setUpdateTime(sdf.parse(data.get(0)));          //回复时间 要改的
+                            // 设置评论/投诉内容，也是错误的取值方式（取的data.get(0)），需要改成对应正确的数据获取逻辑，要改的
-//                            fangjianLiuyanEntity.setCreateTime(date);//时间
+                            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
+        // 前端列表相关的方法，被标注了 @IgnoreAuth 表示这个方法不需要进行权限认证，通过@RequestMapping("/list")指定了该方法处理的请求路径为 /list，用于获取房间评论/投诉信息的分页列表数据并返回给前端展示
-    @RequestMapping("/list")
+        @IgnoreAuth
-    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
+        @RequestMapping("/list")
-        logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
+        public R list(@RequestParam Map<String, Object> params, HttpServletRequest request) {
-
+            // 使用日志记录器记录debug级别的日志信息，记录当前执行的list方法所在的类名以及传入的参数信息（将参数转为JSON字符串格式记录），方便调试查看请求参数情况
-        // 没有指定排序字段就默认id倒序
+            logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
-        if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
+
-            params.put("orderBy","id");
+            // 判断传入的参数中是否指定了排序字段，如果没有指定（即获取到的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}")
+        // 前端详情相关的方法，通过@RequestMapping("/detail/{id}")指定了该方法处理的请求路径为 /detail/{id}，其中{id}是一个路径变量，表示要查询详情的房间评论/投诉的唯一标识，用于获取指定评论/投诉的详细信息并返回给前端展示
-    public R detail(@PathVariable("id") Long id, HttpServletRequest request){
+        @RequestMapping("/detail/{id}")
-        logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
+        public R detail(@PathVariable("id") Long id, HttpServletRequest request) {
-        FangjianLiuyanEntity fangjianLiuyan = fangjianLiuyanService.selectById(id);
+            // 使用日志记录器记录debug级别的日志信息，记录当前执行的detail方法所在的类名以及传入的评论/投诉ID参数，方便调试查看请求参数情况
-            if(fangjianLiuyan !=null){
+            logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
-
+            // 调用fangjianLiuyanService的selectById方法，根据传入的评论/投诉ID从数据库中查询对应的FangjianLiuyanEntity对象（代表评论/投诉实体数据）
-
+            FangjianLiuyanEntity fangjianLiuyan = fangjianLiuyanService.selectById(id);
-                //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、创建时间等字段）
-                    FangjianEntity fangjian = fangjianService.selectById(fangjianLiuyan.getFangjianId());
+                // 调用fangjianService的selectById方法，根据评论/投诉实体中关联的房间ID获取对应的FangjianEntity对象（代表房间实体数据）
-                if(fangjian != null){
+                FangjianEntity fangjian = fangjianService.selectById(fangjianLiuyan.getFangjianId());
-                    BeanUtils.copyProperties( fangjian , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
+                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());
+                // 以下是处理级联表相关的数据，获取评论/投诉对应的用户信息，并添加到视图对象中（排除一些不需要的字段，如id、创建时间等字段）
-                if(yonghu != null){
+                // 调用yonghuService的selectById方法，根据评论/投诉实体中关联的用户ID获取对应的YonghuEntity对象（代表用户实体数据）
-                    BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
+                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 {
+            } else {
-                return R.error(511,"查不到数据");
+                // 如果根据传入的ID没有查询到对应的评论/投诉数据，返回一个错误信息给前端，错误码是511，提示查不到数据，告知前端请求的详情数据不存在
+                return R.error(511, "查不到数据");
             }
-    }
+        }
 
 
     /**
     * 前端保存
     */
-    @RequestMapping("/add")
+        // 前端保存相关的方法，通过@RequestMapping("/add")指定了该方法处理的请求路径为 /add，并且使用@RequestBody注解表示接收前端传来的JSON格式的请求体数据，并将其转换为FangjianLiuyanEntity对象，用于保存新的房间评论/投诉信息到数据库中
-    public R add(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request){
+        @RequestMapping("/add")
-        logger.debug("add方法:,,Controller:{},,fangjianLiuyan:{}",this.getClass().getName(),fangjianLiuyan.toString());
+        public R add(@RequestBody FangjianLiuyanEntity fangjianLiuyan, HttpServletRequest request) {
-        fangjianLiuyan.setInsertTime(new Date());
+            // 使用日志记录器记录debug级别的日志信息，记录当前执行的add方法所在的类名以及传入的FangjianLiuyanEntity对象信息（将对象转为字符串格式记录），方便调试查看请求数据情况
-        fangjianLiuyan.setCreateTime(new Date());
+            logger.debug("add方法:,,Controller:{},,fangjianLiuyan:{}", this.getClass().getName(), fangjianLiuyan.toString());
-        fangjianLiuyanService.insert(fangjianLiuyan);
+            // 设置评论/投诉信息的插入时间为当前系统时间，用于记录该评论/投诉的创建时间，确定其插入数据库时的时间点
-        return R.ok();
+            fangjianLiuyan.setInsertTime(new Date());
+            // 设置评论/投诉信息的创建时间为当前系统时间，与插入时间在业务上可能有不同含义（具体看业务需求），这里统一设置为当前时间
+            fangjianLiuyan.setCreateTime(new Date());
+            // 调用fangjianLiuyanService的insert方法，将当前的FangjianLiuyanEntity对象插入到数据库中，实现保存新评论/投诉信息的功能
+            fangjianLiuyanService.insert(fangjianLiuyan);
+            // 如果插入操作成功，返回一个表示成功的响应给前端，告知前端数据已成功保存
+            return R.ok();
         }
-
-
-}

minsu/minsuguanliw/src/main/java/com/controller/FangjianOrderController.java

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

minsu/minsuguanliw/src/main/java/com/controller/ForumController.java

@@ -1,4 +1,3 @@
-
 package com.controller;
 
 import java.io.File;
@@ -35,315 +34,305 @@ import com.alibaba.fastjson.*;
 /**
  * 论坛
  * 后端接口
- * @author
+ * 该类主要作为论坛相关功能的控制层，处理各种与论坛业务相关的HTTP请求，调用对应的服务层方法来实现具体功能，
+ * 并与数据库进行交互以及处理返回结果等操作。
+ * @author  WMZ
  * @email
-*/
+ */
 @RestController
 @Controller
 @RequestMapping("/forum")
 public class ForumController {
+    // 创建日志记录器，
+    // 用于记录该类中各个方法执行过程中的关键信息，方便调试和问题排查
     private static final Logger logger = LoggerFactory.getLogger(ForumController.class);
 
+    // 通过Spring的依赖注入，自动装配ForumService，
+    // 用于处理论坛相关的业务逻辑，比如查询、插入、更新、删除等操作
     @Autowired
     private ForumService forumService;
 
-
+    // 自动注入TokenService，
+    // 可能用于处理用户认证相关的令牌操作（具体功能需看对应服务层实现）
     @Autowired
     private TokenService tokenService;
+    // 自动注入DictionaryService，
+    // 用于处理字典表相关的数据转换等操作（比如将字典表中的编码转换为对应的有意义的值等）
     @Autowired
     private DictionaryService dictionaryService;
 
-    //级联表service
+    // 自动注入YonghuService，
+    // 用于处理与用户（Yonghu，可能是具体业务中的一种用户类型）相关的级联表操作
     @Autowired
     private YonghuService yonghuService;
+    // 自动注入UsersService，
+    // 用于处理与普通用户相关的级联表操作（比如获取用户详细信息等）
     @Autowired
     private UsersService usersService;
 
-
-
     /**
-    * 后端列表
+     * 后端列表功能方法
-    */
+     * 接收前端传来的查询参数params以及HttpServletRequest对象，用于获取分页数据以及进行相关业务逻辑处理，
+     * 根据参数查询论坛信息列表，并进行字典表数据转换后返回给前端。
+     * @param params 包含查询条件、分页等相关参数的Map集合
+     * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的属性等）
+     * @return R类型的结果对象，包含操作结果状态以及查询到的数据等信息（R应该是自定义的统一返回结果类型）
+     */
     @RequestMapping("/page")
-    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
+    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
-        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
+        // 记录page方法的调用信息，
-        if(params.get("orderBy")==null || params.get("orderBy")==""){
+        // 包括当前类名和传入的参数，
-            params.put("orderBy","id");
+        // 方便调试查看参数情况（以JSON字符串形式记录参数）
+        logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
+        // 如果传入的排序字段参数为空，
+        // 则默认按照"id"字段进行排序
+        if (params.get("orderBy") == null || params.get("orderBy") == "") {
+            params.put("orderBy", "id");
         }
+        // 调用forumService的queryPage方法，
+        // 根据传入的参数获取分页数据（该方法内部应该是与数据库交互获取相应的数据列表等）
         PageUtils page = forumService.queryPage(params);
 
-        //字典表数据转换
+        // 获取分页数据中的列表数据
-        List<ForumView> list =(List<ForumView>)page.getList();
+        // （这里应该是ForumView类型的列表，ForumView可能是用于展示的视图对象）
-        for(ForumView c:list){
+        List<ForumView> list = (List<ForumView>) page.getList();
-            //修改对应字典表字段
+        // 遍历列表数据，
+        // 对每条数据进行字典表数据转换操作（比如将字典表中的编码转换为对应的实际含义显示给前端）
+        for (ForumView c : list) {
             dictionaryService.dictionaryConvert(c, request);
         }
+        // 返回包含处理后数据的成功结果对象
+        // （R.ok()表示操作成功，并将数据放入返回对象中返回给前端）
         return R.ok().put("data", page);
     }
 
     /**
-    * 后端详情
+     * 后端详情功能方法
-    */
+     * 根据传入的论坛记录id，从数据库中查询对应的论坛详细信息，
+     * 进行相关的实体转视图、级联表数据处理以及字典表数据转换后返回给前端。
+     * @param id 要查询的论坛记录的唯一标识（Long类型的id）
+     * @param request HttpServletRequest对象，
+     *                用于获取请求相关的信息（如会话中的属性等）
+     * @return R类型的结果对象，
+     * 包含操作结果状态以及查询到的详细数据等信息（若查询到数据则返回成功及数据，否则返回错误提示）
+     */
     @RequestMapping("/info/{id}")
-    public R info(@PathVariable("id") Long id, HttpServletRequest request){
+    public R info(@PathVariable("id") Long id, HttpServletRequest request) {
-        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
+        logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
+        // 通过forumService根据传入的id从数据库中查询对应的ForumEntity对象（ForumEntity可能是数据库对应的实体类）
         ForumEntity forum = forumService.selectById(id);
-        if(forum !=null){
+        if (forum!= null) {
-            //entity转view
+            // 创建ForumView对象，
+            // 用于将查询到的实体数据转换为适合展示的视图数据（ForumView可能包含了部分需要展示给前端的字段等）
             ForumView view = new ForumView();
-            BeanUtils.copyProperties( forum , view );//把实体数据重构到view中
+            // 使用Spring的BeanUtils工具，
-
+            // 将forum实体对象中的属性值复制到view视图对象中
-                //级联表
+            BeanUtils.copyProperties(forum, view);
-                YonghuEntity yonghu = yonghuService.selectById(forum.getYonghuId());
+
-                if(yonghu != null){
+            // 处理级联表数据，
-                    BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
+            // 获取与该论坛记录关联的YonghuEntity（用户相关的实体对象），并将部分属性复制到view中（排除一些不需要的字段）
-                    view.setYonghuId(yonghu.getId());
+            YonghuEntity yonghu = yonghuService.selectById(forum.getYonghuId());
-                }
+            if (yonghu!= null) {
-                //管理员用户表做特殊处理,防止和用户表账户姓名字段冲突
+                BeanUtils.copyProperties(yonghu, view, new String[] { "id", "createTime", "insertTime", "updateTime" });
-                UsersEntity users = usersService.selectById(forum.getUsersId());
+                view.setYonghuId(yonghu.getId());
-                if(users != null){
+            }
-                    view.setUsersId(users.getId());
+            // 处理管理员用户表数据，
-                    view.setUusername(users.getUsername());
+            // 获取与该论坛记录关联的UsersEntity（管理员用户相关的实体对象），并将部分关键属性设置到view中
-                    view.setUpassword(users.getPassword());
+            UsersEntity users = usersService.selectById(forum.getUsersId());
-                    view.setUrole(users.getRole());
+            if (users!= null) {
-                    view.setUaddtime(users.getAddtime());
+                view.setUsersId(users.getId());
-                }
+                view.setUusername(users.getUsername());
-            //修改对应字典表字段
+                view.setUpassword(users.getPassword());
+                view.setUrole(users.getRole());
+                view.setUaddtime(users.getAddtime());
+            }
+            // 对view视图对象进行字典表数据转换操作
+            // （比如将字典表中的编码转换为对应的实际含义显示给前端）
             dictionaryService.dictionaryConvert(view, request);
+            // 返回包含处理后详细数据的成功结果对象（R.ok()表示操作成功，
+            // 并将数据放入返回对象中返回给前端）
             return R.ok().put("data", view);
-        }else {
+        } else {
-            return R.error(511,"查不到数据");
+            // 如果未查询到对应的数据，
+            // 则返回包含错误码和错误提示信息的错误结果对象
+            return R.error(511, "查不到数据");
         }
-
     }
 
     /**
-    * 后端保存
+     * 后端保存功能方法
-    */
+     * 接收前端传来的ForumEntity对象（包含要保存的论坛相关数据）以及HttpServletRequest对象，
+     * 根据当前用户角色设置相关的关联用户id，并检查数据是否重复后将数据插入到数据库中。
+     * @param forum 包含要保存的论坛相关数据的ForumEntity对象
+     * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的用户角色、用户id等属性）
+     * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息）
+     */
     @RequestMapping("/save")
-    public R save(@RequestBody ForumEntity forum, HttpServletRequest request){
+    public R save(@RequestBody ForumEntity forum, HttpServletRequest request) {
-        logger.debug("save方法:,,Controller:{},,forum:{}",this.getClass().getName(),forum.toString());
+        logger.debug("save方法:,,Controller:{},,forum:{}", this.getClass().getName(), forum.toString());
 
+        // 从HttpServletRequest的会话中获取当前用户的角色信息（这里先将获取到的Object类型强制转换为String类型）
         String role = String.valueOf(request.getSession().getAttribute("role"));
-        if(false)
+        if (false)
-            return R.error(511,"永远不会进入");
+            return R.error(511, "永远不会进入");
-        else if("用户".equals(role))
+        else if ("用户".equals(role))
+            // 如果当前用户角色是"用户"，
+            // 则将论坛记录的YonghuId设置为从会话中获取的当前用户的id（这里做了一些类型转换操作）
             forum.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
-        else if("管理员".equals(role))
+        else if ("管理员".equals(role))
+            // 如果当前用户角色是"管理员"，
+            // 则将论坛记录的UsersId设置为从会话中获取的当前用户的id（同样进行了类型转换）
             forum.setUsersId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
 
+        // 创建EntityWrapper对象，
+        // 用于构建查询条件，检查数据库中是否已经存在相同的数据（根据多个字段进行等值判断）
         Wrapper<ForumEntity> queryWrapper = new EntityWrapper<ForumEntity>()
-            .eq("forum_name", forum.getForumName())
+                .eq("forum_name", forum.getForumName())
-            .eq("yonghu_id", forum.getYonghuId())
+                .eq("yonghu_id", forum.getYonghuId())
-            .eq("users_id", forum.getUsersId())
+                .eq("users_id", forum.getUsersId())
-            .eq("super_ids", forum.getSuperIds())
+                .eq("super_ids", forum.getSuperIds())
-            .eq("forum_state_types", forum.getForumStateTypes())
+                .eq("forum_state_types", forum.getForumStateTypes());
-            ;
+
-
+        logger.info("sql语句:" + queryWrapper.getSqlSegment());
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
+        // 根据构建的查询条件查询数据库中是否已经存在相同的数据
+        // （通过selectOne方法查询一条符合条件的数据）
         ForumEntity forumEntity = forumService.selectOne(queryWrapper);
-        if(forumEntity==null){
+        if (forumEntity == null) {
+            // 如果不存在相同数据，
+            // 则设置论坛记录的插入时间和创建时间为当前时间，并将该记录插入到数据库中（通过insert方法）
             forum.setInsertTime(new Date());
             forum.setCreateTime(new Date());
             forumService.insert(forum);
             return R.ok();
-        }else {
+        } else {
-            return R.error(511,"表中有相同数据");
+            // 如果存在相同数据，
+            // 则返回包含错误码和提示信息的错误结果对象，表示表中已有相同数据
+            return R.error(511, "表中有相同数据");
         }
     }
 
     /**
-    * 后端修改
+     * 后端修改功能方法
-    */
+     * 接收前端传来的ForumEntity对象（包含要修改的论坛相关数据）以及HttpServletRequest对象，
+     * 根据字段查询是否有相同数据，若不存在则根据id更新数据库中的对应论坛记录。
+     * @param forum 包含要修改的论坛相关数据的ForumEntity对象
+     * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的用户角色等属性）
+     * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息）
+     */
     @RequestMapping("/update")
-    public R update(@RequestBody ForumEntity forum, HttpServletRequest request){
+    public R update(@RequestBody ForumEntity forum, HttpServletRequest request) {
-        logger.debug("update方法:,,Controller:{},,forum:{}",this.getClass().getName(),forum.toString());
+        logger.debug("update方法:,,Controller:{},,forum:{}", this.getClass().getName(), forum.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))
 //            forum.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
-//        else if("管理员".equals(role))
+//        else if ("管理员".equals(role))
 //            forum.setUsersId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
-        //根据字段查询是否有相同数据
+        // 创建EntityWrapper对象，用于构建查询条件，检查数据库中除了当前要修改的记录（根据id排除）外是否存在相同的数据（根据多个字段进行等值判断）
+
         Wrapper<ForumEntity> queryWrapper = new EntityWrapper<ForumEntity>()
-            .notIn("id",forum.getId())
+                .notIn("id", forum.getId())
-            .andNew()
+                .andNew()
-            .eq("forum_name", forum.getForumName())
+                .eq("forum_name", forum.getForumName())
-            .eq("yonghu_id", forum.getYonghuId())
+                .eq("yonghu_id", forum.getYonghuId())
-            .eq("users_id", forum.getUsersId())
+                .eq("users_id", forum.getUsersId())
-            .eq("super_ids", forum.getSuperIds())
+                .eq("super_ids", forum.getSuperIds())
-            .eq("forum_state_types", forum.getForumStateTypes())
+                .eq("forum_state_types", forum.getForumStateTypes());
-            ;
+
-
+
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
+        logger.info("sql语句:" + queryWrapper.getSqlSegment());
+        // 根据构建的查询条件查询数据库中是否已经存在相同的数据（通过selectOne方法查询一条符合条件的数据）
+
         ForumEntity forumEntity = forumService.selectOne(queryWrapper);
+        // 设置论坛记录的更新时间为当前时间
+
+
+
         forum.setUpdateTime(new Date());
-        if(forumEntity==null){
+        if (forumEntity == null) {
-            forumService.updateById(forum);//根据id更新
+            // 如果不存在相同数据，
+            // 则根据传入的forum对象的id更新数据库中的对应论坛记录（通过updateById方法）
+            forumService.updateById(forum);
             return R.ok();
-        }else {
+        } else {
-            return R.error(511,"表中有相同数据");
+            // 如果存在相同数据，
+            // 则返回包含错误码和提示信息的错误结果对象，表示表中已有相同数据
+            return R.error(511, "表中有相同数据");
         }
     }
 
 
 
-    /**
+   /**
-    * 删除
+     * 删除功能方法
-    */
+     * 接收前端传来的要删除的论坛记录的id数组，调用forumService的批量删除方法，从数据库中删除对应的数据记录，
+     * 并返回操作结果给前端。
+     * @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) {
+        logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
+        // 调用forumService的deleteBatchIds方法，
+        // 批量删除数据库中对应id的论坛记录（传入的是将数组转换为List后的集合）
         forumService.deleteBatchIds(Arrays.asList(ids));
         return R.ok();
     }
 
-
     /**
-     * 批量上传
+     * 批量上传功能方法
+     * 接收文件名fileName以及HttpServletRequest对象，用于将指定的Excel文件中的论坛数据批量插入到数据库中，
+     * 在插入前进行一些文件格式校验、数据读取以及重复数据检查等操作。
+     * @param fileName 要上传的文件的名称（这里应该是位于特定目录下的文件名）
+     * @param request HttpServletRequest对象，用于获取请求相关的信息（如当前用户的id等属性）
+     * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息）
      */
+
+
     @RequestMapping("/batchInsert")
-    public R save( String fileName, HttpServletRequest request){
+    public R save(String fileName, HttpServletRequest request) {
-        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
+        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
+        // 从HttpServletRequest的会话中获取当前用户的id，并转换为Integer类型（这里做了一些强制类型转换操作）
         Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         try {
-            List<ForumEntity> forumList = new ArrayList<>();//上传的东西
+            // 创建一个用于存储要插入数据库的ForumEntity对象列表（即从文件中读取到的多条论坛数据记录）
-            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
+            List<ForumEntity> forumList = new ArrayList<>();
+            // 创建一个Map，用于存储要查询是否重复的字段信息（具体的使用方式需看后续代码逻辑）
+            Map<String, List<String>> seachFields = new HashMap<>();
             Date date = new Date();
             int lastIndexOf = fileName.lastIndexOf(".");
-            if(lastIndexOf == -1){
+            if (lastIndexOf == -1) {
-                return R.error(511,"该文件没有后缀");
+                return R.error(511, "该文件没有后缀");
-            }else{
+            } else {
                 String suffix = fileName.substring(lastIndexOf);
-                if(!".xls".equals(suffix)){
+                if (!".xls".equals(suffix)) {
-                    return R.error(511,"只支持后缀为xls的excel文件");
+                    return R.error(511, "只支持后缀为xls的excel文件");
-                }else{
+                } else {
-                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
+                    // 通过类加载器获取指定文件名对应的文件资源路径（这里应该是位于"static/upload/"目录下的文件）
+                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
                     File file = new File(resource.getFile());
-                    if(!file.exists()){
+                    if (!file.exists()) {
-                        return R.error(511,"找不到上传文件，请联系管理员");
+                        return R.error(511, "找不到上传文件，请联系管理员");
-                    }else{
+                    } else {
-                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
+                        // 调用PoiUtil的poiImport方法读取Excel文件中的数据（返回的是一个嵌套的List，外层List表示行，内层List表示每行中的单元格数据）
-                        dataList.remove(0);//删除第一行，因为第一行是提示
+                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());
-                        for(List<String> data:dataList){
+                        // 删除读取到的数据列表中的第一行（可能是表头之类的提示信息，不需要插入数据库）
-                            //循环
+                        dataList.remove(0);
+                        for (List<String> data : dataList) {
+                            // 循环处理每一行数据，创建一个ForumEntity对象，用于存储要插入数据库的一条论坛记录信息
                             ForumEntity forumEntity = new ForumEntity();
 //                            forumEntity.setForumName(data.get(0));                    //帖子标题 要改的
 //                            forumEntity.setYonghuId(Integer.valueOf(data.get(0)));   //用户 要改的
 //                            forumEntity.setUsersId(Integer.valueOf(data.get(0)));   //管理员 要改的
 //                            forumEntity.setForumContent("");//详情和图片
 //                            forumEntity.setSuperIds(Integer.valueOf(data.get(0)));   //父id 要改的
-//                            forumEntity.setForumStateTypes(Integer.valueOf(data.get(0)));   //帖子状态 要改的
+//                            forumEntity.setForumStateTypes(Integer.valueOf(data.get(0)));   //帖子状态 要改的
-//                            forumEntity.setInsertTime(date);//时间
-//                            forumEntity.setUpdateTime(sdf.parse(data.get(0)));          //修改时间 要改的
-//                            forumEntity.setCreateTime(date);//时间
-                            forumList.add(forumEntity);
-
-
-                            //把要查询是否重复的字段放入map中
-                        }
-
-                        //查询是否重复
-                        forumService.insertBatch(forumList);
-                        return R.ok();
-                    }
-                }
-            }
-        }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 = forumService.queryPage(params);
-
-        //字典表数据转换
-        List<ForumView> list =(List<ForumView>)page.getList();
-        for(ForumView 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);
-        ForumEntity forum = forumService.selectById(id);
-            if(forum !=null){
-
-
-                //entity转view
-                ForumView view = new ForumView();
-                BeanUtils.copyProperties( forum , view );//把实体数据重构到view中
-
-                //级联表
-                    YonghuEntity yonghu = yonghuService.selectById(forum.getYonghuId());
-                if(yonghu != null){
-                    BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
-                    view.setYonghuId(yonghu.getId());
-                }
-                    UsersEntity users = usersService.selectById(forum.getUsersId());
-                if(users != null){
-                    view.setUsersId(users.getId());
-                    view.setUusername(users.getUsername());
-                    view.setUpassword(users.getPassword());
-                    view.setUrole(users.getRole());
-                    view.setUaddtime(users.getAddtime());
-                }
-                //修改对应字典表字段
-                dictionaryService.dictionaryConvert(view, request);
-                return R.ok().put("data", view);
-            }else {
-                return R.error(511,"查不到数据");
-            }
-    }
-
-
-    /**
-    * 前端保存
-    */
-    @RequestMapping("/add")
-    public R add(@RequestBody ForumEntity forum, HttpServletRequest request){
-        logger.debug("add方法:,,Controller:{},,forum:{}",this.getClass().getName(),forum.toString());
-        Wrapper<ForumEntity> queryWrapper = new EntityWrapper<ForumEntity>()
-            .eq("forum_name", forum.getForumName())
-            .eq("yonghu_id", forum.getYonghuId())
-            .eq("users_id", forum.getUsersId())
-            .eq("super_ids", forum.getSuperIds())
-            .eq("forum_state_types", forum.getForumStateTypes())
-            ;
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
-        ForumEntity forumEntity = forumService.selectOne(queryWrapper);
-        if(forumEntity==null){
-            forum.setInsertTime(new Date());
-            forum.setCreateTime(new Date());
-        forumService.insert(forum);
-            return R.ok();
-        }else {
-            return R.error(511,"表中有相同数据");
-        }
-    }
-
-
-}

minsu/minsuguanliw/src/main/java/com/controller/NewsController.java

@@ -1,4 +1,3 @@
-
 package com.controller;
 
 import java.io.File;
@@ -35,178 +34,273 @@ import com.alibaba.fastjson.*;
 /**
  * 公告信息
  * 后端接口
- * @author
+ * 该类作为公告信息相关功能的控制层，负责接收前端发送的各种HTTP请求，
- * @email
+ * 调用对应的服务层方法来处理公告信息的查询、保存、修改、删除以及批量上传等业务操作，
-*/
+ * 并与数据库进行交互，对返回结果进行相应处理后返回给前端。
+ * @author wangmuzi
+ *
+ */
 @RestController
 @Controller
 @RequestMapping("/news")
 public class NewsController {
+    // 创建一个日志记录器，用于记录该类中各个方法执行过程中的关键信息，方便后续调试和问题排查
     private static final Logger logger = LoggerFactory.getLogger(NewsController.class);
 
+    // 通过Spring的依赖注入，
+    // 自动装配NewsService，用于处理公告信息相关的核心业务逻辑，比如数据库操作等
     @Autowired
     private NewsService newsService;
 
-
+    // 自动注入TokenService，
+    // 可能用于处理与用户认证令牌相关的操作（具体功能需看对应服务层实现）
     @Autowired
     private TokenService tokenService;
+    // 自动注入DictionaryService，
+    // 用于处理字典表数据的转换操作，例如将字典表中的编码转换为有实际意义的展示值
     @Autowired
     private DictionaryService dictionaryService;
 
-    //级联表service
+    // 自动注入YonghuService，
-
+    // 可能用于处理与用户（Yonghu，可能是特定业务中的一种用户类型）相关的级联表操作（具体使用场景看后续代码逻辑）
     @Autowired
     private YonghuService yonghuService;
 
-
     /**
-    * 后端列表
+     * 后端列表功能方法
-    */
+     * 接收前端传来的查询参数以及HttpServletRequest对象，根据用户角色添加相应查询条件，获取公告信息的分页列表数据，
+     * 并对字典表相关字段进行数据转换后返回给前端。
+     * @param params 包含查询条件、分页等相关参数的Map集合，例如每页显示数量、页码、排序字段等
+     * @param request HttpServletRequest对象，用于获取请求相关的信息，如当前用户的角色、用户ID等，以便添加特定的查询条件
+     * @return R类型的结果对象，包含操作结果状态以及查询到的分页数据等信息（R应该是自定义的统一返回结果类型）
+     */
     @RequestMapping("/page")
-    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
+    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
-        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
+        // 记录page方法的调用信息，
+        // 包括当前类名和传入的参数（将参数转换为JSON字符串形式记录，方便查看参数详情），用于调试目的
+        logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
+        // 从HttpServletRequest的会话中获取当前用户的角色信息，
+        // 并转换为String类型
         String role = String.valueOf(request.getSession().getAttribute("role"));
-        if(false)
+        if (false)
-            return R.error(511,"永不会进入");
+            return R.error(511, "永不会进入");
-        else if("用户".equals(role))
+        else if ("用户".equals(role))
-            params.put("yonghuId",request.getSession().getAttribute("userId"));
+            // 如果当前用户角色是"用户"，
-        if(params.get("orderBy")==null || params.get("orderBy")==""){
+            // 则将当前用户的ID添加到查询参数中，作为查询属于该用户的公告信息的条件（这里假设数据库中有对应的关联字段）
-            params.put("orderBy","id");
+            params.put("yonghuId", request.getSession().getAttribute("userId"));
+        // 如果传入的排序字段参数为空，则默认按照"id"字段进行排序
+        if (params.get("orderBy") == null || params.get("orderBy") == "") {
+            params.put("orderBy", "id");
         }
+        // 调用newsService的queryPage方法，
+        // 根据传入的参数获取公告信息的分页数据（该方法内部应该是与数据库交互来查询相应的数据列表等）
         PageUtils page = newsService.queryPage(params);
 
-        //字典表数据转换
+        // 获取分页数据中的列表数据（这里应该是NewsView类型的列表，NewsView可能是用于展示的视图对象）
-        List<NewsView> list =(List<NewsView>)page.getList();
+        List<NewsView> list = (List<NewsView>) page.getList();
-        for(NewsView c:list){
+        // 遍历列表数据，对每条数据进行字典表数据转换操作，
-            //修改对应字典表字段
+        // 将字典表中的编码等转换为对应的实际展示值（比如状态码转换为具体的状态文字描述）
+        for (NewsView c : list) {
             dictionaryService.dictionaryConvert(c, request);
         }
+        // 返回包含处理后数据的成功结果对象（R.ok()表示操作成功，
+        // 并将数据放入返回对象中返回给前端）
         return R.ok().put("data", page);
     }
 
     /**
-    * 后端详情
+     * 后端详情功能方法
-    */
+     * 根据传入的公告信息记录的id，从数据库中查询对应的详细信息，进行实体转视图操作以及字典表数据转换后返回给前端。
+     * @param id 要查询的公告信息记录的唯一标识（Long类型的id）
+     * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的属性等），可能在字典表数据转换时会用到
+     * @return R类型的结果对象，包含操作结果状态以及查询到的详细数据等信息（若查询到数据则返回成功及数据，否则返回错误提示）
+     */
     @RequestMapping("/info/{id}")
-    public R info(@PathVariable("id") Long id, HttpServletRequest request){
+    public R info(@PathVariable("id") Long id, HttpServletRequest request) {
-        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
+        logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
+        // 通过newsService根据传入的id从数据库中查询对应的NewsEntity对象（NewsEntity可能是数据库对应的实体类）
         NewsEntity news = newsService.selectById(id);
-        if(news !=null){
+        if (news!= null) {
-            //entity转view
+            // 创建NewsView对象，
+            // 用于将查询到的实体数据转换为适合展示的视图数据（NewsView可能包含了部分需要展示给前端的字段等）
             NewsView view = new NewsView();
-            BeanUtils.copyProperties( news , view );//把实体数据重构到view中
+            // 使用Spring的BeanUtils工具，
+            // 将news实体对象中的属性值复制到view视图对象中，实现实体转视图的基本数据复制
+            BeanUtils.copyProperties(news, view);
 
-            //修改对应字典表字段
+            // 对view视图对象进行字典表数据转换操作，
+            // 将字典表相关字段转换为有实际意义的展示值（比如将类型编码转换为类型名称等）
             dictionaryService.dictionaryConvert(view, request);
+            // 返回包含处理后详细数据的成功结果对象（R.ok()表示操作成功，
+            // 并将数据放入返回对象中返回给前端）
             return R.ok().put("data", view);
-        }else {
+        } else {
-            return R.error(511,"查不到数据");
+            // 如果未查询到对应的数据，
+            // 则返回包含错误码和错误提示信息的错误结果对象
+            return R.error(511, "查不到数据");
         }
-
     }
 
     /**
-    * 后端保存
+     * 后端保存功能方法
-    */
+     * 接收前端传来的NewsEntity对象（包含要保存的公告信息相关数据）以及HttpServletRequest对象，
+     * 检查数据是否重复后将数据插入到数据库中。
+     * @param news 包含要保存的公告信息相关数据的NewsEntity对象，包含如公告名称、类型等各种属性信息
+     * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的用户角色等属性），不过此处暂时未体现更多使用场景
+     * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息）
+     */
     @RequestMapping("/save")
-    public R save(@RequestBody NewsEntity news, HttpServletRequest request){
+    public R save(@RequestBody NewsEntity news, HttpServletRequest request) {
-        logger.debug("save方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString());
+        logger.debug("save方法:,,Controller:{},,news:{}", this.getClass().getName(), news.toString());
 
         String role = String.valueOf(request.getSession().getAttribute("role"));
-        if(false)
+        if (false)
-            return R.error(511,"永远不会进入");
+            return R.error(511, "永远不会进入");
 
+        // 创建EntityWrapper对象，用于构建查询条件，
+        // 检查数据库中是否已经存在相同的公告信息（根据公告名称和公告类型等字段进行等值判断）
         Wrapper<NewsEntity> queryWrapper = new EntityWrapper<NewsEntity>()
-            .eq("news_name", news.getNewsName())
+                .eq("news_name", news.getNewsName())
-            .eq("news_types", news.getNewsTypes())
+                .eq("news_types", news.getNewsTypes());
-            ;
 
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
+        logger.info("sql语句:" + queryWrapper.getSqlSegment());
+        // 根据构建的查询条件查询数据库中是否已经存在相同的数据（通过selectOne方法查询一条符合条件的数据）
         NewsEntity newsEntity = newsService.selectOne(queryWrapper);
-        if(newsEntity==null){
+        if (newsEntity == null) {
+            // 如果不存在相同数据，则设置公告信息的插入时间和创建时间为当前时间，
+            // 并将该公告信息插入到数据库中（通过insert方法）
             news.setInsertTime(new Date());
             news.setCreateTime(new Date());
             newsService.insert(news);
             return R.ok();
-        }else {
+        } else {
-            return R.error(511,"表中有相同数据");
+            // 如果存在相同数据，则返回包含错误码和提示信息的错误结果对象，表示表中已有相同数据
+            return R.error(511, "表中有相同数据");
         }
     }
 
     /**
-    * 后端修改
+     * 后端修改功能方法
-    */
+     * 接收前端传来的NewsEntity对象（包含要修改的公告信息相关数据）以及HttpServletRequest对象，
+     * 根据字段查询是否有相同数据，若不存在则根据id更新数据库中的对应公告信息记录，同时对图片字段进行空值处理。
+     * @param news 包含要修改的公告信息相关数据的NewsEntity对象，包含如公告名称、类型、图片等各种属性信息，且部分属性可能已被修改
+     * @param request HttpServletRequest对象，用于获取请求相关的信息（如会话中的用户角色等属性），不过此处暂时未体现更多使用场景
+     * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息）
+     */
     @RequestMapping("/update")
-    public R update(@RequestBody NewsEntity news, HttpServletRequest request){
+    public R update(@RequestBody NewsEntity news, HttpServletRequest request) {
-        logger.debug("update方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString());
+        logger.debug("update方法:,,Controller:{},,news:{}", this.getClass().getName(), news.toString());
 
         String role = String.valueOf(request.getSession().getAttribute("role"));
-//        if(false)
+//        if (false)
-//            return R.error(511,"永远不会进入");
+//            return R.error(511, "永远不会进入");
-        //根据字段查询是否有相同数据
+        // 创建EntityWrapper对象，用于构建查询条件，检查数据库中除了当前要修改的记录（根据id排除）外是否存在相同的公告信息（根据公告名称和公告类型等字段进行等值判断）
         Wrapper<NewsEntity> queryWrapper = new EntityWrapper<NewsEntity>()
-            .notIn("id",news.getId())
+                .notIn("id", news.getId())
-            .andNew()
+                .andNew()
-            .eq("news_name", news.getNewsName())
+                .eq("news_name", news.getNewsName())
-            .eq("news_types", news.getNewsTypes())
+                .eq("news_types", news.getNewsTypes());
-            ;
+
+        logger.info("sql语句:" + queryWrapper.getSqlSegment());
 
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
+        // 根据构建的查询条件查询数据库中是否已经存在相同的数据（通过selectOne方法查询一条符合条件的数据）
         NewsEntity newsEntity = newsService.selectOne(queryWrapper);
-        if("".equals(news.getNewsPhoto()) || "null".equals(news.getNewsPhoto())){
+
-                news.setNewsPhoto(null);
+        // 如果公告图片字段为空字符串或者值为"null"
+        // （这里可能是前端传递过来的表示空值的情况），则将其设置为null，以便后续正确更新到数据库中
+        if ("".equals(news.getNewsPhoto()) || "null".equals(news.getNewsPhoto())) {
+            news.setNewsPhoto(null);
         }
-        if(newsEntity==null){
+        if (newsEntity == null) {
-            newsService.updateById(news);//根据id更新
+
+            // 如果不存在相同数据，
+            // 则根据传入的news对象的id更新数据库中的对应公告信息记录（通过updateById方法）
+
+            newsService.updateById(news);
             return R.ok();
-        }else {
+        } else {
-            return R.error(511,"表中有相同数据");
-        }
-    }
 
+            // 如果存在相同数据，
 
+            // 则返回包含错误码和提示信息的错误结果对象，表示表中已有相同数据
+            return R.error(511, "表中有相同数据");
+        }
+    }
 
     /**
-    * 删除
+     * 删除功能方法
-    */
+     * 接收前端传来的要删除的公告信息记录的id数组，调用newsService的批量删除方法，从数据库中删除对应的数据记录，
+     * 并返回操作结果给前端。
+     * @param ids 包含要删除的公告信息记录的id的整数数组，用于指定要删除的多条公告信息
+     * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息）
+     */
     @RequestMapping("/delete")
-    public R delete(@RequestBody Integer[] ids){
+    public R delete(@RequestBody Integer[] ids) {
-        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
+
+        logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
+        // 调用newsService的deleteBatchIds方法，
+        // 批量删除数据库中对应id的公告信息记录（传入的是将数组转换为List后的集合）
+
         newsService.deleteBatchIds(Arrays.asList(ids));
         return R.ok();
     }
 
-
     /**
-     * 批量上传
+     * 批量上传功能方法
+     * 接收文件名fileName以及HttpServletRequest对象，用于将指定的Excel文件中的公告信息数据批量插入到数据库中，
+     * 在插入前进行一些文件格式校验、数据读取以及重复数据检查等操作。
+     * @param fileName 要上传的文件的名称（这里应该是位于特定目录下的文件名，预期是Excel文件）
+     * @param request HttpServletRequest对象，用于获取请求相关的信息，如当前用户的ID等属性，可能在后续业务逻辑中有更多用途
+     * @return R类型的结果对象，包含操作结果状态（成功或失败及对应的提示信息）
      */
     @RequestMapping("/batchInsert")
-    public R save( String fileName, HttpServletRequest request){
+    public R save(String fileName, HttpServletRequest request) {
-        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
+        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
+
+        // 从HttpServletRequest的会话中获取当前用户的ID，
+        // 并转换为Integer类型（这里做了一些强制类型转换操作）
+
         Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         try {
-            List<NewsEntity> newsList = new ArrayList<>();//上传的东西
+
-            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
+            // 创建一个用于存储要插入数据库的NewsEntity对象列表（即从文件中读取到的多条公告信息记录）
+            List<NewsEntity> newsList = new ArrayList<>();
+            // 创建一个Map，
+
+            // 用于存储要查询是否重复的字段信息（具体的使用方式需看后续代码逻辑，可能用于去重判断等）
+            Map<String, List<String>> seachFields = new HashMap<>();
             Date date = new Date();
             int lastIndexOf = fileName.lastIndexOf(".");
-            if(lastIndexOf == -1){
+            if (lastIndexOf == -1) {
-                return R.error(511,"该文件没有后缀");
+                return R.error(511, "该文件没有后缀");
-            }else{
+            } else {
                 String suffix = fileName.substring(lastIndexOf);
-                if(!".xls".equals(suffix)){
+                if (!".xls".equals(suffix)) {
-                    return R.error(511,"只支持后缀为xls的excel文件");
+                    return R.error(511, "只支持后缀为xls的excel文件");
-                }else{
+                } else {
-                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
+                    // 通过类加载器获取指定文件名对应的文件资源路径（这里应该是位于"static/upload/"目录下的文件）
+                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);
                     File file = new File(resource.getFile());
-                    if(!file.exists()){
+                    if (!file.exists()) {
-                        return R.error(511,"找不到上传文件，请联系管理员");
+                        return R.error(511, "找不到上传文件，请联系管理员");
-                    }else{
+                    } else {
-                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
+
-                        dataList.remove(0);//删除第一行，因为第一行是提示
+                        // 调用PoiUtil的poiImport方法读取Excel文件中的数据（返回的是一个嵌套的List，
-                        for(List<String> data:dataList){
+                        // 外层List表示行，内层List表示每行中的单元格数据）
-                            //循环
+                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());
+                        // 删除读取到的数据列表中的第一行（可能是表头之类的提示信息，不需要插入数据库）
+                        dataList.remove(0);
+                        for (List<String> data : dataList) {
+                            // 循环处理每一行数据，创建一个NewsEntity对象，用于存储要插入数据库的一条公告信息记录信息
                             NewsEntity newsEntity = new NewsEntity();
+//
+//
+//
+//
+//
+//
+//
 //                            newsEntity.setNewsName(data.get(0));                    //公告标题 要改的
 //                            newsEntity.setNewsTypes(Integer.valueOf(data.get(0)));   //公告类型 要改的
 //                            newsEntity.setNewsPhoto("");//详情和图片
@@ -215,91 +309,28 @@ public class NewsController {
 //                            newsEntity.setCreateTime(date);//时间
                             newsList.add(newsEntity);
 
+                            // 把要查询是否重复的字段放入map中（此处代码未完整实现具体放入逻辑，需补充）
 
-                            //把要查询是否重复的字段放入map中
                         }
 
-                        //查询是否重复
+
+                        // 查询是否重复（此处应该是根据放入seachFields中的字段去检查数据库中是否已存在相同记录，
+                        // 代码可能需完善）
                         newsService.insertBatch(newsList);
+
                         return R.ok();
                     }
                 }
             }
-        }catch (Exception e){
+        } catch (Exception e) {
             e.printStackTrace();
-            return R.error(511,"批量插入数据异常，请联系管理员");
+            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 = newsService.queryPage(params);
-
-        //字典表数据转换
-        List<NewsView> list =(List<NewsView>)page.getList();
-        for(NewsView c:list)
-            dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
-        return R.ok().put("data", page);
     }
 
-    /**
+/**
-    * 前端详情
+ * 前端列表功能方法
-    */
+ * 接收前端传来的查询参数以及HttpServletRequest对象，获取公告信息的分页列表数据，
-    @RequestMapping("/detail/{id}")
+ * 并对字典表相关字段进行数据转换后返回给前端，此方法不受权限验证限制（通过@IgnoreAuth注解标识）。
-    public R detail(@PathVariable("id") Long id, HttpServletRequest request){
+ * @param params 包含查询条件、分页等相关参数的Map集合，例如每页显示数量、页码、排序字段等
-        logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
+ * @param request HttpServletRequest对象，用于获取请求相关的信息，如当前用户的角色、用户ID等，以便添加特定的查询
-        NewsEntity news = newsService.selectById(id);
-            if(news !=null){
-
-
-                //entity转view
-                NewsView view = new NewsView();
-                BeanUtils.copyProperties( news , view );//把实体数据重构到view中
-
-                //修改对应字典表字段
-                dictionaryService.dictionaryConvert(view, request);
-                return R.ok().put("data", view);
-            }else {
-                return R.error(511,"查不到数据");
-            }
-    }
-
-
-    /**
-    * 前端保存
-    */
-    @RequestMapping("/add")
-    public R add(@RequestBody NewsEntity news, HttpServletRequest request){
-        logger.debug("add方法:,,Controller:{},,news:{}",this.getClass().getName(),news.toString());
-        Wrapper<NewsEntity> queryWrapper = new EntityWrapper<NewsEntity>()
-            .eq("news_name", news.getNewsName())
-            .eq("news_types", news.getNewsTypes())
-            ;
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
-        NewsEntity newsEntity = newsService.selectOne(queryWrapper);
-        if(newsEntity==null){
-            news.setInsertTime(new Date());
-            news.setCreateTime(new Date());
-        newsService.insert(news);
-            return R.ok();
-        }else {
-            return R.error(511,"表中有相同数据");
-        }
-    }
-
-
-}

minsu/minsuguanliw/src/main/java/com/controller/UsersController.java

@@ -27,142 +27,233 @@ import com.utils.R;
 
 /**
  * 登录相关
+ * 该类主要处理与用户登录、注册以及退出相关的操作，通过调用对应的服务层接口来实现具体业务逻辑，并与前端进行交互返回相应结果。
+ * 类上使用了 @RequestMapping("users") 注解来指定该控制器处理的基础请求路径为 "/users"，使用 @RestController 注解表明这是一个 RESTful 风格的控制器，返回的数据会直接转换为 JSON 等格式响应给前端。
  */
+
 @RequestMapping("users")
 @RestController
 public class UsersController {
-	
+
+	// 自动注入用户服务层接口，通过该接口可以调用与用户相关的业务方法，比如查询用户、插入用户等数据库操作相关的方法，具体实现由对应的服务层类来完成。
 	@Autowired
 	private UsersService usersService;
-	
+
+	// 自动注入Token服务层接口，用于处理与用户Token相关的业务逻辑，例如生成用户登录后的Token等操作，具体功能在TokenService类中实现。
 	@Autowired
 	private TokenService tokenService;
 
 	/**
 	 * 登录
+	 * 处理用户登录的业务逻辑，接收用户名、密码和验证码（当前代码中验证码未做完整验证逻辑）作为参数，验证用户信息是否正确，若正确则生成Token并返回相关用户信息给前端。
+	 * 该方法使用了 @IgnoreAuth 注解，意味着此登录接口可能不需要进行权限认证即可访问（具体取决于该注解的实际定义和功能），使用 @PostMapping 注解指定该接口处理的是POST请求，请求路径为 "/login"，即完整路径为 "/users/login"。
+	 * @param username 用户名，从前端请求中传入，用于查找对应的用户信息。
+	 * @param password 密码，从前端请求中传入，用于和数据库中存储的用户密码进行比对验证。
+	 * @param captcha 验证码，从前端请求中传入，当前代码未对其进行完整的验证逻辑处理（比如与缓存中的验证码比对等操作）。
+	 * @param request HttpServletRequest对象，用于获取当前请求相关的信息，不过在当前登录方法中未体现更多复杂的使用情况。
+	 * @return R对象，封装了操作结果及相关数据，若登录成功则包含生成的Token、用户角色、用户ID等信息，若登录失败则返回账号或密码不正确的错误信息。
 	 */
+
 	@IgnoreAuth
 	@PostMapping(value = "/login")
 	public R login(String username, String password, String captcha, HttpServletRequest request) {
+
+		// 通过用户服务层的selectOne方法，结合EntityWrapper构建的查询条件，根据传入的用户名从数据库中查询对应的用户实体信息。
+		// 这里的查询条件是查找用户名与传入的username相等的用户记录，返回符合条件的UsersEntity对象（若存在），若不存在则返回null。
 		UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
-		if(user==null || !user.getPassword().equals(password)) {
+		// 如果查询到的用户为null（即用户名不存在）或者密码不匹配（通过调用user对象的getPassword方法获取存储的密码并与传入的password比对），则返回账号或密码不正确的错误信息给前端。
+		if (user == null ||!user.getPassword().equals(password)) {
 			return R.error("账号或密码不正确");
 		}
-		String token = tokenService.generateToken(user.getId(),username, "users", user.getRole());
+		// 如果用户信息验证通过，调用Token服务层的generateToken方法，根据用户的ID、用户名、用户类型（这里固定为"users"）以及用户的角色信息生成一个用于标识用户登录状态的Token字符串。
+		String token = tokenService.generateToken(user.getId(), username, "users", user.getRole());
 		R r = R.ok();
+		// 将生成的Token放入返回结果对象R中，以便前端接收并后续用于验证用户登录状态等操作。
 		r.put("token", token);
-		r.put("role",user.getRole());
+		// 将用户的角色信息放入返回结果对象R中，方便前端知晓当前登录用户的角色权限等情况。
-		r.put("userId",user.getId());
+		r.put("role", user.getRole());
+		// 将用户的ID信息放入返回结果对象R中，前端可能会根据此ID进行一些与用户相关的后续操作。
+		r.put("userId", user.getId());
 		return r;
 	}
-	
+
 	/**
 	 * 注册
+	 * 处理用户注册的业务逻辑，接收包含用户信息的UsersEntity对象作为参数，先检查用户名是否已被使用，若未被使用则将新用户信息插入到数据库中。
+	 * 该方法同样使用了 @IgnoreAuth 注解，可能表示此注册接口不需要进行权限认证即可访问（具体取决于该注解的实际定义和功能），使用 @PostMapping 注解指定该接口处理的是POST请求，请求路径为 "/register"，即完整路径为 "/users/register"。
+	 * @param user 包含用户注册信息的UsersEntity对象，通过请求体传入，通常是前端提交的注册表单数据等内容，包含了用户名、密码等各种用户相关信息。
+	 * @return R对象，封装了操作结果，若注册成功则返回成功信息，若用户名已存在则返回用户已存在的错误信息。
 	 */
+
 	@IgnoreAuth
 	@PostMapping(value = "/register")
-	public R register(@RequestBody UsersEntity user){
+	public R register(@RequestBody UsersEntity user) {
-//    	ValidatorUtils.validateEntity(user);
+		// 以下这行代码被注释掉了，可能原本是用于对传入的用户实体进行数据合法性验证的逻辑，比如验证用户名、密码是否符合格式要求等，目前未生效。
-    	if(usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
+		// ValidatorUtils.validateEntity(user);
-    		return R.error("用户已存在");
+		// 通过用户服务层的selectOne方法，结合EntityWrapper构建的查询条件，根据传入的用户实体中的用户名去数据库中查询是否已存在相同用户名的用户记录，若存在则返回对应的UsersEntity对象，若不存在则返回null。
-    	}
+		if (usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername()))!= null) {
-        usersService.insert(user);
+			return R.error("用户已存在");
-        return R.ok();
+		}
-    }
+		// 如果用户名未被使用，调用用户服务层的insert方法将包含新用户信息的user对象插入到数据库中，完成用户注册操作。
+		usersService.insert(user);
+		return R.ok();
+	}
 
 	/**
 	 * 退出
+	 * 处理用户退出登录的业务逻辑，通过使当前请求的会话（Session）失效来清除用户登录状态等相关信息，返回退出成功的提示信息给前端。
+	 * 使用 @GetMapping 注解指定该接口处理的是GET请求，请求路径为 "/logout"，即完整路径为 "/users/logout"。
+	 * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是操作其对应的会话对象来实现会话失效操作。
+	 * @return R对象，封装了操作结果及相关提示信息，这里返回包含"退出成功"提示内容的成功信息给前端，表示用户已成功退出登录。
 	 */
+
 	@GetMapping(value = "logout")
 	public R logout(HttpServletRequest request) {
+		// 调用HttpServletRequest对象的invalidate方法使当前会话失效，即清除会话中存储的用户登录凭证、用户相关属性等信息，达到退出登录的效果。
 		request.getSession().invalidate();
 		return R.ok("退出成功");
 	}
-	
+}
-	/**
+
-     * 密码重置
+/**
-     */
+ * 密码重置
-    @IgnoreAuth
+ * 用于处理用户忘记密码后重置密码的业务逻辑，根据传入的用户名查找对应的用户，若用户存在则将其密码重置为固定值“123456”，并返回相应提示信息。
+ * 该方法使用了 @IgnoreAuth 注解，意味着此接口可能不需要进行权限认证即可访问（具体取决于该注解的实际定义和功能），通过 @RequestMapping 注解指定其处理的请求路径为 "/resetPass"，完整路径为 "/users/resetPass"（结合类上的@RequestMapping("users") 注解）。
+ * @param username 用户名，从前端请求中传入，用于查找对应的用户，以便后续重置密码操作。
+ * @param request HttpServletRequest对象，用于获取当前请求相关的信息，不过在当前方法中未体现更多复杂使用情况。
+ * @return R对象，封装了操作结果及相关信息，若用户不存在则返回账号不存在的错误信息，若密码重置成功则返回包含密码已重置提示信息的成功结果。
+ */
+
+	@IgnoreAuth
 	@RequestMapping(value = "/resetPass")
-    public R resetPass(String username, HttpServletRequest request){
+	public R resetPass(String username, HttpServletRequest request) {
-    	UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
+	// 通过用户服务层的selectOne方法，结合EntityWrapper构建的查询条件（查找用户名与传入的username相等的用户记录），从数据库中查询对应的用户实体信息。
-    	if(user==null) {
+	UsersEntity user = usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", username));
-    		return R.error("账号不存在");
+	// 如果查询到的用户为null，即用户名对应的用户不存在，返回账号不存在的错误信息给前端。
-    	}
+	if (user == null) {
-    	user.setPassword("123456");
+		return R.error("账号不存在");
-        usersService.update(user,null);
+	}
-        return R.ok("密码已重置为：123456");
+	// 如果用户存在，将用户的密码设置为固定值“123456”，实际应用中这样直接设置密码不太安全，可后续优化为更安全合理的密码重置逻辑，比如通过发送验证码验证等方式。
-    }
+	user.setPassword("123456");
-	
+	// 调用用户服务层的update方法，传入更新后的user对象以及null（可能表示不需要其他额外的更新条件，具体取决于update方法的参数定义），将用户的密码更新到数据库中。
-	/**
+	usersService.update(user, null);
-     * 列表
+	// 返回操作成功的结果信息，并附带密码已重置为“123456”的提示内容，告知前端密码重置操作已完成。
-     */
+	return R.ok("密码已重置为：123456");
-    @RequestMapping("/page")
+}
-    public R page(@RequestParam Map<String, Object> params,UsersEntity user){
-        EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
-    	PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
-        return R.ok().put("data", page);
-    }
 
-	/**
+/**
-     * 列表
+ * 列表（分页查询）
-     */
+ * 用于获取用户列表数据，并进行分页以及根据传入的用户对象构建查询条件等相关处理后返回给前端，返回结果包含分页相关信息以及符合条件的用户数据列表。
-    @RequestMapping("/list")
+ * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/page"，完整路径为 "/users/page"。
-    public R list( UsersEntity user){
+ * @param params 包含查询参数的Map，例如分页参数（如每页条数、当前页码等）、筛选条件等，通过请求参数传入，用于构建数据库查询条件以及分页相关设置。
-       	EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
+ * @param user 包含用户相关信息的UsersEntity对象，可能用于进一步构建查询条件，比如根据用户对象中的某些属性来筛选特定用户数据等，具体取决于业务逻辑和相关工具类（如MPUtil）的使用方式。
-      	ew.allEq(MPUtil.allEQMapPre( user, "user")); 
+ * @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表信息（通过PageUtils对象承载）。
-        return R.ok().put("data", usersService.selectListView(ew));
+ */
-    }
+	@RequestMapping("/page")
-
+	public R page(@RequestParam Map<String, Object> params, UsersEntity user) {
-    /**
+	// 创建一个EntityWrapper对象，用于构建数据库查询条件，它可以方便地拼接各种查询条件语句，例如等于、大于、小于等条件，初始时为空，后续会根据业务逻辑添加相应条件。
-     * 信息
+	EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
-     */
+	// 调用用户服务层的queryPage方法进行分页查询，传入params参数用于分页相关设置以及通过MPUtil相关工具方法构建的查询条件。
-    @RequestMapping("/info/{id}")
+	// MPUtil.sort方法可能用于对查询结果进行排序设置，MPUtil.between方法可能用于构建范围查询条件，MPUtil.allLike方法可能用于构建模糊查询条件等，具体功能取决于MPUtil工具类的实现。
-    public R info(@PathVariable("id") String id){
+	PageUtils page = usersService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.allLike(ew, user), params), params));
-        UsersEntity user = usersService.selectById(id);
+	return R.ok().put("data", page);
-        return R.ok().put("data", user);
+}
-    }
+
-    
+/**
-    /**
+ * 列表（另一种查询方式）
-     * 获取用户的session用户信息
+ * 根据传入的用户对象构建查询条件，从数据库中查询符合条件的用户数据列表并返回给前端，返回结果包含查询到的用户数据列表信息。
-     */
+ * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/list"，完整路径为 "/users/list"。
-    @RequestMapping("/session")
+ * @param user 包含用户相关信息的UsersEntity对象，用于构建查询条件，通过MPUtil工具类的allEq方法将用户对象中的属性转换为相等查询条件，以便从数据库中筛选出符合条件的用户数据。
-    public R getCurrUser(HttpServletRequest request){
+ * @return R对象，封装了操作结果及相关数据，成功时包含查询到的用户数据列表（通过调用usersService.selectListView方法查询得到）。
-    	Integer id = (Integer)request.getSession().getAttribute("userId");
+ */
-        UsersEntity user = usersService.selectById(id);
+	@RequestMapping("/list")
-        return R.ok().put("data", user);
+	public R list(UsersEntity user) {
-    }
+	// 创建一个EntityWrapper对象，用于构建数据库查询条件，方便后续添加具体的查询条件语句。
-
+	EntityWrapper<UsersEntity> ew = new EntityWrapper<UsersEntity>();
-    /**
+	// 使用MPUtil工具类的allEq方法，将用户对象中的属性按照指定前缀（这里是"user"）转换为相等查询条件，添加到EntityWrapper对象中，用于构建查询符合该用户对象属性值的所有用户记录的条件语句。
-     * 保存
+	ew.allEq(MPUtil.allEQMapPre(user, "user"));
-     */
+	return R.ok().put("data", usersService.selectListView(ew));
-    @PostMapping("/save")
+}
-    public R save(@RequestBody UsersEntity user){
+
-//    	ValidatorUtils.validateEntity(user);
+/**
-    	if(usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername())) !=null) {
+ * 信息
-    		return R.error("用户已存在");
+ * 根据传入的用户ID，从数据库中查询对应的用户详细信息并返回给前端，若查询到则将用户信息封装在R对象中返回，若未查询到则返回相应错误信息（当前代码未做错误处理，实际可能需要完善）。
-    	}
+ * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/info/{id}"，完整路径为 "/users/info/{id}"，其中{id}是路径变量，用于接收要查询信息的用户的唯一标识（通常是数据库中的主键ID）。
-    	user.setPassword("123456");
+ * @param id 用户的唯一标识（通常是数据库中的主键ID），通过路径变量传入，用于指定要查询详细信息的用户。
-        usersService.insert(user);
+ * @return R对象，封装了操作结果及相关数据，成功时包含查询到的对应的用户详细信息（以UsersEntity对象形式返回）。
-        return R.ok();
+ */
-    }
+	@RequestMapping("/info/{id}")
-
+	public R info(@PathVariable("id") String id) {
-    /**
+	// 通过用户服务层的selectById方法，根据传入的用户ID从数据库中查询对应的用户实体信息。
-     * 修改
+	UsersEntity user = usersService.selectById(id);
-     */
+	return R.ok().put("data", user);
-    @RequestMapping("/update")
+}
-    public R update(@RequestBody UsersEntity user){
+
-//        ValidatorUtils.validateEntity(user);
+/**
-        usersService.updateById(user);//全部更新
+ * 获取用户的session用户信息
-        return R.ok();
+ * 从当前请求的会话（Session）中获取用户ID，然后根据该ID查询对应的用户实体信息并返回给前端，若获取到用户ID则进行查询并返回用户信息，若未获取到用户ID（比如会话中不存在该属性等情况）则可能返回相应错误信息（当前代码未做完善处理）。
-    }
+ * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/session"，完整路径为 "/users/session"。
-
+ * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是从中获取会话中的用户ID属性值，用于后续查询用户信息操作。
-    /**
+ * @return R对象，封装了操作结果及相关数据，成功时包含查询到的对应的用户详细信息（以UsersEntity对象形式返回）。
-     * 删除
+ */
-     */
+	@RequestMapping("/session")
-    @RequestMapping("/delete")
+	public R getCurrUser(HttpServletRequest request) {
-    public R delete(@RequestBody Long[] ids){
+	// 从当前请求的会话中获取名为“userId”的属性值，并转换为整数类型，该值作为用户的唯一标识，用于后续查询用户信息。
-        usersService.deleteBatchIds(Arrays.asList(ids));
+	Integer id = (Integer) request.getSession().getAttribute("userId");
-        return R.ok();
+	// 通过用户服务层的selectById方法，根据获取到的用户ID从数据库中查询对应的用户实体信息。
-    }
+	UsersEntity user = usersService.selectById(id);
+	return R.ok().put("data", user);
+}
+
+/**
+ * 保存
+ * 处理新增用户信息的保存操作，先检查用户名是否已被使用，若未被使用则将新用户信息插入到数据库中，同时设置默认密码为“123456”（实际应用中密码设置可优化），并返回相应操作结果给前端。
+ * 通过 @PostMapping 注解指定该方法处理的是POST请求，请求路径为 "/save"，完整路径为 "/users/save"，表示用于接收前端提交的新增用户信息并进行保存操作。
+ * @param user 包含用户信息的UsersEntity对象，通过请求体传入，通常是前端提交的新增用户表单数据等内容，包含了用户名、密码等各种用户相关信息。
+ * @return R对象，封装了操作结果，若用户名已存在则返回用户已存在的错误信息，若保存成功则返回成功信息。
+ */
+	@PostMapping("/save")
+	public R save(@RequestBody UsersEntity user) {
+	// 以下这行代码被注释掉了，可能原本是用于对传入的用户实体进行数据合法性验证的逻辑，比如验证用户名、密码是否符合格式要求等，目前未生效。
+	// ValidatorUtils.validateEntity(user);
+	// 通过用户服务层的selectOne方法，结合EntityWrapper构建的查询条件（查找用户名与传入的user.getUsername()相等的用户记录），从数据库中查询是否已存在相同用户名的用户，若存在则返回对应的UsersEntity对象，若不存在则返回null。
+	if (usersService.selectOne(new EntityWrapper<UsersEntity>().eq("username", user.getUsername()))!= null) {
+		return R.error("用户已存在");
+	}
+	// 设置新用户的密码为固定值“123456”，实际应用中这样直接设置密码不太安全，可后续优化为更安全合理的密码设置方式，比如进行密码加密等操作。
+	user.setPassword("123456");
+	// 调用用户服务层的insert方法将包含新用户信息的user对象插入到数据库中，完成用户新增保存操作。
+	usersService.insert(user);
+	return R.ok();
+}
+
+/**
+ * 修改
+ * 处理用户信息修改的业务逻辑，接收包含更新后用户信息的UsersEntity对象，将其全部更新到数据库中对应的用户记录（具体更新方式取决于updateById方法的实现，可能是根据ID进行匹配更新等），并返回操作成功的结果给前端。
+ * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/update"，完整路径为 "/users/update"，表示用于接收前端提交的更新后的用户信息并进行数据库更新操作。
+ * @param user 包含更新后用户信息的UsersEntity对象，通过请求体传入，通常是前端提交的修改后的用户表单数据等内容，包含了需要更新的各种用户相关信息。
+ * @return R对象，封装了操作结果，成功则返回操作成功的信息，表示用户信息已更新到数据库中。
+ */
+	@RequestMapping("/update")
+	public R update(@RequestBody UsersEntity user) {
+	// 以下这行代码被注释掉了，可能原本是用于对传入的用户实体进行数据合法性验证的逻辑，比如验证更新后的用户信息是否符合格式要求等，目前未生效。
+	// ValidatorUtils.validateEntity(user);
+	// 调用用户服务层的updateById方法，根据传入的user对象中的ID（通常是数据库中的主键ID）找到对应的用户记录，并将user对象中的所有属性值更新到数据库中对应的字段上，完成用户信息更新操作。
+	usersService.updateById(user);
+	return R.ok();
+}
+
+/**
+ * 删除
+ * 处理批量删除用户的业务逻辑，接收包含要删除的用户ID的数组，调用用户服务层的方法批量删除数据库中对应的用户记录，并返回操作成功的结果给前端。
+ * 通过 @RequestMapping 注解指定该方法处理的请求路径为 "/delete"，完整路径为 "/users/delete"，表示用于接收前端提交的要删除的用户ID列表并进行批量删除操作。
+ * @param ids 包含要删除的用户ID的Long类型数组，通过请求体传入，用于指定要删除的多个用户记录在数据库中的唯一标识。
+ * @return R对象，封装了操作结果，成功则返回操作成功的信息，表示批量删除操作已完成。
+ */
+	@RequestMapping("/delete")
+	public R delete(@RequestBody Long[] ids) {
+	// 调用用户服务层的deleteBatchIds方法，传入要删除的用户ID列表（通过Arrays.asList方法将数组转换为List集合形式，具体取决于deleteBatchIds方法的参数要求），执行批量删除数据库中对应用户记录的操作。
+	usersService.deleteBatchIds(Arrays.asList(ids));
+	return R.ok();
+}
 }

minsu/minsuguanliw/src/main/java/com/controller/YonghuController.java

@@ -42,40 +42,56 @@ import com.alibaba.fastjson.*;
 @Controller
 @RequestMapping("/yonghu")
 public class YonghuController {
+
+    // 创建日志记录器，用于记录该类中的相关操作日志
     private static final Logger logger = LoggerFactory.getLogger(YonghuController.class);
 
+    // 自动注入用户服务层接口，用于处理与用户相关的业务逻辑，如数据库操作等
     @Autowired
     private YonghuService yonghuService;
 
-
+    // 自动注入Token服务层接口，用于处理与用户Token相关的业务，例如生成、验证等操作
     @Autowired
     private TokenService tokenService;
+
+    // 自动注入字典服务层接口，用于处理字典数据相关的转换等操作
     @Autowired
     private DictionaryService dictionaryService;
 
-    //级联表service
+    // 此处可能用于自动注入级联表相关的服务层接口，当前代码中未完整体现具体使用情况
-
-
 
     /**
-    * 后端列表
+     * 后端列表
-    */
+     * 用于获取用户列表数据，并进行分页、字典表数据转换等处理后返回给前端
+     * @param params 包含查询参数的Map，例如分页参数、排序参数、筛选条件等
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等
+     * @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表
+     */
     @RequestMapping("/page")
     public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
         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,"永不会进入");
+            // 如果用户角色是"用户"，则添加当前用户ID作为查询条件，用于筛选当前用户相关的数据
         else if("用户".equals(role))
             params.put("yonghuId",request.getSession().getAttribute("userId"));
-        params.put("yonghuDeleteStart",1);params.put("yonghuDeleteEnd",1);
+            params.put("yonghuDeleteStart",1);params.put("yonghuDeleteEnd",1);
+        // 设置默认的逻辑删除开始和结束标识，用于筛选未删除的用户数据（这里假设1表示未删除）
+        params.put("yonghuDeleteStart",1);
+        params.put("yonghuDeleteEnd",1);
+        // 如果没有指定排序字段，则默认按照"id"字段进行排序
         if(params.get("orderBy")==null || params.get("orderBy")==""){
             params.put("orderBy","id");
         }
+        // 调用用户服务层的方法查询分页数据
         PageUtils page = yonghuService.queryPage(params);
-
+        // 获取分页数据中的用户视图列表（可能是用于展示给前端的特定格式数据）
         //字典表数据转换
         List<YonghuView> list =(List<YonghuView>)page.getList();
+        // 遍历用户视图列表，对每个用户数据进行字典表数据转换操作
         for(YonghuView c:list){
             //修改对应字典表字段
             dictionaryService.dictionaryConvert(c, request);
@@ -84,16 +100,25 @@ public class YonghuController {
     }
 
     /**
-    * 后端详情
+     * 后端详情
-    */
+     * 根据用户ID获取用户的详细信息，进行必要的数据转换后返回给前端
+     * @param id 用户的唯一标识（通常是数据库中的主键ID）
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等
+     * @return R对象，封装了操作结果及相关数据，成功时包含用户详细信息
+     */
+
     @RequestMapping("/info/{id}")
     public R info(@PathVariable("id") Long id, HttpServletRequest request){
         logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
+        // 根据ID从数据库中查询用户实体信息
         YonghuEntity yonghu = yonghuService.selectById(id);
         if(yonghu !=null){
             //entity转view
+            // 创建用户视图对象，用于转换和返回给前端展示的数据格式
             YonghuView view = new YonghuView();
+            // 将用户实体中的数据复制到用户视图对象中，实现数据格式转换
             BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中
+            // 对用户视图对象中的相关字典表字段进行数据转换操作
 
             //修改对应字典表字段
             dictionaryService.dictionaryConvert(view, request);
@@ -105,15 +130,22 @@ public class YonghuController {
     }
 
     /**
-    * 后端保存
+     * 后端保存
-    */
+     * 用于保存新用户信息到数据库，会先检查用户名和手机号是否已被使用
+     * @param yonghu 包含用户信息的YonghuEntity对象，通过请求体传入（通常是前端提交的用户注册等数据）
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等
+     * @return R对象，封装了操作结果，成功表示保存成功，失败则提示账户或者手机号已经被使用等错误信息
+     */
+
     @RequestMapping("/save")
     public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
         logger.debug("save方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
 
         String role = String.valueOf(request.getSession().getAttribute("role"));
+        // 此处条件永远为假，实际应该不会进入该分支，可能是预留逻辑待完善
         if(false)
             return R.error(511,"永远不会进入");
+        // 创建查询条件包装器，用于构建查询用户名或手机号是否已存在且未被删除的用户的SQL条件
 
         Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
             .eq("username", yonghu.getUsername())
@@ -124,11 +156,15 @@ public class YonghuController {
             ;
 
         logger.info("sql语句:"+queryWrapper.getSqlSegment());
+        // 根据构建的查询条件查询是否已存在相同用户名或手机号的用户
         YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
         if(yonghuEntity==null){
             yonghu.setYonghuDelete(1);
+            // 设置用户的逻辑删除标识为未删除（这里假设1表示未删除）
             yonghu.setCreateTime(new Date());
+            // 设置默认密码（实际应用中可能需要更安全的密码处理方式）
             yonghu.setPassword("123456");
+            // 将新用户信息插入到数据库中
             yonghuService.insert(yonghu);
             return R.ok();
         }else {
@@ -137,8 +173,13 @@ public class YonghuController {
     }
 
     /**
-    * 后端修改
+     * 后端修改
-    */
+     * 根据传入的用户信息更新数据库中对应的用户数据，会先检查用户名和手机号是否已被其他用户使用（排除自身）
+     * @param yonghu 包含更新后用户信息的YonghuEntity对象，通过请求体传入（通常是前端提交的用户修改后的数据）
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如会话中的用户角色等
+     * @return R对象，封装了操作结果，成功表示更新成功，失败则提示账户或者手机号已经被使用等错误信息
+     */
+
     @RequestMapping("/update")
     public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
         logger.debug("update方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
@@ -158,12 +199,14 @@ public class YonghuController {
             ;
 
         logger.info("sql语句:"+queryWrapper.getSqlSegment());
+        // 根据构建的查询条件查询是否已存在符合条件的用户
         YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
+        // 如果用户的照片字段为空字符串或"null"，则将其设置为null，可能是为了符合数据库存储要求
         if("".equals(yonghu.getYonghuPhoto()) || "null".equals(yonghu.getYonghuPhoto())){
                 yonghu.setYonghuPhoto(null);
         }
         if(yonghuEntity==null){
-            yonghuService.updateById(yonghu);//根据id更新
+            yonghuService.updateById(yonghu);// 根据用户ID更新数据库中的用户信息
             return R.ok();
         }else {
             return R.error(511,"账户或者手机号已经被使用");
@@ -171,10 +214,13 @@ public class YonghuController {
     }
 
 
-
     /**
-    * 删除
+     * 删除
-    */
+     * 批量将指定用户的逻辑删除标识设置为已删除（这里假设2表示已删除），实现软删除功能
+     * @param ids 包含要删除的用户ID的整数数组，通过请求体传入
+     * @return R对象，封装了操作结果，成功表示删除操作执行成功（实际只是更新了逻辑删除标识）
+     */
+
     @RequestMapping("/delete")
     public R delete(@RequestBody Integer[] ids){
         logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
@@ -194,34 +240,48 @@ public class YonghuController {
 
     /**
      * 批量上传
+     * 从指定的Excel文件（仅支持后缀为.xls的文件）中读取用户数据，进行重复性检查后批量插入到数据库中
+     * @param fileName 要上传的Excel文件名，从请求参数中获取
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如当前用户ID等
+     * @return R对象，封装了操作结果，成功表示批量插入成功，失败则提示各种错误信息，如文件格式错误、数据重复、插入异常等
      */
+
     @RequestMapping("/batchInsert")
     public R save( String fileName, HttpServletRequest request){
         logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
+        // 从会话中获取当前用户ID，并转换为整数类型
         Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         try {
             List<YonghuEntity> yonghuList = new ArrayList<>();//上传的东西
+            // 用于存储要查询是否重复的字段及对应的值，以字段名为键，值的列表为值
             Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
             Date date = new Date();
             int lastIndexOf = fileName.lastIndexOf(".");
+            // 如果文件名没有后缀，返回错误信息
             if(lastIndexOf == -1){
                 return R.error(511,"该文件没有后缀");
             }else{
                 String suffix = fileName.substring(lastIndexOf);
+                // 如果文件后缀不是.xls，返回错误信息，表明只支持该后缀的Excel文件
                 if(!".xls".equals(suffix)){
                     return R.error(511,"只支持后缀为xls的excel文件");
                 }else{
+                    // 获取指定文件名对应的文件资源路径
                     URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
                     File file = new File(resource.getFile());
+                    // 如果文件不存在，返回错误信息，提示联系管理员
                     if(!file.exists()){
                         return R.error(511,"找不到上传文件，请联系管理员");
                     }else{
+                        // 使用工具类读取Excel文件中的数据，返回二维列表，每一行表示一条数据
                         List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
+                        // 删除第一行数据，通常第一行是标题行等提示信息，不需要插入数据库
                         dataList.remove(0);//删除第一行，因为第一行是提示
                         for(List<String> data:dataList){
                             //循环
                             YonghuEntity yonghuEntity = new YonghuEntity();
+                            // 以下是对用户实体各字段的赋值操作，目前都被注释掉了，可能需要根据实际Excel文件中的列顺序和数据内容进行正确赋值
 //                            yonghuEntity.setUsername(data.get(0));                    //账户 要改的
 //                            //yonghuEntity.setPassword("123456");//密码
 //                            yonghuEntity.setYonghuName(data.get(0));                    //用户姓名 要改的
@@ -235,8 +295,8 @@ public class YonghuController {
                             yonghuList.add(yonghuEntity);
 
 
-                            //把要查询是否重复的字段放入map中
+                            // 把要查询是否重复的字段（用户名和手机号）放入seachFields中，用于后续重复性检查
-                                //账户
+                            // 处理用户名字段
                                 if(seachFields.containsKey("username")){
                                     List<String> username = seachFields.get("username");
                                     username.add(data.get(0));//要改的
@@ -245,7 +305,7 @@ public class YonghuController {
                                     username.add(data.get(0));//要改的
                                     seachFields.put("username",username);
                                 }
-                                //手机号
+                            // 处理手机号字段
                                 if(seachFields.containsKey("yonghuPhone")){
                                     List<String> yonghuPhone = seachFields.get("yonghuPhone");
                                     yonghuPhone.add(data.get(0));//要改的
@@ -258,93 +318,138 @@ public class YonghuController {
 
                         //查询是否重复
                          //账户
+                        // 根据从Excel文件中读取的数据里的用户名，去数据库查询是否存在已逻辑删除（这里假设逻辑删除标识为1表示未删除）的同名用户
                         List<YonghuEntity> yonghuEntities_username = yonghuService.selectList(new EntityWrapper<YonghuEntity>().in("username", seachFields.get("username")).eq("yonghu_delete", 1));
+                        // 如果查询到的同名用户数量大于0，说明存在重复的用户名
                         if(yonghuEntities_username.size() >0 ){
                             ArrayList<String> repeatFields = new ArrayList<>();
+                            // 遍历查询到的同名用户列表，将他们的用户名添加到repeatFields列表中
                             for(YonghuEntity s:yonghuEntities_username){
                                 repeatFields.add(s.getUsername());
                             }
+                            // 返回错误信息，提示数据库中该表的[账户]字段已经存在，并列出重复的用户名数据
                             return R.error(511,"数据库的该表中的 [账户] 字段已经存在 存在数据为:"+repeatFields.toString());
                         }
-                         //手机号
+                        // 根据从Excel文件中读取的数据里的手机号，去数据库查询是否存在已逻辑删除（这里假设逻辑删除标识为1表示未删除）的同手机号用户
                         List<YonghuEntity> yonghuEntities_yonghuPhone = yonghuService.selectList(new EntityWrapper<YonghuEntity>().in("yonghu_phone", seachFields.get("yonghuPhone")).eq("yonghu_delete", 1));
+                        // 如果查询到的同手机号用户数量大于0，说明存在重复的手机号
                         if(yonghuEntities_yonghuPhone.size() >0 ){
                             ArrayList<String> repeatFields = new ArrayList<>();
                             for(YonghuEntity s:yonghuEntities_yonghuPhone){
                                 repeatFields.add(s.getYonghuPhone());
                             }
+                            // 返回错误信息，提示数据库中该表的[手机号]字段已经存在，并列出重复的手机号数据
                             return R.error(511,"数据库的该表中的 [手机号] 字段已经存在 存在数据为:"+repeatFields.toString());
                         }
+                        // 经过上述重复性检查后，如果没有重复数据，则批量将从Excel文件中读取并整理好的用户数据列表插入到数据库中
                         yonghuService.insertBatch(yonghuList);
                         return R.ok();
                     }
                 }
             }
         }catch (Exception e){
+            // 如果在上述批量插入等操作过程中出现异常，打印异常堆栈信息方便排查问题
             e.printStackTrace();
+            // 返回错误信息，提示批量插入数据出现异常，并建议联系管理员处理
             return R.error(511,"批量插入数据异常，请联系管理员");
         }
     }
 
 
     /**
-    * 登录
+     * 登录
-    */
+     * 用于处理用户登录逻辑，验证用户名、密码以及账户是否已被删除等情况，登录成功后生成Token并返回相关用户信息
-    @IgnoreAuth
+     * @param username 用户名，从请求参数中获取
+     * @param password 密码，从请求参数中获取
+     * @param captcha 验证码，从请求参数中获取（当前代码中未体现验证码具体验证逻辑）
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息
+     * @return R对象，封装了操作结果及相关数据，成功时包含用户登录后的Token、角色、用户名、所属表名、用户ID等信息，失败则返回相应错误提示
+     */
+
+    @IgnoreAuth // 该注解可能表示此登录接口不需要进行权限认证（具体取决于该注解的实际定义和功能）
     @RequestMapping(value = "/login")
     public R login(String username, String password, String captcha, HttpServletRequest request) {
+        // 根据传入的用户名从数据库中查询对应的用户实体信息
         YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("username", username));
-        if(yonghu==null || !yonghu.getPassword().equals(password))
+        // 如果查询到的用户为null（即用户名不存在）或者密码不匹配，返回账号或密码不正确的错误信息
+        if (yonghu == null ||!yonghu.getPassword().equals(password))
             return R.error("账号或密码不正确");
-        else if(yonghu.getYonghuDelete() != 1)
+            // 如果用户的逻辑删除标识不为1（这里假设1表示未删除，即账户已被删除），返回账户已被删除的错误信息
+        else if (yonghu.getYonghuDelete()!= 1)
             return R.error("账户已被删除");
-        //  // 获取监听器中的字典表
+        // 以下几行代码被注释掉了，可能原本是用于获取字典表相关数据进行后续处理的逻辑，目前未生效
+        // 获取当前Web应用上下文的ServletContext对象，用于获取应用范围内共享的数据（比如字典表数据等）
         // ServletContext servletContext = ContextLoader.getCurrentWebApplicationContext().getServletContext();
-        // Map<String, Map<Integer, String>> dictionaryMap= (Map<String, Map<Integer, String>>) servletContext.getAttribute("dictionaryMap");
+        // 从ServletContext中获取名为"dictionaryMap"的属性，该属性可能是一个嵌套的Map结构，外层键是字典类型，内层键值对是字典代码和对应的名称等信息
+        // Map<String, Map<Integer, String>> dictionaryMap = (Map<String, Map<Integer, String>>) servletContext.getAttribute("dictionaryMap");
+        // 从字典表数据中获取名为"role_types"的字典类型对应的内层Map，可能是用于获取角色相关的字典信息（如角色代码和角色名称的对应关系等）
         // Map<Integer, String> role_types = dictionaryMap.get("role_types");
-        // role_types.get(.getRoleTypes());
+        // 根据用户ID、用户名、用户类型等信息生成用户登录的Token（具体生成逻辑在TokenService中实现）
-        String token = tokenService.generateToken(yonghu.getId(),username, "yonghu", "用户");
+        String token = tokenService.generateToken(yonghu.getId(), username, "yonghu", "用户");
         R r = R.ok();
+        // 将生成的Token放入返回结果对象中
         r.put("token", token);
-        r.put("role","用户");
+        // 将用户角色放入返回结果对象中，这里固定为"用户"
-        r.put("username",yonghu.getYonghuName());
+        r.put("role", "用户");
-        r.put("tableName","yonghu");
+        // 将用户的真实姓名（假设YonghuEntity中的YonghuName字段表示真实姓名）放入返回结果对象中
-        r.put("userId",yonghu.getId());
+        r.put("username", yonghu.getYonghuName());
+        // 将用户所属表名放入返回结果对象中，这里固定为"yonghu"
+        r.put("tableName", "yonghu");
+        // 将用户ID放入返回结果对象中
+        r.put("userId", yonghu.getId());
         return r;
     }
 
     /**
-    * 注册
+     * 注册
-    */
+     * 用于处理用户注册逻辑，先检查用户名和手机号是否已被使用，若未被使用则将新用户信息插入到数据库中
-    @IgnoreAuth
+     * @param yonghu 包含用户注册信息的YonghuEntity对象，通过请求体传入（通常是前端提交的注册表单数据等）
+     * @return R对象，封装了操作结果，成功表示注册成功，失败则提示账户或者手机号已经被使用的错误信息
+     */
+
+    @IgnoreAuth // 该注解可能表示此注册接口不需要进行权限认证（具体取决于该注解的实际定义和功能）
     @PostMapping(value = "/register")
-    public R register(@RequestBody YonghuEntity yonghu){
+    public R register(@RequestBody YonghuEntity yonghu) {
-//    	ValidatorUtils.validateEntity(user);
+        // 以下这行代码被注释掉了，可能原本是用于对传入的用户实体进行数据合法性验证的逻辑，目前未生效
+        // ValidatorUtils.validateEntity(user);
+        // 创建查询条件包装器，用于构建查询用户名或手机号是否已存在且未被删除的用户的SQL条件
         Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
-            .eq("username", yonghu.getUsername())
+                .eq("username", yonghu.getUsername())
-            .or()
+                .or()
-            .eq("yonghu_phone", yonghu.getYonghuPhone())
+                .eq("yonghu_phone", yonghu.getYonghuPhone())
-            .andNew()
+                .andNew()
-            .eq("yonghu_delete", 1)
+                .eq("yonghu_delete", 1);
-            ;
+        // 根据构建的查询条件查询是否已存在相同用户名或手机号的用户
         YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
-        if(yonghuEntity != null)
+        // 如果已存在相同用户名或手机号的用户，返回账户或者手机号已经被使用的错误信息
+        if (yonghuEntity!= null)
             return R.error("账户或者手机号已经被使用");
+        // 设置新用户的初始余额为0.0（可能根据业务需求设定的初始值）
         yonghu.setNewMoney(0.0);
+        // 设置新用户的逻辑删除标识为未删除（这里假设1表示未删除）
         yonghu.setYonghuDelete(1);
+        // 设置新用户的创建时间为当前时间
         yonghu.setCreateTime(new Date());
+        // 将新用户信息插入到数据库中
         yonghuService.insert(yonghu);
         return R.ok();
     }
 
     /**
      * 重置密码
+     * 根据传入的用户ID，将对应的用户密码重置为固定值"123456"（实际应用中可能需要更安全合理的密码重置逻辑）
+     * @param id 用户的唯一标识（通常是数据库中的主键ID），从请求参数中获取
+     * @return R对象，封装了操作结果，成功表示密码重置成功
      */
+
     @GetMapping(value = "/resetPassword")
-    public R resetPassword(Integer  id){
+    public R resetPassword(Integer id) {
         YonghuEntity yonghu = new YonghuEntity();
+        // 设置要重置的密码为"123456"
         yonghu.setPassword("123456");
+        // 设置要重置密码的用户ID
         yonghu.setId(id);
+        // 根据用户ID更新数据库中对应的用户密码信息
         yonghuService.updateById(yonghu);
         return R.ok();
     }
@@ -352,124 +457,177 @@ public class YonghuController {
 
     /**
      * 忘记密码
+     * 用于处理用户忘记密码的情况，根据用户名查找对应的用户，若存在则将其密码重置为固定值“123456”（实际应用中可能需要更安全合理的重置逻辑，比如发送验证码验证等）
+     * @param username 用户名，从请求参数中获取，用于查找对应的用户
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，但在当前方法中未体现更多相关使用情况
+     * @return R对象，封装了操作结果，成功表示密码重置成功，若用户不存在则返回账号不存在的错误信息，若更新数据库操作失败则返回相应错误信息
      */
+
     @IgnoreAuth
     @RequestMapping(value = "/resetPass")
     public R resetPass(String username, HttpServletRequest request) {
+        // 根据传入的用户名从数据库中查询对应的用户实体信息
         YonghuEntity yonghu = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("username", username));
-        if(yonghu!=null){
+        // 如果查询到对应的用户实体信息不为null，说明该用户存在
+        if (yonghu!= null) {
+            // 将用户的密码设置为固定值“123456”，实际中这样直接设置密码不太安全，可后续优化为更安全的重置逻辑
             yonghu.setPassword("123456");
+            // 通过用户服务层的方法根据用户实体中的ID（已设置好）更新数据库中该用户的密码信息，并获取更新操作的结果（true表示更新成功，false表示更新失败）
             boolean b = yonghuService.updateById(yonghu);
-            if(!b){
+            // 如果更新操作失败（即b为false），返回相应的错误信息
-               return R.error();
+            if (!b) {
+                return R.error();
             }
-        }else{
+        } else {
-           return R.error("账号不存在");
+            // 如果根据用户名未查询到对应的用户，返回账号不存在的错误信息
+            return R.error("账号不存在");
         }
+        // 如果密码重置并更新数据库操作都成功，返回操作成功的结果信息
         return R.ok();
     }
 
 
     /**
-    * 获取用户的session用户信息
+     * 获取用户的session用户信息
-    */
+     * 从当前请求的会话（Session）中获取用户ID，然后根据该ID查询对应的用户实体信息，经过格式转换（实体转视图）和字典表字段转换后返回给前端展示
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是从中获取会话中的用户ID
+     * @return R对象，封装了操作结果及相关数据，成功时包含经过转换后的用户视图信息，若查不到数据则返回相应错误信息
+     */
+
     @RequestMapping("/session")
-    public R getCurrYonghu(HttpServletRequest request){
+    public R getCurrYonghu(HttpServletRequest request) {
-        Integer id = (Integer)request.getSession().getAttribute("userId");
+        // 从当前请求的会话中获取名为“userId”的属性值，并转换为整数类型，该值作为用户的唯一标识，用于后续查询用户信息
+        Integer id = (Integer) request.getSession().getAttribute("userId");
+        // 根据获取到的用户ID从数据库中查询对应的用户实体信息
         YonghuEntity yonghu = yonghuService.selectById(id);
-        if(yonghu !=null){
+        // 如果查询到的用户实体信息不为null，说明找到了对应的用户
-            //entity转view
+        if (yonghu!= null) {
+            // 创建一个用户视图对象，用于转换和返回适合前端展示的数据格式
             YonghuView view = new YonghuView();
-            BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中
+            // 使用Spring提供的BeanUtils工具类将用户实体中的数据复制到用户视图对象中，实现数据格式的转换
+            BeanUtils.copyProperties(yonghu, view);
 
-            //修改对应字典表字段
+            // 调用字典服务层的方法对用户视图对象中的相关字典表字段进行数据转换操作，使数据格式更符合前端展示需求
             dictionaryService.dictionaryConvert(view, request);
             return R.ok().put("data", view);
-        }else {
+        } else {
-            return R.error(511,"查不到数据");
+            // 如果根据用户ID未查询到对应的用户，返回查不到数据的错误信息，错误码为511（具体含义由业务定义）
+            return R.error(511, "查不到数据");
         }
     }
 
 
     /**
-    * 退出
+     * 退出
-    */
+     * 用于处理用户退出登录的操作，通过使当前请求的会话失效来实现清除用户登录状态等相关信息的效果
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，重点是操作其对应的会话对象
+     * @return R对象，封装了操作结果及相关提示信息，这里返回退出成功的提示
+     */
+
     @GetMapping(value = "logout")
     public R logout(HttpServletRequest request) {
+        // 调用HttpServletRequest对象的invalidate方法使当前会话失效，即清除会话中存储的用户登录等相关信息
         request.getSession().invalidate();
+        // 返回操作成功的结果信息，并附带“退出成功”的提示内容
         return R.ok("退出成功");
     }
 
 
-
-
     /**
-    * 前端列表
+     * 前端列表
-    */
+     * 该方法用于获取用户列表数据并返回给前端展示，支持排序参数传入，若未传入排序字段则默认按照"id"字段倒序排列，同时会对获取到的数据进行字典表数据转换操作。
+     * 此接口标注了 @IgnoreAuth 注解，可能意味着该接口不需要进行权限认证即可访问（具体取决于该注解的实际定义和功能）。
+     * @param params 包含查询参数的Map，例如分页参数、排序参数、筛选条件等，通过请求参数传入。
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，比如可能用于后续字典表数据转换等操作获取相关上下文信息，但当前代码中未体现更多复杂使用情况。
+     * @return R对象，封装了操作结果及相关数据，成功时包含分页后的用户数据列表（已经过字典表数据转换）。
+     */
+
     @IgnoreAuth
     @RequestMapping("/list")
-    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
+    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request) {
-        logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
+        logger.debug("list方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
 
-        // 没有指定排序字段就默认id倒序
+        // 判断传入的参数中排序字段是否为空，如果为空（即没有指定排序字段），则将排序字段设置为"id"，表示默认按照"id"字段进行倒序排序（此处未明确体现倒序逻辑，可能在PageUtils或相关数据库查询逻辑中处理）。
-        if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
+        if (StringUtil.isEmpty(String.valueOf(params.get("orderBy")))) {
-            params.put("orderBy","id");
+            params.put("orderBy", "id");
         }
+        // 调用用户服务层的queryPage方法，传入参数params，用于查询符合条件的分页用户数据，返回的PageUtils对象包含了分页相关信息以及用户数据列表等内容。
         PageUtils page = yonghuService.queryPage(params);
 
-        //字典表数据转换
+        // 获取分页数据中的用户视图列表（可能是用于展示给前端的特定格式数据），这里将PageUtils中的用户数据列表取出并强转类型为List<YonghuView>。
-        List<YonghuView> list =(List<YonghuView>)page.getList();
+        List<YonghuView> list = (List<YonghuView>) page.getList();
-        for(YonghuView c:list)
+        // 遍历用户视图列表，对每个用户数据进行字典表数据转换操作，调用dictionaryService的dictionaryConvert方法来处理，目的是使展示的数据符合字典表相关的业务格式要求。
-            dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
+        for (YonghuView c : list)
+            dictionaryService.dictionaryConvert(c, request);
+
         return R.ok().put("data", page);
     }
 
     /**
-    * 前端详情
+     * 前端详情
-    */
+     * 根据传入的用户ID获取对应的用户详细信息，将用户实体数据转换为适合前端展示的视图数据格式，并进行字典表数据转换后返回给前端。
+     * @param id 用户的唯一标识（通常是数据库中的主键ID），通过路径变量{id}传入，用于指定要查询详细信息的用户。
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，如在字典表数据转换时可能需要的一些上下文信息等，但当前代码中未体现更多复杂使用情况。
+     * @return R对象，封装了操作结果及相关数据，成功时包含经过转换后的用户详细信息，若未查询到对应的数据则返回查不到数据的错误提示。
+     */
+
     @RequestMapping("/detail/{id}")
-    public R detail(@PathVariable("id") Long id, HttpServletRequest request){
+    public R detail(@PathVariable("id") Long id, HttpServletRequest request) {
-        logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
+        logger.debug("detail方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
+        // 通过用户服务层的selectById方法，根据传入的用户ID从数据库中查询对应的用户实体信息。
         YonghuEntity yonghu = yonghuService.selectById(id);
-            if(yonghu !=null){
+        if (yonghu!= null) {
 
+            // 创建一个用户视图对象，用于将从数据库查询到的用户实体数据转换为适合前端展示的数据格式。
+            YonghuView view = new YonghuView();
+            // 使用Spring提供的BeanUtils工具类将用户实体中的数据复制到用户视图对象中，实现数据格式的转换，比如将实体中的各个属性值对应复制到视图对象的相应属性中。
+            BeanUtils.copyProperties(yonghu, view);
 
-                //entity转view
+            // 调用字典服务层的dictionaryConvert方法，对用户视图对象中的相关字典表字段进行数据转换操作，使数据格式更符合前端展示需求，比如将字典代码转换为对应的字典名称等。
-                YonghuView view = new YonghuView();
+            dictionaryService.dictionaryConvert(view, request);
-                BeanUtils.copyProperties( yonghu , view );//把实体数据重构到view中
+            return R.ok().put("data", view);
-
+        } else {
-                //修改对应字典表字段
+            // 如果根据传入的用户ID未查询到对应的用户，返回查不到数据的错误信息，错误码为511（具体含义由业务定义）。
-                dictionaryService.dictionaryConvert(view, request);
+            return R.error(511, "查不到数据");
-                return R.ok().put("data", view);
+        }
-            }else {
-                return R.error(511,"查不到数据");
-            }
     }
 
 
     /**
-    * 前端保存
+     * 前端保存
-    */
+     * 用于处理前端提交的新增用户信息的保存操作，会先检查用户名和手机号是否已被其他用户使用（逻辑删除标识为1表示未删除的用户），若未被使用则将新用户信息插入到数据库中。
+     * @param yonghu 包含用户信息的YonghuEntity对象，通过请求体传入，通常是前端提交的新增用户表单数据等内容。
+     * @param request HttpServletRequest对象，用于获取当前请求相关的信息，当前代码中主要用于日志记录展示请求相关信息，但未体现更多复杂使用情况。
+     * @return R对象，封装了操作结果，成功表示保存成功，失败则提示账户或者手机号已经被使用的错误信息。
+     */
+
     @RequestMapping("/add")
-    public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request){
+    public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request) {
-        logger.debug("add方法:,,Controller:{},,yonghu:{}",this.getClass().getName(),yonghu.toString());
+        logger.debug("add方法:,,Controller:{},,yonghu:{}", this.getClass().getName(), yonghu.toString());
+        // 创建查询条件包装器，用于构建查询用户名或手机号是否已存在且未被删除的用户的SQL条件，通过使用EntityWrapper来方便地构建数据库查询条件。
         Wrapper<YonghuEntity> queryWrapper = new EntityWrapper<YonghuEntity>()
-            .eq("username", yonghu.getUsername())
+                .eq("username", yonghu.getUsername())
-            .or()
+                .or()
-            .eq("yonghu_phone", yonghu.getYonghuPhone())
+                .eq("yonghu_phone", yonghu.getYonghuPhone())
-            .andNew()
+                .andNew()
-            .eq("yonghu_delete", 1)
+                .eq("yonghu_delete", 1);
-            ;
+
-        logger.info("sql语句:"+queryWrapper.getSqlSegment());
+        logger.info("sql语句:" + queryWrapper.getSqlSegment());
+        // 根据构建的查询条件查询是否已存在相同用户名或手机号的用户，调用用户服务层的selectOne方法执行查询操作，返回符合条件的用户实体对象（若存在），否则返回null。
         YonghuEntity yonghuEntity = yonghuService.selectOne(queryWrapper);
-        if(yonghuEntity==null){
+        if (yonghuEntity == null) {
+            // 设置新用户的逻辑删除标识为未删除（这里假设1表示未删除），表示该用户数据为有效可用状态。
             yonghu.setYonghuDelete(1);
+            // 设置新用户的创建时间为当前时间，通过创建一个新的Date对象来表示当前时刻。
             yonghu.setCreateTime(new Date());
-        yonghu.setPassword("123456");
+            // 设置新用户的默认密码为"123456"，实际应用中可能需要更安全的密码设置方式，比如密码加密等操作。
-        yonghuService.insert(yonghu);
+            yonghu.setPassword("123456");
+            // 将包含完整信息的新用户实体对象插入到数据库中，调用用户服务层的insert方法执行插入操作。
+            yonghuService.insert(yonghu);
             return R.ok();
-        }else {
+        } else {
-            return R.error(511,"账户或者手机号已经被使用");
+            // 如果查询到已存在相同用户名或手机号的用户，返回账户或者手机号已经被使用的错误信息，错误码为511（具体含义由业务定义）。
+            return R.error(511, "账户或者手机号已经被使用");
         }
     }
 

minsu/minsuguanliw/src/main/java/com/dao/DictionaryDao.java

@@ -11,11 +11,39 @@ import com.entity.view.DictionaryView;
 
 /**
  * 字典表 Dao 接口
- *
+ * 该接口继承自 MyBatis Plus
- * @author 
+ * 的 `BaseMapper` 接口，用于定义与字典表数据持久化操作相关的方法，
+ * 这些方法主要涉及到对数据库中字典表数据的
+ * 查询、插入、更新、删除等操作（继承了 `BaseMapper` 中已有的通用方法），
+ * 同时在此基础上可以自定义扩展针对字典表的特定查询方法，
+ * 方便与数据库进行交互，以满足业务需求。
+ * @author
  */
 public interface DictionaryDao extends BaseMapper<DictionaryEntity> {
 
-   List<DictionaryView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
+   /**
-
+    * 根据分页信息以及查询参数，获取符合条件的字典表数据列表，
-}
+    * 并转换为适合展示的视图实体类列表返回。
+    * 此方法通常用于实现分页查询功能，
+    * 根据传入的分页设置（如页码、每页显示数量等）以及其他自定义的查询条件参数，
+    * 从数据库中检索出对应的字典表数据记录，并将其封装为 `DictionaryView` 类型的列表，
+    * `DictionaryView` 可能包含了字典表数据以及关联的其他相关信息，
+    * 更适合在前端展示或者其他业务场景下使用。
+    *
+    * @param page 分页对象，类型为 `Pagination`，
+    *             通过该对象可以获取分页相关的参数信息（如当前页码、每页显示数量等），
+    *             用于控制数据库查询时的分页逻辑，以获取指定页的数据记录。
+    * @param params 查询参数，是一个 `Map` 类型的数据结构，
+    *               用于传递各种自定义的查询条件，例如可以包含用于筛选字典表数据的关键字、
+    *               按照特定字段进行范围筛选的条件等信息，方便灵活地构建复杂的查询逻辑，
+    *               以获取符合业务需求的字典表数据子集。
+    * @return 返回一个 `List<DictionaryView>` 类型的列表，
+    * 其中包含了符合分页和查询条件的字典表数据记录对应的视图实体类对象，
+    *         列表中的每个 `DictionaryView` 对象都承载了一条字典表数据以及相关的展示信息，
+    *
+    *
+    *
+    *         方便后续在业务逻辑中进行处理和展示给前端等操作。
+    */
+   List<DictionaryView> selectListView(Pagination page, @Param("params") Map<String, Object> params);
+}

minsu/minsuguanliw/src/main/java/com/dao/ForumDao.java

@@ -9,11 +9,11 @@ import com.baomidou.mybatisplus.plugins.pagination.Pagination;
 import org.apache.ibatis.annotations.Param;
 import com.entity.view.ForumView;
 
-/**
+//**
- * 论坛 Dao 接口
+ //* 论坛 Dao 接口
- *
+ //*
- * @author 
+ //* @author
- */
+ //*/
 public interface ForumDao extends BaseMapper<ForumEntity> {
 
    List<ForumView> selectListView(Pagination page,@Param("params")Map<String,Object> params);

minsu/minsuguanliw/src/main/java/com/dao/NewsDao.java

@@ -9,11 +9,11 @@ import com.baomidou.mybatisplus.plugins.pagination.Pagination;
 import org.apache.ibatis.annotations.Param;
 import com.entity.view.NewsView;
 
-/**
+//**
- * 公告信息 Dao 接口
+ // 公告信息 Dao 接口
- *
+ //*
- * @author 
+ //* @author
- */
+ //*/
 public interface NewsDao extends BaseMapper<NewsEntity> {
 
    List<NewsView> selectListView(Pagination page,@Param("params")Map<String,Object> params);

minsu/minsuguanliw/src/main/java/com/dao/TokenDao.java

@@ -1,4 +1,3 @@
-
 package com.dao;
 
 import java.util.List;
@@ -12,11 +11,53 @@ import com.entity.TokenEntity;
 
 /**
  * token
+ * 该接口是与 `token` 相关的数据访问对象（DAO）接口，
+ * 继承自 MyBatis Plus 的 `BaseMapper` 接口，
+ * 意味着它具备了 `BaseMapper`
+ * 提供的通用数据库操作方法（如根据主键查询、插入、更新、删除等操作），
+ * 同时在此基础上自定义扩展了针对 `token`
+ * 数据的特定查询方法，用于满足与 `token` 相关的业务场景下对数据库操作的需求，
+ * 方便与数据库进行交互，获取或操作 `token` 相关的数据记录。
  */
 public interface TokenDao extends BaseMapper<TokenEntity> {
-	
+
+	/**
+	 * 根据给定的条件包装器（Wrapper）查询并返回符合条件的 `TokenEntity` 列表。
+	 * 条件包装器（Wrapper）在 MyBatis Plus 中是一种灵活构建查询条件的方式，
+	 * 它可以组合多个字段的筛选条件（如等于、大于、小于等关系判断）、
+	 * 排序条件以及分组条件等，通过传入的 `Wrapper<TokenEntity>`
+	 * 对象能够精确地定义查询 `token` 数据的逻辑，
+	 * 从数据库中获取满足这些条件的 `TokenEntity` 记录列表。
+	 *
+	 * @param wrapper 用于构建查询条件的包装器对象，
+	 *                   它详细定义了查询 `TokenEntity` 列表的具体条件，
+	 *                例如可以通过它设置只查询某个用户的有效 `token`
+	 *                、特定角色对应的 `token` 等各种复杂的筛选逻辑，
+	 *                作为从数据库中获取期望的 `token` 实体列表的依据。
+	 * @return 返回一个包含符合条件的 `TokenEntity` 对象的列表，
+	 * 列表中的每个 `TokenEntity` 代表了一条符合设定条件的 `token` 相关记录，
+	 *         方便后续在业务逻辑中对这些查询到的 `token` 实体进行进一步处理，如验证、更新等操作。
+	 */
 	List<TokenEntity> selectListView(@Param("ew") Wrapper<TokenEntity> wrapper);
 
-	List<TokenEntity> selectListView(Pagination page,@Param("ew") Wrapper<TokenEntity> wrapper);
+	/**
-	
+	 * 根据给定的分页信息以及条件包装器（Wrapper）查询并返回符合条件的 `TokenEntity` 列表。
-}
+	 * 此方法结合了分页功能与复杂查询条件构建功能，
+	 * 在获取符合特定条件的 `token` 数据的同时，
+	 * 能够按照设定的分页参数（如页码、每页显示数量等）进行分页处理，
+	 * 方便在需要展示大量 `token` 数据时进行分页展示，提高数据查询和展示的效率与用户体验。
+	 *
+	 * @param page 分页对象，类型为 `Pagination`，
+	 *                通过该对象可以获取分页相关的参数信息（如当前页码、每页显示数量等），
+	 *             用于控制数据库查询时的分页逻辑，
+	 *             以获取指定页的数据记录，确保返回的数据符合分页展示的需求。
+	 * @param wrapper 用于构建查询条件的包装器对象，
+	 *                   同样可以定义复杂的查询条件，如筛选特定状态、关联特定用户或角色的 `token` 等，
+	 *                与分页对象配合使用，
+	 *                共同确定从数据库中获取哪些符合条件的 `token` 数据记录以及返回的分页范围。
+	 * @return 返回一个包含符合条件的 `TokenEntity` 对象的列表，
+	 * 该列表中的数据是经过分页处理后符合给定查询条件的 `token` 记录，
+	 *         方便后续在前端分页展示或者其他业务场景下对分页后的 `token` 数据进行处理操作。
+	 */
+	List<TokenEntity> selectListView(Pagination page, @Param("ew") Wrapper<TokenEntity> wrapper);
+}

minsu/minsuguanliw/src/main/java/com/dao/UsersDao.java

@@ -12,11 +12,34 @@ import com.entity.UsersEntity;
 
 /**
  * 用户
+ * 这是一个接口定义，用于定义与用户数据访问相关的方法，该接口继承自BaseMapper<UsersEntity>，
+ * 意味着它会继承BaseMapper中提供的一些基础的数据库操作方法（例如根据ID查询、插入、更新、删除等操作方法），
+ * 同时在此基础上又自定义了一些针对用户数据查询的特定方法，方便在具体的数据访问层实现类中去实现这些方法逻辑，
+ * 以满足业务中对用户数据不同查询需求的操作。
  */
 public interface UsersDao extends BaseMapper<UsersEntity> {
-	
+
+	/**
+	 * 选择列表视图（简单查询版本）
+	 * 定义了一个用于查询用户数据列表的方法，该方法接收一个Wrapper<UsersEntity>类型的参数，
+	 * 这个Wrapper通常用于构建复杂的查询条件（例如添加筛选条件、排序条件等），通过它可以灵活地定义查询用户数据的具体逻辑，
+	 * 返回的是一个UsersEntity类型的列表，即符合查询条件的用户数据集合。
+	 * @param wrapper 用于构建查询条件的包装器对象，调用者可以利用它来设置诸如等于、不等于、大于、小于等各种条件，
+	 *                以此来精确地控制从数据库中获取哪些用户的数据。
+	 * @return 符合查询条件的用户实体对象列表，列表中的每个UsersEntity对象代表一条用户数据记录。
+	 */
 	List<UsersEntity> selectListView(@Param("ew") Wrapper<UsersEntity> wrapper);
 
+	/**
+	 * 选择列表视图（带分页查询版本）
+	 * 定义了另一个用于查询用户数据列表的方法，此方法在简单查询版本的基础上增加了分页功能，
+	 * 它接收一个Pagination类型的分页参数对象和一个用于构建查询条件的Wrapper<UsersEntity>类型的参数，
+	 * 通过分页参数可以指定每页显示的数据条数、当前页码等信息，结合查询条件包装器一起实现带分页功能的用户数据查询操作，
+	 * 返回的同样是一个UsersEntity类型的列表，即当前页符合查询条件的用户数据集合。
+	 * @param page 用于设置分页相关参数的对象，比如可以指定每页的数据量、当前是第几页等，以便从数据库中获取对应分页的数据。
+	 * @param wrapper 用于构建查询条件的包装器对象，和上面的方法类似，用于精确控制查询哪些用户的数据，只是这里配合分页参数共同作用。
+	 * @return 当前页中符合查询条件的用户实体对象列表，列表中的每个UsersEntity对象代表一条用户数据记录。
+	 */
 	List<UsersEntity> selectListView(Pagination page, @Param("ew") Wrapper<UsersEntity> wrapper);
-	
+
 }

minsu/minsuguanliw/src/main/java/com/dao/YonghuDao.java

@@ -11,11 +11,28 @@ import com.entity.view.YonghuView;
 
 /**
  * 用户 Dao 接口
+ * 此接口用于定义针对用户数据进行持久化操作（通常是与数据库交互）相关的方法声明，它继承自BaseMapper<YonghuEntity>，
+ * 也就继承了BaseMapper中提供的如按主键查询、插入、更新、删除等基础数据库操作方法，在此基础上又自定义了特定的查询方法，
+ * 以满足业务中对用户数据更复杂查询需求，方便后续通过对应的实现类来具体实现这些方法逻辑，从而与数据库进行交互获取相应数据。
  *
- * @author 
+ * @author
+ * 这里标注了作者信息（具体作者名未填写完整），通常用于代码的归属及溯源等情况。
  */
 public interface YonghuDao extends BaseMapper<YonghuEntity> {
 
-   List<YonghuView> selectListView(Pagination page,@Param("params")Map<String,Object> params);
+   /**
+    * 选择列表视图
+    * 该方法用于从数据库中查询用户数据列表，并且支持分页功能，它接收一个Pagination类型的分页参数对象以及一个Map<String, Object>类型的参数对象，
+    * 分页参数用于控制每页显示的数据量、当前页码等分页相关信息，而params参数则可以用于传递各种灵活的查询条件（例如筛选条件、排序条件等），
+    * 返回的是一个YonghuView类型的列表，YonghuView可能是专门用于展示给前端或者在业务逻辑中使用的用户数据视图对象，
+    * 即符合传入的分页及其他查询条件的用户数据集合（以视图对象形式呈现）。
+    *
+    * @param page 用于指定分页相关设置的对象，比如每页的记录条数、当前所在页码等信息，通过这个参数来实现分页查询功能，
+    *             使得可以按照指定的分页规则从数据库中获取相应的数据。
+    * @param params 用于传递各种查询条件的Map对象，键值对形式，其中键可以是自定义的表示不同查询条件的字符串（如"nameLike"表示按用户名模糊查询等），
+    *               值则是对应条件的具体内容（如模糊查询的关键字等），以此可以灵活构建出多样化的查询逻辑，从数据库中获取想要的用户数据子集。
+    * @return 符合传入的分页条件以及其他查询条件的用户视图对象列表，每个YonghuView对象代表一条符合要求的用户数据记录，方便后续在业务中展示或处理。
+    */
+   List<YonghuView> selectListView(Pagination page, @Param("params") Map<String, Object> params);
 
 }

minsu/minsuguanliw/src/main/java/com/entity/DictionaryEntity.java

@@ -22,212 +22,374 @@ import com.baomidou.mybatisplus.enums.IdType;
 
 /**
  * 字典表
- *
+ * 该类用于表示字典表相关的数据实体，
- * @author 
+ * 对应数据库中的 `dictionary` 表结构，存储字典表中的各项数据信息，
+ * 实现了 `Serializable` 接口，以便能在网络传输、
+ * 持久化存储（如保存到文件、数据库等情况）时进行序列化和反序列化操作，保证数据的完整性和可恢复性。
+ * @author
  * @email
  */
 @TableName("dictionary")
 public class DictionaryEntity<T> implements Serializable {
     private static final long serialVersionUID = 1L;
 
+    // **
+    //  * 默认构造函数，用于创建一个空的 `DictionaryEntity`
+    //  对象实例，在需要先创建对象再逐步设置属性值的场景下使用，
+    //  * 例如在一些复杂业务逻辑中，先实例化对象，
+    //  后续根据不同的数据源或条件来分别为各个属性赋值，提供了一种灵活构建对象的方式。
+    //  */
+    public DictionaryEntity() {
 
-	public DictionaryEntity() {
+    }
-
-	}
-
-	public DictionaryEntity(T t) {
-		try {
-			BeanUtils.copyProperties(this, t);
-		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
 
+    // **
+    //  * 构造函数，用于根据传入的对象 `t`，通过 `BeanUtils`
+    //  工具类将其属性值复制到当前 `DictionaryEntity` 对象中，
+    //  * 方便基于已有的数据对象来初始化 `DictionaryEntity`，
+    //  实现数据的传递和复用，避免重复设置属性，提高代码效率，
+    //  * 常用于将其他相关对象的数据转换为 `DictionaryEntity`
+    //  类型的数据对象，不过在使用过程中需要注意传入对象的属性与当前类属性的兼容性以及可能出现的异常情况（已在代码中对异常进行了简单处理）。
+    //  * @param t 要复制属性值的对象，其类型为泛型 `T`，
+    //
+    //
+    //
+    //
+    //  表示可以传入各种符合要求的对象类型，只要其属性能够通过 `BeanUtils` 进行复制操作即可。
+    //  */
+    public DictionaryEntity(T t) {
+        try {
+            BeanUtils.copyProperties(this, t);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+    }
 
-    /**
+    // **
-     * 主键
+    //  * 主键，用于唯一标识字典表中的每一条记录，
-     */
+    //
+    //  通过 `@TableId` 注解指定该字段为主键，并设置主键的生成策略为自增长（`IdType.AUTO`），
+    //  * 在向数据库插入新记录时，系统会按照自增长规则自动为该字段赋予唯一的值，
+    //
+    //  方便在数据库操作（如查询、更新、删除等）中精准定位到特定的字典表数据行，确保数据的唯一性和可操作性。
+    //  * @TableField 注解用于明确该字段在数据库表中对应的列名，
+    //
+    //  这里对应 `id` 列，使得对象属性与数据库表字段之间建立准确的映射关系。
+    //  */
     @TableId(type = IdType.AUTO)
     @TableField(value = "id")
-
     private Integer id;
 
-
+    // **
-    /**
+    //  * 字段，用于存储字典表中某个条目的特定代码或者标识信息，
-     * 字段
+    //
-     */
+    //  通过 `@TableField` 注解指定其在数据库表中对应的列名为 `dic_code`，
+    //  * 例如该字段可以是代表不同分类、类型等的代码值，
+    //
+    //  在业务逻辑中可基于此字段进行相关的查询、匹配等操作，以区分不同的字典项。
+    //  */
     @TableField(value = "dic_code")
-
     private String dicCode;
 
-
+    // **
-    /**
+    //  * 字段名，与 `dicCode` 相对应，
-     * 字段名
+    //
-     */
+    //  用于存储该字段对应的直观的名称描述，通过 `@TableField` 注解对应数据库表中的 `dic_name` 列，
+    //  * 方便在前端展示或者业务逻辑处理中让人更容易理解该字段所代表的含义，
+    //
+    //  例如如果 `dicCode` 是分类代码，那 `dicName` 就是具体的分类名称，增强了数据的可读性。
+    //  */
     @TableField(value = "dic_name")
-
     private String dicName;
 
-
+    // **
-    /**
+    //  * 编码，可能是对字典表中各项进行编号的一个整数值，
-     * 编码
+    //
-     */
+    //  通过 `@TableField` 注解对应数据库表中的 `code_index` 列，
+    //  * 用于在内部对字典项进行排序、索引或者作为另一种标识方式，
+    //
+    //  在一些需要按照特定顺序处理字典数据或者通过编号快速查找字典项的业务场景中会发挥作用。
+    //  */
     @TableField(value = "code_index")
-
     private Integer codeIndex;
 
-
+    // **
-    /**
+    //  * 编码名字，与 `codeIndex` 相对应，
-     * 编码名字
+    //
-     */
+    //  是对该编码所代表含义的文字描述，通过 `@TableField` 注解对应数据库表中的 `index_name` 列，
+    //  * 同样是为了提高数据的可读性和可理解性，
+    //
+    //  便于在展示给用户或者业务逻辑处理中清晰地知晓该编码具体对应的内容。
+    //  */
     @TableField(value = "index_name")
-
     private String indexName;
 
-
+    // **
-    /**
+    //  * 父字段id，用于表示当前字典项在层级结构中的上级字段的唯一标识（如果字典表存在层级关系的话），
-     * 父字段id
+    //
-     */
+    //  通过 `@TableField` 注解对应数据库表中的 `super_id` 列，
+    //  * 借助这个 `superId` 可以构建字典项之间的父子关联关系，
+    //
+    //  方便进行树形结构数据的展示、查询以及相关业务逻辑处理（比如查找某个分类下的子分类等情况）。
+    //  */
     @TableField(value = "super_id")
-
     private Integer superId;
 
-
+    // **
-    /**
+    //  * 备注，用于存储一些对该字典项的额外说明信息，
-     * 备注
+    //
-     */
+    //  通过 `@TableField` 注解对应数据库表中的 `beizhu` 列，
+    //  * 例如该项的特殊用途、适用范围、创建背景等内容，
+    //
+    //  在需要详细了解字典项相关细节或者进行一些辅助性的业务逻辑判断时，可以参考备注中的信息。
+    //  */
     @TableField(value = "beizhu")
-
     private String beizhu;
 
+    // **
+    //  * 创建时间，记录该字典表记录的创建时间点，
+    //
+    //  通过 `@JsonFormat` 和 `@DateTimeFormat` 注解来规范时间格式的序列化与格式化处理，
+    //  * 确保在前后端交互以及数据存储等场景下时间格式的一致性，
+    //
+    //  同时使用 `@TableField` 注解指定其在数据库表中对应的列名为 `create_time`，并设置了 `FieldFill.INSERT` 填充策略，
+    //  * 意味着在向数据库插入新记录时，
+    //
+    //  该字段会自动填充当前时间（通常由 MyBatis Plus 根据配置来完成），例如在按照时间顺序查询字典表数据、统计不同时间段创建的数据量等业务场景中会用到该时间信息。
+    //  * @JsonFormat 注解用于控制在将对象转换为JSON格式时时间的显示格式，
+    //
+    //  这里设置为中文（`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
+    @TableField(value = "create_time", fill = FieldFill.INSERT)
+    private Date createTime;
 
-    /**
+    // **
-     * 创建时间
+    //  * 获取：主键，
-     */
+    //
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    //  对外提供获取主键值（`id`）的方法，方便在其他类中访问该 `DictionaryEntity` 对象的主键信息，
-	@DateTimeFormat
-    @TableField(value = "create_time",fill = FieldFill.INSERT)
 
-    private Date createTime;
 
 
-    /**
+    //  * 例如在进行数据库查询结果映射或者业务逻辑处理中需要用到字典表记录主键时可调用此方法获取，返回对应的整数值。
-	 * 设置：主键
+    //  * @return 返回主键对应的整数值。
-	 */
+    //  */
     public Integer getId() {
         return id;
     }
-    /**
-	 * 获取：主键
-	 */
 
+    // **
+    //  * 设置：主键，用于设置该对象的主键值，
+    //
+    //  通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用，
+    //  * 不过由于主键一般是自增长且由数据库管理，
+    //
+    //  实际业务中手动设置的情况相对较少，但保留此方法以满足可能的特殊需求（如数据迁移等场景），
+    //  * 通过传入对应的整数值来更新主键信息。
+    //  * @param id 要设置的主键整数值。
+    //  */
     public void setId(Integer id) {
         this.id = id;
     }
-    /**
+
-	 * 设置：字段
+    // **
-	 */
+    //  * 获取：字段，
+    //
+    //
+    //  对外提供获取字段值（`dicCode`）的方法，以便在业务逻辑中根据该字段进行相关操作，比如查询特定代码的字典项、
+    //  * 根据代码进行匹配判断等情况时可调用此方法获取字段值，
+    //
+    //  返回对应的字符串内容。
+    //  * @return 返回字段对应的字符串值。
+    //  */
     public String getDicCode() {
         return dicCode;
     }
-    /**
-	 * 获取：字段
-	 */
 
+    // **
+    //  * 设置：字段，用于更新字段值（`dicCode`），
+    //
+    //
+    //  例如在修改字典表记录中该字段的代码内容后，调用此方法来保存新的代码信息，以反映字典项的变化。
+    //  * @param dicCode 要设置的字段字符串值。
+    //  */
     public void setDicCode(String dicCode) {
         this.dicCode = dicCode;
     }
-    /**
+
-	 * 设置：字段名
+    // **
-	 */
+    //  * 获取：字段名，对外提供获取字段名（`dicName`）的方法，
+    //
+    //
+    //  在需要展示字典项的名称给用户或者在业务逻辑中基于名称进行相关处理（如筛选、排序等）时，
+    //  * 可调用此方法获取对应的字符串内容，方便操作和展示。
+    //  * @return 返回字段名对应的字符串值。
+    //  */
     public String getDicName() {
+        androidx.annotation.NonNull();
         return dicName;
     }
-    /**
-	 * 获取：字段名
-	 */
 
+    // **
+    //  * 设置：字段名，用于更新字段名（`dicName`），
+    //
+    //  比如对字典项的名称进行修改后，通过此方法保存新的名称信息，确保名称能准确反映字典项的实际含义。
+    //  * @param dicName 要设置的字段名字符串值。
+    //  */
     public void setDicName(String dicName) {
         this.dicName = dicName;
     }
-    /**
+
-	 * 设置：编码
+    // **
-	 */
+    //  * 获取：编码，对外提供获取编码值（`codeIndex`）的方法，
+    //
+    //  在涉及到按照编码进行排序、查找特定编码的字典项等业务场景中，
+    //  * 可调用此方法获取对应的整数值，便于进行相应的业务处理。
+    //  * @return 返回编码对应的整数值。
+    //  */
     public Integer getCodeIndex() {
         return codeIndex;
     }
-    /**
-	 * 获取：编码
-	 */
 
+    // **
+    //  * 设置：编码，用于更新编码值（`codeIndex`），
+    //
+    //  例如调整字典项的编号顺序或者重新分配编码后，
+    //
+    //  调用此方法来保存新的编码信息，以符合业务要求的编码规则。
+    //  * @param codeIndex 要设置的编码整数值。
+    //  */
     public void setCodeIndex(Integer codeIndex) {
         this.codeIndex = codeIndex;
     }
-    /**
+
-	 * 设置：编码名字
+    // **
-	 */
+    //  * 获取：编码名字，对外提供获取编码名字（`indexName`）的方法，
+    //
+    //  在需要展示编码对应的具体含义或者基于名称进行业务逻辑处理（如匹配、筛选等）时，
+    //  * 可调用此方法获取对应的字符串内容，增强数据的可读性和可操作性。
+    //  * @return 返回编码名字对应的字符串值。
+    //  */
     public String getIndexName() {
         return indexName;
     }
-    /**
-	 * 获取：编码名字
-	 */
 
+    // **
+    //  * 设置：编码名字，用于更新编码名字（`indexName`），
+    //
+    //  比如对编码所代表的含义进行重新定义或者修改描述后，
+    //
+    //  通过此方法保存新的名称信息，
+    //  * 以便准确传达编码的实际意义。
+    //  * @param indexName 要设置的编码名字符串值。
+    //  */
     public void setIndexName(String indexName) {
         this.indexName = indexName;
     }
-    /**
+
-	 * 设置：父字段id
+    // **
-	 */
+    //  * 获取：父字段id，对外提供获取父字段id（`superId`）的方法，
+    //
+    //  在处理字典表的层级关系数据时，比如查找某个父项下的子项、
+    //  * 判断字典项的层级归属等业务场景中，
+    //
+    //
+    //  可调用此方法获取对应的整数值，方便进行相关的关联操作和业务逻辑处理。
+    //  * @return 返回父字段id对应的整数值。
+    //  */
     public Integer getSuperId() {
         return superId;
     }
-    /**
-	 * 获取：父字段id
-	 */
 
+    // **
+    //  * 设置：父字段id，用于更新父字段id（`superId`）的值，
+    //
+    //  例如调整字典项的层级结构、变更上级字段后，通过此方法保存新的父字段id信息，
+    //  * 以正确反映字典项在层级关系中的位置变化。
+    //  * @param superId 要设置的父字段id整数值。
+    //  */
     public void setSuperId(Integer superId) {
         this.superId = superId;
     }
-    /**
+
-	 * 设置：备注
+    // **
-	 */
+    //  * 获取：备注，对外提供获取备注信息（`beizhu`）的方法，
+    //
+    //
+    //  在需要查看字典项的额外说明或者根据备注内容进行一些特殊业务逻辑判断（如判断适用范围等）时，
+    //  * 可调用此方法获取对应的字符串内容，辅助业务处理。
+    //  * @return 返回备注对应的字符串值。
+    //  */
     public String getBeizhu() {
         return beizhu;
     }
-    /**
-	 * 获取：备注
-	 */
 
+    // **
+    //  * 设置：备注，用于更新备注信息（`beizhu`），
+    //
+    //  例如添加、修改字典项的备注内容后，
+    //
+    //  通过此方法保存新的备注信息，方便后续查看和参考。
+    //  * @param beizhu 要设置的备注字符串值。
+    //  */
     public void setBeizhu(String beizhu) {
         this.beizhu = beizhu;
     }
-    /**
+
-	 * 设置：创建时间
+    // **
-	 */
+    //  * 获取：创建时间，
+    //
+    //  对外提供获取创建时间（`createTime`）的方法，在展示字典表记录的创建时间、按照时间范围查询字典项、
+    //  * 统计不同时间段创建的数据量等业务场景中，
+    //
+    //
+    //  可调用此方法获取对应的 `Date` 类型对象，用于后续的时间相关操作和展示。
+    //  * @return 返回创建时间对应的 `Date` 类型对象。
+    //  */
     public Date getCreateTime() {
         return createTime;
     }
-    /**
-	 * 获取：创建时间
-	 */
 
+    // **
+    //  * 设置：创建时间，用于更新创建时间（`createTime`）的值，
+    //
+    //  不过在实际业务中通常创建时间是在记录首次创建时自动设置，较少进行手动更新，
+    //  * 但保留此方法以满足可能的特殊需求（如数据迁移、时间校准等场景下对创建时间进行调整），
+    //
+    //  通过传入对应的 `Date` 类型对象来更新创建时间信息。
+    //  * @param createTime 要设置的创建时间对应的 `Date` 类型对象。
+    //  */
     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
 
+    // **
+    //  * 重写 `toString` 方法，用于返回 `DictionaryEntity`
+    //
+    //  对象的字符串表示形式，方便在调试、日志输出以及一些需要以字符串形式展示对象内容的场景中使用，
+    //  * 按照自定义的格式将对象的各个属性值拼接成一个字符串，
+    //
+    //  使得可以直观地查看对象的属性信息，便于开发过程中的调试和问题排查等操作。
+
+
+
+    //  * 返回的字符串格式形如 "Dictionary{" + "id=" + id + ", dicCode=" + dicCode + ", dicName=" + dicName + ", codeIndex=" + codeIndex + ", indexName=" + indexName + ", superId=" + superId + ", beizhu=" + beizhu + ", createTime=" + createTime + "}"，
+    //  * 其中展示了各个属性的名称和对应的值，方便快速了解对象的状态。
+    //  */
     @Override
     public String toString() {
         return "Dictionary{" +
-            "id=" + id +
+                "id=" + id +
-            ", dicCode=" + dicCode +
+                ", dicCode=" + dicCode +
-            ", dicName=" + dicName +
+                ", dicName=" + dicName +
-            ", codeIndex=" + codeIndex +
+                ", codeIndex=" + codeIndex +
-            ", indexName=" + indexName +
+                ", indexName=" + indexName +
-            ", superId=" + superId +
+                ", superId=" + superId +
-            ", beizhu=" + beizhu +
+                ", beizhu=" + beizhu +
-            ", createTime=" + createTime +
+                ", createTime=" + createTime +
-        "}";
+                "}";
-    }
+    }
-}
+}

minsu/minsuguanliw/src/main/java/com/entity/FangjianEntity.java

@@ -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 
+ * @author  // 此处应该填写作者相关信息，可能是开发人员的姓名等，但代码中未明确给出具体值
- * @email
+ * @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")
+    @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
-    @TableField(value = "create_time",fill = FieldFill.INSERT)
+    @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 +
+                "id=" + id +
-            ", fangjianName=" + fangjianName +
+                ", fangjianName=" + fangjianName +
-            ", fangjianPhoto=" + fangjianPhoto +
+                ", fangjianPhoto=" + fangjianPhoto +
-            ", fangjianTese=" + fangjianTese +
+                ", fangjianTese=" + fangjianTese +
-            ", fangjianPeizhi=" + fangjianPeizhi +
+                ", fangjianPeizhi=" + fangjianPeizhi +
-            ", fangjianShangpin=" + fangjianShangpin +
+                ", fangjianShangpin=" + fangjianShangpin +
-            ", fangjianFuwu=" + fangjianFuwu +
+                ", fangjianFuwu=" + fangjianFuwu +
-            ", fangjianMoney=" + fangjianMoney +
+                ", fangjianMoney=" + fangjianMoney +
-            ", fangjianTypes=" + fangjianTypes +
+                ", fangjianTypes=" + fangjianTypes +
-            ", fangjianNumber=" + fangjianNumber +
+                ", fangjianNumber=" + fangjianNumber +
-            ", fangjianClicknum=" + fangjianClicknum +
+                ", fangjianClicknum=" + fangjianClicknum +
-            ", fangjianContent=" + fangjianContent +
+                ", fangjianContent=" + fangjianContent +
-            ", createTime=" + createTime +
+                ", createTime=" + createTime +
-        "}";
+                "}";
-    }
+    }
-}

minsu/minsuguanliw/src/main/java/com/entity/FangjianLiuyanEntity.java

@@ -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 
+ * @author  // 此处应该填写作者相关信息，可能是开发人员的姓名等，但代码中未明确给出具体值
- * @email
+ * @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")
+    @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
-    @TableField(value = "insert_time",fill = FieldFill.INSERT)
+    @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")
+    @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
-    @TableField(value = "update_time",fill = FieldFill.UPDATE)
+    @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")
+    @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
-    @TableField(value = "create_time",fill = FieldFill.INSERT)
+    @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 +
+                "id=" + id +
-            ", fangjianId=" + fangjianId +
+                ", fangjianId=" + fangjianId +
-            ", yonghuId=" + yonghuId +
+                ", yonghuId=" + yonghuId +
-            ", fangjianLiuyanText=" + fangjianLiuyanText +
+                ", fangjianLiuyanText=" + fangjianLiuyanText +
-            ", replyText=" + replyText +
+                ", replyText=" + replyText +
-            ", insertTime=" + insertTime +
+                ", insertTime=" + insertTime +
-            ", updateTime=" + updateTime +
+                ", updateTime=" + updateTime +
-            ", createTime=" + createTime +
+                ", createTime=" + createTime +
-        "}";
+                "}";
-    }
+    }
-}

minsu/minsuguanliw/src/main/java/com/entity/FangjianOrderEntity.java

@@ -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 
+ * @author  // 此处应该填写作者相关信息，可能是开发人员的姓名等，但代码中未明确给出具体值，用于标识代码的创作者
- * @email
+ * @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")
+    @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd")
-	@DateTimeFormat
+    @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")
+    @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
-    @TableField(value = "create_time",fill = FieldFill.INSERT)
+    @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 +
+                "id=" + id +
-            ", fangjianId=" + fangjianId +
+                ", fangjianId=" + fangjianId +
-            ", yonghuId=" + yonghuId +
+                ", yonghuId=" + yonghuId +
-            ", fangjianOrderTime=" + fangjianOrderTime +
+                ", fangjianOrderTime=" + fangjianOrderTime +
-            ", fangjianOrderText=" + fangjianOrderText +
+                ", fangjianOrderText=" + fangjianOrderText +
-            ", fangjianOrderTypes=" + fangjianOrderTypes +
+                ", fangjianOrderTypes=" + fangjianOrderTypes +
-            ", createTime=" + createTime +
+                ", createTime=" + createTime +
-        "}";
+                "}";
-    }
+    }
-}

minsu/minsuguanliw/src/main/java/com/entity/ForumEntity.java

@@ -22,243 +22,292 @@ import com.baomidou.mybatisplus.enums.IdType;
 
 /**
  * 论坛
+ * 该类定义了论坛相关的数据实体，
  *
- * @author 
+ *
+ * 对应数据库中的"forum"表，用于存储和传递论坛帖子等相关信息，
+ * 包含了帖子的各种属性以及对应的Getter、
+ *
+ * Setter方法，同时实现了Serializable接口以支持对象的序列化操作。
+ * @author  wangmuzi
  * @email
  */
 @TableName("forum")
 public class ForumEntity<T> implements Serializable {
+    // 用于定义序列化版本号，
+    // 保证在对象序列化和反序列化过程中的兼容性，
+    // 当类的结构发生变化时可更新该版本号
     private static final long serialVersionUID = 1L;
 
+    // 无参构造函数，用
+    // 于创建ForumEntity对象的默认实例，
+    // 在一些框架或反射创建对象的场景中可能会用到
+    public ForumEntity() {
 
-	public ForumEntity() {
+    }
-
-	}
-
-	public ForumEntity(T t) {
-		try {
-			BeanUtils.copyProperties(this, t);
-		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
 
+   // 有参构造函数，接受一个泛型参数t
+    //// ，尝试将t对象的属性值复制到当前ForumEntity对象中，
+    //// 通过BeanUtils进行属性复制
+    // ，若出现异常则打印堆栈信息，可用于基于已有对象来初始化该实体对象的场景。
+    public ForumEntity(T t) {
+        try {
+            BeanUtils.copyProperties(this, t);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+    }
 
-    /**
+    //**
-     * 主键
+     //* 主键
+    // * 对应数据库表中记录的唯一标识符，
+     * 使用了MyBatis Plus的注解来指定主键的相关配置，
+     * 如设置主键生成策略为自增长（IdType.AUTO），
+     * 并指定了数据库表中的字段名为"id"。
      */
     @TableId(type = IdType.AUTO)
     @TableField(value = "id")
-
     private Integer id;
 
-
+   // /**
-    /**
+    // * 帖子标题
-     * 帖子标题
+    // * 用于存储论坛帖子的标题信息，
+    // * 通过@TableField注解指定了在数据库表"forum"中对应的字段名为"forum_name"。
      */
     @TableField(value = "forum_name")
-
     private String forumName;
 
-
     /**
      * 用户
-     */
+    // * 用于存储发布该帖子的用户的唯一标识（可能关联到用户表中的用户ID），
+    // * 通过@TableField注解指定了在数据库表"forum"中对应的字段名为"yonghu_id"。
+    // */
     @TableField(value = "yonghu_id")
-
     private Integer yonghuId;
 
-
     /**
-     * 管理员
+    // * 管理员
-     */
+     //* 用于存储与该帖子相关的管理员用户的唯一标识（可能在一些管理操作或权限相关场景中有作用），
+    // * 通过@TableField注解指定了在数据库表"forum"中对应的字段名为"users_id"。
+    //*/
     @TableField(value = "users_id")
-
     private Integer usersId;
 
-
+   // /**
-    /**
+     //* 发布内容
-     * 发布内容
+   //  * 用于存储论坛帖子的具体内容信息，通过@TableField注解指定了在数据库表"forum"中对应的字段名为"forum_content"。
-     */
+     //*/
     @TableField(value = "forum_content")
-
     private String forumContent;
 
-
+   // /**
-    /**
+    // * 父id
-     * 父id
+    // * 可能用于表示帖子之间的层级关系（比如回复帖子时关联到原帖子的ID等情况），
-     */
+     //* 通过@TableField注解指定了在数据库表"forum"中对应的字段名为"super_ids"。
+   //  */
     @TableField(value = "super_ids")
-
     private Integer superIds;
 
-
+   // /**
-    /**
+     //* 帖子状态
-     * 帖子状态
+    // * 用于存储帖子当前所处的状态信息（例如审核状态、是否可见等不同状态，具体含义由业务定义），
-     */
+     //* 通过@TableField注解指定了在数据库表"forum"中对应的字段名为"forum_state_types"。
+     //*/
     @TableField(value = "forum_state_types")
-
     private Integer forumStateTypes;
 
-
+    ///**
-    /**
+    // * 发帖时间
-     * 发帖时间
+     //* 用于记录帖子发布的时间，使用了@JsonFormat注解来指定时间格式化的相关配置，如设置时区、格式化模式等，
-     */
+    // * 使其在序列化为JSON等格式时能以指定格式展示时间，同时通过@DateTimeFormat注解用于在接收前端传入时间格式数据时进行解析，
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    // * 并且通过@TableField注解指定了该字段在数据库表"forum"中对应的字段名为"insert_time"以及其填充策略为插入时自动填充（FieldFill.INSERT）。
-	@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注解指定了该字段在数据库表"forum"中对应的字段名为"update_time"以及其填充策略为更新时自动填充（FieldFill.UPDATE）。
-    @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")
-    @TableField(value = "update_time",fill = FieldFill.UPDATE)
+    @DateTimeFormat
-
+    @TableField(value = "update_time", fill = FieldFill.UPDATE)
     private Date updateTime;
 
-
+    ///**
-    /**
+     //* 创建时间
-     * 创建时间
+     //* 用于记录帖子相关记录在系统中创建的时间，使用了@JsonFormat和@DateTimeFormat注解来处理时间的格式化和解析，
-     */
+     //* 通过@TableField注解指定了该字段在数据库表"forum"中对应的字段名为"create_time"以及其填充策略为插入时自动填充（FieldFill.INSERT）。
-    @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")
-    @TableField(value = "create_time",fill = FieldFill.INSERT)
+    @DateTimeFormat
-
+    @TableField(value = "create_time", fill = FieldFill.INSERT)
     private Date createTime;
 
-
+    ///**
-    /**
+     //* 设置：主键
-	 * 设置：主键
+     //* Getter方法，用于获取主键id的值，外部代码可以通过该方法获取当前ForumEntity对象的主键值。
-	 */
+     //*/
     public Integer getId() {
         return id;
     }
-    /**
-	 * 获取：主键
-	 */
 
+    ///**
+     //* 获取：主键
+     //* Setter方法，用于设置主键id的值，外部代码可以通过该方法来修改当前ForumEntity对象的主键值。
+     //*/
     public void setId(Integer id) {
         this.id = id;
     }
-    /**
+
-	 * 设置：帖子标题
+    ///**
-	 */
+    // * 设置：帖子标题
+     //* Getter方法，用于获取帖子标题forumName的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子标题。
+    // */
     public String getForumName() {
         return forumName;
     }
-    /**
-	 * 获取：帖子标题
-	 */
 
+    ///**
+    // * 获取：帖子标题
+     //* Setter方法，用于设置帖子标题forumName的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子标题。
+     //*/
     public void setForumName(String forumName) {
         this.forumName = forumName;
     }
-    /**
+
-	 * 设置：用户
+    ///**
-	 */
+    // * 设置：用户
+     //* Getter方法，用于获取用户ID（yonghuId）的值，外部代码可以通过该方法获取当前ForumEntity对象所关联的用户标识。
+     //*/
+    //
+    //
+    //
+    //
     public Integer getYonghuId() {
         return yonghuId;
     }
-    /**
-	 * 获取：用户
-	 */
 
+   // /**
+     //* 获取：用户
+     //* Setter方法，用于设置用户ID（yonghuId）的值，外部代码可以通过该方法来修改当前ForumEntity对象所关联的用户标识。
+     //*/
     public void setYonghuId(Integer yonghuId) {
         this.yonghuId = yonghuId;
     }
-    /**
+
-	 * 设置：管理员
+    ///**
-	 */
+     //* 设置：管理员
+    // * Getter方法，用于获取管理员用户ID（usersId）的值，外部代码可以通过该方法获取当前ForumEntity对象所关联的管理员标识。
+     //*/
     public Integer getUsersId() {
         return usersId;
     }
-    /**
-	 * 获取：管理员
-	 */
 
+    ///**
+    // * 获取：管理员
+    // * Setter方法，用于设置管理员用户ID（usersId）的值，外部代码可以通过该方法来修改当前ForumEntity对象所关联的管理员标识。
+    // */
     public void setUsersId(Integer usersId) {
         this.usersId = usersId;
     }
-    /**
+
-	 * 设置：发布内容
+    ///**
-	 */
+     //* 设置：发布内容
+     //* Getter方法，用于获取帖子发布内容（forumContent）的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子具体内容。
+    //*/
     public String getForumContent() {
         return forumContent;
     }
-    /**
-	 * 获取：发布内容
-	 */
 
+   // /**
+     //* 获取：发布内容
+     //* Setter方法，用于设置帖子发布内容（forumContent）的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子具体内容。
+    //*/
     public void setForumContent(String forumContent) {
         this.forumContent = forumContent;
     }
-    /**
+
-	 * 设置：父id
+    ///**
-	 */
+     //* 设置：父id
+     //* Getter方法，用于获取父ID（superIds）的值，外部代码可以通过该方法获取当前ForumEntity对象所关联的父级帖子标识（如果有层级关系的话）。
+    // */
     public Integer getSuperIds() {
         return superIds;
     }
-    /**
-	 * 获取：父id
-	 */
 
+    ///**
+    // * 获取：父id
+     //* Setter方法，用于设置父ID（superIds）的值，外部代码可以通过该方法来修改当前ForumEntity对象所关联的父级帖子标识（如果有层级关系的话）。
+    // */
     public void setSuperIds(Integer superIds) {
         this.superIds = superIds;
     }
-    /**
+
-	 * 设置：帖子状态
+   // /**
-	 */
+    // * 设置：帖子状态
+     //* Getter方法，用于获取帖子状态（forumStateTypes）的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子当前状态信息。
+     //*/
     public Integer getForumStateTypes() {
         return forumStateTypes;
     }
-    /**
-	 * 获取：帖子状态
-	 */
 
+    ///**
+    // * 获取：帖子状态
+    // * Setter方法，用于设置帖子状态（forumStateTypes）的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子当前状态信息。
+     //*/
     public void setForumStateTypes(Integer forumStateTypes) {
         this.forumStateTypes = forumStateTypes;
     }
-    /**
+
-	 * 设置：发帖时间
+    //**
-	 */
+     //* 设置：发帖时间
+    // * Getter方法，用于获取发帖时间（insertTime）的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子发布时间信息。
+   //  */
     public Date getInsertTime() {
         return insertTime;
     }
-    /**
-	 * 获取：发帖时间
-	 */
 
+    ///**
+     //* 获取：发帖时间
+    ////* Setter方法，用于设置发帖时间（insertTime）的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子发布时间信息。
+     //*/
     public void setInsertTime(Date insertTime) {
         this.insertTime = insertTime;
     }
-    /**
+
-	 * 设置：修改时间
+    ///**
-	 */
+    // * 设置：修改时间
+     //* Getter方法，用于获取修改时间（updateTime）的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子最后修改时间信息。
+    // */
     public Date getUpdateTime() {
         return updateTime;
     }
-    /**
-	 * 获取：修改时间
-	 */
 
+    ///**
+     //* 获取：修改时间
+     //* Setter方法，用于设置修改时间（updateTime）的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子最后修改时间信息。
+    // */
     public void setUpdateTime(Date updateTime) {
         this.updateTime = updateTime;
     }
-    /**
+
-	 * 设置：创建时间
+    ///**
-	 */
+    // * 设置：创建时间
+    // * Getter方法，用于获取创建时间（createTime）的值，外部代码可以通过该方法获取当前ForumEntity对象的帖子相关记录创建时间信息。
+    // */
     public Date getCreateTime() {
         return createTime;
     }
-    /**
-	 * 获取：创建时间
-	 */
 
+   // /**
+    // * 获取：创建时间
+     //* Setter方法，用于设置创建时间（createTime）的值，外部代码可以通过该方法来修改当前ForumEntity对象的帖子相关记录创建时间信息。
+    // */
     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
@@ -266,16 +315,16 @@ public class ForumEntity<T> implements Serializable {
     @Override
     public String toString() {
         return "Forum{" +
-            "id=" + id +
+                "id=" + id +
-            ", forumName=" + forumName +
+                ", forumName=" + forumName +
-            ", yonghuId=" + yonghuId +
+                ", yonghuId=" + yonghuId +
-            ", usersId=" + usersId +
+                ", usersId=" + usersId +
-            ", forumContent=" + forumContent +
+                ", forumContent=" + forumContent +
-            ", superIds=" + superIds +
+                ", superIds=" + superIds +
-            ", forumStateTypes=" + forumStateTypes +
+                ", forumStateTypes=" + forumStateTypes +
-            ", insertTime=" + insertTime +
+                ", insertTime=" + insertTime +
-            ", updateTime=" + updateTime +
+                ", updateTime=" + updateTime +
-            ", createTime=" + createTime +
+                ", createTime=" + createTime +
-        "}";
+                "}";
     }
-}
+}

minsu/minsuguanliw/src/main/java/com/entity/NewsEntity.java

@@ -20,180 +20,251 @@ import com.baomidou.mybatisplus.annotations.TableField;
 import com.baomidou.mybatisplus.enums.FieldFill;
 import com.baomidou.mybatisplus.enums.IdType;
 
-/**
+///**
- * 公告信息
+ //* 公告信息
- *
+ // 该类定义了公告信息相关的数据实体，对应数据库中的"news"表，用于存储和传递公告相关的各种属性信息，
- * @author 
+ //* 同时实现了Serializable接口，使其能够进行序列化操作，方便在网络传输、持久化等场景中使用，
- * @email
+ //* 类中还包含了用于属性访问的Getter和Setter方法以及重写的toString方法，便于对象的操作和信息展示。
- */
+ //* @author  wangmuzi
+ //* @email
+ //*/
 @TableName("news")
 public class NewsEntity<T> implements Serializable {
+   //
+   //
+    // 定义序列化版本号，用于在对象序列化和反序列化过程中确保兼容性，
+    // 当类的结构发生变化（如新增、删除字段等）时，
+    // 可适当更新该版本号，以避免出现序列化和反序列化不一致的问题。
     private static final long serialVersionUID = 1L;
 
+    // 无参构造函数，主要用于创建NewsEntity类的默认实例对象，
+    // 在一些框架自动实例化对象或者通过反射创建对象等场景下会被调用。
+    public NewsEntity() {
 
-	public NewsEntity() {
+    }
-
-	}
-
-	public NewsEntity(T t) {
-		try {
-			BeanUtils.copyProperties(this, t);
-		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
 
+    // 有参构造函数，接受一个泛型参数t，
+    // 其目的是尝试将传入的t对象的属性值复制到当前的NewsEntity对象中。
+    // 通过使用BeanUtils工具类的copyProperties方法来实现属性复制，
+    // 若在复制过程中出现IllegalAccessException（例如访问权限问题）
+    // 或者InvocationTargetException（例如被调用方法抛出异常），
+    // 则会打印异常堆栈信息进行调试。
+    public NewsEntity(T t) {
+        try {
+            BeanUtils.copyProperties(this, t);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+    }
 
-    /**
+    ///**
-     * 主键
+     //* 主键
-     */
+     //* 对应数据库中"news"表记录的唯一标识符，
+    // * 通过@TableId注解指定了主键的生成策略为自增长（IdType.AUTO），
+     //* 并使用@TableField注解明确了在数据库表中的字段名为"id"，用于唯一标识每条公告信息记录。
+     //*/
     @TableId(type = IdType.AUTO)
     @TableField(value = "id")
-
     private Integer id;
 
-
+   // /**
-    /**
+   //  * 公告标题
-     * 公告标题
+    // * 用于存储公告的标题内容，
-     */
+    // * 通过@TableField注解将该属性与数据库表"news"中的"news_name"字段进行映射关联，
+     //// 方便在进行数据库操作时进行数据的存取。
+    // */
     @TableField(value = "news_name")
-
     private String newsName;
 
-
+    ///**
-    /**
+    // * 公告类型
-     * 公告类型
+     //* 用于表示公告所属的类型（例如通知类、活动类等，
-     */
+    // * 具体类型由业务逻辑定义），通过@TableField注解将其与数据库表"news"中的"news_types"字段对应起来，
+    //* 其类型为Integer，可能在数据库中以数字编码形式存储不同的公告类型。
+    // */
     @TableField(value = "news_types")
-
     private Integer newsTypes;
-
+//
-
+   // /**
-    /**
+   // * 公告图片
-     * 公告图片
+    // * 用于存放公告相关的图片路径或者图片资源的标识信息（具体取决于业务实现方式，可能是文件系统路径、URL等），
-     */
+    // * 通过@TableField注解关联到数据库表"news"中的"news_photo"字段，方便进行图片相关的数据操作与存储。
+    // */
     @TableField(value = "news_photo")
-
     private String newsPhoto;
 
-
+   // /**
-    /**
+    // * 添加时间
-     * 添加时间
+    // * 用于记录公告信息添加到系统中的时间，
-     */
+    // * 通过@JsonFormat注解来指定时间的格式化方式，使其在序列化为JSON格式数据时能够按照指定的格式展示，
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    // * 例如设置了中文地区（locale="zh"）、东八区时区（timezone="GMT+8"）以及具体的时间格式（pattern="yyyy-MM-dd HH:mm:ss"）。
-	@DateTimeFormat
+    // * 同时，@DateTimeFormat注解用于在接收前端传入的时间格式数据时进行解析转换，使其能正确赋值给该属性。
-    @TableField(value = "insert_time",fill = FieldFill.INSERT)
+    // * @TableField注解指定了在数据库表中的字段名为"insert_time"，并且设置了填充策略为插入时自动填充（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;
 
-
+    ///**
-    /**
+     //* 公告详情
-     * 公告详情
+    //* 用于存储公告的详细内容信息，
-     */
+     //* 通过@TableField注解与数据库表"news"中的"news_content"字段进行关联，
+    // // 方便在进行数据库读写操作时传递和保存公告的详细文本内容。
+    // */
     @TableField(value = "news_content")
-
     private String newsContent;
 
-
+   // /**
-    /**
+   //  * 创建时间
-     * 创建时间
+    // * 类似于添加时间，用于记录公告相关记录在系统中创建的时间，
-     */
+    // * 同样使用了@JsonFormat和@DateTimeFormat注解来处理时间的格式化和解析，
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    //* 通过@TableField注解指定了该字段在数据库表"news"中对应的字段名为"create_time"以及其填充策略为插入时自动填充（FieldFill.INSERT），
-	@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;
 
-
+   // /**
-    /**
+    // * 设置：主键
-	 * 设置：主键
+    // * 这是属性id的Getter方法，
-	 */
+    /// * 外部代码可以通过调用该方法获取当前NewsEntity对象的主键值，方便在业务逻辑中进行基于主键的操作，
+     ///* 比如查询、更新、删除等操作时使用该主键来定位特定的公告记录。
+     //*/
     public Integer getId() {
         return id;
     }
-    /**
-	 * 获取：主键
-	 */
 
+    ///**
+    // * 获取：主键
+    // * 这是属性id的Setter方法，外部代码可以通过调用该方法来设置当前NewsEntity对象的主键值，
+    // * 不过通常主键在数据库中是由自增长等策略生成，
+    // * 手动设置的情况相对较少，但在一些特定业务场景下可能会用到，比如数据迁移等情况。
+    // */
     public void setId(Integer id) {
         this.id = id;
     }
-    /**
+
-	 * 设置：公告标题
+  //  /**
-	 */
+    // * 设置：公告标题
+     //* 这是属性newsName的Getter方法，
+     //* 外部代码通过调用它可以获取当前NewsEntity对象所存储的公告标题内容，
+     //// 便于在展示公告信息或者进行标题相关的业务判断等场景中使用。
+    // */
     public String getNewsName() {
         return newsName;
     }
-    /**
-	 * 获取：公告标题
-	 */
 
+   // /**
+    // * 获取：公告标题
+    // * 这是属性newsName的Setter方法，
+    // * 外部代码调用该方法可以修改当前NewsEntity对象的公告标题内容，
+     // 比如在编辑公告功能中更新公告的标题时会用到。
+    // */
     public void setNewsName(String newsName) {
         this.newsName = newsName;
     }
-    /**
+
-	 * 设置：公告类型
+  // /**
-	 */
+    // * 设置：公告类型
+    // * 这是属性newsTypes的Getter方法，
+    // * 外部代码通过调用它可以获取当前NewsEntity对象所代表的公告类型标识（数字编码形式），
+    // // 便于在业务逻辑中根据公告类型进行分类处理、查询筛选等操作。
+     //*/
     public Integer getNewsTypes() {
         return newsTypes;
     }
-    /**
-	 * 获取：公告类型
-	 */
 
+   // /**
+     //* 获取：公告类型
+     //* 这是属性newsTypes的Setter方法，外部代码调用该方法可以修改当前NewsEntity对象的公告类型标识，
+     //// 例如在调整公告所属分类等业务场景下会用到。
+     //*/
     public void setNewsTypes(Integer newsTypes) {
         this.newsTypes = newsTypes;
     }
-    /**
+
-	 * 设置：公告图片
+  //  /**
-	 */
+    // * 设置：公告图片
+    // * 这是属性newsPhoto的Getter方法，
+     //* 外部代码通过调用它可以获取当前NewsEntity对象存储的公告图片相关信息（路径或标识等），
+     // 在显示公告图片或者对图片资源进行管理等场景中会用到该方法获取相应信息。
+   //  */
     public String getNewsPhoto() {
         return newsPhoto;
     }
-    /**
-	 * 获取：公告图片
-	 */
 
+    /**
+     * 获取：公告图片
+     * 这是属性newsPhoto的Setter方法，
+     * 外部代码调用该方法可以修改当前NewsEntity对象的公告图片相关信息，
+     // 比如更新公告的配图、修改图片路径等业务操作时会用到。
+     */
     public void setNewsPhoto(String newsPhoto) {
         this.newsPhoto = newsPhoto;
     }
+
     /**
-	 * 设置：添加时间
+     * 设置：添加时间
-	 */
+     * 这是属性insertTime的Getter方法，
+     * 外部代码通过调用它可以获取当前NewsEntity对象记录的公告添加时间信息，
+     // 在查询公告历史记录、按照时间范围筛选公告等业务场景中会用到该时间信息。
+     */
     public Date getInsertTime() {
         return insertTime;
     }
-    /**
-	 * 获取：添加时间
-	 */
 
+    /**
+     * 获取：添加时间
+     * 这是属性insertTime的Setter方法，
+     * 外部代码调用该方法可以修改当前NewsEntity对象的公告添加时间信息，
+     // 不过一般情况下该时间是由系统自动填充，
+     手动修改的情况较少，特殊业务需求下可能会用到（如数据纠错等）。
+     */
     public void setInsertTime(Date insertTime) {
         this.insertTime = insertTime;
     }
+
     /**
-	 * 设置：公告详情
+     * 设置：公告详情
-	 */
+     * 这是属性newsContent的Getter方法，
+     * 外部代码通过调用它可以获取当前NewsEntity对象存储的公告详细内容信息，
+     // 是展示公告完整内容给用户查看的关键方法，在公告详情页面等场景中会用到。
+     */
     public String getNewsContent() {
         return newsContent;
     }
-    /**
-	 * 获取：公告详情
-	 */
 
+    /**
+     * 获取：公告详情
+     * 这是属性newsContent的Setter方法，
+     * 外部代码调用该方法可以修改当前NewsEntity对象的公告详细内容信息，
+     // 比如在编辑公告详情文本内容时会用到该方法进行更新操作。
+     */
     public void setNewsContent(String newsContent) {
         this.newsContent = newsContent;
     }
+
     /**
-	 * 设置：创建时间
+     * 设置：创建时间
-	 */
+     * 这是属性createTime的Getter方法，
+     * 外部代码通过调用它可以获取当前NewsEntity对象记录的公告相关记录创建时间信息，
+     // 在一些涉及到数据创建时间跟踪、按照创建时间排序等业务场景中会用到该时间信息。
+     */
     public Date getCreateTime() {
         return createTime;
     }
-    /**
-	 * 获取：创建时间
-	 */
 
+    /**
+     * 获取：创建时间
+     * 这是属性createTime的Setter方法，
+     * 外部代码调用该方法可以修改当前NewsEntity对象的公告相关记录创建时间信息，
+     // 通常该时间由系统自动填充，手动修改场景较少，特殊业务场景下（如数据迁移、时间校正等）可能会用到。
+     */
     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
@@ -201,13 +272,13 @@ public class NewsEntity<T> implements Serializable {
     @Override
     public String toString() {
         return "News{" +
-            "id=" + id +
+                "id=" + id +
-            ", newsName=" + newsName +
+                ", newsName=" + newsName +
-            ", newsTypes=" + newsTypes +
+                ", newsTypes=" + newsTypes +
-            ", newsPhoto=" + newsPhoto +
+                ", newsPhoto=" + newsPhoto +
-            ", insertTime=" + insertTime +
+                ", insertTime=" + insertTime +
-            ", newsContent=" + newsContent +
+                ", newsContent=" + newsContent +
-            ", createTime=" + createTime +
+                ", createTime=" + createTime +
-        "}";
+                "}";
-    }
+    }
-}
+}

minsu/minsuguanliw/src/main/java/com/entity/TokenEntity.java

@@ -7,116 +7,337 @@ import com.baomidou.mybatisplus.annotations.TableId;
 import com.baomidou.mybatisplus.annotations.TableName;
 import com.baomidou.mybatisplus.enums.IdType;
 
-/** 
+/**
  * token表
+ * 该类用于表示 `token` 相关的数据实体，
+ * 对应数据库中的 `token` 表结构，存储与用户 `token` 相关的各种信息，
+ * 实现了 `Serializable` 接口，
+ *
+ *
+ *
+ * 便能够在网络传输或者持久化存储（如保存到文件、数据库等情况）时进行序列化和反序列化操作，保证数据的完整性和可恢复性。
  */
 @TableName("token")
 public class TokenEntity implements Serializable {
 	private static final long serialVersionUID = 1L;
-	
+
+	// **
+	//  * 主键标识，通过 `@TableId`
+	//
+	//
+	//  注解指定该字段为主键，并且设置主键的生成策略为自增长（`IdType.AUTO`），
+	//  * 在数据库插入操作时，系统会按照设定的自增长规则自动为该字段赋值，
+	//
+	//
+	//  用于唯一标识每条 `token` 记录，方便进行数据库层面的操作（如查询、更新、删除等），
+	//  * 确保数据的唯一性和可定位性。
+	//  */
 	@TableId(type = IdType.AUTO)
 	private Integer id;
-	
+
-	/**
+	// **
-	 * 用户id
+	//  * 用户id，用于关联具体的用户，明确该 `token` 是属于哪个用户的标识信息，
-	 */
+	//  * 通过这个字段可以建立 `token`
+	//
+	//  与用户之间的对应关系，在进行用户认证、权限验证等业务场景中，
+	//  * 基于该用户 `id` 去查找对应的用户信息以及判断该 `token` 是否合法等操作。
+	//  */
 	private Integer userid;
-	
+
-	/**
+	// **
-	 * 用户名
+	//  * 用户名，存储对应用户的名称信息，
-	 */
+	//
+	//  与 `userid` 一起进一步明确用户身份，增强用户标识的可读性和可辨识度，
+	//  * 在一些业务场景中（如展示用户相关信息、
+	//
+	//  记录操作日志等涉及到用户显示名称的情况）会用到该字段内容。
+	//  */
 	private String username;
-	
+
-	/**
+	// **
-	 * 表名
+	//  * 表名，可能用于标识该 `token`
-	 */
+	//
+	//
+	//  相关数据存储所在的具体数据库表（在多表关联或者分表存储等复杂业务场景下），
+	//  * 可以帮助更准确地定位和管理与该 `token` 相关的其他数据信息，
+	//
+	//  也有助于区分不同业务模块下的 `token` 情况，
+	//  * 例如不同业务表对应的 `token` 有不同的作用范围和验证规则等，
+	//
+	//  通过这个字段可以进行区分和相应的业务处理。
+	//  */
 	private String tablename;
-	
+
-	/**
+	// **
-	 * 角色
+	//  * 角色，用于记录用户在系统中所扮演的角色，例如管理员、普通用户、
-	 */
+	//
+	//
+	//  特定权限角色等不同角色往往具有不同的权限范围，
+	//  * 通过该 `role` 字段可以在基于 `token` 进行权限验证等操作时，
+	//
+	//  判断用户是否具备执行某些特定操作的权限，
+	//  * 确保系统的安全性和数据访问的合法性。
+	//  */
 	private String role;
-	
+
-	/**
+	// **
-	 * token
+	//  * token，存储实际的 `token` 字符串值，
-	 */
+	//
+	//  这是用于标识用户身份的关键信息，
+	//
+	//  在用户登录成功或者进行身份验证等操作后生成，
+	//  * 后续用户在访问系统接口、进行页面操作等场景下，
+	//
+	//  需要携带该 `token` 字符串进行身份验证，系统通过验证该 `token` 的有效性来确定用户是否有权限继续操作，
+	//  * 它通常是一个具有一定随机性和唯一性的字符串，
+	//
+	//  保证每个用户的 `token` 都能唯一标识其身份。
+	//  */
 	private String token;
-	
+
-	/**
+	// **
-	 * 过期时间
+	//  * 过期时间，记录该 `token` 的有效截止时间，
-	 */
+	//
+	//  通过设置过期时间可以提高系统的安全性，避免 `token` 长期有效可能带来的安全风险，
+	//  * 在进行 `token` 验证时，
+	//
+	//  会对比当前时间与该过期时间来判断 `token` 是否仍然有效，
+	//
+	//  对于过期的 `token` 则拒绝相应的操作请求，
+	//  * 通常是一个 `Date` 类型的时间对象，表示具体的时间点。
+	//  */
 	private Date expiratedtime;
-	
+
-	/**
+	// **
-	 * 新增时间
+	//  * 新增时间，记录该 `token` 在系统中创建的时间点，
-	 */
+	//
+	//  可用于查询、统计等业务场景，例如查看新生成的 `token` 情况、
+	//  * 分析不同时间段内 `token` 的生成频率等，
+	//
+	//  也有助于在一些数据管理和审计场景下了解 `token` 的生命周期相关信息，
+	//  * 同样是一个 `Date` 类型的时间对象。
+	//  */
 	private Date addtime;
 
+	// **
+	//  * 获取：主键，对外提供获取主键值（`id`）的方法，
+	//
+	//  方便在其他类中访问该 `TokenEntity` 对象的主键信息，
+	//  * 例如在进行数据库查询结果映射或者业务逻辑处理中需要用到
+	//
+	//  `token` 记录主键时可调用此方法获取，返回对应的整数值。
+	//  * @return 返回主键对应的整数值。
+	//  */
 	public Integer getId() {
 		return id;
 	}
 
+	// **
+	//  * 设置：主键，用于设置该对象的主键值，
+	//
+	//  通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用，
+	//  * 不过由于主键一般是自增长且由数据库管理，
+	//  在实际业务中手动设置的情况相对较少，
+	//  但保留此方法以满足可能的特殊需求（如数据迁移等场景），
+	//  * 通过传入对应的整数值来更新主键信息。
+	//  * @param id 要设置的主键整数值。
+	//  */
 	public void setId(Integer id) {
 		this.id = id;
 	}
 
+	// **
+	//  * 获取：用户id，对外提供获取用户 `id`
+	//
+	//  值（`userid`）的方法，在需要关联用户信息、进行基于用户的业务逻辑处理（如查找用户相关的其他数据、
+	//  * 判断 `token` 所属用户等情况）时，
+	//  可调用此方法获取对应的整数值，便于操作和业务逻辑实现。
+	//  * @return 返回用户 `id` 对应的整数值。
+	//  */
 	public Integer getUserid() {
 		return userid;
 	}
 
+	// **
+	//  * 设置：用户id，用于更新用户 `id` 值（`userid`），
+	//  例如在某些特殊情况下（如用户信息变更导致关联的 `userid` 需要调整等），
+	//  * 通过传入新的整数值来改变该 `TokenEntity`
+	//  对象所关联的用户标识信息，不过这种情况相对较少出现，需谨慎操作以保证数据一致性。
+	//  * @param userid 要设置的用户 `id` 整数值。
+	//  */
 	public void setUserid(Integer userid) {
 		this.userid = userid;
 	}
 
-	public String getRole() {
+	// **
-		return role;
+	//  * 获取：用户名，对外提供获取用户名（`username`）的方法，
-	}
+	//
-
+	//
-	public void setRole(String role) {
+	//  在需要展示用户名称、基于用户名进行业务逻辑处理（如记录操作日志中显示用户名等情况）时，
-		this.role = role;
+	//  * 可调用此方法获取对应的字符串内容，方便进行相应的展示和操作。
+	//  * @return 返回用户名对应的字符串值。
+	//  */
+	public String getUsername() {
+		return username;
 	}
 
-	public String getToken() {
+	// **
-		return token;
+	//  * 设置：用户名，用于更新用户名（`username`），
+	//
+	//  比如用户修改了自己的用户名后，通过此方法保存新的用户名信息到该 `TokenEntity` 对象中，
+	//  * 确保相关业务逻辑中获取到的用户名是最新且准确的，
+	//
+	//  需要注意的是这种更新可能需要同时考虑与其他关联数据的一致性等问题。
+	//  * @param username 要设置的用户名字符串值。
+	//  */
+	public void setUsername(String username) {
+		this.username = username;
 	}
 
+	// **
+	//  * 获取：表名，对外提供获取表名（`tablename`）的方法，
+	//
+	//  在涉及到多表关联操作、区分不同业务模块下 `token` 的处理逻辑或者根据表名查找相关数据等业务场景中，
+	//  * 可调用此方法获取对应的字符串内容，
+	//
+	//  便于进行相应的数据库操作和业务处理。
+	//  * @return 返回表名对应的字符串值。
+	//  */
 	public String getTablename() {
 		return tablename;
 	}
 
+	// **
+	//  * 设置：表名，用于更新表名（`tablename`），
+	//
+	//  在一些特殊的业务场景变化（如数据库结构调整、业务模块重新划分导致表名变更等）时，
+	//  * 通过传入新的字符串值来改变该 `TokenEntity`
+	//
+	//  对象对应的表名信息，不过这种变更需要谨慎处理，确保与数据库实际情况以及其他相关代码逻辑的一致性。
+	//  * @param tablename 要设置的表名字符串值。
+	//  */
 	public void setTablename(String tablename) {
 		this.tablename = tablename;
 	}
 
+	// **
+	//  * 获取：角色，对外提供获取角色（`role`）的方法，
+	//
+	//  在基于 `token` 进行权限验证、判断用户在系统中的操作权限范围等业务场景中，
+	//  * 可调用此方法获取对应的字符串内容，
+	//
+	//  以便根据角色信息进行相应的权限控制和业务逻辑处理。
+	//  * @return 返回角色对应的字符串值。
+	//  */
+	public String getRole() {
+		return role;
+	}
+
+	// **
+	//  * 设置：角色，用于更新角色（`role`），
+	//
+	//  例如在系统进行角色调整、用户权限变更等情况下，通过传入新的字符串值来改变该 `TokenEntity` 对象中记录的用户角色信息，
+	//  * 从而影响后续基于角色的权限验证等业务操作，
+	//
+	//  同样需要注意保证数据一致性以及相关业务逻辑的正确调整。
+	//  * @param role 要设置的角色字符串值。
+	//  */
+	public void setRole(String role) {
+		this.role = role;
+	}
+
+	// **
+	//  * 获取：token，对外提供获取 `token`
+	//
+	//  字符串值（`token`）的方法，在需要使用 `token` 进行身份验证、传递给其他模块进行相关操作等场景中，
+	//  * 可调用此方法获取对应的字符串内容，
+	//
+	//  它是整个 `TokenEntity` 对象中最为关键的用于标识用户身份的信息部分。
+	//  * @return 返回 `token` 对应的字符串值。
+	//  */
+	public String getToken() {
+		return token;
+	}
+
+	// **
+	//  * 设置：token，用于更新 `token` 字符串值（`token`），
+	//
+	//  通常在 `token` 重新生成（如用户重新登录、`token` 过期后重新获取等情况）时，
+	//  * 通过传入新的字符串值来替换原有的 `token` 信息，
+	//
+	//  确保 `token` 的有效性和安全性，同时需要注意更新相关的验证逻辑以及与其他模块的交互情况。
+	//  * @param token 要设置的 `token` 字符串值。
+	//  */
 	public void setToken(String token) {
 		this.token = token;
 	}
 
+	// **
+	//  * 获取：过期时间，对外提供获取过期时间（`expiratedtime`）的方法，
+	//
+	//  在进行 `token` 有效性验证、判断是否需要重新获取 `token` 等业务场景中，
+	//  * 可调用此方法获取对应的 `Date` 类型对象，
+	//
+	//  以便与当前时间进行比较操作，进而确定 `token` 是否还能继续使用。
+	//  * @return 返回过期时间对应的 `Date` 类型对象。
+	//  */
 	public Date getExpiratedtime() {
 		return expiratedtime;
 	}
 
+	// **
+	//  * 设置：过期时间，用于更新过期时间（`expiratedtime`）的值，
+	//
+	//  例如在调整 `token` 的有效期策略、手动延长或缩短 `token` 有效期等特殊情况下，
+	//  * 通过传入新的 `Date` 类型对象来改变该 `TokenEntity`
+	//
+	//  对象中记录的 `token` 过期时间信息，不过这种操作需要谨慎进行，避免影响系统的安全性和正常业务流程。
+	//  * @param expiratedtime 要设置的过期时间对应的 `Date` 类型对象。
+	//  */
 	public void setExpiratedtime(Date expiratedtime) {
 		this.expiratedtime = expiratedtime;
 	}
 
+	// **
+	//  * 获取：新增时间，对外提供获取新增时间（`addtime`）的方法，
+	//
+	//  在进行数据统计、审计以及一些基于时间顺序的业务逻辑处理（如查找近期生成的 `token` 等情况）时，
+	//  * 可调用此方法获取对应的 `Date` 类型对象，方便进行相应的时间相关操作和业务逻辑实现。
+	//  * @return 返回新增时间对应的 `Date` 类型对象。
+	//  */
 	public Date getAddtime() {
 		return addtime;
 	}
 
+	// **
+	//  * 设置：新增时间，用于更新新增时间（`addtime`）的值，
+	//
+	//  虽然在实际业务中新增时间一般是在 `token` 创建时自动记录且较少手动修改，
+	//  * 但保留此方法以满足可能的特殊需求（如数据迁移、时间校准等场景下对新增时间进行调整），
+	//
+	//  通过传入对应的 `Date` 类型对象来更新新增时间信息，
+	//  * 同样需要注意保证数据的合理性和一致性。
+	//  */
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
-	public String getUsername() {
+	// **
-		return username;
+	//  * 构造函数，用于创建 `TokenEntity` 对象实例时传入必要的参数进行初始化，
-	}
+	//
-
+	//  通常在创建新的 `token` 相关记录或者从数据库等外部数据源加载数据后创建对象时使用，
-	public void setUsername(String username) {
+	//  * 接收用户 `id`、用户名、表名、角色、`token` 字符串以及过期时间等参数，
-		this.username = username;
+	//
-	}
+	//  按照传入的值初始化对象的各个属性，方便快速构建一个完整的 `TokenEntity` 对象，
-
+	//  * 用于后续的业务操作（如插入数据库、传递给其他模块等）。
-	public TokenEntity(Integer userid, String username, String tablename,String role, String token, Date expiratedtime) {
+	//  * @param userid 用户的唯一标识，整数值。
+	//  * @param username 用户的名称，字符串值。
+	//  * @param tablename 所属表名，字符串值。
+	//  * @param role 用户在系统中所扮演的角色，字符串值。
+	//  * @param token 用于标识用户身份的 `token` 字符串值。
+	//  * @param expiratedtime `token` 的过期时间，`Date` 类型对象。
+	//  */
+	public TokenEntity(Integer userid, String username, String tablename, String role, String token, Date expiratedtime) {
 		super();
 		this.userid = userid;
 		this.username = username;
@@ -125,8 +346,16 @@ public class TokenEntity implements Serializable {
 		this.token = token;
 		this.expiratedtime = expiratedtime;
 	}
-	
+
+	// **
+	//  * 默认构造函数，用于创建一个空的 `TokenEntity` 对象实例，
+	//
+	//  当需要先创建对象再逐步设置属性值时可使用该构造函数，
+	//  * 例如在一些复杂的业务逻辑中，先创建对象占位，后续根据不同的条件和数据来源来分别设置对象的各个属性，
+	//
+	//  方便灵活构建 `TokenEntity` 对象，
+	//  * 为空对象的初始化提供了一种方式。
+	//  */
 	public TokenEntity() {
 	}
-	
+}
-}

minsu/minsuguanliw/src/main/java/com/entity/UsersEntity.java

@@ -10,68 +10,140 @@ import com.baomidou.mybatisplus.enums.IdType;
 /** 
  * 用户
  */
+// 通过 @TableName 注解指定该实体类对应的数据库表名为 "users"，表明这个实体类与数据库中名为 "users" 的表存在映射关系，
+// 在使用一些持久化框架（如 MyBatis-Plus 等）时，框架会依据这个映射关系进行数据库操作，例如将该实体类的对象持久化到对应表中，或者从表中查询数据填充到该类的对象里。
 @TableName("users")
+// 定义一个名为 UsersEntity 的类，实现了 Serializable 接口，意味着该类的对象可以被序列化和反序列化，
+// 常用于在网络传输、对象持久化存储等场景中保证对象状态的保存和恢复，方便数据的传递与存储操作。
 public class UsersEntity implements Serializable {
 	private static final long serialVersionUID = 1L;
-	
+
+	// 通过 @TableId 注解指定了主键的生成策略为自动增长（IdType.AUTO），即数据库会自动为该字段分配唯一的整数值，
+	// 这里的主键字段用于唯一标识数据库表中的每一条用户记录，方便后续对特定用户数据进行精准的查询、更新、删除等操作。
 	@TableId(type = IdType.AUTO)
 	private Integer id;
-	
+
 	/**
 	 * 用户账号
+	 * 用于存储用户登录系统所使用的账号信息，是用户登录时的重要标识，在用户注册、登录以及相关业务逻辑中会频繁涉及对该字段的操作，
+	 // 通常具有唯一性，以区分不同的用户个体。
 	 */
 	private String username;
-	
+
 	/**
 	 * 密码
+	 * 存储用户登录系统时需要提供的密码内容，由于密码涉及用户隐私安全，在实际应用中通常需要对其进行加密存储等额外的安全处理，
+	 // 而不只是简单的文本存储，在用户登录验证、修改密码等业务场景中会重点使用该字段。
 	 */
 	private String password;
-	
+
 	/**
 	 * 用户类型
+	 * 用于区分不同角色或者权限的用户，例如可以是 "普通用户"、"管理员" 等不同的取值（具体由业务定义），
+	 // 系统可以根据该字段来判断用户具备哪些操作权限，进而控制用户对不同功能模块的访问，在权限管理相关的业务逻辑中起到关键作用。
 	 */
 	private String role;
-	
+
+	// 用于记录用户相关数据添加到系统中的时间，比如在统计用户增长趋势、查询某个时间段内新增的用户等业务场景下会用到该时间信息，
+	// 具体的时间格式和处理方式可能会根据业务需求以及相关的时间格式化注解来确定（当前代码中未展示相关格式化处理，但实际应用中可能会有）。
 	private Date addtime;
 
+	/**
+	 * 获取用户账号的方法（getter 方法）
+	 * 按照 Java 的 JavaBean 规范定义，方便其他类在需要获取该 UsersEntity 对象的用户账号信息时调用，返回存储的用户账号字符串值。
+	 * @return 返回存储的用户账号字符串。
+	 */
 	public String getUsername() {
 		return username;
 	}
 
+	/**
+	 * 设置用户账号的方法（setter 方法）
+	 * 按照 Java 的 JavaBean 规范定义，用于在创建或修改用户对象时为用户账号字段赋值，比如用户注册或者修改账号时会用到，
+	 * 传入要设置的用户账号字符串值，用于更新用户对象的用户账号字段内容。
+	 * @param username 要设置的用户账号字符串值。
+	 */
 	public void setUsername(String username) {
 		this.username = username;
 	}
 
+	/**
+	 * 获取密码的方法（getter 方法）
+	 * 用于获取用户密码字段值的公共访问方法，不过在实际应用中要注意密码的安全性，一般不会随意对外暴露密码的原始值，
+	 // 可能会经过加密等处理后再进行相关操作，此处返回的是存储的密码字符串值。
+	 * @return 返回存储的用户密码字符串值。
+	 */
 	public String getPassword() {
 		return password;
 	}
 
+	/**
+	 * 设置密码的方法（setter 方法）
+	 * 用于在用户注册、修改密码等业务场景下为密码字段赋值，同样要注意在实际应用中对密码进行安全的存储处理，比如加密后再保存到数据库等操作，
+	 // 传入要设置的用户密码字符串值，用于更新用户对象的密码字段内容。
+	 * @param password 要设置的用户密码字符串值。
+	 */
 	public void setPassword(String password) {
 		this.password = password;
 	}
 
+	/**
+	 * 获取用户类型的方法（getter 方法）
+	 * 方便其他类在需要了解该 UsersEntity 对象所代表用户的类型信息时调用，返回存储的用户类型字符串值，其具体取值由业务中对用户类型的定义决定。
+	 * @return 返回存储的用户类型字符串值。
+	 */
 	public String getRole() {
 		return role;
 	}
 
+	/**
+	 * 设置用户类型的方法（setter 方法）
+	 * 用于在创建或修改用户对象时设置用户的类型信息，比如在系统后台为用户分配角色、修改用户权限等场景下会调用该方法，
+	 // 传入要设置的用户类型字符串值，用于更新用户对象的用户类型字段内容。
+	 * @param role 要设置的用户类型字符串值。
+	 */
 	public void setRole(String role) {
 		this.role = role;
 	}
 
+	/**
+	 * 获取添加时间的方法（getter 方法）
+	 * 用于获取用户数据添加到系统中的时间信息，在需要查看用户创建时间或者基于时间进行相关统计、查询等业务操作时会调用该方法，
+	 // 返回存储的 Date 类型的添加时间对象。
+	 * @return 返回存储的 Date 类型的添加时间对象。
+	 */
 	public Date getAddtime() {
 		return addtime;
 	}
 
+	/**
+	 * 设置添加时间的方法（setter 方法）
+	 * 用于在创建用户对象或者更新用户相关时间信息时为添加时间字段赋值，传入要设置的 Date 类型的添加时间值，用于更新用户对象的添加时间字段内容，
+	 // 比如在数据从其他数据源导入到系统中时，需要准确设置该时间信息等场景下会用到。
+	 * @param addtime 要设置的 Date 类型的添加时间值。
+	 */
 	public void setAddtime(Date addtime) {
 		this.addtime = addtime;
 	}
 
+	/**
+	 * 获取主键的方法（getter 方法）
+	 * 按照 Java 的 JavaBean 规范定义，方便其他类在需要获取该 UsersEntity 对象的主键值（即唯一标识）时调用，返回存储的主键整数值。
+	 * @return 返回存储的主键整数值。
+	 */
 	public Integer getId() {
 		return id;
 	}
 
+	/**
+	 * 设置主键的方法（setter 方法）
+	 * 用于在创建或修改用户对象时为其主键字段赋值，通常在一些特定的业务场景下（如从数据库查询数据后填充对象、新建对象并指定其唯一标识等情况）会调用该方法，
+	 // 传入要设置的主键整数值，用于更新用户对象的主键字段内容。
+	 * @param id 要设置的主键整数值。
+	 */
 	public void setId(Integer id) {
 		this.id = id;
 	}
+}
 
 }

minsu/minsuguanliw/src/main/java/com/entity/YonghuEntity.java

@@ -26,274 +26,369 @@ import com.baomidou.mybatisplus.enums.IdType;
  * @author 
  * @email
  */
+// 通过 @TableName 注解指定该实体类对应的数据库表名为 "yonghu"，表明这个实体类与数据库中名为 "yonghu" 的表存在映射关系，
+// 在使用一些持久化框架（如 MyBatis-Plus 等）时，框架会依据这个映射关系进行数据库操作，例如将该实体类的对象持久化到对应表中，或者从表中查询数据填充到该类的对象里。
 @TableName("yonghu")
+// 定义一个名为 YonghuEntity 的泛型类，实现了 Serializable 接口，意味着该类的对象可以被序列化和反序列化，
+// 常用于在网络传输、对象持久化存储等场景中保证对象状态的保存和恢复，方便数据的传递与存储操作。
 public class YonghuEntity<T> implements Serializable {
     private static final long serialVersionUID = 1L;
 
+    // 默认构造函数，用于创建一个空的 YonghuEntity 对象实例，在某些初始化场景（如通过反射创建对象等情况）下会被调用，
+    // 此时对象的各个属性会被赋予默认的初始值（例如基本数据类型会有对应的默认值，引用类型为 null 等）。
+    public YonghuEntity() {
 
-	public YonghuEntity() {
+    }
-
-	}
-
-	public YonghuEntity(T t) {
-		try {
-			BeanUtils.copyProperties(this, t);
-		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
-			e.printStackTrace();
-		}
-	}
 
+    // 带参数的构造函数，接受一个泛型参数 T，尝试使用 BeanUtils.copyProperties 方法（通常来自 Spring 等相关框架提供的工具类）
+    // 将传入的参数对象 t 的属性值复制到当前的 YonghuEntity 对象中，实现基于已有对象来初始化当前对象的功能。
+    // 如果在属性复制过程中出现异常（比如属性没有对应的访问权限或者复制方法调用出现问题等），会打印异常堆栈信息方便排查问题，
+    // 不过当前只是简单打印，实际应用中可根据需求完善异常处理逻辑。
+    public YonghuEntity(T t) {
+        try {
+            BeanUtils.copyProperties(this, t);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+    }
 
     /**
      * 主键
+     * 用于唯一标识数据库表中的每一条用户记录，通过 @TableId 注解指定了主键的生成策略为自动增长（IdType.AUTO），
+     * 即数据库会自动为该字段分配唯一的整数值，同时通过 @TableField 注解明确了该字段在数据库表中对应的列名为 "id"，
+     * 这样持久化框架就能准确地将实体类中的这个属性与数据库表中的相应列进行映射关联。
      */
     @TableId(type = IdType.AUTO)
     @TableField(value = "id")
-
     private Integer id;
 
-
     /**
      * 账户
+     * 用于存储用户登录系统所使用的账户信息，通过 @TableField 注解指定该属性对应数据库表中的 "username" 列，
+     // 保证了实体类与数据库表之间在该字段上的映射关系，方便数据的读写操作，在用户登录、注册等业务场景中会频繁涉及对该字段的操作。
      */
     @TableField(value = "username")
-
     private String username;
 
-
     /**
      * 密码
+     * 存储用户登录系统时需要提供的密码内容，通过 @TableField 注解与数据库表中的 "password" 列建立映射关系，
+     // 由于密码涉及用户隐私安全，在实际应用中通常需要对其进行加密存储等额外的安全处理，而不只是简单的文本存储。
      */
     @TableField(value = "password")
-
     private String password;
 
-
     /**
      * 用户姓名
+     * 用于记录用户的真实姓名，通过 @TableField 注解对应数据库表中的 "yonghu_name" 列，
+     // 方便在系统中展示用户的个人信息，比如在用户资料页面、用户列表展示等地方呈现给用户或者管理员查看。
      */
     @TableField(value = "yonghu_name")
-
     private String yonghuName;
 
-
     /**
      * 头像
+     * 存放用户头像相关的信息，可能是头像文件的存储路径或者头像的标识等内容（具体取决于系统的实现方式），
+     // 通过 @TableField 注解与数据库表中的 "yonghu_photo" 列关联，以便在需要展示用户头像的界面或者相关业务逻辑中进行数据操作。
      */
     @TableField(value = "yonghu_photo")
-
     private String yonghuPhoto;
 
-
     /**
      * 手机号
+     * 存储用户的手机号码，通过 @TableField 注解与数据库表中的 "yonghu_phone" 列对应，
+     // 在诸多业务场景中都有重要作用，例如身份验证、短信通知、找回密码等操作时作为与用户联系的关键方式。
      */
     @TableField(value = "yonghu_phone")
-
     private String yonghuPhone;
 
-
     /**
      * 电子邮箱
+     * 保存用户的电子邮箱地址，通过 @TableField 注解与数据库表中的 "yonghu_email" 列相映射，
+     // 同样可用于系统与用户之间的沟通交流，像发送重要通知、密码重置链接等业务场景都会用到该字段存储的邮箱信息。
      */
     @TableField(value = "yonghu_email")
-
     private String yonghuEmail;
 
-
     /**
      * 性别
+     * 用于记录用户的性别信息，可能取值为特定的代码（如 0 表示男，1 表示女等，具体由业务定义），
+     // 通过 @TableField 注解与数据库表中的 "sex_types" 列关联，便于系统根据性别进行相关的统计、展示或者业务逻辑处理。
      */
     @TableField(value = "sex_types")
-
     private Integer sexTypes;
 
-
     /**
      * 余额
+     * 存储用户在系统中的账户余额数据，在涉及支付、消费、充值等业务功能的系统中，该字段记录着用户当前可支配的金额数量，
+     // 通过 @TableField 注解与数据库表中的 "new_money" 列建立映射关系，以保证余额数据在实体类与数据库之间的正确读写。
      */
     @TableField(value = "new_money")
-
     private Double newMoney;
 
-
     /**
      * 假删
+     * 这是一个用于实现软删除功能的字段，通过设置不同的值来表示用户数据是否被删除，例如可以设定某个特定值（如 1 表示未删除，0 表示已删除等，具体由业务规则确定），
+     // 借助 @TableField 注解与数据库表中的 "yonghu_delete" 列相对应，相比于直接从数据库中物理删除数据，软删除便于数据的恢复以及相关业务逻辑的处理，同时可以保留数据的历史记录等信息。
      */
     @TableField(value = "yonghu_delete")
-
     private Integer yonghuDelete;
 
-
     /**
      * 创建时间
+     * 用于记录用户数据在系统中被创建的具体时间点，通过 @JsonFormat 注解可以指定该时间在序列化（比如转换为 JSON 格式返回给前端时）的格式，
+     // @DateTimeFormat 注解则可能用于在接收前端传入的时间格式数据时进行格式化处理，以便正确地将数据绑定到该字段上，
+     // 并且通过 @TableField 注解与数据库表中的 "create_time" 列关联，同时设置了 fill = FieldFill.INSERT 表示在插入数据时该字段会自动填充相应的值（通常是当前时间），
+     // 该时间信息在很多业务场景中都有作用，比如按照创建时间排序、查询某个时间段内创建的用户等。
      */
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
-    @TableField(value = "create_time",fill = FieldFill.INSERT)
+    @TableField(value = "create_time", fill = FieldFill.INSERT)
-
     private Date createTime;
 
-
     /**
-	 * 设置：主键
+     * 获取：主键
-	 */
+     * 这是一个用于获取主键字段值的公共访问方法（getter 方法），按照 Java 的 JavaBean 规范定义，方便其他类在需要获取该 YonghuEntity 对象的主键值时调用，
+     * 返回存储的主键整数值，即用户记录的唯一标识。
+     * @return 返回存储的主键整数值。
+     */
     public Integer getId() {
         return id;
     }
-    /**
-	 * 获取：主键
-	 */
 
+    /**
+     * 设置：主键
+     * 这是一个用于设置主键字段值的公共设置方法（setter 方法），按照 Java 的 JavaBean 规范定义，用于在创建或修改用户对象时为其主键字段赋值，
+     * 通常在一些特定的业务场景下（如从数据库查询数据后填充对象、新建对象并指定其唯一标识等情况）会调用该方法。
+     * @param id 要设置的主键整数值，用于更新用户对象的主键字段内容。
+     */
     public void setId(Integer id) {
         this.id = id;
     }
+
     /**
-	 * 设置：账户
+     * 获取：账户
-	 */
+     * 用于获取用户账户字段值的公共访问方法（getter 方法），方便其他类获取该 YonghuEntity 对象的账户信息，返回存储的用户账户字符串值，即用户登录所使用的账户名。
+     * @return 返回存储的用户账户字符串值。
+     */
     public String getUsername() {
         return username;
     }
-    /**
-	 * 获取：账户
-	 */
 
+    /**
+     * 设置：账户
+     * 用于设置用户账户字段值的公共设置方法（setter 方法），在创建或修改用户对象时可通过该方法为账户字段赋值，比如用户注册或者修改账户名时会用到，
+     * 传入要设置的用户账户字符串值，用于更新用户对象的账户字段内容。
+     * @param username 要设置的用户账户字符串值。
+     */
     public void setUsername(String username) {
         this.username = username;
     }
+
     /**
-	 * 设置：密码
+     * 获取：密码
-	 */
+     * 用于获取用户密码字段值的公共访问方法（getter 方法），不过在实际应用中要注意密码的安全性，一般不会随意对外暴露密码的原始值，
+     * 可能会经过加密等处理后再进行相关操作，此处返回的是存储的密码字符串值。
+     * @return 返回存储的用户密码字符串值。
+     */
     public String getPassword() {
         return password;
     }
-    /**
-	 * 获取：密码
-	 */
 
+    /**
+     * 设置：密码
+     * 用于设置用户密码字段值的公共设置方法（setter 方法），在用户注册、修改密码等业务场景下会调用该方法为密码字段赋值，
+     * 同样要注意在实际应用中对密码进行安全的存储处理，比如加密后再保存到数据库等操作，传入要设置的用户密码字符串值，用于更新用户对象的密码字段内容。
+     * @param password 要设置的用户密码字符串值。
+     */
     public void setPassword(String password) {
         this.password = password;
     }
+
     /**
-	 * 设置：用户姓名
+     * 获取：用户姓名
-	 */
+     * 用于获取用户姓名字段值的公共访问方法（getter 方法），方便在需要展示用户姓名的地方调用该方法获取相应信息，返回存储的用户姓名字符串值，即用户的真实姓名内容。
+     * @return 返回存储的用户姓名字符串值。
+     */
     public String getYonghuName() {
         return yonghuName;
     }
-    /**
-	 * 获取：用户姓名
-	 */
 
+    /**
+     * 设置：用户姓名
+     * 用于设置用户姓名字段值的公共设置方法（setter 方法），例如在用户完善个人资料、修改姓名等场景下会使用该方法更新用户对象的姓名字段内容，
+     * 传入要设置的用户姓名字符串值，用于更新用户对象的姓名字段内容。
+     * @param yonghuName 要设置的用户姓名字符串值。
+     */
     public void setYonghuName(String yonghuName) {
         this.yonghuName = yonghuName;
     }
+
     /**
-	 * 设置：头像
+     * 获取：头像
-	 */
+     * 用于获取用户头像字段值的公共访问方法（getter 方法），在需要展示用户头像的界面或者相关业务逻辑中，可通过该方法获取头像相关信息，
+     * 返回存储的用户头像字符串值，可能是头像文件的路径或者头像的标识等内容（具体取决于系统实现）。
+     * @return 返回存储的用户头像字符串值。
+     */
     public String getYonghuPhoto() {
         return yonghuPhoto;
     }
-    /**
-	 * 获取：头像
-	 */
 
+    /**
+     * 设置：头像
+     * 用于设置用户头像字段值的公共设置方法（setter 方法），比如用户上传新头像、修改头像等业务场景下会调用该方法更新用户对象的头像字段内容，
+     * 传入要设置的用户头像字符串值，用于更新用户对象的头像字段内容。
+     * @param yonghuPhoto 要设置的用户头像字符串值。
+     */
     public void setYonghuPhoto(String yonghuPhoto) {
         this.yonghuPhoto = yonghuPhoto;
     }
+
     /**
-	 * 设置：手机号
+     * 获取：手机号
-	 */
+     * 用于获取用户手机号字段值的公共访问方法（getter 方法），在涉及手机号相关的业务操作（如短信验证、联系用户等）时可通过该方法获取相应信息，
+     * 返回存储的用户手机号字符串值，即用户的手机号码内容。
+     * @return 返回存储的用户手机号字符串值。
+     */
     public String getYonghuPhone() {
         return yonghuPhone;
     }
-    /**
-	 * 获取：手机号
-	 */
 
+    /**
+     * 设置：手机号
+     * 用于设置用户手机号字段值的公共设置方法（setter 方法），在用户注册、修改手机号等场景下会调用该方法更新用户对象的手机号字段内容，
+     * 传入要设置的用户手机号字符串值，用于更新用户对象的手机号字段内容。
+     * @param yonghuPhone 要设置的用户手机号字符串值。
+     */
     public void setYonghuPhone(String yonghuPhone) {
         this.yonghuPhone = yonghuPhone;
     }
+
     /**
-	 * 设置：电子邮箱
+     * 获取：电子邮箱
-	 */
+     * 用于获取用户电子邮箱字段值的公共访问方法（getter 方法），在需要通过邮箱与用户进行沟通、发送通知等业务场景下可通过该方法获取相应信息，
+     * 返回存储的用户电子邮箱字符串值，即用户的邮箱地址内容。
+     * @return 返回存储的用户电子邮箱字符串值。
+     */
     public String getYonghuEmail() {
         return yonghuEmail;
     }
-    /**
-	 * 获取：电子邮箱
-	 */
 
+    /**
+     * 设置：电子邮箱
+     * 用于设置用户电子邮箱字段值的公共设置方法（setter 方法），在用户注册、修改邮箱地址等场景下会调用该方法更新用户对象的电子邮箱字段内容，
+     * 传入要设置的用户电子邮箱字符串值，用于更新用户对象的电子邮箱字段内容。
+     * @param yonghuEmail 要设置的用户电子邮箱字符串值。
+     */
     public void setYonghuEmail(String yonghuEmail) {
         this.yonghuEmail = yonghuEmail;
     }
+
     /**
-	 * 设置：性别
+     * 获取：性别
-	 */
+     * 用于获取用户性别字段值的公共访问方法（getter 方法），在需要根据性别进行统计、展示或者业务逻辑处理时可通过该方法获取相应信息，
+     * 返回存储的用户性别整数值，其具体含义由业务中对性别的代码定义决定（如 0 表示男，1 表示女等）。
+     * @return 返回存储的用户性别整数值。
+     */
     public Integer getSexTypes() {
         return sexTypes;
     }
-    /**
-	 * 获取：性别
-	 */
 
+    /**
+     * 设置：性别
+     * 用于设置用户性别字段值的公共设置方法（setter 方法），在用户完善个人资料、修改性别等场景下会调用该方法更新用户对象的性别字段内容，
+     * 同样要依据业务定义的性别代码规则来进行赋值操作，传入要设置的用户性别整数值，用于更新用户对象的性别字段内容。
+     * @param sexTypes 要设置的用户性别整数值。
+     */
     public void setSexTypes(Integer sexTypes) {
         this.sexTypes = sexTypes;
     }
+
     /**
-	 * 设置：余额
+     * 获取：余额
-	 */
+     * 用于获取用户余额字段值的公共访问方法（getter 方法），在涉及用户账户余额相关的业务操作（如消费、充值、查询余额等）时可通过该方法获取相应信息，
+     * 返回存储的用户余额双精度浮点数值，即用户当前账户中的金额数量。
+     * @return 返回存储的用户余额双精度浮点数值。
+     */
     public Double getNewMoney() {
         return newMoney;
     }
-    /**
-	 * 获取：余额
-	 */
 
+    /**
+     * 设置：余额
+     * 用于设置用户余额字段值的公共设置方法（setter 方法），在用户充值、消费等业务场景下会调用该方法更新用户对象的余额字段内容，
+     * 要注意余额的计算和更新逻辑需符合业务规则以及数据的准确性要求，传入要设置的用户余额双精度浮点数值，用于更新用户对象的余额字段内容。
+     * @param newMoney 要设置的用户余额双精度浮点数值。
+     */
     public void setNewMoney(Double newMoney) {
         this.newMoney = newMoney;
     }
+
     /**
-	 * 设置：假删
+     * 获取：假删
-	 */
+     * 用于获取用户假删字段值的公共访问方法（getter 方法），在涉及数据删除状态判断、数据恢复等业务逻辑中可通过该方法获取相应信息，
+     * 根据其取值来确定用户数据是否已被标记为删除状态（按照业务定义的取值规则），返回存储的用户假删整数值。
+     * @return 返回存储的用户假删整数值。
+     */
     public Integer getYonghuDelete() {
         return yonghuDelete;
     }
+
     /**
-	 * 获取：假删
+     * 获取：假删
-	 */
+     * 这是一个按照JavaBean规范定义的公共访问方法（getter方法），用于获取“假删”字段的值。
+     * 在业务逻辑中，其他类可以通过调用此方法来知晓当前对象所代表的用户数据是否处于被标记为删除的状态（具体取决于“假删”字段值的定义规则，例如通常可能用特定数字表示删除与否）。
+     * @return 返回存储的“假删”字段整数值，代表用户数据的删除标记状态。
+     */
 
     public void setYonghuDelete(Integer yonghuDelete) {
         this.yonghuDelete = yonghuDelete;
     }
+
     /**
-	 * 设置：创建时间
+     * 获取：创建时间
-	 */
+     * 此为获取“创建时间”字段值的公共访问方法（getter方法），遵循JavaBean规范。
+     * 在许多业务场景中，例如按照创建时间对用户数据进行排序、查询某个时间段内创建的用户等操作时，其他类可以调用该方法来获取用户数据在系统中最初被创建的具体时间点信息，
+     * 返回的是一个Date类型的对象，表示具体的时间值，并且该时间值的格式等相关处理可能受到类中定义的 @JsonFormat 和 @DateTimeFormat 等注解影响（若存在对应使用场景）。
+     * @return 返回存储的“创建时间”Date对象，即代表用户数据被创建时的时间信息。
+     */
     public Date getCreateTime() {
         return createTime;
     }
-    /**
-	 * 获取：创建时间
-	 */
 
+    /**
+     * 设置：创建时间
+     * 按照JavaBean规范定义的用于设置“创建时间”字段值的公共设置方法（setter方法）。
+     * 在创建用户对象或者从数据库查询数据后填充对象等场景下，可调用该方法来更新用户对象的“创建时间”字段内容，
+     * 要注意传入的时间值需符合 @DateTimeFormat 注解定义的格式要求（如果有相应的反序列化处理逻辑），以保证数据能正确绑定到该字段上，确保时间数据的准确性和一致性。
+     * @param createTime 要设置的“创建时间”Date对象，用于更新当前对象的“创建时间”字段内容。
+     */
     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
 
+    /**
+     * 重写toString方法
+     * toString方法在Java中用于将对象以字符串的形式表示出来，方便在调试、日志记录以及一些需要直观展示对象内容的场景下使用。
+     * 这里重写了该方法，按照自定义的格式将对象中的各个重要属性（包括主键、用户名、密码、用户姓名、头像、手机号、电子邮箱、性别、余额、假删状态、创建时间等）拼接成一个字符串返回，
+     * 使得在查看该对象的字符串表示时，能够清晰地了解对象内部各关键属性的具体值情况，便于开发人员快速知晓对象的状态信息。
+     * @return 返回一个包含对象关键属性信息的字符串，格式为 "Yonghu{" + 各属性键值对拼接 + "}"，其中属性值按照实际存储的值进行展示。
+     */
     @Override
     public String toString() {
         return "Yonghu{" +
-            "id=" + id +
+                "id=" + id +
-            ", username=" + username +
+                ", username=" + username +
-            ", password=" + password +
+                ", password=" + password +
-            ", yonghuName=" + yonghuName +
+                ", yonghuName=" + yonghuName +
-            ", yonghuPhoto=" + yonghuPhoto +
+                ", yonghuPhoto=" + yonghuPhoto +
-            ", yonghuPhone=" + yonghuPhone +
+                ", yonghuPhone=" + yonghuPhone +
-            ", yonghuEmail=" + yonghuEmail +
+                ", yonghuEmail=" + yonghuEmail +
-            ", sexTypes=" + sexTypes +
+                ", sexTypes=" + sexTypes +
-            ", newMoney=" + newMoney +
+                ", newMoney=" + newMoney +
-            ", yonghuDelete=" + yonghuDelete +
+                ", yonghuDelete=" + yonghuDelete +
-            ", createTime=" + createTime +
+                ", createTime=" + createTime +
-        "}";
+                "}";
     }
 }

minsu/minsuguanliw/src/main/java/com/entity/model/DictionaryModel.java

@@ -8,180 +8,266 @@ import java.util.Date;
 import org.springframework.format.annotation.DateTimeFormat;
 import java.io.Serializable;
 
-
 /**
  * 字典表
  * 接收传参的实体类
- *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ * 该类主要用于在系统与外部（如移动端等）
- * 取自ModelAndView 的model名称
+ * 进行数据交互时，接收传递过来的与字典表相关的参数信息，起到数据传输载体的作用。
+ * 在实际开发中，根据具体业务场景，
+ * 可以手动对其包含的字段进行筛选调整（去掉一些在特定接口或业务逻辑中不需要的字段），
+ * 因为后端在很多情况下直接使用 `entity` 类
+ * （如 `DictionaryEntity`）就可以满足基本的数据操作需求，这里的 `Model` 类更侧重于接收外部传入的数据格式适配。
+ * 其名称取自 `ModelAndView` 的 `model`，
+ * 暗示了它在数据传递和视图模型构建方面的作用（通常用于构建适合展示或处理的数据模型结构）。
  */
 public class DictionaryModel implements Serializable {
     private static final long serialVersionUID = 1L;
 
-
+    // **
-
+    //  * 主键，用于唯一标识字典表中的每一条记录，
-
+    //  在数据库操作中（如查询、更新、删除等）可通过主键精准定位到特定的字典表数据行，
-    /**
+    //  * 通常对应数据库表中定义的主键字段，
-     * 主键
+    //  保证数据的唯一性和可识别性。
-     */
+    //  */
     private Integer id;
 
-
+    // **
-    /**
+    //  * 字段，可能用于存储字典表中某个条目的特定代码或者标识信息，
-     * 字段
+    //  例如可以是代表不同分类、类型等的代码值，
-     */
+    //  * 通过该字段能够区分不同的字典项，
+    //  并且在业务逻辑中可以基于此字段进行相关的查询、匹配等操作。
+    //  */
     private String dicCode;
 
-
+    // **
-    /**
+    //  * 字段名，与 `dicCode` 相对应，
-     * 字段名
+    //  用于存储该字段对应的直观的名称描述，
-     */
+    //  方便在前端展示或者业务逻辑处理中让人更容易理解该字段所代表的含义，
+    //  * 例如如果 `dicCode` 是分类代码，那 `dicName` 就是具体的分类名称，增强了数据的可读性。
+    //  */
     private String dicName;
 
-
+    // **
-    /**
+    //  * 编码，可能是对字典表中各项进行编号的一个整数值，
-     * 编码
+    //  用于在内部对字典项进行排序、索引或者作为另一种标识方式，
-     */
+    //  * 在一些需要按照特定顺序处理字典数据或者通过编号快速查找字典项的业务场景中会发挥作用。
+    //  */
     private Integer codeIndex;
 
-
+    // **
-    /**
+    //  * 编码名字，与 `codeIndex` 相对应，
-     * 编码名字
+    //  是对该编码所代表含义的文字描述，
-     */
+    //  同样是为了提高数据的可读性和可理解性，
+    //  * 便于在展示给用户或者业务逻辑处理中清晰地知晓该编码具体对应的内容。
+    //  */
     private String indexName;
 
-
+    // **
-    /**
+    //  * 父字段id，用于表示当前字典项在层级结构中的上级字段的唯一标识（如果字典表存在层级关系的话），
-     * 父字段id
+    //  * 通过这个 `superId`
-     */
+    //  可以构建字典项之间的父子关联关系，方便进行树形结构数据的展示、
+    //  查询以及相关业务逻辑处理（比如查找某个分类下的子分类等情况）。
+    //  */
     private Integer superId;
 
-
+    // **
-    /**
+    //  * 备注，用于存储一些对该字典项的额外说明信息，
-     * 备注
+    //  例如该项的特殊用途、适用范围、创建背景等内容，
-     */
+    //  * 在需要详细了解字典项相关细节或者进行一些辅助性的业务逻辑判断时，
+    //  可以参考备注中的信息。
+    //  */
     private String beizhu;
 
-
+    // **
-    /**
+    //  * 创建时间，记录该字典表记录的创建时间点，
-     * 创建时间
+    //  通过 `@JsonFormat` 和 `@DateTimeFormat` 注解来规范时间格式的序列化与格式化处理，
-     */
+    //  * 确保在前后端交互以及数据存储等场景下时间格式的一致性。
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    //  例如在按照时间顺序查询字典表数据、统计不同时间段创建的数据量等业务场景中会用到该时间信息。
-	@DateTimeFormat
+    //  * @JsonFormat 注解用于控制在将对象转换为JSON格式时时间的显示格式。
+    //  * @DateTimeFormat 注解用于在接收前端传入时间格式数据时进行解析转换。
+    //  */
+    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat
     private Date createTime;
 
-
+    // **
-    /**
+    //  * 获取：主键，对外提供获取主键值的方法，
-	 * 获取：主键
+    //  方便在其他类中访问该对象的主键信息，
-	 */
+    //  例如在进行数据库查询结果映射或者业务逻辑处理中需要用到字典表记录主键时可调用此方法获取。
+    //  * @return 返回主键对应的整数值。
+    //  */
     public Integer getId() {
         return id;
     }
 
-
+    // **
-    /**
+    //  * 设置：主键，用于设置该对象的主键值，
-	 * 设置：主键
+    //  通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用
-	 */
+    //  ，例如创建新字典表记录对象并保存到数据库前需要设置主键值。
+    //  * @param id 要设置的主键整数值。
+    //  */
     public void setId(Integer id) {
         this.id = id;
     }
-    /**
+
-	 * 获取：字段
+    // **
-	 */
+    //  * 获取：字段，对外提供获取字段值（`dicCode`）的方法，
+    //  以便在业务逻辑中根据该字段进行相关操作，比如查询特定代码的字典项、
+    //  * 根据代码进行匹配判断等情况时可调用此方法获取字段值，返回对应的字符串内容。
+    //  * @return 返回字段对应的字符串值。
+    //  */
     public String getDicCode() {
         return dicCode;
     }
 
-
+    // **
-    /**
+    //  * 设置：字段，用于更新字段值（`dicCode`），
-	 * 设置：字段
+    //  例如在修改字典表记录中该字段的代码内容后，
-	 */
+    //  调用此方法来保存新的代码信息，以反映字典项的变化。
+    //  * @param dicCode 要设置的字段字符串值。
+    //  */
     public void setDicCode(String dicCode) {
         this.dicCode = dicCode;
     }
-    /**
+
-	 * 获取：字段名
+    // **
-	 */
+    //  * 获取：字段名，对外提供获取字段名（`dicName`）的方法，
+    //  在需要展示字典项的名称给用户或者在业务逻辑中基于名称进行相关处理（如筛选、排序等）时，
+    //  * 可调用此方法获取对应的字符串内容，方便操作和展示。
+    //  * @return 返回字段名对应的字符串值。
+    //  */
     public String getDicName() {
         return dicName;
     }
 
-
+    // **
-    /**
+    //  * 设置：字段名，用于更新字段名（`dicName`），
-	 * 设置：字段名
+    //  比如对字典项的名称进行修改后，通过此方法保存新的名称信息，
-	 */
+    //  确保名称能准确反映字典项的实际含义。
+    //  * @param dicName 要设置的字段名字符串值。
+    //  */
     public void setDicName(String dicName) {
         this.dicName = dicName;
     }
-    /**
+
-	 * 获取：编码
+    // **
-	 */
+    //  * 获取：编码，对外提供获取编码值（`codeIndex`）的方法，
+    //  在涉及到按照编码进行排序、查找特定编码的字典项等业务场景中，
+    //  * 可调用此方法获取对应的整数值，便于进行相应的业务处理。
+    //  * @return 返回编码对应的整数值。
+    //  */
     public Integer getCodeIndex() {
         return codeIndex;
     }
 
-
+    // **
-    /**
+    //  * 设置：编码，用于更新编码值（`codeIndex`），
-	 * 设置：编码
+    //  例如调整字典项的编号顺序或者重新分配编码后，
-	 */
+    //  调用此方法来保存新的编码信息，以符合业务要求的编码规则。
+    //  * @param codeIndex 要设置的编码整数值。
+    //  */
     public void setCodeIndex(Integer codeIndex) {
         this.codeIndex = codeIndex;
     }
-    /**
+
-	 * 获取：编码名字
+    // **
-	 */
+    //  * 获取：编码名字，对外提供获取编码名字（`indexName`）的方法，
+    //  在需要展示编码对应的具体含义或者基于名称进行业务逻辑处理（如匹配、筛选等）时，
+    //  * 可调用此方法获取对应的字符串内容，增强数据的可读性和可操作性。
+    //  * @return 返回编码名字对应的字符串值。
+    //  */
     public String getIndexName() {
         return indexName;
     }
 
-
+    // **
-    /**
+    //  * 设置：编码名字，用于更新编码名字（`indexName`），
-	 * 设置：编码名字
+    //  比如对编码所代表的含义进行重新定义或者修改描述后，通过此方法保存新的名称信息，
-	 */
+    //  * 以便准确传达编码的实际意义。
+    //  * @param indexName 要设置的编码名字符串值。
+    //  */
     public void setIndexName(String indexName) {
         this.indexName = indexName;
     }
-    /**
+
-	 * 获取：父字段id
+    // **
-	 */
+    //  * 获取：父字段id，对外提供获取父字段id（`superId`）的方法，
+    //  在处理字典表的层级关系数据时，比如查找某个父项下的子项、
+    //  * 判断字典项的层级归属等业务场景中，
+    //  可调用此方法获取对应的整数值，
+    //  方便进行相关的关联操作和业务逻辑处理。
+    //  * @return 返回父字段id对应的整数值。
+    //  */
+
+
+
+
+
     public Integer getSuperId() {
         return superId;
     }
 
+    // **
+    //  * 设置：父字段id，用于更新父字段id（`superId`）的值，
+    //  例如调整字典项的层级结构、变更上级字段后，通过此方法保存新的父字段id信息，
+    //  * 以正确反映字典项在层级关系中的位置变化。
+    //  * @param superId 要设置的父字段id整数值。
+    //  */
+
+
+
 
-    /**
-	 * 设置：父字段id
-	 */
     public void setSuperId(Integer superId) {
         this.superId = superId;
     }
-    /**
+
-	 * 获取：备注
+    // **
-	 */
+    //  * 获取：备注，对外提供获取备注信息（`beizhu`）的方法，
+    //
+    //  在需要查看字典项的额外说明或者根据备注内容进行一些特殊业务逻辑判断（如判断适用范围等）时，
+    //  * 可调用此方法获取对应的字符串内容，辅助业务处理。
+    //  * @return 返回备注对应的字符串值。
+    //  */
     public String getBeizhu() {
         return beizhu;
     }
 
-
+    // **
-    /**
+    //  * 设置：备注，用于更新备注信息（`beizhu`），
-	 * 设置：备注
+    //
-	 */
+    //  例如添加、修改字典项的备注内容后，通过此方法保存新的备注信息，方便后续查看和参考。
+    //  * @param beizhu 要设置的备注字符串值。
+    //  */
     public void setBeizhu(String beizhu) {
         this.beizhu = beizhu;
     }
-    /**
+
-	 * 获取：创建时间
+    // **
-	 */
+    //  * 获取：创建时间，对外提供获取创建时间（`createTime`）的方法，
+    //
+    //  在展示字典表记录的创建时间、按照时间范围查询字典项、
+    //  * 统计不同时间段创建的数据量等业务场景中，可调用此方法获取对应的 `
+    //
+    //
+    //  Date` 类型对象，用于后续的时间相关操作和展示。
+    //  * @return 返回创建时间对应的 `Date` 类型对象。
+    //  */
     public Date getCreateTime() {
         return createTime;
     }
 
+    // **
+
 
-    /**
+    //  * 设置：创建时间，用于更新创建时间（`createTime`）的值
-	 * 设置：创建时间
+    //
-	 */
+    //  ，不过在实际业务中通常创建时间是在记录首次创建时自动设置，较少进行手动更新，
+    //  * 但保留此方法以满足可能的特殊需求（如数据迁移、时间校准等场景下对创建时间进行调整），
+    //
+    //  通过传入对应的 `Date` 类型对象来更新创建时间信息。
+    //  * @param createTime 要设置的创建时间对应的 `Date` 类型对象。
+    //  */
     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
-
+}
-    }

minsu/minsuguanliw/src/main/java/com/entity/model/FangjianLiuyanModel.java

@@ -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")
+    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
     private Date insertTime;
 
-
     /**
      * 回复时间
+     * 用于记录对用户的评论/投诉进行回复的具体时间点，同样通过相关注解来规范其日期时间格式处理，方便在不同场景下正确展示和使用该时间数据
      */
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
     private Date updateTime;
 
-
     /**
      * 创建时间
+     * 用于记录该条房间评论/投诉记录在系统中创建的时间点，例如在插入数据库时自动获取当前时间作为创建时间，也通过注解保证日期时间格式的正确处理
      */
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @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;
     }
-
+}
-    }

minsu/minsuguanliw/src/main/java/com/entity/model/FangjianModel.java

@@ -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")
+    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @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;
     }
-
+}
-    }

minsu/minsuguanliw/src/main/java/com/entity/model/FangjianOrderModel.java

@@ -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")
+    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @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")
+    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @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;
     }
-
+}
-    }

minsu/minsuguanliw/src/main/java/com/entity/model/ForumModel.java

@@ -1,231 +1,238 @@
 package com.entity.model;
 
 import com.entity.ForumEntity;
-
 import com.baomidou.mybatisplus.annotations.TableName;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import java.util.Date;
 import org.springframework.format.annotation.DateTimeFormat;
 import java.io.Serializable;
 
-
+// **
-/**
+//  * 论坛
- * 论坛
+//  * 接收传参的实体类
- * 接收传参的实体类
+//  * （实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
- *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+//  * 取自ModelAndView的model名称
- * 取自ModelAndView 的model名称
+//  */
- */
 public class ForumModel implements Serializable {
-    private static final long serialVersionUID = 1L;
-
-
 
+    // 用于定义序列化版本号，在对象序列化和反序列化过程中确保版本兼容性，当类的结构发生变化时，可适当更新此版本号
+    private static final long serialVersionUID = 1L;
 
-    /**
+    // **
-     * 主键
+    //  * 主键，用于唯一标识论坛中的每一条记录，通常对应数据库表中的主键字段
-     */
+    //  */
     private Integer id;
 
-
+    // **
-    /**
+    //  * 帖子标题，用于存储论坛帖子的标题内容，展示给用户查看帖子主题
-     * 帖子标题
+    //  */
-     */
     private String forumName;
 
-
+    // **
-    /**
+    //  * 用户，可能关联到发布该帖子的用户的唯一标识（通常是用户ID），用于记录帖子的发布者信息
-     * 用户
+    //  */
-     */
     private Integer yonghuId;
 
-
+    // **
-    /**
+    //  * 管理员，可能关联到对该帖子有管理权限的管理员的唯一标识（通常是管理员ID），便于后续进行相关管理操作时确定操作主体
-     * 管理员
+    //  */
-     */
     private Integer usersId;
 
-
+    // **
-    /**
+    //  * 发布内容，用于存储用户在论坛中发布帖子的具体文本内容，是帖子的核心信息部分
-     * 发布内容
+    //  */
-     */
     private String forumContent;
 
-
+    // **
-    /**
+    //  * 父id，可能用于表示当前帖子所属的上级帖子的ID（例如在有回复、跟帖等层级结构的论坛中，用于构建帖子之间的关联关系）
-     * 父id
+    //  */
-     */
     private Integer superIds;
 
-
+    // **
-    /**
+    //  * 帖子状态，用于标记帖子当前所处的状态，比如是正常显示、已删除、待审核等不同状态，不同整数值可对应不同的业务状态含义
-     * 帖子状态
+    //  */
-     */
     private Integer forumStateTypes;
 
-
+    // **
-    /**
+    //  * 发帖时间，记录帖子发布的具体时间，通过 @JsonFormat 和 @DateTimeFormat 注解来规范时间格式的序列化与格式化处理，确保在前后端交互以及数据存储等场景下时间格式的一致性
-     * 发帖时间
+    //  * @JsonFormat 注解用于控制在将对象转换为JSON格式时时间的显示格式
-     */
+    //  * @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")
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat
-	@DateTimeFormat
     private Date updateTime;
 
-
+    // **
-    /**
+    //  * 创建时间 show2，可能是用于特定展示需求或者区分不同创建时间相关概念的字段，同样进行时间格式规范处理，记录帖子相关创建操作对应的时间信息
-     * 创建时间 show2
+    //  */
-     */
+    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat
-	@DateTimeFormat
     private Date createTime;
 
-
+    // **
-    /**
+    //  * 获取：主键，对外提供获取主键值的方法，方便在其他类中访问该对象的主键信息
-	 * 获取：主键
+    //  * @return 返回主键对应的整数值
-	 */
+    //  */
     public Integer getId() {
         return id;
     }
 
-
+    // **
-    /**
+    //  * 设置：主键，用于设置该对象的主键值，通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用
-	 * 设置：主键
+    //  * @param id 要设置的主键整数值
-	 */
+    //  */
     public void setId(Integer id) {
         this.id = id;
     }
-    /**
+
-	 * 获取：帖子标题
+    // **
-	 */
+    //  * 获取：帖子标题，对外提供获取帖子标题的方法，以便在业务逻辑中获取并展示或处理帖子标题相关内容
+    //  * @return 返回帖子标题对应的字符串值
+    //  */
     public String getForumName() {
         return forumName;
     }
 
-
+    // **
-    /**
+    //  * 设置：帖子标题，用于更新帖子标题内容，例如用户编辑帖子标题后调用此方法来保存新的标题信息
-	 * 设置：帖子标题
+    //  * @param forumName 要设置的帖子标题字符串值
-	 */
+    //  */
     public void setForumName(String forumName) {
         this.forumName = forumName;
     }
-    /**
+
-	 * 获取：用户
+    // **
-	 */
+    //  * 获取：用户，对外提供获取发布该帖子用户ID的方法，便于在业务逻辑中关联用户相关信息，如查询用户详情等
+    //  * @return 返回发布帖子的用户对应的ID整数值
+    //  */
     public Integer getYonghuId() {
         return yonghuId;
     }
 
-
+    // **
-    /**
+    //  * 设置：用户，用于设置发布该帖子的用户ID，可能在从数据库加载数据或者创建新帖子对象时调用此方法来关联用户信息
-	 * 设置：用户
+    //  * @param yonghuId 要设置的用户ID整数值
-	 */
+    //  */
     public void setYonghuId(Integer yonghuId) {
         this.yonghuId = yonghuId;
     }
-    /**
+
-	 * 获取：管理员
+    // **
-	 */
+    //  * 获取：管理员，对外提供获取对该帖子有管理权限的管理员ID的方法，方便在进行管理操作时确定操作主体相关信息
+    //  * @return 返回管理员对应的ID整数值
+    //  */
     public Integer getUsersId() {
         return usersId;
     }
 
-
+    // **
-    /**
+    //  * 设置：管理员，用于设置对该帖子有管理权限的管理员ID，例如在分配管理员对特定帖子进行管理等场景下调用此方法来关联管理员信息
-	 * 设置：管理员
+    //  * @param usersId 要设置的管理员ID整数值
-	 */
+    //  */
     public void setUsersId(Integer usersId) {
         this.usersId = usersId;
     }
-    /**
+
-	 * 获取：发布内容
+    // **
-	 */
+    //  * 获取：发布内容，对外提供获取帖子发布内容的方法，用于在展示帖子详情、搜索帖子内容等业务场景中获取具体文本信息
+    //  * @return 返回帖子发布内容对应的字符串值
+    //  */
     public String getForumContent() {
         return forumContent;
     }
 
-
+    // **
-    /**
+    //  * 设置：发布内容，用于更新帖子的发布内容，例如用户编辑帖子内容后调用此方法来保存新的内容信息
-	 * 设置：发布内容
+    //  * @param forumContent 要设置的发布内容字符串值
-	 */
+    //  */
     public void setForumContent(String forumContent) {
         this.forumContent = forumContent;
     }
-    /**
+
-	 * 获取：父id
+    // **
-	 */
+    //  * 获取：父id，对外提供获取帖子父ID的方法，在处理帖子层级关系相关业务逻辑时（如查询回复所属的原帖等）会用到此信息
+    //  * @return 返回帖子父ID对应的整数值
+    //  */
     public Integer getSuperIds() {
         return superIds;
     }
 
-
+    // **
-    /**
+    //  * 设置：父id，用于设置帖子的父ID，例如在创建回复帖子并关联到原帖等场景下调用此方法来构建帖子间的层级关联关系
-	 * 设置：父id
+    //  * @param superIds 要设置的父ID整数值
-	 */
+    //  */
     public void setSuperIds(Integer superIds) {
         this.superIds = superIds;
     }
-    /**
+
-	 * 获取：帖子状态
+    // **
-	 */
+    //  * 获取：帖子状态，对外提供获取帖子当前状态的方法，便于在业务逻辑中根据状态进行不同的处理，如显示、隐藏、审核等操作
+    //  * @return 返回帖子状态对应的整数值
+    //  */
     public Integer getForumStateTypes() {
         return forumStateTypes;
     }
 
-
+    // **
-    /**
+    //  * 设置：帖子状态，用于更新帖子的状态，比如管理员审核通过帖子后调用此方法将状态设置为正常显示等场景下使用
-	 * 设置：帖子状态
+    //  * @param forumStateTypes 要设置的帖子状态整数值
-	 */
+    //  */
     public void setForumStateTypes(Integer forumStateTypes) {
         this.forumStateTypes = forumStateTypes;
     }
-    /**
+
-	 * 获取：发帖时间
+    // **
-	 */
+    //  * 获取：发帖时间，对外提供获取帖子发布时间的方法，在展示帖子信息、按时间排序等业务场景中会用到此时间信息
+    //  * @return 返回帖子发布时间对应的Date对象
+    //  */
     public Date getInsertTime() {
         return insertTime;
     }
 
-
+    // **
-    /**
+    //  * 设置：发帖时间，用于设置帖子的发布时间，一般在创建帖子对象时会根据实际发布时间来调用此方法进行设置
-	 * 设置：发帖时间
+    //  * @param insertTime 要设置的发布时间对应的Date对象
-	 */
+    //  */
     public void setInsertTime(Date insertTime) {
         this.insertTime = insertTime;
     }
-    /**
+
-	 * 获取：修改时间
+    // **
-	 */
+    //  * 获取：修改时间，对外提供获取帖子最后修改时间的方法，在展示帖子历史修改记录、判断内容更新情况等业务场景中会用到此时间信息
+    //  * @return 返回帖子最后修改时间对应的Date对象
+    //  */
     public Date getUpdateTime() {
         return updateTime;
     }
 
-
+    // **
-    /**
+    //  * 设置：修改时间，用于更新帖子最后修改时间，在帖子内容被修改后调用此方法来记录最新的修改时间信息
-	 * 设置：修改时间
+    //  * @param updateTime 要设置的最后修改时间对应的Date对象
-	 */
+    //  */
     public void setUpdateTime(Date updateTime) {
         this.updateTime = updateTime;
     }
-    /**
+
-	 * 获取：创建时间 show2
+    // **
-	 */
+    //  * 获取：创建时间 show2，对外提供获取该特定创建时间字段值的方法，根据具体业务需求在相关场景中使用此时间信息
+    //  * @return 返回创建时间 show2对应的Date对象
+    //  */
     public Date getCreateTime() {
         return createTime;
     }
 
-
+    // **
-    /**
+    //  * 设置：创建时间 show2，用于设置该特定创建时间字段的值，在相应的创建相关业务操作场景下调用此方法进行设置
-	 * 设置：创建时间 show2
+    //  * @param createTime 要设置的创建时间 show2对应的Date对象
-	 */
+    //  */
     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
-
+}
-    }

minsu/minsuguanliw/src/main/java/com/entity/model/NewsModel.java

@@ -1,169 +1,198 @@
 package com.entity.model;
 
 import com.entity.NewsEntity;
-
 import com.baomidou.mybatisplus.annotations.TableName;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import java.util.Date;
 import org.springframework.format.annotation.DateTimeFormat;
 import java.io.Serializable;
 
-
 /**
  * 公告信息
  * 接收传参的实体类
- *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ * （实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
- * 取自ModelAndView 的model名称
+ * 取自ModelAndView的model名称
  */
 public class NewsModel implements Serializable {
-    private static final long serialVersionUID = 1L;
-
-
 
+    // 用于定义序列化版本号，在对象序列化和反序列化过程中确保版本兼容性，
+    // 当类的结构发生变化时，可适当更新此版本号
+    private static final long serialVersionUID = 1L;
 
-    /**
+    // **
-     * 主键
+    //  * 主键，用于唯一标识每一条公告记录，
-     */
+    //  通常对应数据库表中的主键字段，方便对公告进行查找、更新、删除等操作
+    //  */
     private Integer id;
 
-
+    // **
-    /**
+    //  * 公告标题，存储公告的标题内容，
-     * 公告标题
+    //  用于直观展示公告主题，方便用户快速了解公告大致内容
-     */
+    //  */
     private String newsName;
 
-
+    // **
-    /**
+    //  * 公告类型，可能用于区分不同种类的公告（例如通知类、活动类、政策类等）
-     * 公告类型
+    //  ，通过不同的整数值对应不同的公告分类，便于后续按类型筛选、展示公告
-     */
+    //  */
     private Integer newsTypes;
 
-
+    // **
-    /**
+    //  * 公告图片，用于存储公告相关的图片路径或者图片资源的标识等信息
-     * 公告图片
+    //  （具体取决于项目中图片存储和引用的方式），可用于在前端展示公告时显示对应的图片内容，增强公告的展示效果
-     */
+    //  */
     private String newsPhoto;
 
-
+    // **
-    /**
+    //  * 添加时间，记录公告被添加到系统中的具体时间，
-     * 添加时间
+    //  通过 @JsonFormat 和 @DateTimeFormat
-     */
+    //  注解来规范时间格式的序列化与格式化处理，确保在前后端交互以及数据存储等场景下时间格式的一致性
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    //  * @JsonFormat 注解用于控制在将对象转换为JSON格式时时间的显示格式
-	@DateTimeFormat
+    //  * @DateTimeFormat 注解用于在接收前端传入时间格式数据时进行解析转换
+    //  */
+    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
+    @DateTimeFormat
     private Date insertTime;
 
-
+    // **
-    /**
+    //  * 公告详情，用于存储公告的详细文本内容，
-     * 公告详情
+    //  是公告的核心信息部分，包含了需要传达给用户的具体事项、说明等内容
-     */
+    //  */
     private String newsContent;
 
-
+    // **
-    /**
+    //  * 创建时间 show1 show2 nameShow，
-     * 创建时间 show1 show2 nameShow
+    //  可能是用于满足不同业务场景下对公告创建时间展示需求而设置的字段（比如在不同页面或者功能模块中以不同名称展示创建时间），同样使用相关注解保证时间格式处理的正确性，用于记录公告创建相关的时间信息
-     */
+    //  */
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
     private Date createTime;
 
-
+    // **
-    /**
+    //  * 获取：主键，对外提供获取主键值的方法，
-	 * 获取：主键
+    //  方便在其他类中访问该对象的主键信息，例如在进行数据库查询结果映射或者业务逻辑处理中需要用到公告主键时可调用此方法获取
-	 */
+    //  * @return 返回主键对应的整数值
+    //  */
     public Integer getId() {
         return id;
     }
 
-
+    // **
-    /**
+    //  * 设置：主键，用于设置该对象的主键值，
-	 * 设置：主键
+    //  通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用，例如创建新公告对象并保存到数据库前需要设置主键值
-	 */
+    //  * @param id 要设置的主键整数值
+    //  */
     public void setId(Integer id) {
         this.id = id;
     }
-    /**
+
-	 * 获取：公告标题
+    // **
-	 */
+    //  * 获取：公告标题，对外提供获取公告标题的方法，
+    //  以便在业务逻辑中获取并展示或处理公告标题相关内容，比如在前端页面展示公告列表时调用此方法获取标题并显示给用户
+    //  * @return 返回公告标题对应的字符串值
+    //  */
     public String getNewsName() {
         return newsName;
     }
 
-
+    // **
-    /**
+    //  * 设置：公告标题，用于更新公告标题内容，
-	 * 设置：公告标题
+    //  例如管理员编辑公告标题后调用此方法来保存新的标题信息
-	 */
+    //  * @param newsName 要设置的公告标题字符串值
+    //  */
     public void setNewsName(String newsName) {
         this.newsName = newsName;
     }
-    /**
+
-	 * 获取：公告类型
+    // **
-	 */
+    //  * 获取：公告类型，对外提供获取公告类型的方法，
+    //  便于在业务逻辑中根据类型进行不同的处理，如按类型分类展示公告、根据类型进行权限控制等操作，
+    //  可通过返回的整数值判断公告所属类型
+    //  * @return 返回公告类型对应的整数值
+    //  */
     public Integer getNewsTypes() {
         return newsTypes;
     }
 
-
+    // **
-    /**
+    //  * 设置：公告类型，用于更新公告的类型，
-	 * 设置：公告类型
+    //  比如管理员对公告重新分类后调用此方法将类型设置为新的分类对应整数值，以反映公告类型的变化
-	 */
+    //  * @param newsTypes 要设置的公告类型整数值
+    //  */
     public void setNewsTypes(Integer newsTypes) {
         this.newsTypes = newsTypes;
     }
-    /**
+
-	 * 获取：公告图片
+    // **
-	 */
+    //  * 获取：公告图片，对外提供获取公告图片相关信息的方法，
+    //  在业务逻辑中用于获取图片信息以在前端展示公告图片，具体返回的字符串根据项目中图片存储和引用方式而定，
+    //  可能是图片的URL、本地路径等
+    //  * @return 返回公告图片对应的字符串值
+    //  */
     public String getNewsPhoto() {
         return newsPhoto;
     }
 
-
+    // **
-    /**
+    //  * 设置：公告图片，用于更新公告的图片信息，
-	 * 设置：公告图片
+    //  例如管理员更换公告图片后调用此方法来保存新的图片相关字符串信息，以更新公告展示时的图片内容
-	 */
+    //  * @param newsPhoto 要设置的公告图片字符串值
+    //  */
     public void setNewsPhoto(String newsPhoto) {
         this.newsPhoto = newsPhoto;
     }
-    /**
+
-	 * 获取：添加时间
+    // **
-	 */
+    //  * 获取：添加时间，对外提供获取公告添加时间的方法，在展示公告信息、
+    //  按时间排序等业务场景中会用到此时间信息，例如在公告列表中按照添加时间先后顺序展示公告
+    //  * @return 返回公告添加时间对应的Date对象
+    //  */
     public Date getInsertTime() {
         return insertTime;
     }
 
-
+    // **
-    /**
+    //  * 设置：添加时间，用于设置公告的添加时间，
-	 * 设置：添加时间
+    //  一般在创建公告对象时会根据实际添加时间来调用此方法进行设置，确保添加时间记录的准确性
-	 */
+    //  * @param insertTime 要设置的添加时间对应的Date对象
+    //  */
     public void setInsertTime(Date insertTime) {
         this.insertTime = insertTime;
     }
-    /**
+
-	 * 获取：公告详情
+    // **
-	 */
+    //  * 获取：公告详情，对外提供获取公告详细内容的方法，
+    //  用于在展示公告详情页面、搜索公告内容等业务场景中获取具体文本信息，以完整呈现公告需要传达的信息
+    //  * @return 返回公告详情对应的字符串值
+    //  */
     public String getNewsContent() {
         return newsContent;
     }
 
-
+    // **
-    /**
+    //  * 设置：公告详情，用于更新公告的详细内容，
-	 * 设置：公告详情
+    //  例如管理员编辑公告内容后调用此方法来保存新的内容信息，保证公告详情能及时更新反映最新情况
-	 */
+    //  * @param newsContent 要设置的公告详情字符串值
+    //  */
     public void setNewsContent(String newsContent) {
         this.newsContent = newsContent;
     }
-    /**
+
-	 * 获取：创建时间 show1 show2 nameShow
+    // **
-	 */
+    //  * 获取：创建时间 show1 show2 nameShow，
+    //  对外提供获取该特定创建时间字段值的方法，根据具体业务需求在相关场景中使用此时间信息，例如在不同的展示页面按照对应名称展示公告创建时间
+    //  * @return 返回创建时间 show1 show2 nameShow对应的Date对象
+    //  */
     public Date getCreateTime() {
         return createTime;
     }
 
-
+    // **
-    /**
+    //  * 设置：创建时间 show1 show2 nameShow，
-	 * 设置：创建时间 show1 show2 nameShow
+    //  用于设置该特定创建时间字段的值，在相应的创建相关业务操作场景下调用此方法进行设置，确保创建时间记录符合业务要求
-	 */
+    //  * @param createTime 要设置的创建时间 show1 show2 nameShow对应的Date对象
+    //  */
     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
-
+}
-    }

minsu/minsuguanliw/src/main/java/com/entity/model/YonghuModel.java

@@ -12,236 +12,290 @@ import java.io.Serializable;
 /**
  * 用户
  * 接收传参的实体类
- *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ * 此实体类用于接收与用户相关的数据参数，在实际的业务流程中，比如前端向后端传递用户信息或者后端内部不同模块间传递用户相关数据时会用到该类来承载数据。
+ * （实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
+ * 这里说明了在实际开发场景下，根据移动端接口开发的具体需求，可能会对该类中的字段进行调整，去除一些不必要的字段，并且通常后端直接使用对应的实体类（可能指的是更纯粹与数据库表结构对应的实体类）就可以满足大部分需求了，此处在特定场景下有其存在的意义。
  * 取自ModelAndView 的model名称
+ * 表明这个类的命名可能与ModelAndView中的model相关概念有关联，或许是用于类似的在视图与数据传递间起作用的实体对象。
  */
 public class YonghuModel implements Serializable {
     private static final long serialVersionUID = 1L;
 
-
-
-
     /**
      * 主键
+     * 用于唯一标识一条用户记录，在数据库中通常对应着表的主键字段，通过该字段可以准确地定位、操作某一个特定用户的数据。
      */
     private Integer id;
 
-
     /**
      * 账户
+     * 用于存储用户的登录账户信息，是用户登录系统时所使用的标识之一，通常具有唯一性，方便系统区分不同的用户。
      */
     private String username;
 
-
     /**
      * 密码
+     * 存储用户登录系统时需要提供的密码信息，用于验证用户身份的合法性，保证只有知道正确密码的用户才能登录成功并访问相应权限内的功能。
      */
     private String password;
 
-
     /**
      * 用户姓名
+     * 用于记录用户的真实姓名，便于在系统中更友好地展示用户信息，比如在用户个人资料页面、用户列表展示等场景下呈现给用户或者管理员查看。
      */
     private String yonghuName;
 
-
     /**
      * 头像
+     * 用于存放用户头像对应的文件路径或者头像相关的标识信息（具体取决于系统的实现方式），以在系统界面上展示用户的个性化头像，增强用户体验和辨识度。
      */
     private String yonghuPhoto;
 
-
     /**
      * 手机号
+     * 存储用户的手机号码信息，可用于多种业务场景，比如身份验证、短信通知、找回密码等操作时与用户进行联系的重要方式。
      */
     private String yonghuPhone;
 
-
     /**
      * 电子邮箱
+     * 保存用户的电子邮箱地址，同样可用于系统与用户之间的沟通交流，例如发送重要通知、密码重置链接等，也是用户在系统中重要的联系方式之一。
      */
     private String yonghuEmail;
 
-
     /**
      * 性别
+     * 用于记录用户的性别信息，可能取值为特定的代码（如0表示男，1表示女等，具体由业务定义），方便系统根据性别进行相关的统计、展示或者业务逻辑处理。
      */
     private Integer sexTypes;
 
-
     /**
      * 余额
+     * 用于存储用户在系统中的账户余额信息，比如在涉及支付、消费、充值等业务功能的系统中，该字段记录着用户当前可支配的金额数量。
      */
     private Double newMoney;
 
-
     /**
      * 假删
+     * 这是一个用于实现软删除功能的字段，通过设置不同的值来表示用户数据是否被删除，例如可以设定某个特定值（如1表示未删除，0表示已删除等，具体由业务规则确定），
+     * 相比于直接从数据库中物理删除数据，软删除便于数据的恢复以及相关业务逻辑的处理，同时可以保留数据的历史记录等信息。
      */
     private Integer yonghuDelete;
 
-
     /**
      * 创建时间
+     * 用于记录用户数据在系统中被创建的具体时间点，通过@JsonFormat注解可以指定该时间在序列化（比如转换为JSON格式返回给前端时）的格式，
+     * @DateTimeFormat注解可能用于在接收前端传入的时间格式数据时进行格式化处理，以便正确地将数据绑定到该字段上，
+     * 该时间信息在很多业务场景中都有作用，比如按照创建时间排序、查询某个时间段内创建的用户等。
      */
-    @JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss")
+    @JsonFormat(locale = "zh", timezone = "GMT + 8", pattern = "yyyy-MM-dd HH:mm:ss")
-	@DateTimeFormat
+    @DateTimeFormat
     private Date createTime;
 
-
     /**
-	 * 获取：主键
+     * 获取：主键
-	 */
+     * 这是一个用于获取主键字段值的公共访问方法（getter方法），按照Java的JavaBean规范定义，方便其他类在需要获取该用户对象的主键值时调用。
+     * @return 返回存储的主键整数值，即用户记录的唯一标识。
+     */
     public Integer getId() {
         return id;
     }
 
-
     /**
-	 * 设置：主键
+     * 设置：主键
-	 */
+     * 这是一个用于设置主键字段值的公共设置方法（setter方法），按照Java的JavaBean规范定义，用于在创建或修改用户对象时为其主键字段赋值，
+     * 通常在一些特定的业务场景下（如从数据库查询数据后填充对象、新建对象并指定其唯一标识等情况）会调用该方法。
+     * @param id 要设置的主键整数值，用于更新用户对象的主键字段内容。
+     */
     public void setId(Integer id) {
         this.id = id;
     }
+
     /**
-	 * 获取：账户
+     * 获取：账户
-	 */
+     * 用于获取用户账户字段值的公共访问方法（getter方法），方便其他类获取该用户对象的账户信息。
+     * @return 返回存储的用户账户字符串值，即用户登录所使用的账户名。
+     */
     public String getUsername() {
         return username;
     }
 
-
     /**
-	 * 设置：账户
+     * 设置：账户
-	 */
+     * 用于设置用户账户字段值的公共设置方法（setter方法），在创建或修改用户对象时可通过该方法为账户字段赋值，比如用户注册或者修改账户名时会用到。
+     * @param username 要设置的用户账户字符串值，用于更新用户对象的账户字段内容。
+     */
     public void setUsername(String username) {
         this.username = username;
     }
+
     /**
-	 * 获取：密码
+     * 获取：密码
-	 */
+     * 用于获取用户密码字段值的公共访问方法（getter方法），不过在实际应用中要注意密码的安全性，一般不会随意对外暴露密码的原始值，
+     * 可能会经过加密等处理后再进行相关操作，此处返回的是存储的密码字符串值。
+     * @return 返回存储的用户密码字符串值，即用户登录时需提供的密码内容。
+     */
     public String getPassword() {
         return password;
     }
 
-
     /**
-	 * 设置：密码
+     * 设置：密码
-	 */
+     * 用于设置用户密码字段值的公共设置方法（setter方法），在用户注册、修改密码等业务场景下会调用该方法为密码字段赋值，
+     * 同样要注意在实际应用中对密码进行安全的存储处理，比如加密后再保存到数据库等操作。
+     * @param password 要设置的用户密码字符串值，用于更新用户对象的密码字段内容。
+     */
     public void setPassword(String password) {
         this.password = password;
     }
+
     /**
-	 * 获取：用户姓名
+     * 获取：用户姓名
-	 */
+     * 用于获取用户姓名字段值的公共访问方法（getter方法），方便在需要展示用户姓名的地方调用该方法获取相应信息。
+     * @return 返回存储的用户姓名字符串值，即用户的真实姓名内容。
+     */
     public String getYonghuName() {
         return yonghuName;
     }
 
-
     /**
-	 * 设置：用户姓名
+     * 设置：用户姓名
-	 */
+     * 用于设置用户姓名字段值的公共设置方法（setter方法），例如在用户完善个人资料、修改姓名等场景下会使用该方法更新用户对象的姓名字段内容。
+     * @param yonghuName 要设置的用户姓名字符串值，用于更新用户对象的姓名字段内容。
+     */
     public void setYonghuName(String yonghuName) {
         this.yonghuName = yonghuName;
     }
+
     /**
-	 * 获取：头像
+     * 获取：头像
-	 */
+     * 用于获取用户头像字段值的公共访问方法（getter方法），在需要展示用户头像的界面或者相关业务逻辑中，可通过该方法获取头像相关信息。
+     * @return 返回存储的用户头像字符串值，可能是头像文件的路径或者头像的标识等内容（具体取决于系统实现）。
+     */
     public String getYonghuPhoto() {
         return yonghuPhoto;
     }
 
-
     /**
-	 * 设置：头像
+     * 设置：头像
-	 */
+     * 用于设置用户头像字段值的公共设置方法（setter方法），比如用户上传新头像、修改头像等业务场景下会调用该方法更新用户对象的头像字段内容。
+     * @param yonghuPhoto 要设置的用户头像字符串值，用于更新用户对象的头像字段内容。
+     */
     public void setYonghuPhoto(String yonghuPhoto) {
         this.yonghuPhoto = yonghuPhoto;
     }
+
     /**
-	 * 获取：手机号
+     * 获取：手机号
-	 */
+     * 用于获取用户手机号字段值的公共访问方法（getter方法），在涉及手机号相关的业务操作（如短信验证、联系用户等）时可通过该方法获取相应信息。
+     * @return 返回存储的用户手机号字符串值，即用户的手机号码内容。
+     */
     public String getYonghuPhone() {
         return yonghuPhone;
     }
 
-
     /**
-	 * 设置：手机号
+     * 设置：手机号
-	 */
+     * 用于设置用户手机号字段值的公共设置方法（setter方法），在用户注册、修改手机号等场景下会调用该方法更新用户对象的手机号字段内容。
+     * @param yonghuPhone 要设置的用户手机号字符串值，用于更新用户对象的手机号字段内容。
+     */
     public void setYonghuPhone(String yonghuPhone) {
         this.yonghuPhone = yonghuPhone;
     }
+
     /**
-	 * 获取：电子邮箱
+     * 获取：电子邮箱
-	 */
+     * 用于获取用户电子邮箱字段值的公共访问方法（getter方法），在需要通过邮箱与用户进行沟通、发送通知等业务场景下可通过该方法获取相应信息。
+     * @return 返回存储的用户电子邮箱字符串值，即用户的邮箱地址内容。
+     */
     public String getYonghuEmail() {
         return yonghuEmail;
     }
 
-
     /**
-	 * 设置：电子邮箱
+     * 设置：电子邮箱
-	 */
+     * 用于设置用户电子邮箱字段值的公共设置方法（setter方法），在用户注册、修改邮箱地址等场景下会调用该方法更新用户对象的电子邮箱字段内容。
+     * @param yonghuEmail 要设置的用户电子邮箱字符串值，用于更新用户对象的电子邮箱字段内容。
+     */
     public void setYonghuEmail(String yonghuEmail) {
         this.yonghuEmail = yonghuEmail;
     }
+
     /**
-	 * 获取：性别
+     * 获取：性别
-	 */
+     * 用于获取用户性别字段值的公共访问方法（getter方法），在需要根据性别进行统计、展示或者业务逻辑处理时可通过该方法获取相应信息。
+     * @return 返回存储的用户性别整数值，其具体含义由业务中对性别的代码定义决定（如0表示男，1表示女等）。
+     */
     public Integer getSexTypes() {
         return sexTypes;
     }
 
-
     /**
-	 * 设置：性别
+     * 设置：性别
-	 */
+     * 用于设置用户性别字段值的公共设置方法（setter方法），在用户完善个人资料、修改性别等场景下会调用该方法更新用户对象的性别字段内容，
+     * 同样要依据业务定义的性别代码规则来进行赋值操作。
+     * @param sexTypes 要设置的用户性别整数值，用于更新用户对象的性别字段内容。
+     */
     public void setSexTypes(Integer sexTypes) {
         this.sexTypes = sexTypes;
     }
+
     /**
-	 * 获取：余额
+     * 获取：余额
-	 */
+     * 用于获取用户余额字段值的公共访问方法（getter方法），在涉及用户账户余额相关的业务操作（如消费、充值、查询余额等）时可通过该方法获取相应信息。
+     * @return 返回存储的用户余额双精度浮点数值，即用户当前账户中的金额数量。
+     */
     public Double getNewMoney() {
         return newMoney;
     }
 
-
     /**
-	 * 设置：余额
+     * 设置：余额
-	 */
+     * 用于设置用户余额字段值的公共设置方法（setter方法），在用户充值、消费等业务场景下会调用该方法更新用户对象的余额字段内容，
+     * 要注意余额的计算和更新逻辑需符合业务规则以及数据的准确性要求。
+     * @param newMoney 要设置的用户余额双精度浮点数值，用于更新用户对象的余额字段内容。
+     */
     public void setNewMoney(Double newMoney) {
         this.newMoney = newMoney;
     }
+
     /**
-	 * 获取：假删
+     * 获取：假删
-	 */
+     * 用于获取用户假删字段值的公共访问方法（getter方法），在涉及数据删除状态判断、数据恢复等业务逻辑中可通过该方法获取相应信息，
+     * 根据其取值来确定用户数据是否已被标记为删除状态（按照业务定义的取值规则）。
+     * @return 返回存储的用户假删整数值，其具体含义由业务中对假删状态的代码定义决定（如1表示未删除，0表示已删除等）。
+     */
     public Integer getYonghuDelete() {
         return yonghuDelete;
     }
 
-
     /**
-	 * 设置：假删
+     * 设置：假删
-	 */
+     * 用于设置用户假删字段值的公共设置方法（setter方法），在进行数据删除（软删除操作）或者恢复已删除数据等业务场景下会调用该方法更新用户对象的假删字段内容，
+     * 要依据业务定义的假删状态代码规则来进行赋值操作。
+     * @param yonghuDelete 要设置的用户假删整数值，用于更新用户对象的假删字段内容。
+     */
     public void setYonghuDelete(Integer yonghuDelete) {
         this.yonghuDelete = yonghuDelete;
     }
+
     /**
-	 * 获取：创建时间
+     * 获取：创建时间
-	 */
+     * 用于获取用户创建时间字段值的公共访问方法（getter方法），在需要按照创建时间进行数据排序、查询某个时间段内创建的用户等业务场景下可通过该方法获取相应信息，
+     * 并且通过相关注解（@JsonFormat和@DateTimeFormat）保证了时间数据在序列化和反序列化过程中的格式正确处理。
+     * @return 返回存储的用户创建时间Date对象，即用户数据在系统中被创建的具体时间点。
+     */
     public Date getCreateTime() {
         return createTime;
     }
 
-
     /**
-	 * 设置：创建时间
+     * 设置：创建时间
-	 */
+     * 用于设置用户创建时间字段值的公共设置方法（setter方法），在创建用户对象或者从数据库查询数据后填充对象等场景下会调用该方法更新用户对象的创建时间字段内容，
+     * 要注意传入的时间值需符合@DateTimeFormat注解定义的格式要求（如果有相应的反序列化处理逻辑），以保证数据能正确绑定到该字段上。
+     * @param createTime 要设置的用户创建时间Date对象，用于更新用户对象的创建时间字段内容。
+     */
     public void setCreateTime(Date createTime) {
         this.createTime = createTime;
     }
-
+}
-    }

minsu/minsuguanliw/src/main/java/com/entity/view/DictionaryView.java

@@ -12,19 +12,45 @@ import java.util.Date;
 /**
  * 字典表
  * 后端返回视图实体辅助类
- * （通常后端关联的表或者自定义的字段需要返回使用）
+ * 此类主要用于作为后端向外部（如前端界面或者其他调用接口的客户端）返回数据时的视图实体辅助类，
+ * 它继承自 `DictionaryEntity`，意味着拥有 `DictionaryEntity` 的所有属性及方法，
+ * 并且在此基础上可以根据业务需求添加额外的属性或者方法，
+ * 用于构建适合展示给外部的视图数据结构。通常在后端业务逻辑中涉及到关联其他表或者有自定义的字段需要一并返回给前端等使用场景下发挥作用，
+ * 帮助对要返回的数据进行整合、格式转换以及添加必要的展示相关逻辑等操作，
+ * 以满足前端展示或外部调用者对数据格式和内容的期望。
  */
 @TableName("dictionary")
 public class DictionaryView extends DictionaryEntity implements Serializable {
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
-
+
-
+	// **
-
+	//  * 默认构造函数，用于创建一个空的 `DictionaryView`
-
+	//  对象实例，在某些场景下（比如先创建对象，后续再根据具体数据来填充属性值）会使用到，
+	//  * 提供了一种灵活创建该视图实体对象的方式，
+	//
+	//  方便后续在复杂业务逻辑中按需构建对象并设置其属性。
+	//  */
 	public DictionaryView() {
 
 	}
 
+	// **
+	//  * 构造函数，用于根据传入的 `DictionaryEntity` 对象，
+	//
+	//  通过 `BeanUtils` 工具类将其属性值复制到当前 `DictionaryView` 对象中，
+	//  * 这样可以方便地基于已有的 `DictionaryEntity`
+	//
+	//
+	//  类型的数据对象来初始化 `DictionaryView` 对象，实现数据的传递和复用，避免重复设置各个属性，提高代码效率，
+	//  * 在后端从数据库查询出 `DictionaryEntity` 数据后，
+	//
+	//  若要转换为适合返回的视图实体时，就可以使用这个构造函数进行属性值的复制，
+	//
+	//  不过在使用过程中需要注意可能出现的异常情况（已在代码中对异常进行了简单处理）。
+	//  * @param dictionaryEntity 要复制属性值的 `DictionaryEntity`
+	//
+	//  对象，通过该对象的属性来初始化当前 `DictionaryView` 对象的属性。
+	//  */
 	public DictionaryView(DictionaryEntity dictionaryEntity) {
 		try {
 			BeanUtils.copyProperties(this, dictionaryEntity);
@@ -33,25 +59,4 @@ public class DictionaryView extends DictionaryEntity implements Serializable {
 			e.printStackTrace();
 		}
 	}
-
+}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-}

minsu/minsuguanliw/src/main/java/com/entity/view/FangjianLiuyanView.java

@@ -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;
+	// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化时（如添加、删除字段等），可以通过修改这个版本号来避免反序列化出错，初始值设为1L，在类相对稳定的情况下一般不需要改动
-
+	// 它类似于一个标识，在对象进行序列化存储后，如果类的结构发生了改变（比如添加了新属性、修改了属性类型等），反序列化时会根据这个版本号来判断是否能够正确还原对象，若版本号不匹配可能会导致反序列化失败，通过手动修改它可以尝试进行兼容处理。
-
+	private static final long serialVersionUID = 1L;
-
+
-
+	// 以下是级联表 fangjian 相关的属性定义，用于存储房间的各种详细信息，方便在展示房间评论/投诉信息时，同时向前端提供对应的房间具体情况，增强信息的完整性和展示效果
-		//级联表 fangjian
+
-			/**
+	// 房间名称
-			* 房间名称
+	// 用于存储房间的具体名称，方便用户更直观地识别和区分不同的房间，例如“标准间”“豪华套房”等，在前端展示评论/投诉信息时可一并展示房间名称，让用户清楚是针对哪个房间的反馈
-			*/
+	// 这样用户在查看评论或投诉内容时，能快速了解所涉及的具体房间，有助于更好地理解反馈的针对性和关联性。
-			private String fangjianName;
+	private String fangjianName;
-			/**
+
-			* 房间图片
+	// 房间图片
-			*/
+	// 用于存储房间相关图片的路径或者图片的标识信息（具体取决于业务中图片存储和引用的方式），以便在前端展示房间外观、内部布置等图片信息，结合评论/投诉内容能让用户更全面了解房间情况
-			private String fangjianPhoto;
+	// 例如，若评论提到房间的装修风格，同时展示房间的图片可以让用户更直观地感受装修的实际效果，增强对评论/投诉内容的理解。
-			/**
+	private String fangjianPhoto;
-			* 房间特色
+
-			*/
+	// 房间特色
-			private String fangjianTese;
+	// 用于描述房间具有的独特特点，比如“海景房”的海景特色、“主题房”的主题特色等，在展示评论/投诉时展示房间特色有助于用户更好地理解反馈背景
-			/**
+	// 比如用户投诉房间的海景视野不好，知道这是海景房这个特色后，就能更清楚问题所在以及影响的程度等情况。
-			* 房间配置
+	private String fangjianTese;
-			*/
+
-			private String fangjianPeizhi;
+	// 房间配置
-			/**
+	// 用于列举房间内配备的各种设施设备等信息，像“有电视、空调、独立卫生间”等，使前端能展示房间的硬件配置情况，辅助用户了解评论/投诉所涉及的房间设施相关内容
-			* 提供的商品
+	// 如果评论提到房间内某个设施出现故障等问题，通过展示房间配置信息，用户能明确知道是哪种设施出了状况，便于后续的处理和理解。
-			*/
+	private String fangjianPeizhi;
-			private String fangjianShangpin;
+
-			/**
+	// 提供的商品
-			* 提供的服务
+	// 用于说明房间为住客额外提供的商品信息，例如“提供免费的矿泉水、洗漱用品”等，在展示评论/投诉信息时告知用户房间原本提供的商品情况，便于更好地理解反馈内容
-			*/
+	// 例如用户投诉没有提供应有的免费矿泉水，通过展示提供的商品信息就能直观判断是否确实存在该问题。
-			private String fangjianFuwu;
+	private String fangjianShangpin;
-			/**
+
-			* 价格（天）
+	// 提供的服务
-			*/
+	// 用于介绍房间配套提供的服务项目，比如“包含早餐服务”“提供免费的客房清洁服务”等，让前端能展示房间配套的服务内容，帮助用户从服务角度理解评论/投诉相关情况
-			private Double fangjianMoney;
+	// 比如用户投诉客房清洁服务不及时，知道房间有该项服务后，就能更准确地评估问题的合理性以及影响程度等。
-			/**
+	private String fangjianFuwu;
-			* 房间类型
+
-			*/
+	// 价格（天）
-			private Integer fangjianTypes;
+	// 用于存储房间每天的出租价格，方便用户了解住宿该房间的费用情况，在展示评论/投诉时展示价格信息可让用户从性价比等角度综合考虑相关反馈
-				/**
+	// 例如用户评论房间价格过高，通过展示价格信息，其他用户可以结合房间配置、服务等情况来判断这个价格是否确实不合理，从更全面的角度看待评论内容。
-				* 房间类型的值
+	private Double fangjianMoney;
-				*/
+
-				private String fangjianValue;
+	// 房间类型
-			/**
+	// 用于区分不同种类的房间，可能通过数字或其他编码方式对应不同的房型分类，例如1表示单人间，2表示双人间等，便于前端进行房间分类展示以及用户根据房型对评论/投诉进行分类查看和理解
-			* 房间剩余数量
+	// 不同房型的特点和用户期望可能不同，这样分类展示能让用户更方便地筛选和查看与自己关注的房型相关的评论/投诉内容，提高信息查找的效率。
-			*/
+	private Integer fangjianTypes;
-			private Integer fangjianNumber;
+
-			/**
+	// 房间类型的值
-			* 点击次数
+	// 可能用于存储房间类型对应的更具体的描述性值（比如房间类型代码对应的具体文字描述等），方便在前端更友好地展示房间类型相关信息，辅助用户理解评论/投诉涉及的房间类型情况
-			*/
+	// 例如对于一些复杂的房型分类，仅用数字或代码表示不够直观，通过这个具体描述性值（如“豪华海景双人房”等）能让用户更清晰地知晓房型情况，更好地理解相关评论/投诉。
-			private Integer fangjianClicknum;
+	private String fangjianValue;
-			/**
+
-			* 房间详情
+	// 房间剩余数量
-			*/
+	// 用于记录当前房间还可预订的剩余数量，实时反映房间的预订余量情况，在展示评论/投诉时展示剩余数量可让用户了解房间的热门程度等相关背景信息
-			private String fangjianContent;
+	// 如果一个房间剩余数量很少但评论较多，可能说明该房间比较热门，用户可以从这个角度进一步思考评论内容的参考价值等。
-
+	private Integer fangjianNumber;
-		//级联表 yonghu
+
-			/**
+	// 点击次数
-			* 用户姓名
+	// 用于统计房间信息被查看的次数，可用于分析房间的受欢迎程度等，在展示评论/投诉时展示点击次数能让用户知晓房间的关注度情况，辅助理解反馈的重要性等
-			*/
+	// 一般来说，点击次数高的房间关注度高，其评论/投诉可能更受关注，用户可以根据这个关注度情况来判断评论/投诉内容的影响力和参考价值。
-			private String yonghuName;
+	private Integer fangjianClicknum;
-			/**
+
-			* 头像
+	// 房间详情
-			*/
+	// 用于存储更详细的关于房间的描述信息，可能包含房间的布局、面积大小、装修风格等更全面的介绍内容，在前端展示评论/投诉时一并展示详细内容能让用户更深入了解房间情况及反馈背景
-			private String yonghuPhoto;
+	// 例如用户投诉房间空间小，通过查看房间详情里的面积大小等信息，能更准确地判断这个投诉是否合理，帮助用户更全面地理解评论/投诉的具体情况。
-			/**
+	private String fangjianContent;
-			* 手机号
+
-			*/
+	// 以下是级联表 yonghu 相关的属性定义，用于存储发表评论/投诉的用户的各种详细信息，方便在展示房间评论/投诉信息时，同时向前端提供对应的用户具体情况，增强信息的完整性和展示效果
-			private String yonghuPhone;
+
-			/**
+	// 用户姓名
-			* 电子邮箱
+	// 用于存储发表评论/投诉的用户的姓名，方便在前端展示评论/投诉信息时明确反馈者身份，增强信息的可读性和关联性
-			*/
+	// 知道是谁发表的评论/投诉，能让其他用户更直观地判断反馈的可信度以及可能的针对性等情况，使信息展示更人性化。
-			private String yonghuEmail;
+	private String yonghuName;
-			/**
+
-			* 余额
+	// 头像
-			*/
+	// 用于存储用户的头像相关信息（比如头像图片的路径或者标识等），以便在前端展示用户头像，使展示的评论/投诉信息更具个性化和直观性
-			private Double newMoney;
+	// 展示头像可以让用户界面更生动，同时也有助于用户快速识别不同的反馈者，增强信息展示的辨识度。
-			/**
+	private String yonghuPhoto;
-			* 假删
+
-			*/
+	// 手机号
-			private Integer yonghuDelete;
+	// 用于存储用户的手机号码，可能在某些业务场景下（如需要联系用户核实评论/投诉内容等）会用到该信息，同时在前端展示也能增加用户信息的完整性
-
+	// 虽然一般不会直接在前端完全展示手机号，但在特定情况下（如管理员有相应权限查看并联系用户），手机号信息的存在能确保业务流程的连贯性，方便进行相关操作。
+	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
+	// 设置： 房间类型的值
-
+// 定义了设置房间类型的值（fangjianValue）属性值的方法，遵循JavaBean规范里的属性修改器（setter）规则，用于设置房间类型对应的具体描述性值。
-					/**
+// 外部代码在诸如更新房间类型对应的文字描述（比如对房型的命名进行优化、修改，使其更符合实际情况或者更通俗易懂等情况）时，可以调用这个方法，传入新的描述性字符串内容，以此来更新该属性的值，确保前端展示的房间类型具体描述信息是准确且易于用户理解的。
-					* 获取： 房间名称
+	public void setFangjianValue(String fangjianValue) {
-					*/
+		this.fangjianValue = fangjianValue;
-					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规范定义的访问器（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;
+	}
+}

minsu/minsuguanliw/src/main/java/com/entity/view/FangjianOrderView.java

@@ -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;
+	// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化时（如添加、删除字段等），可以通过修改这个版本号来避免反序列化出错，初始值设为1L，在类相对稳定的情况下一般不需要改动
-
+	private static final long serialVersionUID = 1L;
-		/**
+
-		* 订单状态的值
+	/**
-		*/
+	 * 订单状态的值
-		private String fangjianOrderValue;
+	 * 用于存储房间预约订单状态对应的具体描述性值（比如订单状态代码对应的具体文字描述等），方便在前端更友好地展示订单状态相关信息，辅助用户理解房间预约相关情况涉及的订单状态情况。
-
+	 */
-
+	private String fangjianOrderValue;
-
+
-		//级联表 fangjian
+	// 级联表 fangjian相关属性定义，用于存储房间的各种详细信息，方便在展示房间预约信息时，同时向前端提供对应的房间具体情况，增强信息的完整性和展示效果
-			/**
+
-			* 房间名称
+	/**
-			*/
+	 * 房间名称
-			private String fangjianName;
+	 * 用于存储房间的具体名称，方便用户更直观地识别和区分不同的房间，例如“标准间”“豪华套房”等，在前端展示房间预约信息时可一并展示房间名称，让用户清楚是针对哪个房间的预约。
-			/**
+	 */
-			* 房间图片
+	private String fangjianName;
-			*/
+
-			private String fangjianPhoto;
+	/**
-			/**
+	 * 房间图片
-			* 房间特色
+	 * 用于存储房间相关图片的路径或者图片的标识信息（具体取决于业务中图片存储和引用的方式），以便在前端展示房间外观、内部布置等图片信息，结合房间预约信息能让用户更全面了解房间情况。
-			*/
+	 */
-			private String fangjianTese;
+	private String fangjianPhoto;
-			/**
+
-			* 房间配置
+	/**
-			*/
+	 * 房间特色
-			private String fangjianPeizhi;
+	 * 用于描述房间具有的独特特点，比如“海景房”的海景特色、“主题房”的主题特色等，在展示房间预约信息时展示房间特色有助于用户更好地理解预约背景。
-			/**
+	 */
-			* 提供的商品
+	private String fangjianTese;
-			*/
+
-			private String fangjianShangpin;
+	/**
-			/**
+	 * 房间配置
-			* 提供的服务
+	 * 用于列举房间内配备的各种设施设备等信息，像“有电视、空调、独立卫生间”等，使前端能展示房间的硬件配置情况，辅助用户了解房间预约所涉及的房间设施相关内容。
-			*/
+	 */
-			private String fangjianFuwu;
+	private String fangjianPeizhi;
-			/**
+
-			* 价格（天）
+	/**
-			*/
+	 * 提供的商品
-			private Double fangjianMoney;
+	 * 用于说明房间为住客额外提供的商品信息，例如“提供免费的矿泉水、洗漱用品”等，在展示房间预约信息时告知用户房间原本提供的商品情况，便于更好地理解预约相关内容。
-			/**
+	 */
-			* 房间类型
+	private String fangjianShangpin;
-			*/
+
-			private Integer fangjianTypes;
+	/**
-				/**
+	 * 提供的服务
-				* 房间类型的值
+	 * 用于介绍房间配套提供的服务项目，比如“包含早餐服务”“提供免费的客房清洁服务”等，让前端能展示房间配套的服务内容，帮助用户从服务角度理解房间预约相关情况。
-				*/
+	 */
-				private String fangjianValue;
+	private String fangjianFuwu;
-			/**
+
-			* 房间剩余数量
+	/**
-			*/
+	 * 价格（天）
-			private Integer fangjianNumber;
+	 * 用于存储房间每天的出租价格，方便用户了解住宿该房间的费用情况，在展示房间预约信息时展示价格信息可让用户从性价比等角度综合考虑相关预约情况。
-			/**
+	 */
-			* 点击次数
+	private Double fangjianMoney;
-			*/
+
-			private Integer fangjianClicknum;
+	/**
-			/**
+	 * 房间类型
-			* 房间详情
+	 * 用于区分不同种类的房间，可能通过数字或其他编码方式对应不同的房型分类，例如1表示单人间，2表示双人间等，便于前端进行房间分类展示以及用户根据房型对预约进行分类查看和理解。
-			*/
+	 */
-			private String fangjianContent;
+	private Integer fangjianTypes;
-
+
-		//级联表 yonghu
+	/**
-			/**
+	 * 房间类型的值
-			* 用户姓名
+	 * 可能用于存储房间类型对应的更具体的描述性值（比如房间类型代码对应的具体文字描述等），方便在前端更友好地展示房间类型相关信息，辅助用户理解房间预约涉及的房间类型情况。
-			*/
+	 */
-			private String yonghuName;
+	private String fangjianValue;
-			/**
+
-			* 头像
+	/**
-			*/
+	 * 房间剩余数量
-			private String yonghuPhoto;
+	 * 用于记录当前房间还可预订的剩余数量，实时反映房间的预订余量情况，在展示房间预约信息时展示剩余数量可让用户了解房间的热门程度等相关背景信息。
-			/**
+	 */
-			* 手机号
+	private Integer fangjianNumber;
-			*/
+
-			private String yonghuPhone;
+	/**
-			/**
+	 * 点击次数
-			* 电子邮箱
+	 * 用于统计房间信息被查看的次数，可用于分析房间的受欢迎程度等，在展示房间预约信息时展示点击次数能让用户知晓房间的关注度情况，辅助理解预约的重要性等。
-			*/
+	 */
-			private String yonghuEmail;
+	private Integer fangjianClicknum;
-			/**
+
-			* 余额
+	/**
-			*/
+	 * 房间详情
-			private Double newMoney;
+	 * 用于存储更详细的关于房间的描述信息，可能包含房间的布局、面积大小、装修风格等更全面的介绍内容，在前端展示房间预约信息时一并展示详细内容能让用户更深入了解房间情况及预约背景。
-			/**
+	 */
-			* 假删
+	private String fangjianContent;
-			*/
+
-			private Integer yonghuDelete;
+	// 级联表 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;
+	}
 
-			/**
+	/**
-			* 获取： 订单状态的值
+	 * 设置： 房间图片
-			*/
+	 * 这是遵循JavaBean规范定义的用于设置房间图片（fangjianPhoto）属性值的方法，属于属性修改器（setter）方法。
-			public String getFangjianOrderValue() {
+	 * 外部代码在出现诸如房间图片更新（比如更换了新的宣传图片，或者图片存储路径发生变化等情况），需要更新房间图片相关信息时，可以调用这个方法，传入新的图片相关信息（如更新后的图片路径等），来更新该属性的值，保证前端展示的房间图片信息与实际情况相符。
-				return fangjianOrderValue;
+	 */
-			}
+	public void setFangjianPhoto(String fangjianPhoto) {
-			/**
+		this.fangjianPhoto = fangjianPhoto;
-			* 设置： 订单状态的值
+	}
-			*/
-			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规范定义的访问器（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类的定义，表示该类的代码块范围到此结束
+}

minsu/minsuguanliw/src/main/java/com/entity/view/FangjianView.java

@@ -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;
+	// 定义一个序列化版本号，用于在序列化和反序列化过程中保证版本的兼容性，当类的结构发生变化（如添加、删除字段等）时，可以通过修改这个版本号来避免反序列化出错，初始值设为1L，在类相对稳定的情况下一般不需要改动
-
+	private static final long serialVersionUID = 1L;
-		/**
-		* 房间类型的值
-		*/
-		private String fangjianValue;
-
 
+	/**
+	 * 房间类型的值
+	 * 用于存储房间类型对应的更具体的描述性值（比如房间类型代码对应的具体文字描述等内容），方便在前端更友好、直观地展示房间类型相关信息，辅助用户更好地理解房间的具体类型情况。
+	 */
+	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;
+	}
 
-
+	/**
-			/**
+	 * 设置： 房间类型的值
-			* 获取： 房间类型的值
+	 * 定义了设置房间类型的值（fangjianValue）属性值的方法，遵循JavaBean规范中的属性修改器（setter）方法定义。
-			*/
+	 * 外部代码在需要更新房间类型的具体描述信息时（比如对房型的命名进行优化、修改，使其更符合实际情况或者更通俗易懂等情况），可以调用这个方法，传入相应的字符串内容作为新的房间类型描述，以此来改变该属性的值，确保在前端展示的房间类型信息是准确且符合实际情况的。
-			public String getFangjianValue() {
+	 */
-				return fangjianValue;
+	public void setFangjianValue(String fangjianValue) {
-			}
+		this.fangjianValue = fangjianValue;
-			/**
+	}
-			* 设置： 房间类型的值
+}
-			*/
-			public void setFangjianValue(String fangjianValue) {
-				this.fangjianValue = fangjianValue;
-			}
-
-
-
-
-
-
-
-
-
-
-}

minsu/minsuguanliw/src/main/java/com/entity/view/ForumView.java

@@ -12,67 +12,102 @@ import java.util.Date;
 /**
  * 论坛
  * 后端返回视图实体辅助类
- * （通常后端关联的表或者自定义的字段需要返回使用）
+ * （通常后端关联的表或者自定义的字段需要返回使用，用于构建适合前端展示或其他业务场景需求的视图数据结构）
  */
 @TableName("forum")
 public class ForumView extends ForumEntity implements Serializable {
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
-
+
-		/**
+	// **
-		* 帖子状态的值
+	//  * 帖子状态的值，
-		*/
+	//  用于存储帖子状态对应的具体描述性字符串
-		private String forumStateValue;
+	//  （可能比单纯用数字表示状态更直观，便于前端直接展示给用户理解帖子当前状态含义）
-
+	//  */
-
+	private String forumStateValue;
-
+
-		//级联表 yonghu
+	// 以下是与级联表 yonghu 相关的属性，
-			/**
+	// 用于扩展论坛帖子关联的用户相关信息，
-			* 用户姓名
+	// 方便在展示帖子时一并提供用户的详细资料
-			*/
+
-			private String yonghuName;
+	// **
-			/**
+	//  * 用户姓名，存储发布该帖子的用户的真实姓名信息，
-			* 头像
+	//  便于在前端展示帖子时显示发布者的姓名，增强信息展示的完整性
-			*/
+	//  */
-			private String yonghuPhoto;
+	private String yonghuName;
-			/**
+
-			* 手机号
+	// **
-			*/
+	//  * 头像，用于存储用户的头像图片相关信息
-			private String yonghuPhone;
+	//  （可能是图片路径、URL或者其他标识，取决于项目中头像存储和引用方式），
-			/**
+	//  以便在前端展示用户头像，提升用户界面的可视化效果
-			* 电子邮箱
+	//  */
-			*/
+	private String yonghuPhoto;
-			private String yonghuEmail;
+
-			/**
+	// **
-			* 余额
+	//  * 手机号，存储用户的手机号码信息，
-			*/
+	//  在某些业务场景下（比如需要联系用户、验证用户身份等）
-			private Double newMoney;
+	//  可能会用到该信息进行相关操作或展示给有权限查看的角色
-			/**
+	//  */
-			* 假删
+	private String yonghuPhone;
-			*/
+
-			private Integer yonghuDelete;
+	// **
-
+	//  * 电子邮箱，保存用户的电子邮箱地址，
-		//级联表 users
+	//  可用于发送通知、进行账号相关操作验证等业务场景，
-			/**
+	//  也可能展示给用户用于沟通联系等用途
-			* 用户名
+	//  */
-			*/
+	private String yonghuEmail;
-			private String uusername;
+
-			/**
+	// **
-			* 密码
+	//  * 余额，可能用于记录用户在系统中的账户余额信息（
-			*/
+	//  例如在涉及支付、消费等功能的论坛系统中，用户可能有相应的资金账户情况），
-			private String upassword;
+	//  方便在相关业务逻辑中查询和处理余额相关操作
-			/**
+	//  */
-			* 角色
+	private Double newMoney;
-			*/
+
-			private String urole;
+	// **
-			/**
+	//  * 假删，可能用于标记用户账号是否处于一种类似“软删除”的状态（
-			* 新增时间
+	//  即表面上好像删除了，但实际数据还保留，只是在某些业务场景下不显示等情况），方便进行数据管理和状态控制
-			*/
+	//  */
-			private Date uaddtime;
+	private Integer yonghuDelete;
-
+
+	// 以下是与级联表 users 相关的属性，
+	// 用于扩展与论坛帖子可能关联的管理员或其他相关角色的详细信息
+
+	// **
+	//  * 用户名，存储对应管理员或相关角色的用户名，
+	//  便于在前端展示或者业务逻辑中识别和区分不同的操作主体（比如知道是哪个管理员进行了帖子管理操作等）
+	//  */
+	private String uusername;
+
+	// **
+	//  * 密码，虽然在实际返回给前端的视图数据中通常不会直接展示密码（出于安全考虑），
+	//  但在后端业务逻辑处理中，可能涉及到验证、加密等与密码相关的操作，这里存储对应角色的密码信息
+	//  */
+	private String upassword;
+
+	// **
+	//  * 角色，用于明确该用户在系统中所扮演的角色
+	//  （例如管理员、普通用户、版主等不同角色具有不同的权限和操作范围），方便进行权限控制和业务流程处理
+	//  */
+	private String urole;
+
+	// **
+	//  * 新增时间，记录该用户账号
+	//  （对应管理员或相关角色）在系统中创建的具体时间，
+	//  可用于查询、统计等业务场景，例如查看新注册的管理员情况等
+	//  */
+	private Date uaddtime;
+
+	// 默认构造函数，用于创建 ForumView
+	// 对象实例时进行一些默认的初始化操作
+	// （目前为空实现，可根据后续需求添加初始化逻辑）
 	public ForumView() {
 
 	}
 
+	// 构造函数，用于根据已有的 ForumEntity 对象来初始化 ForumView 对象，
+	// 通过 BeanUtils 工具类将 ForumEntity 中的属性值复制到当前对象中
+	// 这样可以方便地基于已有的实体对象数据来构建视图对象，
+	// 减少重复设置属性的操作，提高代码复用性
 	public ForumView(ForumEntity forumEntity) {
 		try {
 			BeanUtils.copyProperties(this, forumEntity);
@@ -82,176 +117,241 @@ public class ForumView extends ForumEntity implements Serializable {
 		}
 	}
 
+	// **
+	//  * 获取： 帖子状态的值，
+	//  对外提供获取帖子状态对应描述性字符串的方法，
+	//  以便在前端展示帖子状态信息或者在业务逻辑中根据该字符串进行相应处理
+	//  * @return 返回帖子状态对应的字符串值
+	//  */
+	public String getForumStateValue() {
+		return forumStateValue;
+	}
 
+	// **
+	//  * 设置： 帖子状态的值，
+	//  用于更新帖子状态对应的描述性字符串，
+	//  例如当帖子状态发生变化后，通过此方法设置新的状态描述信息，方便后续展示和处理
+	//  * @param forumStateValue 要设置的帖子状态描述性字符串值
+	//  */
+	public void setForumStateValue(String forumStateValue) {
+		this.forumStateValue = forumStateValue;
+	}
 
-			/**
+	// 以下是级联表 yonghu 的一系列获取（get）和设置（set）方法，
-			* 获取： 帖子状态的值
+	// 用于对用户相关属性进行访问和修改操作
-			*/
+
-			public String getForumStateValue() {
+	// **
-				return forumStateValue;
+	//  * 获取： 用户姓名，对外提供获取用户姓名的方法，
-			}
+	//  便于在前端展示帖子时获取并显示发布者的姓名信息，
-			/**
+	//  或者在业务逻辑中根据姓名进行查询、统计等操作
-			* 设置： 帖子状态的值
+	//  * @return 返回用户姓名对应的字符串值
-			*/
+	//  */
-			public void setForumStateValue(String forumStateValue) {
+	public String getYonghuName() {
-				this.forumStateValue = forumStateValue;
+		return yonghuName;
-			}
+	}
-
 
+	// **
+	//  * 设置： 用户姓名，用于更新用户的姓名信息，
+	//  例如用户修改了自己的真实姓名后，
+	//  通过此方法保存新的姓名数据，以便后续正确展示
+	//  * @param yonghuName 要设置的用户姓名字符串值
+	//  */
+	public void setYonghuName(String yonghuName) {
+		this.yonghuName = yonghuName;
+	}
 
+	// **
+	//  * 获取： 头像，对外提供获取用户头像相关信息的方法，
+	//  在前端展示用户头像时调用此方法获取对应数据（根据存储方式进行相应的图片展示处理），
+	//  也可在业务逻辑中对头像信息进行修改、更新等操作时使用
+	//  * @return 返回用户头像对应的字符串值（如图片路径、URL等）
+	//  */
+	public String getYonghuPhoto() {
+		return yonghuPhoto;
+	}
 
+	// **
+	//  * 设置： 头像，用于更新用户的头像信息，
+	//  比如用户更换了头像图片后，通过此方法保存新的头像相关数据，
+	//  确保前端展示的头像为最新的图片
+	//  * @param yonghuPhoto 要设置的用户头像字符串值（如新的图片路径、URL等）
+	//  */
+	public void setYonghuPhoto(String yonghuPhoto) {
+		this.yonghuPhoto = yonghuPhoto;
+	}
 
+	// **
+	//  * 获取： 手机号，对外提供获取用户手机号码的方法，
+	//  在需要联系用户、验证身份等业务场景下可调用此方法获取手机号信息，
+	//  也可用于在前端展示用户信息时包含手机号（需考虑隐私保护相关设置）
+	//  * @return 返回用户手机号对应的字符串值
+	//  */
+	public String getYonghuPhone() {
+		return yonghuPhone;
+	}
 
+	// **
+	//  * 设置： 手机号，用于更新用户的手机号码信息，
+	//  例如用户更换了手机号后，通过此方法保存新的手机号数据，
+	//  以便后续业务逻辑能正确使用最新的号码
+	//  * @param yonghuPhone 要设置的用户手机号字符串值
+	//  */
+	public void setYonghuPhone(String yonghuPhone) {
+		this.yonghuPhone = yonghuPhone;
+	}
 
+	// **
+	//  * 获取： 电子邮箱，对外提供获取用户电子邮箱地址的方法，
+	//  在发送通知、账号验证等业务场景下可调用此方法获取邮箱信息，
+	//  也可在前端展示用户信息时包含邮箱（同样需考虑隐私保护）
+	//  * @return 返回用户电子邮箱对应的字符串值
+	//  */
+	public String getYonghuEmail() {
+		return yonghuEmail;
+	}
 
+	// **
+	//  * 设置： 电子邮箱，用于更新用户的电子邮箱地址，
+	//  例如用户修改了邮箱后，通过此方法保存新的邮箱数据，
+	//  保证后续相关业务操作使用正确的邮箱信息
+	//  * @param yonghuEmail 要设置的用户电子邮箱字符串值
+	//  */
+	public void setYonghuEmail(String yonghuEmail) {
+		this.yonghuEmail = yonghuEmail;
+	}
 
+	// **
+	//  * 获取： 余额，对外提供获取用户账户余额的方法，
+	//  在涉及支付、消费、查询余额等业务逻辑中可调用此方法获取余额数值，
+	//  方便进行相应的资金相关处理
+	//  * @return 返回用户账户余额对应的 Double 类型数值
+	//  */
+	public Double getNewMoney() {
+		return newMoney;
+	}
 
+	// **
+	//  * 设置： 余额，用于更新用户的账户余额信息，
+	//  比如用户进行充值、消费等操作后，通过此方法保存新的余额数据，
+	//  确保系统中记录的余额是最新准确的
+	//  * @param newMoney 要设置的用户账户余额 Double 类型数值
+	//  */
+	public void setNewMoney(Double newMoney) {
+		this.newMoney = newMoney;
+	}
 
+	// **
 
 
 
+	//  * 获取： 假删，对外提供获取用户“假删”状态标记的方法，
+	//  在数据管理、查询已“删除”用户等业务场景下可调用此方法获取该状态值，
+	//  以便进行相应的业务处理
+	//  * @return 返回用户“假删”状态对应的整数值（通常是表示是否处于假删状态的标志位）
+	//  */
+	public Integer getYonghuDelete() {
+		return yonghuDelete;
+	}
 
+	// **
+	//  * 设置： 假删，
+	//  用于更新用户的“假删”状态标记，
+	//
+	//
+	//
+	//  例如管理员进行账号删除操作（软删除情况）时，
+	//
+	//
+	//  通过此方法设置相应的状态值，改变用户在系统中的显示和可操作状态
+	//  * @param yonghuDelete 要设置的用户“假删”状态整数值
+	//  */
+	public void setYonghuDelete(Integer yonghuDelete) {
+		this.yonghuDelete = yonghuDelete;
+	}
 
+	// 以下是级联表 users 的一系列获取（get）和设置（set）方法，
+	// 用于对管理员或相关角色的属性进行访问和修改操作
 
+	// **
+	//  * 获取： 用户名，对外提供获取管理员或相关角色用户名的方法，
+	//  便于在前端展示帖子管理操作主体信息或者在业务逻辑中根据用户名进行权限判断、操作记录查询等操作
+	//  * @return 返回用户名对应的字符串值
+	//  */
+	public String getUusername() {
+		return uusername;
+	}
 
+	// **
+	//  * 设置： 用户名，用于更新管理员或相关角色的用户名信息，
+	//  例如管理员修改了自己的用户名后，
+	//  通过此方法保存新的用户名数据，以便后续正确展示和处理相关业务
+	//  * @param uusername 要设置的用户名字符串值
+	//  */
+	public void setUusername(String uusername) {
+		this.uusername = uusername;
+	}
 
+	// **
+	//  * 获取： 密码，对外提供获取管理员或相关角色密码的方法，
+	//  虽然在前端视图展示中通常不会直接显示密码，
+	//  但在后端业务逻辑中涉及密码验证、加密存储等操作时会用到此方法获取密码信息（需确保密码存储和传输的安全性）
+	//  * @return 返回密码对应的字符串值
+	//  */
+	public String getUpassword() {
+		return upassword;
+	}
 
+	// **
+	//  * 设置： 密码，用于更新管理员或相关角色的密码信息，
+	//  比如管理员修改密码后，通过此方法保存新的密码数据，
+	//  保证系统中存储的密码是最新且符合安全要求的
+	//  * @param upassword 要设置的密码字符串值
+	//  */
+	public void setUpassword(String upassword) {
+		this.upassword = upassword;
+	}
 
+	// **
+	//  * 获取： 角色，对外提供获取管理员或相关角色在系统中所扮演角色的方法，
+	//  便于在业务逻辑中根据角色进行权限控制、
+	//  操作范围限定等处理，例如判断是否具有特定帖子管理权限等
+	//  * @return 返回角色对应的字符串值（如管理员、普通用户、版主等不同角色名称或标识）
+	//  */
+	public String getUrole() {
+		return urole;
+	}
 
-				//级联表的get和set yonghu
+	// **
+	//  * 设置： 角色，用于更新管理员或相关角色的角色信息，
+	//  例如系统进行角色调整后，通过此方法保存新的角色数据，
+	//  以便后续根据新角色进行相应的权限和业务流程处理
+	//  * @param urole 要设置的角色字符串值（如修改后的角色名称或标识）
+	//  */
+	public void setUrole(String urole) {
+		this.urole = urole;
+	}
 
-					/**
+	// **
-					* 获取： 用户姓名
+	//  * 获取： 新增时间，
-					*/
+	//  对外提供获取管理员或相关角色账号创建时间的方法，
-					public String getYonghuName() {
+	//  在查询新注册管理员、
-						return yonghuName;
+	//  统计账号创建趋势等业务场景下可调用此方法获取时间信息，
-					}
+	//  方便进行相应的数据分析和管理操作
-					/**
+	//  * @return 返回新增时间对应的 Date 类型对象
-					* 设置： 用户姓名
+	//  */
-					*/
+	public Date getUaddtime() {
-					public void setYonghuName(String yonghuName) {
+		return uaddtime;
-						this.yonghuName = yonghuName;
+	}
-					}
 
-					/**
+	// **
-					* 获取： 头像
+	//  * 设置： 新增时间，
-					*/
+	//  用于更新管理员或相关角色的账号创建时间信息
-					public String getYonghuPhoto() {
+	//  （虽然在实际业务中一般较少出现修改创建时间的情况，
-						return yonghuPhoto;
+	//  但保留此方法以满足可能的特殊需求），
-					}
+	//  例如数据迁移、时间校准等场景下可能会用到
-					/**
+	//  * @param uaddtime 要设置的新增时间对应的 Date 类型对象
-					* 设置： 头像
+	//  */
-					*/
+	public void setUaddtime(Date uaddtime) {
-					public void setYonghuPhoto(String yonghuPhoto) {
+		this.uaddtime = uaddtime;
-						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;
-					}
-
-
-
-
-			//级联表的get和set users
-
-					/**
-					* 获取： 用户名
-					*/
-					public String getUusername() {
-						return uusername;
-					}
-					/**
-					* 设置： 用户名
-					*/
-					public void setUusername(String uusername) {
-						this.uusername = uusername;
-					}
-
-					/**
-					* 获取： 密码
-					*/
-					public String getUpassword() {
-						return upassword;
-					}
-					/**
-					* 设置： 密码
-					*/
-					public void setUpassword(String upassword) {
-						this.upassword = upassword;
-					}
-
-					/**
-					* 获取： 角色
-					*/
-					public String getUrole() {
-						return urole;
-					}
-					/**
-					* 设置： 角色
-					*/
-					public void setUrole(String urole) {
-						this.urole = urole;
-					}
-
-					/**
-					* 获取： 新增时间
-					*/
-					public Date getUaddtime() {
-						return uaddtime;
-					}
-					/**
-					* 设置： 新增时间
-					*/
-					public void setUaddtime(Date uaddtime) {
-						this.uaddtime = uaddtime;
-					}
-}

minsu/minsuguanliw/src/main/java/com/entity/view/NewsView.java

@@ -12,23 +12,38 @@ import java.util.Date;
 /**
  * 公告信息
  * 后端返回视图实体辅助类
- * （通常后端关联的表或者自定义的字段需要返回使用）
+ //* （通常后端关联的表或者自定义的字段需要返回使用，
+ 其目的在于构建适合前端展示或者满足其他业务场景特定需求的数据结构，
+
+
+ 方便传递更丰富、直观的数据给前端等调用方）
  */
 @TableName("news")
 public class NewsView extends NewsEntity implements Serializable {
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
-
+
-		/**
+	// **
-		* 公告类型的值
+	//  * 公告类型的值，
-		*/
+	//  用于存储公告类型对应的具体描述性字符串。
-		private String newsValue;
+	//
-
+	//
-
+	//  相较于单纯使用数字等方式表示公告类型，这个字符串形式能更直观地体现公告类型含义，
-
+	//
+	//  方便前端直接展示给用户理解公告所属的具体分类情况
+	//  */
+	private String newsValue;
+
+	// 默认构造函数，用于创建 NewsView 对象实例时进行一
+	// 些默认的初始化操作（当前为空实现，后续若有需要可以添加相应的初始化逻辑，
+	// 比如设置一些默认属性值等）
 	public NewsView() {
 
 	}
 
+	// 构造函数，用于根据已有的 NewsEntity 对象来初始化 NewsView 对象。通
+	// 过 BeanUtils 工具类将 NewsEntity 中的属性值复制到当前对象中，
+	// 这样可以便捷地基于已有的实体对象数据构建视图对象，避免重复逐个设置属性，
+	// 提高代码复用性，减少代码冗余，方便在不同业务场景下进行对象数据的转换和传递
 	public NewsView(NewsEntity newsEntity) {
 		try {
 			BeanUtils.copyProperties(this, newsEntity);
@@ -38,28 +53,28 @@ public class NewsView extends NewsEntity implements Serializable {
 		}
 	}
 
+	// **
+	//  * 获取： 公告类型的值，
+	//  对外提供获取公告类型对应描述性字符串的方法，
+	//  以便在前端展示公告信息时能直观呈现公告类型内容，
+	//  或者在业务逻辑中根据该字符串进行相应的分类处理、筛选等操作
+	//  * @return 返回公告类型对应的字符串值
+	//  */
+	public String getNewsValue() {
+		return newsValue;
+	}
 
-
+	// **
-			/**
+	//  * 设置： 公告类型的值，
-			* 获取： 公告类型的值
+	//  用于更新公告类型对应的描述性字符串，
-			*/
+	//  例如当公告分类发生变化或者需要更准确、
-			public String getNewsValue() {
+	//
-				return newsValue;
+	//
-			}
+	//  更符合业务展示需求的类型描述时，通过此方法设置新的类型描述信息，
-			/**
+	//  便于后续展示和处理相关业务逻辑
-			* 设置： 公告类型的值
+	//  * @param newsValue 要设置的公告类型描述性字符串值
-			*/
+	//  */
-			public void setNewsValue(String newsValue) {
+	public void setNewsValue(String newsValue) {
-				this.newsValue = newsValue;
+		this.newsValue = newsValue;
-			}
+	}
-
+}
-
-
-
-
-
-
-
-
-
-}

minsu/minsuguanliw/src/main/java/com/entity/view/YonghuView.java

@@ -12,54 +12,65 @@ import java.util.Date;
 /**
  * 用户
  * 后端返回视图实体辅助类
- * （通常后端关联的表或者自定义的字段需要返回使用）
+ * 此实体类作为后端返回给前端视图相关的辅助类存在，用于承载一些特定的数据，特别是那些后端关联的表中的数据或者自定义的额外字段，这些数据往往是需要展示给前端使用的，
+ * 它在业务中扮演着对后端数据进行整合、包装后再传递给前端的角色，方便前端获取并展示符合业务要求的完整用户相关信息。
  */
 @TableName("yonghu")
+// 通过 @TableName 注解指定了该实体类对应的数据库表名为 "yonghu"，通常在与数据库交互的框架（如 MyBatis-Plus 等）中，
+// 用于建立实体类与数据库表之间的映射关系，框架可以根据这个注解来确定操作的具体表。
 public class YonghuView extends YonghuEntity implements Serializable {
-    private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L;
-
+
-		/**
+	/**
-		* 性别的值
+	 * 性别的值
-		*/
+	 * 用于存储性别的具体值（可能是具体的文字描述，比如 "男"、"女" 等，区别于 YonghuEntity 中可能只是用代码表示性别的字段），
-		private String sexValue;
+	 * 方便直接展示给前端更直观的性别信息，而不是原始的代码形式，增强了数据展示的友好性和可读性。
-
+	 */
-
+	private String sexValue;
-
+
+	/**
+	 * 默认构造函数
+	 * 用于创建一个空的 YonghuView 对象实例，在一些场景下（如通过反射等方式创建对象）可能会用到，初始化时对象的各个属性为默认值（如基本数据类型的默认初始值等）。
+	 */
 	public YonghuView() {
 
 	}
 
+	/**
+	 * 构造函数（基于 YonghuEntity 进行初始化）
+	 * 该构造函数接受一个 YonghuEntity 对象作为参数，目的是将 YonghuEntity 中的属性值复制到当前的 YonghuView 对象中，
+	 * 通过使用 BeanUtils.copyProperties 方法（可能来自 Spring 等相关框架提供的工具类）实现属性的拷贝，
+	 * 这样可以方便地基于已有的 YonghuEntity 对象来创建 YonghuView 对象，减少了手动逐个设置属性的繁琐操作，
+	 * 并且保证了大部分基础属性的一致性，同时在此基础上可以额外处理 YonghuView 中特有的属性（如 sexValue 字段）。
+	 * @param yonghuEntity 用于提供基础数据的 YonghuEntity 对象，其属性值将被复制到当前创建的 YonghuView 对象中。
+	 */
 	public YonghuView(YonghuEntity yonghuEntity) {
 		try {
 			BeanUtils.copyProperties(this, yonghuEntity);
 		} catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
+			// 如果在属性复制过程中出现异常（比如属性没有对应的访问权限或者复制方法调用出现问题等），
+			// 则会打印异常堆栈信息，方便开发人员排查问题所在，当前只是简单地将异常打印出来，实际应用中可根据需求进行更完善的异常处理逻辑。
 			e.printStackTrace();
 		}
 	}
 
+	/**
+	 * 获取： 性别的值
+	 * 这是一个用于获取 sexValue 属性值的公共访问方法（getter 方法），按照 Java 的 JavaBean 规范定义，
+	 * 方便其他类在需要获取该 YonghuView 对象的性别值时调用，返回存储的性别值字符串内容（如 "男"、"女" 等）。
+	 * @return 返回存储的性别的值字符串，即代表具体性别的文字描述信息。
+	 */
+	public String getSexValue() {
+		return sexValue;
+	}
 
-
+	/**
-			/**
+	 * 设置： 性别的值
-			* 获取： 性别的值
+	 * 这是一个用于设置 sexValue 属性值的公共设置方法（setter 方法），按照 Java 的 JavaBean 规范定义，
-			*/
+	 * 用于在需要更新 YonghuView 对象的性别值时调用，比如根据后端业务逻辑处理后得到的具体性别文字描述来更新该字段内容。
-			public String getSexValue() {
+	 * @param sexValue 要设置的性别的值字符串，用于更新 YonghuView 对象的 sexValue 字段内容。
-				return sexValue;
+	 */
-			}
+	public void setSexValue(String sexValue) {
-			/**
+		this.sexValue = sexValue;
-			* 设置： 性别的值
+	}
-			*/
+}
-			public void setSexValue(String sexValue) {
-				this.sexValue = sexValue;
-			}
-
-
-
-
-
-
-
-
-
-
-}

minsu/minsuguanliw/src/main/java/com/service/DictionaryService.java

@@ -8,17 +8,67 @@ import javax.servlet.http.HttpServletRequest;
 
 /**
  * 字典表 服务类
+ * 该接口定义了与字典表相关的业务逻辑方法，
+ * 继承自 MyBatis Plus 的 `IService`
+ * 接口（意味着具备 `IService` 提供的通用数据库操作相关的方法，如基本的增删改查等功能），
+ * 在此基础上扩展了针对字典表特有的业务操作方法，
+ * 用于满足项目中对字典表数据处理的具体需求，方便在不同的业务场景下调用对应的方法来实现相应功能，
+ * 并且使得业务逻辑与数据持久化操作进行了有效的分离，
+ * 提高代码的可维护性和可扩展性。
  */
 public interface DictionaryService extends IService<DictionaryEntity> {
 
     /**
-    * @param params 查询参数
+     * 根据传入的查询参数进行字典表数据的分页查询操作，并返回分页后的查询结果。
-    * @return 带分页的查询出来的数据
+     * 此方法是用于满足按照特定条件分页获取字典表数据的业务需求，
-    */
+     * 调用者可以传入包含各种查询条件（
-     PageUtils queryPage(Map<String, Object> params);
+     *
-      /**
+     *
-      * 字典表转换
+     * 如筛选条件、排序条件、页码、每页显示数量等信息）的 `Map` 类型参数，
-      * @param obj
+     * 该方法内部会基于这些参数与数据库进行交互，执行相应的查询语句，
-      */
+     *
-     void dictionaryConvert(Object obj, HttpServletRequest request);
+     * 获取符合条件的字典表数据分页信息，最终将结果封装在 `PageUtils`
+     *
+     * 类型的对象中返回，方便后续进行分页展示或其他相关业务处理。
+     *
+     * @param params 查询参数，是一个 `Map` 类型的数据结构，
+     *
+     *               用于传递各种查询条件信息，不同的键值对可以表示不同的含义，
+     *               例如可以通过特定的键设置筛选字典表数据的关键字、
+     *
+     *               按照某个字段进行排序的规则、指定要获取的页码以及每页显示的记录数量等，以灵活控制查询逻辑，获取期望的分页数据。
+     * @return 返回一个 `PageUtils` 类型的对象，
+     *
+     * 该对象中封装了分页后的字典表数据以及分页相关的元信息（比如总记录数、总页数等），
+     *         方便在前端展示或者其他业务场景下对分页数据进行处理，
+     *
+     *         例如分页展示、数据统计等操作。
+     */
+    PageUtils queryPage(Map<String, Object> params);
+
+    /**
+     * 对字典表相关的数据对象进行转换操作，具体的转换逻辑可能根据业务需求而定，
+     *
+     * 并且会依赖于请求相关的上下文信息（通过 `HttpServletRequest` 获取）。
+     * 这个方法通常用于对从数据库查询出来的字典表数据（可能是原始的实体对象或者其他相关的数据结构）
+     *
+     * 进行一些额外的处理，比如对字典表中的某些字段值进行格式转换、
+     * 根据业务规则进行重新赋值、关联其他相关数据等操作，使其更适合后续的展示或者业务逻辑处理，
+     *
+     * 传入的 `Object` 类型参数表示可以接受各种类型的与字典表相关的数据对象进行转换处理。
+     *
+     * @param obj 要进行转换操作的对象，类型为 `Object`，
+     *
+     *            它可以是字典表对应的实体类对象（如 `DictionaryEntity` 及其子类等）或者其他包含字典表相关数据的对象结构，
+     *            具体的类型取决于调用该方法时传入的实际参数情况，该对象将作为转换操作的基础数据来源，
+     *
+     *            其内部的字典表相关属性会根据业务逻辑进行相应的转换处理。
+     * @param request `HttpServletRequest` 对象，用于获取请求相关的上下文信息，
+     *
+     *                例如可以从中获取用户相关信息、请求头信息等，这些信息可能会辅助字典表数据的转换逻辑，
+     *                比如根据用户的不同权限或者地区设置等对字典表中的某些字段进行不同的转换处理，
+     *
+     *                确保转换后的数据符合具体业务场景下的展示和使用要求。
+     */
+    void dictionaryConvert(Object obj, HttpServletRequest request);
 }

minsu/minsuguanliw/src/main/java/com/service/FangjianLiuyanService.java

@@ -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 查询参数
+     * @param params 查询参数
-    * @return 带分页的查询出来的数据
+     * 该参数用于接收一个Map类型的对象，其中键为查询条件的名称（比如"user_id"表示按用户ID查询时的键，"start_time"和"end_time"表示按时间范围查询时的起始和结束时间键等），
-    */
+     * 值则为对应的具体查询条件值（如具体的用户ID数值、具体的日期对象等），通过这个参数可以灵活地传递各种不同的查询条件，以满足多样化的查询需求。
-     PageUtils queryPage(Map<String, Object> params);
+     *
+     * @return 带分页的查询出来的数据
+     * 返回值类型为PageUtils，这是一个自定义的工具类对象，它封装了分页查询后得到的相关数据，包括当前页的数据列表（通常是包含房间评论/投诉实体对象的列表）、总记录数、总页数等信息，方便前端进行分页展示以及相关业务逻辑处理。
+     */
+    PageUtils queryPage(Map<String, Object> params);
 }

minsu/minsuguanliw/src/main/java/com/service/FangjianOrderService.java

@@ -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 查询参数
+     * @param params 查询参数
-    * @return 带分页的查询出来的数据
+     * 这里的params参数是一个Map类型的变量，用于接收从外部传入的查询条件信息，其内部以键值对的形式组织数据。键代表查询条件的具体名称（例如“room_id”可以表示按房间编号查询时的条件名，“order_status”可作为按订单状态查询的条件名等），
-    */
+     * 值则对应具体的查询条件内容（像房间编号的具体数值、订单状态对应的具体状态值等），这样可以灵活地设置各种不同的查询需求，以适应复杂多样的业务查询场景，比如根据不同用户、不同时间段、不同房间来查询预约信息等。
-     PageUtils queryPage(Map<String, Object> params);
+     *
+     * @return 带分页的查询出来的数据
+     * 该方法的返回值类型是PageUtils，这是一个自定义的工具类，它里面封装了分页查询后所得到的一系列相关数据，包含了当前页所展示的房间预约记录列表（通常是FangjianOrderEntity类型的对象列表，每条记录对应一条预约信息）、总的记录条数（用于计算总页数以及给用户提示数据总量等情况）以及总页数等重要信息，方便前端页面进行分页展示，也利于后续业务逻辑根据这些分页数据做进一步的处理，例如实现翻页功能、根据总记录数进行统计分析等操作。
+     */
+    PageUtils queryPage(Map<String, Object> params);
 }

minsu/minsuguanliw/src/main/java/com/service/FangjianService.java

@@ -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 查询参数
+     * @param params 查询参数
-    * @return 带分页的查询出来的数据
+     * 这里的params参数是一个Map类型的变量，其作用是接收从外部传入的各种查询条件信息，这些信息以键值对的形式进行组织。其中，键表示具体的查询条件名称，例如“room_name”可以用来表示按照房间名称进行查询的条件，“create_time_start”和“create_time_end”可以分别表示按照创建时间范围来查询房间的起始时间和结束时间等；
-    */
+     * 值则对应着具体的查询条件内容，比如对于“room_name”这个键，值可能就是具体的房间名称字符串；对于时间范围相关的键，值就是对应的具体日期对象等。通过这样的方式，可以灵活地传递各种不同的查询要求，满足多样化的业务查询需求，比如查找特定名称、特定时间段内创建的房间等。
-     PageUtils queryPage(Map<String, Object> params);
+     *
+     * @return 带分页的查询出来的数据
+     * 该方法返回值类型为PageUtils，这是一个自定义的工具类，它里面封装了分页查询后所得到的一系列相关数据，主要包括当前页所展示的房间信息记录列表（通常是FangjianEntity类型的对象列表，每个对象代表一条房间信息记录）、总的记录条数（可以用于计算总页数、提示用户数据总量等情况）以及总页数等关键信息，
+     * 方便前端页面进行分页展示，也便于后续业务逻辑根据这些分页数据做进一步的处理，例如实现分页导航、根据总记录数进行统计分析等操作，从而更好地展示和处理房间信息数据。
+     */
+    PageUtils queryPage(Map<String, Object> params);
 }

minsu/minsuguanliw/src/main/java/com/service/ForumService.java

@@ -8,12 +8,34 @@ import javax.servlet.http.HttpServletRequest;
 
 /**
  * 论坛 服务类
+ * 该接口定义了与论坛相关的业务逻辑方法，
+ * 它继承自 MyBatis Plus 的 IService 接口，
+ * 意味着可以复用 IService 中提供的一些
+ * 通用的数据库操作相关方法，同时在此基础上扩展论坛业务特有的功能方法。
+ * 主要用于规范论坛服务层的功能边界，
+ * 使得不同的实现类能够按照统一的接口定义来实现具体的业务逻辑，便于代码的解耦和维护。
  */
 public interface ForumService extends IService<ForumEntity> {
 
     /**
-    * @param params 查询参数
+     * 查询分页数据的方法，
-    * @return 带分页的查询出来的数据
+     * 用于根据传入的查询参数获取论坛相关数据，并按照分页的形式返回结果。
-    */
+     *
-     PageUtils queryPage(Map<String, Object> params);
+     * @param params 查询参数，是一个 Map 类型的数据结构，用于传递各种筛选、排序以及分页相关的条件信息。
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *
+     *               例如，可以包含关键词用于搜索特定主题的论坛帖子，也可以有页码、每页显示数量等分页相关参数，
+     *               还可以设置其他的自定义筛选条件（如按发布时间范围、用户等进行筛选）。
+     * @return 返回一个 PageUtils 类型的对象，该对象封装了分页后的论坛数据以及分页相关的元信息（比如总记录数、总页数等），
+     *         方便在前端页面或者其他调用该接口的地方进行分页展示和进一步的数据处理操作。
+     */
+    PageUtils queryPage(Map<String, Object> params);
 }

minsu/minsuguanliw/src/main/java/com/service/NewsService.java

@@ -8,12 +8,35 @@ import javax.servlet.http.HttpServletRequest;
 
 /**
  * 公告信息 服务类
+ * 此接口继承自 MyBatis Plus 的 IService 接
+ * 口，目的在于借助 IService 提供的通用数据库操作方法基础，
+ * 进一步定义与公告信息相关的特定业务逻辑方法，
+ * 以此规范公告信息服务层的功能范畴，方便后续实现类按照统一标准来实现具体业务，
+ * 同时也利于代码模块间的解耦，
+ * 提高代码的可维护性与扩展性。
  */
 public interface NewsService extends IService<NewsEntity> {
 
     /**
-    * @param params 查询参数
+     * 查询分页数据的方法，
-    * @return 带分页的查询出来的数据
+     * 用于依据传入的查询参数来获取公告信息相关的数据，并将结果以分页的形式进行返回。
-    */
+     *
-     PageUtils queryPage(Map<String, Object> params);
+     * @param params 查询参数，其类型为 Map，这是一个能灵活存储各种键值对的集合类型。
+     *               在这里主要用于承载各类与公告信息查询相关的条件设定，
+     *               例如可以存放用于筛选特定类型公告的条件（如按公告类别区分）、
+     *               限定公告发布时间范围的条件，
+     *               也可以包含分页相关的关键参数，像页码（用于指定要获取第几页的数据）、
+     *               每页显示数量（表明每页呈现多少条公告信息）等内容。
+     * @return 返回一个 PageUtils 类型的对象，
+     * 该对象对查询出来的分页公告信息数据进行了统一封装，
+     *         除了包含具体的公告信息数据外，还整合了分页相关的元数据，
+     *         比如总记录数（表示符合查询条件的公告总条数）、
+     *         总页数
+     *         （根据每页显示数量和总记录数计算得出的总共可分的页数）等信息，
+     *
+     *
+     *         方便前端页面或者其他调用该接口的地方
+     *         能够便捷地进行分页展示以及基于分页数据开展进一步的业务处理操作。
+     */
+    PageUtils queryPage(Map<String, Object> params);
 }

minsu/minsuguanliw/src/main/java/com/service/TokenService.java

@@ -1,4 +1,3 @@
-
 package com.service;
 
 import java.util.List;
@@ -9,20 +8,92 @@ import com.baomidou.mybatisplus.service.IService;
 import com.entity.TokenEntity;
 import com.utils.PageUtils;
 
-
 /**
  * token
+ * 该接口主要用于定义与 token 相关的一系列业务逻辑方法，例如 token 的生成、查询、获取对应实体等操作。
  * @author yangliyuan
  * @date 2019年10月10日 上午9:18:20
  */
 public interface TokenService extends IService<TokenEntity> {
- 	PageUtils queryPage(Map<String, Object> params);
+
-    
+	/**
-   	List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper);
+	 * 查询分页数据的方法，
-   	
+	 * 根据传入的查询参数（通常包含分页相关设置以及筛选条件等信息）获取 token 相关数据，并以分页形式返回结果。
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<TokenEntity> wrapper);
+	 *
-	
+	 * @param params
-   	String generateToken(Integer userid,String username,String tableName, String role);
+	 *
-   	
+	 *
-   	TokenEntity getTokenEntity(String token);
+	 * 查询参数，是一个 Map 类型的数据结构，可用于传递如每页显示数量、页码、特定筛选条件（例如按创建时间范围、关联用户等条件筛选 token）等信息，
-}
+	 *               方便灵活地控制查询逻辑，以获取符合业务需求的分页数据。
+	 * @return 返回一个 PageUtils 类型的对象，该对象封装了分页后的 token 相关数据以及分页相关的元信息，例如总记录数、总页数等，
+	 *         便于在前端展示或者其他需要处理分页数据的地方进行相应操作，如分页展示、数据统计等。
+	 */
+	PageUtils queryPage(Map<String, Object> params);
+
+	/**
+	 * 根据给定的条件包装器（Wrapper）查询并返回符合条件的 TokenEntity 列表。
+	 * 条件包装器（Wrapper）通常用于构建复杂的查询条件，比如可以灵活组合多个字段的筛选条件（大于、小于、等于关系等）、排序条件等，
+	 * 以此精准地从数据库中获取期望的 token 实体列表。
+	 *
+	 * @param wrapper
+	 * 用于构建查询条件的包装器对象，它定义了查询 TokenEntity 列表的具体条件，
+	 *
+	 *                例如可以通过它设置只查询某个用户的有效 token、特定角色对应的 token 等各种复杂的筛选逻辑。
+	 * @return 返回一个包含符合条件的 TokenEntity 对象的列表，列表中的每个 TokenEntity
+	 * 代表了一条符合设定条件的 token 相关记录，
+	 *         方便后续在业务逻辑中对这些查询到的 token 实体进行进一步处理，如验证、更新等操作。
+	 */
+	List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper);
+
+	/**
+	 * 结合查询参数（params）和条件包装器（wrapper）来查询 token 相关数据，并以分页形式返回结果。
+	 * 这样可以同时利用参数中设定的分页相关设置以及包装器中定义的复杂查询条件，更精准地获取符合业务要求的分页数据。
+	 *
+	 * @param params 查询参数，同样是 Map 类型，可包含如分页相关的页码、
+	 *                  每页显示数量等基本信息，也可以设置一些通用的筛选条件，
+	 *               辅助细化查询范围，与 wrapper 中的条件共同作用来确定最终的查询结果。
+	 * @param wrapper 用于构建查询条件的包装器对象，可定义更细致、更复杂的针对 token 的筛选、排序等条件，
+	 *                如根据特定的业务规则筛选出某些特定状态、关联特定用户或角色的 token 等，与 params 配合实现灵活查询。
+	 * @return 返回一个 PageUtils
+	 * 类型的对象，里面封装了依据上述条件组合查询到的分页后的 token 相关数据以及对应的分页元信息，
+	 *         用于在相应业务场景下进行分页展示和后续的数据处理工作。
+	 */
+	PageUtils queryPage(Map<String, Object> params, Wrapper<TokenEntity> wrapper);
+
+	/**
+	 * 生成 token 的方法，根据传入的用户相关信息（用户 ID、用户名、所属表名、角色）来创建一个对应的 token 字符串。
+	 * 在实际应用中，token 常用于用户认证、授权等场景，通过该方法可以基于特定用户的关键信息生成唯一标识该用户的 token，
+	 * 方便后续在系统中进行身份验证和权限控制等操作。
+	 *
+	 * @param userid
+	 * 用户的唯一标识，通常是一个整数类型的 ID，用于明确是哪个用户对应的 token 正在生成，
+	 *               是区分不同用户 token 的重要依据之一。
+	 * @param username
+	 * 用户的名称，字符串类型，与 userid 共同进一步确定用户身份，确保生成的 token 与特定用户准确关联。
+	 * @param tableName
+	 * 所属表名，可能用于标识该用户信息存储所在的数据库表，在一些多表关联或者分表存储的复杂业务场景下，
+	 *                  可以帮助更准确地定位和管理与该用户相关的 token 信息，也有助于区分不同业务模块下的 token 生成逻辑。
+	 * @param role
+	 *
+	 * 用户在系统中所扮演的角色，例如管理员、普通用户等不同角色往往具有不同的权限范围，
+	 *             通过角色信息可以在生成 token 时融入相应的权限特征，便于后续基于 token 进行权限验证等操作。
+	 * @return 返回生成的 token 字符串，该字符串将作为用户后续在系统中进行操作时的身份验证标识，
+	 *         会在如接口调用、页面访问等场景中被传递和验证，以确定用户是否有权限进行相应操作。
+	 */
+	String generateToken(Integer userid, String username, String tableName, String role);
+
+	/**
+	 * 根据给定的 token 字符串获取对应的 TokenEntity 对象。
+	 * 在系统中，TokenEntity 可能包含了更多关于 token 的详细信息（如创建时间、过期时间、关联用户等），
+	 *
+	 * 通过传入一个 token 字符串，能够从数据库或者其他存储介质中查找并返回与之对应的完整 TokenEntity，
+	 * 方便后续进行如 token 有效性验证、更新 token 相关属性等业务操作。
+	 *
+	 * @param token 要
+	 *                 查找对应实体的 token 字符串，它是之前通过 generateToken 方法等生成的用于标识用户身份的标识信息，
+	 *              作为查找的关键依据，在系统中唯一对应一个 TokenEntity 对象（在符合业务逻辑和数据规范的情况下）。
+	 * @return 返回与传入的 token 字符串对应的 TokenEntity 对象，如果找到则返回该对象，可进一步获取其中的详细信息进行后续处理；
+	 *         如果未找到符合条件的对象，则可能返回 null（具体取决于实现类中的逻辑），表示该 token 不存在或者无效等情况。
+	 */
+	TokenEntity getTokenEntity(String token);
+}

minsu/minsuguanliw/src/main/java/com/service/UsersService.java

@@ -15,11 +15,45 @@ import com.utils.PageUtils;
  * @author yangliyuan
  * @date 2019年10月10日 上午9:18:20
  */
+// 定义了一个名为 UsersService 的接口，该接口继承自 IService<UsersEntity>，意味着它会继承 IService 接口中针对 UsersEntity 类型的一系列通用的服务层方法，
+// 比如常见的根据主键查询、插入、更新、删除等基础业务操作方法，在此基础上又自定义了一些特定于用户业务相关的方法，用于满足更复杂的业务需求。
+// 通常会有对应的实现类来具体实现这些方法逻辑，以实现与数据库或其他数据源交互来完成相应的业务功能。
 public interface UsersService extends IService<UsersEntity> {
+
+	/**
+	 * 查询分页数据
+	 * 此方法用于根据传入的参数（以 Map 形式传递各种查询相关的条件、分页信息等）查询用户数据，并返回分页后的结果信息，封装在 PageUtils 类中。
+	 * PageUtils 类可能包含了分页相关的属性，如总记录数、每页记录数、当前页码以及具体的分页数据列表等内容，方便前端进行分页展示以及其他相关业务处理。
+	 * 该方法主要应用在需要按照一定条件分页展示用户列表的业务场景中，比如在用户管理页面，管理员查看众多用户信息时按页进行展示。
+	 *
+	 * @param params 包含查询条件及分页相关参数的 Map 对象，键为参数名称（如 "pageNum" 表示当前页码，"pageSize" 表示每页记录数等，也可以包含自定义的筛选条件等），
+	 *               值为对应的参数值，通过这个参数可以灵活控制查询的具体逻辑以及分页设置。
+	 * @return 返回 PageUtils 对象，其中包含了符合查询条件的分页后的用户数据信息，可用于前端展示或后续的业务操作。
+	 */
+
  	PageUtils queryPage(Map<String, Object> params);
-    
+
+	/**
+	 * 选择列表视图
+	 * 定义了一个用于查询用户数据列表的方法，该方法接收一个 Wrapper<UsersEntity> 类型的参数，这个 Wrapper 通常用于构建复杂的查询条件（例如添加筛选条件、排序条件等），
+	 * 通过它可以灵活地定义查询用户数据的具体逻辑，返回的是一个 UsersEntity 类型的列表，即符合查询条件的用户数据集合，方便在业务中获取特定条件下的用户数据列表，
+	 * 例如在查询满足某些特定属性（如特定角色、特定时间段内注册等）的用户列表场景下会用到该方法。
+	 *
+	 * @param wrapper 用于构建查询条件的包装器对象，调用者可以利用它来设置诸如等于、不等于、大于、小于等各种条件，以此来精确地控制从数据库中获取哪些用户的数据。
+	 * @return 符合查询条件的用户实体对象列表，列表中的每个 UsersEntity 对象代表一条用户数据记录。
+	 */
+
    	List<UsersEntity> selectListView(Wrapper<UsersEntity> wrapper);
-   	
+	/**
+	 * 查询分页数据（带条件）
+	 * 与前面的 queryPage(Map<String, Object> params) 方法类似，也是用于查询分页的用户数据，但此方法额外接收一个 Wrapper<UsersEntity> 类型的参数，
+	 * 用于构建更复杂、更精确的查询条件，结合传入的 params 参数（包含分页相关设置及其他可能的通用查询条件），可以实现带特定条件的分页查询功能，
+	 * 比如在用户管理中按照特定角色、特定状态等条件分页查看用户信息时会使用该方法。
+	 *
+	 * @param params 包含查询条件及分页相关参数的 Map 对象，作用与前面 queryPage 方法中的 params 参数类似，用于设置分页相关属性以及一些基础的查询条件等。
+	 * @param wrapper 用于构建查询条件的包装器对象，用于添加额外的、更具体的查询条件，与 params 参数共同作用来精准控制查询哪些用户的数据以及如何分页展示这些数据。
+	 * @return 返回 PageUtils 对象，其中包含了符合传入的分页条件以及其他查询条件的分页后的用户数据信息，以供前端展示或后续业务操作使用。
+	 */
    	PageUtils queryPage(Map<String, Object> params, Wrapper<UsersEntity> wrapper);
-	   	
+
 }

minsu/minsuguanliw/src/main/java/com/service/YonghuService.java

@@ -15,5 +15,9 @@ public interface YonghuService extends IService<YonghuEntity> {
     * @param params 查询参数
     * @return 带分页的查询出来的数据
     */
+    // 定义了一个名为 `queryPage` 的方法，它接收一个 `Map<String, Object>` 类型的参数 `params`，
+    // 该方法的作用是根据传入的 `params` 参数中包含的各种查询条件及分页相关信息，查询相应的分页数据，
+    // 并返回一个 `PageUtils` 类型的对象，`PageUtils` 类通常用于封装分页相关的属性（如总记录数、每页记录数、当前页码以及具体的分页数据列表等），
+    // 以便后续进行分页展示或者其他与分页数据相关的业务操作。例如在用户管理系统中，通过传入不同的查询条件和分页参数，获取对应分页的用户数据列表等场景会调用此方法。
      PageUtils queryPage(Map<String, Object> params);
 }

minsu/minsuguanliw/src/main/java/com/service/impl/ForumServiceImpl.java

@@ -19,21 +19,48 @@ import com.entity.view.ForumView;
 
 /**
  * 论坛 服务实现类
+ * 该类继承自 MyBatis Plus 的 ServiceImpl 类，
+ * 用于实现 ForumService 接口中定义的与论坛相关的业务逻辑方法，
+ * 同时被标记为 Spring 的服务组件（@Service），并
+ * 开启了事务管理（@Transactional），确保相关数据库操作的一致性和完整性。
  */
 @Service("forumService")
 @Transactional
 public class ForumServiceImpl extends ServiceImpl<ForumDao, ForumEntity> implements ForumService {
 
+    /**
+     * 查询分页数据的方法，用
+     * 于根据传入的参数获取论坛相关数据的分页信息，并封装成适合返回给前端等调用方使用的格式。
+     *
+     * @param params 一个 Map
+     *               类型的参数，用于接收各种查询条件和分页相关的参数，例如查询关键字、筛选条件以及页码、每页显示数量等信息。
+     * @return 返回一个 PageUtils
+     * 对象，该对象包含了分页后的论坛数据以及分页相关的元信息（如总记录数、总页数等），方便前端进行分页展示等操作。
+     */
     @Override
-    public PageUtils queryPage(Map<String,Object> params) {
+    public PageUtils queryPage(Map<String, Object> params) {
-        if(params != null && (params.get("limit") == null || params.get("page") == null)){
+        // 如果传入的参数不为空，
-            params.put("page","1");
+        // 并且参数中没有设置 "limit"（每页显示数量）
-            params.put("limit","10");
+        // 或者 "page"（页码）字段，则设置默认的页码为 1，每页显示数量为 10
+        if (params!= null && (params.get("limit") == null || params.get("page") == null)) {
+            params.put("page", "1");
+            params.put("limit", "10");
         }
-        Page<ForumView> page =new Query<ForumView>(params).getPage();
-        page.setRecords(baseMapper.selectListView(page,params));
-        return new PageUtils(page);
-    }
 
+        // 通过传入的参数构建一个 Query 对象，
+        // 并调用其 getPage 方法获取一个 Page<ForumView> 类型的分页对象，
+        // 这里 ForumView 可能是一个适合展示给前端的视图实体类，
+        // 包含了论坛相关数据以及可能关联的其他必要信息。
+        Page<ForumView> page = new Query<ForumView>(params).getPage();
+
+        // 调用 baseMapper（继承自 ServiceImpl 类，
+        // 实际对应 ForumDao 接口中定义的数据库操作方法）的 selectListView 方法，
+        // 将分页对象以及查询参数传入，获取符合条件的分页数据列表，
+        // 并设置到 page 对象的 records 属性中，用于后续封装返回。
+        page.setRecords(baseMapper.selectListView(page, params));
 
-}
+        // 使用获取到的包含分页数据的 page
+        // 对象构建并返回一个 PageUtils 对象，将分页数据及相关元信息进行整合封装，方便对外提供统一格式的分页数据结果。
+        return new PageUtils(page);
+    }
+}

minsu/minsuguanliw/src/main/java/com/service/impl/NewsServiceImpl.java

@@ -19,21 +19,47 @@ import com.entity.view.NewsView;
 
 /**
  * 公告信息 服务实现类
+ * 该类继承自 MyBatis Plus 的 ServiceImpl 类，
+ * 用于实现 NewsService 接口中定义的与公告信息相关的业务逻辑方法，
+ * 同时被标记为 Spring 的服务组件（@Service），并
+ * 开启了事务管理（@Transactional），以此确保涉及公告信息相关数据库操作时的一致性和完整性。
  */
 @Service("newsService")
 @Transactional
 public class NewsServiceImpl extends ServiceImpl<NewsDao, NewsEntity> implements NewsService {
 
+    /**
+     * 查询分页数据的方法，其主要功能是依据传入的参数来获取公告信息相关数据的分页情况，
+     * 并将其封装成便于返回给前端或者其他调用方使用的格式。
+     *
+     * @param params 一个 Map 类型的参数，该参数用于接收各类查询条件以及分页相关的设定，
+     *               比如用于筛选公告的特定条件（如公告类型、发布时间范围等）、页码、每页显示的公告数量等信息。
+     * @return 返回一个 PageUtils 对象，此对象中包含了经过分页处理后的公告信息数据，同时还整合了分页相关的元数据（例如总记录数、总页数等），方便前端进行分页展示等后续操作。
+     */
     @Override
-    public PageUtils queryPage(Map<String,Object> params) {
+    public PageUtils queryPage(Map<String, Object> params) {
-        if(params != null && (params.get("limit") == null || params.get("page") == null)){
+        // 首先判断传入的参数是否不为空，并且在参数中没有设定
-            params.put("page","1");
+        // "limit"（表示每页显示的公告数量）或者 "page"（表示页码）这两个关键分页参数时，
-            params.put("limit","10");
+        // 则为其赋予默认值，即将页码设为 1，每页显示的公告数量设为 10，以此确保分页查询能正常进行。
+        if (params!= null && (params.get("limit") == null || params.get("page") == null)) {
+            params.put("page", "1");
+            params.put("limit", "10");
         }
-        Page<NewsView> page =new Query<NewsView>(params).getPage();
-        page.setRecords(baseMapper.selectListView(page,params));
-        return new PageUtils(page);
-    }
 
+        // 通过传入的参数构建一个 Query<NewsView> 类型的对象，
+        // 并调用其 getPage 方法来获取一个 Page<NewsView> 类型的分页对象。
+        // 这里的 NewsView 大概率是一个专门为前端展示等需求而设计的视图实体类，
+        // 它包含了公告信息以及可能与之关联的其他需要展示的相关信息。
+        Page<NewsView> page = new Query<NewsView>(params).getPage();
+
+        // 调用 baseMapper（它继承自 ServiceImpl 类，
+        // 实际上对应的是 NewsDao 接口中定义的与数据库操作相关的方法）的 selectListView 方法，
+        // 把前面获取到的分页对象以及查询参数传递进去，获取符合查询条件的分页数据列表，
+        // 然后将这些数据设置到 page 对象的 records 属性中，以便后续进行封装并返回。
+        page.setRecords(baseMapper.selectListView(page, params));
 
-}
+        // 最后，利用已经填充好数据的 page 对象来构建并返回一个 PageUtils 对象，
+        // 该对象会把分页数据以及与之相关的元数据进行整合封装，对外提供统一格式的分页数据结果，方便其他部分的代码进行使用。
+        return new PageUtils(page);
+    }
+}

minsu/minsuguanliw/src/main/java/com/service/impl/TokenServiceImpl.java

@@ -1,7 +1,5 @@
-
 package com.service.impl;
 
-
 import java.util.Calendar;
 import java.util.Date;
 import java.util.List;
@@ -21,60 +19,211 @@ import com.utils.CommonUtil;
 import com.utils.PageUtils;
 import com.utils.Query;
 
-
 /**
  * token
+ * 该类是 `TokenService` 接口的实现类，
+ * 用于具体实现与 token 相关的各项业务逻辑操作，继承自 MyBatis Plus 的 `ServiceImpl` 类，
+ * 借助其提供的通用数据库操作方法来简化代码编写，
+ * 并被标记为 Spring 的服务组件（`@Service`），
+ * 以便能被 Spring 框架管理和注入到其他需要使用的地方。
  * @author
  */
 @Service("tokenService")
 public class TokenServiceImpl extends ServiceImpl<TokenDao, TokenEntity> implements TokenService {
 
+	/**
+	 * 根据传入的查询参数查询 token 相关数据，并以分页形式返回结果的方法，
+	 * 实现了 `TokenService` 接口中定义的对应方法。
+	 * 此方法主要利用 MyBatis Plus 提供的分页查询功能，
+	 * 结合传入的参数构建分页查询条件，从数据库中获取符合条件的 token 数据分页信息。
+	 *
+	 * @param params 查询参数，是一个 Map 类型的数据结构，可包含如页码、
+	 *                  每页显示数量以及其他用于筛选 token 的条件信息（例如按创建时间范围、关联用户等条件进行筛选），
+	 *               用于控制分页查询的具体逻辑，以获取期望的分页数据。
+	 * @return 返回一个 `PageUtils` 类型的对象，
+	 * 该对象封装了分页后的 token 相关数据以及分页相关的元信息（比如总记录数、总页数等），
+	 *         方便在前端展示或者其他业务场景下对分页数据进行处理，例如分页展示、数据统计等操作。
+	 */
 	@Override
 	public PageUtils queryPage(Map<String, Object> params) {
+		// 通过传入的参数构建一个 `Query<TokenEntity>` 对象，
+		// 并调用其 `getPage` 方法获取一个 `Page<TokenEntity>` 类型的分页对象，
+		// 这个分页对象包含了基本的分页信息（如当前页码、每页显示数量等），用于后续的分页查询操作。
 		Page<TokenEntity> page = this.selectPage(
-                new Query<TokenEntity>(params).getPage(),
+				new Query<TokenEntity>(params).getPage(),
-                new EntityWrapper<TokenEntity>()
+				new EntityWrapper<TokenEntity>()
-        );
+		);
-        return new PageUtils(page);
+		// 使用获取到的包含分页数据的 `page`
+		// 对象构建并返回一个 `PageUtils` 对象，将分页数据及相关元信息进行整合封装，
+		// 对外提供统一格式的分页数据结果，便于其他部分的代码使用。
+		return new PageUtils(page);
 	}
 
+	/**
+	 * 根据给定的条件包装器（Wrapper）查询并返回符合条件的
+	 * `TokenEntity` 列表的方法，实现了 `TokenService` 接口中定义的对应方法。
+	 * 通过调用对应的 `baseMapper`
+	 * （继承自 `ServiceImpl`，实际对应 `TokenDao` 接口中定义的数据库操作方法）的 `selectListView` 方法，
+	 * 依据传入的条件包装器进行数据库查询，获取符合条件的 token 实体列表。
+	 *
+	 * @param wrapper 用于构建查询条件的包装器对象，
+	 *                   它定义了查询 `TokenEntity` 列表的具体条件，
+	 *                例如可以通过它设置只查询某个用户的有效 token、
+	 *                特定角色对应的 token 等各种复杂的筛选逻辑，
+	 *                作为从数据库中获取期望的 token 实体列表的依据。
+	 * @return 返回一个包含符合条件的 `TokenEntity`
+	 * 对象的列表，列表中的每个 `TokenEntity` 代表了一条符合设定条件的 token 相关记录，
+	 *         方便后续在业务逻辑中对这些查询到的 token 实体进行进一步处理，如验证、更新等操作。
+	 */
 	@Override
 	public List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper) {
 		return baseMapper.selectListView(wrapper);
 	}
 
+	/**
+	 * 结合查询参数（params）和条件包装器（wrapper）
+	 * 来查询 token 相关数据，并以分页形式返回结果的方法，实现了 `TokenService` 接口中定义的对应方法。
+	 * 先是利用传入的参数构建分页对象，再结合条件包装器通过数据库查询获取符合条件的分页数据，
+	 * 最后将数据封装到 `PageUtils` 对象中返回。
+	 *
+	 * @param params 查询参数，同样是 Map 类型，可包含如分页相关的页码、
+	 *                  每页显示数量等基本信息，也可以设置一些通用的筛选条件，
+	 *               辅助细化查询范围，与 `wrapper` 中的条件共同作用来确定最终的查询结果。
+	 * @param wrapper 用于构建查询条件的包装器对象，可定义更细致、更复杂的针对 token 的筛选、排序等条件，
+	 *                如根据特定的业务规则筛选出某些特定状态、关联特定用户或角色的 token 等，
+	 *                与 `params` 配合实现灵活查询。
+	 * @return 返回一个 `PageUtils` 类型的对象，
+	 * 里面封装了依据上述条件组合查询到的分页后的 token 相关数据以及对应的分页元信息，
+	 *         用于在相应业务场景下进行分页展示和后续的数据处理工作。
+	 */
 	@Override
-	public PageUtils queryPage(Map<String, Object> params,
+	public PageUtils queryPage(Map<String, Object> params, Wrapper<TokenEntity> wrapper) {
-			Wrapper<TokenEntity> wrapper) {
+		// 通过传入的参数构建一个 `Page<TokenEntity>` 类型的分页对象，该对象包含了基本的分页设置信息，为后续查询做准备。
-		 Page<TokenEntity> page =new Query<TokenEntity>(params).getPage();
+
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+		Page<TokenEntity> page = new Query<TokenEntity>(params).getPage();
-	    	PageUtils pageUtil = new PageUtils(page);
+		// 调用 `baseMapper` 的 `selectListView` 方法，传入分页对象和条件包装器，获取符合条件的分页数据列表，
-	    	return pageUtil;
+		// 并将这些数据设置到 `page` 对象的 `records` 属性中，填充分页对象的具体数据内容。
+
+
+
+
+		page.setRecords(baseMapper.selectListView(page, wrapper));
+		// 使用填充好数据的 `page` 对象构建一个 `PageUtils` 对象，将分页数据及相关元信息进行整合封装，
+		// 然后返回这个 `PageUtils` 对象，以便向外提供统一格式的分页数据结果，供其他业务代码使用。
+		PageUtils pageUtil = new PageUtils(page);
+		return pageUtil;
 	}
 
+	/**
+	 * 生成 token 的方法，实现了 `TokenService` 接口中定义的对应方法。根据传入的用户相关信息（用户 ID、用户名、所属表名、角色）来创建一个对应的 token 字符串，
+	 * 并处理与该 token 相关的数据库操作，
+	 * 如更新已存在的 token 记录或者插入新的 token 记录等，以保证 token 的有效性和唯一性。
+	 *
+	 * @param userid 用户的唯一标识，
+	 *                  通常是一个整数类型的 ID，用于明确是哪个用户对应的 token 正在生成，
+	 *               是区分不同用户 token 的重要依据之一。
+	 * @param username 用户的名称，字符串类型，与 `userid` 共同进一步确定用户身份，确保生成的 token 与特定用户准确关联。
+	 * @param tableName 所属表名，可
+	 *                     能用于标识该用户信息存储所在的数据库表，在一些多表关联或者分表存储的复杂业务场景下，
+	 *                  可以帮助更准确地定位和管理与该用户相关的 token 信息，也有助于区分不同业务模块下的 token 生成逻辑。
+	 * @param role 用户在系统中所扮演的角色，例如管理员、
+	 *                普通用户等不同角色往往具有不同的权限范围，
+	 *             通过角色信息可以在生成 token 时融入相应的权限特征，便于后续基于 token 进行权限验证等操作。
+	 * @return 返回生成的 token 字符串，
+	 * 该字符串将作为用户后续在系统中进行操作时的身份验证标识，
+	 *         会在如接口调用、页面访问等场景中被传递和验证，以确定用户是否有权限进行相应操作。
+	 */
+
+
 	@Override
-	public String generateToken(Integer userid,String username, String tableName, String role) {
+	public String generateToken(Integer userid, String username, String tableName, String role) {
+		// 首先尝试从数据库中查找是否已存在该用户
+		// （根据传入的 `userid` 和 `role`）对应的 token 记录，
+		// 通过构建一个 `EntityWrapper`
+		// 对象设置查询条件（使用 `eq` 方法表示相等条件，即查找 `userid` 和 `role` 与传入值相等的记录），
+		// 然后调用 `selectOne` 方法进行查询，
+		// 如果找到则返回对应的 `TokenEntity` 对象，否则返回 `null`。
 		TokenEntity tokenEntity = this.selectOne(new EntityWrapper<TokenEntity>().eq("userid", userid).eq("role", role));
+		// 调用工具类 `CommonUtil` 的 `getRandomString`
+		// 方法生成一个长度为 32 的随机字符串，作为新的 token 值，
+		// 这个随机字符串将作为唯一标识用户身份的关键信息，用于后续的身份验证等操作。
 		String token = CommonUtil.getRandomString(32);
-		Calendar cal = Calendar.getInstance();   
+		// 获取一个 `Calendar` 实例，
-    	cal.setTime(new Date());   
+		// 用于操作日期和时间，这里用于设置 token 的过期时间。
-    	cal.add(Calendar.HOUR_OF_DAY, 1);
+		Calendar cal = Calendar.getInstance();
-		if(tokenEntity!=null) {
+		// 将 `Calendar`
+		// 的时间设置为当前时间，以此为基础来计算过期时间。
+		cal.setTime(new Date());
+		// 给当前时间加上 1 小时，
+		// 即设置 token 的过期时间为从当前时间起 1 小时后，
+		// 这样可以控制 token 的有效时长，
+		// 提高系统的安全性，避免 token 长期有效可能带来的安全风险。
+		cal.add(Calendar.HOUR_OF_DAY, 1);
+
+		// 如果之前查询到已存在该用户对应的 token 记录（即 `tokenEntity` 不为 `null`），
+		// 则更新该记录的 `token` 值为新生成的 `token` 字符串，
+		// 并设置其 `expiratedtime`（过期时间）为刚才计算好的时间，
+		// 最后调用 `updateById` 方法将更新后的 `TokenEntity`
+		// 对象保存到数据库中，完成 token 的更新操作。
+
+
+
+		if (tokenEntity!= null) {
 			tokenEntity.setToken(token);
 			tokenEntity.setExpiratedtime(cal.getTime());
 			this.updateById(tokenEntity);
 		} else {
-			this.insert(new TokenEntity(userid,username, tableName, role, token, cal.getTime()));
+			// 如果之前不存在对应的 token 记录，
+			// 则创建一个新的 `TokenEntity` 对象，
+			// 将传入的用户相关信息（`userid`、`username`、`tableName`、`role`）、
+			// 新生成的 `token` 字符串以及计算好的过期时间作为参数传入构造函数，
+			// 然后调用 `insert` 方法将新的 `TokenEntity` 对象插入到数据库中，
+			// 完成新 token 的创建操作。
+			this.insert(new TokenEntity(userid, username, tableName, role, token, cal.getTime()));
 		}
+		// 最后返回生成的 token 字符串，
+		// 该字符串将作为后续业务操作中用于验证用户身份的标识信息。
 		return token;
 	}
 
+	/**
+	 * 根据给定的 token 字符串获取对应的 `TokenEntity`
+	 * 对象的方法，实现了 `TokenService` 接口中定义的对应方法。
+	 * 先从数据库中查找对应 token 的记录，如果找到且该 token 未过期，
+	 * 则返回对应的 `TokenEntity` 对象，否则返回 `null`，以此来验证 token 的有效性。
+	 *
+	 * @param token 要查找对应实体的 token 字符串，
+	 *                 它是之前通过 `generateToken` 方法等生成的用于标识用户身份的标识信息，
+	 *              作为查找的关键依据，在系统中唯一对应一个 `TokenEntity`
+	 *              对象（在符合业务逻辑和数据规范的情况下）。
+	 * @return 返回与传入的 token 字符串对应的 `TokenEntity` 对象，
+	 * 如果找到则返回该对象，可进一步获取其中的详细信息进行后续处理；
+	 *         如果未找到符合条件的对象（即 `token` 在数据库中不存在或者已过期），则返回 `null`，表示该 token 不存在或者无效等情况。
+	 */
 	@Override
 	public TokenEntity getTokenEntity(String token) {
+		// 通过构建一个 `EntityWrapper`
+		// 对象设置查询条件（使用 `eq` 方法表示相等条件，即查找 `token` 字段与传入的 `token` 值相等的记录），
+		// 然后调用 `selectOne`
+		// 方法从数据库中查找对应的 `TokenEntity` 对象，如果找到则返回该对象，否则返回 `null`。
+
+
+
+
+
+
 		TokenEntity tokenEntity = this.selectOne(new EntityWrapper<TokenEntity>().eq("token", token));
-		if(tokenEntity == null || tokenEntity.getExpiratedtime().getTime()<new Date().getTime()) {
+		// 如果查询到的 `tokenEntity` 为 `null`，说明数据库中不存在对应的 token 记录，直接返回 `null`，表示该 token 无效；
+		// 或者如果查询到的 `tokenEntity` 的 `expiratedtime`（过期时间）早于当前时间（通过 `getTime` 方法获取时间的毫秒数进行比较），
+		// 说明 token 已经过期，同样返回 `null`，表示该 token 已失效，不能用于后续的身份验证等操作。
+
+
+
+		if (tokenEntity == null || tokenEntity.getExpiratedtime().getTime() < new Date().getTime()) {
 			return null;
 		}
+		// 如果 token 存在且未过期，则返回对应的 `TokenEntity` 对象，以便后续可以获取其中的详细信息（如关联用户、角色等）进行相应的业务操作，
+		// 例如基于该 token 进行权限验证、获取用户相关信息等。
 		return tokenEntity;
 	}
-}
+}