注释

README.md

@@ -135,39 +135,7 @@ 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,6 +3,8 @@ 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;
@@ -10,36 +12,35 @@ import java.net.UnknownHostException;
 import java.util.Date;
 
 /**
- * 主应用程序类，启动Spring Boot应用程序。
- *
- * @author xcs
- * @date 2023年12月21日 17时02分
- **/
-@SpringBootApplication // 声明这是一个Spring Boot应用程序
+ * 微信数据导出应用的主类。
+ * 这个类作为整个应用的启动类，负责初始化Spring应用上下文，并打印应用的启动信息。
+ */
+@SpringBootApplication // 指定这是一个Spring Boot应用
 @EnableTransactionManagement // 启用事务管理
 public class WxDumpApplication {
 
     /**
-     * 应用程序的入口点。
-     *
-     * @param args 命令行参数
-     * @throws UnknownHostException 当无法获取本地主机地址时抛出异常
+     * 应用的入口点。
+     * 这个方法是程序执行的起点，它启动Spring应用上下文，并计算启动时间。
+     * @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("╔════════════════════════════════════════════════════╗");
@@ -48,6 +49,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; // 导入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注解
+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;
 
 /**
  * 多微信数据源动态切换拦截
@@ -16,20 +16,14 @@ import org.springframework.stereotype.Component; // 导入Spring的Component注
  * @author xcs
  * @date 2024年6月27日14:29:32
  */
-@Slf4j // 使用lombok提供的日志注解
-@Aspect // 声明这是一个切面
-@Component // 声明这是一个Spring组件
+@Slf4j
+@Aspect
+@Component
 public class RepositoryAspect {
 
-    /**
-     * 环绕通知，用于在目标方法执行前后进行增强处理
-     * @param joinPoint 连接点，表示被拦截的方法
-     * @return 目标方法的返回值
-     * @throws Throwable 可能抛出的异常
-     */
-    @Around("execution(public * com.xcs.wx.repository..*.*(..))") // 指定切点表达式，拦截com.xcs.wx.repository包及其子包下所有类的所有方法
+    @Around("execution(public * 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();
@@ -37,16 +31,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,70 +1,60 @@
 package com.xcs.wx.config;
 
-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的全局异常处理注解
+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;
 
 /**
- * 全局异常处理配置类
- *
  * @author xcs
  * @date 2023年12月25日 17时29分
  **/
-@Slf4j // 使用lombok提供的日志注解
-@RestControllerAdvice // 声明这是一个全局异常处理的RestControllerAdvice
-@ResponseStatus(HttpStatus.OK) // 设置默认的响应状态码为OK
+@Slf4j
+@RestControllerAdvice
+@ResponseStatus(HttpStatus.OK)
 public class ExceptionAdviceConfig {
 
     /**
-     * 捕获并处理BizException异常
-     * @param e 抛出的BizException异常
-     * @return 自定义的响应VO对象
+     * 捕获BizException异常
      **/
-    @ExceptionHandler(BizException.class) // 指定这个方法处理BizException异常
+    @ExceptionHandler(BizException.class)
     public ResponseVO<String> handleException(BizException e) {
-        return ResponseVO.error(e.getCode(), e.getMsg()); // 返回异常的错误码和消息
+        return ResponseVO.error(e.getCode(), e.getMsg());
     }
 
     /**
-     * 捕获并处理MyBatisSystemException异常
-     * @param e 抛出的MyBatisSystemException异常
-     * @return 自定义的响应VO对象
+     * 捕获MyBatisSystemException异常
      **/
-    @ExceptionHandler(MyBatisSystemException.class) // 指定这个方法处理MyBatisSystemException异常
+    @ExceptionHandler(MyBatisSystemException.class)
     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异常
-     * @param e 抛出的RuntimeException异常
-     * @return 自定义的响应VO对象
+     * 捕获RuntimeException异常
      **/
-    @ExceptionHandler(RuntimeException.class) // 指定这个方法处理RuntimeException异常
+    @ExceptionHandler(RuntimeException.class)
     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异常
-     * @param e 抛出的Exception异常
-     * @return 自定义的响应VO对象
+     * 捕获Exception异常
      **/
-    @ExceptionHandler(Exception.class) // 指定这个方法处理Exception异常
+    @ExceptionHandler(Exception.class)
     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,30 +1,27 @@
 package com.xcs.wx.config;
 
-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的配置类注解
+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;
 
 /**
- * MyBatis-Plus配置类
- *
  * @author xcs
  * @date 2023年12月29日 16时10分
  **/
-@Configuration // 声明这是一个Spring配置类
-@MapperScan({"com.xcs.wx.mapper"}) // 指定MyBatis的Mapper接口所在包，Spring会自动扫描这个包下的Mapper接口
+@Configuration
+@MapperScan({"com.xcs.wx.mapper"})
 public class MybatisPlusConfig {
 
     /**
      * 添加分页插件
-     * @return 分页插件的Bean
      */
-    @Bean // 声明这是一个Spring Bean
+    @Bean
     public MybatisPlusInterceptor mybatisPlusInterceptor() {
-        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); // 创建MyBatis-Plus拦截器实例
-        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.SQLITE)); // 向拦截器添加分页插件，这里指定了数据库类型为SQLite
-        return interceptor; // 返回分页插件的Bean实例
+        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
+        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.SQLITE));
+        return interceptor;
     }
-}
+}

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

@@ -1,26 +1,20 @@
 package com.xcs.wx.config;
 
-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接口
+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;
 
 /**
- * 静态资源配置类
- *
  * @author xcs
  * @date 2024年01月26日 11时46分
  **/
-@Configuration // 声明这是一个Spring配置类
-@EnableWebMvc // 启用Web MVC功能，允许定义额外的mvc配置
-public class UseStaticResourceConfig implements WebMvcConfigurer { // 实现WebMvcConfigurer接口，自定义Web MVC配置
+@Configuration
+@EnableWebMvc
+public class UseStaticResourceConfig implements WebMvcConfigurer {
 
-    /**
-     * 添加资源处理器
-     * @param registry 资源处理器注册表
-     */
-    @Override // 覆盖WebMvcConfigurer接口的addResourceHandlers方法
+    @Override
     public void addResourceHandlers(ResourceHandlerRegistry registry) {
-        registry.addResourceHandler("/**").addResourceLocations("file:../html/"); // 添加资源处理器，匹配所有请求（"/**"），并指定资源位置为"file:../html/"，即项目外的html目录
+        registry.addResourceHandler("/**").addResourceLocations("file:../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; // 导入lombok提供的@Data注解，用于生成getter、setter等方法
-import org.springframework.boot.context.properties.ConfigurationProperties; // 导入Spring Boot的配置属性注解
-import org.springframework.context.annotation.Configuration; // 导入Spring的配置类注解
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
 
-import java.util.Map; // 导入Java的Map接口
+import java.util.Map;
 
 /**
- * 微信参数偏移量配置类
+ * 微信参数偏移量配置
  *
  * @author xcs
  * @date 2023年12月25日 10时05分
  **/
-@Data // 使用lombok提供的@Data注解，自动生成getter、setter等方法
-@Configuration(proxyBeanMethods = false) // 声明这是一个Spring配置类，不创建代理bean
-@ConfigurationProperties(prefix = "wechat-offset") // 声明这是一个配置属性类，配置属性的前缀为"wechat-offset"
+@Data
+@Configuration(proxyBeanMethods = false)
+@ConfigurationProperties(prefix = "wechat-offset")
 public class WeChatOffsetProperties {
 
     /**
      * 微信各个版本对应的偏移量配置
      */
-    private Map<String, VersionConfig> version; // 定义一个Map，键为版本号，值为VersionConfig对象，包含不同版本的偏移量配置
+    private Map<String, VersionConfig> version;
 
-    @Data // 使用lombok提供的@Data注解，自动生成getter、setter等方法
+    @Data
     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; // 定义包名为com.xcs.wx.constant，用于存放常量类
+package com.xcs.wx.constant;
 
 /**
  * 群聊枚举
@@ -9,10 +9,8 @@ package com.xcs.wx.constant; // 定义包名为com.xcs.wx.constant，用于存
 public class ChatRoomConstant {
 
     private ChatRoomConstant() {
-    } // 私有的构造函数，防止此类被实例化
+    }
 
-    /**
-     * 群聊标识后缀
-     */
-    public static final String CHATROOM_SUFFIX = "@chatroom"; // 定义一个公共静态最终字符串常量，值为"@chatroom"，用于标识群聊
-}
+    public static final String CHATROOM_SUFFIX = "@chatroom";
+
+}

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

@@ -1,15 +1,15 @@
-package com.xcs.wx.constant; // 定义包名为com.xcs.wx.constant，用于存放常量类
+package com.xcs.wx.constant;
 
-import cn.hutool.extra.spring.SpringUtil; // 导入hutool工具类，用于Spring Bean操作
-import com.baomidou.dynamic.datasource.DynamicRoutingDataSource; // 导入MyBatis动态数据源类
-import com.xcs.wx.service.UserService; // 导入UserService接口
+import cn.hutool.extra.spring.SpringUtil;
+import com.baomidou.dynamic.datasource.DynamicRoutingDataSource;
+import com.xcs.wx.service.UserService;
 
-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工具类
+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;
 
 /**
  * 数据源类型枚举
@@ -19,31 +19,62 @@ import java.util.stream.Collectors; // 导入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(); // 获取当前用户的微信ID
+        String wxId = SpringUtil.getBean(UserService.class).currentUser();
         // 空校验
         if (wxId == null) {
-            return Collections.emptyList(); // 如果微信ID为空，返回空列表
+            return Collections.emptyList();
         }
-        return getDb(wxId + "#" + "MSG.*\\.db"); // 调用getDb方法，传入匹配模式
+        return getDb(wxId + "#" + "MSG.*\\.db");
     }
 
     /**
      * 根据pattern匹配数据库
-     * @param pattern 需要匹配的字符串模式
-     * @return 数据库名称列表
+     *
+     * @param pattern 需要匹配的字符串
+     * @return 数据库名称
      */
     private static List<String> getDb(String pattern) {
         // 获取动态数据源
@@ -53,8 +84,8 @@ public class DataSourceType {
 
         // 筛选出符合模式的数据源键，并进行降序排序
         return dataSources.keySet().stream()
-                .filter(key -> key.matches(pattern)) // 筛选出匹配给定模式的数据源键
-                .sorted(Comparator.naturalOrder()) // 按照自然顺序排序
-                .collect(Collectors.toList()); // 收集为List
+                .filter(key -> key.matches(pattern))
+                .sorted(Comparator.naturalOrder())
+                .collect(Collectors.toList());
     }
-}
+}

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

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

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; // 导入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 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 java.util.List; // 导入List接口
+import java.util.List;
 
 /**
  * 群聊 Controller
@@ -20,24 +20,24 @@ import java.util.List; // 导入List接口
  * @author xcs
  * @date 2024年01月08日 16时03分
  **/
-@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
-@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
-@RequestMapping("/api/chatroom") // 定义类级别的请求映射，所有方法的URL都会以/api/chatroom开头
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/chatroom")
 public class ChatRoomController {
 
-    private final ChatRoomService chatRoomService; // 注入ChatRoomService，用于业务逻辑处理
+    private final ChatRoomService chatRoomService;
 
     /**
      * 查询群聊列表
      *
      * @param chatRoomDTO 查询参数
-     * @return ChatRoomVO列表的响应对象
+     * @return ChatRoomVO
      */
-    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/chatroom/list
+    @GetMapping("/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,22 +45,20 @@ public class ChatRoomController {
      * 查询群聊详情
      *
      * @param chatRoomName 群聊名称
-     * @return ChatRoomDetailVO的响应对象
+     * @return ChatRoomDetailVO
      */
-    @GetMapping("/detail") // 定义GET请求的映射，访问路径为/api/chatroom/detail
+    @GetMapping("/detail")
     public ResponseVO<ChatRoomDetailVO> detail(@RequestParam String chatRoomName) {
-        // 调用chatRoomService的方法查询群聊详情，并返回响应对象
         return ResponseVO.ok(chatRoomService.queryChatRoomDetail(chatRoomName));
     }
 
     /**
      * 导出群聊
      *
-     * @return ResponseVO的响应对象
+     * @return ResponseVO
      */
-    @GetMapping("/export") // 定义GET请求的映射，访问路径为/api/chatroom/export
+    @GetMapping("/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.*; // 导入所有联系人相关的视图对象（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 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 java.util.List; // 导入List接口
+import java.util.List;
 
 /**
  * 联系人 Controller
@@ -16,12 +16,12 @@ import java.util.List; // 导入List接口
  * @author xcs
  * @date 2023年12月22日 14时16分
  **/
-@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
-@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
-@RequestMapping("/api/contact") // 定义类级别的请求映射，所有方法的URL都会以/api/contact开头
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/contact")
 public class ContactController {
 
-    private final ContactService contactService; // 注入ContactService，用于业务逻辑处理
+    private final ContactService contactService;
 
     /**
      * 查询联系人
@@ -29,11 +29,11 @@ public class ContactController {
      * @param contactDTO 请求参数
      * @return ResponseVO
      */
-    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/contact/list
+    @GetMapping("/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,9 +42,8 @@ public class ContactController {
      *
      * @return ResponseVO
      */
-    @GetMapping("/all") // 定义GET请求的映射，访问路径为/api/contact/all
+    @GetMapping("/all")
     public ResponseVO<List<AllContactVO>> all() {
-        // 调用contactService的方法查询所有联系人
         return ResponseVO.ok(contactService.queryAllContact());
     }
 
@@ -53,9 +52,8 @@ public class ContactController {
      *
      * @return ContactLabelVO
      */
-    @GetMapping("/label") // 定义GET请求的映射，访问路径为/api/contact/label
+    @GetMapping("/label")
     public ResponseVO<List<ContactLabelVO>> label() {
-        // 调用contactService的方法查询联系人标签
         return ResponseVO.ok(contactService.queryContactLabel());
     }
 
@@ -64,9 +62,8 @@ public class ContactController {
      *
      * @return ResponseVO
      */
-    @GetMapping("/export") // 定义GET请求的映射，访问路径为/api/contact/export
+    @GetMapping("/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; // 导入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 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 javax.servlet.http.HttpServletResponse; // 导入HttpServletResponse类，用于操作HTTP响应
-import java.io.IOException; // 导入IOException类，用于处理可能的I/O异常
-import java.io.OutputStream; // 导入OutputStream类，用于输出流
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.OutputStream;
 
 /**
  * 联系人头像 Controller
@@ -17,13 +17,13 @@ import java.io.OutputStream; // 导入OutputStream类，用于输出流
  * @author xcs
  * @date 2024年6月18日15:45:17
  **/
-@Slf4j // 使用Lombok注解自动生成日志对象
-@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式或相应内容
-@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
-@RequestMapping("/api/contact/headImg") // 定义类级别的请求映射，所有方法的URL都会以/api/contact/headImg开头
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/contact/headImg")
 public class ContactHeadImgController {
 
-    private final ContactHeadImgService contactHeadImgService; // 注入ContactHeadImgService，用于业务逻辑处理
+    private final ContactHeadImgService contactHeadImgService;
 
     /**
      * 用户头像
@@ -31,20 +31,20 @@ public class ContactHeadImgController {
      * @param userName 用户名
      * @param response HttpServletResponse
      */
-    @GetMapping("/avatar") // 定义GET请求的映射，访问路径为/api/contact/headImg/avatar
+    @GetMapping("/avatar")
     public void avatar(String userName, HttpServletResponse response) {
-        byte[] avatarBytes = contactHeadImgService.avatar(userName); // 调用contactHeadImgService的方法获取用户头像的字节数据
+        byte[] avatarBytes = contactHeadImgService.avatar(userName);
         if (avatarBytes != null) {
-            response.setContentType("image/gif"); // 设置响应的内容类型为image/gif
-            response.setContentLength(avatarBytes.length); // 设置响应的内容长度
-            try (OutputStream os = response.getOutputStream()) { // 获取响应的输出流
-                os.write(avatarBytes); // 将头像字节数据写入输出流
-                os.flush(); // 刷新输出流，确保数据被写出
+            response.setContentType("image/gif");
+            response.setContentLength(avatarBytes.length);
+            try (OutputStream os = response.getOutputStream()) {
+                os.write(avatarBytes);
+                os.flush();
             } catch (IOException e) {
-                log.error("avatar fail", e); // 如果发生I/O异常，记录错误日志
+                log.error("avatar fail", e);
             }
         } else {
-            response.setStatus(HttpServletResponse.SC_NOT_FOUND); // 如果头像字节数据为空，设置HTTP响应状态为404未找到
+            response.setStatus(HttpServletResponse.SC_NOT_FOUND);
         }
     }
-}
+}

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

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; // 导入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 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 java.io.IOException; // 导入IOException类，用于处理可能的I/O异常
-import java.util.List; // 导入List接口
+import java.io.IOException;
+import java.util.List;
 
 /**
  * 数据库 Controller
@@ -21,47 +21,47 @@ import java.util.List; // 导入List接口
  * @author xcs
  * @date 2024年01月20日 14时35分
  **/
-@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
-@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
-@RequestMapping("/api/database") // 定义类级别的请求映射，所有方法的URL都会以/api/database开头
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/database")
 public class DatabaseController {
 
-    private final DatabaseService databaseService; // 注入DatabaseService，用于业务逻辑处理
+    private final DatabaseService databaseService;
 
     /**
      * 数据库解密
      *
      * @return ResponseVO
      */
-    @GetMapping("/decrypt") // 定义GET请求的映射，访问路径为/api/database/decrypt
+    @GetMapping("/decrypt")
     public SseEmitter decrypt(DecryptDTO decryptDTO) {
-        SseEmitter emitter = new SseEmitter(0L); // 创建一个SseEmitter对象，用于服务器发送事件
+        SseEmitter emitter = new SseEmitter(0L);
         // 启动一个子线程，异步回调给前端
         new Thread(() -> {
             // 读取JDK版本号
-            if (SystemUtil.getJavaInfo().getVersionInt() < 1100) { // 如果JDK版本低于11
+            if (SystemUtil.getJavaInfo().getVersionInt() < 1100) {
                 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); // 如果发生I/O异常，抛出运行时异常
+                    throw new RuntimeException(e);
                 } finally {
-                    emitter.complete(); // 标记SseEmitter为完成状态
+                    emitter.complete();
                 }
-                return; // 返回，不再执行后续代码
+                return;
             }
-            databaseService.decrypt(emitter, decryptDTO); // 调用databaseService的方法进行解密操作
-        }).start(); // 启动线程
-        // 返回SseEmitter对象
+            databaseService.decrypt(emitter, decryptDTO);
+        }).start();
+        // 返回数据
         return emitter;
     }
 
     /**
-     * 获取数据库信息
+     * 数据库解密
      *
      * @return ResponseVO
      */
-    @GetMapping("/getDatabase") // 定义GET请求的映射，访问路径为/api/database/getDatabase
+    @GetMapping("/getDatabase")
     public ResponseVO<List<DatabaseVO>> decrypt(String wxId) {
-        return ResponseVO.ok(databaseService.getDatabase(wxId)); // 调用databaseService的方法获取数据库信息，并返回响应对象
+        return ResponseVO.ok(databaseService.getDatabase(wxId));
     }
-}
+}

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; // 导入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 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 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对象
+import java.io.IOException;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 
 /**
  * 导出 Controller
@@ -23,30 +23,30 @@ import java.nio.file.Paths; // 导入Paths工具类，用于创建Path对象
  * @author xcs
  * @date 2024年01月05日 15时56分
  **/
-@Controller // 定义一个控制器，用于处理HTTP请求
-@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
-@RequestMapping("/api/export") // 定义类级别的请求映射，所有方法的URL都会以/api/export开头
+@Controller
+@RequiredArgsConstructor
+@RequestMapping("/api/export")
 public class ExportController {
 
     /**
      * 下载文件
      */
-    @GetMapping("download") // 定义GET请求的映射，访问路径为/api/export/download
+    @GetMapping("download")
     public ResponseEntity<Resource> download(@RequestParam String path) throws IOException {
-        Path filePath = Paths.get(path); // 根据传入的路径参数创建Path对象
-        Resource resource = new FileSystemResource(filePath.toFile()); // 创建FileSystemResource对象，用于访问文件系统资源
+        Path filePath = Paths.get(path);
+        Resource resource = new FileSystemResource(filePath.toFile());
 
         // 处理文件不存在的情况
-        if (!resource.exists()) { // 如果资源不存在
-            return ResponseEntity.notFound().build(); // 返回404未找到的响应实体
+        if (!resource.exists()) {
+            return ResponseEntity.notFound().build();
         }
 
-        String encodedFilename = URLEncoder.encode(resource.getFilename(), StandardCharsets.UTF_8.name()).replace("+", "%20"); // 对文件名进行URL编码，并替换空格为%20
-        String contentDisposition = "attachment; filename*=UTF-8''" + encodedFilename; // 构建Content-Disposition响应头，设置文件名和编码
+        String encodedFilename = URLEncoder.encode(resource.getFilename(), StandardCharsets.UTF_8.name()).replace("+", "%20");
+        String contentDisposition = "attachment; filename*=UTF-8''" + encodedFilename;
 
-        return ResponseEntity.ok() // 构建200成功的响应实体
-                .contentType(MediaType.parseMediaType("application/vnd.ms-excel")) // 设置响应的内容类型为Excel
-                .header("Content-Disposition", contentDisposition) // 设置Content-Disposition响应头
-                .body(resource); // 设置响应体为资源对象
+        return ResponseEntity.ok()
+                .contentType(MediaType.parseMediaType("application/vnd.ms-excel"))
+                .header("Content-Disposition", contentDisposition)
+                .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; // 导入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 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 java.util.List; // 导入List接口，用于处理列表数据
+import java.util.List;
 
 /**
- * 朋友圈 Controller
+ * 朋友圈  Controller
  *
  * @author xcs
  * @date 2024年01月04日 13时48分
  **/
-@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
-@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
-@RequestMapping("/api/feeds") // 定义类级别的请求映射，所有方法的URL都会以/api/feeds开头
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/feeds")
 public class FeedsController {
 
-    private final FeedsService feedsService; // 注入FeedsService，用于业务逻辑处理
+    private final FeedsService feedsService;
 
     /**
      * 查询朋友圈
@@ -31,11 +31,11 @@ public class FeedsController {
      * @param feedsDTO 请求参数
      * @return FeedsVO
      */
-    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/feeds/list
+    @GetMapping("/list")
     public ResponseVO<List<FeedsVO>> list(FeedsDTO feedsDTO) {
         // 查询朋友圈
-        PageVO<FeedsVO> pageVO = feedsService.queryFeeds(feedsDTO); // 调用feedsService的方法查询朋友圈数据，并返回分页视图对象
+        PageVO<FeedsVO> pageVO = feedsService.queryFeeds(feedsDTO);
         // 返回数据
-        return ResponseVO.ok(pageVO.getRecords(), pageVO.getCurrent(), pageVO.getTotal()); // 使用ResponseVO构建响应对象，包含记录列表、当前页码和总记录数
+        return ResponseVO.ok(pageVO.getRecords(), pageVO.getCurrent(), pageVO.getTotal());
     }
-}
+}

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

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

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

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; // 导入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 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 java.util.List; // 导入List接口，用于处理列表数据
+import java.util.List;
 
 /**
  * 消息 Controller
@@ -17,23 +17,22 @@ import java.util.List; // 导入List接口，用于处理列表数据
  * @author xcs
  * @date 2023年12月25日 17时06分
  **/
-@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
-@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
-@RequestMapping("/api/msg") // 定义类级别的请求映射，所有方法的URL都会以/api/msg开头
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/msg")
 public class MsgController {
 
-    private final MsgService msgService; // 注入MsgService，用于业务逻辑处理
+    private final MsgService msgService;
 
     /**
      * 查询消息
      *
-     * @param talker       对话者
+     * @param talker       对话着
      * @param nextSequence 下一个序列号
      * @return ResponseVO
      */
-    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/msg/list
+    @GetMapping("/list")
     public ResponseVO<List<MsgVO>> list(@RequestParam String talker, @RequestParam Long nextSequence) {
-        // 调用msgService的方法查询消息，并返回响应对象
         return ResponseVO.ok(msgService.queryMsg(talker, nextSequence));
     }
 
@@ -42,9 +41,8 @@ public class MsgController {
      *
      * @return ResponseVO
      */
-    @GetMapping("/export") // 定义GET请求的映射，访问路径为/api/msg/export
+    @GetMapping("/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,49 +1,48 @@
-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; // 导入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 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 java.util.List; // 导入List接口，用于处理列表数据
+import java.util.List;
 
 /**
- * 找回联系人 Controller
+ * 找回联系人  Controller
  *
  * @author xcs
  * @date 2024年01月04日 13时48分
  **/
-@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
-@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
-@RequestMapping("/api/recover/contact") // 定义类级别的请求映射，所有方法的URL都会以/api/recover/contact开头
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/recover/contact")
 public class RecoverContactController {
 
-    private final RecoverContactService recoverContactService; // 注入RecoverContactService，用于业务逻辑处理
+    private final RecoverContactService recoverContactService;
 
     /**
-     * 查询找回联系人
+     * 查询朋友圈
      *
      * @param recoverContactDTO 请求参数
-     * @return ResponseVO
+     * @return FeedsVO
      */
-    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/recover/contact/list
+    @GetMapping("/list")
     public ResponseVO<List<RecoverContactVO>> list(RecoverContactDTO recoverContactDTO) {
-        // 调用recoverContactService的方法查询找回联系人，并返回响应对象
+        // 返回数据
         return ResponseVO.ok(recoverContactService.queryRecoverContact(recoverContactDTO));
     }
 
     /**
-     * 导出找回联系人
+     * 导出联系人
      *
      * @return ResponseVO
      */
-    @GetMapping("/export") // 定义GET请求的映射，访问路径为/api/recover/contact/export
+    @GetMapping("/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; // 导入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 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 java.util.List; // 导入List接口，用于处理列表数据
+import java.util.List;
 
 /**
  * 会话 Controller
@@ -16,21 +16,20 @@ import java.util.List; // 导入List接口，用于处理列表数据
  * @author xcs
  * @date 2023年12月21日 17时38分
  **/
-@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
-@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
-@RequestMapping("/api/session") // 定义类级别的请求映射，所有方法的URL都会以/api/session开头
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/session")
 public class SessionController {
 
-    private final SessionService sessionService; // 注入SessionService，用于业务逻辑处理
+    private final SessionService sessionService;
 
     /**
      * 查询会话列表
      *
-     * @return 会话列表的响应对象
+     * @return SessionVO
      */
-    @GetMapping("/list") // 定义GET请求的映射，访问路径为/api/session/list
+    @GetMapping("/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,18 +1,19 @@
-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; // 导入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 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 java.util.List; // 导入List接口，用于处理列表数据
 
 /**
  * UserController
@@ -20,62 +21,62 @@ import java.util.List; // 导入List接口，用于处理列表数据
  * @author xcs
  * @date 2024年6月15日16:05:49
  */
-@RestController // 定义一个REST风格的控制器，返回的数据会自动转换为JSON格式
-@RequiredArgsConstructor // 使用Lombok注解自动生成包含所有final字段的构造函数
-@RequestMapping("/api/user") // 定义类级别的请求映射，所有方法的URL都会以/api/user开头
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/user")
 public class UserController {
 
-    private final UserService userService; // 注入UserService，用于用户相关的业务逻辑处理
-    private final WeChatService weChatService; // 注入WeChatService，用于微信相关的业务逻辑处理
+    private final UserService userService;
+    private final WeChatService weChatService;
 
     /**
      * 查询微信信息
      *
      * @return ResponseVO
      */
-    @GetMapping("/readWeChatConfig") // 定义GET请求的映射，访问路径为/api/user/readWeChatConfig
+    @GetMapping("/readWeChatConfig")
     public ResponseVO<List<WeChatConfigVO>> readWeChatConfig() {
-        return ResponseVO.ok(weChatService.readWeChatConfig()); // 调用weChatService的方法读取微信配置，并返回响应对象
+        return ResponseVO.ok(weChatService.readWeChatConfig());
     }
 
     /**
-     * 查询用户信息
+     * 用户头像
      *
      * @return ResponseVO
      */
-    @GetMapping("/userInfo") // 定义GET请求的映射，访问路径为/api/user/userInfo
+    @GetMapping("/userInfo")
     public ResponseVO<UserInfoVO> userInfo() {
-        return ResponseVO.ok(userService.userInfo()); // 调用userService的方法获取用户信息，并返回响应对象
+        return ResponseVO.ok(userService.userInfo());
     }
 
     /**
-     * 获取用户头像
+     * 用户头像
      *
      * @return ResponseVO
      */
-    @GetMapping("/avatar") // 定义GET请求的映射，访问路径为/api/user/avatar
+    @GetMapping("/avatar")
     public ResponseVO<String> avatar() {
-        return ResponseVO.ok(userService.avatar()); // 调用userService的方法获取用户头像，并返回响应对象
+        return ResponseVO.ok(userService.avatar());
     }
 
     /**
-     * 获取用户昵称
+     * 用户昵称
      *
      * @return ResponseVO
      */
-    @GetMapping("/nickname") // 定义GET请求的映射，访问路径为/api/user/nickname
+    @GetMapping("/nickname")
     public ResponseVO<String> nickname() {
-        return ResponseVO.ok(userService.nickname()); // 调用userService的方法获取用户昵称，并返回响应对象
+        return ResponseVO.ok(userService.nickname());
     }
 
     /**
-     * 获取所有用户
+     * 所有用户
      *
      * @return ResponseVO
      */
-    @GetMapping("/users") // 定义GET请求的映射，访问路径为/api/user/users
+    @GetMapping("/users")
     public ResponseVO<List<UserVO>> users() {
-        return ResponseVO.ok(userService.users()); // 调用userService的方法获取所有用户，并返回响应对象
+        return ResponseVO.ok(userService.users());
     }
 
     /**
@@ -84,9 +85,9 @@ public class UserController {
      * @param wxId wxId
      * @return ResponseVO
      */
-    @PutMapping("/switchUser") // 定义PUT请求的映射，访问路径为/api/user/switchUser
+    @PutMapping("/switchUser")
     public ResponseVO<String> switchUser(String wxId) {
-        userService.switchUser(wxId); // 调用userService的方法切换用户
-        return ResponseVO.ok("切换成功"); // 返回操作成功的响应对象
+        userService.switchUser(wxId);
+        return ResponseVO.ok("切换成功");
     }
-}
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,45 +1,41 @@
-package com.xcs.wx.domain; // 定义了这个类的包名，表示这个类属于com.xcs.wx.domain包。
+package com.xcs.wx.domain;
 
-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方法。
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
 
 /**
  * SQLite 数据库中的一个系统表
- * 这个类表示SQLite数据库中的系统表sqlite_master的数据结构。
  *
- * @author xcs // 表示这个类的作者。
- * @date 2024年6月13日09:18:29 // 表示这个类的创建日期和时间。
+ * @author xcs
+ * @date 2024年6月13日09:18:29
  */
-@Data // 使用Lombok的@Data注解，自动为类的字段生成getter和setter方法。
-@TableName("sqlite_master") // 使用MyBatis Plus的@TableName注解，指定这个实体类对应的数据库表名为"sqlite_master"。
-public class SqliteMaster { // 定义了一个名为SqliteMaster的类，用于表示SQLite数据库中的系统表sqlite_master的数据结构。
+@Data
+@TableName("sqlite_master")
+public class SqliteMaster {
 
     /**
      * type
-     * 表示表的类型。
      */
-    @TableField("type") // 使用@TableField注解指定这个字段映射到数据库中的"type"列。
-    private String type; // 定义了一个名为type的私有成员变量，类型为String，表示表的类型。
+    @TableField("type")
+    private String type;
 
     /**
      * tblName
-     * 表示表的名称。
      */
-    @TableField("tbl_name") // 使用@TableField注解指定这个字段映射到数据库中的"tbl_name"列。
-    private String tblName; // 定义了一个名为tblName的私有成员变量，类型为String，表示表的名称。
+    @TableField("tbl_name")
+    private String tblName;
 
     /**
      * rootPage
-     * 表示表的根页面。
      */
-    @TableField("rootpage") // 使用@TableField注解指定这个字段映射到数据库中的"rootpage"列。
-    private String rootPage; // 定义了一个名为rootPage的私有成员变量，类型为String，表示表的根页面。
+    @TableField("rootpage")
+    private String rootPage;
 
     /**
      * sql
-     * 表示创建表的SQL语句。
      */
-    @TableField("sql") // 使用@TableField注解指定这个字段映射到数据库中的"sql"列。
-    private String sql; // 定义了一个名为sql的私有成员变量，类型为String，表示创建表的SQL语句。
-}
+    @TableField("sql")
+    private 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; // 定义了BO（Business Object）所在的包名
+package com.xcs.wx.domain.bo;
 
-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等方法
+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;
 
 /**
  * CompressContentBO
@@ -11,100 +11,96 @@ import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、
  * @author xcs
  * @date 2024年01月16日 14时59分
  **/
-@Data // 使用Lombok注解自动生成getter、setter等方法
-@JsonIgnoreProperties(ignoreUnknown = true) // 指定Jackson忽略未知属性
-@JacksonXmlRootElement(localName = "msg") // 指定XML的根元素名称为"msg"
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+@JacksonXmlRootElement(localName = "msg")
 public class CompressContentBO {
 
-    @JacksonXmlProperty(localName = "appmsg") // 指定XML属性名称为"appmsg"
-    private AppMsg appMsg; // 成员变量，用于存储AppMsg对象
+    @JacksonXmlProperty(localName = "appmsg")
+    private AppMsg appMsg;
 
-    @JacksonXmlProperty(localName = "fromusername") // 指定XML属性名称为"fromusername"
-    private String fromUsername; // 成员变量，用于存储发送者用户名
+    @JacksonXmlProperty(localName = "fromusername")
+    private String fromUsername;
 
-    @JacksonXmlProperty(localName = "scene") // 指定XML属性名称为"scene"
-    private int scene; // 成员变量，用于存储场景值
+    @JacksonXmlProperty(localName = "scene")
+    private int scene;
 
-    @JacksonXmlProperty(localName = "appinfo") // 指定XML属性名称为"appinfo"
-    private AppInfo appInfo; // 成员变量，用于存储AppInfo对象
+    @JacksonXmlProperty(localName = "appinfo")
+    private AppInfo appInfo;
 
-    @JacksonXmlProperty(localName = "titile") // 指定XML属性名称为"titile"（注意：这里可能是拼写错误，通常应为"title"）
-    private String titile; // 成员变量，用于存储标题
+    @JacksonXmlProperty(localName = "titile")
+    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; // 成员变量，用于存储服务器ID
+            private long svrId;
 
             @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; // 成员变量，用于存储微信小程序图标URL
+            private String weAppIconUrl;
 
             @JacksonXmlProperty(localName = "weapppagethumbrawurl")
-            private String weAppPageThumbRawUrl; // 成员变量，用于存储微信小程序页面缩略图原始URL
+            private String weAppPageThumbRawUrl;
         }
     }
 
-    // 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; // 定义了BO（Business Object）所在的包名
+package com.xcs.wx.domain.bo;
 
-import lombok.AllArgsConstructor; // 导入Lombok提供的注解，用于自动生成全参数的构造函数
-import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import lombok.AllArgsConstructor;
+import lombok.Data;
 
 /**
  * DecryptBO
@@ -9,17 +9,17 @@ import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、
  * @author xcs
  * @date 2023年12月10日20:21:02
  */
-@Data // 使用Lombok注解自动生成getter、setter等方法
-@AllArgsConstructor // 使用Lombok注解自动生成包含所有字段的构造函数
+@Data
+@AllArgsConstructor
 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,173 +1,169 @@
-package com.xcs.wx.domain.bo; // 定义了BO（Business Object）所在的包名
+package com.xcs.wx.domain.bo;
 
-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等方法
+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;
 
 /**
- * MsgBO 类用于表示消息业务对象，并包含了XML映射的注解。
- *
  * @author xcs
  * @date 2024年01月16日 14时59分
  **/
-@Data // 使用Lombok注解自动生成getter、setter等方法
-@JsonIgnoreProperties(ignoreUnknown = true) // 指定Jackson忽略未知属性
-@JacksonXmlRootElement(localName = "msg") // 指定XML的根元素名称为"msg"
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+@JacksonXmlRootElement(localName = "msg")
 public class MsgBO {
 
-    @JacksonXmlProperty(localName = "img") // 指定XML属性名称为"img"
-    public Img img; // 成员变量，用于存储图片信息
+    @JacksonXmlProperty(localName = "img")
+    public Img img;
 
-    @JacksonXmlProperty(localName = "emoji") // 指定XML属性名称为"emoji"
-    private Emoji emoji; // 成员变量，用于存储表情信息
+    @JacksonXmlProperty(localName = "emoji")
+    private Emoji emoji;
 
-    // Img内部类的开始，用于存储图片信息
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class Img {
-        @JacksonXmlProperty(isAttribute = true, localName = "aeskey") // 指定XML属性，且为true表示这是一个属性节点
-        public String aesKey; // 图片的aes加密key
+        @JacksonXmlProperty(isAttribute = true, localName = "aeskey")
+        public String aesKey;
 
         @JacksonXmlProperty(isAttribute = true, localName = "encryver")
-        public String encryVer; // 加密版本
+        public String encryVer;
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnthumbaeskey")
-        public String cdnThumbAesKey; // 缩略图的aes加密key
+        public String cdnThumbAesKey;
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnthumburl")
-        public String cdnThumbUrl; // 缩略图URL
+        public String cdnThumbUrl;
 
         @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; // 中等尺寸图片URL
+        public String cdnMidImgUrl;
 
         @JacksonXmlProperty(isAttribute = true, localName = "length")
-        public int length; // 图片长度
+        public int length;
 
         @JacksonXmlProperty(isAttribute = true, localName = "md5")
-        public String md5; // 图片MD5值
+        public String md5;
 
         @JacksonXmlProperty(isAttribute = true, localName = "hevc_mid_size")
-        public int hevcMidSize; // HEVC编码中等尺寸大小
+        public int hevcMidSize;
 
         @JacksonXmlProperty(isAttribute = true, localName = "originsourcemd5")
-        public String originSourceMd5; // 原始来源MD5值
+        public String originSourceMd5;
     }
 
-    // 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; // 表情ID缓冲区
+        private String idBuffer;
 
         @JacksonXmlProperty(isAttribute = true, localName = "md5")
-        private String md5; // 表情MD5值
+        private String md5;
 
         @JacksonXmlProperty(isAttribute = true, localName = "len")
-        private String len; // 表情长度
+        private String len;
 
         @JacksonXmlProperty(isAttribute = true, localName = "productid")
-        private String productId; // 产品ID
+        private String productId;
 
         @JacksonXmlProperty(isAttribute = true, localName = "androidmd5")
-        private String androidMd5; // Android平台表情MD5值
+        private String androidMd5;
 
         @JacksonXmlProperty(isAttribute = true, localName = "androidlen")
-        private String androidLen; // Android平台表情长度
+        private String androidLen;
 
         @JacksonXmlProperty(isAttribute = true, localName = "s60v3md5")
-        private String s60v3Md5; // S60v3平台表情MD5值
+        private String s60v3Md5;
 
         @JacksonXmlProperty(isAttribute = true, localName = "s60v3len")
-        private String s60v3Len; // S60v3平台表情长度
+        private String s60v3Len;
 
         @JacksonXmlProperty(isAttribute = true, localName = "s60v5md5")
-        private String s60v5Md5; // S60v5平台表情MD5值
+        private String s60v5Md5;
 
         @JacksonXmlProperty(isAttribute = true, localName = "s60v5len")
-        private String s60v5Len; // S60v5平台表情长度
+        private String s60v5Len;
 
         @JacksonXmlProperty(isAttribute = true, localName = "cdnurl")
-        private String cdnUrl; // CDN URL
+        private String cdnUrl;
 
         @JacksonXmlProperty(isAttribute = true, localName = "designerid")
-        private String designerId; // 设计师ID
+        private String designerId;
 
         @JacksonXmlProperty(isAttribute = true, localName = "thumburl")
-        private String thumbUrl; // 缩略图URL
+        private String thumbUrl;
 
         @JacksonXmlProperty(isAttribute = true, localName = "encrypturl")
-        private String encryptUrl; // 加密URL
+        private String encryptUrl;
 
         @JacksonXmlProperty(isAttribute = true, localName = "aeskey")
-        private String aesKey; // AES密钥
+        private String aesKey;
 
         @JacksonXmlProperty(isAttribute = true, localName = "externurl")
-        private String externUrl; // 外部URL
+        private String externUrl;
 
         @JacksonXmlProperty(isAttribute = true, localName = "externmd5")
-        private String externMd5; // 外部MD5值
+        private String externMd5;
 
         @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; // TP URL
+        private String tpUrl;
 
         @JacksonXmlProperty(isAttribute = true, localName = "tpauthkey")
-        private String tpAuthKey; // TP授权密钥
+        private String tpAuthKey;
 
         @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; // 镜头ID
+        private String lensId;
 
         @JacksonXmlProperty(isAttribute = true, localName = "emojiattr")
-        private String emojiAttr; // 表情属性
+        private String emojiAttr;
 
         @JacksonXmlProperty(isAttribute = true, localName = "linkid")
-        private String linkId; // 链接ID
+        private String linkId;
 
         @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,203 +1,223 @@
-package com.xcs.wx.domain.bo; // 定义了BO（Business Object）所在的包名
+package com.xcs.wx.domain.bo;
 
-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接口，用于处理列表数据
+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;
 
 /**
- * TimelineObjectBO 类用于表示时间线对象，并包含了XML映射的注解。
+ * TimelineObjectBO
  *
  * @author xcs
  * @date 2024年01月03日 17时47分
  **/
-@Data // 使用Lombok注解自动生成getter、setter等方法
-@JsonIgnoreProperties(ignoreUnknown = true) // 指定Jackson忽略未知属性
-@JacksonXmlRootElement(localName = "TimelineObject") // 指定XML的根元素名称为"TimelineObject"
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+@JacksonXmlRootElement(localName = "TimelineObject")
 public class TimelineObjectBO {
 
-    @JacksonXmlProperty(localName = "id") // 指定XML属性名称为"id"
-    private String id; // 成员变量，用于存储时间线对象的ID
+    @JacksonXmlProperty(localName = "id")
+    private String id;
 
-    @JacksonXmlProperty(localName = "username") // 指定XML属性名称为"username"
-    private String username; // 成员变量，用于存储用户名
+    @JacksonXmlProperty(localName = "username")
+    private String username;
 
-    @JacksonXmlProperty(localName = "createTime") // 指定XML属性名称为"createTime"
-    private Long createTime; // 成员变量，用于存储创建时间
+    @JacksonXmlProperty(localName = "createTime")
+    private Long createTime;
 
-    @JacksonXmlProperty(localName = "contentDesc") // 指定XML属性名称为"contentDesc"
-    private String contentDesc; // 成员变量，用于存储内容描述
+    @JacksonXmlProperty(localName = "contentDesc")
+    private String contentDesc;
 
-    @JacksonXmlProperty(localName = "contentDescShowType") // 指定XML属性名称为"contentDescShowType"
-    private String contentDescShowType; // 成员变量，用于存储内容描述展示类型
+    @JacksonXmlProperty(localName = "contentDescShowType")
+    private String contentDescShowType;
 
-    @JacksonXmlProperty(localName = "contentDescScene") // 指定XML属性名称为"contentDescScene"
-    private String contentDescScene; // 成员变量，用于存储内容描述场景
+    @JacksonXmlProperty(localName = "contentDescScene")
+    private String contentDescScene;
 
-    @JacksonXmlProperty(localName = "private") // 指定XML属性名称为"private"
-    private String asPrivate; // 成员变量，用于存储是否私有
+    @JacksonXmlProperty(localName = "private")
+    private String asPrivate;
 
-    @JacksonXmlProperty(localName = "sightFolded") // 指定XML属性名称为"sightFolded"
-    private String sightFolded; // 成员变量，用于存储是否折叠
+    @JacksonXmlProperty(localName = "sightFolded")
+    private String sightFolded;
 
-    @JacksonXmlProperty(localName = "showFlag") // 指定XML属性名称为"showFlag"
-    private String showFlag; // 成员变量，用于存储展示标志
+    @JacksonXmlProperty(localName = "showFlag")
+    private String showFlag;
 
-    @JacksonXmlProperty(localName = "appInfo") // 指定XML属性名称为"appInfo"
-    private AppInfo appInfo; // 成员变量，用于存储应用信息
+    @JacksonXmlProperty(localName = "appInfo")
+    private AppInfo appInfo;
 
-    @JacksonXmlProperty(localName = "sourceUserName") // 指定XML属性名称为"sourceUserName"
-    private String sourceUserName; // 成员变量，用于存储源用户名
+    @JacksonXmlProperty(localName = "sourceUserName")
+    private String sourceUserName;
 
-    @JacksonXmlProperty(localName = "sourceNickName") // 指定XML属性名称为"sourceNickName"
-    private String sourceNickName; // 成员变量，用于存储源昵称
+    @JacksonXmlProperty(localName = "sourceNickName")
+    private String sourceNickName;
 
-    @JacksonXmlProperty(localName = "statisticsData") // 指定XML属性名称为"statisticsData"
-    private String statisticsData; // 成员变量，用于存储统计数据
+    @JacksonXmlProperty(localName = "statisticsData")
+    private String statisticsData;
 
-    @JacksonXmlProperty(localName = "statExtStr") // 指定XML属性名称为"statExtStr"
-    private String statExtStr; // 成员变量，用于存储统计扩展字符串
+    @JacksonXmlProperty(localName = "statExtStr")
+    private String statExtStr;
 
-    @JacksonXmlProperty(localName = "ContentObject") // 指定XML属性名称为"ContentObject"
-    private ContentObject contentObject; // 成员变量，用于存储内容对象
+    @JacksonXmlProperty(localName = "ContentObject")
+    private ContentObject contentObject;
 
-    @JacksonXmlProperty(localName = "publicUserName") // 指定XML属性名称为"publicUserName"
-    private String publicUserName; // 成员变量，用于存储公开用户名
+    @JacksonXmlProperty(localName = "publicUserName")
+    private String publicUserName;
 
-    @JacksonXmlProperty(localName = "location") // 指定XML属性名称为"location"
-    private Location location; // 成员变量，用于存储位置信息
+    @JacksonXmlProperty(localName = "location")
+    private Location location;
 
-    @JacksonXmlProperty(localName = "streamvideo") // 指定XML属性名称为"streamvideo"
-    private StreamVideo streamVideo; // 成员变量，用于存储视频流信息
+    @JacksonXmlProperty(localName = "streamvideo")
+    private StreamVideo streamVideo;
 
-    // AppInfo内部类的开始，用于存储应用信息
+    /**
+     * AppInfo
+     */
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class AppInfo {
         @JacksonXmlProperty(localName = "id")
-        private String id; // 应用ID
+        private String 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; // 应用安装URL
+        private String installUrl;
 
         @JacksonXmlProperty(localName = "fromUrl")
-        private String fromUrl; // 应用来源URL
+        private String fromUrl;
 
         @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; // 内容URL
+        private String contentUrl;
 
         @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; // 媒体ID
+            private String 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; // URL信息
+            private 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; // URL类型
+            private int type;
 
             @JacksonXmlProperty(isAttribute = true)
-            private String md5; // URL的MD5值
+            private String md5;
 
             @JacksonXmlProperty(isAttribute = true)
-            private String videomd5; // 视频URL的MD5值
+            private String videomd5;
 
             @JacksonXmlText
-            private String value; // URL文本内容
+            private String value;
         }
 
-        // 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; // 兴趣点分类ID
+        private String poiClassifyId;
 
         @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; // 兴趣点分类类型
+        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;
 
-        @JacksonXmlProperty(isAttribute = true, local
+        @JacksonXmlProperty(localName = "streamvideothumburl")
+        private String streamVideoThumbUrl;
+
+        @JacksonXmlProperty(localName = "streamvideoweburl")
+        private String streamVideoWebUrl;
+    }
+}

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

@@ -1,45 +1,45 @@
-package com.xcs.wx.domain.bo; // 定义了BO（Business Object）所在的包名
+package com.xcs.wx.domain.bo;
 
-import lombok.Builder; // 导入Lombok提供的注解，用于自动生成builder模式的方法
-import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter、toString等方法
+import lombok.Builder;
+import lombok.Data;
 
 /**
- * UserBO 类用于表示用户业务对象。
+ * UserBO
  *
  * @author xcs
  * @date 2023年12月31日15:25:21
  */
-@Data // 使用Lombok注解自动生成getter、setter、toString、equalsAndHashCode等方法
-@Builder // 使用Lombok注解自动生成builder模式的代码
+@Data
+@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,32 +1,31 @@
-package com.xcs.wx.domain.bo; // 定义了BO（Business Object）所在的包名
+package com.xcs.wx.domain.bo;
 
-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等方法
+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;
 
 /**
- * VoipMsgBO 类用于表示VoIP消息业务对象，并包含了XML映射的注解。
+ * VoipMsgBO
  *
  * @author xcs
  * @date 2024年01月17日 15时15分
  **/
-@Data // 使用Lombok注解自动生成getter、setter等方法
-@JsonIgnoreProperties(ignoreUnknown = true) // 指定Jackson忽略未知属性
-@JacksonXmlRootElement(localName = "voipmsg") // 指定XML的根元素名称为"voipmsg"
+@Data
+@JsonIgnoreProperties(ignoreUnknown = true)
+@JacksonXmlRootElement(localName = "voipmsg")
 public class VoipMsgBO {
 
-    @JacksonXmlProperty(localName = "VoIPBubbleMsg") // 指定XML属性名称为"VoIPBubbleMsg"
-    private VoIPBubbleMsg voIPBubbleMsg; // 成员变量，用于存储VoIPBubbleMsg对象
+    @JacksonXmlProperty(localName = "VoIPBubbleMsg")
+    private VoIPBubbleMsg voIPBubbleMsg;
 
-    // VoIPBubbleMsg内部类的开始，用于存储VoIP消息内容
     @Data
     @JsonIgnoreProperties(ignoreUnknown = true)
     public static class VoIPBubbleMsg {
 
-        @JacksonXmlCData // 标记该字段的值为XML中的CData区域，用于避免XML解析时的特殊字符问题
-        @JacksonXmlProperty(localName = "msg") // 指定XML属性名称为"msg"
-        private String msg; // 成员变量，用于存储消息内容
+        @JacksonXmlCData
+        @JacksonXmlProperty(localName = "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; // 定义了DTO（Data Transfer Object）所在的包名
+package com.xcs.wx.domain.dto;
 
-import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
-import lombok.EqualsAndHashCode; // 导入Lombok提供的注解，用于自动生成equals和hashCode方法
+import lombok.Data;
+import lombok.EqualsAndHashCode;
 
 /**
- * ChatRoomDTO 类用于表示群聊数据传输对象。
+ * ChatRoomDTO
  *
  * @author xcs
  * @date 2024年01月08日 16时24分
  **/
-@Data // 使用Lombok注解自动生成getter、setter等方法
-@EqualsAndHashCode(callSuper = true) // 使用Lombok注解自动生成equals和hashCode方法，并调用父类的equals和hashCode
-public class ChatRoomDTO extends PageDTO { // ChatRoomDTO类继承自PageDTO类
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ChatRoomDTO extends 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; // 定义了DTO（Data Transfer Object）所在的包名
+package com.xcs.wx.domain.dto;
 
-import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
-import lombok.EqualsAndHashCode; // 导入Lombok提供的注解，用于自动生成equals和hashCode方法
+import lombok.Data;
+import lombok.EqualsAndHashCode;
 
 /**
- * ContactDTO 类用于表示联系人数据传输对象。
+ * ContactDTO
  *
  * @author xcs
  * @date 2023年12月31日15:25:21
- **/
-@Data // 使用Lombok注解自动生成getter、setter等方法
-@EqualsAndHashCode(callSuper = true) // 使用Lombok注解自动生成equals和hashCode方法，并调用父类的equals和hashCode
-public class ContactDTO extends PageDTO { // ContactDTO类继承自PageDTO类
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ContactDTO extends PageDTO {
 
     /**
      * 备注
      */
-    private String remark; // 成员变量，用于存储联系人的备注信息
+    private String remark;
 
     /**
      * 昵称
      */
-    private String nickName; // 成员变量，用于存储联系人的昵称
+    private String nickName;
 
     /**
      * 标签Id
      */
-    private String labels; // 成员变量，用于存储联系人的标签ID
+    private String labels;
 
     /**
      * 描述
      */
-    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; // 定义了DTO（Data Transfer Object）所在的包名
+package com.xcs.wx.domain.dto;
 
-import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import lombok.Data;
 
 /**
- * DecryptDTO 类用于表示解密操作相关的数据传输对象。
+ * DecryptDTO
  *
  * @author xcs
  * @date 2023年12月31日15:25:21
- **/
-@Data // 使用Lombok注解自动生成getter、setter等方法
+ */
+@Data
 public class DecryptDTO {
 
     /**
      * pid
      */
-    private int pid; // 成员变量，用于存储进程ID（可能是微信的进程ID）
+    private int pid;
 
     /**
      * 文件目录
      */
-    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; // 定义了DTO（Data Transfer Object）所在的包名
+package com.xcs.wx.domain.dto;
 
-import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
-import lombok.EqualsAndHashCode; // 导入Lombok提供的注解，用于自动生成equals和hashCode方法
+import lombok.Data;
+import lombok.EqualsAndHashCode;
 
 /**
- * FeedsDTO 类用于表示朋友圈数据传输对象。
+ * FeedsDTO
  *
  * @author xcs
  * @date 2024年01月03日 17时17分
  **/
-@Data // 使用Lombok注解自动生成getter、setter等方法
-@EqualsAndHashCode(callSuper = true) // 使用Lombok注解自动生成equals和hashCode方法，并调用父类的equals和hashCode
-public class FeedsDTO extends PageDTO { // FeedsDTO类继承自PageDTO类
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class FeedsDTO extends 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; // 定义了DTO（Data Transfer Object）所在的包名
+package com.xcs.wx.domain.dto;
 
-import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
+import lombok.Data;
 
 /**
- * PageDTO 类用于表示分页数据传输对象。
+ * PageDTO
  *
  * @author xcs
  * @date 2023年12月29日 15时58分
  **/
-@Data // 使用Lombok注解自动生成getter、setter等方法
+@Data
 public class PageDTO {
 
     /**
      * 当前页数
      */
-    private Long current; // 成员变量，用于存储当前的页码（页码从1开始）
+    private Long current;
 
     /**
      * 页数大小
      */
-    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; // 定义了DTO（Data Transfer Object）所在的包名
+package com.xcs.wx.domain.dto;
 
-import lombok.Data; // 导入Lombok提供的注解，用于自动生成getter、setter等方法
-import lombok.EqualsAndHashCode; // 导入Lombok提供的注解，用于自动生成equals和hashCode方法
+import lombok.Data;
+import lombok.EqualsAndHashCode;
 
 /**
- * RecoverContactDTO 类用于表示找回联系人的数据传输对象。
+ * RecoverContactDTO
  *
  * @author xcs
  * @date 2024年6月14日15:29:54
  **/
-@Data // 使用Lombok注解自动生成getter、setter等方法
-@EqualsAndHashCode(callSuper = true) // 使用Lombok注解自动生成equals和hashCode方法，并调用父类的equals和hashCode
-public class RecoverContactDTO extends PageDTO { // RecoverContactDTO类继承自PageDTO类
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class RecoverContactDTO extends 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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,121 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,33 @@
+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

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

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

@@ -1,16 +1,14 @@
-package com.xcs.wx.exception; // 定义了这个类的包名，表示这个类属于com.xcs.wx.exception包。
+package 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 { // 定义了一个名为BizException的类，继承自BaseException，用于表示业务异常。
+public class BizException extends BaseException {
 
-    // 构造函数，接收错误编码和错误消息作为参数。
-    public BizException(Integer code, String msg) { // 定义构造函数，接收两个参数：错误编码(code)和错误消息(msg)。
-        super(code, msg); // 调用父类BaseException的构造函数，传递错误编码和错误消息。
+    public BizException(Integer code, String msg) {
+        super(code, msg);
     }
-}
+}

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

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

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

@@ -1,46 +1,43 @@
-package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
+package com.xcs.wx.mapper;
 
-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接口，用于返回列表类型的数据。
+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;
 
 /**
  * 群聊 Mapper
- * 这个接口定义了与群聊相关的数据库操作。
  *
- * @author xcs // 表示这个接口的作者。
- * @date 2024年01月08日 15时55分 // 表示这个接口的创建日期和时间。
+ * @author xcs
+ * @date 2024年01月08日 15时55分
  **/
-public interface ChatRoomMapper extends BaseMapper<ChatRoom> { // 定义了一个名为ChatRoomMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为ChatRoom，表示这个Mapper接口是用于操作ChatRoom表的数据库操作。
+public interface ChatRoomMapper extends BaseMapper<ChatRoom> {
 
     /**
      * 查询群聊
-     * 该方法用于根据分页信息和查询条件查询群聊信息。
      *
-     * @param page 分页信息，包含查询的页码和每页的数量。
-     * @param chatRoomDTO 查询条件，包含过滤和排序的参数。
-     * @return ChatRoomVO 分页的群聊视图对象，包含群聊的详细信息。
+     * @param page        分页信息
+     * @param chatRoomDTO 查询条件
+     * @return ChatRoomVO
      */
-    Page<ChatRoomVO> queryChatRoom(Page<ChatRoomVO> page, @Param("chatRoomDTO") ChatRoomDTO chatRoomDTO); // 定义了一个名为queryChatRoom的方法，用于查询群聊信息。
+    Page<ChatRoomVO> queryChatRoom(Page<ChatRoomVO> page, @Param("chatRoomDTO") ChatRoomDTO chatRoomDTO);
 
     /**
      * 统计群聊数量
-     * 该方法用于统计群聊的总数。
      *
-     * @return 群聊总数。
+     * @return 群聊总数
      */
-    int countChatRoom(); // 定义了一个名为countChatRoom的方法，用于统计群聊数量。
+    int countChatRoom();
 
     /**
      * 导出群聊
-     * 该方法用于导出群聊信息。
      *
-     * @return ExportChatRoomVO 包含群聊导出信息的列表。
+     * @return ExportChatRoomVO
      */
-    List<ExportChatRoomVO> exportChatRoom(); // 定义了一个名为exportChatRoom的方法，用于导出群聊信息。
-}
+    List<ExportChatRoomVO> exportChatRoom();
+}

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

@@ -1,23 +1,21 @@
-package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
+package com.xcs.wx.mapper;
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
-import com.xcs.wx.domain.ContactHeadImg; // 导入ContactHeadImg实体类，这个类定义了联系人头像的数据结构。
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.xcs.wx.domain.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> { // 定义了一个名为ContactHeadImgMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为ContactHeadImg，表示这个Mapper接口是用于操作ContactHeadImg表的数据库操作。
+public interface ContactHeadImgMapper extends BaseMapper<ContactHeadImg> {
 
     /**
      * 根据用户名查询联系人头像
-     * 该方法用于根据提供的用户名查询对应的联系人头像信息。
      *
-     * @param usrName 用户名，作为查询条件。
-     * @return ContactHeadImg 查询到的联系人头像对象。
+     * @param usrName 用户名
+     * @return ContactHeadImg
      */
-    ContactHeadImg getContactHeadImg(String usrName); // 定义了一个名为getContactHeadImg的方法，用于根据用户名查询联系人头像。
-}
+    ContactHeadImg getContactHeadImg(String usrName);
+}

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

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

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

@@ -1,15 +1,13 @@
-package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
+package com.xcs.wx.mapper;
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
-import com.xcs.wx.domain.ContactLabel; // 导入ContactLabel实体类，这个类定义了联系人标签的数据结构。
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.xcs.wx.domain.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> { // 定义了一个名为ContactLabelMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为ContactLabel，表示这个Mapper接口是用于操作ContactLabel表的数据库操作。
-    // 该接口中没有定义额外的方法，因为BaseMapper已经提供了常用的CRUD操作方法。
-}
+public interface ContactLabelMapper extends BaseMapper<ContactLabel> {
+}

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

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

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

@@ -1,15 +1,14 @@
-package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
+package com.xcs.wx.mapper;
 
-import com.baomidou.mybatisplus.core.mapper.BaseMapper; // 导入MyBatis Plus框架的核心Mapper接口。
-import com.xcs.wx.domain.FTSContactContent; // 导入FTSContactContent实体类，这个类定义了全文搜索联系人内容的数据结构。
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.xcs.wx.domain.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> { // 定义了一个名为FTSContactContentMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为FTSContactContent，表示这个Mapper接口是用于操作FTSContactContent表的数据库操作。
-    // 该接口中没有定义额外的方法，因为BaseMapper已经提供了常用的CRUD操作方法。
-}
+public interface FTSContactContentMapper extends BaseMapper<FTSContactContent> {
+
+}

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

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

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

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

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

@@ -1,24 +1,22 @@
-package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
+package com.xcs.wx.mapper;
 
-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注解，用于指定方法参数的名称。
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.xcs.wx.domain.HardLinkImageAttribute;
+import org.apache.ibatis.annotations.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> { // 定义了一个名为HardLinkImageAttributeMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为HardLinkImageAttribute，表示这个Mapper接口是用于操作HardLinkImageAttribute表的数据库操作。
+public interface HardLinkImageAttributeMapper extends BaseMapper<HardLinkImageAttribute> {
 
     /**
      * 查询图片
-     * 该方法用于根据图片的MD5值查询图片链接。
      *
-     * @param md5 图片的MD5值。
-     * @return 返回查询到的图片链接。
+     * @param md5 md5
+     * @return 图片
      */
-    String queryHardLinkImage(@Param("md5") byte[] md5); // 定义了一个名为queryHardLinkImage的方法，用于根据MD5值查询图片链接。
-}
+    String queryHardLinkImage(@Param("md5") byte[] md5);
+}

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

@@ -1,24 +1,22 @@
-package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
+package com.xcs.wx.mapper;
 
-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注解，用于指定方法参数的名称。
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.xcs.wx.domain.HardLinkVideoAttribute;
+import org.apache.ibatis.annotations.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> { // 定义了一个名为HardLinkVideoAttributeMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为HardLinkVideoAttribute，表示这个Mapper接口是用于操作HardLinkVideoAttribute表的数据库操作。
+public interface HardLinkVideoAttributeMapper extends BaseMapper<HardLinkVideoAttribute> {
 
     /**
      * 查询视频
-     * 该方法用于根据视频的MD5值查询视频链接。
      *
-     * @param md5 视频的MD5值。
-     * @return 返回查询到的视频链接。
+     * @param md5 md5
+     * @return 视频
      */
-    String queryHardLinkVideo(@Param("md5") byte[] md5); // 定义了一个名为queryHardLinkVideo的方法，用于根据MD5值查询视频链接。
-}
+    String queryHardLinkVideo(@Param("md5") byte[] md5);
+}

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

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

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

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

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

@@ -1,19 +1,18 @@
-package com.xcs.wx.mapper; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapper包。
+package com.xcs.wx.mapper;
 
-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 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 java.util.List; // 导入Java的List接口，用于返回列表类型的数据。
+import java.util.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> { // 定义了一个名为SqliteMasterMapper的接口，继承自MyBatis Plus的BaseMapper接口，泛型参数为SqliteMaster，表示这个Mapper接口是用于操作SqliteMaster表的数据库操作。
-    // 该接口中没有定义额外的方法，因为BaseMapper已经提供了常用的CRUD操作方法。
+public interface SqliteMasterMapper extends BaseMapper<SqliteMaster> {
+
 }

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

@@ -1,86 +1,80 @@
-package com.xcs.wx.mapping; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapping包。
+package com.xcs.wx.mapping;
 
-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 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 java.util.List; // 导入Java的List接口，用于返回列表类型的数据。
-import java.util.Map; // 导入Java的Map接口，用于处理键值对数据。
-import java.util.stream.Collectors; // 导入Java的Collectors类，用于流操作的收集器。
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * 群聊 Mapping
- * 这个接口定义了群聊相关对象之间的转换映射。
  *
- * @author xcs // 表示这个接口的作者。
- * @date 2024年01月08日 17时00分 // 表示这个接口的创建日期和时间。
+ * @author xcs
+ * @date 2024年01月08日 17时00分
  **/
-@Mapper(componentModel = "spring") // 使用MapStruct的@Mapper注解，指定该接口为映射接口，并配置为Spring组件。
-public interface ChatRoomMapping { // 定义了一个名为ChatRoomMapping的接口，用于群聊对象之间的转换映射。
+@Mapper(componentModel = "spring")
+public interface ChatRoomMapping {
 
     /**
      * 参数转换
-     * 将一组ChatRoom对象转换为ChatRoomVO对象。
      *
-     * @param chatRooms 入参，待转换的ChatRoom对象列表。
-     * @return ChatRoomVO 转换后的ChatRoom视图对象列表。
+     * @param chatRooms 入参
+     * @return ChatRoomVO
      */
-    List<ChatRoomVO> convert(List<ChatRoom> chatRooms); // 定义了一个方法，将ChatRoom列表转换为ChatRoomVO列表。
+    List<ChatRoomVO> convert(List<ChatRoom> chatRooms);
 
     /**
      * 转换参数
-     * 将单个ChatRoom对象转换为ChatRoomDetailVO对象。
      *
-     * @param chatRoom 入参，待转换的ChatRoom对象。
-     * @return ChatRoomDetailVO 转换后的ChatRoom详细视图对象。
+     * @param chatRoom 入参
+     * @return ChatRoomDetailVO
      */
-    ChatRoomDetailVO convert(ChatRoom chatRoom); // 定义了一个方法，将单个ChatRoom对象转换为ChatRoomDetailVO对象。
+    ChatRoomDetailVO convert(ChatRoom chatRoom);
 
     /**
      * 转换参数
-     * 将单个ChatRoomInfo对象转换为ChatRoomInfoVO对象。
      *
-     * @param chatRoomInfo 入参，待转换的ChatRoomInfo对象。
-     * @return ChatRoomInfoVO 转换后的ChatRoom信息视图对象。
+     * @param chatRoomInfo 入参
+     * @return ChatRoomInfoVO
      */
-    ChatRoomInfoVO convert(ChatRoomInfo chatRoomInfo); // 定义了一个方法，将单个ChatRoomInfo对象转换为ChatRoomInfoVO对象。
+    ChatRoomInfoVO convert(ChatRoomInfo chatRoomInfo);
 
     /**
      * 参数转换
-     * 将单个ChatRoomProto.Member对象转换为ChatRoomMemberVO对象。
      *
-     * @param member 入参，待转换的ChatRoomProto.Member对象。
-     * @return ChatRoomMemberVO 转换后的ChatRoom成员视图对象。
+     * @param member 入参
+     * @return ChatRoomMemberVO
      */
-    ChatRoomMemberVO convert(ChatRoomProto.Member member); // 定义了一个方法，将单个ChatRoomProto.Member对象转换为ChatRoomMemberVO对象。
+    ChatRoomMemberVO convert(ChatRoomProto.Member member);
 
     /**
      * 参数转换
-     * 将一组ChatRoomProto.Member对象转换为ChatRoomMemberVO对象，并设置头像和群昵称。
      *
-     * @param members            入参，待转换的ChatRoomProto.Member对象列表。
-     * @param headImgUrlMap     头像信息的映射。
-     * @param contactNicknameMap 群昵称的映射。
-     * @return ChatRoomMemberVO 转换后的ChatRoom成员视图对象列表。
+     * @param members            入参
+     * @param headImgUrlMap      头像信息
+     * @param contactNicknameMap 群昵称
+     * @return ChatRoomMemberVO
      */
-    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 -> { // 对每个成员进行处理。
+    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 -> {
                     // 如果存在群备注则不处理
-                    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,27 +1,25 @@
-package com.xcs.wx.mapping; // 定义了这个接口的包名，表示这个接口属于com.xcs.wx.mapping包。
+package com.xcs.wx.mapping;
 
-import com.xcs.wx.domain.ContactLabel; // 导入ContactLabel实体类，这个类定义了联系人标签的数据结构。
-import com.xcs.wx.domain.vo.ContactLabelVO; // 导入ContactLabelVO类，这个类定义了联系人标签视图对象的数据结构。
-import org.mapstruct.Mapper; // 导入MapStruct的@Mapper注解，用于定义映射接口。
+import com.xcs.wx.domain.ContactLabel;
+import com.xcs.wx.domain.vo.ContactLabelVO;
+import org.mapstruct.Mapper;
 
-import java.util.List; // 导入Java的List接口，用于返回列表类型的数据。
+import java.util.List;
 
 /**
  * 联系人标签 Mapping
- * 这个接口定义了联系人标签相关对象之间的转换映射。
  *
- * @author xcs // 表示这个接口的作者。
- * @date 2023年12月22日 15时00分 // 表示这个接口的创建日期和时间。
+ * @author xcs
+ * @date 2023年12月22日 15时00分
  **/
-@Mapper(componentModel = "spring") // 使用MapStruct的@Mapper注解，指定该接口为映射接口，并配置为Spring组件。
-public interface ContactLabelMapping { // 定义了一个名为ContactLabelMapping的接口，用于联系人标签对象之间的转换映射。
+@Mapper(componentModel = "spring")
+public interface ContactLabelMapping {
 
     /**
      * 参数转换
-     * 将一组ContactLabel对象转换为ContactLabelVO对象。
      *
-     * @param labels 入参，待转换的ContactLabel对象列表。
-     * @return List<ContactLabelVO> 转换后的ContactLabel视图对象列表。
+     * @param labels 标签
+     * @return MsgDTO
      */
-    List<ContactLabelVO> convert(List<ContactLabel> labels); // 定义了一个方法，将ContactLabel列表转换为ContactLabelVO列表。
-}
+    List<ContactLabelVO> convert(List<ContactLabel> labels);
+}