目前提交这么多

README.md

@@ -135,7 +135,39 @@ wx-dump-4j是一款基于Java开发的微信数据分析工具。它准确显示
 
 本软件仅供技术研究和教育目的使用，旨在解密用户个人微信聊天记录。严禁将本软件用于任何非法目的，包括但不限于侵犯隐私权或非授权数据访问。作为软件开发者，我不对因使用或滥用本软件产生的任何形式的损失或损害承担责任。
 
+## ⛵欢迎贡献！
 
+如果你发现任何错误🔍或者有改进建议🛠️，欢迎提交 issue 或者 pull request。你的反馈📢对于我非常宝贵💎！
+
+## 💻我的 GitHub 统计
+
+[![Star History Chart](https://api.star-history.com/svg?repos=xuchengsheng/wx-dump-4j&type=Date)](https://star-history.com/#xuchengsheng/wx-dump-4j&Date)
+
+## 🎉Stargazers
+
+[![Stargazers123 repo roster for @xuchengsheng/wx-dump-4j](https://reporoster.com/stars/xuchengsheng/wx-dump-4j)](https://github.com/xuchengsheng/wx-dump-4j/stargazers)
+
+## 🎉Forkers
+
+[![Forkers repo roster for @xuchengsheng/wx-dump-4j](https://reporoster.com/forks/xuchengsheng/wx-dump-4j)](https://github.com/xuchengsheng/wx-dump-4j/network/members)
+
+## 🍱请我吃盒饭？
+
+作者晚上还要写博客✍️,平时还需要工作💼,如果帮到了你可以请作者吃个盒饭🥡
+<div>
+<img alt="logo" src="image/WeChatPay.png" style="width: 240px;height: 260px">
+<img alt="logo" src="image/Alipay.png" style="width: 240px;height: 260px">
+</div>
+
+## ⭐️扫码关注微信公众号
+
+关注后，回复关键字📲 **加群**📲，即可加入我们的技术交流群，与更多开发者一起交流学习。
+
+在此，我们真诚地邀请您访问我们的GitHub项目页面，如果您觉得***wx-dump-4j***对您有帮助，请顺手点个⭐️**Star**⭐️！每一颗星星都是我们前进的动力，是对我们努力的最大肯定。非常感谢您的支持！
+
+<div>
+<img alt="logo" src="image/wechat-mp.png" height="180px">>
+</div>
 
 ## 👀 演示图
 

wx-dump-admin/src/main/java/com/xcs/wx/WxDumpApplication.java

@@ -3,8 +3,6 @@ package com.xcs.wx;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.context.ConfigurableApplicationContext;
-import org.springframework.context.annotation.EnableAspectJAutoProxy;
-import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
 
 import java.net.InetAddress;
@@ -12,35 +10,36 @@ import java.net.UnknownHostException;
 import java.util.Date;
 
 /**
- * 微信数据导出应用的主类。
- * 这个类作为整个应用的启动类，负责初始化Spring应用上下文，并打印应用的启动信息。
- */
-@SpringBootApplication // 指定这是一个Spring Boot应用
+ * 主应用程序类，启动Spring Boot应用程序。
+ *
+ * @author xcs
+ * @date 2023年12月21日 17时02分
+ **/
+@SpringBootApplication // 声明这是一个Spring Boot应用程序
 @EnableTransactionManagement // 启用事务管理
 public class WxDumpApplication {
 
     /**
-     * 应用的入口点。
-     * 这个方法是程序执行的起点，它启动Spring应用上下文，并计算启动时间。
-     * @param args 命令行参数。
-     * @throws UnknownHostException 如果无法获取本地主机地址。
+     * 应用程序的入口点。
+     *
+     * @param args 命令行参数
+     * @throws UnknownHostException 当无法获取本地主机地址时抛出异常
      */
     public static void main(String[] args) throws UnknownHostException {
-        long startTime = System.currentTimeMillis(); // 记录启动开始时间
+        long startTime = System.currentTimeMillis(); // 记录启动时间
         ConfigurableApplicationContext context = SpringApplication.run(WxDumpApplication.class, args); // 启动Spring应用
-        long endTime = System.currentTimeMillis(); // 记录启动结束时间
+        long endTime = System.currentTimeMillis(); // 记录结束时间
 
-        // 获取应用的端口和上下文路径
+        // 获取服务器端口和上下文路径
         String port = context.getEnvironment().getProperty("server.port", "8080");
         String contextPath = context.getEnvironment().getProperty("server.servlet.context-path", "");
-        // 获取本地主机地址
-        String localHostAddress = InetAddress.getLocalHost().getHostAddress();
+        String localHostAddress = InetAddress.getLocalHost().getHostAddress(); // 获取本地主机地址
 
-        // 构建本地和网络访问的URL
+        // 构造本地和网络访问URL
         String localUrl = "http://localhost:" + port + contextPath;
         String networkUrl = "http://" + localHostAddress + ":" + port + contextPath;
 
-        // 打印启动信息
+        // 输出启动信息
         System.out.println("DONE successfully in " + (endTime - startTime) + "ms");
         System.out.println("Time: " + new Date());
         System.out.println("╔════════════════════════════════════════════════════╗");
@@ -49,6 +48,6 @@ public class WxDumpApplication {
         System.out.println("║    > Network: " + networkUrl + "                    ");
         System.out.println("║                                                    ║");
         System.out.println("║ Now you can open browser with the above addresses↑ ║");
-        System.out.println("╚══════════════════════════════════════════════════╝");
+        System.out.println("╚════════════════════════════════════════════════════╝");
     }
 }

wx-dump-admin/src/main/java/com/xcs/wx/aop/RepositoryAspect.java

@@ -1,14 +1,14 @@
 package com.xcs.wx.aop;
 
-import cn.hutool.core.annotation.AnnotationUtil;
-import com.baomidou.dynamic.datasource.annotation.DS;
-import com.baomidou.dynamic.datasource.toolkit.DynamicDataSourceContextHolder;
-import com.xcs.wx.util.DSNameUtil;
-import lombok.extern.slf4j.Slf4j;
-import org.aspectj.lang.ProceedingJoinPoint;
-import org.aspectj.lang.annotation.Around;
-import org.aspectj.lang.annotation.Aspect;
-import org.springframework.stereotype.Component;
+import cn.hutool.core.annotation.AnnotationUtil; // 导入hutool工具类，用于获取注解
+import com.baomidou.dynamic.datasource.annotation.DS; // 导入动态数据源注解
+import com.baomidou.dynamic.datasource.toolkit.DynamicDataSourceContextHolder; // 导入动态数据源上下文持有者
+import com.xcs.wx.util.DSNameUtil; // 导入自定义的工具类，用于获取数据源名称
+import lombok.extern.slf4j.Slf4j; // 导入日志注解
+import org.aspectj.lang.ProceedingJoinPoint; // 导入AOP的ProceedingJoinPoint接口
+import org.aspectj.lang.annotation.Around; // 导入AOP的Around注解
+import org.aspectj.lang.annotation.Aspect; // 导入AOP的Aspect注解
+import org.springframework.stereotype.Component; // 导入Spring的Component注解
 
 /**
  * 多微信数据源动态切换拦截
@@ -16,14 +16,20 @@ import org.springframework.stereotype.Component;
  * @author xcs
  * @date 2024年6月27日14:29:32
  */
-@Slf4j
-@Aspect
-@Component
+@Slf4j // 使用lombok提供的日志注解
+@Aspect // 声明这是一个切面
+@Component // 声明这是一个Spring组件
 public class RepositoryAspect {
 
-    @Around("execution(public * com.xcs.wx.repository..*.*(..))")
+    /**
+     * 环绕通知，用于在目标方法执行前后进行增强处理
+     * @param joinPoint 连接点，表示被拦截的方法
+     * @return 目标方法的返回值
+     * @throws Throwable 可能抛出的异常
+     */
+    @Around("execution(public * com.xcs.wx.repository..*.*(..))") // 指定切点表达式，拦截com.xcs.wx.repository包及其子包下所有类的所有方法
     public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
-        String previousDs = DynamicDataSourceContextHolder.peek();
+        String previousDs = DynamicDataSourceContextHolder.peek(); // 获取当前的数据源
         try {
             // 获取拦截方法所在的类
             Class<?> targetClass = joinPoint.getTarget().getClass();
@@ -31,16 +37,16 @@ public class RepositoryAspect {
             DS dsAnnotation = AnnotationUtil.getAnnotation(targetClass, DS.class);
             // 有指定的注解
             if (dsAnnotation != null) {
-                DynamicDataSourceContextHolder.push(DSNameUtil.getDSName(dsAnnotation.value()));
+                DynamicDataSourceContextHolder.push(DSNameUtil.getDSName(dsAnnotation.value())); // 切换到指定的数据源
             }
-            return joinPoint.proceed();
+            return joinPoint.proceed(); // 执行目标方法
         } finally {
             // 恢复之前的ds
             if (previousDs != null) {
-                DynamicDataSourceContextHolder.push(previousDs);
+                DynamicDataSourceContextHolder.push(previousDs); // 如果之前有数据源，则恢复
             } else {
-                DynamicDataSourceContextHolder.clear();
+                DynamicDataSourceContextHolder.clear(); // 否则清除
             }
         }
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/config/ExceptionAdviceConfig.java

@@ -1,60 +1,70 @@
 package com.xcs.wx.config;
 
-import com.baomidou.dynamic.datasource.exception.CannotFindDataSourceException;
-import com.xcs.wx.domain.vo.ResponseVO;
-import com.xcs.wx.exception.BizException;
-import lombok.extern.slf4j.Slf4j;
-import org.mybatis.spring.MyBatisSystemException;
-import org.springframework.http.HttpStatus;
-import org.springframework.web.bind.annotation.ExceptionHandler;
-import org.springframework.web.bind.annotation.ResponseStatus;
-import org.springframework.web.bind.annotation.RestControllerAdvice;
+import com.baomidou.dynamic.datasource.exception.CannotFindDataSourceException; // 导入动态数据源异常类
+import com.xcs.wx.domain.vo.ResponseVO; // 导入自定义的响应VO类
+import com.xcs.wx.exception.BizException; // 导入自定义的业务异常类
+import lombok.extern.slf4j.Slf4j; // 导入lombok提供的日志注解
+import org.mybatis.spring.MyBatisSystemException; // 导入MyBatis系统异常类
+import org.springframework.http.HttpStatus; // 导入Spring的HTTP状态码类
+import org.springframework.web.bind.annotation.ExceptionHandler; // 导入Spring的异常处理器注解
+import org.springframework.web.bind.annotation.ResponseStatus; // 导入Spring的响应状态注解
+import org.springframework.web.bind.annotation.RestControllerAdvice; // 导入Spring的全局异常处理注解
 
 /**
+ * 全局异常处理配置类
+ *
  * @author xcs
  * @date 2023年12月25日 17时29分
  **/
-@Slf4j
-@RestControllerAdvice
-@ResponseStatus(HttpStatus.OK)
+@Slf4j // 使用lombok提供的日志注解
+@RestControllerAdvice // 声明这是一个全局异常处理的RestControllerAdvice
+@ResponseStatus(HttpStatus.OK) // 设置默认的响应状态码为OK
 public class ExceptionAdviceConfig {
 
     /**
-     * 捕获BizException异常
+     * 捕获并处理BizException异常
+     * @param e 抛出的BizException异常
+     * @return 自定义的响应VO对象
      **/
-    @ExceptionHandler(BizException.class)
+    @ExceptionHandler(BizException.class) // 指定这个方法处理BizException异常
     public ResponseVO<String> handleException(BizException e) {
-        return ResponseVO.error(e.getCode(), e.getMsg());
+        return ResponseVO.error(e.getCode(), e.getMsg()); // 返回异常的错误码和消息
     }
 
     /**
-     * 捕获MyBatisSystemException异常
+     * 捕获并处理MyBatisSystemException异常
+     * @param e 抛出的MyBatisSystemException异常
+     * @return 自定义的响应VO对象
      **/
-    @ExceptionHandler(MyBatisSystemException.class)
+    @ExceptionHandler(MyBatisSystemException.class) // 指定这个方法处理MyBatisSystemException异常
     public ResponseVO<String> myBatisSystemException(MyBatisSystemException e) {
-        // 数据库未就绪状态
+        // 如果异常的原因是数据源未找到，则返回特定的错误消息
         if (e.getCause().getCause() instanceof CannotFindDataSourceException) {
             return ResponseVO.error(-1, "微信数据库未就绪状态,请先点击左侧解密工具进行数据解密！");
         }
-        log.error("mybatis system exception", e);
-        return ResponseVO.error(-1, "系统异常");
+        log.error("mybatis system exception", e); // 记录异常日志
+        return ResponseVO.error(-1, "系统异常"); // 返回系统异常的错误消息
     }
 
     /**
-     * 捕获RuntimeException异常
+     * 捕获并处理RuntimeException异常
+     * @param e 抛出的RuntimeException异常
+     * @return 自定义的响应VO对象
      **/
-    @ExceptionHandler(RuntimeException.class)
+    @ExceptionHandler(RuntimeException.class) // 指定这个方法处理RuntimeException异常
     public ResponseVO<String> handleException(RuntimeException e) {
-        log.error("runtime exception", e);
-        return ResponseVO.error(-1, "系统异常");
+        log.error("runtime exception", e); // 记录异常日志
+        return ResponseVO.error(-1, "系统异常"); // 返回系统异常的错误消息
     }
 
     /**
-     * 捕获Exception异常
+     * 捕获并处理Exception异常
+     * @param e 抛出的Exception异常
+     * @return 自定义的响应VO对象
      **/
-    @ExceptionHandler(Exception.class)
+    @ExceptionHandler(Exception.class) // 指定这个方法处理Exception异常
     public ResponseVO<String> handleException(Exception e) {
-        log.error("exception", e);
-        return ResponseVO.error(-1, "系统异常");
+        log.error("exception", e); // 记录异常日志
+        return ResponseVO.error(-1, "系统异常"); // 返回系统异常的错误消息
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/config/MybatisPlusConfig.java

@@ -1,27 +1,30 @@
 package com.xcs.wx.config;
 
-import com.baomidou.mybatisplus.annotation.DbType;
-import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
-import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
-import org.mybatis.spring.annotation.MapperScan;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
+import com.baomidou.mybatisplus.annotation.DbType; // 导入MyBatis-Plus支持的数据库类型枚举
+import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; // 导入MyBatis-Plus拦截器
+import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; // 导入MyBatis-Plus分页插件
+import org.mybatis.spring.annotation.MapperScan; // 导入MyBatis的Mapper扫描注解
+import org.springframework.context.annotation.Bean; // 导入Spring的Bean注解
+import org.springframework.context.annotation.Configuration; // 导入Spring的配置类注解
 
 /**
+ * MyBatis-Plus配置类
+ *
  * @author xcs
  * @date 2023年12月29日 16时10分
  **/
-@Configuration
-@MapperScan({"com.xcs.wx.mapper"})
+@Configuration // 声明这是一个Spring配置类
+@MapperScan({"com.xcs.wx.mapper"}) // 指定MyBatis的Mapper接口所在包，Spring会自动扫描这个包下的Mapper接口
 public class MybatisPlusConfig {
 
     /**
      * 添加分页插件
+     * @return 分页插件的Bean
      */
-    @Bean
+    @Bean // 声明这是一个Spring Bean
     public MybatisPlusInterceptor mybatisPlusInterceptor() {
-        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
-        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.SQLITE));
-        return interceptor;
+        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); // 创建MyBatis-Plus拦截器实例
+        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.SQLITE)); // 向拦截器添加分页插件，这里指定了数据库类型为SQLite
+        return interceptor; // 返回分页插件的Bean实例
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/config/UseStaticResourceConfig.java

@@ -1,20 +1,26 @@
 package com.xcs.wx.config;
 
-import org.springframework.context.annotation.Configuration;
-import org.springframework.web.servlet.config.annotation.EnableWebMvc;
-import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
-import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+import org.springframework.context.annotation.Configuration; // 导入Spring的配置类注解
+import org.springframework.web.servlet.config.annotation.EnableWebMvc; // 导入Spring MVC的@EnableWebMvc注解，启用Web MVC功能
+import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry; // 导入Spring MVC的资源处理器注册表接口
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; // 导入Spring MVC的WebMvcConfigurer接口
 
 /**
+ * 静态资源配置类
+ *
  * @author xcs
  * @date 2024年01月26日 11时46分
  **/
-@Configuration
-@EnableWebMvc
-public class UseStaticResourceConfig implements WebMvcConfigurer {
+@Configuration // 声明这是一个Spring配置类
+@EnableWebMvc // 启用Web MVC功能，允许定义额外的mvc配置
+public class UseStaticResourceConfig implements WebMvcConfigurer { // 实现WebMvcConfigurer接口，自定义Web MVC配置
 
-    @Override
+    /**
+     * 添加资源处理器
+     * @param registry 资源处理器注册表
+     */
+    @Override // 覆盖WebMvcConfigurer接口的addResourceHandlers方法
     public void addResourceHandlers(ResourceHandlerRegistry registry) {
-        registry.addResourceHandler("/**").addResourceLocations("file:../html/");
+        registry.addResourceHandler("/**").addResourceLocations("file:../html/"); // 添加资源处理器，匹配所有请求（"/**"），并指定资源位置为"file:../html/"，即项目外的html目录
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/config/WeChatOffsetProperties.java

@@ -1,31 +1,31 @@
 package com.xcs.wx.config;
 
-import lombok.Data;
-import org.springframework.boot.context.properties.ConfigurationProperties;
-import org.springframework.context.annotation.Configuration;
+import lombok.Data; // 导入lombok提供的@Data注解，用于生成getter、setter等方法
+import org.springframework.boot.context.properties.ConfigurationProperties; // 导入Spring Boot的配置属性注解
+import org.springframework.context.annotation.Configuration; // 导入Spring的配置类注解
 
-import java.util.Map;
+import java.util.Map; // 导入Java的Map接口
 
 /**
- * 微信参数偏移量配置
+ * 微信参数偏移量配置类
  *
  * @author xcs
  * @date 2023年12月25日 10时05分
  **/
-@Data
-@Configuration(proxyBeanMethods = false)
-@ConfigurationProperties(prefix = "wechat-offset")
+@Data // 使用lombok提供的@Data注解，自动生成getter、setter等方法
+@Configuration(proxyBeanMethods = false) // 声明这是一个Spring配置类，不创建代理bean
+@ConfigurationProperties(prefix = "wechat-offset") // 声明这是一个配置属性类，配置属性的前缀为"wechat-offset"
 public class WeChatOffsetProperties {
 
     /**
      * 微信各个版本对应的偏移量配置
      */
-    private Map<String, VersionConfig> version;
+    private Map<String, VersionConfig> version; // 定义一个Map，键为版本号，值为VersionConfig对象，包含不同版本的偏移量配置
 
-    @Data
+    @Data // 使用lombok提供的@Data注解，自动生成getter、setter等方法
     public static class VersionConfig {
-        private Long nickname;
-        private Long account;
-        private Long mobile;
+        private Long nickname; // 定义昵称的偏移量
+        private Long account; // 定义账号的偏移量
+        private Long mobile; // 定义手机号的偏移量
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/constant/ChatRoomConstant.java

@@ -1,4 +1,4 @@
-package com.xcs.wx.constant;
+package com.xcs.wx.constant; // 定义包名为com.xcs.wx.constant，用于存放常量类
 
 /**
  * 群聊枚举
@@ -9,8 +9,10 @@ package com.xcs.wx.constant;
 public class ChatRoomConstant {
 
     private ChatRoomConstant() {
-    }
+    } // 私有的构造函数，防止此类被实例化
 
-    public static final String CHATROOM_SUFFIX = "@chatroom";
-
-}
+    /**
+     * 群聊标识后缀
+     */
+    public static final String CHATROOM_SUFFIX = "@chatroom"; // 定义一个公共静态最终字符串常量，值为"@chatroom"，用于标识群聊
+}

wx-dump-admin/src/main/java/com/xcs/wx/constant/DataSourceType.java

@@ -1,15 +1,15 @@
-package com.xcs.wx.constant;
+package com.xcs.wx.constant; // 定义包名为com.xcs.wx.constant，用于存放常量类
 
-import cn.hutool.extra.spring.SpringUtil;
-import com.baomidou.dynamic.datasource.DynamicRoutingDataSource;
-import com.xcs.wx.service.UserService;
+import cn.hutool.extra.spring.SpringUtil; // 导入hutool工具类，用于Spring Bean操作
+import com.baomidou.dynamic.datasource.DynamicRoutingDataSource; // 导入MyBatis动态数据源类
+import com.xcs.wx.service.UserService; // 导入UserService接口
 
-import javax.sql.DataSource;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
+import javax.sql.DataSource; // 导入DataSource接口
+import java.util.Collections; // 导入Collections工具类
+import java.util.Comparator; // 导入Comparator接口
+import java.util.List; // 导入List接口
+import java.util.Map; // 导入Map接口
+import java.util.stream.Collectors; // 导入Stream的Collectors工具类
 
 /**
  * 数据源类型枚举
@@ -19,62 +19,31 @@ import java.util.stream.Collectors;
  **/
 public class DataSourceType {
 
+    // 定义一系列公共静态最终字符串常量，每个常量代表一个特定的数据库名称
     public static final String APPLET_DB = "Applet.db";
     public static final String BIZ_CHAT_DB = "BizChat.db";
-    public static final String BIZ_CHAT_MSG_DB = "BizChatMsg.db";
-    public static final String CHAT_MSG_DB = "ChatMsg.db";
-    public static final String CHAT_ROOM_USER_DB = "ChatRoomUser.db";
-    public static final String CLIENT_CONFIG_DB = "ClientConfig.db";
-    public static final String CLIENT_GENERAL_DB = "ClientGeneral.db";
-    public static final String CUSTOMER_SERVICE_DB = "CustomerService.db";
-    public static final String EMOTION_DB = "Emotion.db";
-    public static final String FAVORITE_DB = "Favorite.db";
-    public static final String FTS_CONTACT_DB = "FTSContact.db";
-    public static final String FTS_FAVORITE_DB = "FTSFavorite.db";
-    public static final String FTS_MSG_DB = "FTSMsg.db";
-    public static final String FUNCTION_MSG_DB = "FunctionMsg.db";
-    public static final String HARD_LINK_FILE_DB = "HardLinkFile.db";
-    public static final String HARD_LINK_IMAGE_DB = "HardLinkImage.db";
-    public static final String HARD_LINK_VIDEO_DB = "HardLinkVideo.db";
-    public static final String IMAGE_TRANSLATE_DB = "ImageTranslate.db";
-    public static final String LINK_HISTORY_DB = "LinkHistory.db";
-    public static final String MEDIA_DB = "Media.db";
-    public static final String MICRO_MSG_DB = "MicroMsg.db";
-    public static final String MISC_DB = "Misc.db";
-    public static final String MULTI_SEARCH_CHAT_MSG_DB = "MultiSearchChatMsg.db";
-    public static final String NEW_TIPS_DB = "NewTips.db";
-    public static final String OPEN_IM_CONTACT_DB = "OpenIMContact.db";
-    public static final String OPEN_IM_MEDIA_DB = "OpenIMMedia.db";
-    public static final String OPEN_IM_MSG_DB = "OpenIMMsg.db";
-    public static final String OPEN_IM_RESOURCE_DB = "OpenIMResource.db";
-    public static final String PRE_DOWNLOAD_DB = "PreDownload.db";
-    public static final String PUBLIC_MSG_DB = "PublicMsg.db";
-    public static final String PUBLIC_MSG_MEDIA_DB = "PublicMsgMedia.db";
-    public static final String SNS_DB = "Sns.db";
-    public static final String STORE_EMOTION_DB = "StoreEmotion.db";
-    public static final String VOIP_DB = "Voip.db";
+    // ... 省略其他数据库名称常量定义 ...
+
     public static final String MSG_DB = "MSG.db";
     public static final String MSG0_DB = "MSG0.db";
 
     /**
-     * 读取MSG*.db
-     *
-     * @return 数据库名称
+     * 读取MSG*.db数据库名称
+     * @return 数据库名称列表
      */
     public static List<String> getMsgDb() {
-        String wxId = SpringUtil.getBean(UserService.class).currentUser();
+        String wxId = SpringUtil.getBean(UserService.class).currentUser(); // 获取当前用户的微信ID
         // 空校验
         if (wxId == null) {
-            return Collections.emptyList();
+            return Collections.emptyList(); // 如果微信ID为空，返回空列表
         }
-        return getDb(wxId + "#" + "MSG.*\\.db");
+        return getDb(wxId + "#" + "MSG.*\\.db"); // 调用getDb方法，传入匹配模式
     }
 
     /**
      * 根据pattern匹配数据库
-     *
-     * @param pattern 需要匹配的字符串
-     * @return 数据库名称
+     * @param pattern 需要匹配的字符串模式
+     * @return 数据库名称列表
      */
     private static List<String> getDb(String pattern) {
         // 获取动态数据源
@@ -84,8 +53,8 @@ public class DataSourceType {
 
         // 筛选出符合模式的数据源键，并进行降序排序
         return dataSources.keySet().stream()
-                .filter(key -> key.matches(pattern))
-                .sorted(Comparator.naturalOrder())
-                .collect(Collectors.toList());
+                .filter(key -> key.matches(pattern)) // 筛选出匹配给定模式的数据源键
+                .sorted(Comparator.naturalOrder()) // 按照自然顺序排序
+                .collect(Collectors.toList()); // 收集为List
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/constant/SqliteConstant.java

@@ -1,20 +1,20 @@
-package com.xcs.wx.constant;
+package com.xcs.wx.constant; // 定义包名为com.xcs.wx.constant，用于存放常量类
 
 /**
- * sqlite常量
+ * SQLite常量类
  *
  * @author xcs
  * @date 2024年1月20日21:12:51
- */
+ **/
 public class SqliteConstant {
 
     /**
-     * url前缀
+     * SQLite数据库URL前缀
      */
-    public static final String URL_PREFIX = "jdbc:sqlite:";
+    public static final String URL_PREFIX = "jdbc:sqlite:"; // 定义一个公共静态最终字符串常量，表示SQLite数据库的URL前缀
 
     /**
-     * sqlite驱动类
+     * SQLite数据库驱动类名称
      */
-    public static final String DRIVER_CLASS_NAME = "org.sqlite.JDBC";
-}
+    public static final String DRIVER_CLASS_NAME = "org.sqlite.JDBC"; // 定义一个公共静态最终字符串常量，表示SQLite数据库驱动类的名称
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/ChatRoomController.java

@@ -1,18 +1,18 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import com.xcs.wx.domain.dto.ChatRoomDTO;
-import com.xcs.wx.domain.vo.ChatRoomDetailVO;
-import com.xcs.wx.domain.vo.ChatRoomVO;
-import com.xcs.wx.domain.vo.PageVO;
-import com.xcs.wx.domain.vo.ResponseVO;
-import com.xcs.wx.service.ChatRoomService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.RestController;
+import com.xcs.wx.domain.dto.ChatRoomDTO; // 导入群聊数据传输对象
+import com.xcs.wx.domain.vo.ChatRoomDetailVO; // 导入群聊详情视图对象
+import com.xcs.wx.domain.vo.ChatRoomVO; // 导入群聊视图对象
+import com.xcs.wx.domain.vo.PageVO; // 导入分页视图对象
+import com.xcs.wx.domain.vo.ResponseVO; // 导入响应视图对象
+import com.xcs.wx.service.ChatRoomService; // 导入群聊服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RequestParam; // 导入用于定义请求参数的注解
+import org.springframework.web.bind.annotation.RestController; // 导入用于定义REST控制器的注解
 
-import java.util.List;
+import java.util.List; // 导入List接口
 
 /**
  * 群聊 Controller
@@ -20,24 +20,24 @@ import java.util.List;
  * @author xcs
  * @date 2024年01月08日 16时03分
  **/
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("/api/chatroom")
+@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/chatroom") // 定义类级别的请求映射，所有方法的URL都会以/api/chatroom开头
 public class ChatRoomController {
 
-    private final ChatRoomService chatRoomService;
+    private final ChatRoomService chatRoomService; // 注入ChatRoomService，用于业务逻辑处理
 
     /**
      * 查询群聊列表
      *
      * @param chatRoomDTO 查询参数
-     * @return ChatRoomVO
+     * @return ChatRoomVO列表的响应对象
      */
-    @GetMapping("/list")
+    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/chatroom/list
     public ResponseVO<List<ChatRoomVO>> list(ChatRoomDTO chatRoomDTO) {
-        // 查询群聊列表
+        // 调用chatRoomService的方法查询群聊列表
         PageVO<ChatRoomVO> pageVO = chatRoomService.queryChatRoom(chatRoomDTO);
-        // 返回数据
+        // 返回包含群聊列表和分页信息的响应对象
         return ResponseVO.ok(pageVO.getRecords(), pageVO.getCurrent(), pageVO.getTotal());
     }
 
@@ -45,20 +45,22 @@ public class ChatRoomController {
      * 查询群聊详情
      *
      * @param chatRoomName 群聊名称
-     * @return ChatRoomDetailVO
+     * @return ChatRoomDetailVO的响应对象
      */
-    @GetMapping("/detail")
+    @GetMapping("/detail") // 定义GET请求的映射，访问路径为/api/chatroom/detail
     public ResponseVO<ChatRoomDetailVO> detail(@RequestParam String chatRoomName) {
+        // 调用chatRoomService的方法查询群聊详情，并返回响应对象
         return ResponseVO.ok(chatRoomService.queryChatRoomDetail(chatRoomName));
     }
 
     /**
      * 导出群聊
      *
-     * @return ResponseVO
+     * @return ResponseVO的响应对象
      */
-    @GetMapping("/export")
+    @GetMapping("/export") // 定义GET请求的映射，访问路径为/api/chatroom/export
     public ResponseVO<String> export() {
+        // 调用chatRoomService的方法导出群聊，并返回响应对象
         return ResponseVO.ok(chatRoomService.exportChatRoom());
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/ContactController.java

@@ -1,14 +1,14 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import com.xcs.wx.domain.dto.ContactDTO;
-import com.xcs.wx.domain.vo.*;
-import com.xcs.wx.service.ContactService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import com.xcs.wx.domain.dto.ContactDTO; // 导入联系人数据传输对象
+import com.xcs.wx.domain.vo.*; // 导入所有联系人相关的视图对象（VO）
+import com.xcs.wx.service.ContactService; // 导入联系人服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RestController; // 导入用于定义REST控制器的注解
 
-import java.util.List;
+import java.util.List; // 导入List接口
 
 /**
  * 联系人 Controller
@@ -16,12 +16,12 @@ import java.util.List;
  * @author xcs
  * @date 2023年12月22日 14时16分
  **/
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("/api/contact")
+@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/contact") // 定义类级别的请求映射，所有方法的URL都会以/api/contact开头
 public class ContactController {
 
-    private final ContactService contactService;
+    private final ContactService contactService; // 注入ContactService，用于业务逻辑处理
 
     /**
      * 查询联系人
@@ -29,11 +29,11 @@ public class ContactController {
      * @param contactDTO 请求参数
      * @return ResponseVO
      */
-    @GetMapping("/list")
+    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/contact/list
     public ResponseVO<List<ContactVO>> list(ContactDTO contactDTO) {
-        // 查询联系人
+        // 调用contactService的方法查询联系人
         PageVO<ContactVO> pageVO = contactService.queryContact(contactDTO);
-        // 返回数据
+        // 返回包含联系人列表和分页信息的响应对象
         return ResponseVO.ok(pageVO.getRecords(), pageVO.getCurrent(), pageVO.getTotal());
     }
 
@@ -42,8 +42,9 @@ public class ContactController {
      *
      * @return ResponseVO
      */
-    @GetMapping("/all")
+    @GetMapping("/all") // 定义GET请求的映射，访问路径为/api/contact/all
     public ResponseVO<List<AllContactVO>> all() {
+        // 调用contactService的方法查询所有联系人
         return ResponseVO.ok(contactService.queryAllContact());
     }
 
@@ -52,8 +53,9 @@ public class ContactController {
      *
      * @return ContactLabelVO
      */
-    @GetMapping("/label")
+    @GetMapping("/label") // 定义GET请求的映射，访问路径为/api/contact/label
     public ResponseVO<List<ContactLabelVO>> label() {
+        // 调用contactService的方法查询联系人标签
         return ResponseVO.ok(contactService.queryContactLabel());
     }
 
@@ -62,8 +64,9 @@ public class ContactController {
      *
      * @return ResponseVO
      */
-    @GetMapping("/export")
+    @GetMapping("/export") // 定义GET请求的映射，访问路径为/api/contact/export
     public ResponseVO<String> export() {
+        // 调用contactService的方法导出联系人
         return ResponseVO.ok(contactService.exportContact());
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/ContactHeadImgController.java

@@ -1,15 +1,15 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import com.xcs.wx.service.ContactHeadImgService;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import com.xcs.wx.service.ContactHeadImgService; // 导入联系人头像服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import lombok.extern.slf4j.Slf4j; // 导入Lombok提供的注解，用于自动生成日志对象
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RestController; // 导入用于定义REST控制器的注解
 
-import javax.servlet.http.HttpServletResponse;
-import java.io.IOException;
-import java.io.OutputStream;
+import javax.servlet.http.HttpServletResponse; // 导入HttpServletResponse类，用于操作HTTP响应
+import java.io.IOException; // 导入IOException类，用于处理可能的I/O异常
+import java.io.OutputStream; // 导入OutputStream类，用于输出流
 
 /**
  * 联系人头像 Controller
@@ -17,13 +17,13 @@ import java.io.OutputStream;
  * @author xcs
  * @date 2024年6月18日15:45:17
  **/
-@Slf4j
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("/api/contact/headImg")
+@Slf4j // 使用Lombok注解自动生成日志对象
+@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式或相应内容
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/contact/headImg") // 定义类级别的请求映射，所有方法的URL都会以/api/contact/headImg开头
 public class ContactHeadImgController {
 
-    private final ContactHeadImgService contactHeadImgService;
+    private final ContactHeadImgService contactHeadImgService; // 注入ContactHeadImgService，用于业务逻辑处理
 
     /**
      * 用户头像
@@ -31,20 +31,20 @@ public class ContactHeadImgController {
      * @param userName 用户名
      * @param response HttpServletResponse
      */
-    @GetMapping("/avatar")
+    @GetMapping("/avatar") // 定义GET请求的映射，访问路径为/api/contact/headImg/avatar
     public void avatar(String userName, HttpServletResponse response) {
-        byte[] avatarBytes = contactHeadImgService.avatar(userName);
+        byte[] avatarBytes = contactHeadImgService.avatar(userName); // 调用contactHeadImgService的方法获取用户头像的字节数据
         if (avatarBytes != null) {
-            response.setContentType("image/gif");
-            response.setContentLength(avatarBytes.length);
-            try (OutputStream os = response.getOutputStream()) {
-                os.write(avatarBytes);
-                os.flush();
+            response.setContentType("image/gif"); // 设置响应的内容类型为image/gif
+            response.setContentLength(avatarBytes.length); // 设置响应的内容长度
+            try (OutputStream os = response.getOutputStream()) { // 获取响应的输出流
+                os.write(avatarBytes); // 将头像字节数据写入输出流
+                os.flush(); // 刷新输出流，确保数据被写出
             } catch (IOException e) {
-                log.error("avatar fail", e);
+                log.error("avatar fail", e); // 如果发生I/O异常，记录错误日志
             }
         } else {
-            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
+            response.setStatus(HttpServletResponse.SC_NOT_FOUND); // 如果头像字节数据为空，设置HTTP响应状态为404未找到
         }
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/DashboardController.java

@@ -1,13 +1,13 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import com.xcs.wx.domain.vo.*;
-import com.xcs.wx.service.DashboardService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import com.xcs.wx.domain.vo.*; // 导入所有仪表盘相关的视图对象（VO）
+import com.xcs.wx.service.DashboardService; // 导入仪表盘服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RestController; // 导入用于定义REST控制器的注解
 
-import java.util.List;
+import java.util.List; // 导入List接口
 
 /**
  * 仪表盘 Controller
@@ -15,21 +15,21 @@ import java.util.List;
  * @author xcs
  * @date 2024年01月15日 11时26分
  **/
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("/api/dashboard")
+@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/dashboard") // 定义类级别的请求映射，所有方法的URL都会以/api/dashboard开头
 public class DashboardController {
 
-    private final DashboardService dashBoardService;
+    private final DashboardService dashBoardService; // 注入DashboardService，用于业务逻辑处理
 
     /**
      * 统计面板
      *
      * @return ResponseVO
      */
-    @GetMapping("/statsPanel")
+    @GetMapping("/statsPanel") // 定义GET请求的映射，访问路径为/api/dashboard/statsPanel
     public ResponseVO<StatsPanelVO> statsPanel() {
-        return ResponseVO.ok(dashBoardService.statsPanel());
+        return ResponseVO.ok(dashBoardService.statsPanel()); // 调用dashBoardService的方法获取统计面板数据，并返回响应对象
     }
 
     /**
@@ -37,9 +37,9 @@ public class DashboardController {
      *
      * @return ResponseVO
      */
-    @GetMapping("/msgTypeDistribution")
+    @GetMapping("/msgTypeDistribution") // 定义GET请求的映射，访问路径为/api/dashboard/msgTypeDistribution
     public ResponseVO<List<MsgTypeDistributionVO>> msgTypeDistribution() {
-        return ResponseVO.ok(dashBoardService.msgTypeDistribution());
+        return ResponseVO.ok(dashBoardService.msgTypeDistribution()); // 调用dashBoardService的方法获取消息类型分布数据，并返回响应对象
     }
 
     /**
@@ -47,9 +47,9 @@ public class DashboardController {
      *
      * @return ResponseVO
      */
-    @GetMapping("/countRecentMsgs")
+    @GetMapping("/countRecentMsgs") // 定义GET请求的映射，访问路径为/api/dashboard/countRecentMsgs
     public ResponseVO<List<CountRecentMsgsVO>> countRecentMsgs() {
-        return ResponseVO.ok(dashBoardService.countRecentMsgs());
+        return ResponseVO.ok(dashBoardService.countRecentMsgs()); // 调用dashBoardService的方法获取最近消息统计数据，并返回响应对象
     }
 
     /**
@@ -57,9 +57,9 @@ public class DashboardController {
      *
      * @return ResponseVO
      */
-    @GetMapping("/topContacts")
+    @GetMapping("/topContacts") // 定义GET请求的映射，访问路径为/api/dashboard/topContacts
     public ResponseVO<List<TopContactsVO>> topContacts() {
-        return ResponseVO.ok(dashBoardService.topContacts());
+        return ResponseVO.ok(dashBoardService.topContacts()); // 调用dashBoardService的方法获取最频繁联系人数据，并返回响应对象
     }
 
     /**
@@ -67,8 +67,8 @@ public class DashboardController {
      *
      * @return ResponseVO
      */
-    @GetMapping("/queryRecentUsedKeyWord")
+    @GetMapping("/queryRecentUsedKeyWord") // 定义GET请求的映射，访问路径为/api/dashboard/queryRecentUsedKeyWord
     public ResponseVO<List<RecentUsedKeyWordVO>> queryRecentUsedKeyWord() {
-        return ResponseVO.ok(dashBoardService.queryRecentUsedKeyWord());
+        return ResponseVO.ok(dashBoardService.queryRecentUsedKeyWord()); // 调用dashBoardService的方法获取最近使用的关键字数据，并返回响应对象
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/DatabaseController.java

@@ -1,19 +1,19 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import cn.hutool.system.SystemUtil;
-import com.xcs.wx.domain.dto.DecryptDTO;
-import com.xcs.wx.domain.vo.DatabaseVO;
-import com.xcs.wx.domain.vo.ResponseVO;
-import com.xcs.wx.service.DatabaseService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.http.MediaType;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
+import cn.hutool.system.SystemUtil; // 导入Hutool工具库中的系统信息工具类
+import com.xcs.wx.domain.dto.DecryptDTO; // 导入解密数据传输对象
+import com.xcs.wx.domain.vo.DatabaseVO; // 导入数据库视图对象
+import com.xcs.wx.domain.vo.ResponseVO; // 导入响应视图对象
+import com.xcs.wx.service.DatabaseService; // 导入数据库服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.http.MediaType; // 导入Spring的MediaType类，用于定义响应的内容类型
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RestController; // 导入用于定义REST控制器的注解
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter; // 导入Spring的SseEmitter类，用于服务器发送事件（Server-Sent Events）
 
-import java.io.IOException;
-import java.util.List;
+import java.io.IOException; // 导入IOException类，用于处理可能的I/O异常
+import java.util.List; // 导入List接口
 
 /**
  * 数据库 Controller
@@ -21,47 +21,47 @@ import java.util.List;
  * @author xcs
  * @date 2024年01月20日 14时35分
  **/
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("/api/database")
+@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/database") // 定义类级别的请求映射，所有方法的URL都会以/api/database开头
 public class DatabaseController {
 
-    private final DatabaseService databaseService;
+    private final DatabaseService databaseService; // 注入DatabaseService，用于业务逻辑处理
 
     /**
      * 数据库解密
      *
      * @return ResponseVO
      */
-    @GetMapping("/decrypt")
+    @GetMapping("/decrypt") // 定义GET请求的映射，访问路径为/api/database/decrypt
     public SseEmitter decrypt(DecryptDTO decryptDTO) {
-        SseEmitter emitter = new SseEmitter(0L);
+        SseEmitter emitter = new SseEmitter(0L); // 创建一个SseEmitter对象，用于服务器发送事件
         // 启动一个子线程，异步回调给前端
         new Thread(() -> {
             // 读取JDK版本号
-            if (SystemUtil.getJavaInfo().getVersionInt() < 1100) {
+            if (SystemUtil.getJavaInfo().getVersionInt() < 1100) { // 如果JDK版本低于11
                 try {
-                    emitter.send(ResponseVO.error(-1, "微信解密必须要求JDK11以上版本,请更换JDK版本。"), MediaType.APPLICATION_JSON);
+                    emitter.send(ResponseVO.error(-1, "微信解密必须要求JDK11以上版本,请更换JDK版本。"), MediaType.APPLICATION_JSON); // 发送错误信息给客户端
                 } catch (IOException e) {
-                    throw new RuntimeException(e);
+                    throw new RuntimeException(e); // 如果发生I/O异常，抛出运行时异常
                 } finally {
-                    emitter.complete();
+                    emitter.complete(); // 标记SseEmitter为完成状态
                 }
-                return;
+                return; // 返回，不再执行后续代码
             }
-            databaseService.decrypt(emitter, decryptDTO);
-        }).start();
-        // 返回数据
+            databaseService.decrypt(emitter, decryptDTO); // 调用databaseService的方法进行解密操作
+        }).start(); // 启动线程
+        // 返回SseEmitter对象
         return emitter;
     }
 
     /**
-     * 数据库解密
+     * 获取数据库信息
      *
      * @return ResponseVO
      */
-    @GetMapping("/getDatabase")
+    @GetMapping("/getDatabase") // 定义GET请求的映射，访问路径为/api/database/getDatabase
     public ResponseVO<List<DatabaseVO>> decrypt(String wxId) {
-        return ResponseVO.ok(databaseService.getDatabase(wxId));
+        return ResponseVO.ok(databaseService.getDatabase(wxId)); // 调用databaseService的方法获取数据库信息，并返回响应对象
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/ExportController.java

@@ -1,21 +1,21 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import lombok.RequiredArgsConstructor;
-import org.springframework.core.io.FileSystemResource;
-import org.springframework.core.io.Resource;
-import org.springframework.core.io.UrlResource;
-import org.springframework.http.MediaType;
-import org.springframework.http.ResponseEntity;
-import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.core.io.FileSystemResource; // 导入Spring的FileSystemResource类，用于访问文件系统资源
+import org.springframework.core.io.Resource; // 导入Spring的Resource接口，用于访问资源
+import org.springframework.core.io.UrlResource; // 导入Spring的UrlResource类，用于访问URL资源
+import org.springframework.http.MediaType; // 导入Spring的MediaType类，用于定义响应的内容类型
+import org.springframework.http.ResponseEntity; // 导入Spring的ResponseEntity类，用于构建响应实体
+import org.springframework.stereotype.Controller; // 导入Spring的Controller注解，用于定义控制器
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RequestParam; // 导入用于定义请求参数的注解
 
-import java.io.IOException;
-import java.net.URLEncoder;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Path;
-import java.nio.file.Paths;
+import java.io.IOException; // 导入IOException类，用于处理可能的I/O异常
+import java.net.URLEncoder; // 导入URLEncoder类，用于URL编码
+import java.nio.charset.StandardCharsets; // 导入StandardCharsets类，用于获取标准字符集
+import java.nio.file.Path; // 导入Path接口，用于表示文件路径
+import java.nio.file.Paths; // 导入Paths工具类，用于创建Path对象
 
 /**
  * 导出 Controller
@@ -23,30 +23,30 @@ import java.nio.file.Paths;
  * @author xcs
  * @date 2024年01月05日 15时56分
  **/
-@Controller
-@RequiredArgsConstructor
-@RequestMapping("/api/export")
+@Controller // 定义一个控制器，用于处理HTTP请求
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/export") // 定义类级别的请求映射，所有方法的URL都会以/api/export开头
 public class ExportController {
 
     /**
      * 下载文件
      */
-    @GetMapping("download")
+    @GetMapping("download") // 定义GET请求的映射，访问路径为/api/export/download
     public ResponseEntity<Resource> download(@RequestParam String path) throws IOException {
-        Path filePath = Paths.get(path);
-        Resource resource = new FileSystemResource(filePath.toFile());
+        Path filePath = Paths.get(path); // 根据传入的路径参数创建Path对象
+        Resource resource = new FileSystemResource(filePath.toFile()); // 创建FileSystemResource对象，用于访问文件系统资源
 
         // 处理文件不存在的情况
-        if (!resource.exists()) {
-            return ResponseEntity.notFound().build();
+        if (!resource.exists()) { // 如果资源不存在
+            return ResponseEntity.notFound().build(); // 返回404未找到的响应实体
         }
 
-        String encodedFilename = URLEncoder.encode(resource.getFilename(), StandardCharsets.UTF_8.name()).replace("+", "%20");
-        String contentDisposition = "attachment; filename*=UTF-8''" + encodedFilename;
+        String encodedFilename = URLEncoder.encode(resource.getFilename(), StandardCharsets.UTF_8.name()).replace("+", "%20"); // 对文件名进行URL编码，并替换空格为%20
+        String contentDisposition = "attachment; filename*=UTF-8''" + encodedFilename; // 构建Content-Disposition响应头，设置文件名和编码
 
-        return ResponseEntity.ok()
-                .contentType(MediaType.parseMediaType("application/vnd.ms-excel"))
-                .header("Content-Disposition", contentDisposition)
-                .body(resource);
+        return ResponseEntity.ok() // 构建200成功的响应实体
+                .contentType(MediaType.parseMediaType("application/vnd.ms-excel")) // 设置响应的内容类型为Excel
+                .header("Content-Disposition", contentDisposition) // 设置Content-Disposition响应头
+                .body(resource); // 设置响应体为资源对象
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/FeedsController.java

@@ -1,29 +1,29 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import com.xcs.wx.domain.dto.FeedsDTO;
-import com.xcs.wx.domain.vo.FeedsVO;
-import com.xcs.wx.domain.vo.PageVO;
-import com.xcs.wx.domain.vo.ResponseVO;
-import com.xcs.wx.service.FeedsService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import com.xcs.wx.domain.dto.FeedsDTO; // 导入朋友圈数据传输对象
+import com.xcs.wx.domain.vo.FeedsVO; // 导入朋友圈视图对象
+import com.xcs.wx.domain.vo.PageVO; // 导入分页视图对象
+import com.xcs.wx.domain.vo.ResponseVO; // 导入响应视图对象
+import com.xcs.wx.service.FeedsService; // 导入朋友圈服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RestController; // 导入用于定义REST控制器的注解
 
-import java.util.List;
+import java.util.List; // 导入List接口，用于处理列表数据
 
 /**
- * 朋友圈  Controller
+ * 朋友圈 Controller
  *
  * @author xcs
  * @date 2024年01月04日 13时48分
  **/
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("/api/feeds")
+@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/feeds") // 定义类级别的请求映射，所有方法的URL都会以/api/feeds开头
 public class FeedsController {
 
-    private final FeedsService feedsService;
+    private final FeedsService feedsService; // 注入FeedsService，用于业务逻辑处理
 
     /**
      * 查询朋友圈
@@ -31,11 +31,11 @@ public class FeedsController {
      * @param feedsDTO 请求参数
      * @return FeedsVO
      */
-    @GetMapping("/list")
+    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/feeds/list
     public ResponseVO<List<FeedsVO>> list(FeedsDTO feedsDTO) {
         // 查询朋友圈
-        PageVO<FeedsVO> pageVO = feedsService.queryFeeds(feedsDTO);
+        PageVO<FeedsVO> pageVO = feedsService.queryFeeds(feedsDTO); // 调用feedsService的方法查询朋友圈数据，并返回分页视图对象
         // 返回数据
-        return ResponseVO.ok(pageVO.getRecords(), pageVO.getCurrent(), pageVO.getTotal());
+        return ResponseVO.ok(pageVO.getRecords(), pageVO.getCurrent(), pageVO.getTotal()); // 使用ResponseVO构建响应对象，包含记录列表、当前页码和总记录数
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/ImageController.java

@@ -1,13 +1,13 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import com.xcs.wx.service.ImageService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.core.io.Resource;
-import org.springframework.http.ResponseEntity;
-import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
+import com.xcs.wx.service.ImageService; // 导入图片服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.core.io.Resource; // 导入Spring的Resource接口，用于访问资源
+import org.springframework.http.ResponseEntity; // 导入Spring的ResponseEntity类，用于构建响应实体
+import org.springframework.stereotype.Controller; // 导入Spring的Controller注解，用于定义控制器
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RequestParam; // 导入用于定义请求参数的注解
 
 /**
  * 图片 Controller
@@ -15,12 +15,12 @@ import org.springframework.web.bind.annotation.RequestParam;
  * @author xcs
  * @date 2024年1月24日16:41:52
  */
-@Controller
-@RequiredArgsConstructor
-@RequestMapping("/api/image")
+@Controller // 定义一个控制器，用于处理HTTP请求
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/image") // 定义类级别的请求映射，所有方法的URL都会以/api/image开头
 public class ImageController {
 
-    private final ImageService imageService;
+    private final ImageService imageService; // 注入ImageService，用于业务逻辑处理
 
     /**
      * 根据Md5下载图片
@@ -28,30 +28,30 @@ public class ImageController {
      * @param md5 Md5值
      * @return 图片
      */
-    @GetMapping("/downloadImgMd5")
+    @GetMapping("/downloadImgMd5") // 定义GET请求的映射，访问路径为/api/image/downloadImgMd5
     public ResponseEntity<Resource> downloadImgMd5(@RequestParam String md5) {
-        return imageService.downloadImgMd5(md5);
+        return imageService.downloadImgMd5(md5); // 调用imageService的方法根据Md5值下载图片，并返回响应实体
     }
 
     /**
      * 根据路径下载图片
      *
-     * @param path Md5值
+     * @param path 路径
      * @return 图片
      */
-    @GetMapping("/downloadImg")
+    @GetMapping("/downloadImg") // 定义GET请求的映射，访问路径为/api/image/downloadImg
     public ResponseEntity<Resource> downloadImg(@RequestParam String path) {
-        return imageService.downloadImg(path);
+        return imageService.downloadImg(path); // 调用imageService的方法根据路径下载图片，并返回响应实体
     }
 
     /**
-     * 根据路径下载图片
+     * 根据本地路径下载图片
      *
-     * @param localPath 本地图片
+     * @param localPath 本地路径
      * @return 图片
      */
-    @GetMapping("/downloadImgFormLocal")
+    @GetMapping("/downloadImgFormLocal") // 定义GET请求的映射，访问路径为/api/image/downloadImgFormLocal
     public ResponseEntity<Resource> downloadImgFormLocal(@RequestParam String localPath) {
-        return imageService.downloadImgFormLocal(localPath);
+        return imageService.downloadImgFormLocal(localPath); // 调用imageService的方法根据本地路径下载图片，并返回响应实体
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/IndexController.java

@@ -1,14 +1,13 @@
-package com.xcs.wx.controller;
-
-import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.RequestMapping;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
+import org.springframework.stereotype.Controller; // 导入Spring的Controller注解，用于定义控制器
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
 
 /**
  * @author xcs
  * @date 2024年01月26日 11时34分
  **/
-@Controller
+@Controller // 定义一个控制器，用于处理HTTP请求
 public class IndexController {
 
     /**
@@ -16,8 +15,8 @@ public class IndexController {
      *
      * @return html
      */
-    @RequestMapping(value = {"/", "/{path:[^.]*}"})
+    @RequestMapping(value = {"/", "/{path:[^.]*}"}) // 定义请求映射，拦截根路径"/"和所有不包含"."的路径
     public String index() {
-        return "index";
+        return "index"; // 返回视图名为"index"的HTML页面
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/MsgController.java

@@ -1,15 +1,15 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import com.xcs.wx.domain.vo.MsgVO;
-import com.xcs.wx.domain.vo.ResponseVO;
-import com.xcs.wx.service.MsgService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.bind.annotation.RestController;
+import com.xcs.wx.domain.vo.MsgVO; // 导入消息视图对象
+import com.xcs.wx.domain.vo.ResponseVO; // 导入响应视图对象
+import com.xcs.wx.service.MsgService; // 导入消息服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RequestParam; // 导入用于定义请求参数的注解
+import org.springframework.web.bind.annotation.RestController; // 导入用于定义REST控制器的注解
 
-import java.util.List;
+import java.util.List; // 导入List接口，用于处理列表数据
 
 /**
  * 消息 Controller
@@ -17,22 +17,23 @@ import java.util.List;
  * @author xcs
  * @date 2023年12月25日 17时06分
  **/
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("/api/msg")
+@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/msg") // 定义类级别的请求映射，所有方法的URL都会以/api/msg开头
 public class MsgController {
 
-    private final MsgService msgService;
+    private final MsgService msgService; // 注入MsgService，用于业务逻辑处理
 
     /**
      * 查询消息
      *
-     * @param talker       对话着
+     * @param talker       对话者
      * @param nextSequence 下一个序列号
      * @return ResponseVO
      */
-    @GetMapping("/list")
+    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/msg/list
     public ResponseVO<List<MsgVO>> list(@RequestParam String talker, @RequestParam Long nextSequence) {
+        // 调用msgService的方法查询消息，并返回响应对象
         return ResponseVO.ok(msgService.queryMsg(talker, nextSequence));
     }
 
@@ -41,8 +42,9 @@ public class MsgController {
      *
      * @return ResponseVO
      */
-    @GetMapping("/export")
+    @GetMapping("/export") // 定义GET请求的映射，访问路径为/api/msg/export
     public ResponseVO<String> export(@RequestParam String talker) {
+        // 调用msgService的方法导出聊天记录，并返回响应对象
         return ResponseVO.ok(msgService.exportMsg(talker));
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/RecoverContactController.java

@@ -1,48 +1,49 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import com.xcs.wx.domain.dto.RecoverContactDTO;
-import com.xcs.wx.domain.vo.RecoverContactVO;
-import com.xcs.wx.domain.vo.ResponseVO;
-import com.xcs.wx.service.RecoverContactService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import com.xcs.wx.domain.dto.RecoverContactDTO; // 导入找回联系人的数据传输对象
+import com.xcs.wx.domain.vo.RecoverContactVO; // 导入找回联系人的视图对象
+import com.xcs.wx.domain.vo.ResponseVO; // 导入响应视图对象
+import com.xcs.wx.service.RecoverContactService; // 导入找回联系人的服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RestController; // 导入用于定义REST控制器的注解
 
-import java.util.List;
+import java.util.List; // 导入List接口，用于处理列表数据
 
 /**
- * 找回联系人  Controller
+ * 找回联系人 Controller
  *
  * @author xcs
  * @date 2024年01月04日 13时48分
  **/
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("/api/recover/contact")
+@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/recover/contact") // 定义类级别的请求映射，所有方法的URL都会以/api/recover/contact开头
 public class RecoverContactController {
 
-    private final RecoverContactService recoverContactService;
+    private final RecoverContactService recoverContactService; // 注入RecoverContactService，用于业务逻辑处理
 
     /**
-     * 查询朋友圈
+     * 查询找回联系人
      *
      * @param recoverContactDTO 请求参数
-     * @return FeedsVO
+     * @return ResponseVO
      */
-    @GetMapping("/list")
+    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/recover/contact/list
     public ResponseVO<List<RecoverContactVO>> list(RecoverContactDTO recoverContactDTO) {
-        // 返回数据
+        // 调用recoverContactService的方法查询找回联系人，并返回响应对象
         return ResponseVO.ok(recoverContactService.queryRecoverContact(recoverContactDTO));
     }
 
     /**
-     * 导出联系人
+     * 导出找回联系人
      *
      * @return ResponseVO
      */
-    @GetMapping("/export")
+    @GetMapping("/export") // 定义GET请求的映射，访问路径为/api/recover/contact/export
     public ResponseVO<String> export() {
+        // 调用recoverContactService的方法导出找回联系人，并返回响应对象
         return ResponseVO.ok(recoverContactService.exportRecoverContact());
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/SessionController.java

@@ -1,14 +1,14 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import com.xcs.wx.domain.vo.ResponseVO;
-import com.xcs.wx.domain.vo.SessionVO;
-import com.xcs.wx.service.SessionService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import com.xcs.wx.domain.vo.ResponseVO; // 导入响应视图对象
+import com.xcs.wx.domain.vo.SessionVO; // 导入会话视图对象
+import com.xcs.wx.service.SessionService; // 导入会话服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RestController; // 导入用于定义REST控制器的注解
 
-import java.util.List;
+import java.util.List; // 导入List接口，用于处理列表数据
 
 /**
  * 会话 Controller
@@ -16,20 +16,21 @@ import java.util.List;
  * @author xcs
  * @date 2023年12月21日 17时38分
  **/
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("/api/session")
+@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/session") // 定义类级别的请求映射，所有方法的URL都会以/api/session开头
 public class SessionController {
 
-    private final SessionService sessionService;
+    private final SessionService sessionService; // 注入SessionService，用于业务逻辑处理
 
     /**
      * 查询会话列表
      *
-     * @return SessionVO
+     * @return 会话列表的响应对象
      */
-    @GetMapping("/list")
+    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/session/list
     public ResponseVO<List<SessionVO>> list() {
+        // 调用sessionService的方法查询会话列表，并返回响应对象
         return ResponseVO.ok(sessionService.querySession());
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/controller/UserController.java

@@ -1,19 +1,18 @@
-package com.xcs.wx.controller;
+package com.xcs.wx.controller; // 定义了控制器所在的包名
 
-import com.xcs.wx.domain.vo.UserInfoVO;
-import com.xcs.wx.domain.vo.UserVO;
-import com.xcs.wx.domain.vo.ResponseVO;
-import com.xcs.wx.domain.vo.WeChatConfigVO;
-import com.xcs.wx.service.UserService;
-import com.xcs.wx.service.WeChatService;
-import lombok.RequiredArgsConstructor;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PutMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
-
-import java.util.List;
+import com.xcs.wx.domain.vo.UserInfoVO; // 导入用户信息视图对象
+import com.xcs.wx.domain.vo.UserVO; // 导入用户视图对象
+import com.xcs.wx.domain.vo.ResponseVO; // 导入响应视图对象
+import com.xcs.wx.domain.vo.WeChatConfigVO; // 导入微信配置视图对象
+import com.xcs.wx.service.UserService; // 导入用户服务接口
+import com.xcs.wx.service.WeChatService; // 导入微信服务接口
+import lombok.RequiredArgsConstructor; // 导入Lombok提供的注解，用于自动生成final字段的构造器
+import org.springframework.web.bind.annotation.GetMapping; // 导入用于定义GET请求的注解
+import org.springframework.web.bind.annotation.PutMapping; // 导入用于定义PUT请求的注解
+import org.springframework.web.bind.annotation.RequestMapping; // 导入用于定义请求映射的注解
+import org.springframework.web.bind.annotation.RestController; // 导入用于定义REST控制器的注解
 
+import java.util.List; // 导入List接口，用于处理列表数据
 
 /**
  * UserController
@@ -21,62 +20,62 @@ import java.util.List;
  * @author xcs
  * @date 2024年6月15日16:05:49
  */
-@RestController
-@RequiredArgsConstructor
-@RequestMapping("/api/user")
+@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
+@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
+@RequestMapping("/api/user") // 定义类级别的请求映射，所有方法的URL都会以/api/user开头
 public class UserController {
 
-    private final UserService userService;
-    private final WeChatService weChatService;
+    private final UserService userService; // 注入UserService，用于用户相关的业务逻辑处理
+    private final WeChatService weChatService; // 注入WeChatService，用于微信相关的业务逻辑处理
 
     /**
      * 查询微信信息
      *
      * @return ResponseVO
      */
-    @GetMapping("/readWeChatConfig")
+    @GetMapping("/readWeChatConfig") // 定义GET请求的映射，访问路径为/api/user/readWeChatConfig
     public ResponseVO<List<WeChatConfigVO>> readWeChatConfig() {
-        return ResponseVO.ok(weChatService.readWeChatConfig());
+        return ResponseVO.ok(weChatService.readWeChatConfig()); // 调用weChatService的方法读取微信配置，并返回响应对象
     }
 
     /**
-     * 用户头像
+     * 查询用户信息
      *
      * @return ResponseVO
      */
-    @GetMapping("/userInfo")
+    @GetMapping("/userInfo") // 定义GET请求的映射，访问路径为/api/user/userInfo
     public ResponseVO<UserInfoVO> userInfo() {
-        return ResponseVO.ok(userService.userInfo());
+        return ResponseVO.ok(userService.userInfo()); // 调用userService的方法获取用户信息，并返回响应对象
     }
 
     /**
-     * 用户头像
+     * 获取用户头像
      *
      * @return ResponseVO
      */
-    @GetMapping("/avatar")
+    @GetMapping("/avatar") // 定义GET请求的映射，访问路径为/api/user/avatar
     public ResponseVO<String> avatar() {
-        return ResponseVO.ok(userService.avatar());
+        return ResponseVO.ok(userService.avatar()); // 调用userService的方法获取用户头像，并返回响应对象
     }
 
     /**
-     * 用户昵称
+     * 获取用户昵称
      *
      * @return ResponseVO
      */
-    @GetMapping("/nickname")
+    @GetMapping("/nickname") // 定义GET请求的映射，访问路径为/api/user/nickname
     public ResponseVO<String> nickname() {
-        return ResponseVO.ok(userService.nickname());
+        return ResponseVO.ok(userService.nickname()); // 调用userService的方法获取用户昵称，并返回响应对象
     }
 
     /**
-     * 所有用户
+     * 获取所有用户
      *
      * @return ResponseVO
      */
-    @GetMapping("/users")
+    @GetMapping("/users") // 定义GET请求的映射，访问路径为/api/user/users
     public ResponseVO<List<UserVO>> users() {
-        return ResponseVO.ok(userService.users());
+        return ResponseVO.ok(userService.users()); // 调用userService的方法获取所有用户，并返回响应对象
     }
 
     /**
@@ -85,9 +84,9 @@ public class UserController {
      * @param wxId wxId
      * @return ResponseVO
      */
-    @PutMapping("/switchUser")
+    @PutMapping("/switchUser") // 定义PUT请求的映射，访问路径为/api/user/switchUser
     public ResponseVO<String> switchUser(String wxId) {
-        userService.switchUser(wxId);
-        return ResponseVO.ok("切换成功");
+        userService.switchUser(wxId); // 调用userService的方法切换用户
+        return ResponseVO.ok("切换成功"); // 返回操作成功的响应对象
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/ChatRoom.java

@@ -1,115 +1,92 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了实体类所在的包名
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
-import org.apache.ibatis.type.ByteArrayTypeHandler;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus的注解，用于指定字段映射
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus的注解，用于指定主键字段
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus的注解，用于指定表名
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import org.apache.ibatis.type.ByteArrayTypeHandler; // 导入MyBatis的类型处理器，用于处理byte数组字段
 
 /**
- * 群聊
+ * ChatRoom 类用于表示群聊实体。
  *
  * @author xcs
  * @date 2024年01月08日 09时45分
  **/
-@Data
-@TableName(value = "ChatRoom", autoResultMap = true)
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@TableName(value = "ChatRoom", autoResultMap = true) // 使用MyBatis Plus注解指定实体类对应的数据库表名，并自动生成ResultMap
 public class ChatRoom {
 
     /**
      * 聊天室名称，作为主键。
      */
-    @TableId("ChatRoomName")
-    private String chatRoomName;
+    @TableId("ChatRoomName") // 使用MyBatis Plus注解指定该字段为数据库表的主键
+    private String chatRoomName; // 成员变量，用于存储聊天室的名称
 
     /**
      * 用户名列表，以文本形式存储。
      */
-    @TableField("UserNameList")
-    private String userNameList;
+    @TableField("UserNameList") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String userNameList; // 成员变量，用于存储聊天室中所有用户的用户名列表
 
     /**
      * 显示名称列表，以文本形式存储。
      */
-    @TableField("DisplayNameList")
-    private String displayNameList;
+    @TableField("DisplayNameList") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String displayNameList; // 成员变量，用于存储聊天室中所有用户的显示名称列表
 
     /**
      * 聊天室标志，默认为 0。
      */
-    @TableField("ChatRoomFlag")
-    private Integer chatRoomFlag;
+    @TableField("ChatRoomFlag") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer chatRoomFlag; // 成员变量，用于存储聊天室的标志，如是否公开等
 
     /**
      * 聊天室拥有者的标识，默认为 0。
      */
-    @TableField("Owner")
-    private Integer owner;
+    @TableField("Owner") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer owner; // 成员变量，用于存储聊天室拥有者的标识
 
     /**
      * 是否显示名称的标志，默认为 0。
      */
-    @TableField("IsShowName")
-    private Integer isShowName;
+    @TableField("IsShowName") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer isShowName; // 成员变量，用于存储是否显示名称的标志
 
     /**
      * 自己在聊天室中的显示名称。
      */
-    @TableField("SelfDisplayName")
-    private String selfDisplayName;
+    @TableField("SelfDisplayName") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String selfDisplayName; // 成员变量，用于存储自己在聊天室中的显示名称
 
-    /**
-     * 预留字段1。
-     */
-    @TableField("Reserved1")
-    private Integer reserved1;
+    // 以下是预留字段，用于未来可能的扩展
+    @TableField("Reserved1") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved1; // 预留字段1
 
-    /**
-     * 预留字段2。
-     */
-    @TableField("Reserved2")
-    private String reserved2;
+    @TableField("Reserved2") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved2; // 预留字段2
 
-    /**
-     * 预留字段3。
-     */
-    @TableField("Reserved3")
-    private Integer reserved3;
+    @TableField("Reserved3") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved3; // 预留字段3
 
-    /**
-     * 预留字段4。
-     */
-    @TableField("Reserved4")
-    private String reserved4;
+    @TableField("Reserved4") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved4; // 预留字段4
 
-    /**
-     * 预留字段5。
-     */
-    @TableField("Reserved5")
-    private Integer reserved5;
+    @TableField("Reserved5") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved5; // 预留字段5
 
-    /**
-     * 预留字段6。
-     */
-    @TableField("Reserved6")
-    private String reserved6;
+    @TableField("Reserved6") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved6; // 预留字段6
 
     /**
      * 聊天室数据，以 BLOB 形式存储。
      */
-    @TableField(value = "RoomData", typeHandler = ByteArrayTypeHandler.class)
-    private byte[] roomData;
+    @TableField(value = "RoomData", typeHandler = ByteArrayTypeHandler.class) // 使用MyBatis Plus注解指定该字段对应的数据库表字段名，并指定类型处理器处理byte数组
+    private byte[] roomData; // 成员变量，用于存储聊天室数据，以BLOB形式存储
 
-    /**
-     * 预留字段7。
-     */
-    @TableField("Reserved7")
-    private Integer reserved7;
+    @TableField("Reserved7") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved7; // 预留字段7
 
-    /**
-     * 预留字段8。
-     */
-    @TableField("Reserved8")
-    private String reserved8;
+    @TableField("Reserved8") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved8; // 预留字段8
 
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/ChatRoomInfo.java

@@ -1,101 +1,79 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了实体类所在的包名
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus的注解，用于指定字段映射
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus的注解，用于指定主键字段
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus的注解，用于指定表名
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
 
 /**
- * 群聊信息
+ * ChatRoomInfo 类用于表示群聊信息实体。
  *
  * @author xcs
  * @date 2024年01月09日 14时53分
  **/
-@Data
-@TableName("ChatRoomInfo")
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@TableName("ChatRoomInfo") // 使用MyBatis Plus注解指定实体类对应的数据库表名
 public class ChatRoomInfo {
 
     /**
      * 聊天室名称，作为主键。
      */
-    @TableId("ChatRoomName")
-    private String chatRoomName;
+    @TableId("ChatRoomName") // 使用MyBatis Plus注解指定该字段为数据库表的主键
+    private String chatRoomName; // 成员变量，用于存储聊天室的名称
 
     /**
      * 聊天室公告内容。
      */
-    @TableField("Announcement")
-    private String announcement;
+    @TableField("Announcement") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String announcement; // 成员变量，用于存储聊天室的公告内容
 
     /**
      * 信息版本号，默认为 0。
      */
-    @TableField("InfoVersion")
-    private Integer infoVersion;
+    @TableField("InfoVersion") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer infoVersion; // 成员变量，用于存储信息的版本号
 
     /**
      * 公告编辑者。
      */
-    @TableField("AnnouncementEditor")
-    private String announcementEditor;
+    @TableField("AnnouncementEditor") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String announcementEditor; // 成员变量，用于存储公告的编辑者
 
     /**
      * 公告发布时间，存储为时间戳，默认为 0。
      */
-    @TableField("AnnouncementPublishTime")
-    private Long announcementPublishTime;
+    @TableField("AnnouncementPublishTime") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Long announcementPublishTime; // 成员变量，用于存储公告的发布时间
 
     /**
      * 聊天室状态，默认为 0。
      */
-    @TableField("ChatRoomStatus")
-    private Integer chatRoomStatus;
+    @TableField("ChatRoomStatus") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer chatRoomStatus; // 成员变量，用于存储聊天室的状态
 
-    /**
-     * 预留字段1。
-     */
-    @TableField("Reserved1")
-    private Integer reserved1;
+    // 以下是预留字段，用于未来可能的扩展
+    @TableField("Reserved1") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved1; // 预留字段1
 
-    /**
-     * 预留字段2。
-     */
-    @TableField("Reserved2")
-    private String reserved2;
+    @TableField("Reserved2") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved2; // 预留字段2
 
-    /**
-     * 预留字段3。
-     */
-    @TableField("Reserved3")
-    private Integer reserved3;
+    @TableField("Reserved3") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved3; // 预留字段3
 
-    /**
-     * 预留字段4。
-     */
-    @TableField("Reserved4")
-    private String reserved4;
+    @TableField("Reserved4") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved4; // 预留字段4
 
-    /**
-     * 预留字段5。
-     */
-    @TableField("Reserved5")
-    private Integer reserved5;
+    @TableField("Reserved5") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved5; // 预留字段5
 
-    /**
-     * 预留字段6。
-     */
-    @TableField("Reserved6")
-    private String reserved6;
+    @TableField("Reserved6") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved6; // 预留字段6
 
-    /**
-     * 预留字段7。
-     */
-    @TableField("Reserved7")
-    private Integer reserved7;
+    @TableField("Reserved7") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved7; // 预留字段7
 
-    /**
-     * 预留字段8。
-     */
-    @TableField("Reserved8")
-    private String reserved8;
-}
+    @TableField("Reserved8") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved8; // 预留字段8
+
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/Contact.java

@@ -1,204 +1,173 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了实体类所在的包名
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
-import org.apache.ibatis.type.ByteArrayTypeHandler;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus的注解，用于指定字段映射
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus的注解，用于指定主键字段
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus的注解，用于指定表名
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import org.apache.ibatis.type.ByteArrayTypeHandler; // 导入MyBatis的类型处理器，用于处理byte数组字段
 
 /**
- * 联系人
+ * Contact 类用于表示联系人实体。
  *
  * @author xcs
  * @date 2023年12月22日 10时59分
  **/
-@Data
-@TableName(value = "Contact",autoResultMap = true)
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@TableName(value = "Contact", autoResultMap = true) // 使用MyBatis Plus注解指定实体类对应的数据库表名，并自动生成ResultMap
 public class Contact {
 
     /**
      * 用户名，作为主键。
      */
-    @TableId(value = "UserName")
-    private String userName;
+    @TableId(value = "UserName") // 使用MyBatis Plus注解指定该字段为数据库表的主键
+    private String userName; // 成员变量，用于存储用户名
 
     /**
      * 别名。
      */
-    @TableField("Alias")
-    private String alias;
+    @TableField("Alias") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String alias; // 成员变量，用于存储别名
 
     /**
      * 加密用户名。
      */
-    @TableField("EncryptUserName")
-    private String encryptUserName;
+    @TableField("EncryptUserName") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String encryptUserName; // 成员变量，用于存储加密后的用户名
 
     /**
      * 删除标志，默认为0。
      */
-    @TableField("DelFlag")
-    private Integer delFlag;
+    @TableField("DelFlag") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer delFlag; // 成员变量，用于存储删除标志
 
     /**
      * 类型，默认为0。
      */
-    @TableField("Type")
-    private Integer type;
+    @TableField("Type") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer type; // 成员变量，用于存储类型
 
     /**
      * 验证标志，默认为0。
      */
-    @TableField("VerifyFlag")
-    private Integer verifyFlag;
+    @TableField("VerifyFlag") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer verifyFlag; // 成员变量，用于存储验证标志
 
-    /**
-     * 预留字段1。
-     */
-    @TableField("Reserved1")
-    private Integer reserved1;
+    // 以下是预留字段，用于未来可能的扩展
+    @TableField("Reserved1") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved1; // 预留字段1
 
-    /**
-     * 预留字段2。
-     */
-    @TableField("Reserved2")
-    private Integer reserved2;
+    @TableField("Reserved2") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved2; // 预留字段2
 
-    /**
-     * 预留字段3。
-     */
-    @TableField("Reserved3")
-    private String reserved3;
+    @TableField("Reserved3") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved3; // 预留字段3
 
-    /**
-     * 预留字段4。
-     */
-    @TableField("Reserved4")
-    private String reserved4;
+    @TableField("Reserved4") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved4; // 预留字段4
 
     /**
      * 备注信息。
      */
-    @TableField("Remark")
-    private String remark;
+    @TableField("Remark") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String remark; // 成员变量，用于存储备注信息
 
     /**
      * 昵称。
      */
-    @TableField("NickName")
-    private String nickName;
+    @TableField("NickName") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String nickName; // 成员变量，用于存储昵称
 
     /**
      * 标签ID列表。
      */
-    @TableField("LabelIDList")
-    private String labelIdList;
+    @TableField("LabelIDList") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String labelIdList; // 成员变量，用于存储标签ID列表
 
     /**
      * 域列表。
      */
-    @TableField("DomainList")
-    private String domainList;
+    @TableField("DomainList") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String domainList; // 成员变量，用于存储域列表
 
     /**
      * 聊天室类型。
      */
-    @TableField("ChatRoomType")
-    private Integer chatRoomType;
+    @TableField("ChatRoomType") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer chatRoomType; // 成员变量，用于存储聊天室类型
 
     /**
      * 昵称的拼音首字母。
      */
-    @TableField("PYInitial")
-    private String pyInitial;
+    @TableField("PYInitial") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String pyInitial; // 成员变量，用于存储昵称的拼音首字母
 
     /**
      * 昵称的完整拼音。
      */
-    @TableField("QuanPin")
-    private String quanPin;
+    @TableField("QuanPin") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String quanPin; // 成员变量，用于存储昵称的完整拼音
 
     /**
      * 备注的拼音首字母。
      */
-    @TableField("RemarkPYInitial")
-    private String remarkPyInitial;
+    @TableField("RemarkPYInitial") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String remarkPyInitial; // 成员变量，用于存储备注的拼音首字母
 
     /**
      * 备注的完整拼音。
      */
-    @TableField("RemarkQuanPin")
-    private String remarkQuanPin;
+    @TableField("RemarkQuanPin") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String remarkQuanPin; // 成员变量，用于存储备注的完整拼音
 
     /**
      * 大头像URL。
      */
-    @TableField("BigHeadImgUrl")
-    private String bigHeadImgUrl;
+    @TableField("BigHeadImgUrl") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String bigHeadImgUrl; // 成员变量，用于存储大头像URL
 
     /**
      * 小头像URL。
      */
-    @TableField("SmallHeadImgUrl")
-    private String smallHeadImgUrl;
+    @TableField("SmallHeadImgUrl") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String smallHeadImgUrl; // 成员变量，用于存储小头像URL
 
     /**
      * 头像的MD5值。
      */
-    @TableField("HeadImgMd5")
-    private String headImgMd5;
+    @TableField("HeadImgMd5") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String headImgMd5; // 成员变量，用于存储头像的MD5值
 
     /**
      * 聊天室通知标志，默认为0。
      */
-    @TableField("ChatRoomNotify")
-    private Integer chatRoomNotify;
+    @TableField("ChatRoomNotify") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer chatRoomNotify; // 成员变量，用于存储聊天室通知标志
 
-    /**
-     * 预留字段5。
-     */
-    @TableField("Reserved5")
-    private Integer reserved5;
+    // 以下是更多的预留字段，用于未来可能的扩展
+    @TableField("Reserved5") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved5; // 预留字段5
 
-    /**
-     * 预留字段6。
-     */
-    @TableField("Reserved6")
-    private String reserved6;
+    @TableField("Reserved6") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved6; // 预留字段6
 
-    /**
-     * 预留字段7。
-     */
-    @TableField("Reserved7")
-    private String reserved7;
+    @TableField("Reserved7") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved7; // 预留字段7
 
-    /**
-     * 预留字段8。
-     */
-    @TableField("Reserved8")
-    private Integer reserved8;
+    @TableField("Reserved8") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved8; // 预留字段8
 
-    /**
-     * 预留字段9。
-     */
-    @TableField("Reserved9")
-    private Integer reserved9;
+    @TableField("Reserved9") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved9; // 预留字段9
 
-    /**
-     * 预留字段10。
-     */
-    @TableField("Reserved10")
-    private String reserved10;
+    @TableField("Reserved10") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved10; // 预留字段10
 
-    /**
-     * 预留字段11。
-     */
-    @TableField("Reserved11")
-    private String reserved11;
+    @TableField("Reserved11") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved11; // 预留字段11
 
     /**
      * 额外数据
      */
-    @TableField(value = "ExtraBuf", typeHandler = ByteArrayTypeHandler.class)
-    private byte[] extraBuf;
-}
+    @TableField(value = "ExtraBuf", typeHandler = ByteArrayTypeHandler.class) // 使用MyBatis Plus注解指定该字段对应的数据库表字段名，并指定类型处理器处理byte数组
+    private byte[] extraBuf; // 成员变量，用于存储额外的数据
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/ContactHeadImg.java

@@ -1,42 +1,42 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了实体类所在的包名
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
-import org.apache.ibatis.type.ByteArrayTypeHandler;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus的注解，用于指定字段映射
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus的注解，用于指定主键字段
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus的注解，用于指定表名
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import org.apache.ibatis.type.ByteArrayTypeHandler; // 导入MyBatis的类型处理器，用于处理byte数组字段
 
 /**
- * 联系人头像表实体类
+ * ContactHeadImg 类用于表示联系人头像表的实体类。
  *
  * @author xcs
  * @date 2023年12月22日 10时59分
  **/
-@Data
-@TableName("ContactHeadImg1")
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@TableName("ContactHeadImg1") // 使用MyBatis Plus注解指定实体类对应的数据库表名
 public class ContactHeadImg {
 
     /**
-     * 用户名，主键
+     * 用户名，作为主键。
      */
-    @TableId("usrName")
-    private String usrName;
+    @TableId("usrName") // 使用MyBatis Plus注解指定该字段为数据库表的主键
+    private String usrName; // 成员变量，用于存储用户名
 
     /**
      * 创建时间
      */
-    @TableField("createTime")
-    private Integer createTime;
+    @TableField("createTime") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer createTime; // 成员变量，用于存储创建时间
 
     /**
      * 小头像数据
      */
-    @TableField(value = "smallHeadBuf", typeHandler = ByteArrayTypeHandler.class)
-    private byte[] smallHeadBuf;
+    @TableField(value = "smallHeadBuf", typeHandler = ByteArrayTypeHandler.class) // 使用MyBatis Plus注解指定该字段对应的数据库表字段名，并指定类型处理器处理byte数组
+    private byte[] smallHeadBuf; // 成员变量，用于存储小头像数据
 
     /**
      * 头像MD5值
      */
-    @TableField("m_headImgMD5")
-    private String headImgMd5;
-}
+    @TableField("m_headImgMD5") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String headImgMd5; // 成员变量，用于存储头像的MD5值
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/ContactHeadImgUrl.java

@@ -1,53 +1,53 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了实体类所在的包名
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus的注解，用于指定字段映射
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus的注解，用于指定主键字段
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus的注解，用于指定表名
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
 
 /**
- * 联系人头像
+ * ContactHeadImgUrl 类用于表示联系人头像URL的实体类。
  *
  * @author xcs
  * @date 2023年12月21日 18时31分
  **/
-@Data
-@TableName("ContactHeadImgUrl")
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@TableName("ContactHeadImgUrl") // 使用MyBatis Plus注解指定实体类对应的数据库表名
 public class ContactHeadImgUrl {
 
     /**
      * 用户名
      */
-    @TableId("usrName")
-    private String usrName;
+    @TableId("usrName") // 使用MyBatis Plus注解指定该字段为数据库表的主键
+    private String usrName; // 成员变量，用于存储用户名
 
     /**
      * 小头像图片的URL地址
      */
-    @TableField("smallHeadImgUrl")
-    private String smallHeadImgUrl;
+    @TableField("smallHeadImgUrl") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String smallHeadImgUrl; // 成员变量，用于存储小头像图片的URL地址
 
     /**
      * 大头像图片的URL地址
      */
-    @TableField("bigHeadImgUrl")
-    private String bigHeadImgUrl;
+    @TableField("bigHeadImgUrl") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String bigHeadImgUrl; // 成员变量，用于存储大头像图片的URL地址
 
     /**
      * 头像图片的MD5校验值
      */
-    @TableField("headImgMd5")
-    private String headImgMd5;
+    @TableField("headImgMd5") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String headImgMd5; // 成员变量，用于存储头像图片的MD5校验值
 
     /**
      * 预留字段0，可能用于未来的扩展或特定的内部用途
      */
-    @TableField("reverse0")
-    private Integer reverse0;
+    @TableField("reverse0") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reverse0; // 成员变量，预留字段0
 
     /**
      * 预留字段1，同样可能用于未来的扩展或特定的内部用途
      */
-    @TableField("reverse1")
-    private String reverse1;
+    @TableField("reverse1") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reverse1; // 成员变量，预留字段1
 }

wx-dump-admin/src/main/java/com/xcs/wx/domain/ContactLabel.java

@@ -1,66 +1,51 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了实体类所在的包名
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus的注解，用于指定字段映射
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus的注解，用于指定主键字段
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus的注解，用于指定表名
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
 
 /**
- * 联系人标签
+ * ContactLabel 类用于表示联系人标签的实体类。
  *
  * @author xcs
  * @date 2023年12月22日 16时53分
  **/
-@Data
-@TableName("ContactLabel")
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@TableName("ContactLabel") // 使用MyBatis Plus注解指定实体类对应的数据库表名
 public class ContactLabel {
 
     /**
      * 标签Id
      */
-    @TableId("LabelId")
-    private String labelId;
+    @TableId("LabelId") // 使用MyBatis Plus注解指定该字段为数据库表的主键
+    private String labelId; // 成员变量，用于存储标签的唯一标识符
 
     /**
      * 标签名称
      */
-    @TableField("LabelName")
-    private String labelName;
+    @TableField("LabelName") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String labelName; // 成员变量，用于存储标签的名称
 
-    /**
-     * 预留字段1。
-     */
-    @TableField("Reserved1")
-    private Integer reserved1;
+    // 以下是预留字段，用于未来可能的扩展
+    @TableField("Reserved1") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved1; // 预留字段1，类型为Integer
 
-    /**
-     * 预留字段2。
-     */
-    @TableField("Reserved2")
-    private Integer reserved2;
+    @TableField("Reserved2") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private Integer reserved2; // 预留字段2，类型为Integer
 
-    /**
-     * 预留字段3。
-     */
-    @TableField("Reserved3")
-    private String reserved3;
+    @TableField("Reserved3") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved3; // 预留字段3，类型为String
 
-    /**
-     * 预留字段4。
-     */
-    @TableField("Reserved4")
-    private String reserved4;
+    @TableField("Reserved4") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved4; // 预留字段4，类型为String
 
-    /**
-     * 预留字段5。
-     */
-    @TableField("Reserved5")
-    private String reserved5;
+    @TableField("Reserved5") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String reserved5; // 预留字段5，类型为String
 
     /**
      * 响应数据
      */
-    @TableField("RespData")
-    private String respData;
-
-}
+    @TableField("RespData") // 使用MyBatis Plus注解指定该字段对应的数据库表字段名
+    private String respData; // 成员变量，用于存储响应数据，可能用于存储额外的业务数据或配置信息
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/FTSContactContent.java

@@ -1,42 +1,43 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了这个类的包名，表示这个类属于com.xcs.wx.domain包。
 
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.IdType; // 导入MyBatis Plus框架的注解，用于指定主键的类型。
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus框架的注解，用于指定数据库表中的字段。
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus框架的注解，用于指定数据库表的主键字段。
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus框架的注解，用于指定实体类对应的数据库表名。
+import lombok.Data; // 导入Lombok库的@Data注解，用于自动生成getter和setter方法，以及toString、equals和hashCode方法。
 
 /**
  * FTSContactContent
+ * 这个类表示全文搜索（Full-Text Search）联系人内容的数据结构。
  *
- * @author xcs
- * @date 2024年6月14日15:12:27
+ * @author xcs // 表示这个类的作者。
+ * @date 2024年6月14日15:12:27 // 表示这个类的创建日期和时间。
  **/
-@Data
-@TableName(value = "FTSContact15_content", autoResultMap = true)
-public class FTSContactContent {
+@Data // 使用Lombok的@Data注解，自动为类的字段生成getter和setter方法。
+@TableName(value = "FTSContact15_content", autoResultMap = true) // 使用MyBatis Plus的@TableName注解，指定这个实体类对应的数据库表名为"FTSContact15_content"，并且开启自动结果映射。
+public class FTSContactContent { // 定义了一个名为FTSContactContent的类，用于表示全文搜索联系人内容的数据结构。
 
     /**
      * 本地唯一标识符，自增。
      */
-    @TableId(value = "docid", type = IdType.AUTO)
-    private Integer docId;
+    @TableId(value = "docid", type = IdType.AUTO) // 使用@TableId注解指定这个字段为数据库表的主键，并且映射到数据库中的"docid"列，同时指定主键的类型为自增（AUTO）。
+    private Integer docId; // 定义了一个名为docId的私有成员变量，类型为Integer，表示本地唯一标识符。
 
     /**
      * alias
      */
-    @TableField("c0alias")
-    private String alias;
+    @TableField("c0alias") // 使用@TableField注解指定这个字段映射到数据库中的"c0alias"列。
+    private String alias; // 定义了一个名为alias的私有成员变量，类型为String，表示别名。
 
     /**
      * nickname
      */
-    @TableField("c1nickname")
-    private String nickname;
+    @TableField("c1nickname") // 使用@TableField注解指定这个字段映射到数据库中的"c1nickname"列。
+    private String nickname; // 定义了一个名为nickname的私有成员变量，类型为String，表示昵称。
 
     /**
      * c2remark
      */
-    @TableField("c2remark")
-    private String remark;
-}
+    @TableField("c2remark") // 使用@TableField注解指定这个字段映射到数据库中的"c2remark"列。
+    private String remark; // 定义了一个名为remark的私有成员变量，类型为String，表示备注。
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/FTSRecentUsed.java

@@ -1,35 +1,36 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了这个类的包名，表示这个类属于com.xcs.wx.domain包。
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus框架的注解，用于指定数据库表中的字段。
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus框架的注解，用于指定数据库表的主键字段。
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus框架的注解，用于指定实体类对应的数据库表名。
+import lombok.Data; // 导入Lombok库的@Data注解，用于自动生成getter和setter方法，以及toString、equals和hashCode方法。
 
 /**
  * 最近使用关键字
+ * 这个类表示最近使用的关键字的数据结构。
  *
- * @author xcs
- * @date 2024年01月23日 11时09分
+ * @author xcs // 表示这个类的作者。
+ * @date 2024年01月23日 11时09分 // 表示这个类的创建日期和时间。
  **/
-@Data
-@TableName("FTSRecentUsed15")
-public class FTSRecentUsed {
+@Data // 使用Lombok的@Data注解，自动为类的字段生成getter和setter方法。
+@TableName("FTSRecentUsed15") // 使用MyBatis Plus的@TableName注解，指定这个实体类对应的数据库表名为"FTSRecentUsed15"。
+public class FTSRecentUsed { // 定义了一个名为FTSRecentUsed的类，用于表示最近使用的关键字的数据结构。
 
     /**
      * 查询的内容
      */
-    @TableId("queryText")
-    private String queryText;
+    @TableId("queryText") // 使用@TableId注解指定这个字段为数据库表的主键，并且映射到数据库中的"queryText"列。
+    private String queryText; // 定义了一个名为queryText的私有成员变量，类型为String，表示查询的内容。
 
     /**
      * 用户名
      */
-    @TableField("username")
-    private Integer username;
+    @TableField("username") // 使用@TableField注解指定这个字段映射到数据库中的"username"列。
+    private Integer username; // 定义了一个名为username的私有成员变量，类型为Integer，表示用户名。这里可能是一个错误，因为通常用户名应该是字符串类型。
 
     /**
      * 修改时间
      */
-    @TableField("updateTime")
-    private String updateTime;
-}
+    @TableField("updateTime") // 使用@TableField注解指定这个字段映射到数据库中的"updateTime"列。
+    private String updateTime; // 定义了一个名为updateTime的私有成员变量，类型为String，表示修改时间。
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/Feeds.java

@@ -1,77 +1,77 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了这个类的包名，表示这个类属于com.xcs.wx.domain包。
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus框架的注解，用于指定数据库表中的字段。
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus框架的注解，用于指定数据库表的主键字段。
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus框架的注解，用于指定实体类对应的数据库表名。
+import lombok.Data; // 导入Lombok库的@Data注解，用于自动生成getter和setter方法，以及toString、equals和hashCode方法。
 
 /**
  * 朋友圈
  *
- * @author xcs
- * @date 2024年01月03日 16时41分
+ * @author xcs // 表示这个类的作者。
+ * @date 2024年01月03日 16时41分 // 表示这个类的创建日期和时间。
  **/
-@Data
-@TableName(value = "FeedsV20", autoResultMap = true)
-public class Feeds {
+@Data // 使用Lombok的@Data注解，自动为类的字段生成getter和setter方法。
+@TableName(value = "FeedsV20", autoResultMap = true) // 使用MyBatis Plus的@TableName注解，指定这个实体类对应的数据库表名为"FeedsV20"，并且开启自动结果映射。
+public class Feeds { // 定义了一个名为Feeds的类，用于表示朋友圈的数据结构。
 
     /**
      * 动态的唯一标识ID。
      */
-    @TableId("FeedId")
-    private Long feedId;
+    @TableId("FeedId") // 使用@TableId注解指定这个字段为数据库表的主键，并且映射到数据库中的"FeedId"列。
+    private Long feedId; // 定义了一个名为feedId的私有成员变量，类型为Long，表示动态的唯一标识ID。
 
     /**
      * 创建时间，存储为整数形式。
      */
-    @TableField("CreateTime")
-    private Integer createTime;
+    @TableField("CreateTime") // 使用@TableField注解指定这个字段映射到数据库中的"CreateTime"列。
+    private Integer createTime; // 定义了一个名为createTime的私有成员变量，类型为Integer，表示创建时间。
 
     /**
      * 故障ID，用于记录相关故障信息。
      */
-    @TableField("FaultId")
-    private Integer faultId;
+    @TableField("FaultId") // 使用@TableField注解指定这个字段映射到数据库中的"FaultId"列。
+    private Integer faultId; // 定义了一个名为faultId的私有成员变量，类型为Integer，表示故障ID。
 
     /**
      * 动态的类型。
      */
-    @TableField("Type")
-    private Integer type;
+    @TableField("Type") // 使用@TableField注解指定这个字段映射到数据库中的"Type"列。
+    private Integer type; // 定义了一个名为type的私有成员变量，类型为Integer，表示动态的类型。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField("UserName")
-    private String userName;
+    @TableField("UserName") // 使用@TableField注解指定这个字段映射到数据库中的"UserName"列。
+    private String userName; // 定义了一个名为userName的私有成员变量，类型为String，表示发布用户的用户名。
 
     /**
      * 动态的状态。
      */
-    @TableField("Status")
-    private Integer status;
+    @TableField("Status") // 使用@TableField注解指定这个字段映射到数据库中的"Status"列。
+    private Integer status; // 定义了一个名为status的私有成员变量，类型为Integer，表示动态的状态。
 
     /**
      * 扩展标志，用于存储额外信息。
      */
-    @TableField("ExtFlag")
-    private Integer extFlag;
+    @TableField("ExtFlag") // 使用@TableField注解指定这个字段映射到数据库中的"ExtFlag"列。
+    private Integer extFlag; // 定义了一个名为extFlag的私有成员变量，类型为Integer，表示扩展标志。
 
     /**
      * 隐私标志，指示动态的隐私级别。
      */
-    @TableField("PrivFlag")
-    private Integer privFlag;
+    @TableField("PrivFlag") // 使用@TableField注解指定这个字段映射到数据库中的"PrivFlag"列。
+    private Integer privFlag; // 定义了一个名为privFlag的私有成员变量，类型为Integer，表示隐私标志。
 
     /**
      * 字符串ID，可能用于关联其他数据。
      */
-    @TableField("StringId")
-    private String stringId;
+    @TableField("StringId") // 使用@TableField注解指定这个字段映射到数据库中的"StringId"列。
+    private String stringId; // 定义了一个名为stringId的私有成员变量，类型为String，表示字符串ID。
 
     /**
      * 动态的内容文本。
      */
-    @TableField("Content")
-    private String content;
-}
+    @TableField("Content") // 使用@TableField注解指定这个字段映射到数据库中的"Content"列。
+    private String content; // 定义了一个名为content的私有成员变量，类型为String，表示动态的内容文本。
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/HardLinkImageAttribute.java

@@ -1,55 +1,55 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了这个类的包名，表示这个类属于com.xcs.wx.domain包。
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
-import org.apache.ibatis.type.ByteArrayTypeHandler;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus框架的注解，用于指定数据库表中的字段。
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus框架的注解，用于指定数据库表的主键字段。
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus框架的注解，用于指定实体类对应的数据库表名。
+import lombok.Data; // 导入Lombok库的@Data注解，用于自动生成getter和setter方法，以及toString、equals和hashCode方法。
+import org.apache.ibatis.type.ByteArrayTypeHandler; // 导入MyBatis的ByteArrayTypeHandler，用于处理byte[]类型的字段。
 
 /**
  * 图片链接表
+ * 这个类表示图片链接属性的数据结构。
  *
- * @author xcs
- * @date 2024年01月04日 17时55分
+ * @author xcs // 表示这个类的作者。
+ * @date 2024年01月04日 17时55分 // 表示这个类的创建日期和时间。
  **/
-@Data
-@TableName(value = "HardLinkImageAttribute", autoResultMap = true)
-public class HardLinkImageAttribute {
+@Data // 使用Lombok的@Data注解，自动为类的字段生成getter和setter方法。
+@TableName(value = "HardLinkImageAttribute", autoResultMap = true) // 使用MyBatis Plus的@TableName注解，指定这个实体类对应的数据库表名为"HardLinkImageAttribute"，并且开启自动结果映射。
+public class HardLinkImageAttribute { // 定义了一个名为HardLinkImageAttribute的类，用于表示图片链接属性的数据结构。
 
     /**
      * 动态的唯一标识ID。
      */
-    @TableId("Md5Hash")
-    private Long md5Hash;
+    @TableId("Md5Hash") // 使用@TableId注解指定这个字段为数据库表的主键，并且映射到数据库中的"Md5Hash"列。
+    private Long md5Hash; // 定义了一个名为md5Hash的私有成员变量，类型为Long，表示动态的唯一标识ID。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField("DirID1")
-    private String dirId1;
+    @TableField("DirID1") // 使用@TableField注解指定这个字段映射到数据库中的"DirID1"列。
+    private String dirId1; // 定义了一个名为dirId1的私有成员变量，类型为String，表示发布用户的用户名或相关标识。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField("DirID2")
-    private String dirId2;
+    @TableField("DirID2") // 使用@TableField注解指定这个字段映射到数据库中的"DirID2"列。
+    private String dirId2; // 定义了一个名为dirId2的私有成员变量，类型为String，表示发布用户的用户名或相关标识。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField(value = "Md5", typeHandler = ByteArrayTypeHandler.class)
-    private byte[] md5;
+    @TableField(value = "Md5", typeHandler = ByteArrayTypeHandler.class) // 使用@TableField注解指定这个字段映射到数据库中的"Md5"列，并使用ByteArrayTypeHandler处理byte[]类型的字段。
+    private byte[] md5; // 定义了一个名为md5的私有成员变量，类型为byte[]，表示文件的MD5哈希值。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField("ModifyTime")
-    private String modifyTime;
+    @TableField("ModifyTime") // 使用@TableField注解指定这个字段映射到数据库中的"ModifyTime"列。
+    private String modifyTime; // 定义了一个名为modifyTime的私有成员变量，类型为String，表示修改时间。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField("FileName")
-    private String fileName;
-
-}
+    @TableField("FileName") // 使用@TableField注解指定这个字段映射到数据库中的"FileName"列。
+    private String fileName; // 定义了一个名为fileName的私有成员变量，类型为String，表示文件名。
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/HardLinkVideoAttribute.java

@@ -1,55 +1,55 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了这个类的包名，表示这个类属于com.xcs.wx.domain包。
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
-import org.apache.ibatis.type.ByteArrayTypeHandler;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus框架的注解，用于指定数据库表中的字段。
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus框架的注解，用于指定数据库表的主键字段。
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus框架的注解，用于指定实体类对应的数据库表名。
+import lombok.Data; // 导入Lombok库的@Data注解，用于自动生成getter和setter方法，以及toString、equals和hashCode方法。
+import org.apache.ibatis.type.ByteArrayTypeHandler; // 导入MyBatis的ByteArrayTypeHandler，用于处理byte[]类型的字段。
 
 /**
  * 视频链接表
+ * 这个类表示视频链接属性的数据结构。
  *
- * @author xcs
- * @date 2024年02月07日 15时24分
+ * @author xcs // 表示这个类的作者。
+ * @date 2024年02月07日 15时24分 // 表示这个类的创建日期和时间。
  **/
-@Data
-@TableName(value = "HardLinkVideoAttribute", autoResultMap = true)
-public class HardLinkVideoAttribute {
+@Data // 使用Lombok的@Data注解，自动为类的字段生成getter和setter方法。
+@TableName(value = "HardLinkVideoAttribute", autoResultMap = true) // 使用MyBatis Plus的@TableName注解，指定这个实体类对应的数据库表名为"HardLinkVideoAttribute"，并且开启自动结果映射。
+public class HardLinkVideoAttribute { // 定义了一个名为HardLinkVideoAttribute的类，用于表示视频链接属性的数据结构。
 
     /**
      * 动态的唯一标识ID。
      */
-    @TableId("Md5Hash")
-    private Long md5Hash;
+    @TableId("Md5Hash") // 使用@TableId注解指定这个字段为数据库表的主键，并且映射到数据库中的"Md5Hash"列。
+    private Long md5Hash; // 定义了一个名为md5Hash的私有成员变量，类型为Long，表示动态的唯一标识ID。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField("DirID1")
-    private String dirId1;
+    @TableField("DirID1") // 使用@TableField注解指定这个字段映射到数据库中的"DirID1"列。
+    private String dirId1; // 定义了一个名为dirId1的私有成员变量，类型为String，表示发布用户的用户名或相关标识。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField("DirID2")
-    private String dirId2;
+    @TableField("DirID2") // 使用@TableField注解指定这个字段映射到数据库中的"DirID2"列。
+    private String dirId2; // 定义了一个名为dirId2的私有成员变量，类型为String，表示发布用户的用户名或相关标识。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField(value = "Md5", typeHandler = ByteArrayTypeHandler.class)
-    private byte[] md5;
+    @TableField(value = "Md5", typeHandler = ByteArrayTypeHandler.class) // 使用@TableField注解指定这个字段映射到数据库中的"Md5"列，并使用ByteArrayTypeHandler处理byte[]类型的字段。
+    private byte[] md5; // 定义了一个名为md5的私有成员变量，类型为byte[]，表示文件的MD5哈希值。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField("ModifyTime")
-    private String modifyTime;
+    @TableField("ModifyTime") // 使用@TableField注解指定这个字段映射到数据库中的"ModifyTime"列。
+    private String modifyTime; // 定义了一个名为modifyTime的私有成员变量，类型为String，表示修改时间。
 
     /**
      * 发布用户的用户名。
      */
-    @TableField("FileName")
-    private String fileName;
-
-}
+    @TableField("FileName") // 使用@TableField注解指定这个字段映射到数据库中的"FileName"列。
+    private String fileName; // 定义了一个名为fileName的私有成员变量，类型为String，表示文件名。
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/Msg.java

@@ -1,176 +1,162 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了这个类的包名，表示这个类属于com.xcs.wx.domain包。
 
-
-import com.baomidou.mybatisplus.annotation.IdType;
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
-import org.apache.ibatis.type.ByteArrayTypeHandler;
+import com.baomidou.mybatisplus.annotation.IdType; // 导入MyBatis Plus框架的注解，用于指定主键的类型。
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus框架的注解，用于指定数据库表中的字段。
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus框架的注解，用于指定数据库表的主键字段。
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus框架的注解，用于指定实体类对应的数据库表名。
+import lombok.Data; // 导入Lombok库的@Data注解，用于自动生成getter和setter方法，以及toString、equals和hashCode方法。
+import org.apache.ibatis.type.ByteArrayTypeHandler; // 导入MyBatis的ByteArrayTypeHandler，用于处理byte[]类型的字段。
 
 /**
  * 消息
+ * 这个类表示消息的数据结构。
  *
- * @author xcs
- * @date 2023年12月25日 15时08分
+ * @author xcs // 表示这个类的作者。
+ * @date 2023年12月25日 15时08分 // 表示这个类的创建日期和时间。
  **/
-@Data
-@TableName(value = "MSG", autoResultMap = true)
-public class Msg {
+@Data // 使用Lombok的@Data注解，自动为类的字段生成getter和setter方法。
+@TableName(value = "MSG", autoResultMap = true) // 使用MyBatis Plus的@TableName注解，指定这个实体类对应的数据库表名为"MSG"，并且开启自动结果映射。
+public class Msg { // 定义了一个名为Msg的类，用于表示消息的数据结构。
 
     /**
      * 本地唯一标识符，自增。
      */
-    @TableId(value = "localId",type = IdType.AUTO)
-    private Integer localId;
+    @TableId(value = "localId",type = IdType.AUTO) // 使用@TableId注解指定这个字段为数据库表的主键，并且映射到数据库中的"localId"列，同时指定主键的类型为自增（AUTO）。
+    private Integer localId; // 定义了一个名为localId的私有成员变量，类型为Integer，表示本地唯一标识符。
 
     /**
      * 聊天对象的 ID。
      */
-    @TableField("TalkerId")
-    private Integer talkerId;
+    @TableField("TalkerId") // 使用@TableField注解指定这个字段映射到数据库中的"TalkerId"列。
+    private Integer talkerId; // 定义了一个名为talkerId的私有成员变量，类型为Integer，表示聊天对象的ID。
 
     /**
      * 消息服务器 ID。
      */
-    @TableField("MsgSvrID")
-    private String msgSvrId;
+    @TableField("MsgSvrID") // 使用@TableField注解指定这个字段映射到数据库中的"MsgSvrID"列。
+    private String msgSvrId; // 定义了一个名为msgSvrId的私有成员变量，类型为String，表示消息服务器ID。
 
     /**
      * 消息类型。
      */
-    @TableField("Type")
-    private Integer type;
+    @TableField("Type") // 使用@TableField注解指定这个字段映射到数据库中的"Type"列。
+    private Integer type; // 定义了一个名为type的私有成员变量，类型为Integer，表示消息类型。
 
     /**
      * 消息子类型。
      */
-    @TableField("SubType")
-    private Integer subType;
+    @TableField("SubType") // 使用@TableField注解指定这个字段映射到数据库中的"SubType"列。
+    private Integer subType; // 定义了一个名为subType的私有成员变量，类型为Integer，表示消息子类型。
 
     /**
      * 发送者标识（是否为发送者）。
      */
-    @TableField("IsSender")
-    private Integer isSender;
+    @TableField("IsSender") // 使用@TableField注解指定这个字段映射到数据库中的"IsSender"列。
+    private Integer isSender; // 定义了一个名为isSender的私有成员变量，类型为Integer，表示发送者标识。
 
     /**
      * 消息创建时间。
      */
-    @TableField("CreateTime")
-    private Integer createTime;
+    @TableField("CreateTime") // 使用@TableField注解指定这个字段映射到数据库中的"CreateTime"列。
+    private Integer createTime; // 定义了一个名为createTime的私有成员变量，类型为Integer，表示消息创建时间。
 
     /**
      * 序列号，默认为 0。
      */
-    @TableField("Sequence")
-    private Long sequence;
+    @TableField("Sequence") // 使用@TableField注解指定这个字段映射到数据库中的"Sequence"列。
+    private Long sequence; // 定义了一个名为sequence的私有成员变量，类型为Long，表示序列号。
 
     /**
      * 扩展状态，默认为 0。
      */
-    @TableField("StatusEx")
-    private Integer statusEx;
+    @TableField("StatusEx") // 使用@TableField注解指定这个字段映射到数据库中的"StatusEx"列。
+    private Integer statusEx; // 定义了一个名为statusEx的私有成员变量，类型为Integer，表示扩展状态。
 
     /**
      * 扩展标志。
      */
-    @TableField("FlagEx")
-    private Integer flagEx;
+    @TableField("FlagEx") // 使用@TableField注解指定这个字段映射到数据库中的"FlagEx"列。
+    private Integer flagEx; // 定义了一个名为flagEx的私有成员变量，类型为Integer，表示扩展标志。
 
     /**
      * 消息状态。
      */
-    @TableField("Status")
-    private Integer status;
+    @TableField("Status") // 使用@TableField注解指定这个字段映射到数据库中的"Status"列。
+    private Integer status; // 定义了一个名为status的私有成员变量，类型为Integer，表示消息状态。
 
     /**
      * 消息服务器序列号。
      */
-    @TableField("MsgServerSeq")
-    private Integer msgServerSeq;
+    @TableField("MsgServerSeq") // 使用@TableField注解指定这个字段映射到数据库中的"MsgServerSeq"列。
+    private Integer msgServerSeq; // 定义了一个名为msgServerSeq的私有成员变量，类型为Integer，表示消息服务器序列号。
 
     /**
      * 消息序列号。
      */
-    @TableField("MsgSequence")
-    private Integer msgSequence;
+    @TableField("MsgSequence") // 使用@TableField注解指定这个字段映射到数据库中的"MsgSequence"列。
+    private Integer msgSequence; // 定义了一个名为msgSequence的私有成员变量，类型为Integer，表示消息序列号。
 
     /**
      * 聊天者字符串。
      */
-    @TableField("StrTalker")
-    private String strTalker;
+    @TableField("StrTalker") // 使用@TableField注解指定这个字段映射到数据库中的"StrTalker"列。
+    private String strTalker; // 定义了一个名为strTalker的私有成员变量，类型为String，表示聊天者字符串。
 
     /**
      * 消息内容字符串。
      */
-    @TableField("StrContent")
-    private String strContent;
+    @TableField("StrContent") // 使用@TableField注解指定这个字段映射到数据库中的"StrContent"列。
+    private String strContent; // 定义了一个名为strContent的私有成员变量，类型为String，表示消息内容字符串。
 
     /**
      * 显示内容。
      */
-    @TableField("DisplayContent")
-    private String displayContent;
+    @TableField("DisplayContent") // 使用@TableField注解指定这个字段映射到数据库中的"DisplayContent"列。
+    private String displayContent; // 定义了一个名为displayContent的私有成员变量，类型为String，表示显示内容。
 
     /**
      * 保留字段 0，默认为 0。
      */
-    @TableField("Reserved0")
-    private Integer reserved0;
+    @TableField("Reserved0") // 使用@TableField注解指定这个字段映射到数据库中的"Reserved0"列。
+    private Integer reserved0; // 定义了一个名为reserved0的私有成员变量，类型为Integer，表示保留字段0。
 
     /**
      * 保留字段 1，默认为 0。
      */
-    @TableField("Reserved1")
-    private Integer reserved1;
+    @TableField("Reserved1") // 使用@TableField注解指定这个字段映射到数据库中的"Reserved1"列。
+    private Integer reserved1; // 定义了一个名为reserved1的私有成员变量，类型为Integer，表示保留字段1。
 
     /**
      * 保留字段 2，默认为 0。
      */
-    @TableField("Reserved2")
-    private Integer reserved2;
+    @TableField("Reserved2") // 使用@TableField注解指定这个字段映射到数据库中的"Reserved2"列。
+    private Integer reserved2; // 定义了一个名为reserved2的私有成员变量，类型为Integer，表示保留字段2。
 
     /**
      * 保留字段 3，默认为 0。
      */
-    @TableField("Reserved3")
-    private Integer reserved3;
+    @TableField("Reserved3") // 使用@TableField注解指定这个字段映射到数据库中的"Reserved3"列。
+    private Integer reserved3; // 定义了一个名为reserved3的私有成员变量，类型为Integer，表示保留字段3。
 
     /**
      * 保留字段 4，文本类型。
      */
-    @TableField("Reserved4")
-    private String reserved4;
+    @TableField("Reserved4") // 使用@TableField注解指定这个字段映射到数据库中的"Reserved4"列。
+    private String reserved4; // 定义了一个名为reserved4的私有成员变量，类型为String，表示保留字段4。
 
     /**
      * 保留字段 5，文本类型。
      */
-    @TableField("Reserved5")
-    private String reserved5;
+    @TableField("Reserved5") // 使用@TableField注解指定这个字段映射到数据库中的"Reserved5"列。
+    private String reserved5; // 定义了一个名为reserved5的私有成员变量，类型为String，表示保留字段5。
 
     /**
      * 保留字段 6，文本类型。
      */
-    @TableField("Reserved6")
-    private String reserved6;
+    @TableField("Reserved6") // 使用@TableField注解指定这个字段映射到数据库中的"Reserved6"列。
+    private String reserved6; // 定义了一个名为reserved6的私有成员变量，类型为String，表示保留字段6。
 
     /**
      * 压缩内容，二进制大对象。
      */
-    @TableField(value = "CompressContent", typeHandler = ByteArrayTypeHandler.class)
-    private byte[] compressContent;
-
-    /**
-     * 额外字节信息，二进制大对象。
-     */
-    @TableField(value = "BytesExtra", typeHandler = ByteArrayTypeHandler.class)
-    private byte[] bytesExtra;
-
-    /**
-     * 传输字节信息，二进制大对象。
-     */
-    @TableField(value = "BytesTrans", typeHandler = ByteArrayTypeHandler.class)
-    private byte[] bytesTrans;
-}
+    @TableField(value = "CompressContent", typeHandler = ByteArrayTypeHandler.class) // 使用@TableField注解指定这个字段映射

wx-dump-admin/src/main/java/com/xcs/wx/domain/Session.java

@@ -1,95 +1,96 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了这个类的包名，表示这个类属于com.xcs.wx.domain包。
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableId;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus框架的注解，用于指定数据库表中的字段。
+import com.baomidou.mybatisplus.annotation.TableId; // 导入MyBatis Plus框架的注解，用于指定数据库表的主键字段。
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus框架的注解，用于指定实体类对应的数据库表名。
+import lombok.Data; // 导入Lombok库的@Data注解，用于自动生成getter和setter方法，以及toString、equals和hashCode方法。
 
 /**
  * 会话
+ * 这个类表示会话的数据结构。
  *
- * @author xcs
- * @date 2023年12月21日 17时05分
+ * @author xcs // 表示这个类的作者。
+ * @date 2023年12月21日 17时05分 // 表示这个类的创建日期和时间。
  **/
-@Data
-@TableName("Session")
-public class Session {
+@Data // 使用Lombok的@Data注解，自动为类的字段生成getter和setter方法。
+@TableName("Session") // 使用MyBatis Plus的@TableName注解，指定这个实体类对应的数据库表名为"Session"。
+public class Session { // 定义了一个名为Session的类，用于表示会话的数据结构。
 
     /**
      * 用户名
      */
-    @TableId("strUsrName")
-    private String usrName;
+    @TableId("strUsrName") // 使用@TableId注解指定这个字段为数据库表的主键，并且映射到数据库中的"strUsrName"列。
+    private String usrName; // 定义了一个名为usrName的私有成员变量，类型为String，表示用户名。
 
     /**
      * 未读消息计数
      */
-    @TableField("nUnReadCount")
-    private Integer unReadCount;
+    @TableField("nUnReadCount") // 使用@TableField注解指定这个字段映射到数据库中的"nUnReadCount"列。
+    private Integer unReadCount; // 定义了一个名为unReadCount的私有成员变量，类型为Integer，表示未读消息计数。
 
     /**
      * 父引用，可能指向与此会话相关联的其他实体
      */
-    @TableField("parentRef")
-    private String parentRef;
+    @TableField("parentRef") // 使用@TableField注解指定这个字段映射到数据库中的"parentRef"列。
+    private String parentRef; // 定义了一个名为parentRef的私有成员变量，类型为String，表示父引用。
 
     /**
      * 用户昵称
      */
-    @TableField("strNickName")
-    private String nickName;
+    @TableField("strNickName") // 使用@TableField注解指定这个字段映射到数据库中的"strNickName"列。
+    private String nickName; // 定义了一个名为nickName的私有成员变量，类型为String，表示用户昵称。
 
     /**
      * 会话状态
      */
-    @TableField("nStatus")
-    private Integer status;
+    @TableField("nStatus") // 使用@TableField注解指定这个字段映射到数据库中的"nStatus"列。
+    private Integer status; // 定义了一个名为status的私有成员变量，类型为Integer，表示会话状态。
 
     /**
      * 发送状态标识
      */
-    @TableField("nIsSend")
-    private Integer isSend;
+    @TableField("nIsSend") // 使用@TableField注解指定这个字段映射到数据库中的"nIsSend"列。
+    private Integer isSend; // 定义了一个名为isSend的私有成员变量，类型为Integer，表示发送状态标识。
 
     /**
      * 会话内容
      */
-    @TableField("strContent")
-    private String content;
+    @TableField("strContent") // 使用@TableField注解指定这个字段映射到数据库中的"strContent"列。
+    private String content; // 定义了一个名为content的私有成员变量，类型为String，表示会话内容。
 
     /**
      * 消息类型
      */
-    @TableField("nMsgType")
-    private Integer msgType;
+    @TableField("nMsgType") // 使用@TableField注解指定这个字段映射到数据库中的"nMsgType"列。
+    private Integer msgType; // 定义了一个名为msgType的私有成员变量，类型为Integer，表示消息类型。
 
     /**
      * 本地消息ID
      */
-    @TableField("nMsgLocalID")
-    private Integer msgLocalId;
+    @TableField("nMsgLocalID") // 使用@TableField注解指定这个字段映射到数据库中的"nMsgLocalID"列。
+    private Integer msgLocalId; // 定义了一个名为msgLocalId的私有成员变量，类型为Integer，表示本地消息ID。
 
     /**
      * 消息状态
      */
-    @TableField("nMsgStatus")
-    private Integer msgStatus;
+    @TableField("nMsgStatus") // 使用@TableField注解指定这个字段映射到数据库中的"nMsgStatus"列。
+    private Integer msgStatus; // 定义了一个名为msgStatus的私有成员变量，类型为Integer，表示消息状态。
 
     /**
      * 消息时间戳
      */
-    @TableField("nTime")
-    private Integer time;
+    @TableField("nTime") // 使用@TableField注解指定这个字段映射到数据库中的"nTime"列。
+    private Integer time; // 定义了一个名为time的私有成员变量，类型为Integer，表示消息时间戳。
 
     /**
      * 编辑过的内容
      */
-    @TableField("editContent")
-    private String editContent;
+    @TableField("editContent") // 使用@TableField注解指定这个字段映射到数据库中的"editContent"列。
+    private String editContent; // 定义了一个名为editContent的私有成员变量，类型为String，表示编辑过的内容。
 
     /**
      * 标记是否有其他人@我
      */
-    @TableField("othersAtMe")
-    private Integer othersAtMe;
-}
+    @TableField("othersAtMe") // 使用@TableField注解指定这个字段映射到数据库中的"othersAtMe"列。
+    private Integer othersAtMe; // 定义了一个名为othersAtMe的私有成员变量，类型为Integer，表示标记是否有其他人@我。
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/SqliteMaster.java

@@ -1,41 +1,45 @@
-package com.xcs.wx.domain;
+package com.xcs.wx.domain; // 定义了这个类的包名，表示这个类属于com.xcs.wx.domain包。
 
-import com.baomidou.mybatisplus.annotation.TableField;
-import com.baomidou.mybatisplus.annotation.TableName;
-import lombok.Data;
+import com.baomidou.mybatisplus.annotation.TableField; // 导入MyBatis Plus框架的注解，用于指定数据库表中的字段。
+import com.baomidou.mybatisplus.annotation.TableName; // 导入MyBatis Plus框架的注解，用于指定实体类对应的数据库表名。
+import lombok.Data; // 导入Lombok库的@Data注解，用于自动生成getter和setter方法，以及toString、equals和hashCode方法。
 
 /**
  * SQLite 数据库中的一个系统表
+ * 这个类表示SQLite数据库中的系统表sqlite_master的数据结构。
  *
- * @author xcs
- * @date 2024年6月13日09:18:29
+ * @author xcs // 表示这个类的作者。
+ * @date 2024年6月13日09:18:29 // 表示这个类的创建日期和时间。
  */
-@Data
-@TableName("sqlite_master")
-public class SqliteMaster {
+@Data // 使用Lombok的@Data注解，自动为类的字段生成getter和setter方法。
+@TableName("sqlite_master") // 使用MyBatis Plus的@TableName注解，指定这个实体类对应的数据库表名为"sqlite_master"。
+public class SqliteMaster { // 定义了一个名为SqliteMaster的类，用于表示SQLite数据库中的系统表sqlite_master的数据结构。
 
     /**
      * type
+     * 表示表的类型。
      */
-    @TableField("type")
-    private String type;
+    @TableField("type") // 使用@TableField注解指定这个字段映射到数据库中的"type"列。
+    private String type; // 定义了一个名为type的私有成员变量，类型为String，表示表的类型。
 
     /**
      * tblName
+     * 表示表的名称。
      */
-    @TableField("tbl_name")
-    private String tblName;
+    @TableField("tbl_name") // 使用@TableField注解指定这个字段映射到数据库中的"tbl_name"列。
+    private String tblName; // 定义了一个名为tblName的私有成员变量，类型为String，表示表的名称。
 
     /**
      * rootPage
+     * 表示表的根页面。
      */
-    @TableField("rootpage")
-    private String rootPage;
+    @TableField("rootpage") // 使用@TableField注解指定这个字段映射到数据库中的"rootpage"列。
+    private String rootPage; // 定义了一个名为rootPage的私有成员变量，类型为String，表示表的根页面。
 
     /**
      * sql
+     * 表示创建表的SQL语句。
      */
-    @TableField("sql")
-    private String sql;
-
-}
+    @TableField("sql") // 使用@TableField注解指定这个字段映射到数据库中的"sql"列。
+    private String sql; // 定义了一个名为sql的私有成员变量，类型为String，表示创建表的SQL语句。
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/CompressContentBO.java

@@ -1,9 +1,9 @@
-package com.xcs.wx.domain.bo;
+package com.xcs.wx.domain.bo; // 定义了BO（Business Object）所在的包名
 
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
-import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
-import lombok.Data;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties; // 导入Jackson库的注解，用于控制序列化行为
+import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; // 导入Jackson库的注解，用于XML属性映射
+import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement; // 导入Jackson库的注解，用于XML根元素映射
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
 
 /**
  * CompressContentBO
@@ -11,96 +11,100 @@ import lombok.Data;
  * @author xcs
  * @date 2024年01月16日 14时59分
  **/
-@Data
-@JsonIgnoreProperties(ignoreUnknown = true)
-@JacksonXmlRootElement(localName = "msg")
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@JsonIgnoreProperties(ignoreUnknown = true) // 指定Jackson忽略未知属性
+@JacksonXmlRootElement(localName = "msg") // 指定XML的根元素名称为"msg"
 public class CompressContentBO {
 
-    @JacksonXmlProperty(localName = "appmsg")
-    private AppMsg appMsg;
+    @JacksonXmlProperty(localName = "appmsg") // 指定XML属性名称为"appmsg"
+    private AppMsg appMsg; // 成员变量，用于存储AppMsg对象
 
-    @JacksonXmlProperty(localName = "fromusername")
-    private String fromUsername;
+    @JacksonXmlProperty(localName = "fromusername") // 指定XML属性名称为"fromusername"
+    private String fromUsername; // 成员变量，用于存储发送者用户名
 
-    @JacksonXmlProperty(localName = "scene")
-    private int scene;
+    @JacksonXmlProperty(localName = "scene") // 指定XML属性名称为"scene"
+    private int scene; // 成员变量，用于存储场景值
 
-    @JacksonXmlProperty(localName = "appinfo")
-    private AppInfo appInfo;
+    @JacksonXmlProperty(localName = "appinfo") // 指定XML属性名称为"appinfo"
+    private AppInfo appInfo; // 成员变量，用于存储AppInfo对象
 
-    @JacksonXmlProperty(localName = "titile")
-    private String titile;
+    @JacksonXmlProperty(localName = "titile") // 指定XML属性名称为"titile"（注意：这里可能是拼写错误，通常应为"title"）
+    private String titile; // 成员变量，用于存储标题
 
+    // AppMsg内部类的开始
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class AppMsg {
         @JacksonXmlProperty(localName = "title")
-        private String title;
+        private String title; // 成员变量，用于存储标题
 
         @JacksonXmlProperty(localName = "sourcedisplayname")
-        private String sourceDisplayName;
+        private String sourceDisplayName; // 成员变量，用于存储来源显示名称
 
         @JacksonXmlProperty(localName = "des")
-        private String des;
+        private String des; // 成员变量，用于存储描述
 
         @JacksonXmlProperty(localName = "url")
-        private String url;
+        private String url; // 成员变量，用于存储链接
 
         @JacksonXmlProperty(localName = "action")
-        private String action;
+        private String action; // 成员变量，用于存储动作
 
         @JacksonXmlProperty(localName = "type")
-        private int type;
+        private int type; // 成员变量，用于存储类型
 
         @JacksonXmlProperty(localName = "showtype")
-        private int showType;
+        private int showType; // 成员变量，用于存储展示类型
 
         @JacksonXmlProperty(localName = "refermsg")
-        private ReferMsg referMsg;
+        private ReferMsg referMsg; // 成员变量，用于存储引用消息
 
         @JacksonXmlProperty(localName = "weappinfo")
-        private WeAppInfo weAppInfo;
+        private WeAppInfo weAppInfo; // 成员变量，用于存储微信小程序信息
 
+        // ReferMsg内部类的开始
         @Data
         @JsonIgnoreProperties(ignoreUnknown = true)
         public static class ReferMsg {
             @JacksonXmlProperty(localName = "type")
-            private int type;
+            private int type; // 成员变量，用于存储类型
 
             @JacksonXmlProperty(localName = "svrid")
-            private long svrId;
+            private long svrId; // 成员变量，用于存储服务器ID
 
             @JacksonXmlProperty(localName = "fromusr")
-            private String fromUsr;
+            private String fromUsr; // 成员变量，用于存储发送者用户名
 
             @JacksonXmlProperty(localName = "displayname")
-            private String displayName;
+            private String displayName; // 成员变量，用于存储显示名称
 
             @JacksonXmlProperty(localName = "content")
-            private String content;
+            private String content; // 成员变量，用于存储内容
 
             @JacksonXmlProperty(localName = "msgsource")
-            private String msgSource;
+            private String msgSource; // 成员变量，用于存储消息来源
         }
 
+        // WeAppInfo内部类的开始
         @Data
         @JsonIgnoreProperties(ignoreUnknown = true)
         public static class WeAppInfo {
             @JacksonXmlProperty(localName = "weappiconurl")
-            private String weAppIconUrl;
+            private String weAppIconUrl; // 成员变量，用于存储微信小程序图标URL
 
             @JacksonXmlProperty(localName = "weapppagethumbrawurl")
-            private String weAppPageThumbRawUrl;
+            private String weAppPageThumbRawUrl; // 成员变量，用于存储微信小程序页面缩略图原始URL
         }
     }
 
+    // AppInfo内部类的开始
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class AppInfo {
         @JacksonXmlProperty(localName = "version")
-        private int version;
+        private int version; // 成员变量，用于存储版本
 
         @JacksonXmlProperty(localName = "appname")
-        private String appName;
+        private String appName; // 成员变量，用于存储应用名称
     }
 }

wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/DecryptBO.java

@@ -1,7 +1,7 @@
-package com.xcs.wx.domain.bo;
+package com.xcs.wx.domain.bo; // 定义了BO（Business Object）所在的包名
 
-import lombok.AllArgsConstructor;
-import lombok.Data;
+import lombok.AllArgsConstructor; // 导入Lombok提供的注解，用于自动生成全参数的构造函数
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
 
 /**
  * DecryptBO
@@ -9,17 +9,17 @@ import lombok.Data;
  * @author xcs
  * @date 2023年12月10日20:21:02
  */
-@Data
-@AllArgsConstructor
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@AllArgsConstructor // 使用Lombok注解自动生成包含所有字段的构造函数
 public class DecryptBO {
 
     /**
      * 输入要解密的文件
      */
-    private String input;
+    private String input; // 成员变量，用于存储输入的要解密的文件路径或名称
 
     /**
      * 解密后的文件
      */
-    private String output;
-}
+    private String output; // 成员变量，用于存储解密后的文件路径或名称
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/MsgBO.java

@@ -1,169 +1,173 @@
-package com.xcs.wx.domain.bo;
+package com.xcs.wx.domain.bo; // 定义了BO（Business Object）所在的包名
 
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
-import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
-import lombok.Data;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties; // 导入Jackson库的注解，用于控制序列化行为
+import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; // 导入Jackson库的注解，用于XML属性映射
+import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement; // 导入Jackson库的注解，用于XML根元素映射
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
 
 /**
+ * MsgBO 类用于表示消息业务对象，并包含了XML映射的注解。
+ *
  * @author xcs
  * @date 2024年01月16日 14时59分
  **/
-@Data
-@JsonIgnoreProperties(ignoreUnknown = true)
-@JacksonXmlRootElement(localName = "msg")
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@JsonIgnoreProperties(ignoreUnknown = true) // 指定Jackson忽略未知属性
+@JacksonXmlRootElement(localName = "msg") // 指定XML的根元素名称为"msg"
 public class MsgBO {
 
-    @JacksonXmlProperty(localName = "img")
-    public Img img;
+    @JacksonXmlProperty(localName = "img") // 指定XML属性名称为"img"
+    public Img img; // 成员变量，用于存储图片信息
 
-    @JacksonXmlProperty(localName = "emoji")
-    private Emoji emoji;
+    @JacksonXmlProperty(localName = "emoji") // 指定XML属性名称为"emoji"
+    private Emoji emoji; // 成员变量，用于存储表情信息
 
+    // Img内部类的开始，用于存储图片信息
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class Img {
-        @JacksonXmlProperty(isAttribute = true, localName = "aeskey")
-        public String aesKey;
+        @JacksonXmlProperty(isAttribute = true, localName = "aeskey") // 指定XML属性，且为true表示这是一个属性节点
+        public String aesKey; // 图片的aes加密key
 
         @JacksonXmlProperty(isAttribute = true, localName = "encryver")
-        public String encryVer;
+        public String encryVer; // 加密版本
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnthumbaeskey")
-        public String cdnThumbAesKey;
+        public String cdnThumbAesKey; // 缩略图的aes加密key
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnthumburl")
-        public String cdnThumbUrl;
+        public String cdnThumbUrl; // 缩略图URL
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnthumblength")
-        public int cdnThumbLength;
+        public int cdnThumbLength; // 缩略图长度
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnthumbheight")
-        public int cdnThumbHeight;
+        public int cdnThumbHeight; // 缩略图高度
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnthumbwidth")
-        public int cdnThumbWidth;
+        public int cdnThumbWidth; // 缩略图宽度
 
-        @JacksonXmlProperty(isAttribute = true,localName = "cdnmidheight")
-        public int cdnMidHeight;
+        @JacksonXmlProperty(isAttribute = true, localName = "cdnmidheight")
+        public int cdnMidHeight; // 中等尺寸图片高度
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnmidwidth")
-        public int cdnMidWidth;
+        public int cdnMidWidth; // 中等尺寸图片宽度
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnhdheight")
-        public int cdnHdHeight;
+        public int cdnHdHeight; // 高清图片高度
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnhdwidth")
-        public int cdnHdWidth;
+        public int cdnHdWidth; // 高清图片宽度
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnmidimgurl")
-        public String cdnMidImgUrl;
+        public String cdnMidImgUrl; // 中等尺寸图片URL
 
         @JacksonXmlProperty(isAttribute = true, localName = "length")
-        public int length;
+        public int length; // 图片长度
 
         @JacksonXmlProperty(isAttribute = true, localName = "md5")
-        public String md5;
+        public String md5; // 图片MD5值
 
         @JacksonXmlProperty(isAttribute = true, localName = "hevc_mid_size")
-        public int hevcMidSize;
+        public int hevcMidSize; // HEVC编码中等尺寸大小
 
         @JacksonXmlProperty(isAttribute = true, localName = "originsourcemd5")
-        public String originSourceMd5;
+        public String originSourceMd5; // 原始来源MD5值
     }
 
+    // Emoji内部类的开始，用于存储表情信息
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class Emoji {
-
+        // 以下字段都是表情信息的属性，使用@JacksonXmlProperty注解将它们映射到XML属性
         @JacksonXmlProperty(isAttribute = true, localName = "fromusername")
-        private String fromUsername;
+        private String fromUsername; // 表情发送者用户名
 
         @JacksonXmlProperty(isAttribute = true, localName = "tousername")
-        private String toUsername;
+        private String toUsername; // 表情接收者用户名
 
         @JacksonXmlProperty(isAttribute = true, localName = "type")
-        private String type;
+        private String type; // 表情类型
 
         @JacksonXmlProperty(isAttribute = true, localName = "idbuffer")
-        private String idBuffer;
+        private String idBuffer; // 表情ID缓冲区
 
         @JacksonXmlProperty(isAttribute = true, localName = "md5")
-        private String md5;
+        private String md5; // 表情MD5值
 
         @JacksonXmlProperty(isAttribute = true, localName = "len")
-        private String len;
+        private String len; // 表情长度
 
         @JacksonXmlProperty(isAttribute = true, localName = "productid")
-        private String productId;
+        private String productId; // 产品ID
 
         @JacksonXmlProperty(isAttribute = true, localName = "androidmd5")
-        private String androidMd5;
+        private String androidMd5; // Android平台表情MD5值
 
         @JacksonXmlProperty(isAttribute = true, localName = "androidlen")
-        private String androidLen;
+        private String androidLen; // Android平台表情长度
 
         @JacksonXmlProperty(isAttribute = true, localName = "s60v3md5")
-        private String s60v3Md5;
+        private String s60v3Md5; // S60v3平台表情MD5值
 
         @JacksonXmlProperty(isAttribute = true, localName = "s60v3len")
-        private String s60v3Len;
+        private String s60v3Len; // S60v3平台表情长度
 
         @JacksonXmlProperty(isAttribute = true, localName = "s60v5md5")
-        private String s60v5Md5;
+        private String s60v5Md5; // S60v5平台表情MD5值
 
         @JacksonXmlProperty(isAttribute = true, localName = "s60v5len")
-        private String s60v5Len;
+        private String s60v5Len; // S60v5平台表情长度
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnurl")
-        private String cdnUrl;
+        private String cdnUrl; // CDN URL
 
         @JacksonXmlProperty(isAttribute = true, localName = "designerid")
-        private String designerId;
+        private String designerId; // 设计师ID
 
         @JacksonXmlProperty(isAttribute = true, localName = "thumburl")
-        private String thumbUrl;
+        private String thumbUrl; // 缩略图URL
 
         @JacksonXmlProperty(isAttribute = true, localName = "encrypturl")
-        private String encryptUrl;
+        private String encryptUrl; // 加密URL
 
         @JacksonXmlProperty(isAttribute = true, localName = "aeskey")
-        private String aesKey;
+        private String aesKey; // AES密钥
 
         @JacksonXmlProperty(isAttribute = true, localName = "externurl")
-        private String externUrl;
+        private String externUrl; // 外部URL
 
         @JacksonXmlProperty(isAttribute = true, localName = "externmd5")
-        private String externMd5;
+        private String externMd5; // 外部MD5值
 
         @JacksonXmlProperty(isAttribute = true, localName = "width")
-        private String width;
+        private String width; // 宽度
 
         @JacksonXmlProperty(isAttribute = true, localName = "height")
-        private String height;
+        private String height; // 高度
 
         @JacksonXmlProperty(isAttribute = true, localName = "tpurl")
-        private String tpUrl;
+        private String tpUrl; // TP URL
 
         @JacksonXmlProperty(isAttribute = true, localName = "tpauthkey")
-        private String tpAuthKey;
+        private String tpAuthKey; // TP授权密钥
 
         @JacksonXmlProperty(isAttribute = true, localName = "attachedtext")
-        private String attachedText;
+        private String attachedText; // 附加文本
 
         @JacksonXmlProperty(isAttribute = true, localName = "attachedtextcolor")
-        private String attachedTextColor;
+        private String attachedTextColor; // 附加文本颜色
 
         @JacksonXmlProperty(isAttribute = true, localName = "lensid")
-        private String lensId;
+        private String lensId; // 镜头ID
 
         @JacksonXmlProperty(isAttribute = true, localName = "emojiattr")
-        private String emojiAttr;
+        private String emojiAttr; // 表情属性
 
         @JacksonXmlProperty(isAttribute = true, localName = "linkid")
-        private String linkId;
+        private String linkId; // 链接ID
 
         @JacksonXmlProperty(isAttribute = true, localName = "desc")
-        private String desc;
+        private String desc; // 描述
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/TimelineObjectBO.java

@@ -1,223 +1,203 @@
-package com.xcs.wx.domain.bo;
+package com.xcs.wx.domain.bo; // 定义了BO（Business Object）所在的包名
 
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
-import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
-import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlText;
-import lombok.Data;
-
-import java.util.List;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties; // 导入Jackson库的注解，用于控制序列化行为
+import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; // 导入Jackson库的注解，用于XML属性映射
+import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement; // 导入Jackson库的注解，用于XML根元素映射
+import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlText; // 导入Jackson库的注解，用于XML文本内容映射
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import java.util.List; // 导入List接口，用于处理列表数据
 
 /**
- * TimelineObjectBO
+ * TimelineObjectBO 类用于表示时间线对象，并包含了XML映射的注解。
  *
  * @author xcs
  * @date 2024年01月03日 17时47分
  **/
-@Data
-@JsonIgnoreProperties(ignoreUnknown = true)
-@JacksonXmlRootElement(localName = "TimelineObject")
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@JsonIgnoreProperties(ignoreUnknown = true) // 指定Jackson忽略未知属性
+@JacksonXmlRootElement(localName = "TimelineObject") // 指定XML的根元素名称为"TimelineObject"
 public class TimelineObjectBO {
 
-    @JacksonXmlProperty(localName = "id")
-    private String id;
+    @JacksonXmlProperty(localName = "id") // 指定XML属性名称为"id"
+    private String id; // 成员变量，用于存储时间线对象的ID
 
-    @JacksonXmlProperty(localName = "username")
-    private String username;
+    @JacksonXmlProperty(localName = "username") // 指定XML属性名称为"username"
+    private String username; // 成员变量，用于存储用户名
 
-    @JacksonXmlProperty(localName = "createTime")
-    private Long createTime;
+    @JacksonXmlProperty(localName = "createTime") // 指定XML属性名称为"createTime"
+    private Long createTime; // 成员变量，用于存储创建时间
 
-    @JacksonXmlProperty(localName = "contentDesc")
-    private String contentDesc;
+    @JacksonXmlProperty(localName = "contentDesc") // 指定XML属性名称为"contentDesc"
+    private String contentDesc; // 成员变量，用于存储内容描述
 
-    @JacksonXmlProperty(localName = "contentDescShowType")
-    private String contentDescShowType;
+    @JacksonXmlProperty(localName = "contentDescShowType") // 指定XML属性名称为"contentDescShowType"
+    private String contentDescShowType; // 成员变量，用于存储内容描述展示类型
 
-    @JacksonXmlProperty(localName = "contentDescScene")
-    private String contentDescScene;
+    @JacksonXmlProperty(localName = "contentDescScene") // 指定XML属性名称为"contentDescScene"
+    private String contentDescScene; // 成员变量，用于存储内容描述场景
 
-    @JacksonXmlProperty(localName = "private")
-    private String asPrivate;
+    @JacksonXmlProperty(localName = "private") // 指定XML属性名称为"private"
+    private String asPrivate; // 成员变量，用于存储是否私有
 
-    @JacksonXmlProperty(localName = "sightFolded")
-    private String sightFolded;
+    @JacksonXmlProperty(localName = "sightFolded") // 指定XML属性名称为"sightFolded"
+    private String sightFolded; // 成员变量，用于存储是否折叠
 
-    @JacksonXmlProperty(localName = "showFlag")
-    private String showFlag;
+    @JacksonXmlProperty(localName = "showFlag") // 指定XML属性名称为"showFlag"
+    private String showFlag; // 成员变量，用于存储展示标志
 
-    @JacksonXmlProperty(localName = "appInfo")
-    private AppInfo appInfo;
+    @JacksonXmlProperty(localName = "appInfo") // 指定XML属性名称为"appInfo"
+    private AppInfo appInfo; // 成员变量，用于存储应用信息
 
-    @JacksonXmlProperty(localName = "sourceUserName")
-    private String sourceUserName;
+    @JacksonXmlProperty(localName = "sourceUserName") // 指定XML属性名称为"sourceUserName"
+    private String sourceUserName; // 成员变量，用于存储源用户名
 
-    @JacksonXmlProperty(localName = "sourceNickName")
-    private String sourceNickName;
+    @JacksonXmlProperty(localName = "sourceNickName") // 指定XML属性名称为"sourceNickName"
+    private String sourceNickName; // 成员变量，用于存储源昵称
 
-    @JacksonXmlProperty(localName = "statisticsData")
-    private String statisticsData;
+    @JacksonXmlProperty(localName = "statisticsData") // 指定XML属性名称为"statisticsData"
+    private String statisticsData; // 成员变量，用于存储统计数据
 
-    @JacksonXmlProperty(localName = "statExtStr")
-    private String statExtStr;
+    @JacksonXmlProperty(localName = "statExtStr") // 指定XML属性名称为"statExtStr"
+    private String statExtStr; // 成员变量，用于存储统计扩展字符串
 
-    @JacksonXmlProperty(localName = "ContentObject")
-    private ContentObject contentObject;
+    @JacksonXmlProperty(localName = "ContentObject") // 指定XML属性名称为"ContentObject"
+    private ContentObject contentObject; // 成员变量，用于存储内容对象
 
-    @JacksonXmlProperty(localName = "publicUserName")
-    private String publicUserName;
+    @JacksonXmlProperty(localName = "publicUserName") // 指定XML属性名称为"publicUserName"
+    private String publicUserName; // 成员变量，用于存储公开用户名
 
-    @JacksonXmlProperty(localName = "location")
-    private Location location;
+    @JacksonXmlProperty(localName = "location") // 指定XML属性名称为"location"
+    private Location location; // 成员变量，用于存储位置信息
 
-    @JacksonXmlProperty(localName = "streamvideo")
-    private StreamVideo streamVideo;
+    @JacksonXmlProperty(localName = "streamvideo") // 指定XML属性名称为"streamvideo"
+    private StreamVideo streamVideo; // 成员变量，用于存储视频流信息
 
-    /**
-     * AppInfo
-     */
+    // AppInfo内部类的开始，用于存储应用信息
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class AppInfo {
         @JacksonXmlProperty(localName = "id")
-        private String id;
+        private String id; // 应用ID
 
         @JacksonXmlProperty(localName = "version")
-        private String version;
+        private String version; // 应用版本
 
         @JacksonXmlProperty(localName = "appName")
-        private String appName;
+        private String appName; // 应用名称
 
         @JacksonXmlProperty(localName = "installUrl")
-        private String installUrl;
+        private String installUrl; // 应用安装URL
 
         @JacksonXmlProperty(localName = "fromUrl")
-        private String fromUrl;
+        private String fromUrl; // 应用来源URL
 
         @JacksonXmlProperty(localName = "isForceUpdate")
-        private String isForceUpdate;
+        private String isForceUpdate; // 是否强制更新
 
         @JacksonXmlProperty(localName = "isHidden")
-        private String isHidden;
+        private String isHidden; // 是否隐藏
     }
 
-    /**
-     * ContentObject
-     */
+    // ContentObject内部类的开始，用于存储内容对象
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class ContentObject {
         @JacksonXmlProperty(localName = "contentStyle")
-        private Integer contentStyle;
+        private Integer contentStyle; // 内容样式
 
         @JacksonXmlProperty(localName = "description")
-        private String description;
+        private String description; // 内容描述
 
         @JacksonXmlProperty(localName = "title")
-        private String title;
+        private String title; // 内容标题
 
         @JacksonXmlProperty(localName = "contentUrl")
-        private String contentUrl;
+        private String contentUrl; // 内容URL
 
         @JacksonXmlProperty(localName = "mediaList")
-        private List<Media> mediaList;
+        private List<Media> mediaList; // 媒体列表
 
-        /**
-         * Media
-         */
+        // Media内部类的开始，用于存储媒体信息
         @Data
         @JsonIgnoreProperties(ignoreUnknown = true)
         public static class Media {
             @JacksonXmlProperty(localName = "id")
-            private String id;
+            private String id; // 媒体ID
 
             @JacksonXmlProperty(localName = "type")
-            private String type;
+            private String type; // 媒体类型
 
             @JacksonXmlProperty(localName = "title")
-            private String title;
+            private String title; // 媒体标题
 
             @JacksonXmlProperty(localName = "description")
-            private String description;
+            private String description; // 媒体描述
 
             @JacksonXmlProperty(localName = "private")
-            private String asPrivate;
+            private String asPrivate; // 是否私有
 
             @JacksonXmlProperty(localName = "userData")
-            private String userData;
+            private String userData; // 用户数据
 
             @JacksonXmlProperty(localName = "subType")
-            private String subType;
+            private String subType; // 子类型
 
             @JacksonXmlProperty(localName = "videoSize")
-            private String videoSize;
+            private String videoSize; // 视频大小
 
             @JacksonXmlProperty(localName = "url")
-            private Url url;
+            private Url url; // URL信息
 
             @JacksonXmlProperty(localName = "thumb")
-            private Thumb thumb;
+            private Thumb thumb; // 缩略图信息
 
             @JacksonXmlProperty(localName = "size")
-            private String size;
+            private String size; // 大小
         }
 
+        // Url内部类的开始，用于存储URL信息
         @Data
         @JsonIgnoreProperties(ignoreUnknown = true)
         public static class Url {
             @JacksonXmlProperty(isAttribute = true)
-            private int type;
+            private int type; // URL类型
 
             @JacksonXmlProperty(isAttribute = true)
-            private String md5;
+            private String md5; // URL的MD5值
 
             @JacksonXmlProperty(isAttribute = true)
-            private String videomd5;
+            private String videomd5; // 视频URL的MD5值
 
             @JacksonXmlText
-            private String value;
+            private String value; // URL文本内容
         }
 
+        // Thumb内部类的开始，用于存储缩略图信息
         @Data
         @JsonIgnoreProperties(ignoreUnknown = true)
         public static class Thumb {
             @JacksonXmlProperty(isAttribute = true)
-            private int type;
+            private int type; // 缩略图类型
 
             @JacksonXmlText
-            private String value;
+            private String value; // 缩略图文本内容
         }
     }
 
+    // Location内部类的开始，用于存储位置信息
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class Location {
         @JacksonXmlProperty(isAttribute = true, localName = "poiClassifyId")
-        private String poiClassifyId;
+        private String poiClassifyId; // 兴趣点分类ID
 
         @JacksonXmlProperty(isAttribute = true, localName = "poiName")
-        private String poiName;
+        private String poiName; // 兴趣点名称
 
         @JacksonXmlProperty(isAttribute = true, localName = "poiAddress")
-        private String poiAddress;
+        private String poiAddress; // 兴趣点地址
 
         @JacksonXmlProperty(isAttribute = true, localName = "poiClassifyType")
-        private Integer poiClassifyType;
-
-        @JacksonXmlProperty(isAttribute = true, localName = "city")
-        private String city;
-    }
-
-    @Data
-    @JsonIgnoreProperties(ignoreUnknown = true)
-    public static class StreamVideo {
-        @JacksonXmlProperty(localName = "streamvideourl")
-        private String streamVideoUrl;
+        private Integer poiClassifyType; // 兴趣点分类类型
 
-        @JacksonXmlProperty(localName = "streamvideothumburl")
-        private String streamVideoThumbUrl;
-
-        @JacksonXmlProperty(localName = "streamvideoweburl")
-        private String streamVideoWebUrl;
-    }
-}
+        @JacksonXmlProperty(isAttribute = true, local

wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/UserBO.java

@@ -1,45 +1,45 @@
-package com.xcs.wx.domain.bo;
+package com.xcs.wx.domain.bo; // 定义了BO（Business Object）所在的包名
 
-import lombok.Builder;
-import lombok.Data;
+import lombok.Builder; // 导入Lombok提供的注解，用于自动生成builder模式的方法
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter、toString等方法
 
 /**
- * UserBO
+ * UserBO 类用于表示用户业务对象。
  *
  * @author xcs
  * @date 2023年12月31日15:25:21
  */
-@Data
-@Builder
+@Data // 使用Lombok注解自动生成getter、setter、toString、equalsAndHashCode等方法
+@Builder // 使用Lombok注解自动生成builder模式的代码
 public class UserBO {
 
     /**
      * 文件目录
      */
-    private String basePath;
+    private String basePath; // 成员变量，用于存储文件的基本目录路径
 
     /**
      * 微信Id
      */
-    private String wxId;
+    private String wxId; // 成员变量，用于存储微信的唯一标识符
 
     /**
      * 昵称
      */
-    private String nickname;
+    private String nickname; // 成员变量，用于存储用户的昵称
 
     /**
      * 版本号
      */
-    private String version;
+    private String version; // 成员变量，用于存储版本号
 
     /**
      * 账号
      */
-    private String account;
+    private String account; // 成员变量，用于存储用户的账号
 
     /**
      * 手机号
      */
-    private String mobile;
-}
+    private String mobile; // 成员变量，用于存储用户的手机号码
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/VoipMsgBO.java

@@ -1,31 +1,32 @@
-package com.xcs.wx.domain.bo;
+package com.xcs.wx.domain.bo; // 定义了BO（Business Object）所在的包名
 
-import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
-import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlCData;
-import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
-import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
-import lombok.Data;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties; // 导入Jackson库的注解，用于控制序列化行为
+import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlCData; // 导入Jackson库的注解，用于标记XML中的CData区域
+import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty; // 导入Jackson库的注解，用于XML属性映射
+import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement; // 导入Jackson库的注解，用于XML根元素映射
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
 
 /**
- * VoipMsgBO
+ * VoipMsgBO 类用于表示VoIP消息业务对象，并包含了XML映射的注解。
  *
  * @author xcs
  * @date 2024年01月17日 15时15分
  **/
-@Data
-@JsonIgnoreProperties(ignoreUnknown = true)
-@JacksonXmlRootElement(localName = "voipmsg")
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@JsonIgnoreProperties(ignoreUnknown = true) // 指定Jackson忽略未知属性
+@JacksonXmlRootElement(localName = "voipmsg") // 指定XML的根元素名称为"voipmsg"
 public class VoipMsgBO {
 
-    @JacksonXmlProperty(localName = "VoIPBubbleMsg")
-    private VoIPBubbleMsg voIPBubbleMsg;
+    @JacksonXmlProperty(localName = "VoIPBubbleMsg") // 指定XML属性名称为"VoIPBubbleMsg"
+    private VoIPBubbleMsg voIPBubbleMsg; // 成员变量，用于存储VoIPBubbleMsg对象
 
+    // VoIPBubbleMsg内部类的开始，用于存储VoIP消息内容
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class VoIPBubbleMsg {
 
-        @JacksonXmlCData
-        @JacksonXmlProperty(localName = "msg")
-        private String msg;
+        @JacksonXmlCData // 标记该字段的值为XML中的CData区域，用于避免XML解析时的特殊字符问题
+        @JacksonXmlProperty(localName = "msg") // 指定XML属性名称为"msg"
+        private String msg; // 成员变量，用于存储消息内容
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/ChatRoomDTO.java

@@ -1,30 +1,30 @@
-package com.xcs.wx.domain.dto;
+package com.xcs.wx.domain.dto; // 定义了DTO（Data Transfer Object）所在的包名
 
-import lombok.Data;
-import lombok.EqualsAndHashCode;
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import lombok.EqualsAndHashCode; // 导入Lombok提供的注解，用于自动生成equals和hashCode方法
 
 /**
- * ChatRoomDTO
+ * ChatRoomDTO 类用于表示群聊数据传输对象。
  *
  * @author xcs
  * @date 2024年01月08日 16时24分
  **/
-@Data
-@EqualsAndHashCode(callSuper = true)
-public class ChatRoomDTO extends PageDTO {
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@EqualsAndHashCode(callSuper = true) // 使用Lombok注解自动生成equals和hashCode方法，并调用父类的equals和hashCode
+public class ChatRoomDTO extends PageDTO { // ChatRoomDTO类继承自PageDTO类
 
     /**
      * 群聊标题
      */
-    private String chatRoomTitle;
+    private String chatRoomTitle; // 成员变量，用于存储群聊的标题
 
     /**
      * 群昵称
      */
-    private String selfDisplayName;
+    private String selfDisplayName; // 成员变量，用于存储群聊中的昵称
 
     /**
      * 创建人
      */
-    private String createBy;
-}
+    private String createBy; // 成员变量，用于存储群聊的创建人
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/ContactDTO.java

@@ -1,35 +1,35 @@
-package com.xcs.wx.domain.dto;
+package com.xcs.wx.domain.dto; // 定义了DTO（Data Transfer Object）所在的包名
 
-import lombok.Data;
-import lombok.EqualsAndHashCode;
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import lombok.EqualsAndHashCode; // 导入Lombok提供的注解，用于自动生成equals和hashCode方法
 
 /**
- * ContactDTO
+ * ContactDTO 类用于表示联系人数据传输对象。
  *
  * @author xcs
  * @date 2023年12月31日15:25:21
- */
-@Data
-@EqualsAndHashCode(callSuper = true)
-public class ContactDTO extends PageDTO {
+ **/
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@EqualsAndHashCode(callSuper = true) // 使用Lombok注解自动生成equals和hashCode方法，并调用父类的equals和hashCode
+public class ContactDTO extends PageDTO { // ContactDTO类继承自PageDTO类
 
     /**
      * 备注
      */
-    private String remark;
+    private String remark; // 成员变量，用于存储联系人的备注信息
 
     /**
      * 昵称
      */
-    private String nickName;
+    private String nickName; // 成员变量，用于存储联系人的昵称
 
     /**
      * 标签Id
      */
-    private String labels;
+    private String labels; // 成员变量，用于存储联系人的标签ID
 
     /**
      * 描述
      */
-    private String describe;
-}
+    private String describe; // 成员变量，用于存储联系人的描述信息
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/DecryptDTO.java

@@ -1,48 +1,48 @@
-package com.xcs.wx.domain.dto;
+package com.xcs.wx.domain.dto; // 定义了DTO（Data Transfer Object）所在的包名
 
-import lombok.Data;
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
 
 /**
- * DecryptDTO
+ * DecryptDTO 类用于表示解密操作相关的数据传输对象。
  *
  * @author xcs
  * @date 2023年12月31日15:25:21
- */
-@Data
+ **/
+@Data // 使用Lombok注解自动生成getter、setter等方法
 public class DecryptDTO {
 
     /**
      * pid
      */
-    private int pid;
+    private int pid; // 成员变量，用于存储进程ID（可能是微信的进程ID）
 
     /**
      * 文件目录
      */
-    private String basePath;
+    private String basePath; // 成员变量，用于存储文件的基本目录路径
 
     /**
      * 微信Id
      */
-    private String wxId;
+    private String wxId; // 成员变量，用于存储微信的唯一标识符
 
     /**
      * 昵称
      */
-    private String nickname;
+    private String nickname; // 成员变量，用于存储用户的昵称
 
     /**
      * 版本号
      */
-    private String version;
+    private String version; // 成员变量，用于存储版本号
 
     /**
      * 账号
      */
-    private String account;
+    private String account; // 成员变量，用于存储用户的账号
 
     /**
      * 手机号
      */
-    private String mobile;
-}
+    private String mobile; // 成员变量，用于存储用户的手机号码
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/FeedsDTO.java

@@ -1,30 +1,30 @@
-package com.xcs.wx.domain.dto;
+package com.xcs.wx.domain.dto; // 定义了DTO（Data Transfer Object）所在的包名
 
-import lombok.Data;
-import lombok.EqualsAndHashCode;
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import lombok.EqualsAndHashCode; // 导入Lombok提供的注解，用于自动生成equals和hashCode方法
 
 /**
- * FeedsDTO
+ * FeedsDTO 类用于表示朋友圈数据传输对象。
  *
  * @author xcs
  * @date 2024年01月03日 17时17分
  **/
-@Data
-@EqualsAndHashCode(callSuper = true)
-public class FeedsDTO extends PageDTO {
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@EqualsAndHashCode(callSuper = true) // 使用Lombok注解自动生成equals和hashCode方法，并调用父类的equals和hashCode
+public class FeedsDTO extends PageDTO { // FeedsDTO类继承自PageDTO类
 
     /**
      * 用户名
      */
-    private String userName;
+    private String userName; // 成员变量，用于存储用户名
 
     /**
      * 开始时间
      */
-    private Long startTime;
+    private Long startTime; // 成员变量，用于存储开始时间
 
     /**
      * 结束时间
      */
-    private Long endTime;
-}
+    private Long endTime; // 成员变量，用于存储结束时间
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/PageDTO.java

@@ -1,23 +1,23 @@
-package com.xcs.wx.domain.dto;
+package com.xcs.wx.domain.dto; // 定义了DTO（Data Transfer Object）所在的包名
 
-import lombok.Data;
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
 
 /**
- * PageDTO
+ * PageDTO 类用于表示分页数据传输对象。
  *
  * @author xcs
  * @date 2023年12月29日 15时58分
  **/
-@Data
+@Data // 使用Lombok注解自动生成getter、setter等方法
 public class PageDTO {
 
     /**
      * 当前页数
      */
-    private Long current;
+    private Long current; // 成员变量，用于存储当前的页码（页码从1开始）
 
     /**
      * 页数大小
      */
-    private Long pageSize;
-}
+    private Long pageSize; // 成员变量，用于存储每页显示的记录数
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/RecoverContactDTO.java

@@ -1,25 +1,25 @@
-package com.xcs.wx.domain.dto;
+package com.xcs.wx.domain.dto; // 定义了DTO（Data Transfer Object）所在的包名
 
-import lombok.Data;
-import lombok.EqualsAndHashCode;
+import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import lombok.EqualsAndHashCode; // 导入Lombok提供的注解，用于自动生成equals和hashCode方法
 
 /**
- * RecoverContactDTO
+ * RecoverContactDTO 类用于表示找回联系人的数据传输对象。
  *
  * @author xcs
  * @date 2024年6月14日15:29:54
  **/
-@Data
-@EqualsAndHashCode(callSuper = true)
-public class RecoverContactDTO extends PageDTO{
+@Data // 使用Lombok注解自动生成getter、setter等方法
+@EqualsAndHashCode(callSuper = true) // 使用Lombok注解自动生成equals和hashCode方法，并调用父类的equals和hashCode
+public class RecoverContactDTO extends PageDTO { // RecoverContactDTO类继承自PageDTO类
 
     /**
      * nickname
      */
-    private String nickname;
+    private String nickname; // 成员变量，用于存储联系人的昵称
 
     /**
      * c2remark
      */
-    private String remark;
-}
+    private String remark; // 成员变量，用于存储联系人的备注
+}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/AllContactVO.java

@@ -1,23 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * AllContactVO
- *
- * @author xcs
- * @date 2024年02月07日 11时15分
- **/
-@Data
-public class AllContactVO {
-
-    /**
-     * 用户名
-     */
-    private String userName;
-
-    /**
-     * 昵称。
-     */
-    private String nickName;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/CardLinkVO.java

@@ -1,33 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * CardLinkVO
- *
- * @author xcs
- * @date 2024年01月17日 14时50分
- **/
-@Data
-public class CardLinkVO {
-
-    /**
-     * title
-     */
-    private String title;
-
-    /**
-     * sourceDisplayName
-     */
-    private String sourceDisplayName;
-
-    /**
-     * des
-     */
-    private String des;
-
-    /**
-     * url
-     */
-    private String url;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ChatRoomDetailVO.java

@@ -1,63 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import lombok.Data;
-
-import java.util.List;
-
-/**
- * ChatRoomDetailVO
- *
- * @author xcs
- * @date 2024年01月08日 16时10分
- **/
-@Data
-public class ChatRoomDetailVO {
-
-    /**
-     * 群聊名称
-     */
-    private String chatRoomName;
-
-    /**
-     * 群聊标题
-     */
-    private String chatRoomTitle;
-
-    /**
-     * 自己在聊天室中的显示名称。
-     */
-    private String selfDisplayName;
-
-    /**
-     * 创建人
-     */
-    private String createBy;
-
-    /**
-     * 头像
-     */
-    private String headImgUrl;
-
-    /**
-     * 预留字段2
-     */
-    @JsonIgnore
-    private String reserved2;
-
-    /**
-     * roomData
-     */
-    @JsonIgnore
-    private byte[] roomData;
-
-    /**
-     * 群聊信息
-     */
-    private ChatRoomInfoVO chatRoomInfo;
-
-    /**
-     * 群成员
-     */
-    private List<ChatRoomMemberVO> members;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ChatRoomInfoVO.java

@@ -1,48 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * ChatRoomInfoVO
- *
- * @author xcs
- * @date 2024年01月09日 15时27分
- **/
-@Data
-public class ChatRoomInfoVO {
-
-    /**
-     * 聊天室公告内容。
-     */
-    private String announcement;
-
-    /**
-     * 信息版本号，默认为 0。
-     */
-    private Integer infoVersion;
-
-    /**
-     * 公告编辑者。
-     */
-    private String announcementEditor;
-
-    /**
-     * 公告发布人
-     */
-    private String announcementPublisher;
-
-    /**
-     * 公告发布时间，存储为时间戳，默认为 0。
-     */
-    private Long announcementPublishTime;
-
-    /**
-     * 公告发布时间
-     */
-    private String strAnnouncementPublishTime;
-
-    /**
-     * 聊天室状态，默认为 0。
-     */
-    private Integer chatRoomStatus;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ChatRoomMemberVO.java

@@ -1,33 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * ChatRoomMemberVO
- *
- * @author xcs
- * @date 2024年01月08日 16时10分
- **/
-@Data
-public class ChatRoomMemberVO {
-
-    /**
-     * wxId
-     */
-    private String wxId;
-
-    /**
-     * 备注
-     */
-    private String remark;
-
-    /**
-     * 备注
-     */
-    private Integer state;
-
-    /**
-     * 头像
-     */
-    private String headImgUrl;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ChatRoomVO.java

@@ -1,65 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import lombok.Data;
-
-/**
- * ChatRoomVO
- *
- * @author xcs
- * @date 2024年01月08日 16时10分
- **/
-@Data
-public class ChatRoomVO {
-
-    /**
-     * 聊天室名称
-     */
-    private String chatRoomName;
-
-    /**
-     * 群聊标题
-     */
-    private String chatRoomTitle;
-
-    /**
-     * 是否显示名称的标志
-     */
-    private Integer isShowName;
-
-    /**
-     * 自己在聊天室中的显示名称。
-     */
-    private String selfDisplayName;
-
-    /**
-     * 创建人
-     */
-    private String createBy;
-
-    /**
-     * 头像
-     */
-    private String headImgUrl;
-
-    /**
-     * 群聊是否已经解散
-     */
-    private Boolean dissolution;
-
-    /**
-     * 是否为企业微信群
-     */
-    private Boolean enterprise;
-
-    /**
-     * 群聊数据
-     */
-    @JsonIgnore
-    private byte[] roomData;
-
-    /**
-     * 群聊人数
-     */
-    private Integer memberCount;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ContactLabelVO.java

@@ -1,23 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * ContactLabelVO
- *
- * @author xcs
- * @date 2023年12月21日 18时13分
- **/
-@Data
-public class ContactLabelVO {
-
-    /**
-     * 标签Id
-     */
-    private String labelId;
-
-    /**
-     * 标签名称
-     */
-    private String labelName;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ContactVO.java

@@ -1,55 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-import java.util.List;
-
-/**
- * ContactVO
- *
- * @author xcs
- * @date 2023年12月22日 14时43分
- **/
-@Data
-public class ContactVO {
-
-    /**
-     * 用户名
-     */
-    private String userName;
-
-    /**
-     * 别名。
-     */
-    private String alias;
-
-    /**
-     * 备注信息。
-     */
-    private String remark;
-
-    /**
-     * 昵称。
-     */
-    private String nickName;
-
-    /**
-     * 描述
-     */
-    private String describe;
-
-    /**
-     * 头像
-     */
-    private String headImgUrl;
-
-    /**
-     * 标签Id
-     */
-    private String labelIdList;
-
-    /**
-     * 标签
-     */
-    private List<String> labels;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/CountRecentMsgsVO.java

@@ -1,28 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * CountRecentMsgsVO
- *
- * @author xcs
- * @date 2024年01月06日 14时21分
- **/
-@Data
-public class CountRecentMsgsVO {
-
-    /**
-     * 类型
-     */
-    private String type;
-
-    /**
-     * 值
-     */
-    private Long value;
-
-    /**
-     * 分类
-     */
-    private String category;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/DatabaseVO.java

@@ -1,23 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * DatabaseVO
- *
- * @author 林雷
- * @date 2024年6月28日11:08:45
- */
-@Data
-public class DatabaseVO {
-
-    /**
-     * 文件路径
-     */
-    private String filePath;
-
-    /**
-     * 文件大小
-     */
-    private String fileSize;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/DecryptVO.java

@@ -1,35 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Builder;
-import lombok.Data;
-
-/**
- * DecryptVO
- *
- * @author xcs
- * @date 2023年12月21日 18时13分
- **/
-@Data
-@Builder
-public class DecryptVO {
-
-    /**
-     * 文件名称
-     */
-    private String fileName;
-
-    /**
-     * 文件大小
-     */
-    private String fileSize;
-
-    /**
-     * 当前进度
-     */
-    private int currentProgress;
-
-    /**
-     * 总数量
-     */
-    private int total;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ExportChatRoomVO.java

@@ -1,74 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import com.alibaba.excel.annotation.ExcelIgnore;
-import com.alibaba.excel.annotation.ExcelProperty;
-import com.alibaba.excel.annotation.write.style.ColumnWidth;
-import com.alibaba.excel.annotation.write.style.ContentStyle;
-import com.alibaba.excel.enums.poi.HorizontalAlignmentEnum;
-import lombok.Data;
-
-/**
- * ExportChatRoomVO
- *
- * @author xcs
- * @date 2024年01月08日 16时10分
- **/
-@Data
-@ContentStyle(horizontalAlignment = HorizontalAlignmentEnum.CENTER)
-public class ExportChatRoomVO {
-
-    /**
-     * 群号
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("群号")
-    private String chatRoomName;
-
-    /**
-     * 群聊名称
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("群聊名称")
-    private String chatRoomTitle;
-
-    /**
-     * 备注
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("备注")
-    private String selfDisplayName;
-
-    /**
-     * 创建人
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("创建人")
-    private String createBy;
-
-    /**
-     * 群聊是否已经解散
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("群聊是否已经解散")
-    private Boolean dissolution;
-
-    /**
-     * 是否为企业微信群
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("是否为企业微信群")
-    private Boolean enterprise;
-
-    /**
-     * 群聊数据
-     */
-    @ExcelIgnore
-    private byte[] roomData;
-
-    /**
-     * 群聊人数
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("群聊人数")
-    private Integer memberCount;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ExportContactVO.java

@@ -1,60 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import com.alibaba.excel.annotation.ExcelProperty;
-import com.alibaba.excel.annotation.write.style.ColumnWidth;
-import com.alibaba.excel.annotation.write.style.ContentStyle;
-import com.alibaba.excel.enums.poi.HorizontalAlignmentEnum;
-import lombok.Data;
-
-/**
- * ExportContactVO
- *
- * @author xcs
- * @date 2023年12月22日 14时43分
- **/
-@Data
-@ContentStyle(horizontalAlignment = HorizontalAlignmentEnum.CENTER)
-public class ExportContactVO {
-
-    /**
-     * 用户名
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("微信Id")
-    private String userName;
-
-    /**
-     * 别名
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("微信号")
-    private String alias;
-
-    /**
-     * 备注
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("备注")
-    private String remark;
-
-    /**
-     * 昵称
-     */
-    @ColumnWidth(30)
-    @ExcelProperty("昵称")
-    private String nickName;
-
-    /**
-     * 描述
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("描述")
-    private String describe;
-
-    /**
-     * 标签Id
-     */
-    @ColumnWidth(20)
-    @ExcelProperty("标签Id")
-    private String labelIdList;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ExportMsgVO.java

@@ -1,67 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import com.alibaba.excel.annotation.ExcelProperty;
-import com.alibaba.excel.annotation.write.style.ColumnWidth;
-import com.alibaba.excel.annotation.write.style.ContentStyle;
-import com.alibaba.excel.enums.poi.HorizontalAlignmentEnum;
-import lombok.Data;
-
-/**
- * ExportMsgVO
- *
- * @author xcs
- * @date 2024年01月25日 16时16分
- **/
-@Data
-@ContentStyle(horizontalAlignment = HorizontalAlignmentEnum.CENTER)
-public class ExportMsgVO {
-
-    /**
-     * 消息服务器 ID
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("消息Id")
-    private String msgSvrId;
-
-    /**
-     * 聊天人Id
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("聊天人Id")
-    private String wxId;
-
-    /**
-     * 消息类型
-     */
-    @ColumnWidth(10)
-    @ExcelProperty("类型")
-    private Integer type;
-
-    /**
-     * 消息子类型
-     */
-    @ColumnWidth(10)
-    @ExcelProperty("子类型")
-    private Integer subType;
-
-    /**
-     * 是否为发送者
-     */
-    @ColumnWidth(15)
-    @ExcelProperty("是否发送者")
-    private Integer isSender;
-
-    /**
-     * 消息创建时间
-     */
-    @ColumnWidth(25)
-    @ExcelProperty("创建时间")
-    private String strCreateTime;
-
-    /**
-     * 消息内容字符串
-     */
-    @ColumnWidth(80)
-    @ExcelProperty("消息内容")
-    private String strContent;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/FeedsLocationVO.java

@@ -1,38 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * FeedsLocationVO
- *
- * @author xcs
- * @date 2024年01月04日 14时25分
- **/
-@Data
-public class FeedsLocationVO {
-
-    /**
-     * poiClassifyId
-     */
-    private String poiClassifyId;
-
-    /**
-     * poiName
-     */
-    private String poiName;
-
-    /**
-     * poiAddress
-     */
-    private String poiAddress;
-
-    /**
-     * poiClassifyType
-     */
-    private Integer poiClassifyType;
-
-    /**
-     * city
-     */
-    private String city;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/FeedsMediaVO.java

@@ -1,23 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * FeedsMediaVO
- *
- * @author xcs
- * @date 2024年01月04日 14时25分
- **/
-@Data
-public class FeedsMediaVO {
-
-    /**
-     * 大图Url
-     */
-    private String url;
-
-    /**
-     * 缩略图Url
-     */
-    private String thumb;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/FeedsVO.java

@@ -1,98 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import lombok.Data;
-
-import java.util.List;
-
-/**
- * FeedsVO
- *
- * @author xcs
- * @date 2024年01月03日 16时41分
- **/
-@Data
-public class FeedsVO {
-
-    /**
-     * 动态的唯一标识ID。
-     */
-    private Long feedId;
-
-    /**
-     * 创建时间，存储为整数形式。
-     */
-    @JsonIgnore
-    private Integer createTime;
-
-    /**
-     * 创建时间
-     */
-    private String strCreateTime;
-
-    /**
-     * 故障ID，用于记录相关故障信息。
-     */
-    private Integer faultId;
-
-    /**
-     * 动态的类型。
-     */
-    private Integer type;
-
-    /**
-     * 发布用户的用户名。
-     */
-    private String userName;
-
-    /**
-     * 发布用户的用户名。
-     */
-    private String nickName;
-
-    /**
-     * 动态的状态。
-     */
-    private Integer status;
-
-    /**
-     * 扩展标志，用于存储额外信息。
-     */
-    private Integer extFlag;
-
-    /**
-     * 隐私标志，指示动态的隐私级别。
-     */
-    private Integer privFlag;
-
-    /**
-     * 字符串ID，可能用于关联其他数据。
-     */
-    private String stringId;
-
-    /**
-     * 动态的内容文本。
-     */
-    @JsonIgnore
-    private String content;
-
-    /**
-     * 内容描述
-     */
-    private String contentDesc;
-
-    /**
-     * 媒体内容
-     */
-    private List<FeedsMediaVO> medias;
-
-    /**
-     * 位置
-     */
-    private FeedsLocationVO location;
-
-    /**
-     * 联系人头像
-     */
-    private String headImgUrl;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/MsgTypeDistributionVO.java

@@ -1,25 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-
-/**
- * MsgTypeDistributionVO
- *
- * @author xcs
- * @date 2024年01月05日 15时25分
- **/
-@Data
-@AllArgsConstructor
-public class MsgTypeDistributionVO {
-
-    /**
-     * 类型
-     */
-    private String type;
-
-    /**
-     * 数量
-     */
-    private Integer value;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/MsgVO.java

@@ -1,121 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import lombok.Data;
-
-/**
- * MsgVO
- *
- * @author xcs
- * @date 2023年12月22日 14时43分
- **/
-@Data
-public class MsgVO {
-
-    /**
-     * 本地唯一标识符，自增。
-     */
-    private Integer localId;
-
-    /**
-     * 消息服务器 ID
-     */
-    private String msgSvrId;
-
-    /**
-     * 消息类型
-     */
-    private Integer type;
-
-    /**
-     * 消息子类型
-     */
-    private Integer subType;
-
-    /**
-     * 序列号
-     */
-    private Long sequence;
-
-    /**
-     * 是否为发送者
-     */
-    private Integer isSender;
-
-    /**
-     * 消息创建时间
-     */
-    private Long createTime;
-
-    /**
-     * 消息创建时间
-     */
-    private String strCreateTime;
-
-    /**
-     * 消息内容字符串
-     */
-    private String strContent;
-
-    /**
-     * 引用消息内容
-     */
-    private String referMsgContent;
-
-    /**
-     * 聊天者字符串
-     */
-    private String strTalker;
-
-    /**
-     * 头像
-     */
-    private String avatar;
-
-    /**
-     * 图片地址Md5
-     */
-    private String imgMd5;
-
-    /**
-     * 图片缩略图
-     */
-    private String thumb;
-
-    /**
-     * 图片
-     */
-    private String image;
-
-    /**
-     * 表情Url
-     */
-    private String emojiUrl;
-
-    /**
-     * compressContent
-     */
-    @JsonIgnore
-    private byte[] compressContent;
-
-    /**
-     * bytesExtra
-     */
-    @JsonIgnore
-    private byte[] bytesExtra;
-
-    /**
-     * 小程序信息
-     */
-    private WeAppInfoVO weAppInfo;
-
-    /**
-     * 卡片链接
-     */
-    private CardLinkVO cardLink;
-
-    /**
-     * 聊天人Id
-     */
-    private String wxId;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/PageVO.java

@@ -1,37 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-
-import java.util.List;
-
-/**
- * PageVO
- *
- * @author xcs
- * @date 2023年12月29日 16时19分
- **/
-@Data
-@AllArgsConstructor
-public class PageVO<T> {
-
-    /**
-     * 当前页数
-     */
-    private Long current;
-
-    /**
-     * 页数大小
-     */
-    private Long pageSize;
-
-    /**
-     * 总页数
-     */
-    private Long total;
-
-    /**
-     * 查询条件
-     */
-    private List<T> records;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/RecentUsedKeyWordVO.java

@@ -1,20 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-
-/**
- * RecentUsedKeyWordVO
- *
- * @author xcs
- * @date 2024年01月23日 11时27分
- **/
-@Data
-@AllArgsConstructor
-public class RecentUsedKeyWordVO {
-
-    /**
-     * 关键字
-     */
-    private String text;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/RecoverContactVO.java

@@ -1,43 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import com.alibaba.excel.annotation.ExcelIgnore;
-import com.alibaba.excel.annotation.ExcelProperty;
-import com.alibaba.excel.annotation.write.style.ColumnWidth;
-import lombok.Data;
-
-/**
- * RecoverContactVO
- *
- * @author xcs
- * @date 2024年6月14日15:29:54
- **/
-@Data
-public class RecoverContactVO {
-
-    /**
-     * 本地唯一标识符，自增。
-     */
-    @ExcelIgnore
-    private Integer docId;
-
-    /**
-     * alias
-     */
-    @ExcelProperty("微信号")
-    @ColumnWidth(50)
-    private String alias;
-
-    /**
-     * nickname
-     */
-    @ExcelProperty("昵称")
-    @ColumnWidth(100)
-    private String nickname;
-
-    /**
-     * c2remark
-     */
-    @ExcelProperty("备注")
-    @ColumnWidth(100)
-    private String remark;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ResponseVO.java

@@ -1,95 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * ResponseVO
- *
- * @author xcs
- * @date 2023年12月25日 17时31分
- **/
-@Data
-public class ResponseVO<T> {
-
-    /**
-     * 业务编码
-     */
-    private Boolean success;
-
-    /**
-     * 错误编码
-     */
-    private Integer errorCode;
-
-    /**
-     * 错误消息
-     */
-    private String errorMessage;
-
-    /**
-     * 页数
-     */
-    private Long page;
-
-    /**
-     * 总数量
-     */
-    private Long total;
-
-    /**
-     * 展示类型
-     */
-    private Integer showType;
-
-    /**
-     * 数据
-     */
-    private T data;
-
-    /**
-     * 成功
-     *
-     * @param data 数据
-     * @param <T>  泛型对象
-     * @return ResponseDTO
-     */
-    public static <T> ResponseVO<T> ok(T data) {
-        ResponseVO<T> wrapper = new ResponseVO<>();
-        wrapper.setSuccess(true);
-        wrapper.setData(data);
-        return wrapper;
-    }
-
-    /**
-     * 成功
-     *
-     * @param data  数据
-     * @param <T>   泛型对象
-     * @param page  页数
-     * @param total 总数量
-     * @return ResponseDTO
-     */
-    public static <T> ResponseVO<T> ok(T data, Long page, Long total) {
-        ResponseVO<T> wrapper = new ResponseVO<>();
-        wrapper.setSuccess(true);
-        wrapper.setData(data);
-        wrapper.setPage(page);
-        wrapper.setTotal(total);
-        return wrapper;
-    }
-
-    /**
-     * 失败
-     *
-     * @param <T> 数据
-     * @return ResponseDTO
-     */
-    public static <T> ResponseVO<T> error(Integer errorCode, String errorMessage) {
-        ResponseVO<T> wrapper = new ResponseVO<>();
-        wrapper.setSuccess(false);
-        wrapper.setErrorCode(errorCode);
-        wrapper.setShowType(2);
-        wrapper.setErrorMessage(errorMessage);
-        return wrapper;
-    }
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/SessionVO.java

@@ -1,43 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * SessionVO
- *
- * @author xcs
- * @date 2023年12月21日 18时13分
- **/
-@Data
-public class SessionVO {
-
-    /**
-     * 用户名
-     */
-    private String userName;
-
-    /**
-     * 用户昵称
-     */
-    private String nickName;
-
-    /**
-     * 会话内容
-     */
-    private String content;
-
-    /**
-     * 消息时间戳
-     */
-    private Integer time;
-
-    /**
-     * 短时间
-     */
-    private String shortTime;
-
-    /**
-     * 头像Url
-     */
-    private String headImgUrl;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/StatsPanelVO.java

@@ -1,35 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-
-/**
- * StatsPanelVO
- *
- * @author xcs
- * @date 2024年01月23日 17时25分
- **/
-@Data
-@AllArgsConstructor
-public class StatsPanelVO {
-
-    /**
-     * 联系人数量
-     */
-    private Integer contact;
-
-    /**
-     * 群聊数量
-     */
-    private Integer chatRoom;
-
-    /**
-     * 今日发送消息数量
-     */
-    private Integer sent;
-
-    /**
-     * 今日接受消息数量
-     */
-    private Integer received;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/TopContactsVO.java

@@ -1,33 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * TopContactsVO
- *
- * @author xcs
- * @date 2024年01月06日 15时38分
- **/
-@Data
-public class TopContactsVO {
-
-    /**
-     * 用户名
-     */
-    private String userName;
-
-    /**
-     * 昵称
-     */
-    private String nickName;
-
-    /**
-     * 头像
-     */
-    private String headImgUrl;
-
-    /**
-     * total
-     */
-    private Long total;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/UserInfoVO.java

@@ -1,43 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * UserInfoVO
- *
- * @author xcs
- * @date 2024年6月28日16:13:53
- */
-@Data
-public class UserInfoVO {
-
-    /**
-     * 文件目录
-     */
-    private String basePath;
-
-    /**
-     * 微信Id
-     */
-    private String wxId;
-
-    /**
-     * 昵称
-     */
-    private String nickname;
-
-    /**
-     * 版本号
-     */
-    private String version;
-
-    /**
-     * 账号
-     */
-    private String account;
-
-    /**
-     * 手机号
-     */
-    private String mobile;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/UserVO.java

@@ -1,35 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-
-/**
- * UserVO
- *
- * @author xcs
- * @date 2023年12月10日20:21:02
- */
-@Data
-@AllArgsConstructor
-public class UserVO {
-
-    /**
-     * wxId
-     */
-    private String wxId;
-
-    /**
-     * 昵称
-     */
-    private String nickname;
-
-    /**
-     * 头像
-     */
-    private String avatar;
-
-    /**
-     * 当前选中状态
-     */
-    private boolean current;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/WeAppInfoVO.java

@@ -1,33 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.Data;
-
-/**
- * WeAppInfoVO
- *
- * @author xcs
- * @date 2024年01月17日 14时19分
- **/
-@Data
-public class WeAppInfoVO {
-
-    /**
-     * title
-     */
-    private String title;
-
-    /**
-     * sourceDisplayName
-     */
-    private String sourceDisplayName;
-
-    /**
-     * weAppIconUrl
-     */
-    private String weAppIconUrl;
-
-    /**
-     * weAppPageThumbRawUrl
-     */
-    private String weAppPageThumbRawUrl;
-}

wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/WeChatConfigVO.java

@@ -1,57 +0,0 @@
-package com.xcs.wx.domain.vo;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.RequiredArgsConstructor;
-
-/**
- * WeChatConfigVO
- *
- * @author xcs
- * @date 2023年12月25日 09时38分
- **/
-@Data
-@RequiredArgsConstructor
-@AllArgsConstructor
-public class WeChatConfigVO {
-
-    /**
-     * 进程Id
-     */
-    private Integer pid;
-
-    /**
-     * 基址
-     */
-    private Long baseAddress;
-
-    /**
-     * 版本号
-     */
-    private String version;
-
-    /**
-     * 昵称
-     */
-    private String nickname;
-
-    /**
-     * 账号
-     */
-    private String account;
-
-    /**
-     * 手机号
-     */
-    private String mobile;
-
-    /**
-     * 文件目录
-     */
-    private String basePath;
-
-    /**
-     * 微信Id
-     */
-    private String wxId;
-}

wx-dump-admin/src/main/java/com/xcs/wx/exception/BaseException.java

@@ -1,25 +1,25 @@
-package com.xcs.wx.exception;
+package com.xcs.wx.exception; // 定义了这个类的包名，表示这个类属于com.xcs.wx.exception包。
 
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
+import lombok.AllArgsConstructor; // 导入Lombok库的@AllArgsConstructor注解，用于生成包含所有字段的构造函数。
+import lombok.Data; // 导入Lombok库的@Data注解，用于自动生成getter和setter方法，以及toString、equals和hashCode方法。
+import lombok.EqualsAndHashCode; // 导入Lombok库的@EqualsAndHashCode注解，用于生成equals和hashCode方法。
 
 /**
- * @author xcs
- * @date 2023年12月25日 17时39分
+ * @author xcs // 表示这个类的作者。
+ * @date 2023年12月25日 17时39分 // 表示这个类的创建日期和时间。
  **/
-@Data
-@AllArgsConstructor
-@EqualsAndHashCode(callSuper = true)
-public class BaseException extends RuntimeException {
+@Data // 使用Lombok的@Data注解，自动为类的字段生成getter和setter方法。
+@AllArgsConstructor // 使用Lombok的@AllArgsConstructor注解，生成包含所有字段的构造函数。
+@EqualsAndHashCode(callSuper = true) // 使用Lombok的@EqualsAndHashCode注解，生成equals和hashCode方法，并调用父类的equals和hashCode方法。
+public class BaseException extends RuntimeException { // 定义了一个名为BaseException的类，继承自RuntimeException，用于表示基础异常。
 
     /**
      * 错误编码
      */
-    private Integer code;
+    private Integer code; // 定义了一个名为code的私有成员变量，类型为Integer，表示错误的编码。
 
     /**
      * 错误消息
      */
-    private String msg;
-}
+    private String msg; // 定义了一个名为msg的私有成员变量，类型为String，表示错误的消息。
+}

wx-dump-admin/src/main/java/com/xcs/wx/exception/BizException.java

@@ -1,14 +1,16 @@
-package com.xcs.wx.exception;
+package com.xcs.wx.exception; // 定义了这个类的包名，表示这个类属于com.xcs.wx.exception包。
 
 /**
  * 业务异常
+ * 这个类表示业务逻辑中出现的异常情况。
  *
- * @author xcs
- * @date 2023年12月25日 17时38分
+ * @author xcs // 表示这个类的作者。
+ * @date 2023年12月25日 17时38分 // 表示这个类的创建日期和时间。
  **/
-public class BizException extends BaseException {
+public class BizException extends BaseException { // 定义了一个名为BizException的类，继承自BaseException，用于表示业务异常。
 
-    public BizException(Integer code, String msg) {
-        super(code, msg);
+    // 构造函数，接收错误编码和错误消息作为参数。
+    public BizException(Integer code, String msg) { // 定义构造函数，接收两个参数：错误编码(code)和错误消息(msg)。
+        super(code, msg); // 调用父类BaseException的构造函数，传递错误编码和错误消息。
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/ChatRoomInfoMapper.java

@@ -1,13 +1,15 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.ChatRoomInfo;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.ChatRoomInfo; // 导入ChatRoomInfo实体类，这个类定义了群聊详情的数据结构。
 
 /**
  * 群聊详情 Mapper
+ * 这个接口定义了与群聊详情相关的数据库操作。
  *
- * @author xcs
- * @date 2024年01月09日 15时20分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2024年01月09日 15时20分 // 表示这个接口的创建日期和时间。
  **/
-public interface ChatRoomInfoMapper extends BaseMapper<ChatRoomInfo> {
-}
+public interface ChatRoomInfoMapper extends BaseMapper<ChatRoomInfo> { // 定义了一个名为ChatRoomInfoMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为ChatRoomInfo，表示这个Mapper接口是用于操作ChatRoomInfo表的数据库操作。
+    // 该接口中没有定义额外的方法，因为BaseMapper已经提供了常用的CRUD操作方法。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/ChatRoomMapper.java

@@ -1,43 +1,46 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.xcs.wx.domain.ChatRoom;
-import com.xcs.wx.domain.dto.ChatRoomDTO;
-import com.xcs.wx.domain.vo.ChatRoomVO;
-import com.xcs.wx.domain.vo.ExportChatRoomVO;
-import org.apache.ibatis.annotations.Param;
-
-import java.util.List;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入MyBatis Plus的分页插件Page，用于处理分页查询。
+import com.xcs.wx.domain.ChatRoom; // 导入ChatRoom实体类，这个类定义了群聊的数据结构。
+import com.xcs.wx.domain.dto.ChatRoomDTO; // 导入ChatRoomDTO类，这个类定义了群聊的查询条件数据传输对象。
+import com.xcs.wx.domain.vo.ChatRoomVO; // 导入ChatRoomVO类，这个类定义了群聊的视图对象。
+import com.xcs.wx.domain.vo.ExportChatRoomVO; // 导入ExportChatRoomVO类，这个类定义了群聊导出的数据结构。
+import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解，用于指定方法参数的名称。
+import java.util.List; // 导入Java的List接口，用于返回列表类型的数据。
 
 /**
  * 群聊 Mapper
+ * 这个接口定义了与群聊相关的数据库操作。
  *
- * @author xcs
- * @date 2024年01月08日 15时55分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2024年01月08日 15时55分 // 表示这个接口的创建日期和时间。
  **/
-public interface ChatRoomMapper extends BaseMapper<ChatRoom> {
+public interface ChatRoomMapper extends BaseMapper<ChatRoom> { // 定义了一个名为ChatRoomMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为ChatRoom，表示这个Mapper接口是用于操作ChatRoom表的数据库操作。
 
     /**
      * 查询群聊
+     * 该方法用于根据分页信息和查询条件查询群聊信息。
      *
-     * @param page        分页信息
-     * @param chatRoomDTO 查询条件
-     * @return ChatRoomVO
+     * @param page 分页信息，包含查询的页码和每页的数量。
+     * @param chatRoomDTO 查询条件，包含过滤和排序的参数。
+     * @return ChatRoomVO 分页的群聊视图对象，包含群聊的详细信息。
      */
-    Page<ChatRoomVO> queryChatRoom(Page<ChatRoomVO> page, @Param("chatRoomDTO") ChatRoomDTO chatRoomDTO);
+    Page<ChatRoomVO> queryChatRoom(Page<ChatRoomVO> page, @Param("chatRoomDTO") ChatRoomDTO chatRoomDTO); // 定义了一个名为queryChatRoom的方法，用于查询群聊信息。
 
     /**
      * 统计群聊数量
+     * 该方法用于统计群聊的总数。
      *
-     * @return 群聊总数
+     * @return 群聊总数。
      */
-    int countChatRoom();
+    int countChatRoom(); // 定义了一个名为countChatRoom的方法，用于统计群聊数量。
 
     /**
      * 导出群聊
+     * 该方法用于导出群聊信息。
      *
-     * @return ExportChatRoomVO
+     * @return ExportChatRoomVO 包含群聊导出信息的列表。
      */
-    List<ExportChatRoomVO> exportChatRoom();
-}
+    List<ExportChatRoomVO> exportChatRoom(); // 定义了一个名为exportChatRoom的方法，用于导出群聊信息。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/ContactHeadImgMapper.java

@@ -1,21 +1,23 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.ContactHeadImg;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.ContactHeadImg; // 导入ContactHeadImg实体类，这个类定义了联系人头像的数据结构。
 
 /**
  * 联系人头像 Mapper
+ * 这个接口定义了与联系人头像相关的数据库操作。
  *
- * @author xcs
- * @date 2024年6月18日15:33:26
+ * @author xcs // 表示这个接口的作者。
+ * @date 2024年6月18日15:33:26 // 表示这个接口的创建日期和时间。
  **/
-public interface ContactHeadImgMapper extends BaseMapper<ContactHeadImg> {
+public interface ContactHeadImgMapper extends BaseMapper<ContactHeadImg> { // 定义了一个名为ContactHeadImgMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为ContactHeadImg，表示这个Mapper接口是用于操作ContactHeadImg表的数据库操作。
 
     /**
      * 根据用户名查询联系人头像
+     * 该方法用于根据提供的用户名查询对应的联系人头像信息。
      *
-     * @param usrName 用户名
-     * @return ContactHeadImg
+     * @param usrName 用户名，作为查询条件。
+     * @return ContactHeadImg 查询到的联系人头像对象。
      */
-    ContactHeadImg getContactHeadImg(String usrName);
-}
+    ContactHeadImg getContactHeadImg(String usrName); // 定义了一个名为getContactHeadImg的方法，用于根据用户名查询联系人头像。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/ContactHeadImgUrlMapper.java

@@ -1,13 +1,15 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.ContactHeadImgUrl;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.ContactHeadImgUrl; // 导入ContactHeadImgUrl实体类，这个类定义了联系人头像URL的数据结构。
 
 /**
  * 联系人头像 Mapper
+ * 这个接口定义了与联系人头像URL相关的数据库操作。
  *
- * @author xcs
- * @date 2023年12月21日 17时08分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2023年12月21日 17时08分 // 表示这个接口的创建日期和时间。
  **/
-public interface ContactHeadImgUrlMapper extends BaseMapper<ContactHeadImgUrl> {
-}
+public interface ContactHeadImgUrlMapper extends BaseMapper<ContactHeadImgUrl> { // 定义了一个名为ContactHeadImgUrlMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为ContactHeadImgUrl，表示这个Mapper接口是用于操作ContactHeadImgUrl表的数据库操作。
+    // 该接口中没有定义额外的方法，因为BaseMapper已经提供了常用的CRUD操作方法。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/ContactLabelMapper.java

@@ -1,13 +1,15 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.ContactLabel;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.ContactLabel; // 导入ContactLabel实体类，这个类定义了联系人标签的数据结构。
 
 /**
  * 联系人标签 Mapper
+ * 这个接口定义了与联系人标签相关的数据库操作。
  *
- * @author xcs
- * @date 2023年12月22日17:19:20
+ * @author xcs // 表示这个接口的作者。
+ * @date 2023年12月22日17:19:20 // 表示这个接口的创建日期和时间。
  */
-public interface ContactLabelMapper extends BaseMapper<ContactLabel> {
-}
+public interface ContactLabelMapper extends BaseMapper<ContactLabel> { // 定义了一个名为ContactLabelMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为ContactLabel，表示这个Mapper接口是用于操作ContactLabel表的数据库操作。
+    // 该接口中没有定义额外的方法，因为BaseMapper已经提供了常用的CRUD操作方法。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/ContactMapper.java

@@ -1,59 +1,65 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.xcs.wx.domain.Contact;
-import com.xcs.wx.domain.dto.ContactDTO;
-import com.xcs.wx.domain.vo.AllContactVO;
-import com.xcs.wx.domain.vo.ContactVO;
-import com.xcs.wx.domain.vo.ExportContactVO;
-import org.apache.ibatis.annotations.Param;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page; // 导入MyBatis Plus的分页插件Page，用于处理分页查询。
+import com.xcs.wx.domain.Contact; // 导入Contact实体类，这个类定义了联系人的数据结构。
+import com.xcs.wx.domain.dto.ContactDTO; // 导入ContactDTO类，这个类定义了联系人的数据传输对象。
+import com.xcs.wx.domain.vo.AllContactVO; // 导入AllContactVO类，这个类定义了所有联系人的视图对象。
+import com.xcs.wx.domain.vo.ContactVO; // 导入ContactVO类，这个类定义了联系人的视图对象。
+import com.xcs.wx.domain.vo.ExportContactVO; // 导入ExportContactVO类，这个类定义了联系人导出的数据结构。
+import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解，用于指定方法参数的名称。
 
-import java.util.List;
-import java.util.Set;
+import java.util.List; // 导入Java的List接口，用于返回列表类型的数据。
+import java.util.Set; // 导入Java的Set接口，用于返回集合类型的数据。
 
 /**
  * 联系人 Mapper
+ * 这个接口定义了与联系人相关的数据库操作。
  *
- * @author xcs
- * @date 2023年12月22日 13时51分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2023年12月22日 13时51分 // 表示这个接口的创建日期和时间。
  **/
-public interface ContactMapper extends BaseMapper<Contact> {
+public interface ContactMapper extends BaseMapper<Contact> { // 定义了一个名为ContactMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为Contact，表示这个Mapper接口是用于操作Contact表的数据库操作。
 
     /**
      * 查询联系人
+     * 该方法用于根据分页信息和联系人DTO查询联系人信息。
      *
-     * @param page       分页信息
-     * @param contactDTO 联系人
-     * @return Contact
+     * @param page 分页信息，包含查询的页码和每页的数量。
+     * @param contactDTO 联系人DTO，包含过滤和排序的参数。
+     * @return 分页的联系人视图对象，包含联系人的详细信息。
      */
-    Page<ContactVO> queryContact(Page<ContactVO> page, @Param("contactDTO") ContactDTO contactDTO);
+    Page<ContactVO> queryContact(Page<ContactVO> page, @Param("contactDTO") ContactDTO contactDTO); // 定义了一个名为queryContact的方法，用于查询联系人信息。
 
     /**
      * 查询所有联系人
+     * 该方法用于查询所有联系人信息。
      *
-     * @return AllContactVO
+     * @return 包含所有联系人视图对象的列表。
      */
-    List<AllContactVO> queryAllContact();
+    List<AllContactVO> queryAllContact(); // 定义了一个名为queryAllContact的方法，用于查询所有联系人信息。
 
     /**
      * 查询联系人与公众号的Id
+     * 该方法用于查询联系人与公众号的ID。
      *
-     * @return Contact
+     * @return 包含联系人与公众号ID的集合。
      */
-    Set<String> getContactWithMp();
+    Set<String> getContactWithMp(); // 定义了一个名为getContactWithMp的方法，用于查询联系人与公众号的ID。
 
     /**
      * 统计联系人数量
+     * 该方法用于统计联系人的总数。
      *
-     * @return 联系人数量
+     * @return 联系人数量。
      */
-    int countContact();
+    int countContact(); // 定义了一个名为countContact的方法，用于统计联系人数量。
 
     /**
      * 导出联系人
+     * 该方法用于导出联系人信息。
      *
-     * @return ExportContactVO
+     * @return 包含联系人导出信息的列表。
      */
-    List<ExportContactVO> exportContact();
-}
+    List<ExportContactVO> exportContact(); // 定义了一个名为exportContact的方法，用于导出联系人信息。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/FTSContactContentMapper.java

@@ -1,14 +1,15 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.FTSContactContent;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.FTSContactContent; // 导入FTSContactContent实体类，这个类定义了全文搜索联系人内容的数据结构。
 
 /**
  * FTSContactContentMapper
+ * 这个接口定义了与全文搜索联系人内容相关的数据库操作。
  *
- * @author xcs
- * @date 2024年6月14日14:24:43
+ * @author xcs // 表示这个接口的作者。
+ * @date 2024年6月14日14:24:43 // 表示这个接口的创建日期和时间。
  **/
-public interface FTSContactContentMapper extends BaseMapper<FTSContactContent> {
-
-}
+public interface FTSContactContentMapper extends BaseMapper<FTSContactContent> { // 定义了一个名为FTSContactContentMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为FTSContactContent，表示这个Mapper接口是用于操作FTSContactContent表的数据库操作。
+    // 该接口中没有定义额外的方法，因为BaseMapper已经提供了常用的CRUD操作方法。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/FTSRecentUsedMapper.java

@@ -1,13 +1,15 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.FTSRecentUsed;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.FTSRecentUsed; // 导入FTSRecentUsed实体类，这个类定义了最近使用关键字的数据结构。
 
 /**
  * 最近使用关键字 Mapper
+ * 这个接口定义了与最近使用关键字相关的数据库操作。
  *
- * @author xcs
- * @date 2023年12月22日 13时51分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2023年12月22日 13时51分 // 表示这个接口的创建日期和时间。
  **/
-public interface FTSRecentUsedMapper extends BaseMapper<FTSRecentUsed> {
-}
+public interface FTSRecentUsedMapper extends BaseMapper<FTSRecentUsed> { // 定义了一个名为FTSRecentUsedMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为FTSRecentUsed，表示这个Mapper接口是用于操作FTSRecentUsed表的数据库操作。
+    // 该接口中没有定义额外的方法，因为BaseMapper已经提供了常用的CRUD操作方法。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/FeedsMapper.java

@@ -1,14 +1,15 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.Feeds;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.Feeds; // 导入Feeds实体类，这个类定义了朋友圈的数据结构。
 
 /**
  * 朋友圈 Mapper
+ * 这个接口定义了与朋友圈相关的数据库操作。
  *
- * @author xcs
- * @date 2023年12月22日 13时51分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2023年12月22日 13时51分 // 表示这个接口的创建日期和时间。
  **/
-public interface FeedsMapper extends BaseMapper<Feeds> {
-
-}
+public interface FeedsMapper extends BaseMapper<Feeds> { // 定义了一个名为FeedsMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为Feeds，表示这个Mapper接口是用于操作Feeds表的数据库操作。
+    // 该接口中没有定义额外的方法，因为BaseMapper已经提供了常用的CRUD操作方法。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/HardLinkImageAttributeMapper.java

@@ -1,22 +1,24 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.HardLinkImageAttribute;
-import org.apache.ibatis.annotations.Param;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.HardLinkImageAttribute; // 导入HardLinkImageAttribute实体类，这个类定义了图片链接属性的数据结构。
+import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解，用于指定方法参数的名称。
 
 /**
  * 图片链接 Mapper
+ * 这个接口定义了与图片链接相关的数据库操作。
  *
- * @author xcs
- * @date 2024年1月16日21:50:13
+ * @author xcs // 表示这个接口的作者。
+ * @date 2024年1月16日21:50:13 // 表示这个接口的创建日期和时间。
  */
-public interface HardLinkImageAttributeMapper extends BaseMapper<HardLinkImageAttribute> {
+public interface HardLinkImageAttributeMapper extends BaseMapper<HardLinkImageAttribute> { // 定义了一个名为HardLinkImageAttributeMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为HardLinkImageAttribute，表示这个Mapper接口是用于操作HardLinkImageAttribute表的数据库操作。
 
     /**
      * 查询图片
+     * 该方法用于根据图片的MD5值查询图片链接。
      *
-     * @param md5 md5
-     * @return 图片
+     * @param md5 图片的MD5值。
+     * @return 返回查询到的图片链接。
      */
-    String queryHardLinkImage(@Param("md5") byte[] md5);
-}
+    String queryHardLinkImage(@Param("md5") byte[] md5); // 定义了一个名为queryHardLinkImage的方法，用于根据MD5值查询图片链接。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/HardLinkVideoAttributeMapper.java

@@ -1,22 +1,24 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.HardLinkVideoAttribute;
-import org.apache.ibatis.annotations.Param;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.HardLinkVideoAttribute; // 导入HardLinkVideoAttribute实体类，这个类定义了视频链接属性的数据结构。
+import org.apache.ibatis.annotations.Param; // 导入MyBatis的Param注解，用于指定方法参数的名称。
 
 /**
- * 视频链接  Mapper
+ * 视频链接 Mapper
+ * 这个接口定义了与视频链接相关的数据库操作。
  *
- * @author xcs
- * @date 2024年1月16日21:50:13
+ * @author xcs // 表示这个接口的作者。
+ * @date 2024年1月16日21:50:13 // 表示这个接口的创建日期和时间。
  */
-public interface HardLinkVideoAttributeMapper extends BaseMapper<HardLinkVideoAttribute> {
+public interface HardLinkVideoAttributeMapper extends BaseMapper<HardLinkVideoAttribute> { // 定义了一个名为HardLinkVideoAttributeMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为HardLinkVideoAttribute，表示这个Mapper接口是用于操作HardLinkVideoAttribute表的数据库操作。
 
     /**
      * 查询视频
+     * 该方法用于根据视频的MD5值查询视频链接。
      *
-     * @param md5 md5
-     * @return 视频
+     * @param md5 视频的MD5值。
+     * @return 返回查询到的视频链接。
      */
-    String queryHardLinkVideo(@Param("md5") byte[] md5);
-}
+    String queryHardLinkVideo(@Param("md5") byte[] md5); // 定义了一个名为queryHardLinkVideo的方法，用于根据MD5值查询视频链接。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/MsgMapper.java

@@ -1,53 +1,59 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.Msg;
-import com.xcs.wx.domain.vo.CountRecentMsgsVO;
-import com.xcs.wx.domain.vo.MsgTypeDistributionVO;
-import com.xcs.wx.domain.vo.TopContactsVO;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.Msg; // 导入Msg实体类，这个类定义了消息的数据结构。
+import com.xcs.wx.domain.vo.CountRecentMsgsVO; // 导入CountRecentMsgsVO类，这个类定义了统计过去15天每天的发送和接收消息数量的数据结构。
+import com.xcs.wx.domain.vo.MsgTypeDistributionVO; // 导入MsgTypeDistributionVO类，这个类定义了微信消息类型及其分布统计的数据结构。
+import com.xcs.wx.domain.vo.TopContactsVO; // 导入TopContactsVO类，这个类定义了最近一个月内微信互动最频繁的前10位联系人的数据结构。
 
-import java.util.List;
+import java.util.List; // 导入Java的List接口，用于返回列表类型的数据。
 
 /**
  * 消息 Mapper
+ * 这个接口定义了与消息相关的数据库操作。
  *
- * @author xcs
- * @date 2023年12月22日 13时51分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2023年12月22日 13时51分 // 表示这个接口的创建日期和时间。
  **/
-public interface MsgMapper extends BaseMapper<Msg> {
+public interface MsgMapper extends BaseMapper<Msg> { // 定义了一个名为MsgMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为Msg，表示这个Mapper接口是用于操作Msg表的数据库操作。
 
     /**
      * 微信消息类型及其分布统计
+     * 该方法用于统计不同类型消息的分布情况。
      *
-     * @return MsgTypeDistributionVO
+     * @return 包含消息类型及其分布统计信息的列表。
      */
-    List<MsgTypeDistributionVO> msgTypeDistribution();
+    List<MsgTypeDistributionVO> msgTypeDistribution(); // 定义了一个名为msgTypeDistribution的方法，用于统计微信消息类型及其分布。
 
     /**
      * 统计过去 15 天每天的发送和接收消息数量
+     * 该方法用于统计过去15天每天的发送和接收消息数量。
      *
-     * @return MsgTrendVO
+     * @return 包含过去15天每天的发送和接收消息数量统计信息的列表。
      */
-    List<CountRecentMsgsVO> countRecentMsgs();
+    List<CountRecentMsgsVO> countRecentMsgs(); // 定义了一个名为countRecentMsgs的方法，用于统计过去15天每天的发送和接收消息数量。
 
     /**
      * 最近一个月内微信互动最频繁的前10位联系人
+     * 该方法用于找出最近一个月内微信互动最频繁的前10位联系人。
      *
-     * @return MsgRankVO
+     * @return 包含最近一个月内微信互动最频繁的前10位联系人信息的列表。
      */
-    List<TopContactsVO> topContacts();
+    List<TopContactsVO> topContacts(); // 定义了一个名为topContacts的方法，用于找出最近一个月内微信互动最频繁的前10位联系人。
 
     /**
      * 统计发送消息数量
+     * 该方法用于统计发送的消息数量。
      *
-     * @return 消息数量
+     * @return 发送的消息数量。
      */
-    int countSent();
+    int countSent(); // 定义了一个名为countSent的方法，用于统计发送消息数量。
 
     /**
      * 统计接受消息数量
+     * 该方法用于统计接收的消息数量。
      *
-     * @return 消息数量
+     * @return 接收的消息数量。
      */
-    int countReceived();
-}
+    int countReceived(); // 定义了一个名为countReceived的方法，用于统计接受消息数量。
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapper/SessionMapper.java

@@ -1,23 +1,25 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.Session;
-import com.xcs.wx.domain.vo.SessionVO;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.Session; // 导入Session实体类，这个类定义了会话的数据结构。
+import com.xcs.wx.domain.vo.SessionVO; // 导入SessionVO类，这个类定义了会话视图对象的数据结构。
 
-import java.util.List;
+import java.util.List; // 导入Java的List接口，用于返回列表类型的数据。
 
 /**
  * 会话 Mapper
+ * 这个接口定义了与会话相关的数据库操作。
  *
- * @author xcs
- * @date 2023年12月21日 17时08分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2023年12月21日 17时08分 // 表示这个接口的创建日期和时间。
  **/
-public interface SessionMapper extends BaseMapper<Session> {
+public interface SessionMapper extends BaseMapper<Session> { // 定义了一个名为SessionMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为Session，表示这个Mapper接口是用于操作Session表的数据库操作。
 
     /**
      * 查询会话
+     * 该方法用于查询会话信息。
      *
-     * @return
+     * @return 返回包含会话信息的视图对象列表。
      */
-    List<SessionVO> querySession();
+    List<SessionVO> querySession(); // 定义了一个名为querySession的方法，用于查询会话信息，并返回会话视图对象的列表。
 }

wx-dump-admin/src/main/java/com/xcs/wx/mapper/SqliteMasterMapper.java

@@ -1,18 +1,19 @@
-package com.xcs.wx.mapper;
+package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper;
-import com.xcs.wx.domain.Session;
-import com.xcs.wx.domain.SqliteMaster;
-import com.xcs.wx.domain.vo.SessionVO;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
+import com.xcs.wx.domain.Session; // 导入Session实体类，这个类定义了会话的数据结构。
+import com.xcs.wx.domain.SqliteMaster; // 导入SqliteMaster实体类，这个类定义了SQLite数据库中的系统表的数据结构。
+import com.xcs.wx.domain.vo.SessionVO; // 导入SessionVO类，这个类定义了会话视图对象的数据结构。
 
-import java.util.List;
+import java.util.List; // 导入Java的List接口，用于返回列表类型的数据。
 
 /**
  * SQLite 数据库中的一个系统表 Mapper
+ * 这个接口定义了与SQLite数据库中的系统表相关的数据库操作。
  *
- * @author xcs
- * @date 2023年12月21日 17时08分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2023年12月21日 17时08分 // 表示这个接口的创建日期和时间。
  **/
-public interface SqliteMasterMapper extends BaseMapper<SqliteMaster> {
-
+public interface SqliteMasterMapper extends BaseMapper<SqliteMaster> { // 定义了一个名为SqliteMasterMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为SqliteMaster，表示这个Mapper接口是用于操作SqliteMaster表的数据库操作。
+    // 该接口中没有定义额外的方法，因为BaseMapper已经提供了常用的CRUD操作方法。
 }

wx-dump-admin/src/main/java/com/xcs/wx/mapping/ChatRoomMapping.java

@@ -1,80 +1,86 @@
-package com.xcs.wx.mapping;
+package com.xcs.wx.mapping; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapping包。
 
-import cn.hutool.core.util.StrUtil;
-import com.xcs.wx.domain.ChatRoom;
-import com.xcs.wx.domain.ChatRoomInfo;
-import com.xcs.wx.domain.vo.ChatRoomDetailVO;
-import com.xcs.wx.domain.vo.ChatRoomInfoVO;
-import com.xcs.wx.domain.vo.ChatRoomMemberVO;
-import com.xcs.wx.domain.vo.ChatRoomVO;
-import com.xcs.wx.protobuf.ChatRoomProto;
-import org.mapstruct.Mapper;
+import cn.hutool.core.util.StrUtil; // 导入Hutool库中的StrUtil工具类，用于字符串处理。
+import com.xcs.wx.domain.ChatRoom; // 导入ChatRoom实体类，这个类定义了群聊的数据结构。
+import com.xcs.wx.domain.ChatRoomInfo; // 导入ChatRoomInfo实体类，这个类定义了群聊信息的数据结构。
+import com.xcs.wx.domain.vo.ChatRoomDetailVO; // 导入ChatRoomDetailVO类，这个类定义了群聊详细视图对象的数据结构。
+import com.xcs.wx.domain.vo.ChatRoomInfoVO; // 导入ChatRoomInfoVO类，这个类定义了群聊信息视图对象的数据结构。
+import com.xcs.wx.domain.vo.ChatRoomMemberVO; // 导入ChatRoomMemberVO类，这个类定义了群聊成员视图对象的数据结构。
+import com.xcs.wx.domain.vo.ChatRoomVO; // 导入ChatRoomVO类，这个类定义了群聊视图对象的数据结构。
+import com.xcs.wx.protobuf.ChatRoomProto; // 导入ChatRoomProto类，这个类定义了群聊的protobuf协议。
+import org.mapstruct.Mapper; // 导入MapStruct的@Mapper注解，用于定义映射接口。
 
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
+import java.util.List; // 导入Java的List接口，用于返回列表类型的数据。
+import java.util.Map; // 导入Java的Map接口，用于处理键值对数据。
+import java.util.stream.Collectors; // 导入Java的Collectors类，用于流操作的收集器。
 
 /**
  * 群聊 Mapping
+ * 这个接口定义了群聊相关对象之间的转换映射。
  *
- * @author xcs
- * @date 2024年01月08日 17时00分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2024年01月08日 17时00分 // 表示这个接口的创建日期和时间。
  **/
-@Mapper(componentModel = "spring")
-public interface ChatRoomMapping {
+@Mapper(componentModel = "spring") // 使用MapStruct的@Mapper注解，指定该接口为映射接口，并配置为Spring组件。
+public interface ChatRoomMapping { // 定义了一个名为ChatRoomMapping的接口，用于群聊对象之间的转换映射。
 
     /**
      * 参数转换
+     * 将一组ChatRoom对象转换为ChatRoomVO对象。
      *
-     * @param chatRooms 入参
-     * @return ChatRoomVO
+     * @param chatRooms 入参，待转换的ChatRoom对象列表。
+     * @return ChatRoomVO 转换后的ChatRoom视图对象列表。
      */
-    List<ChatRoomVO> convert(List<ChatRoom> chatRooms);
+    List<ChatRoomVO> convert(List<ChatRoom> chatRooms); // 定义了一个方法，将ChatRoom列表转换为ChatRoomVO列表。
 
     /**
      * 转换参数
+     * 将单个ChatRoom对象转换为ChatRoomDetailVO对象。
      *
-     * @param chatRoom 入参
-     * @return ChatRoomDetailVO
+     * @param chatRoom 入参，待转换的ChatRoom对象。
+     * @return ChatRoomDetailVO 转换后的ChatRoom详细视图对象。
      */
-    ChatRoomDetailVO convert(ChatRoom chatRoom);
+    ChatRoomDetailVO convert(ChatRoom chatRoom); // 定义了一个方法，将单个ChatRoom对象转换为ChatRoomDetailVO对象。
 
     /**
      * 转换参数
+     * 将单个ChatRoomInfo对象转换为ChatRoomInfoVO对象。
      *
-     * @param chatRoomInfo 入参
-     * @return ChatRoomInfoVO
+     * @param chatRoomInfo 入参，待转换的ChatRoomInfo对象。
+     * @return ChatRoomInfoVO 转换后的ChatRoom信息视图对象。
      */
-    ChatRoomInfoVO convert(ChatRoomInfo chatRoomInfo);
+    ChatRoomInfoVO convert(ChatRoomInfo chatRoomInfo); // 定义了一个方法，将单个ChatRoomInfo对象转换为ChatRoomInfoVO对象。
 
     /**
      * 参数转换
+     * 将单个ChatRoomProto.Member对象转换为ChatRoomMemberVO对象。
      *
-     * @param member 入参
-     * @return ChatRoomMemberVO
+     * @param member 入参，待转换的ChatRoomProto.Member对象。
+     * @return ChatRoomMemberVO 转换后的ChatRoom成员视图对象。
      */
-    ChatRoomMemberVO convert(ChatRoomProto.Member member);
+    ChatRoomMemberVO convert(ChatRoomProto.Member member); // 定义了一个方法，将单个ChatRoomProto.Member对象转换为ChatRoomMemberVO对象。
 
     /**
      * 参数转换
+     * 将一组ChatRoomProto.Member对象转换为ChatRoomMemberVO对象，并设置头像和群昵称。
      *
-     * @param members            入参
-     * @param headImgUrlMap      头像信息
-     * @param contactNicknameMap 群昵称
-     * @return ChatRoomMemberVO
+     * @param members            入参，待转换的ChatRoomProto.Member对象列表。
+     * @param headImgUrlMap     头像信息的映射。
+     * @param contactNicknameMap 群昵称的映射。
+     * @return ChatRoomMemberVO 转换后的ChatRoom成员视图对象列表。
      */
-    default List<ChatRoomMemberVO> convert(List<ChatRoomProto.Member> members, Map<String, String> headImgUrlMap, Map<String, String> contactNicknameMap) {
-        return members.stream()
-                .map(this::convert)
-                .peek(member -> member.setHeadImgUrl(headImgUrlMap.get(member.getWxId())))
-                .peek(member -> {
+    default List<ChatRoomMemberVO> convert(List<ChatRoomProto.Member> members, Map<String, String> headImgUrlMap, Map<String, String> contactNicknameMap) { // 定义了一个默认方法，将ChatRoomProto.Member列表转换为ChatRoomMemberVO列表。
+        return members.stream() // 将成员列表转换为流。
+                .map(this::convert) // 使用之前定义的convert方法将每个成员转换为ChatRoomMemberVO。
+                .peek(member -> member.setHeadImgUrl(headImgUrlMap.get(member.getWxId()))) // 设置成员的头像URL。
+                .peek(member -> { // 对每个成员进行处理。
                     // 如果存在群备注则不处理
-                    if (StrUtil.isNotBlank(member.getRemark())) {
-                        return;
+                    if (StrUtil.isNotBlank(member.getRemark())) { // 检查成员的备注是否不为空。
+                        return; // 如果备注不为空，则直接返回，不做处理。
                     }
                     // 设置群昵称
-                    member.setRemark(contactNicknameMap.get(member.getWxId()));
+                    member.setRemark(contactNicknameMap.get(member.getWxId())); // 设置成员的群昵称。
                 })
-                .collect(Collectors.toList());
+                .collect(Collectors.toList()); // 收集转换后的成员列表并返回。
     }
-}
+}

wx-dump-admin/src/main/java/com/xcs/wx/mapping/ContactLabelMapping.java

@@ -1,25 +1,27 @@
-package com.xcs.wx.mapping;
+package com.xcs.wx.mapping; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapping包。
 
-import com.xcs.wx.domain.ContactLabel;
-import com.xcs.wx.domain.vo.ContactLabelVO;
-import org.mapstruct.Mapper;
+import com.xcs.wx.domain.ContactLabel; // 导入ContactLabel实体类，这个类定义了联系人标签的数据结构。
+import com.xcs.wx.domain.vo.ContactLabelVO; // 导入ContactLabelVO类，这个类定义了联系人标签视图对象的数据结构。
+import org.mapstruct.Mapper; // 导入MapStruct的@Mapper注解，用于定义映射接口。
 
-import java.util.List;
+import java.util.List; // 导入Java的List接口，用于返回列表类型的数据。
 
 /**
  * 联系人标签 Mapping
+ * 这个接口定义了联系人标签相关对象之间的转换映射。
  *
- * @author xcs
- * @date 2023年12月22日 15时00分
+ * @author xcs // 表示这个接口的作者。
+ * @date 2023年12月22日 15时00分 // 表示这个接口的创建日期和时间。
  **/
-@Mapper(componentModel = "spring")
-public interface ContactLabelMapping {
+@Mapper(componentModel = "spring") // 使用MapStruct的@Mapper注解，指定该接口为映射接口，并配置为Spring组件。
+public interface ContactLabelMapping { // 定义了一个名为ContactLabelMapping的接口，用于联系人标签对象之间的转换映射。
 
     /**
      * 参数转换
+     * 将一组ContactLabel对象转换为ContactLabelVO对象。
      *
-     * @param labels 标签
-     * @return MsgDTO
+     * @param labels 入参，待转换的ContactLabel对象列表。
+     * @return List<ContactLabelVO> 转换后的ContactLabel视图对象列表。
      */
-    List<ContactLabelVO> convert(List<ContactLabel> labels);
-}
+    List<ContactLabelVO> convert(List<ContactLabel> labels); // 定义了一个方法，将ContactLabel列表转换为ContactLabelVO列表。
+}