Merge pull request '注释代码' (#6) from wujiamei_branch into main

src/main/java/com/controller/ChatController.java

@@ -42,214 +42,310 @@ import com.utils.CommonUtil;
 /**
  * 在线咨询
  * 后端接口
- * @author 
+ * @author （这里应该填写作者姓名，但代码中未给出具体值）
- * @email 
+ * @email （这里应该填写作者邮箱，但代码中未给出具体值）
  * @date 2023-02-21 09:46:06
  */
 @RestController
 @RequestMapping("/chat")
 public class ChatController {
+
+    // 自动注入ChatService实例，用于处理与聊天相关的业务逻辑
     @Autowired
     private ChatService chatService;
 
-
-
-    
-
-
     /**
      * 后端列表
+     * 用于获取聊天记录列表，根据不同用户角色（管理员或普通用户）进行数据筛选
+     * @param params 包含查询参数的Map，例如分页参数、筛选条件等
+     * @param chat ChatEntity对象，可能包含一些额外的查询条件
+     * @param request HttpServletRequest对象，用于获取当前会话信息
+     * @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
      */
     @RequestMapping("/page")
-    public R page(@RequestParam Map<String, Object> params,ChatEntity chat, 
+    public R page(@RequestParam Map<String, Object> params, ChatEntity chat,
-		HttpServletRequest request){
+            HttpServletRequest request) {
-    	if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
+        // 如果当前用户不是管理员角色，设置查询条件，只查询当前用户的聊天记录
-    		chat.setUserid((Long)request.getSession().getAttribute("userId"));
+        if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
+            
+            chat.setUserid((Long) request.getSession().getAttribute("userId"));
         }
 
+        // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
         EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
 
+        // 调用chatService的queryPage方法进行分页查询，传入构建好的查询条件和参数
         PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
+        // 将查询结果设置到请求属性中，可能用于在后续的视图渲染中使用
         request.setAttribute("data", page);
+        // 返回包含查询结果的R对象，通常R对象用于统一封装返回结果的状态和数据
         return R.ok().put("data", page);
     }
 
     /**
      * 前端列表
+     * 功能与后端列表类似，但可能在前端展示时有不同的处理或用途
+     * @param params 包含查询参数的Map，例如分页参数、筛选条件等
+     * @param chat ChatEntity对象，可能包含一些额外的查询条件
+     * @param request HttpServletRequest对象，用于获取当前会话信息
+     * @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
      */
     @RequestMapping("/list")
-    public R list(@RequestParam Map<String, Object> params,ChatEntity chat, 
+    public R list(@RequestParam Map<String, Object> params, ChatEntity chat,
-		HttpServletRequest request){
+            HttpServletRequest request) {
-    	if(!request.getSession().getAttribute("role").toString().equals("管理员")) {
+        // 如果当前用户不是管理员角色,设置查询条件，只查询当前用户的聊天记录
-    		chat.setUserid((Long)request.getSession().getAttribute("userId"));
+        if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
+            
+            chat.setUserid((Long) request.getSession().getAttribute("userId"));
         }
 
+        // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
         EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
 
+        // 调用chatService的queryPage方法进行分页查询，传入构建好的查询条件和参数
         PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
+        // 将查询结果设置到请求属性中，可能用于在后续的视图渲染中使用
         request.setAttribute("data", page);
+        // 返回包含查询结果的R对象，通常R对象用于统一封装返回结果的状态和数据
         return R.ok().put("data", page);
     }
 
     /**
      * 列表
+     * 用于获取聊天记录列表，根据传入的ChatEntity对象构建查询条件
+     * @param chat ChatEntity对象，包含查询条件信息
+     * @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
      */
     @RequestMapping("/lists")
-    public R list( ChatEntity chat){
+    public R list(ChatEntity chat) {
+        // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
         EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
-      	ew.allEq(MPUtil.allEQMapPre( chat, "chat")); 
+        // 根据传入的ChatEntity对象构建等值查询条件
+        ew.allEq(MPUtil.allEQMapPre(chat, "chat"));
+        // 调用chatService的selectListView方法进行查询，并返回结果
         return R.ok().put("data", chatService.selectListView(ew));
     }
 
     /**
      * 查询
+     * 用于查询特定条件的在线咨询记录，并返回详细信息视图
+     * @param chat ChatEntity对象，包含查询条件信息
+     * @return R类型的结果，包含查询到的在线咨询详细信息视图及相关状态信息
      */
     @RequestMapping("/query")
-    public R query(ChatEntity chat){
+    public R query(ChatEntity chat) {
-        EntityWrapper< ChatEntity> ew = new EntityWrapper< ChatEntity>();
+        // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
- 		ew.allEq(MPUtil.allEQMapPre( chat, "chat")); 
+        EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
+        // 根据传入的ChatEntity对象构建等值查询条件
+        ew.allEq(MPUtil.allEQMapPre(chat, "chat"));
+        // 调用chatService的selectView方法进行查询，获取ChatView对象（可能是包含详细信息的视图对象）
         ChatView chatView = chatService.selectView(ew);
+        // 返回包含查询结果的R对象，以及提示信息和查询到的详细信息视图
         return R.ok("查询在线咨询成功").put("data", chatView);
     }
 
     /**
      * 后端详情
+     * 用于获取指定ID的聊天记录详细信息
+     * @param id 聊天记录的ID
+     * @return R类型的结果，包含查询到的聊天记录详细信息及相关状态信息
      */
     @RequestMapping("/info/{id}")
-    public R info(@PathVariable("id") Long id){
+    public R info(@PathVariable("id") Long id) {
+        // 调用chatService的selectById方法，根据ID查询聊天记录
         ChatEntity chat = chatService.selectById(id);
+        // 返回包含查询结果的R对象
         return R.ok().put("data", chat);
     }
 
     /**
      * 前端详情
+     * 功能与后端详情类似，但可能在前端展示时有不同的处理或用途，且此方法标注了@IgnoreAuth，表示忽略权限验证
+     * @param id 聊天记录的ID
+     * @return R类型的结果，包含查询到的聊天记录详细信息及相关状态信息
      */
     @IgnoreAuth
     @RequestMapping("/detail/{id}")
-    public R detail(@PathVariable("id") Long id){
+    public R detail(@PathVariable("id") Long id) {
+        // 调用chatService的selectById方法，根据ID查询聊天记录
         ChatEntity chat = chatService.selectById(id);
+        // 返回包含查询结果的R对象
         return R.ok().put("data", chat);
     }
 
-
-
-
     /**
      * 后端保存
+     * 用于保存新的聊天记录，包括设置一些默认值和根据聊天内容更新相关状态
+     * @param chat 包含聊天记录信息的ChatEntity对象
+     * @param request HttpServletRequest对象，用于获取当前会话信息
+     * @return R类型的结果，用于表示保存操作的结果状态
      */
     @RequestMapping("/save")
-    public R save(@RequestBody ChatEntity chat, HttpServletRequest request){
+    public R save(@RequestBody ChatEntity chat, HttpServletRequest request) {
-    	chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
+        // 设置聊天记录的ID，由当前时间戳加上一个随机数生成
+        chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
+        // 此处原本可能用于验证ChatEntity对象的合法性，但被注释掉了
         //ValidatorUtils.validateEntity(chat);
-    	if(StringUtils.isNotBlank(chat.getAsk())) {
+        // 如果聊天记录的提问内容不为空
+        if (StringUtils.isNotBlank(chat.getAsk())) {
+            // 更新当前用户的未回复状态为0，表示有新提问
             chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
-    		chat.setUserid((Long)request.getSession().getAttribute("userId"));
+            // 设置聊天记录的用户ID为当前用户ID
+            chat.setUserid((Long) request.getSession().getAttribute("userId"));
+            // 设置回复状态为1，表示已提问等待回复
             chat.setIsreply(1);
         }
-    	if(StringUtils.isNotBlank(chat.getReply())) {
+        // 如果聊天记录的回复内容不为空
+        if (StringUtils.isNotBlank(chat.getReply())) {
+            // 更新当前用户（提问用户）的未回复状态为0，表示有新回复
             chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
-    		chat.setAdminid((Long)request.getSession().getAttribute("userId"));
+            // 设置聊天记录的管理员ID为当前用户ID（可能表示回复的管理员）
+            chat.setAdminid((Long) request.getSession().getAttribute("userId"));
         }
 
+        // 调用chatService的insert方法插入新的聊天记录
         chatService.insert(chat);
+        // 返回表示保存成功的R对象
         return R.ok();
     }
 
     /**
      * 前端保存
+     * 功能与后端保存类似，但可能在前端保存时有不同的处理或用途
+     * @param chat 包含聊天记录信息的ChatEntity对象
+     * @param request HttpServletRequest对象，用于获取当前会话信息
+     * @return R类型的结果，用于表示保存操作的结果状态
      */
     @RequestMapping("/add")
-    public R add(@RequestBody ChatEntity chat, HttpServletRequest request){
+    public R add(@RequestBody ChatEntity chat, HttpServletRequest request) {
-    	chat.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
+        // 设置聊天记录的ID，由当前时间戳加上一个随机数生成
-    	//ValidatorUtils.validateEntity(chat);
+        chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
-    	chat.setUserid((Long)request.getSession().getAttribute("userId"));
+        
-    	if(StringUtils.isNotBlank(chat.getAsk())) {
+        
+        // 设置聊天记录的用户ID为当前用户ID
+        chat.setUserid((Long) request.getSession().getAttribute("userId"));
+        // 如果聊天记录的提问内容不为空
+        if (StringUtils.isNotBlank(chat.getAsk())) {
+            // 更新当前用户的未回复状态为0，表示有新提问
             chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
-    		chat.setUserid((Long)request.getSession().getAttribute("userId"));
+            // 设置聊天记录的用户ID为当前用户ID
+            chat.setUserid((Long) request.getSession().getAttribute("UserId"));
+            // 设置回复状态为1，表示已提问等待回复
             chat.setIsreply(1);
         }
-    	if(StringUtils.isNotBlank(chat.getReply())) {
+        // 如果聊天记录的回复内容不为空
+        if (StringUtils.isNotBlank(chat.getReply())) {
+            // 更新当前用户（提问用户）的未回复状态为0，表示有新回复
             chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
-    		chat.setAdminid((Long)request.getSession().getAttribute("userId"));
+            // 设置聊天记录的管理员ID为当前用户ID（可能表示回复的管理员）
+            chat.setAdminid((Long) request.getSession().getAttribute("UserId"));
         }
 
+        // 调用chatService的insert方法插入新的聊天记录
         chatService.insert(chat);
+        // 返回表示保存成功的R对象
         return R.ok();
     }
 
-
     /**
      * 修改
+     * 用于修改已存在的聊天记录
+     * @param chat 包含修改后聊天记录信息的ChatEntity对象
+     * @param request HttpServletRequest对象，可能用于获取一些额外信息（此处未体现具体用途）
+     * @return R类型的结果，用于表示修改操作的结果状态
      */
     @RequestMapping("/update")
     @Transactional
-    public R update(@RequestBody ChatEntity chat, HttpServletRequest request){
+    public R update(@RequestBody ChatEntity chat, HttpServletRequest request) {
+        // 此处原本可能用于验证ChatEntity对象的合法性，但被注释掉了
         //ValidatorUtils.validateEntity(chat);
-        chatService.updateById(chat);//全部更新
+        // 调用chatService的updateById方法，根据ID更新聊天记录
+        chatService.updateById(chat); //全部更新
+        // 返回表示修改成功的R对象
         return R.ok();
     }
 
-    
-
     /**
      * 删除
+     * 用于删除指定ID的聊天记录
+     * @param ids 包含要删除聊天记录ID的数组
+     * @return R类型的结果，用于表示删除操作的结果状态
      */
     @RequestMapping("/delete")
-    public R delete(@RequestBody Long[] ids){
+    public R delete(@RequestBody Long[] ids) {
+        // 调用chatService的deleteBatchIds方法，批量删除指定ID的聊天记录
         chatService.deleteBatchIds(Arrays.asList(ids));
+        // 返回表示删除成功的R对象
         return R.ok();
     }
 
     /**
      * 提醒接口
+     * 根据指定的列名、类型以及其他查询条件，统计符合条件的聊天记录数量
+     * @param columnName 要进行条件判断的列名
+     * @param request HttpServletRequest对象，用于获取当前会话信息等
+     * @param type 提醒类型，可能用于区分不同的统计逻辑
+     * @param map 包含其他查询条件的Map，例如时间范围等
+     * @return R类型的结果，包含统计到的符合条件的聊天记录数量及相关状态信息
      */
     @RequestMapping("/remind/{columnName}/{type}")
     public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
-						 @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
+            @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
+        // 将列名和类型添加到查询条件Map中
         map.put("column", columnName);
         map.put("type", type);
 
-		if(type.equals("2")) {
+        // 如果提醒类型为2
+        if (type.equals("2")) {
+            // 创建SimpleDateFormat对象，用于日期格式化
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            // 获取Calendar实例，用于日期计算
             Calendar c = Calendar.getInstance();
             Date remindStartDate = null;
             Date remindEndDate = null;
-			if(map.get("remindstart")!=null) {
+            // 如果查询条件Map中包含remindstart（开始提醒时间）
+            if (map.get("remindstart")!= null) {
+                // 将remindstart转换为整数，表示要添加的天数
                 Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+                // 设置当前日期为基础日期
                 c.setTime(new Date());
-				c.add(Calendar.DAY_OF_MONTH,remindStart);
+                // 根据提醒开始天数添加到当前日期上
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
+                // 获取计算后的提醒开始日期
                 remindStartDate = c.getTime();
+                // 将提醒开始日期格式化为指定格式，并更新到查询条件Map中
                 map.put("remindstart", sdf.format(remindStartDate));
             }
-			if(map.get("remindend")!=null) {
+            // 如果查询条件Map中包含remindend（结束提醒时间）
+            if (map.get("remindend")!= null) {
+                // 将remindend转换为整数，表示要添加的天数
                 Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                // 设置当前日期为基础日期
                 c.setTime(new Date());
-				c.add(Calendar.DAY_OF_MONTH,remindEnd);
+                // 根据提醒结束天数添加到当前日期上
+                c.add(Calendar.DAY_OF_MONTH, remindEnd);
+                // 获取计算后的提醒结束日期
                 remindEndDate = c.getTime();
+                // 将提醒结束日期格式化为指定格式，并更新到查询条件Map中
                 map.put("remindend", sdf.format(remindEndDate));
             }
         }
 
+        // 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
         Wrapper<ChatEntity> wrapper = new EntityWrapper<ChatEntity>();
-		if(map.get("remindstart")!=null) {
+        // 如果查询条件Map中包含remindstart（开始提醒时间），添加大于等于条件到查询条件中
+        if (map.get("remindstart")!= null) {
             wrapper.ge(columnName, map.get("remindstart"));
         }
-		if(map.get("remindend")!=null) {
+        // 如果查询条件Map中包含remindend（结束提醒时间），添加小于等于条件到查询条件中
+        if (map.get("remindend")!= null) {
             wrapper.le(columnName, map.get("remindend"));
         }
 
-
+        // 调用chatService的selectCount方法，根据构建好的查询条件统计符合条件的聊天记录数量
         int count = chatService.selectCount(wrapper);
+        // 返回包含统计结果的R对象
         return R.ok().put("count", count);
     }
 
-	
-
-
-
-
-
-
-
-
 }

src/main/java/com/controller/CommonController.java

@@ -28,74 +28,107 @@ import com.baidu.aip.face.MatchRequest;
 import com.baidu.aip.util.Base64Util;
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
 import com.entity.ConfigEntity;
+// 导入相关的服务类和工具类
 import com.service.CommonService;
 import com.service.ConfigService;
 import com.utils.BaiduUtil;
 import com.utils.FileUtil;
 import com.utils.R;
 import com.utils.CommonUtil;
+
 /**
  * 通用接口
+ * 该类作为一个Spring的RestController，提供了一系列通用的接口方法，用于处理不同类型的业务逻辑，
+ * 如获取数据选项、根据条件获取记录、修改数据状态、统计数据等操作。
  */
 @RestController
-public class CommonController{
+public class CommonController {
+
+    // 自动注入CommonService，用于处理通用的业务逻辑
     @Autowired
     private CommonService commonService;
 
+    // 定义百度AI人脸识别客户端对象，初始化为null
     private static AipFace client = null;
 
+    // 自动注入ConfigService，可能用于获取配置相关信息
     @Autowired
     private ConfigService configService;
+
     /**
-	 * 获取table表中的column列表(联动接口)
+     * 获取table表中的column列表（联动接口）
-	 * @param table
+     * 根据传入的表名、列名以及一些可选的条件参数，获取指定表中指定列的列表数据，可能用于下拉框等联动选择场景。
-	 * @param column
+     *
-	 * @return
+     * @param tableName      表名
+     * @param columnName     列名
+     * @param conditionColumn 可选的条件列名，用于进一步筛选数据
+     * @param conditionValue 可选的条件值，与conditionColumn配合使用来筛选数据
+     * @param level          可选的层级参数，可能用于表示数据的层次结构相关的筛选
+     * @param parent         可选的父级参数，可能用于表示数据的父子关系相关的筛选
+     * @return 返回包含获取到的列列表数据的R对象，R对象通常用于封装返回结果信息
      */
     @RequestMapping("/option/{tableName}/{columnName}")
     @IgnoreAuth
-	public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,@RequestParam(required = false) String conditionColumn,@RequestParam(required = false) String conditionValue,String level,String parent) {
+    public R getOption(@PathVariable("tableName") String tableName, @PathVariable("tableName") String columnName,
+                       @RequestParam(required = false) String conditionColumn,
+                       @RequestParam(required = false) String conditionValue, String level, String parent) {
+        // 创建一个用于存储参数的Map对象
         Map<String, Object> params = new HashMap<String, Object>();
         params.put("table", tableName);
         params.put("column", columnName);
-		if(StringUtils.isNotBlank(level)) {
+        if (StringUtils.isNotBlank(level)) {
             params.put("level", level);
         }
-		if(StringUtils.isNotBlank(parent)) {
+        if (StringUtils.isNotBlank(parent)) {
             params.put("parent", parent);
         }
-        if(StringUtils.isNotBlank(conditionColumn)) {
+        if (StringUtils.isNotBlank(conditionColumn)) {
             params.put("conditionColumn", conditionColumn);
         }
-        if(StringUtils.isNotBlank(conditionValue)) {
+        if (StringUtils.isNotBlank(conditionValue)) {
             params.put("conditionValue", conditionValue);
         }
+
+        // 调用commonService的getOption方法获取数据列表
         List<String> data = commonService.getOption(params);
+
+        // 返回包含数据列表的R对象，结果状态为成功
         return R.ok().put("data", data);
     }
 
     /**
      * 根据table中的column获取单条记录
-	 * @param table
+     * 根据传入的表名、列名以及指定的列值，从指定表中获取满足条件的单条记录数据。
-	 * @param column
+     *
-	 * @return
+     * @param tableName    表名
+     * @param columnName   列名
+     * @param columnValue  用于筛选的列值，根据该值在指定列中查找匹配的记录
+     * @return 返回包含获取到的单条记录数据的R对象
      */
     @RequestMapping("/follow/{tableName}/{columnName}")
     @IgnoreAuth
-	public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @RequestParam String columnValue) {
+    public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
+                               @RequestParam String columnValue) {
+        // 创建一个用于存储参数的Map对象
         Map<String, Object> params = new HashMap<String, Object>();
         params.put("table", tableName);
         params.put("column", columnName);
         params.put("columnValue", columnValue);
+
+        // 调用commonService的getFollowByOption方法获取单条记录数据
         Map<String, Object> result = commonService.getFollowByOption(params);
+
+        // 返回包含单条记录数据的R对象，结果状态为成功
         return R.ok().put("data", result);
     }
 
     /**
      * 修改table表的sfsh状态
-	 * @param table
+     * 根据传入的表名和一个包含修改信息的Map对象，调用commonService的sh方法来修改指定表的sfsh状态。
-	 * @param map
+     *
-	 * @return
+     * @param tableName 表名
+     * @param map       包含修改信息的Map对象，具体内容由调用方确定，通常包含要修改的字段和对应的值等信息
+     * @return 返回表示修改操作成功的R对象
      */
     @RequestMapping("/sh/{tableName}")
     public R sh(@PathVariable("tableName") String tableName, @RequestBody Map<String, Object> map) {
@@ -106,47 +139,58 @@ public class CommonController{
 
     /**
      * 获取需要提醒的记录数
-	 * @param tableName
+     * 根据传入的表名、列名、类型以及一个包含其他条件的Map对象，计算并获取满足条件的需要提醒的记录数量。
-	 * @param columnName
+     * 当类型为2时，会根据传入的提醒开始时间和结束时间进行日期范围的计算和筛选。
-	 * @param type 1:数字 2:日期
+     *
-	 * @param map
+     * @param tableName    表名
-	 * @return
+     * @param columnName   列名
+     * @param type         类型参数，1表示数字类型的提醒条件，2表示日期类型的提醒条件
+     * @param map          包含其他条件的Map对象，如提醒开始时间、提醒结束时间等（当type为2时相关）
+     * @return 返回包含需要提醒的记录数的R对象
      */
     @RequestMapping("/remind/{tableName}/{columnName}/{type}")
     @IgnoreAuth
     public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
-						 @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
+                         @PathVariable("type") String type, @RequestParam Map<String, Object> map) {
         map.put("table", tableName);
         map.put("column", columnName);
         map.put("type", type);
 
-		if(type.equals("2")) {
+        if (type.equals("2")) {
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
             Calendar c = Calendar.getInstance();
             Date remindStartDate = null;
             Date remindEndDate = null;
-			if(map.get("remindstart")!=null) {
+            if (map.get("remindstart")!= null) {
                 Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
                 c.setTime(new Date());
-				c.add(Calendar.DAY_OF_MONTH,remindStart);
+                c.add(Calendar.DAY_OF_MONTH, remindStart);
                 remindStartDate = c.getTime();
                 map.put("remindstart", sdf.format(remindStartDate));
             }
-			if(map.get("remindend")!=null) {
+            if (map.get("remindend")!= null) {
-				Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+                Integer recommendEnd = Integer.parseInt(map.get("remindend").toString());
                 c.setTime(new Date());
-				c.add(Calendar.DAY_OF_MONTH,remindEnd);
+                c.add(Calendar.DAY_OF_MONTH, recommendEnd);
                 remindEndDate = c.getTime();
                 map.put("remindend", sdf.format(remindEndDate));
             }
         }
 
+        // 调用commonService的remindCount方法获取需要提醒的记录数
         int count = commonService.remindCount(map);
+
+        // 返回包含记录数的R对象，结果状态为成功
         return R.ok().put("count", count);
     }
 
     /**
      * 单列求和
+     * 根据传入的表名和列名，调用commonService的selectCal方法对指定表中的指定列进行求和操作，并返回结果。
+     *
+     * @param tableName    表名
+     * @param columnName   列名
+     * @return 返回包含求和结果的R对象
      */
     @RequestMapping("/cal/{tableName}/{columnName}")
     @IgnoreAuth
@@ -154,12 +198,22 @@ public class CommonController{
         Map<String, Object> params = new HashMap<String, Object>();
         params.put("table", tableName);
         params.put("column", columnName);
+
+        // 调用commonService的selectCal方法进行求和操作并获取结果
         Map<String, Object> result = commonService.selectCal(params);
+
+        // 返回包含求和结果的R对象，结果状态为成功
         return R.ok().put("data", result);
     }
 
     /**
      * 分组统计
+     * 根据传入的表名和列名，调用commonService的selectGroup方法对指定表中的指定列进行分组统计操作，
+     * 并对结果中的日期类型数据进行格式化处理后返回。
+     *
+     * @param tableName    表名
+    ， @param columnName   列名
+     * @return 返回包含分组统计结果的R对象
      */
     @RequestMapping("/group/{tableName}/{columnName}")
     @IgnoreAuth
@@ -167,63 +221,93 @@ public class CommonController{
         Map<String, Object> params = new HashMap<String, Object>();
         params.put("table", tableName);
         params.put("column", columnName);
+
+        // 调用commonService的selectGroup方法进行分组统计操作并获取结果
         List<Map<String, Object>> result = commonService.selectGroup(params);
+
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
-		for(Map<String, Object> m : result) {
+        for (Map<String, Object> m : result) {
-			for(String k : m.keySet()) {
+            for (String k : m.keySet()) {
-				if(m.get(k) instanceof Date) {
+                if (m.get(k) instanceof Date) {
-					m.put(k, sdf.format((Date)m.get(k)));
+                    m.put(k, sdf.format((Date) m.get(k)));
                 }
             }
         }
+
+        // 返回包含分组统计结果的R对象，结果状态为成功
         return R.ok().put("data", result);
     }
 
     /**
      * （按值统计）
+     * 根据传入的表名、x列名和y列名，调用commonService的selectValue方法对指定表中的指定列进行按值统计操作，
+     * 并对结果中的日期类型数据进行格式化处理后返回。
+     *
+     * @param tableName    表名
+     * @param yColumnName   用于统计的y列名
+     * @param xColumnName   用于分组的x列名
+     * @return 返回包含按值统计结果的R对象
      */
     @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}")
     @IgnoreAuth
-	public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) {
+    public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName,
+                   @PathVariable("xColumnName") String xColumnName) {
         Map<String, Object> params = new HashMap<String, Object>();
         params.put("table", tableName);
         params.put("xColumn", xColumnName);
         params.put("yColumn", yColumnName);
-		List<Map<String, Object>> result = commonService.selectValue(params);
+
+        // 调用commonService的selectValue方法进行按值统计操作并获取结果
+        List<Map<String, Object> > result = commonService.selectValue(params);
+
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
-		for(Map<String, Object> m : result) {
+        for (Map<String, Object> m : result) {
-			for(String k : m.keySet()) {
+            for (String k : m.keySet()) {
-				if(m.get(k) instanceof Date) {
+                if (m.get(k) instanceof Date) {
-					m.put(k, sdf.format((Date)m.get(k)));
+                    m.put(k, sdf.format((Date) m.get(k)));
                 }
             }
         }
+
+        // 返回包含按值统计结果的R对象，结果状态为成功
         return R.ok().put("data", result);
     }
 
     /**
      * （按值统计）时间统计类型
+     * 根据传入的表名、x列名、y列名和时间统计类型，调用commonService的selectTimeStatValue方法对指定表中的指定列进行按值统计操作，
+     * 并对结果中的日期类型数据进行格式化处理后返回。
+     *
+     * @param tableName    表名
+     * @param yColumnName   用于统计的y列名
+     * @param xColumnName   用于分组的x列名
+     * @param timeStatType 时间统计类型参数
+     * @return 返回包含按值统计结果的R对象
      */
-	@IgnoreAuth
     @RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}/{timeStatType}")
-	public R valueDay(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType) {
+    @IgnoreAuth
+    public R valueDay(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName,
+                      @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType) {
         Map<String, Object> params = new HashMap<String, Object>();
         params.put("table", tableName);
         params.put("xColumn", xColumnName);
         params.put("yColumn", yColumnName);
         params.put("timeStatType", timeStatType);
-		List<Map<String, Object>> result = commonService.selectTimeStatValue(params);
+
+        // 调用commonService的selectTimeStatValue方法进行按值统计操作并获取结果
+        List<Map<String, Object> > result = commonService.selectTimeStatValue(params);
+
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
-		for(Map<String, Object> m : result) {
+        for (Map<String, Object> m : result) {
-			for(String k : m.keySet()) {
+            for (String k : m.keySet()) {
-				if(m.get(k) instanceof Date) {
+                if (m.get(k) instanceof Date) {
-					m.put(k, sdf.format((Date)m.get(k)));
+                    m.put(k, sdf.format((Date) m.get(k)));
                 }
             }
         }
+
+        // 返回包含按值统计结果的R对象，结果状态为成功
         return R.ok().put("data", result);
     }
 
-
-
 }

src/main/java/com/controller/WenjuandafuController.java

@@ -1,36 +1,28 @@
 package com.controller;
 
 import java.math.BigDecimal;
-import java.text.SimpleDateFormat;
 import java.text.ParseException;
+import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Calendar;
-import java.util.Map;
+import java.util.Date;
 import java.util.HashMap;
 import java.util.Iterator;
-import java.util.Date;
 import java.util.List;
+import java.util.Map;
 import javax.servlet.http.HttpServletRequest;
-import java.io.IOException;
-
-import com.utils.ValidatorUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.format.annotation.DateTimeFormat;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
-import com.baomidou.mybatisplus.mapper.EntityWrapper;
-import com.baomidou.mybatisplus.mapper.Wrapper;
 import com.annotation.IgnoreAuth;
-
 import com.entity.WenjuandafuEntity;
 import com.entity.view.WenjuandafuView;
-
 import com.service.WenjuandafuService;
 import com.service.TokenService;
 import com.utils.PageUtils;
@@ -40,11 +32,7 @@ import com.utils.MPUtil;
 import com.utils.CommonUtil;
 
 /**
- * 问卷答复
+ * 问卷答复控制器，提供问卷答复的增删改查接口。
- * 后端接口
- * @author 
- * @email 
- * @date 2023-02-21 09:46:06
  */
 @RestController
 @RequestMapping("/wenjuandafu")
@@ -52,66 +40,57 @@ public class WenjuandafuController {
     @Autowired
     private WenjuandafuService wenjuandafuService;
 
-
-
-    
-
-
     /**
-     * 后端列表
+     * 获取问卷答复列表（分页）
+     * @param params 请求参数
+     * @param wenjuandafu 查询条件
+     * @param request HTTP请求对象
+     * @return 包含问卷答复列表的响应结果
      */
     @RequestMapping("/page")
-    public R page(@RequestParam Map<String, Object> params,WenjuandafuEntity wenjuandafu, 
+    public R page(@RequestParam Map<String, Object> params, WenjuandafuEntity wenjuandafu, HttpServletRequest request){
-		HttpServletRequest request){
-
         String tableName = request.getSession().getAttribute("tableName").toString();
         if(tableName.equals("yonghu")) {
             wenjuandafu.setZhanghao((String)request.getSession().getAttribute("username"));
         }
         EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
-
         PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params));
         request.setAttribute("data", page);
         return R.ok().put("data", page);
     }
 
     /**
-     * 前端列表
+     * 获取问卷答复列表（不分页）
+     * @param params 请求参数
+     * @param wenjuandafu 查询条件
+     * @param request HTTP请求对象
+     * @return 包含问卷答复列表的响应结果
      */
     @IgnoreAuth
     @RequestMapping("/list")
-    public R list(@RequestParam Map<String, Object> params,WenjuandafuEntity wenjuandafu, 
+    public R list(@RequestParam Map<String, Object> params, WenjuandafuEntity wenjuandafu, HttpServletRequest request){
-		HttpServletRequest request){
         EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
-
         PageUtils page = wenjuandafuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params));
         request.setAttribute("data", page);
         return R.ok().put("data", page);
     }
 
     /**
-     * 列表
+     * 获取所有问卷答复列表
+     * @param wenjuandafu 查询条件
+     * @return 包含问卷答复列表的响应结果
      */
     @RequestMapping("/lists")
-    public R list( WenjuandafuEntity wenjuandafu){
+    public R lists(WenjuandafuEntity wenjuandafu){
         EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
         ew.allEq(MPUtil.allEQMapPre( wenjuandafu, "wenjuandafu")); 
         return R.ok().put("data", wenjuandafuService.selectListView(ew));
     }
 
     /**
-     * 查询
+     * 查询单个问卷答复信息
-     */
+     * @param id 问卷答复ID
-    @RequestMapping("/query")
+     * @return 包含问卷答复信息的响应结果
-    public R query(WenjuandafuEntity wenjuandafu){
-        EntityWrapper< WenjuandafuEntity> ew = new EntityWrapper< WenjuandafuEntity>();
- 		ew.allEq(MPUtil.allEQMapPre( wenjuandafu, "wenjuandafu")); 
-		WenjuandafuView wenjuandafuView =  wenjuandafuService.selectView(ew);
-		return R.ok("查询问卷答复成功").put("data", wenjuandafuView);
-    }
-	
-    /**
-     * 后端详情
      */
     @RequestMapping("/info/{id}")
     public R info(@PathVariable("id") Long id){
@@ -120,7 +99,9 @@ public class WenjuandafuController {
     }
 
     /**
-     * 前端详情
+     * 前端详情页面显示问卷答复信息
+     * @param id 问卷答复ID
+     * @return 包含问卷答复信息的响应结果
      */
     @IgnoreAuth
     @RequestMapping("/detail/{id}")
@@ -129,49 +110,52 @@ public class WenjuandafuController {
         return R.ok().put("data", wenjuandafu);
     }
 
-
-
-
     /**
-     * 后端保存
+     * 保存问卷答复信息
+     * @param wenjuandafu 问卷答复实体对象
+     * @param request HTTP请求对象
+     * @return 操作结果响应
      */
     @RequestMapping("/save")
     public R save(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){
         wenjuandafu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
-    	//ValidatorUtils.validateEntity(wenjuandafu);
+        //ValidatorUtils.validateEntity(wenjuandafu); // 验证实体对象（注释掉）
-
         wenjuandafuService.insert(wenjuandafu);
         return R.ok();
     }
 
     /**
-     * 前端保存
+     * 前端保存问卷答复信息
+     * @param wenjuandafu 问卷答复实体对象
+     * @param request HTTP请求对象
+     * @return 操作结果响应
      */
     @RequestMapping("/add")
     public R add(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){
         wenjuandafu.setId(new Date().getTime()+new Double(Math.floor(Math.random()*1000)).longValue());
-    	//ValidatorUtils.validateEntity(wenjuandafu);
+        //ValidatorUtils.validateEntity(wenjuandafu); // 验证实体对象（注释掉）
-
         wenjuandafuService.insert(wenjuandafu);
         return R.ok();
     }
 
-
     /**
-     * 修改
+     * 修改问卷答复信息
+     * @param wenjuandafu 问卷答复实体对象
+     * @param request HTTP请求对象
+     * @return 操作结果响应
      */
     @RequestMapping("/update")
     @Transactional
     public R update(@RequestBody WenjuandafuEntity wenjuandafu, HttpServletRequest request){
-        //ValidatorUtils.validateEntity(wenjuandafu);
+        //ValidatorUtils.validateEntity(wenjuandafu); // 验证实体对象（注释掉）
-        wenjuandafuService.updateById(wenjuandafu);//全部更新
+        wenjuandafuService.updateById(wenjuandafu); //更新全部字段
         return R.ok();
     }
 
-    
-
     /**
-     * 删除
+     * 删除问卷答复信息
+     * @param ids 要删除的问卷答复ID数组
+     * @return 操作结果响应
      */
     @RequestMapping("/delete")
     public R delete(@RequestBody Long[] ids){
@@ -181,50 +165,59 @@ public class WenjuandafuController {
 
     /**
      * 提醒接口
+     * @param columnName 列名
+     * @param type 类型（2：日期范围）
+     * @param request HTTP请求对象
+     * @param map 请求参数
+     * @return 符合条件的记录数响应
      */
     @RequestMapping("/remind/{columnName}/{type}")
-	public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request, 
+    public R remindCount(@PathVariable("columnName") String columnName, @PathVariable("type") String type, HttpServletRequest request, @RequestParam Map<String, Object> map) {
-						 @PathVariable("type") String type,@RequestParam Map<String, Object> map) {
         map.put("column", columnName);
         map.put("type", type);
         
-		if(type.equals("2")) {
+        if(type.equals("2")) { // 如果类型是日期范围
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); 
-			Calendar c = Calendar.getInstance();
+            Calendar c = Calendar.getInstance(); // 获取当前日期实例
+            //初始话开始和结束日期
             Date remindStartDate = null; 
             Date remindEndDate = null; 
-			if(map.get("remindstart")!=null) {
+            
-				Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
+            if(map.get("remindstart") != null) { // 如果请求参数中包含开始日期
-				c.setTime(new Date()); 
+                Integer remindStart = Integer.parseInt(map.get("remindstart").toString()); // 获取开始日期天数差值
-				c.add(Calendar.DAY_OF_MONTH,remindStart);
+                c.setTime(new Date()); // 设置当前日期时间
+                c.add(Calendar.DAY_OF_MONTH, remindStart); // 根据天数差值计算开始日期
                 remindStartDate = c.getTime(); 
-				map.put("remindstart", sdf.format(remindStartDate));
+                map.put("remindstart", sdf.format(remindStartDate)); // 将开始日期格式化并放入请求参数中
             }
-			if(map.get("remindend")!=null) {
+            
-				Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
+            if(map.get("remindend") != null) { // 如果请求参数中包含结束日期
-				c.setTime(new Date());
+                Integer remindEnd = Integer.parseInt(map.get("remindend").toString()); // 获取结束日期天数差值
-				c.add(Calendar.DAY_OF_MONTH,remindEnd);
+                c.setTime(new Date()); // 设置当前日期时间
-				remindEndDate = c.getTime();
+                c.add(Calendar.DAY_OF_MONTH, remindEnd); 
-				map.put("remindend", sdf.format(remindEndDate));
+                remindEndDate = c.getTime(); // 获取计算后的结束日期
+                map.put("remindend", sdf.format(remindEndDate)); // 将结束日期格式化并放入请求参数中
             }
         }
         
-		Wrapper<WenjuandafuEntity> wrapper = new EntityWrapper<WenjuandafuEntity>();
+        String tableName = request.getSession().getAttribute("tableName").toString(); // 获取表名
-		if(map.get("remindstart")!=null) {
+        if(tableName.equals("yonghu")) { // 如果表名是用户表
-			wrapper.ge(columnName, map.get("remindstart"));
+            map.put("zhanghao", (String)request.getSession().getAttribute("username")); // 添加用户名到请求参数中作为过滤条件
-		}
-		if(map.get("remindend")!=null) {
-			wrapper.le(columnName, map.get("remindend"));
         }
         
-		String tableName = request.getSession().getAttribute("tableName").toString();
+        Wrapper<WenjuandafuEntity> wrapper = new EntityWrapper<WenjuandafuEntity>(); // 创建查询包装器实例
-		if(tableName.equals("yonghu")) {
+
-			wrapper.eq("zhanghao", (String)request.getSession().getAttribute("username"));
+        if(map.get("remindstart") != null) { 
+            wrapper.ge(columnName, map.get("remindstart")); // 添加大于等于开始日期的条件到查询包装器中
+        }
+        if(map.get("remindend") != null) { 
+            wrapper.le(columnName, map.get("remindend")); 
         }
         
-		int count = wenjuandafuService.selectCount(wrapper);
+        int count = wenjuandafuService.selectCount(wrapper); // 根据查询包装器统计符合条件的记录数
-		return R.ok().put("count", count);
+        return R.ok().put("count", count); // 返回符合条件的记录数响应
     }
+}
 
 	
 
@@ -236,93 +229,135 @@ public class WenjuandafuController {
      * （按值统计）
      */
    @RequestMapping("/value/{xColumnName}/{yColumnName}")
-    public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName,HttpServletRequest request) {
+public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, HttpServletRequest request) {
+    // 创建参数映射，用于存储请求中的列名
     Map<String, Object> params = new HashMap<String, Object>();
     params.put("xColumn", xColumnName);
     params.put("yColumn", yColumnName);
+
+    // 创建实体包装器，用于构建查询条件
     EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
+
+    // 获取当前会话中的表名
     String tableName = request.getSession().getAttribute("tableName").toString();
-        if(tableName.equals("yonghu")) {
+
-            ew.eq("zhanghao", (String)request.getSession().getAttribute("username"));
+    // 如果表名为"yonghu"，则添加用户账号作为查询条件
+    if (tableName.equals("yonghu")) {
+        ew.eq("zhanghao", (String) request.getSession().getAttribute("username"));
     }
+
+    // 调用服务层方法进行数据查询
     List<Map<String, Object>> result = wenjuandafuService.selectValue(params, ew);
+
+    // 格式化日期对象为字符串
     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
-        for(Map<String, Object> m : result) {
+    for (Map<String, Object> m : result) {
-            for(String k : m.keySet()) {
+        for (String k : m.keySet()) {
-                if(m.get(k) instanceof Date) {
+            if (m.get(k) instanceof Date) {
-                    m.put(k, sdf.format((Date)m.get(k)));
+                m.put(k, sdf.format((Date) m.get(k)));
             }
         }
     }
+
+    // 返回封装好的响应结果
     return R.ok().put("data", result);
-    }
+}
 
-    /**
+/**
  * （按值统计）时间统计类型
  */
-    @RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
+@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
-    public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType,HttpServletRequest request) {
+public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) {
+    // 创建参数映射，用于存储请求中的列名和时间统计类型
     Map<String, Object> params = new HashMap<String, Object>();
     params.put("xColumn", xColumnName);
     params.put("yColumn", yColumnName);
     params.put("timeStatType", timeStatType);
+
+    // 创建实体包装器，用于构建查询条件
     EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
+
+    // 获取当前会话中的表名
     String tableName = request.getSession().getAttribute("tableName").toString();
-        if(tableName.equals("yonghu")) {
+
-            ew.eq("zhanghao", (String)request.getSession().getAttribute("username"));
+    // 如果表名为"yonghu"，则添加用户账号作为查询条件
+    if (tableName.equals("yonghu")) {
+        ew.eq("zhanghao", (String) request.getSession().getAttribute("username"));
     }
+
+    // 调用服务层方法进行数据查询
     List<Map<String, Object>> result = wenjuandafuService.selectTimeStatValue(params, ew);
+
+    // 格式化日期对象为字符串
     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
-        for(Map<String, Object> m : result) {
+    for (Map<String, Object> m : result) {
-            for(String k : m.keySet()) {
+        for (String k : m.keySet()) {
-                if(m.get(k) instanceof Date) {
+            if (m.get(k) instanceof Date) {
-                    m.put(k, sdf.format((Date)m.get(k)));
+                m.put(k, sdf.format((Date) m.get(k)));
             }
         }
     }
+
+    // 返回封装好的响应结果
     return R.ok().put("data", result);
-    }
+}
 
-    /**
+/**
  * 分组统计
  */
-    @RequestMapping("/group/{columnName}")
+@RequestMapping("/group/{columnName}")
-    public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) {
+public R group(@PathVariable("columnName") String columnName, HttpServletRequest request) {
+    // 创建参数映射，用于存储请求中的列名
     Map<String, Object> params = new HashMap<String, Object>();
     params.put("column", columnName);
+
+    // 创建实体包装器，用于构建查询条件
     EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
+
+    // 获取当前会话中的表名
     String tableName = request.getSession().getAttribute("tableName").toString();
-        if(tableName.equals("yonghu")) {
+
-            ew.eq("zhanghao", (String)request.getSession().getAttribute("username"));
+    // 如果表名为"yonghu"，则添加用户账号作为查询条件
+    if (tableName.equals("yonghu")) {
+        ew.eq("zhanghao", (String) request.getSession().getAttribute("username"));
     }
+
+    // 调用服务层方法进行数据查询
     List<Map<String, Object>> result = wenjuandafuService.selectGroup(params, ew);
+
+    // 格式化日期对象为字符串
     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
-        for(Map<String, Object> m : result) {
+    for (Map<String, Object> m : result) {
-            for(String k : m.keySet()) {
+        for (String k : m.keySet()) {
-                if(m.get(k) instanceof Date) {
+            if (m.get(k) instanceof Date) {
-                    m.put(k, sdf.format((Date)m.get(k)));
+                m.put(k, sdf.format((Date) m.get(k)));
-                }
             }
         }
-        return R.ok().put("data", result);
     }
 
+    // 返回封装好的响应结果
+    return R.ok().put("data", result);
+}
 
-
+/**
-
-    /**
  * 总数量
  */
-    @RequestMapping("/count")
+@RequestMapping("/count")
-    public R count(@RequestParam Map<String, Object> params,WenjuandafuEntity wenjuandafu, HttpServletRequest request){
+public R count(@RequestParam Map<String, Object> params, WenjuandafuEntity wenjuandafu, HttpServletRequest request) {
+    // 获取当前会话中的表名
     String tableName = request.getSession().getAttribute("tableName").toString();
-        if(tableName.equals("yonghu")) {
+
-            wenjuandafu.setZhanghao((String)request.getSession().getAttribute("username"));
+    // 如果表名为"yonghu"，则添加用户账号作为查询条件
+    if (tableName.equals("yonghu")) {
+        wenjuandafu.setZhanghao((String) request.getSession().getAttribute("username"));
     }
+
+    // 创建实体包装器，用于构建查询条件
     EntityWrapper<WenjuandafuEntity> ew = new EntityWrapper<WenjuandafuEntity>();
-        int count = wenjuandafuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params));
-        return R.ok().put("data", count);
-    }
 
+    // 调用服务层方法进行数据查询并计算总数
+    int count = wenjuandafuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, wenjuandafu), params), params));
 
+    // 返回封装好的响应结果
+    return R.ok().put("data", count);
 }

src/main/java/com/dao/ChatDao.java

@@ -21,9 +21,9 @@ import com.entity.view.ChatView;
  */
 public interface ChatDao extends BaseMapper<ChatEntity> {
 	
-	List<ChatVO> selectListVO(@Param("ew") Wrapper<ChatEntity> wrapper);
+	List<ChatVO> selectListVO(@Param("ew") Wrapper<ChatEntity> wrapper);//根据给定的条件包装器（Wrapper）查询并返回符合条件的ChatVO列表
 	
-	ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);
+	ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);//根据给定的条件包装器（Wrapper）查询并返回符合条件的ChatView列表
 	
 	List<ChatView> selectListView(@Param("ew") Wrapper<ChatEntity> wrapper);
 

src/main/java/com/dao/CommonDao.java

@@ -5,24 +5,69 @@ import java.util.List;
 import java.util.Map;
 
 /**
- * 通用接口
+ * 通用接口，定义了一组用于数据库操作的方法。
+ */
+public interface CommonDao {
+    
+    /**
+     * 根据给定的参数获取选项列表。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个字符串列表，表示查询结果
      */
-public interface CommonDao{
     List<String> getOption(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数获取关注信息。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个包含关注信息的映射
+     */
     Map<String, Object> getFollowByOption(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数获取另一种形式的关注信息列表。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个字符串列表，表示查询结果
+     */
     List<String> getFollowByOption2(Map<String, Object> params);
     
+    /**
+     * 执行某种操作（具体操作未明确）。
+     * @param params 包含操作所需参数的映射
+     */
     void sh(Map<String, Object> params);
     
+    /**
+     * 计算提醒的数量。
+     * @param params 包含查询条件的参数映射
+     * @return 返回提醒的数量
+     */
     int remindCount(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数进行某种计算。
+     * @param params 包含计算所需参数的映射
+     * @return 返回一个包含计算结果的映射
+     */
     Map<String, Object> selectCal(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数分组查询。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个包含分组查询结果的映射列表
+     */
     List<Map<String, Object>> selectGroup(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数查询值。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个包含查询结果的映射列表
+     */
     List<Map<String, Object>> selectValue(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数查询时间统计值。
+     * @param params 包含查询条件的参数映射
+     * @return 返回一个包含时间统计值的映射列表
+     */
     List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params);
 }

src/main/java/com/dao/WenjuandafuDao.java

@@ -1,4 +1,4 @@
-package com.dao;
+ppackage com.dao;
 
 import com.entity.WenjuandafuEntity;
 import com.baomidou.mybatisplus.mapper.BaseMapper;
@@ -11,33 +11,70 @@ import org.apache.ibatis.annotations.Param;
 import com.entity.vo.WenjuandafuVO;
 import com.entity.view.WenjuandafuView;
 
-
 /**
- * 问卷答复
+ * 问卷答复数据访问对象接口
- * 
+ * 提供对问卷答复数据的查询功能
- * @author 
+ * 使用MyBatis-Plus框架进行数据库操作
- * @email 
- * @date 2023-02-21 09:46:06
  */
 public interface WenjuandafuDao extends BaseMapper<WenjuandafuEntity> {
     
+    /**
+     * 根据条件查询问卷答复的VO列表
+     * @param wrapper 查询条件封装器
+     * @return 符合条件的问卷答复VO列表
+     */
     List<WenjuandafuVO> selectListVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
     
+    /**
+     * 根据条件查询单个问卷答复的VO
+     * @param wrapper 查询条件封装器
+     * @return 符合条件的单个问卷答复VO
+     */
     WenjuandafuVO selectVO(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
     
+    /**
+     * 根据条件查询问卷答复的视图列表
+     * @param wrapper 查询条件封装器
+     * @return 符合条件的问卷答复视图列表
+     */
     List<WenjuandafuView> selectListView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
 
+    /**
+     * 根据分页信息和条件查询问卷答复的视图列表
+     * @param page 分页信息
+     * @param wrapper 查询条件封装器
+     * @return 符合条件的问卷答复视图列表（分页）
+     */
     List<WenjuandafuView> selectListView(Pagination page,@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
     
+    /**
+     * 根据条件查询单个问卷答复的视图
+     * @param wrapper 查询条件封装器
+     * @return 符合条件的单个问卷答复视图
+     */
     WenjuandafuView selectView(@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
     
-
+    /**
+     * 根据参数查询问卷答复的值统计结果
+     * @param params 查询参数
+     * @param wrapper 查询条件封装器
+     * @return 值统计结果列表
+     */
     List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
 
+    /**
+     * 根据参数查询问卷答复的时间统计值
+     * @param params 查询参数
+     * @param wrapper 查询条件封装器
+     * @return 时间统计值列表
+     */
     List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
     
+    /**
+     * 根据参数查询问卷答复的分组统计结果
+     * @param params 查询参数
+     * @param wrapper 查询条件封装器
+     * @return 分组统计结果列表
+     */
     List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<WenjuandafuEntity> wrapper);
-
-
-
 }

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

@@ -6,38 +6,37 @@ import java.util.List;
 import java.util.Map;
 import com.baomidou.mybatisplus.mapper.Wrapper;
 import com.baomidou.mybatisplus.plugins.pagination.Pagination;
-
 import org.apache.ibatis.annotations.Param;
 import com.entity.vo.YonghuVO;
 import com.entity.view.YonghuView;
 
-
 /**
- * 用户
+ * 用户数据访问对象接口，继承自MyBatis-Plus的BaseMapper。
- * 
+ * 提供对用户实体（YonghuEntity）的数据库操作方法。
- * @author 
- * @email 
- * @date 2023-02-21 09:46:06
  */
 public interface YonghuDao extends BaseMapper<YonghuEntity> {
     
+    // 根据条件查询用户视图对象列表
     List<YonghuVO> selectListVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
     
+    // 根据条件查询单个用户视图对象
     YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
     
+    // 根据条件查询用户视图对象列表
     List<YonghuView> selectListView(@Param("ew") Wrapper<YonghuEntity> wrapper);
 
-	List<YonghuView> selectListView(Pagination page,@Param("ew") Wrapper<YonghuEntity> wrapper);
+    // 根据分页信息和条件查询用户视图对象列表
+    List<YonghuView> selectListView(Pagination page, @Param("ew") Wrapper<YonghuEntity> wrapper);
     
+    // 根据条件查询单个用户视图对象
     YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper);
     
+    // 根据参数和条件查询值映射列表
+    List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
 
-    List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<YonghuEntity> wrapper);
+    // 根据参数和条件查询时间统计值映射列表
-
+    List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
-    List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<YonghuEntity> wrapper);
-    
-    List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params,@Param("ew") Wrapper<YonghuEntity> wrapper);
-
-
     
+    // 根据参数和条件分组查询映射列表
+    List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
 }

src/main/java/com/entity/model/ChatModel.java

@@ -12,8 +12,6 @@ import java.io.Serializable;
 /**
  * 在线咨询
  * 接收传参的实体类  
- *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） 
- * 取自ModelAndView 的model名称
  * @author 
  * @email 
  * @date 2023-02-21 09:46:06

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

@@ -12,7 +12,6 @@ import java.io.Serializable;
 /**
  * 用户
  * 接收传参的实体类  
- *（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） 
   * 取自ModelAndView 的model名称
  * @author 
  * @email 

src/main/java/com/entity/view/WenjuandafuView.java

@@ -1,36 +1,35 @@
 package com.entity.view;
 
 import com.entity.WenjuandafuEntity;
-
 import com.baomidou.mybatisplus.annotations.TableName;
 import org.apache.commons.beanutils.BeanUtils;
 import java.lang.reflect.InvocationTargetException;
-
 import java.io.Serializable;
 
-
 /**
- * 问卷答复
+ * 问卷答复视图实体类
- * 后端返回视图实体辅助类   
+ * 用于后端返回给前端的问卷答复数据，通常包括关联表的数据或自定义字段。
- * （通常后端关联的表或者自定义的字段需要返回使用）
+ * 继承自 WenjuandafuEntity，实现 Serializable 接口以支持序列化。
- * @author 
- * @email 
- * @date 2023-02-21 09:46:06
  */
 @TableName("wenjuandafu")
 public class WenjuandafuView extends WenjuandafuEntity implements Serializable {
-	private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L; // 序列化版本号
 
-	public WenjuandafuView(){
+    // 无参构造函数
+    public WenjuandafuView() {
     }
 
- 	public WenjuandafuView(WenjuandafuEntity wenjuandafuEntity){
+    /**
+     * 带参构造函数，通过传入的 WenjuandafuEntity 对象来初始化 WenjuandafuView 对象。
+     * @param wenjuandafuEntity 需要复制属性的 WenjuandafuEntity 实例
+     */
+    public WenjuandafuView(WenjuandafuEntity wenjuandafuEntity) {
         try {
+            // 使用 BeanUtils 工具类将 wenjuandafuEntity 的属性值复制到当前对象中
             BeanUtils.copyProperties(this, wenjuandafuEntity);
         } catch (IllegalAccessException | InvocationTargetException e) {
-			// TODO Auto-generated catch block
+            // 捕获并打印异常信息
             e.printStackTrace();
         }
- 		
     }
 }

src/main/java/com/service/ChatService.java

@@ -10,9 +10,9 @@ import com.entity.vo.ChatVO;
 import org.apache.ibatis.annotations.Param;
 import com.entity.view.ChatView;
 
-
 /**
- * 在线咨询
+ * 在线咨询服务接口，提供对在线咨询相关数据的操作方法。
+ * 继承自 IService<ChatEntity>，利用 MyBatis-Plus 提供的通用 CRUD 操作。
  * 
  * @author 
  * @email 
@@ -20,18 +20,52 @@ import com.entity.view.ChatView;
  */
 public interface ChatService extends IService<ChatEntity> {
 
+    /**
+     * 根据参数查询分页信息。
+     * 
+     * @param params 包含查询条件的参数集合。
+     * @return 返回封装了分页信息的 PageUtils 对象。
+     */
     PageUtils queryPage(Map<String, Object> params);
     
+    /**
+     * 根据条件查询视图对象列表。
+     * 
+     * @param wrapper 查询条件包装器。
+     * @return 返回符合条件的视图对象列表。
+     */
     List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper);
     
+    /**
+     * 根据条件查询单个视图对象。
+     * 
+     * @param wrapper 查询条件包装器。
+     * @return 返回符合条件的单个视图对象。
+     */
     ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);
     
+    /**
+     * 根据条件查询视图对象列表。
+     * 
+     * @param wrapper 查询条件包装器。
+     * @return 返回符合条件的视图对象列表。
+     */
     List<ChatView> selectListView(Wrapper<ChatEntity> wrapper);
     
+    /**
+     * 根据条件查询单个视图对象。
+     * 
+     * @param wrapper 查询条件包装器。
+     * @return 返回符合条件的单个视图对象。
+     */
     ChatView selectView(@Param("ew") Wrapper<ChatEntity> wrapper);
     
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<ChatEntity> wrapper);
+    /**
-   	
+     * 根据参数和条件查询分页信息。
-
+     * 
+     * @param params 包含查询条件的参数集合。
+     * @param wrapper 查询条件包装器。
+     * @return 返回封装了分页信息的 PageUtils 对象。
+     */
+    PageUtils queryPage(Map<String, Object> params, Wrapper<ChatEntity> wrapper);
 }
-

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

@@ -3,20 +3,63 @@ package com.service;
 import java.util.List;
 import java.util.Map;
 
+/**
+ * CommonService 接口定义了一组通用的服务方法，用于处理各种数据操作。
+ */
 public interface CommonService {
+    
+    /**
+     * 根据给定的参数获取选项列表。
+     * @param params 包含查询条件的参数集合。
+     * @return 返回一个字符串列表，表示选项。
+     */
     List<String> getOption(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数获取关注信息。
+     * @param params 包含查询条件的参数集合。
+     * @return 返回一个包含关注信息的映射。
+     */
     Map<String, Object> getFollowByOption(Map<String, Object> params);
     
+    /**
+     * 执行某种操作（具体操作未明确）。
+     * @param params 包含操作所需参数的映射。
+     */
     void sh(Map<String, Object> params);
     
+    /**
+     * 计算提醒的数量。
+     * @param params 包含查询条件的参数集合。
+     * @return 返回提醒的数量。
+     */
     int remindCount(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数选择并计算某些值。
+     * @param params 包含查询条件的参数集合。
+     * @return 返回一个包含计算结果的映射。
+     */
     Map<String, Object> selectCal(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数选择分组信息。
+     * @param params 包含查询条件的参数集合。
+     * @return 返回一个包含分组信息的列表，每个元素是一个映射。
+     */
     List<Map<String, Object>> selectGroup(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数选择值信息。
+     * @param params 包含查询条件的参数集合。
+     * @return 返回一个包含值信息的列表，每个元素是一个映射。
+     */
     List<Map<String, Object>> selectValue(Map<String, Object> params);
     
+    /**
+     * 根据给定的参数选择时间统计值信息。
+     * @param params 包含查询条件的参数集合。
+     * @return 返回一个包含时间统计值信息的列表，每个元素是一个映射。
+     */
     List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params);
 }

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

@@ -10,9 +10,10 @@ import com.entity.vo.YonghuVO;
 import org.apache.ibatis.annotations.Param;
 import com.entity.view.YonghuView;
 
-
 /**
- * 用户
+ * 用户服务接口，定义了对用户实体进行操作的方法。
+ * 继承自 IService<YonghuEntity>，提供基本的 CRUD 操作。
+ * 包含分页查询、条件查询、视图对象查询等方法。
  * 
  * @author 
  * @email 
@@ -20,26 +21,79 @@ import com.entity.view.YonghuView;
  */
 public interface YonghuService extends IService<YonghuEntity> {
 
+    /**
+     * 根据参数查询分页信息。
+     * 
+     * @param params 包含查询条件的参数集合。
+     * @return 返回封装了分页信息的 PageUtils 对象。
+     */
     PageUtils queryPage(Map<String, Object> params);
     
+    /**
+     * 根据条件查询视图对象列表。
+     * 
+     * @param wrapper 查询条件包装器。
+     * @return 返回符合条件的视图对象列表。
+     */
     List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper);
     
+    /**
+     * 根据条件查询单个视图对象。
+     * 
+     * @param wrapper 查询条件包装器。
+     * @return 返回符合条件的单个视图对象。
+     */
     YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
     
+    /**
+     * 根据条件查询视图对象列表。
+     * 
+     * @param wrapper 查询条件包装器。
+     * @return 返回符合条件的视图对象列表。
+     */
     List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper);
     
+    /**
+     * 根据条件查询单个视图对象。
+     * 
+     * @param wrapper 查询条件包装器。
+     * @return 返回符合条件的单个视图对象。
+     */
     YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper);
     
-   	PageUtils queryPage(Map<String, Object> params,Wrapper<YonghuEntity> wrapper);
+    /**
-   	
+     * 根据参数和条件查询分页信息。
-
+     * 
-    List<Map<String, Object>> selectValue(Map<String, Object> params,Wrapper<YonghuEntity> wrapper);
+     * @param params 包含查询条件的参数集合。
-
+     * @param wrapper 查询条件包装器。
-    List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params,Wrapper<YonghuEntity> wrapper);
+     * @return 返回封装了分页信息的 PageUtils 对象。
-    
+     */
-    List<Map<String, Object>> selectGroup(Map<String, Object> params,Wrapper<YonghuEntity> wrapper);
+    PageUtils queryPage(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
     
+    /**
+     * 根据参数和条件选择值信息。
+     * 
+     * @param params 包含查询条件的参数集合。
+     * @param wrapper 查询条件包装器。
+     * @return 返回一个包含值信息的列表，每个元素是一个映射。
+     */
+    List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
     
+    /**
+     * 根据参数和条件选择时间统计值信息。
+     * 
+     * @param params 包含查询条件的参数集合。
+     * @param wrapper 查询条件包装器。
+     * @return 返回一个包含时间统计值信息的列表，每个元素是一个映射。
+     */
+    List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
     
+    /**
+     * 根据参数和条件选择分组信息。
+     * 
+     * @param params 包含查询条件的参数集合。
+     * @param wrapper 查询条件包装器。
+     * @return 返回一个包含分组信息的列表，每个元素是一个映射。
+     */
+    List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
 }
-

src/main/java/com/service/impl/ChatServiceImpl.java

@@ -11,7 +11,6 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl;
 import com.utils.PageUtils;
 import com.utils.Query;
 
-
 import com.dao.ChatDao;
 import com.entity.ChatEntity;
 import com.service.ChatService;
@@ -21,43 +20,81 @@ import com.entity.view.ChatView;
 @Service("chatService")
 public class ChatServiceImpl extends ServiceImpl<ChatDao, ChatEntity> implements ChatService {
 
-
+    /**
+     * 分页查询方法，返回分页后的ChatEntity数据。
+     * @param params 包含分页参数的Map对象
+     * @return 封装了分页信息的PageUtils对象
+     */
     @Override
     public PageUtils queryPage(Map<String, Object> params) {
+        // 使用Query类获取分页信息，并调用selectPage方法进行数据库查询
         Page<ChatEntity> page = this.selectPage(
                 new Query<ChatEntity>(params).getPage(),
                 new EntityWrapper<ChatEntity>()
         );
+        // 将查询结果封装到PageUtils对象中并返回
         return new PageUtils(page);
     }
     
+    /**
+     * 分页查询方法，返回分页后的ChatView数据。
+     * @param params 包含分页参数的Map对象
+     * @param wrapper 查询条件包装器
+     * @return 封装了分页信息的PageUtils对象
+     */
+	// 使用Query类获取分页信息，调用自定义的selectListView方法进行数据库查询，并将结果设置到page对象中
     @Override
     public PageUtils queryPage(Map<String, Object> params, Wrapper<ChatEntity> wrapper) {
-		  Page<ChatView> page =new Query<ChatView>(params).getPage();
+        
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+        Page<ChatView> page = new Query<ChatView>(params).getPage();
+        
+        page.setRecords(baseMapper.selectListView(page, wrapper));
+        // 将查询结果封装到PageUtils对象中并返回
         PageUtils pageUtil = new PageUtils(page);
         return pageUtil;
     }
     
+    /**
+     * 根据条件查询ChatVO列表。
+     * @param wrapper 查询条件包装器
+     * @return 符合条件的ChatVO列表
+     */
     @Override
     public List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper) {
+        // 调用自定义的selectListVO方法进行数据库查询并返回结果
         return baseMapper.selectListVO(wrapper);
     }
     
+    /**
+     * 根据条件查询单个ChatVO对象。
+     * @param wrapper 查询条件包装器
+     * @return 符合条件的单个ChatVO对象
+     */
     @Override
     public ChatVO selectVO(Wrapper<ChatEntity> wrapper) {
+        // 调用自定义的selectVO方法进行数据库查询并返回结果
         return baseMapper.selectVO(wrapper);
     }
     
+    /**
+     * @param wrapper 查询条件包装器
+     * @return 符合条件的ChatView列表
+     */
+	// 调用自定义的selectListView方法进行数据库查询并返回结果
     @Override
     public List<ChatView> selectListView(Wrapper<ChatEntity> wrapper) {
+        
         return baseMapper.selectListView(wrapper);
     }
 
+    /**
+     * 根据条件查询单个ChatView对象。
+     * @param wrapper 查询条件包装器
+     * @return 符合条件的单个ChatView对象
+     */
     @Override
     public ChatView selectView(Wrapper<ChatEntity> wrapper) {
+        // 调用自定义的selectView方法进行数据库查询并返回结果
         return baseMapper.selectView(wrapper);
     }
-
-
 }

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

@@ -1,7 +1,5 @@
-
 package com.service.impl;
 
-
 import java.util.List;
 import java.util.Map;
 
@@ -11,54 +9,53 @@ import org.springframework.stereotype.Service;
 import com.dao.CommonDao;
 import com.service.CommonService;
 
-
 /**
- * 系统用户
+ * 系统用户服务实现类
  */
 @Service("commonService")
 public class CommonServiceImpl implements CommonService {
 	
 	@Autowired
-	private CommonDao commonDao;
+	private CommonDao commonDao; // 自动注入数据访问对象
 
 	@Override
 	public List<String> getOption(Map<String, Object> params) {
-		return commonDao.getOption(params);
+		return commonDao.getOption(params); // 获取选项列表
 	}
 	
 	@Override
 	public Map<String, Object> getFollowByOption(Map<String, Object> params) {
-		return commonDao.getFollowByOption(params);
+		return commonDao.getFollowByOption(params); // 根据选项获取关注信息
 	}
 	
 	@Override
 	public void sh(Map<String, Object> params) {
-		commonDao.sh(params); 
+		commonDao.sh(params); // 执行某种操作（具体操作未明）
 	}
 
 	@Override
 	public int remindCount(Map<String, Object> params) {
-		return commonDao.remindCount(params);
+		return commonDao.remindCount(params); // 获取提醒数量
 	}
 
 	@Override
 	public Map<String, Object> selectCal(Map<String, Object> params) {
-		return commonDao.selectCal(params);
+		return commonDao.selectCal(params); // 选择并计算某些值
 	}
 	
 	@Override
 	public List<Map<String, Object>> selectGroup(Map<String, Object> params) {
-		return commonDao.selectGroup(params);
+		return commonDao.selectGroup(params); // 按组选择数据
 	}
 	
 	@Override
 	public List<Map<String, Object>> selectValue(Map<String, Object> params) {
-		return commonDao.selectValue(params);
+		return commonDao.selectValue(params); // 选择特定值
 	}
 
 	@Override
 	public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params) {
-		return commonDao.selectTimeStatValue(params);
+		return commonDao.selectTimeStatValue(params); // 选择并统计时间相关的值
 	}
 
 }

src/main/java/com/service/impl/WenjuandafuServiceImpl.java

@@ -11,7 +11,6 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl;
 import com.utils.PageUtils;
 import com.utils.Query;
 
-
 import com.dao.WenjuandafuDao;
 import com.entity.WenjuandafuEntity;
 import com.service.WenjuandafuService;
@@ -21,7 +20,11 @@ import com.entity.view.WenjuandafuView;
 @Service("wenjuandafuService")
 public class WenjuandafuServiceImpl extends ServiceImpl<WenjuandafuDao, WenjuandafuEntity> implements WenjuandafuService {
 
-
+    /**
+     * 分页查询问卷答复数据
+     * @param params 查询参数
+     * @return 分页结果封装在 PageUtils 对象中
+     */
     @Override
     public PageUtils queryPage(Map<String, Object> params) {
         Page<WenjuandafuEntity> page = this.selectPage(
@@ -31,50 +34,90 @@ public class WenjuandafuServiceImpl extends ServiceImpl<WenjuandafuDao, Wenjuand
         return new PageUtils(page);
     }
     
+    /**
+     * 分页查询问卷答复视图数据，带查询条件封装器
+     * @param params 查询参数
+     * @param wrapper 查询条件封装器
+     * @return 分页结果封装在 PageUtils 对象中
+     */
     @Override
     public PageUtils queryPage(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper) {
-		  Page<WenjuandafuView> page =new Query<WenjuandafuView>(params).getPage();
+        Page<WenjuandafuView> page = new Query<WenjuandafuView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+        page.setRecords(baseMapper.selectListView(page, wrapper));
         PageUtils pageUtil = new PageUtils(page);
         return pageUtil;
     }
     
+    /**
+     * 根据条件查询问卷答复的视图列表
+     * @param wrapper 查询条件封装器
+     * @return 符合条件的问卷答复视图列表
+     */
     @Override
     public List<WenjuandafuVO> selectListVO(Wrapper<WenjuandafuEntity> wrapper) {
         return baseMapper.selectListVO(wrapper);
     }
     
+    /**
+     * 根据条件查询单个问卷答复的视图
+     * @param wrapper 查询条件封装器
+     * @return 符合条件的单个问卷答复视图
+     */
     @Override
     public WenjuandafuVO selectVO(Wrapper<WenjuandafuEntity> wrapper) {
         return baseMapper.selectVO(wrapper);
     }
     
+    /**
+     * 根据条件查询问卷答复的视图列表（分页）
+     * @param wrapper 查询条件封装器
+     * @return 符合条件的问卷答复视图列表（分页）
+     */
     @Override
     public List<WenjuandafuView> selectListView(Wrapper<WenjuandafuEntity> wrapper) {
         return baseMapper.selectListView(wrapper);
     }
 
+    /**
+     * 根据条件查询单个问卷答复的视图（分页）
+     * @param wrapper 查询条件封装器
+     * @return 符合条件的单个问卷答复视图（分页）
+     */
     @Override
     public WenjuandafuView selectView(Wrapper<WenjuandafuEntity> wrapper) {
         return baseMapper.selectView(wrapper);
     }
 
+    /**
+     * 根据查询参数和条件封装器获取值统计结果
+     * @param params 查询参数
+     * @param wrapper 查询条件封装器
+     * @return 值统计结果列表
+     */
     @Override
     public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper) {
         return baseMapper.selectValue(params, wrapper);
     }
 
+    /**
+     * 根据查询参数和条件封装器获取时间统计值结果
+     * @param params 查询参数
+     * @param wrapper 查询条件封装器
+     * @return 时间统计值结果列表
+     */
     @Override
     public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper) {
         return baseMapper.selectTimeStatValue(params, wrapper);
     }
     
+    /**
+     * 根据查询参数和条件封装器获取分组统计结果
+     * @param params 查询参数
+     * @param wrapper 查询条件封装器
+     * @return 分组统计结果列表
+     */
     @Override
     public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<WenjuandafuEntity> wrapper) {
         return baseMapper.selectGroup(params, wrapper);
     }
-
-
-
-
 }

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

@@ -11,7 +11,6 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl;
 import com.utils.PageUtils;
 import com.utils.Query;
 
-
 import com.dao.YonghuDao;
 import com.entity.YonghuEntity;
 import com.service.YonghuService;
@@ -21,7 +20,7 @@ import com.entity.view.YonghuView;
 @Service("yonghuService")
 public class YonghuServiceImpl extends ServiceImpl<YonghuDao, YonghuEntity> implements YonghuService {
 
-
+    // 分页查询用户信息
     @Override
     public PageUtils queryPage(Map<String, Object> params) {
         Page<YonghuEntity> page = this.selectPage(
@@ -31,50 +30,54 @@ public class YonghuServiceImpl extends ServiceImpl<YonghuDao, YonghuEntity> impl
         return new PageUtils(page);
     }
     
+    // 分页查询用户视图信息
     @Override
     public PageUtils queryPage(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
-		  Page<YonghuView> page =new Query<YonghuView>(params).getPage();
+        Page<YonghuView> page = new Query<YonghuView>(params).getPage();
-	        page.setRecords(baseMapper.selectListView(page,wrapper));
+        page.setRecords(baseMapper.selectListView(page, wrapper));
         PageUtils pageUtil = new PageUtils(page);
         return pageUtil;
     }
     
+    // 查询用户值对象列表
     @Override
     public List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper) {
         return baseMapper.selectListVO(wrapper);
     }
     
+    // 查询单个用户值对象
     @Override
     public YonghuVO selectVO(Wrapper<YonghuEntity> wrapper) {
         return baseMapper.selectVO(wrapper);
     }
     
+    // 查询用户视图列表
     @Override
     public List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper) {
         return baseMapper.selectListView(wrapper);
     }
 
+    // 查询单个用户视图
     @Override
     public YonghuView selectView(Wrapper<YonghuEntity> wrapper) {
         return baseMapper.selectView(wrapper);
     }
 
+    // 根据条件查询特定值
     @Override
     public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
         return baseMapper.selectValue(params, wrapper);
     }
 
+    // 根据条件查询时间统计值
     @Override
     public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
         return baseMapper.selectTimeStatValue(params, wrapper);
     }
     
+    // 根据条件分组查询数据
     @Override
     public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
         return baseMapper.selectGroup(params, wrapper);
     }
-
-
-
-
 }

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

@@ -135,11 +135,11 @@ public class BaiduUtil {
         if(jsonObject == null){
             return "";
         }
-        
+        // 检查 JSON 对象中是否包含 "words_result" 和 "words_result_num" 键
         if(jsonObject.has("words_result") && jsonObject.has("words_result_num")){
             int wordsResultNum = jsonObject.getInt("words_result_num");
             if(wordsResultNum > 0){
-                StringBuilder sb = new StringBuilder();
+                StringBuilder sb = new StringBuilder();// 用于拼接字符串
                 
                 JSONArray jsonArray = jsonObject.getJSONArray("words_result");
                 int len = jsonArray.length();
@@ -193,4 +193,7 @@ public class BaiduUtil {
         return res;
     }
 
+
+    
+
 }

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

@@ -5,38 +5,45 @@ import java.io.InputStreamReader;
 import java.net.HttpURLConnection;
 import java.net.URL;
 
-
 /**
  * HttpClient工具类
  */
 public class HttpClientUtils {
 
     /**
-     * @param uri
+     * 发送GET请求并返回响应内容
-     * @return String
+     * @param uri 请求的URL地址
-     * @description get请求方式
+     * @return 响应内容的字符串形式
+     * @description 使用GET方法发送HTTP请求
      * @author: long.he01
      */
     public static String doGet(String uri) {
-
+        // 用于存储响应结果的StringBuilder对象
         StringBuilder result = new StringBuilder();
         try {
+            // 初始化一个空字符串用于存储每一行读取的内容
             String res = "";
+            // 创建URL对象
             URL url = new URL(uri);
+            // 打开连接
             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+            // 设置请求方法为GET
+            conn.setRequestMethod("GET");
+            // 获取输入流并包装成BufferedReader
             BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
             String line;
+            // 逐行读取响应内容
             while ((line = in.readLine()) != null) {
-                res += line+"\n";
+                res += line + "\n"; 
-            }
+            // 关闭BufferedReader
             in.close();
+            // 返回完整的响应内容
             return res;
-        }catch (Exception e) {
+        } catch (Exception e) {
+            // 捕获异常并打印堆栈信息
             e.printStackTrace();
+           
             return null;
         }
-
     }
-
 }
-

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

@@ -1,54 +1,68 @@
 package com.utils;
 
-public class JQPageInfo{
+public class JQPageInfo {
+    // 当前页码
     private Integer page;
     
+    // 每页显示的记录数
     private Integer limit;
     
+    // 排序字段
     private String sidx;
     
+    // 排序方式（升序或降序）
     private String order;
     
+    // 偏移量，用于计算分页查询时的起始位置
     private Integer offset;
 
+    // 获取当前页码
     public Integer getPage() {
         return page;
     }
 
+    // 设置当前页码
     public void setPage(Integer page) {
         this.page = page;
     }
 
+    // 获取每页显示的记录数
     public Integer getLimit() {
         return limit;
     }
 
+    // 设置每页显示的记录数
     public void setLimit(Integer limit) {
         this.limit = limit;
     }
 
+    // 获取排序字段
     public String getSidx() {
         return sidx;
     }
 
+    // 设置排序字段
     public void setSidx(String sidx) {
         this.sidx = sidx;
     }
     
+    // 获取排序方式
     public String getOrder() {
         return order;
     }
 
+    // 设置排序方式
     public void setOrder(String order) {
         this.order = order;
     }
 
+    // 获取偏移量
     public Integer getOffset() {
         return offset;
     }
 
+    // 设置偏移量
     public void setOffset(Integer offset) {
         this.offset = offset;
     }
-	
 }

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

@@ -17,37 +17,37 @@ import com.baomidou.mybatisplus.mapper.Wrapper;
 public class MPUtil {
     public static final char UNDERLINE = '_';
 
-	
+    // mybatis plus allEQ 表达式转换，带前缀
-	//mybatis plus allEQ 表达式转换
+    public static Map allEQMapPre(Object bean, String pre) {
-		public static Map allEQMapPre(Object bean,String pre) {
+        Map<String, Object> map = BeanUtil.beanToMap(bean);
-		   Map<String, Object> map =BeanUtil.beanToMap(bean);
+        return camelToUnderlineMap(map, pre);
-		  return camelToUnderlineMap(map,pre);
     }
 
-		//mybatis plus allEQ 表达式转换
+    // mybatis plus allEQ 表达式转换，不带前缀
     public static Map allEQMap(Object bean) {
-		   Map<String, Object> map =BeanUtil.beanToMap(bean);
+        Map<String, Object> map = BeanUtil.beanToMap(bean);
-		   return camelToUnderlineMap(map,"");
+        return camelToUnderlineMap(map, "");
     }
 
-		public static Wrapper allLikePre(Wrapper wrapper,Object bean,String pre) {
+    // mybatis plus allLike 表达式转换，带前缀
-			   Map<String, Object> map =BeanUtil.beanToMap(bean);
+    public static Wrapper allLikePre(Wrapper wrapper, Object bean, String pre) {
-			   Map result = camelToUnderlineMap(map,pre);
+        Map<String, Object> map = BeanUtil.beanToMap(bean);
-			 
+        Map result = camelToUnderlineMap(map, pre);
-			return genLike(wrapper,result);
+        return genLike(wrapper, result);
     }
 
-		public static Wrapper allLike(Wrapper wrapper,Object bean) {
+    // mybatis plus allLike 表达式转换，不带前缀
+    public static Wrapper allLike(Wrapper wrapper, Object bean) {
         Map result = BeanUtil.beanToMap(bean, true, true);
-			return genLike(wrapper,result);
+        return genLike(wrapper, result);
     }
 
-	
+    // 生成LIKE查询条件
-		public static Wrapper genLike( Wrapper wrapper,Map param) {
+    public static Wrapper genLike(Wrapper wrapper, Map param) {
         Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
-			int i=0;
+        int i = 0;
         while (it.hasNext()) {
-				if(i>0) wrapper.and();
+            if (i > 0) wrapper.and();
             Map.Entry<String, Object> entry = it.next();
             String key = entry.getKey();
             String value = (String) entry.getValue();
@@ -57,19 +57,21 @@ public class MPUtil {
         return wrapper;
     }
 
-		public static Wrapper likeOrEq(Wrapper wrapper,Object bean) {
+    // 生成LIKE或EQ查询条件
+    public static Wrapper likeOrEq(Wrapper wrapper, Object bean) {
         Map result = BeanUtil.beanToMap(bean, true, true);
-			return genLikeOrEq(wrapper,result);
+        return genLikeOrEq(wrapper, result);
     }
 
-		public static Wrapper genLikeOrEq( Wrapper wrapper,Map param) {
+    // 生成LIKE或EQ查询条件的具体实现
+    public static Wrapper genLikeOrEq(Wrapper wrapper, Map param) {
         Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
-			int i=0;
+        int i = 0;
         while (it.hasNext()) {
-				if(i>0) wrapper.and();
+            if (i > 0) wrapper.and();
             Map.Entry<String, Object> entry = it.next();
             String key = entry.getKey();
-				if(entry.getValue().toString().contains("%")) {
+            if (entry.getValue().toString().contains("%")) {
                 wrapper.like(key, entry.getValue().toString().replace("%", ""));
             } else {
                 wrapper.eq(key, entry.getValue());
@@ -79,17 +81,18 @@ public class MPUtil {
         return wrapper;
     }
 
-		public static Wrapper allEq(Wrapper wrapper,Object bean) {
+    // 生成EQ查询条件
+    public static Wrapper allEq(Wrapper wrapper, Object bean) {
         Map result = BeanUtil.beanToMap(bean, true, true);
-			return genEq(wrapper,result);
+        return genEq(wrapper, result);
     }
 
-	
+    // 生成EQ查询条件的具体实现
-		public static Wrapper genEq( Wrapper wrapper,Map param) {
+    public static Wrapper genEq(Wrapper wrapper, Map param) {
         Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
-			int i=0;
+        int i = 0;
         while (it.hasNext()) {
-				if(i>0) wrapper.and();
+            if (i > 0) wrapper.and();
             Map.Entry<String, Object> entry = it.next();
             String key = entry.getKey();
             wrapper.eq(key, entry.getValue());
@@ -98,19 +101,19 @@ public class MPUtil {
         return wrapper;
     }
 
-	
+    // 生成BETWEEN查询条件
-		public static Wrapper between(Wrapper wrapper,Map<String, Object> params) {
+    public static Wrapper between(Wrapper wrapper, Map<String, Object> params) {
-			for(String key : params.keySet()) {
+        for (String key : params.keySet()) {
             String columnName = "";
-				if(key.endsWith("_start")) {
+            if (key.endsWith("_start")) {
                 columnName = key.substring(0, key.indexOf("_start"));
-					if(StringUtils.isNotBlank(params.get(key).toString())) {
+                if (StringUtils.isNotBlank(params.get(key).toString())) {
                     wrapper.ge(columnName, params.get(key));
                 }
             }
-				if(key.endsWith("_end")) {
+            if (key.endsWith("_end")) {
                 columnName = key.substring(0, key.indexOf("_end"));
-					if(StringUtils.isNotBlank(params.get(key).toString())) {
+                if (StringUtils.isNotBlank(params.get(key).toString())) {
                     wrapper.le(columnName, params.get(key));
                 }
             }
@@ -118,13 +121,14 @@ public class MPUtil {
         return wrapper;
     }
 
-		public static Wrapper sort(Wrapper wrapper,Map<String, Object> params) {
+    // 生成排序查询条件
+    public static Wrapper sort(Wrapper wrapper, Map<String, Object> params) {
         String order = "";
-			if(params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {
+        if (params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {
             order = params.get("order").toString();
         }
-			if(params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) {
+        if (params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) {
-				if(order.equalsIgnoreCase("desc")) {
+            if (order.equalsIgnoreCase("desc")) {
                 wrapper.orderDesc(Arrays.asList(params.get("sort")));
             } else {
                 wrapper.orderAsc(Arrays.asList(params.get("sort")));
@@ -133,13 +137,7 @@ public class MPUtil {
         return wrapper;
     }
 
-	
+    // 驼峰格式字符串转换为下划线格式字符串
-	/**
-	 * 驼峰格式字符串转换为下划线格式字符串
-	 * 
-	 * @param param
-	 * @return
-	 */
     public static String camelToUnderline(String param) {
         if (param == null || "".equals(param.trim())) {
             return "";
@@ -159,12 +157,12 @@ public class MPUtil {
     }
 
     public static void main(String[] ages) {
-		System.out.println(camelToUnderline("ABCddfANM"));
+        System.out.println(camelToUnderline("ABCddfANM")); // 输出：a_b_cddf_anm
     }
 
+    // 将驼峰格式的Map键转换为下划线格式，并添加前缀（如果有）
     public static Map camelToUnderlineMap(Map param, String pre) {
-
+        Map<String, Object> newMap = new HashMap<>();
-		Map<String, Object> newMap = new HashMap<String, Object>();
         Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
         while (it.hasNext()) {
             Map.Entry<String, Object> entry = it.next();
@@ -175,7 +173,6 @@ public class MPUtil {
             } else if (StringUtils.isEmpty(pre)) {
                 newMap.put(newKey, entry.getValue());
             } else {
-
                 newMap.put(pre + "." + newKey, entry.getValue());
             }
         }

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

@@ -1,4 +1,3 @@
-
 package com.utils;
 
 import java.io.Serializable;
@@ -8,23 +7,23 @@ import java.util.Map;
 import com.baomidou.mybatisplus.plugins.Page;
 
 /**
- * 分页工具类
+ * 分页工具类，用于处理分页相关的数据和操作。
  */
 public class PageUtils implements Serializable {
-	private static final long serialVersionUID = 1L;
+	private static final long serialVersionUID = 1L; // 序列化版本号
-	//总记录数
+	// 总记录数
 	private long total;
-	//每页记录数
+	// 每页记录数
 	private int pageSize;
-	//总页数
+	// 总页数
 	private long totalPage;
-	//当前页数
+	// 当前页数
 	private int currPage;
-	//列表数据
+	// 列表数据
 	private List<?> list;
 	
 	/**
-	 * 分页
+	 * 构造函数，通过传入的列表数据、总记录数、每页记录数和当前页数进行初始化。
 	 * @param list        列表数据
 	 * @param totalCount  总记录数
 	 * @param pageSize    每页记录数
@@ -35,29 +34,31 @@ public class PageUtils implements Serializable {
 		this.total = totalCount;
 		this.pageSize = pageSize;
 		this.currPage = currPage;
-		this.totalPage = (int)Math.ceil((double)totalCount/pageSize);
+		this.totalPage = (int)Math.ceil((double)totalCount/pageSize); // 计算总页数
 	}
 
 	/**
-	 * 分页
+	 * 构造函数，通过MyBatis Plus的Page对象进行初始化。
+	 * @param page MyBatis Plus的Page对象
 	 */
 	public PageUtils(Page<?> page) {
-		this.list = page.getRecords();
+		this.list = page.getRecords(); // 获取当前页的数据列表
-		this.total = page.getTotal();
+		this.total = page.getTotal(); // 获取总记录数
-		this.pageSize = page.getSize();
+		this.pageSize = page.getSize(); // 获取每页记录数
-		this.currPage = page.getCurrent();
+		this.currPage = page.getCurrent(); // 获取当前页码
-		this.totalPage = page.getPages();
+		this.totalPage = page.getPages(); // 获取总页数
 	}
 	
-	/*
+	/**
-	 * 空数据的分页
+	 * 构造函数，通过传入的参数Map进行初始化。
+	 * @param params 包含分页参数的Map对象
 	 */
 	public PageUtils(Map<String, Object> params) {
- 		Page page =new Query(params).getPage();
+ 		Page page =new Query(params).getPage(); // 根据参数创建Page对象
-		new PageUtils(page);
+		new PageUtils(page); // 调用另一个构造函数进行初始化
 	}
 
-	 
+	// Getter和Setter方法
 	public int getPageSize() {
 		return pageSize;
 	}
@@ -97,5 +98,4 @@ public class PageUtils implements Serializable {
 	public void setTotal(long total) {
 		this.total = total;
 	}
-	
 }

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

@@ -1,4 +1,3 @@
-
 package com.utils;
 
 import java.util.LinkedHashMap;
@@ -9,89 +8,103 @@ import org.apache.commons.lang3.StringUtils;
 import com.baomidou.mybatisplus.plugins.Page;
 
 /**
- * 查询参数
+ * 查询参数类，用于封装分页和排序信息
  */
 public class Query<T> extends LinkedHashMap<String, Object> {
     private static final long serialVersionUID = 1L;
-    /**
+    
-     * mybatis-plus分页参数
+    // mybatis-plus分页参数
-     */
     private Page<T> page;
-    /**
+    
-     * 当前页码
+    // 当前页码
-     */
     private int currPage = 1;
-    /**
+    
-     * 每页条数
+    // 每页条数
-     */
     private int limit = 10;
 
+    /**
+     * 构造函数，使用JQPageInfo对象初始化查询参数
+     * @param pageInfo 包含分页和排序信息的JQPageInfo对象
+     */
     public Query(JQPageInfo pageInfo) {
-    	//分页参数
+        // 设置分页参数
-        if(pageInfo.getPage()!= null){
+        if (pageInfo.getPage() != null) {
             currPage = pageInfo.getPage();
         }
-        if(pageInfo.getLimit()!= null){
+        if (pageInfo.getLimit() != null) {
             limit = pageInfo.getLimit();
         }
 
-    
+        // 防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
-        //防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
         String sidx = SQLFilter.sqlInject(pageInfo.getSidx());
         String order = SQLFilter.sqlInject(pageInfo.getOrder());
         
-
+        // mybatis-plus分页
-        //mybatis-plus分页
         this.page = new Page<>(currPage, limit);
 
-        //排序
+        // 设置排序字段和顺序
-        if(StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)){
+        if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) {
             this.page.setOrderByField(sidx);
             this.page.setAsc("ASC".equalsIgnoreCase(order));
         }
     }
     
-    
+    /**
-    public Query(Map<String, Object> params){
+     * 构造函数，使用Map对象初始化查询参数
+     * @param params 包含分页和排序信息的Map对象
+     */
+    public Query(Map<String, Object> params) {
         this.putAll(params);
 
-        //分页参数
+        // 设置分页参数
-        if(params.get("page") != null){
+        if (params.get("page") != null) {
-            currPage = Integer.parseInt((String)params.get("page"));
+            currPage = Integer.parseInt((String) params.get("page"));
         }
-        if(params.get("limit") != null){
+        if (params.get("limit") != null) {
-            limit = Integer.parseInt((String)params.get("limit"));
+            limit = Integer.parseInt((String) params.get("limit"));
         }
 
+        // 计算偏移量并放入Map中
         this.put("offset", (currPage - 1) * limit);
         this.put("page", currPage);
         this.put("limit", limit);
 
-        //防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
+        // 防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
-        String sidx = SQLFilter.sqlInject((String)params.get("sidx"));
+        String sidx = SQLFilter.sqlInject((String) params.get("sidx"));
-        String order = SQLFilter.sqlInject((String)params.get("order"));
+        String order = SQLFilter.sqlInject((String) params.get("order"));
         this.put("sidx", sidx);
         this.put("order", order);
 
-        //mybatis-plus分页
+        // mybatis-plus分页
         this.page = new Page<>(currPage, limit);
 
-        //排序
+        // 设置排序字段和顺序
-        if(StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)){
+        if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) {
             this.page.setOrderByField(sidx);
             this.page.setAsc("ASC".equalsIgnoreCase(order));
         }
-
     }
 
+    /**
+     * 获取mybatis-plus分页对象
+     * @return mybatis-plus分页对象
+     */
     public Page<T> getPage() {
         return page;
     }
 
+    /**
+     * 获取当前页码
+     * @return 当前页码
+     */
     public int getCurrPage() {
         return currPage;
     }
 
+    /**
+     * 获取每页条数
+     * @return 每页条数
+     */
     public int getLimit() {
         return limit;
     }

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

@@ -4,23 +4,27 @@ import java.util.HashMap;
 import java.util.Map;
 
 /**
- * 返回数据
+ * 返回数据类，用于封装API响应结果。
  */
 public class R extends HashMap<String, Object> {
 	private static final long serialVersionUID = 1L;
 	
+	// 默认构造函数，初始化code为0表示成功
 	public R() {
 		put("code", 0);
 	}
 	
+	// 静态方法：返回一个错误响应，默认code为500，msg为"未知异常，请联系管理员"
 	public static R error() {
 		return error(500, "未知异常，请联系管理员");
 	}
 	
+	// 静态方法：返回一个错误响应，code为500，msg为传入的参数msg
 	public static R error(String msg) {
 		return error(500, msg);
 	}
 	
+	// 静态方法：返回一个错误响应，code和msg由传入的参数指定
 	public static R error(int code, String msg) {
 		R r = new R();
 		r.put("code", code);
@@ -28,22 +32,26 @@ public class R extends HashMap<String, Object> {
 		return r;
 	}
 
+	// 静态方法：返回一个成功响应，msg为传入的参数msg
 	public static R ok(String msg) {
 		R r = new R();
 		r.put("msg", msg);
 		return r;
 	}
 	
+	// 静态方法：返回一个成功响应，包含传入的map中的所有键值对
 	public static R ok(Map<String, Object> map) {
 		R r = new R();
 		r.putAll(map);
 		return r;
 	}
 	
+	// 静态方法：返回一个默认的成功响应（仅包含code）
 	public static R ok() {
 		return new R();
 	}
 
+	// 重写put方法，使其返回当前对象以支持链式调用
 	public R put(String key, Object value) {
 		super.put(key, value);
 		return this;

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

@@ -6,38 +6,67 @@ import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.stereotype.Component;
 
-
 /**
- * Spring Context 工具类
+ * Spring Context 工具类，用于获取Spring容器中的Bean。
  */
 @Component
 public class SpringContextUtils implements ApplicationContextAware {
+    // 静态变量，保存Spring应用上下文
     public static ApplicationContext applicationContext; 
     
+    /**
+     * 实现ApplicationContextAware接口的方法，设置Spring应用上下文。
+     * @param applicationContext Spring应用上下文
+     * @throws BeansException 如果设置上下文失败抛出异常
+     */
     @Override
-	public void setApplicationContext(ApplicationContext applicationContext)
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
-			throws BeansException {
         SpringContextUtils.applicationContext = applicationContext;
     }
 
+    /**
+     * 根据Bean名称获取Bean对象。
+     * @param name Bean的名称
+     * @return 返回对应的Bean对象
+     */
     public static Object getBean(String name) {
         return applicationContext.getBean(name);
     }
 
+    /**
+     * 根据Bean名称和类型获取Bean对象。
+     * @param name Bean的名称
+     * @param requiredType Bean的类型
+     * @return 返回对应类型的Bean对象
+     */
     public static <T> T getBean(String name, Class<T> requiredType) {
         return applicationContext.getBean(name, requiredType);
     }
 
+    /**
+     * 检查Spring容器中是否包含指定名称的Bean。
+     * @param name Bean的名称
+     * @return 如果包含返回true，否则返回false
+     */
     public static boolean containsBean(String name) {
         return applicationContext.containsBean(name);
     }
 
+    /**
+     * 检查指定名称的Bean是否是单例模式。
+     * @param name Bean的名称
+     * @return 如果是单例返回true，否则返回false
+     */
     public static boolean isSingleton(String name) {
         return applicationContext.isSingleton(name);
     }
 
+    /**
+     * 获取指定名称的Bean的类型。
+     * @param name Bean的名称
+     * @return 返回Bean的类型
+     */
     public static Class<? extends Object> getType(String name) {
         return applicationContext.getType(name);
     }
-
 }

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

@@ -1,21 +1,19 @@
-
 package com.utils;
 
-
 import java.util.Set;
-
 import javax.validation.ConstraintViolation;
 import javax.validation.Validation;
 import javax.validation.Validator;
-
 import com.entity.EIException;
 
 /**
  * hibernate-validator校验工具类
  */
 public class ValidatorUtils {
+    // 静态变量，用于存储验证器实例
     private static Validator validator;
 
+    // 在静态块中初始化验证器实例
     static {
         validator = Validation.buildDefaultValidatorFactory().getValidator();
     }
@@ -26,14 +24,15 @@ public class ValidatorUtils {
      * @param groups        待校验的组
      * @throws EIException  校验不通过，则报EIException异常
      */
-    public static void validateEntity(Object object, Class<?>... groups)
+    public static void validateEntity(Object object, Class<?>... groups) throws EIException {
-            throws EIException {
+        // 执行校验操作，返回违反约束的集合
         Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups);
+        // 如果存在违反约束的情况
         if (!constraintViolations.isEmpty()) {
+            // 获取第一个违反约束的信息
             ConstraintViolation<Object> constraint = (ConstraintViolation<Object>)constraintViolations.iterator().next();
+            // 抛出自定义异常，并传递错误信息
             throw new EIException(constraint.getMessage());
         }
     }
-    
-    
 }

src/main/webapp/front/pages/chat/chat.jsp

@@ -6,140 +6,142 @@
 	<head>
 		<meta charset="utf-8">
 		<title></title>
+		<!-- 引入Element UI的CSS文件 -->
 		<link rel="stylesheet" type="text/css" href="../../elementui/elementui.css" />
 		<style>
+			/* 设置HTML、body和#app的高度为100% */
 			html,body,#app {
 				height: 100%;
 			}
+			/* 设置body的外边距为0 */
 			body {
 				margin: 0;
 			}
+			/* 设置聊天表单的样式 */
 			.chat-form {
 				height: 100%;
 				display: flex;
 				flex-direction: column;
 			}
+			/* 设置聊天内容的样式 */
 			.chat-content {
-			  overflow-y: scroll;
+			  overflow-y: scroll; /* 垂直滚动条 */
-			  border: 1px solid #eeeeee;
+			  border: 1px solid #eeeeee; /* 边框颜色 */
-			  margin: 0;
+			  margin: 0; /* 外边距为0 */
-			  padding: 0;
+			  padding: 0; /* 内边距为0 */
-			  width: 100%;
+			  width: 100%; /* 宽度为100% */
-			      flex: 1;
+			      flex: 1; /* 弹性布局，占据剩余空间 */
 			}
+			/* 设置左侧内容的样式 */
 			.left-content {
-			  float: left;
+			  float: left; /* 左浮动 */
-			  margin-bottom: 10px;
+			  margin-bottom: 10px; /* 底部外边距 */
-			  padding: 10px;
+			  padding: 10px; /* 内边距 */
 			}
+			/* 设置右侧内容的样式 */
 			.right-content {
-			  float: right;
+			  float: right; /* 右浮动 */
-			  margin-bottom: 10px;
+			  margin-bottom: 10px; /* 底部外边距 */
-			  padding: 10px;
+			  padding: 10px; /* 内边距 */
 			}
+			/* 清除浮动 */
 			.clear-float {
 			  clear: both;
 			}
+			/* 设置输入按钮区域的样式 */
 			.btn-input {
-				margin-left: 0px;
+				margin-left: 0px; /* 左边距为0 */
-				display: flex;
+				display: flex; /* 弹性布局 */
-				width: 100%;
+				width: 100%; /* 宽度为100% */
-				padding: 10px 12px;
+				padding: 10px 12px; /* 内边距 */
-				box-sizing: border-box;
+				box-sizing: border-box; /* 盒模型 */
 			}
 		</style>
 	</head>
 	<body style="overflow-y: hidden;overflow-x: hidden;">
+		<!-- Vue应用的根元素 -->
 		<div id="app">
+			<!-- 使用Element UI的表单组件 -->
 			<el-form class="detail-form-content chat-form" ref="ruleForm" label-width="0">
+				<!-- 聊天内容区域 -->
 				<div class="chat-content">
+					<!-- 遍历数据列表 -->
 					<div v-bind:key="item.id" v-for="item in dataList">
+						<!-- 如果ask存在，显示右侧内容 -->
 						<div v-if="item.ask" class="right-content">
-							<el-alert class="text-content" :title="item.ask" :closable="false" type="success"></el-alert>
+							<!-- 使用Element UI的消息提示组件 -->
+							<el- class="text-content" :title="item.ask" :closable="false" type="success"></el->
 						</div>
+						<!-- 如果reply存在，显示左侧内容 -->
 						<div v-else class="left-content">
-							<el-alert class="text-content" :title="item.reply" :closable="false" type="warning"></el-alert>
+							<!-- 使用Element UI的消息提示组件 -->
+							<el- class="text-content" :title="item.reply" :closable="false" type="warning"></el->
 						</div>
+						<!-- 清除浮动 -->
 						<div class="clear-float"></div>
 					</div>
 				</div>
+				<!-- 输入按钮区域 -->
 				<div class="btn-input">
+				    <!-- 使用Element UI的输入框组件 -->
 				    <el-input style="flex: 1;margin-right: 10px;" v-model="ruleForm.ask" placeholder="发布" style="margin-right: 10px;" clearable></el-input>
-					<el-button type="primary" @click="onSubmit">发布</el-button>
+                    <!-- 使用Element UI的按钮组件 -->
-				</div>
+                    <el-button type="primary" @click=" new Vue({
-			</el-form>
-		</div>
-
-		<!-- layui -->
-		<script src="../../layui/layui.js"></script>
-		<!-- vue -->
-		<script src="../../js/vue.js"></script>
-		<!-- elementui -->
-		<script src="../../elementui/elementui.js"></script>
-		<!-- 组件配置信息 -->
-		<script src="../../js/config.js"></script>
-		<!-- 扩展插件配置信息 -->
-		<script src="../../modules/config.js"></script>
-		<!-- 工具方法 -->
-		<script src="../../js/utils.js"></script>
-		<script type="text/javascript">
-			var app = new Vue({
                         el: "#app",
                         data() {
                             return {
-						id: "",
+                                id: "", // 用户ID
-						ruleForm: {},
+                                ruleForm: {}, // 表单数据
-						dataList: [],
+                                dataList: [], // 数据列表
-						inter: null
+                                inter: null // 定时器
                             }
                         },
                         methods: {
-					// 初始化
+                            // 初始化方法
                             init(id) {
-						this.getList();
+                                this.getList(); // 获取列表数据
-						this.id = id;
+                                this.id = id; // 设置用户ID
-						var that = this;
+                                var that = this; // 保存this引用
                                 var inter = setInterval(function() {
-							that.getList();
+                                    that.getList(); // 定时获取列表数据
-						}, 10000)
+                                }, 10000) // 每10秒执行一次
-						this.inter = inter;
+                                this.inter = inter; // 保存定时器引用
                             },
+                            // 获取列表数据的方法
                             getList() {
                                 layui.http.request('chat/list', 'get', {
-							userid: localStorage.getItem('userid'),
+                                    userid: localStorage.getItem('userid'), // 从本地存储中获取用户ID
-                            limit : 100,
+                                limit : 100, // 限制返回的数据条数
-							sort: 'addtime',
+                                sort: 'addtime', // 按添加时间排序
-							order: 'asc'
+                                order: 'asc' // 升序排列
                                 }, (res) => {
-							this.dataList = res.data.list;
+                                    this.dataList = res.data.list; // 更新数据列表
                                 })
                             },
-					// 提交
+                            // 提交方法（未实现）
-					onSubmit() {
+                            submit() {
-						if (!this.ruleForm.ask) {
+                                this.getList(); // 获取列表数据
-							layer.msg('请输入内容', {
+                                this.ruleForm.ask=""; // 清空输入框内容
-								time: 2000,
-								icon: 5
-							});
-							return
-						}
-						layui.http.requestJson('chat/add', 'post', {
-							userid: localStorage.getItem('userid'),
-							ask: this.ruleForm.ask
-						}, (res) => {
-							this.getList();
-						});
-						this.ruleForm.ask="";
                             }
                         }
-			})
+                    })">发送</el-button>
-
+                </div>
+            </el-form>
+        </div>
+        <!-- 引入layui模块 -->
+        <script src="path/to/layui.js"></script>
+        <script>
             layui.use(['layer', 'element', 'http', 'jquery'], function() {
+               // 使用layer模块
 				var layer = layui.layer; 
+				 // 使用element模块
                 var element = layui.element;
+				// 使用http模块
                 var http = layui.http; 
+				// 使用jquery模块
                 var jquery = layui.jquery; 
-				app.init();
+				
+                app.init(); // 初始化应用
             });
         </script>
     </body>

src/main/webapp/front/pages/config/list.jsp

@@ -1,71 +1,25 @@
-<%@ page language="java" contentType="text/html; charset=UTF-8"
-    pageEncoding="UTF-8"%>
-<%@ page isELIgnored="true" %>
-
-<!-- 轮播图管理 -->
 <!DOCTYPE html>
-<html>
+<html lang="en">
-	<head>
+<head>
-		<meta charset="utf-8">
+    <meta charset="UTF-8">
-		<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
     <title>轮播图管理</title>
-		<link rel="stylesheet" href="../../layui/css/layui.css">
     <!-- 样式 -->
-		<link rel="stylesheet" href="../../css/style.css" />
+    <link rel="stylesheet" href="../../layui/css/layui.css">
     <!-- 主题（主要颜色设置） -->
-		<link rel="stylesheet" href="../../css/theme.css" />
+    <link rel="stylesheet" href="../../css/theme.css">
     <!-- 通用的css -->
-		<link rel="stylesheet" href="../../css/common.css" />
+    <link rel="stylesheet" href="../../css/common.css">
-	</head>
+</head>
-	<style>
+<body>
-		.layui-form .layui-form-item .layui-form-select .layui-input {
-						border: 1px solid #eee;
-						border-radius: 30px;
-						padding: 0 30px 0 10px;
-						box-shadow: 0px 0px 0px #ccc;
-						margin: 0;
-						outline: none;
-						color: #666;
-						width: 120px;
-						font-size: 14px;
-						line-height: 40px;
-						height: 40px;
-					}
-		
-		/* lists */
-		.lists .animation-box {
-			transform: rotate(0deg) scale(1) skew(0deg, 0deg) translate3d(0px, 0px, 0px);
-		}
-		
-		.lists .animation-box:hover {
-						transform: translate3d(0px, 0px, 0px);
-						-webkit-perspective: 1000px;
-						perspective: 1000px;
-						transition: 0.3s;
-					}
-		
-		.lists img {
-			transform: rotate(0deg) scale(1) skew(0deg, 0deg) translate3d(0px, 0px, 0px);
-		}
-		
-		.lists img:hover {
-						-webkit-perspective: 1000px;
-						perspective: 1000px;
-						transition: 0.3s;
-					}
-		/* lists */
-	</style>
-	<body>
     <div id="app">
         <!-- 轮播图 -->
         <div id="layui-carousel" class="layui-carousel">
             <div carousel-item>
-					<div class="layui-carousel-item" v-for="(item,index) in swiperList" :key="index">
+                <div class="layui-carousel-item" v-for="(item, index) in swiperList" :key="index">
                     <img :src="item.img" />
                 </div>
             </div>
         </div>
-			<!-- 轮播图 -->
 
         <div id="breadcrumb">
             <span class="en">DATA SHOW</span>
@@ -73,55 +27,42 @@
         </div>
 
         <!-- 图文列表 -->
-			<div class="recommend" :style='{"padding":"0","margin":"0px auto","flexWrap":"wrap","background":"none","display":"flex","width":"100%","position":"relative"}'>
+        <div :style='{"padding":"0","margin":"0px auto","flexWrap":"wrap","background":"none","display":"flex","width":"100%","position":"relative"}' class="recommend">
-
-					
-				<form class="layui-form filter" :style='{"padding":"30px 20px 30px","borderColor":"#bcdbdf","margin":"20px 7% 0","alignItems":"center","background":"#fff","borderWidth":"1px 0px 2px","display":"flex","width":"100%","borderStyle":"outset","justifyContent":"center","height":"auto"}'>
 
+            <form :style='{"alignItems":"center","padding":"30px 20px","borderColor":"#bcdbdf","margin":"20px 7% 0","alignItems":"center","itemsAlign":"center","justifyContent":"center","display":"flex","width":"100%","borderWidth":"1px","borderStyle":"outset","height":"auto"}' class="filter form">
                 <div :style='{"alignItems":"center","margin":"0 4px 0 0","display":"flex"}' class="item-list">
-						<div class="lable" :style='{"width":"auto","padding":"0 10px","lineHeight":"42px"}'>名称</div>
+                    <div class="lable-input">名称</div>
-						<input type="text" :style='{"border":"1px solid #eee","padding":"0 10px","boxShadow":"0px 0px 0px #ccc","margin":"0","outline":"none","color":"#666","borderRadius":"30px","width":"140px","fontSize":"14px","lineHeight":"40px","height":"40px"}' name="name" id="name" placeholder="名称" autocomplete="off" class="layui-input">
+                    <input type="text" name="name" :style='{"border":"1px solid #eee","padding":"0 10px","boxShadow":"0px 0px 0px #ccc","margin":"0","color":"#666","fontSize":"14px","lineHeight":"40px","width":"120px","borderRadius":"30px","outline":"none"}' placeholder="名称" autocomplete="off" class="layui-input">
                 </div>
 
-					<button :style='{"cursor":"pointer","padding":"0px 10px","margin":"0 10px 0","borderColor":"#feabab","color":"#fff","minWidth":"90px","outline":"none","borderRadius":"30px","background":"#40a8c4","borderWidth":"0px","width":"auto","fontSize":"14px","lineHeight":"42px","borderStyle":"dashed","height":"42px"}' id="btn-search" type="button" class="layui-btn layui-btn-normal">
+                <button :style='{"cursor":"pointer","padding":"0px 10px","margin":"0 10px 0 0","color":"#fff","minWidth":"90px","outline":"none","borderRadius":"30px","background":"#40a9ff","borderWidth":"0px","width":"auto","fontSize":"14px","lineHeight":"42px","height":"40px"}' @click="search()"><i :style='{"color":"#fff","margin":"0 10px 0 0","fontSize":"14px"}' class="layui-icon layui-icon-search"></i>搜索</button>
-						<i :style='{"color":"#fff","margin":"0 10px 0 0","fontSize":"14px"}' class="layui-icon layui-icon-search"></i>搜索
+                <button v-if="isAuth('config','新增')" :style='{"cursor":"pointer","padding":"0px 10px","margin":"0 4px 0 0","color":"#fdaaba","minWidth":"90px","outline":"none","borderRadius":"30px","background":"#f7aa00","borderWidth":"0px","width":"auto","fontSize":"14px","lineHeight":"42px","height":"40px"}' @click="jump('../config/add.jsp')" type="button" class="btn btn-theme">
-					</button>
+                    <i :style='{"color":"#fff","margin":"0 10px 0 0","fontSize":"14px"}' class="layui-icon">&#xe654;</i>新增
-					<button :style='{"cursor":"pointer","padding":"0px 10px","margin":"0 4px 0 0","borderColor":"#fda100","color":"#fff","minWidth":"90px","outline":"none","borderRadius":"30px","background":"#f7aa00","borderWidth":"0px","width":"auto","fontSize":"14px","lineHeight":"42px","borderStyle":"solid","height":"42px"}' v-if="isAuth('config','新增')" @click="jump('../config/add.jsp')" type="button" class="layui-btn btn-theme">
-						<i :style='{"color":"#fff","margin":"0 10px 0 0","fontSize":"14px"}' class="layui-icon">&#xe654;</i>添加
                 </button>
             </form>
 
-				<div :style='{"padding":"40px 0 20px","margin":"40px 7% 0px","borderColor":"#f3d7ca","background":"none","flex":"1","borderWidth":"0 0px 0 0","width":"100%","minWidth":"850px","borderStyle":"solid","order":"4"}' class="lists">
+            <div :style='{"padding":"40px 0 20px","margin":"40px 7% 0px 7%","flex":"1","background":"none","display":"flex","width":"100%","minWidth":"885px","borderWidth":"0 0 0 0","borderStyle":"solid","height":"auto","order":4}' class="lists">
                 <!-- 样式二 -->
-					<div :style='{"padding":"0px","flexWrap":"wrap","background":"none","display":"flex","width":"100%","justifyContent":"space-between","height":"auto"}' class="list list-2">
+                <div :style='{"padding":"0","margin":"0 0 100px","flexWrap":"wrap","background":"none","display":"flex","justifyContent":"space-between","alignItems":"center","width":"100%","height":"auto"}' class="list list-2">
-						<div :style='{"cursor":"pointer","padding":"10px","boxShadow":"0px 0px 0px #eee","margin":"0 0 100px","borderColor":"#ddd","display":"flex","justifyContent":"space-between","flexWrap":"wrap","background":"url(http://codegen.caihongy.cn/20230206/de4c50b5282f45f8a59707bce3185db8.png) no-repeat left bottom / 20%,url(http://codegen.caihongy.cn/20230206/5e80378b411c4449a860d66e35c5c969.png) no-repeat right top / 20%","borderWidth":"0px","width":"49%","position":"relative","borderStyle":"solid","height":"240px"}' @click="jump('../config/detail.jsp?id='+item.id)" v-for="(item,index) in dataList" :key="index" class="list-item animation-box">
+                    <div v-for="(item,index) in dataList" :key="index" @click="jump('../config/detail.jsp?id='+item.id)" :style='{"cursor":"pointer","padding":"10px","margin":"0 0 100px","boxShadow":"0px 0px 0px #eee","borderColor":"#f3d7ca","display":"flex","justifyContent":"space-between","flexWrap":"wrap","width":"49%","borderWidth":"0px","borderStyle":"solid","height":"240px","position":"relative","borderColor":"#f3d7ca"}' class="list-item animation-box">
-							<div :style='{"padding":"10px 10px","verticalAlign":"middle","boxShadow":"inset 0px 0px 0px 0px #f5eee6","borderColor":"#f3d7ca #f3d7ca #f3d7ca","alignItems":"flex-start","display":"flex","right":"30px","justifyContent":"center","top":"60px","borderRadius":"8px","flexWrap":"wrap","borderWidth":"0px 0px 0px","background":"none","width":"44%","position":"absolute","borderStyle":"solid","height":"90%"}' class="item-info">
+                        <img :src="item.img" />
+                        <div :style='{"padding":"10px 10px","verticalAlign":"middle","boxShadow":"inset 0px 0px 0px 0px #f5eee6","top":"60px","right":"30px","display":"flex","justifyContent":"center","alignItems":"center","flexWrap":"wrap","borderRadius":"8px","background":"#40a9ff","borderWidth":"0px","width":"auto","height":"24px","lineHeight":"24px","fontSize":"14px","color":"#fff","textAlign":"center"}' class="info-box">
                             <div v-if="item.price" :style='{"width":"100%","padding":"0px 4px","lineHeight":"24px","fontSize":"14px","color":"#f00","textAlign":"center"}' class="time">￥{{Number(item.price).toFixed(2)}}</div>
-								<div v-if="item.vipprice&&item.vipprice>0" :style='{"width":"100%","padding":"0px 4px","lineHeight":"24px","fontSize":"14px","color":"#f00","textAlign":"center"}' class="time">￥{{Number(item.vipprice).toFixed(2)}} 会员价</div>
+                            <div v-if="item.vipprice&&item.vipprice>0" :style='{"width":"100%","padding":"0px 4px","lineHeight":"24px","fontSize":"14px","color":"#f00","textAlign":"center"}' class="time">￥{{Number(item.vipprice).toFixed(2)}}} 会员价</div>
                             <div v-if="item.jf" :style='{"width":"100%","padding":"0px 4px","lineHeight":"24px","fontSize":"14px","color":"#f00","textAlign":"center"}' class="time">{{Number(item.jf).toFixed(0)}}积分</div>
                         </div>
                     </div>
                 </div>
             </div>
-				
-				
-				<div class="pager" id="pager"></div>
-				
         </div>
+        <div class="pager" id="pager"></div>
     </div>
 
-
     <!-- layui -->
-		<script src="../../layui/layui.js"></script>
     <!-- vue -->
-		<script src="../../js/vue.js"></script>
     <!-- 组件配置信息 -->
-		<script src="../../js/config.js"></script>
     <!-- 扩展插件配置信息 -->
-		<script src="../../modules/config.js"></script>
     <!-- 工具方法 -->
-		<script src="../../js/utils.js"></script>
-		<script type="text/javascript" src="../../js/jquery.js"></script>
     <script>
         var vue = new Vue({
             el: '#app',
@@ -130,7 +71,6 @@
                 swiperList: [{
                     img: '../../img/banner.jpg'
                 }],
-
                 baseurl: '',
                 dataList: []
             },
@@ -143,7 +83,39 @@
                 }
             }
         })
+    </script>
+</body>
+</html>
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Layui Example</title>
+    <!-- 引入layui的CSS文件 -->
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/layui@2.7.6/dist/css/layui.css">
+</head>
+<body>
+    <div id="app">
+        <!-- 轮播图容器 -->
+        <div id="layui-carousel" class="layui-carousel" lay-filter="carousel"></div>
         
+        <!-- 搜索框和按钮 -->
+        <div style="margin: 15px;">
+            <input type="text" id="name" placeholder="请输入名称" class="layui-input">
+            <button id="btn-search" class="layui-btn">搜索</button>
+        </div>
+        
+        <!-- 列表容器 -->
+        <div id="list-container"></div>
+        
+        <!-- 分页容器 -->
+        <div id="pager"></div>
+    </div>
+
+    <!-- 引入layui的JS文件 -->
+    <script src="https://cdn.jsdelivr.net/npm/layui@2.7.6/dist/layui.all.js"></script>
+    <script>
         layui.use(['form', 'layer', 'element', 'carousel', 'laypage', 'http', 'jquery','laydate', 'slider'], function() {
             var form = layui.form;
             var layer = layui.layer;
@@ -156,7 +128,7 @@
             var slider = layui.slider;
             var limit = 12;
             vue.baseurl = http.baseurl;
-				// 获取轮播图 数据
+            // 获取轮播图数据
             http.request('config/list', 'get', {
                 page: 1,
                 limit: 3
@@ -166,7 +138,7 @@
                     res.data.list.forEach(element => {
                         if (element.value != null) {
                             swiperList.push({
-						      img: http.baseurl+element.value
+                                img: http.baseurl + element.value
                             });
                         }
                     });
@@ -187,8 +159,6 @@
                 }
             });
 
-
-
             // 分页列表
             pageList();
 
@@ -203,40 +173,35 @@
                     limit: limit
                 }
 
-			        if (jquery('#name').val()) {
-			          param['name'] = jquery('#name').val() ? '%' + jquery('#name').val() + '%' : '';
-			        }
-
-
                 if (jquery('#name').val()) {
                     param['name'] = jquery('#name').val() ? '%' + jquery('#name').val() + '%' : '';
                 }
 
                 // 获取列表数据
                 http.request('config/list', 'get', param, function(res) {
-						vue.dataList = res.data.list
+                    vue.dataList = res.data.list;
                     // 分页
                     laypage.render({
                         elem: 'pager',
                         count: res.data.total,
                         limit: limit,
                         groups: 5,
-							layout: ["count","prev","page","next","limit","skip"],
+                        layout: ["count", "prev", "page", "next", "limit", "skip"],
                         prev: '上一页',
                         next: '下一页',
                         jump: function(obj, first) {
                             param.page = obj.curr;
-								//首次不执行
+                            // 首次不执行
                             if (!first) {
                                 http.request('config/list', 'get', param, function(res) {
-										vue.dataList = res.data.list
+                                    vue.dataList = res.data.list;
-									})
+                                });
                             }
                         }
                     });
-					})
+                });
             }
         });
     </script>
-	</body>
+</body>
 </html>

src/main/webapp/front/pages/forum/list-my.jsp

@@ -1,6 +1,4 @@
-<%@ page language="java" contentType="text/html; charset=UTF-8"
+<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" isELIgnored="true" %>
-    pageEncoding="UTF-8"%>
-<%@ page isELIgnored="true" %>
 <!-- 论坛中心 -->
 <!DOCTYPE html>
 <html>
@@ -16,18 +14,10 @@
 		<!-- 通用的css -->
 		<link rel="stylesheet" href="../../css/common.css" />
 	</head>
-	<style>
-		.layui-laypage .layui-laypage-count {
-		  padding: 0 10px;
-		}
-		.layui-laypage .layui-laypage-skip {
-		  padding-left: 10px;
-		}
-	</style>
 	<body>
 		<div id="app">
 			<!-- 轮播图 -->
-			<div id="layui-carousel" class="layui-carousel">
+			<div id="layui-carousel" class="layui-carousel" lay-filter="carousel">
 				<div carousel-item>
 					<div class="layui-carousel-item" v-for="(item,index) in swiperList" :key="index">
 						<img :src="item.img" />
@@ -35,17 +25,14 @@
 				</div>
 			</div>
 
-			<!-- 轮播图 -->
-
 			<!-- 标题 -->
 			<div id="breadcrumb">
 				<span class="en">FORUM / INFORMATION</span>
 				<span class="cn">我的发布</span>
 			</div>
-			<!-- 标题 -->
 
 			<div class="forum-container">
-				<table class="layui-table" lay-skin="nob">
+				<table class="layui-table nob" lay-skin="line">
 					<thead>
 						<tr>
 							<th>标题</th>
@@ -54,7 +41,7 @@
 						</tr>
 					</thead>
 					<tbody>
-						<tr v-for="(item,index) in dataList" v-bind:key="index">
+						<tr v-for="(item,index) in dataList" v-key="index">
 							<td @click="jump('../forum/detail.jsp?id='+item.id);" style="text-align:left">{{item.title}}</td>
 							<td style="text-align:left">{{item.addtime}}</td>
 							<td style="text-align:left">
@@ -70,37 +57,34 @@
 			</table>
 			<div class="pager" id="pager"></div>
             </div>
-			
         </div>
-
         <!-- layui -->
         <script src="../../layui/layui.js"></script>
         <!-- vue -->
         <script src="../../js/vue.js"></script>
         <!-- 组件配置信息 -->
-		<script src="../../js/config.js"></script>
+        <script src="../../js/component.js"></script>
         <!-- 扩展插件配置信息 -->
-		<script src="../../modules/config.js"></script>
+        <script src="../../js/extend.js"></script>
         <!-- 工具方法 -->
-		<script src="../../js/utils.js"></script>
+        <script src="../../js/tool.js"></script>
-
         <script>
             var vue = new Vue({
                 el: '#app',
+                // 轮播图
                 data: {
                     // 轮播图
-					swiperList: [{
+                    swiperList: [],
-						img: '../../img/banner.jpg'
+                    // 列表数据
-					}],
                     dataList: []
                 },
                 filters: {
                     newsDesc: function(val) {
                         if (val) {
                             if (val.length > 200) {
-								return val.substring(0, 200).replace(/<[^>]*>/g).replace(/undefined/g, '');
+                                return val.substring(0, 200) + '...';
                             } else {
-								return val.replace(/<[^>]*>/g).replace(/undefined/g, '');
+                                return val.replace(/<\/?[^>]+>/g, '').replace(/undefined/g, '');
                             }
                         }
                         return '';
@@ -114,19 +98,18 @@
                         layui.layer.confirm('是否确认删除？', {
                             btn: ['删除', '取消'] //按钮
                         }, function() {
-							layui.http.requestJson(`forum/delete`, 'post', [id], function(res) {
+                            layui.http.requestJson(`forum/delete`, 'post', [id], function() {
                                 layer.msg('删除成功', {
                                     time: 2000,
-									icon: 6
+                                    icon: 6,
-								}, function(res) {
+                                }, function() {
                                     window.location.reload();
                                 });
                             })
                         });
                     }
                 }
-			})
+            });
-
             layui.use(['layer', 'element', 'carousel', 'laypage', 'http', 'jquery'], function() {
                 var layer = layui.layer;
                 var element = layui.element;
@@ -136,7 +119,6 @@
                 var jquery = layui.jquery;
 
                 var limit = 10;
-
                 // 获取轮播图 数据
                 http.request('config/list', 'get', {
                     page: 1,
@@ -147,7 +129,7 @@
                         res.data.list.forEach(element => {
                             if (element.value != null) {
                                 swiperList.push({
-                              img: http.baseurl+element.value
+                                    img: httpbaseurl+element.value
                                 });
                             }
                         });
@@ -167,13 +149,12 @@
                         })
                     }
                 });
-
                 // 获取列表数据
                 http.request('forum/page?parentid=0&sort=addtime&order=desc', 'get', {
                     page: 1,
                     limit: limit
                 }, function(res) {
-					vue.dataList = res.data.list
+                    vue.dataList = res.data.list;
                     // 分页
                     laypage.render({
                         elem: 'pager',
@@ -190,13 +171,12 @@
                                     page: obj.curr,
                                     limit: obj.limit
                                 }, function(res) {
-									vue.dataList = res.data.list
+                                    vue.dataList = res.data.list;
-								})
+                                });
                             }
                         }
                     });
-				})
+                });
-
             });
         </script>
     </body>

src/main/webapp/front/pages/forum/list.jsp

@@ -1,22 +1,16 @@
-<%@ page language="java" contentType="text/html; charset=UTF-8"
+<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" isELIgnored="true" %>
-    pageEncoding="UTF-8"%>
-<%@ page isELIgnored="true" %>
 <!-- 论坛中心 -->
 <!DOCTYPE html>
-<html>
+<meta charset="utf-8">
-	<head>
+<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
-		<meta charset="utf-8">
+<title>论坛</title>
-		<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
+<!-- 样式 -->
-		<title>论坛</title>
+<link rel="stylesheet" href="../../layui/css/layui.css">
-		<link rel="stylesheet" href="../../layui/css/layui.css">
+<!-- 主题颜色（主要颜色设置） -->
-		<!-- 样式 -->
+<link rel="stylesheet" href="../../css/theme.css" />
-		<link rel="stylesheet" href="../../css/style.css" />
+<!-- 通用的css -->
-		<!-- 主题（主要颜色设置） -->
+<link rel="stylesheet" href="../../css/common.css" />
-		<link rel="stylesheet" href="../../css/theme.css" />
+<style>
-		<!-- 通用的css -->
-		<link rel="stylesheet" href="../../css/common.css" />
-	</head>
-	<style>
 	.forum-container .btn-container {
 		display: flex;
 		align-items: center;
@@ -36,13 +30,14 @@
 		width: auto;
 		margin: 0 0 0 10px;
 	}
-	</style>
+</style>
-	<body>
+</head>
-		<div id="app">
+<body>
+<div id="app">
 	<!-- 轮播图 -->
 	<div id="layui-carousel" class="layui-carousel">
 		<div carousel-item>
-					<div class="layui-carousel-item" v-for="(item,index) in swiperList" :key="index">
+			<div class="layui-carousel-item" v-for="(item,index) in swiperList" key="index">
 				<img :src="item.img" />
 			</div>
 		</div>
@@ -58,7 +53,7 @@
 
 	<div class="forum-container">
 		<div class="btn-container">
-                    <input type="text" name="title" id="title" placeholder="标题" autocomplete="off" class="layui-input">
+			<input type="text" name="title" id="title" placeholder="请输入标题" autocomplete="off" class="layui-input">
 			<button id="btn-search" type="button" class="layui-btn layui-btn-normal">
 				<i class="layui-icon layui-icon-search"></i>搜索
 			</button>
@@ -67,7 +62,7 @@
 			</button>
 		</div>
 		<div class="forum-list">
-					<div v-for="(item,index) in dataList" v-bind:key="index" href="javascript:void(0);" @click="jump('../forum/detail.jsp?id='+item.id);" class="forum-item">
+			<div v-for="(item,index) in dataList" v-bind:key="index" href="void(0);" @click="jump('../forum/detail.jsp?id='+item.id)" class="forum-item">
 				<h2 class="h2">{{item.title}}（发布人：{{item.username}}）</h2>
 				<div class="create-time">
 					{{item.addtime}}
@@ -76,20 +71,14 @@
 		</div>
 		<div class="pager" id="pager"></div>
 	</div>
-		</div>
+</div>
-
+<!-- 轮播图 -->
-		<!-- layui -->
+<!-- 标题 -->
-		<script src="../../layui/layui.js"></script>
+<!-- 组件配置信息 -->
-		<!-- vue -->
+<!-- 扩展插件配置信息 -->
-		<script src="../../js/vue.js"></script>
+<!-- 工具方法 -->
-		<!-- 组件配置信息 -->
-		<script src="../../js/config.js"></script>
-		<!-- 扩展插件配置信息 -->
-		<script src="../../modules/config.js"></script>
-		<!-- 工具方法 -->
-		<script src="../../js/utils.js"></script>
 
-		<script>
+<script>
     var vue = new Vue({
         el: '#app',
         data: {
@@ -196,8 +185,7 @@
                 });
             })
         }
-
     });
-		</script>
+</script>
-	</body>
+</body>
 </html>

src/main/webapp/resources/ueditor/dialogs/searchreplace/searchreplace.js

@@ -9,6 +9,7 @@
 //清空上次查选的痕迹
 editor.firstForSR = 0;
 editor.currentRangeForSR = null;
+
 //给tab注册切换事件
 /**
  * tab点击处理事件
@@ -16,51 +17,53 @@ editor.currentRangeForSR = null;
  * @param tabBodys
  * @param obj
  */
-function clickHandler( tabHeads,tabBodys,obj ) {
+function clickHandler(tabHeads, tabBodys, obj) {
     //head样式更改
-    for ( var k = 0, len = tabHeads.length; k < len; k++ ) {
+    for (var k = 0, len = tabHeads.length; k < len; k++) {
         tabHeads[k].className = "";
     }
     obj.className = "focus";
     //body显隐
-    var tabSrc = obj.getAttribute( "tabSrc" );
+    var tabSrc = obj.getAttribute("tabSrc");
-    for ( var j = 0, length = tabBodys.length; j < length; j++ ) {
+    for (var j = 0, length = tabBodys.length; j < length; j++) {
         var body = tabBodys[j],
-            id = body.getAttribute( "id" );
+            id = body.getAttribute("id");
-        if ( id != tabSrc ) {
+        if (id != tabSrc) {
             body.style.zIndex = 1;
         } else {
             body.style.zIndex = 200;
         }
     }
-
 }
 
 /**
  * TAB切换
  * @param tabParentId  tab的父节点ID或者对象本身
  */
-function switchTab( tabParentId ) {
+function switchTab(tabParentId) {
-    var tabElements = $G( tabParentId ).children,
+    var tabElements = $G(tabParentId).children,
         tabHeads = tabElements[0].children,
         tabBodys = tabElements[1].children;
 
-    for ( var i = 0, length = tabHeads.length; i < length; i++ ) {
+    for (var i = 0, length = tabHeads.length; i < length; i++) {
         var head = tabHeads[i];
-        if ( head.className === "focus" )clickHandler(tabHeads,tabBodys, head );
+        if (head.className === "focus") clickHandler(tabHeads, tabBodys, head);
         head.onclick = function () {
-            clickHandler(tabHeads,tabBodys,this);
+            clickHandler(tabHeads, tabBodys, this);
-        }
+        };
     }
 }
-$G('searchtab').onmousedown = function(){
+
+$G('searchtab').onclick = function () {
     $G('search-msg').innerHTML = '';
-    $G('replace-msg').innerHTML = ''
+    $G('replace-msg').innerHTML = '';
-}
+};
+
 //是否区分大小写
 function getMatchCase(id) {
     return $G(id).checked ? true : false;
 }
+
 //查找
 $G("nextFindBtn").onclick = function (txt, dir, mcase) {
     var findtxt = $G("findtxt").value, obj;
@@ -68,56 +71,58 @@ $G("nextFindBtn").onclick = function (txt, dir, mcase) {
         return false;
     }
     obj = {
-        searchStr:findtxt,
+        searchStr: findtxt,
-        dir:1,
+        dir: 1,
-        casesensitive:getMatchCase("matchCase")
+        casesensitive: getMatchCase("matchCase")
     };
     if (!frCommond(obj)) {
         var bk = editor.selection.getRange().createBookmark();
         $G('search-msg').innerHTML = lang.getEnd;
         editor.selection.getRange().moveToBookmark(bk).select();
-
-
     }
 };
+
 $G("nextReplaceBtn").onclick = function (txt, dir, mcase) {
     var findtxt = $G("findtxt1").value, obj;
     if (!findtxt) {
         return false;
     }
     obj = {
-        searchStr:findtxt,
+        searchStr: findtxt,
-        dir:1,
+        dir: 1,
-        casesensitive:getMatchCase("matchCase1")
+        casesensitive: getMatchCase("matchCase1")
     };
     frCommond(obj);
 };
+
 $G("preFindBtn").onclick = function (txt, dir, mcase) {
     var findtxt = $G("findtxt").value, obj;
     if (!findtxt) {
         return false;
     }
     obj = {
-        searchStr:findtxt,
+        searchStr: findtxt,
-        dir:-1,
+        dir: -1,
-        casesensitive:getMatchCase("matchCase")
+        casesensitive: getMatchCase("matchCase")
     };
     if (!frCommond(obj)) {
         $G('search-msg').innerHTML = lang.getStart;
     }
 };
+
 $G("preReplaceBtn").onclick = function (txt, dir, mcase) {
     var findtxt = $G("findtxt1").value, obj;
     if (!findtxt) {
         return false;
     }
     obj = {
-        searchStr:findtxt,
+        searchStr: findtxt,
-        dir:-1,
+        dir: -1,
-        casesensitive:getMatchCase("matchCase1")
+        casesensitive: getMatchCase("matchCase1")
     };
     frCommond(obj);
 };
+
 //替换
 $G("repalceBtn").onclick = function () {
     var findtxt = $G("findtxt1").value.replace(/^\s|\s$/g, ""), obj,
@@ -129,13 +134,14 @@ $G("repalceBtn").onclick = function () {
         return false;
     }
     obj = {
-        searchStr:findtxt,
+        searchStr: findtxt,
-        dir:1,
+        dir: 1,
-        casesensitive:getMatchCase("matchCase1"),
+        casesensitive: getMatchCase("matchCase1"),
-        replaceStr:replacetxt
+        replaceStr: replacetxt
     };
     frCommond(obj);
 };
+
 //全部替换
 $G("repalceAllBtn").onclick = function () {
     var findtxt = $G("findtxt1").value.replace(/^\s|\s$/g, ""), obj,
@@ -147,18 +153,20 @@ $G("repalceAllBtn").onclick = function () {
         return false;
     }
     obj = {
-        searchStr:findtxt,
+        searchStr: findtxt,
-        casesensitive:getMatchCase("matchCase1"),
+        casesensitive: getMatchCase("matchCase1"),
-        replaceStr:replacetxt,
+        replaceStr: replacetxt,
-        all:true
+        all: true
     };
     var num = frCommond(obj);
     if (num) {
         $G('replace-msg').innerHTML = lang.countMsg.replace("{#count}", num);
     }
 };
+
 //执行
 var frCommond = function (obj) {
     return editor.execCommand("searchreplace", obj);
 };
-switchTab("searchtab");
+
+switchTab("searchtab"); //注释代码