mb7o3ja5v
/
wx-dump-4j
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: mb7o3ja5v:main
Branches Tags
mb7o3ja5v:main
mb7o3ja5v:郭雨露
mb7o3ja5v:万佳怡
mb7o3ja5v:吕璟涛
mb7o3ja5v:潘妍
mb7o3ja5v:develop
..
compare: mb7o3ja5v:develop
Branches Tags
mb7o3ja5v:main
mb7o3ja5v:郭雨露
mb7o3ja5v:万佳怡
mb7o3ja5v:吕璟涛
mb7o3ja5v:潘妍
mb7o3ja5v:develop

No commits in common. 'main' and 'develop' have entirely different histories.
main ... develop

295 changed files with 0 additions and 28150 deletions
Show Stats

54
.gitignore vendored
Unescape View File

@ -1,54 +0,0 @@
target/
!**/src/main/**/target/
!**/src/test/**/target/
/db/
/logs/
/img/
/export/
/config/
/data/
### IntelliJ IDEA ###
.idea
*.iws
*.iml
*.ipr
# dependencies
**/node_modules
# roadhog-api-doc ignore
/src/utils/request-temp.js
_roadhog-api-doc
# production
/dist
# misc
.DS_Store
npm-debug.log*
yarn-error.log
/coverage
yarn.lock
package-lock.json
*bak
.vscode
# visual studio code
.history
*.log
functions/*
.temp/**
# umi
.umi
.umi-production
.umi-test
# screenshot
screenshot
.firebase
.eslintcache
build

21
LICENSE
Unescape View File

@ -1,21 +0,0 @@
MIT License
Copyright (c) 2024 xuchengsheng
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.。

197
README.md
Unescape View File

@ -1,199 +1,2 @@
<p align="center">
<a href="https://wx.xxccss.com/"><img src="image/logo.png" width="45%"></a>
</p>
<p align="center">
<strong>🍬Java版微信聊天记录备份与管理工具</strong>
</p>
<p align="center">
👉 <a href="https://wx.xxccss.com/">https://wx.xxccss.com/</a> 👈
</p>
<p align="center">
<a href="https://hellogithub.com/repository/5055dcceee434dc5851ac9897cb27396" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=5055dcceee434dc5851ac9897cb27396&claim_uid=AVv4KeNnZs2Ig3a" alt="Featured｜HelloGitHub" style="width: 250px; height: 54px;" width="250" height="54" /></a>
</p>
<p align="center">
<a href="https://github.com/xuchengsheng/spring-reading/stargazers"><img src="https://img.shields.io/github/stars/xuchengsheng/wx-dump-4j?logo=github&logoColor=%23EF2D5E&label=Stars&labelColor=%23000000&color=%23EF2D5E&cacheSeconds=3600" alt="Stars Badge"/></a>
<a href="https://github.com/xuchengsheng"><img src="https://img.shields.io/github/followers/xuchengsheng?label=Followers&logo=github&logoColor=%23FC521F&labelColor=%231A2477&color=%23FC521F&cacheSeconds=3600" alt="Follow Badge"></a>
<a href="https://github.com/xuchengsheng/wx-dump-4j/fork"><img src="https://img.shields.io/github/forks/xuchengsheng/wx-dump-4j?label=Forks&logo=github&logoColor=%23F2BB13&labelColor=%23BE2323&color=%23F2BB13" alt="Fork Badge"></a>
<a href="https://github.com/xuchengsheng/wx-dump-4j/watchers"><img src="https://img.shields.io/github/watchers/xuchengsheng/wx-dump-4j?label=Watchers&logo=github&logoColor=%23FF4655&labelColor=%234169E1&color=%23FF4655&cacheSeconds=3600" alt="Watchers Badge"></a>
</p>
<p align="center">
<img src="https://img.shields.io/badge/Java-11%2B-%23437291?logo=openjdk&logoColor=%23437291"/>
<img src="https://img.shields.io/badge/Spring-5.3.10-%23437291?logo=Spring&logoColor=%236DB33F&color=%236DB33F"/>
<img src="https://img.shields.io/badge/SpringBoot-2.5.5-%23437291?logo=SpringBoot&logoColor=%236DB33F&color=%236DB33F"/>
<img src="https://img.shields.io/badge/JNA-5.8.0-%23437291?logo=JNA&logoColor=%23228B22&color=%23228B22"/>
<img src="https://img.shields.io/badge/Hutool-5.8.16-%23437291?logo=JNA&logoColor=%23F08080&color=%23F08080"/>
<img src="https://img.shields.io/badge/easyexcel-5.8.16-%23437291?logo=JNA&logoColor=%23D2691E&color=%23D2691E"/>
<img src="https://img.shields.io/badge/protobuf-3.25.1-%23437291?logo=JNA&logoColor=%23800080&color=%23800080"/>
<img src="https://img.shields.io/badge/mapstruct-1.4.2-%23437291?logo=JNA&logoColor=%23DC143C&color=%23DC143C"/>
<img src="https://img.shields.io/badge/druid-1.2.20-%23437291?logo=JNA&logoColor=%23C71585&color=%23C71585"/>
<img src="https://img.shields.io/badge/mybatisPlus-3.5.4.1-%23437291?logo=JNA&logoColor=%234B0082&color=%234B0082"/>
<img src="https://img.shields.io/badge/sqlite-3.34.0-%23437291?logo=JNA&logoColor=%230000CD&color=%230000CD"/>
<img src="https://img.shields.io/badge/lombok-1.18.20-%23437291?logo=JNA&logoColor=%23008B8B&color=%23008B8B"/>
</p>
## 📚 简介
wx-dump-4j是一款基于Java开发的微信数据分析工具。它准确显示好友数、群聊数和当日消息总量，提供过去15天每日消息统计，了解社交活跃度。识别展示最近一个月内互动频繁的前10位联系人。支持导出聊天记录、联系人、群聊信息，及查看**超过三天限制的朋友圈**历史记录和**找回微信好友**。
## 💡 主要功能
- 👤 **获取用户信息**：获取当前登录微信的详细信息，包括昵称、账号、手机号、邮箱、秘钥、微信Id。
- 💬 **支持多种消息类型**：管理微信聊天对话中的文本、引用、图片、表情、卡片链接、系统消息等。
- 📊 **综合管理**：提供微信会话、联系人、群聊与朋友圈的全面管理功能。
- 📥 **记录导出**：支持导出微信聊天记录、联系人、已删除好友和群聊信息，便于备份和管理。
- 📅 **查看历史朋友圈**：突破三日限制，查看更久以前的朋友圈历史记录，方便回顾和管理。
- 📈 **微信统计功能**：展示微信好友数、群聊数及今日收发消息总量，了解社交活跃度。
- 📊 **消息统计**：统计过去15天内每日微信消息数量，掌握长期消息交流情况。
- 🔝 **互动联系人**：展示最近一个月互动最频繁的前10位联系人，了解重要社交联系。
- 🧩 **消息类别占比**：展示微信消息类别占比图表，分析不同类型消息的占比情况。
- ☁️ **关键字词云**：展示微信最近使用的关键字词云图，分析聊天内容重点。
- 🔄 **找回已删除好友**：支持找回已删除的微信好友，恢复重要联系人。
- 🖥️ **微信多开支持**：支持微信多开功能，方便管理多个账号，提高效率。
## 🚀 快速启动
本指南将帮助您快速启动并运行项目，无论是安装包部署还是本地部署。
### 环境准备
在开始之前，请确保您的开发环境满足以下要求：
- 安装 [Java](https://repo.huaweicloud.com/java/jdk/11.0.2+9/jdk-11.0.2_windows-x64_bin.exe)，版本为 JDK 11+。
- 安装 [Node.js](https://nodejs.org/en/)，版本为 18+。
- 安装 [Maven](https://maven.apache.org/download.cgi)，版本为 3.5.0+。
- 选择一款开发工具，比如 IntelliJ IDEA。
### 二进制部署
- 点击下载最新版 [wx-dump-4j-bin.tar.gz](https://github.com/xuchengsheng/wx-dump-4j/releases/download/v1.1.0/wx-dump-4j-bin.tar.gz)。
- 解压缩 `wx-dump-4j-bin.tar.gz` 文件，并进入 `bin` 目录。
- 双击 `start.bat` 启动文件。
- 启动成功后，在浏览器中访问 [http://localhost:8080](http://localhost:8080) 以查看应用。
### 本地部署
- 下载源码：
```bash
$ git clone https://github.com/xuchengsheng/wx-dump-4j.git
```
- 安装后端依赖：
```bash
$ cd wx-dump-4j mvn clean install
```
- 使用开发工具（如 IntelliJ IDEA）启动 com.xcs.wx.WxDumpApplication。
- 安装前端依赖：
```bash
$ cd wx-dump-ui npm install
```
- 启动前端服务：
```bash
$ npm run start
```
- 前端服务启动成功后，在浏览器中访问 http://localhost:8000 以查看应用。
## ⚡ 技术栈
以下是本项目使用的技术栈：
| 技术 | 描述 | 版本 |
|--------------|---------------------------|-----------|
| Spring Boot | Web 和 Thymeleaf 框架 | 2.7.15 |
| SQLite | 轻量级数据库 | 3.34.0 |
| Lombok | 简化 Java 代码 | 1.18.20 |
| MyBatis Plus | ORM 框架扩展 | 3.5.4.1 |
| Dynamic Datasource | 动态数据源管理 | 4.2.0 |
| Druid | 数据库连接池 | 1.2.20 |
| MapStruct | Java Bean 映射工具 | 1.4.2.Final |
| Hutool | Java 工具库 | 5.8.16 |
| JNA | Java 本地访问 | 5.8.0 |
| Protobuf | 序列化框架 | 3.25.1 |
| gRPC | RPC 框架 | 1.11.0 |
| EasyExcel | Excel 操作工具 | 3.3.3 |
| Commons Compress | 压缩和解压缩工具 | 1.19 |
| Jackson Dataformat XML | XML 解析工具 | 2.13.5 |
| Commons Lang3 | 常用工具类库 | 3.12.0 |
## ⛔️️ 使用限制
本软件仅适用于Windows操作系统。我们目前不支持macOS、Linux或其他操作系统。如果你在尝试在非Windows系统上运行本软件时可能遇到兼容性问题，这些问题可能导致软件无法正常运行或产生其他意外后果。
| 操作系统 | 支持情况 |
|:--------:|:----------:|
| Windows | 支持 |
| macOS | 不支持 |
| Linux | 不支持 |
## ⚠️免责声明
本软件仅供技术研究和教育目的使用，旨在解密用户个人微信聊天记录。严禁将本软件用于任何非法目的，包括但不限于侵犯隐私权或非授权数据访问。作为软件开发者，我不对因使用或滥用本软件产生的任何形式的损失或损害承担责任。
## ⛵欢迎贡献！
如果你发现任何错误🔍或者有改进建议🛠️，欢迎提交 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>
## 👀 演示图
<table>
<tr>
<td><img src="image/screenshot/dashboard.png"/></td>
<td><img src="image/screenshot/session.png"/></td>
</tr>
<tr>
<td><img src="image/screenshot/contact.png"/></td>
<td><img src="image/screenshot/recover-contact.png"/></td>
</tr>
<tr>
<td><img src="image/screenshot/feeds.png"/></td>
<td><img src="image/screenshot/chat.png"/></td>
</tr>
<tr>
<td><img src="image/screenshot/chatroom.png"/></td>
<td><img src="image/screenshot/chatroom-detail.png"/></td>
</tr>
<tr>
<td><img src="image/screenshot/database.png"/></td>
<td><img src="image/screenshot/database-list.png"/></td>
</tr>
</table>
=======
# wx-dump-4j # wx-dump-4j
>>>>>>> c4b6449ae2686772c4ab318ba75389b6a4df21ea

211
docs/decrypt.md
Unescape View File

@ -1,211 +0,0 @@
## 微信SQLite数据库文件解密实现
- [微信SQLite数据库文件解密实现](#微信sqlite数据库文件解密实现)
- [SQLite页结构描述](#sqlite页结构描述)
- [SQLite页结构图](#sqlite页结构图)
- [解密实现过程](#解密实现过程)
- [源码地址](#源码地址)
#### SQLite页结构描述
微信`SQLite`数据库文件以每个页面4096字节的大小进行划分，这些页面组成了文件的基本结构。每个页面内部包含了关键的元素，包括盐值、加密后的内容、初始化向量（`IV`）、哈希值（`hashMac`），以及用于保留的空字节。这个结构在整个数据库文件中起到了关键的组织和安全保障的作用。
首个页面是独特的，它包含了生成加密密钥所需的盐值、加密后的内容、初始化向量（`IV`）、哈希值（`hashMac`），以及用于保留的空字节。盐值在加密密钥生成过程中发挥着关键的作用，而哈希值则用于验证密钥的正确性，提供了额外的安全层。空字节的存在为未来可能的拓展或变化预留了空间。
随后的页面结构与首个页面相似，仍然包括了加密后的内容、初始化向量（`IV`）以及用于保留的空字节。这种一致性的结构确保了整个数据库文件的统一性和安全性，使得每个页面都能够独立存储经过加密的数据块，并在需要时通过初始化向量进行解密。这种巧妙的设计使得`SQLite`数据库文件在存储和保护数据方面表现出色。
#### SQLite页结构图
~~~mermaid
graph TD
A[SQLite Database File]
A -->|第一页| C1[4096字节]
C1 -->|盐值| C1A[16字节]
C1 -->|内容| C1C[4032字节]
C1 -->|IV| C1IV[16字节]
C1 -->|hashMac| C1H[20字节]
C1 -->|空字节| C1R[12字节]
A -->|第二页| C2[4096字节]
C2 -->|内容| C2C[4048字节]
C2 -->|IV| C2IV[16字节]
C2 -->|空字节| C2R[32字节]
A -->|第N页| C3[4096字节]
C3 -->|内容| C3C[4048字节]
C3 -->|IV| C3IV[16字节]
C3 -->|空字节| C3R[32字节]
~~~
#### 解密实现过程
`DecryptServiceImpl`类是一个解密服务的实现，专门用于解密`SQLite`数据库文件。首先，它定义了`SQLite`数据库文件的文件头、加密算法（`HmacSHA1`）、页面大小（4096字节）、迭代次数（64000次）以及密钥长度（32字节）。主要功能由`wechatDecrypt`方法实现，该方法接收密码和解密业务对象作为参数。
在`wechatDecrypt`方法内部，首先通过`FileInputStream`读取数据库文件内容，提取文件头、盐值、第一页信息，包括内容、IV、`hashMac`和保留字段。随后，利用`PBKDF2`算法和用户提供的密码生成密钥，并根据提取的盐值和`hashMac`验证密钥的正确性。
如果密钥验证成功，便创建输出文件，写入`SQLite`文件头，并对第一页进行解密，写入解密后的内容和保留字段。接着，循环处理后续数据块，逐一解密并写入到输出文件。整个过程保证了对`SQLite`数据库文件的完整性和保密性的维护。
在解密过程中，`doDecrypt`方法使用`AES/CBC/NoPadding`模式对数据进行解密。为了处理大文件，`splitDataPages`方法将文件内容分割成多个页面进行逐一处理。
最后，通过`checkKey`方法检查密钥的有效性，确保解密过程中密钥的正确性。该类结合了多重密码学技术，保障了对`SQLite`数据库文件的高效且安全的解密操作。
```java
public class DecryptServiceImpl implements DecryptService {
/**
* SQLite数据库的文件头
*/
private static final String SQLITE_FILE_HEADER = "SQLite format 3\u0000";
/**
* 算法
*/
private static final String ALGORITHM = "HmacSHA1";
/**
* 一页的大小
*/
private static final int DEFAULT_PAGESIZE = 4096;
/**
* 迭代次数
*/
private static final int ITERATIONS = 64000;
/**
* Key长度
*/
private static final int HASH_KEY_LENGTH = 32;
@Override
public void wechatDecrypt(String password, DecryptBO decryptBO) {
// 创建File文件
File file = new File(decryptBO.getInput());
try (FileInputStream fis = new FileInputStream(file)) {
// 文件大小
byte[] fileContent = new byte[(int) file.length()];
// 读取内容
fis.read(fileContent);
// 提取盐值
byte[] salt = Arrays.copyOfRange(fileContent, 0, 16);
// 提取第一页
byte[] firstPage = Arrays.copyOfRange(fileContent, 16, DEFAULT_PAGESIZE);
// 提取第一页的内容与IV
byte[] firstPageBodyAndIv = Arrays.copyOfRange(firstPage, 0, firstPage.length - 32);
// 提取第一页的内容
byte[] firstPageBody = Arrays.copyOfRange(firstPage, 0, firstPage.length - 48);
// 提取第一页IV
byte[] firstPageIv = Arrays.copyOfRange(firstPage, firstPage.length - 48, firstPage.length - 32);
// 提取第一页的hashMac
byte[] firstPageHashMac = Arrays.copyOfRange(firstPage, firstPage.length - 32, firstPage.length - 12);
// 提取第一页的保留字段
byte[] firstPageReservedSegment = Arrays.copyOfRange(firstPage, firstPage.length - 48, firstPage.length);
// 生成key
byte[] key = Pbkdf2HmacUtil.pbkdf2Hmac(ALGORITHM, HexUtil.decodeHex(password), salt, ITERATIONS, HASH_KEY_LENGTH);
byte[] macSalt = new byte[salt.length];
for (int i = 0; i < salt.length; i++) {
macSalt[i] = (byte) (salt[i] ^ 58);
}
// 秘钥匹配成功
if (checkKey(key, macSalt, firstPageHashMac, firstPageBodyAndIv)) {
File outputFile = new File(decryptBO.getOutput());
File parentDir = outputFile.getParentFile();
// 检查父目录是否存在，如果不存在，则创建
if (!parentDir.exists()) {
parentDir.mkdirs();
}
// 解密并写入新文件
try (FileOutputStream deFile = new FileOutputStream(outputFile)) {
deFile.write(SQLITE_FILE_HEADER.getBytes());
deFile.write(doDecrypt(key, firstPageIv, firstPageBody));
deFile.write(firstPageReservedSegment);
// 解密后续数据块
for (byte[] page : splitDataPages(fileContent)) {
byte[] iv = Arrays.copyOfRange(page, page.length - 48, page.length - 32);
byte[] body = Arrays.copyOfRange(page, 0, page.length - 48);
byte[] reservedSegment = Arrays.copyOfRange(page, page.length - 48, page.length);
deFile.write(doDecrypt(key, iv, body));
deFile.write(reservedSegment);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 使用AES/CBC/NoPadding模式进行解密
*
* @param key 密钥
* @param iv 初始化向量
* @param input 待解密的数据
* @return 解密后的数据
* @throws GeneralSecurityException 抛出异常
*/
private byte[] doDecrypt(byte[] key, byte[] iv, byte[] input) throws GeneralSecurityException {
Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
SecretKeySpec secretKeySpec = new SecretKeySpec(key, "AES");
IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
return cipher.doFinal(input);
}
/**
* 将数据分割成多个页面
*
* @param fileContent 文件内容的字节数组
* @return 分割后的页面列表
*/
private List<byte[]> splitDataPages(byte[] fileContent) {
List<byte[]> pages = new ArrayList<>();
for (int i = DEFAULT_PAGESIZE; i < fileContent.length; i += DEFAULT_PAGESIZE) {
// 计算每个分割页面的结束位置
int end = Math.min(i + DEFAULT_PAGESIZE, fileContent.length);
byte[] slice = new byte[end - i];
// 将数据复制到新的页面中
System.arraycopy(fileContent, i, slice, 0, slice.length);
pages.add(slice);
}
return pages;
}
/**
* 检查密钥是否有效
*
* @param byteKey 密钥的字节数组
* @param macSalt MAC盐值
* @param hashMac 预期的MAC哈希值
* @param message 消息内容
* @return 如果密钥有效返回true，否则返回false
* @throws Exception 抛出异常
*/
private boolean checkKey(byte[] byteKey, byte[] macSalt, byte[] hashMac, byte[] message) throws Exception {
// 使用PBKDF2算法生成MAC密钥
byte[] macKey = Pbkdf2HmacUtil.pbkdf2Hmac(ALGORITHM, byteKey, macSalt, 2, 32);
Mac mac = Mac.getInstance(ALGORITHM);
SecretKeySpec keySpec = new SecretKeySpec(macKey, ALGORITHM);
mac.init(keySpec);
// 更新MAC计算的消息内容
mac.update(message);
// 添加额外的数据到消息中
mac.update(new byte[]{1, 0, 0, 0});
// 比较计算出的MAC值和预期的MAC值是否相同
return Arrays.equals(hashMac, mac.doFinal());
}
}
```
#### 源码地址
+ https://github.com/xuchengsheng/wx-dump-4j
+ `com.xcs.wx.service.impl.DecryptServiceImpl`

29
docs/display.md
Unescape View File

@ -1,29 +0,0 @@
![](../image/screenshot/index1.png)
![](../image/screenshot/index2.png)
![](../image/screenshot/database.png)
![](../image/screenshot/chat1.png)
![](../image/screenshot/chat.png)
![](../image/screenshot/session.png)
![](../image/screenshot/chatroom.png)
![](../image/screenshot/export-chatroom.png)
![](../image/screenshot/chatroom-detail.png)
![](../image/screenshot/contact.png)
![](../image/screenshot/export-contact.png)
![](../image/screenshot/feeds.png)
![](../image/screenshot/feeds-pre-img.png)
![](../image/screenshot/excel-msg.png)
![](../image/screenshot/excel-contact.png)

BIN
image/Alipay.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 99 KiB

BIN
image/WeChatPay.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 68 KiB

BIN
image/banner.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 28 KiB

BIN
image/logo.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 28 KiB

BIN
image/screenshot/chat.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 163 KiB

BIN
image/screenshot/chatroom-detail.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 365 KiB

BIN
image/screenshot/chatroom.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 287 KiB

BIN
image/screenshot/contact.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 216 KiB

BIN
image/screenshot/dashboard.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 251 KiB

BIN
image/screenshot/database-list.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 258 KiB

BIN
image/screenshot/database.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 112 KiB

BIN
image/screenshot/feeds.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 303 KiB

BIN
image/screenshot/recover-contact.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 145 KiB

BIN
image/screenshot/session.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 207 KiB

BIN
image/wechat-mp.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 4.1 MiB

170
pom.xml
Unescape View File

@ -1,170 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<!-- Maven 项目对象模型（POM）的版本号，通常固定为 4.0.0，表示遵循的 POM 规范版本 -->
<modelVersion>4.0.0</modelVersion>
<!-- 项目的groupId，是项目在 Maven 仓库中的唯一标识，一般采用反向域名的格式，用于区分不同组织或公司下的项目 -->
<groupId>com.xcs.wx</groupId>
<!-- 项目的artifactId，是项目在同一 groupId 下的唯一标识，相当于项目的名称，与 groupId 一起构成项目在 Maven 仓库中的坐标 -->
<artifactId>wx-dump-4j</artifactId>
<!-- 项目的打包类型，这里设置为 "pom"，表示这是一个聚合项目或者父项目，本身不会生成可部署的构件（如 jar 包、war 包等），
而是用于管理子项目以及统一配置依赖等信息 -->
<packaging>pom</packaging>
<!-- 项目的版本号，这里使用了一个属性（${revision}）来定义，后续可以在 properties 元素中对该属性进行赋值 -->
<version>${revision}</version>
<!-- 定义项目包含的子模块，这些子模块会作为当前项目的一部分被统一管理，例如在构建时可以一起构建等 -->
<modules>
<!-- 第一个子模块，模块名称为 "wx-dump-admin"，Maven 会根据配置去查找对应的子项目目录并进行相关构建操作 -->
<module>wx-dump-admin</module>
<!-- 第二个子模块，模块名称为 "wx-dump-dist"，同样会被纳入当前项目的管理范畴 -->
<module>wx-dump-dist</module>
</modules>
<!-- 定义项目中使用的各种属性，这些属性可以在项目的其他地方通过 ${属性名} 的方式进行引用 -->
<properties>
<!-- 指定项目编译时使用的 Java 版本，这里设置源文件和目标文件的编译版本都为 11 -->
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<!-- 指定 Maven Assembly 插件的版本号 -->
<maven-assembly-plugin.version>3.5.0</maven-assembly-plugin.version>
<!-- 指定项目构建时源文件的编码格式为 UTF-8 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<!-- 对之前版本号中使用的 ${revision} 属性进行赋值，这里设置项目的版本为 1.1.0 -->
<revision>1.1.0</revision>
</properties>
<!-- 依赖管理部分，用于统一管理项目及其子项目所依赖的各种外部库的版本等信息，
子项目可以继承这里定义的依赖配置，但不一定会自动引入这些依赖（具体是否引入要看子项目的依赖配置） -->
<dependencyManagement>
<dependencies>
<!-- 引入 Spring Boot 的 Web 启动器依赖，指定版本为 2.7.15，该依赖包含构建 Web 应用所需的一系列基础依赖，
方便快速搭建基于 Spring Boot 的 Web 项目 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.7.15</version>
</dependency>
<!-- 引入 Spring Boot 的 Thymeleaf 启动器依赖，版本为 2.7.15，用于在 Spring Boot 项目中集成 Thymeleaf 模板引擎，
实现页面视图的渲染 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
<version>2.7.15</version>
</dependency>
<!-- 引入 SQLite 的 JDBC 驱动依赖，版本是 3.34.0，用于在项目中连接和操作 SQLite 数据库 -->
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
<version>3.34.0</version>
</dependency>
<!-- 引入 Lombok 依赖，版本为 1.18.20，Lombok 可以通过注解方式简化 Java 代码，自动生成诸如 getter、setter、构造函数等方法 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
</dependency>
<!-- 引入 MyBatis Plus 的 Spring Boot 启动器依赖，版本 3.5.4.1，MyBatis Plus 是 MyBatis 的增强工具，
提供通用的 CRUD 操作等便捷功能，便于数据库访问层开发 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.4.1</version>
</dependency>
<!-- 引入动态数据源的 Spring Boot 启动器依赖，版本 4.2.0，用于实现项目中动态切换数据源的功能 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
<version>4.2.0</version>
</dependency>
<!-- 引入 Druid 的 Spring Boot 启动器依赖，版本 1.2.20，Druid 是性能优秀的数据库连接池，还具备监控等功能 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.2.20</version>
</dependency>
<!-- 引入 MapStruct 的核心依赖，版本 1.4.2.Final，MapStruct 用于生成类型安全、高性能且遵循 Java 规范的 bean 映射代码 -->
<dependency>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct</artifactId>
<version>1.4.2.Final</version>
</dependency>
<!-- 引入 MapStruct 的处理器依赖，版本 1.4.2.Final，用于在编译阶段处理 MapStruct 注解，生成相应的映射代码 -->
<dependency>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct-processor</artifactId>
<version>1.4.2.Final</version>
</dependency>
<!-- 引入 Hutool 工具集依赖，版本 5.8.16，Hutool 提供大量实用工具类，涵盖字符串处理、文件操作、日期时间处理等多方面 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.16</version>
</dependency>
<!-- 引入 JNA（Java Native Access）核心依赖，版本 5.8.0，它允许 Java 程序调用本地代码库，便于与底层系统交互 -->
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna</artifactId>
<version>5.8.0</version>
</dependency>
<!-- 引入 JNA 平台相关依赖，版本 5.8.0，提供特定平台下的扩展功能 -->
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna-platform</artifactId>
<version>5.8.0</version>
</dependency>
<!-- 引入 Google 的 Protocol Buffers（protobuf）核心依赖，版本 3.25.1，protobuf 用于数据序列化和通信协议等场景 -->
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>3.25.1</version>
</dependency>
<!-- 引入 Google 的 Protocol Buffers（protobuf）工具类依赖，版本 3.25.1，提供方便操作 protobuf 数据的实用方法 -->
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java-util</artifactId>
<version>3.25.1</version>
</dependency>
<!-- 引入 gRPC 相关的所有依赖，版本 1.11.0，gRPC 是高性能 RPC 框架，常用于微服务间通信 -->
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-all</artifactId>
<version>1.11.0</version>
</dependency>
<!-- 引入 EasyExcel 依赖，版本 3.3.3，用于方便地操作 Excel 文件 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
<version>3.3.3</version>
</dependency>
<!-- 引入 Commons Compress 依赖，版本 1.19，用于操作各种压缩格式文件 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-compress</artifactId>
<version>1.19</version>
</dependency>
<!-- 引入 Jackson 的 XML 数据格式模块依赖，版本 2.13.5，用于支持对象与 XML 数据的序列化和反序列化 -->
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
<version>2.13.5</version>
</dependency>
<!-- 引入 Commons Lang3 依赖，版本 3.12.0，提供大量对 Java 基本数据类型、字符串等操作的实用工具方法 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.12.0</version>
</dependency>
<!-- 引入名为 "wx-dump-admin" 的项目作为依赖，版本使用之前定义的 ${revision} 属性值，
通常表示当前项目与该子项目之间存在某种关联，比如依赖其提供的功能等 -->
<dependency>
<groupId>com.xcs.wx</groupId>
<artifactId>wx-dump-admin</artifactId>
<version>${revision}</version>
</dependency>
</dependencies>
</dependencyManagement>
</project>

143
wx-dump-admin/pom.xml
Unescape View File

@ -1,143 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<!-- 定义该项目的父项目相关信息，通过这些配置，当前项目可以继承父项目的一些配置和依赖等内容 -->
<parent>
<artifactId>wx-dump-4j</artifactId>
<groupId>com.xcs.wx</groupId>
<version>${revision}</version>
<relativePath>../pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<!-- 当前项目的构件标识符，也就是项目生成的 jar 包等构件的名称 -->
<artifactId>wx-dump-admin</artifactId>
<!-- 项目的打包方式，这里设置为 "jar"，表示最终会打包成一个 Java 可执行的 jar 文件 -->
<packaging>jar</packaging>
<!-- 项目依赖配置部分，在这里列出了项目运行所需要依赖的其他库 -->
<dependencies>
<!-- 引入 Spring Boot 的 Web 启动器依赖，它包含了构建 Web 应用所需的一系列基础依赖，
例如 Spring MVC 等，方便快速搭建基于 Spring Boot 的 Web 项目 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- 引入 Spring Boot 的 Thymeleaf 启动器依赖，用于在 Spring Boot 项目中集成 Thymeleaf 模板引擎，
方便进行页面视图的渲染 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<!-- 引入 SQLite 的 JDBC 驱动依赖，用于在项目中连接和操作 SQLite 数据库 -->
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
</dependency>
<!-- 引入 Lombok 依赖，Lombok 可以通过注解的方式帮助简化 Java 代码，例如自动生成 getter、setter、构造函数等方法 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!-- 引入 MyBatis Plus 的 Spring Boot 启动器依赖，MyBatis Plus 是 MyBatis 的增强工具，
提供了很多便捷的功能，如通用的 CRUD 操作等，方便数据库访问层的开发 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<!-- 引入动态数据源的 Spring Boot 启动器依赖，用于在项目中实现动态切换数据源的功能 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
</dependency>
<!-- 引入 Druid 的 Spring Boot 启动器依赖，Druid 是一款性能优秀的数据库连接池，同时还具备监控等功能 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
</dependency>
<!-- 引入 MapStruct 的核心依赖，MapStruct 是一个用于生成类型安全、高性能且遵循 Java 规范的 bean 映射代码的注解处理器 -->
<dependency>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct</artifactId>
</dependency>
<!-- 引入 MapStruct 的处理器依赖，用于在编译阶段处理 MapStruct 的注解，生成相应的映射代码 -->
<dependency>
<groupId>org.mapstruct</groupId>
<artifactId>mapstruct-processor</artifactId>
</dependency>
<!-- 引入 Hutool 工具集依赖，Hutool 提供了大量实用的工具类，涵盖了字符串处理、文件操作、日期时间处理等多个方面，方便日常开发 -->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
</dependency>
<!-- 引入 JNA（Java Native Access）核心依赖，它允许 Java 程序调用本地代码库，方便与底层系统进行交互 -->
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna</artifactId>
</dependency>
<!-- 引入 JNA 平台相关依赖，提供了特定平台下的一些扩展功能 -->
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna-platform</artifactId>
</dependency>
<!-- 引入 Google 的 Protocol Buffers（protobuf）核心依赖，protobuf 是一种轻便高效的结构化数据存储格式，
常用于数据序列化和通信协议等场景 -->
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
</dependency>
<!-- 引入 Google 的 Protocol Buffers（protobuf）工具类依赖，提供了一些方便操作 protobuf 数据的实用方法 -->
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java-util</artifactId>
</dependency>
<!-- 引入 gRPC 相关的所有依赖，gRPC 是一个高性能、开源和通用的 RPC 框架，基于 HTTP/2 协议实现，
常用于微服务之间的通信 -->
<dependency>
<groupId>io.grpc</groupId>
<artifactId>grpc-all</artifactId>
</dependency>
<!-- 引入 EasyExcel 依赖，EasyExcel 是一个方便操作 Excel 文件的 Java 库，支持读写 Excel 等功能 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
</dependency>
<!-- 引入 Commons Compress 依赖，它提供了对各种压缩格式文件（如 ZIP、GZIP 等）进行操作的功能 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-compress</artifactId>
</dependency>
<!-- 引入 Jackson 的 XML 数据格式模块依赖，用于在项目中支持将对象序列化为 XML 格式以及反序列化 XML 数据为对象 -->
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
</dependency>
<!-- 引入 Commons Lang3 依赖，它提供了大量对 Java 基本数据类型、字符串、数组等进行操作的实用工具方法 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
</dependencies>
<!-- 项目构建配置部分，主要配置项目构建过程中使用的插件等相关信息 -->
<build>
<!-- 定义项目最终生成的构件（如 jar 包等）的名称 -->
<finalName>wx-dump-admin</finalName>
<plugins>
<!-- 配置 Maven 编译器插件，用于指定项目编译时使用的 Java 版本 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>11</source>
<target>11</target>
</configuration>
</plugin>
</plugins>
</build>
</project>

79
wx-dump-admin/src/main/java/com/xcs/wx/WxDumpApplication.java
Unescape View File

@ -1,79 +0,0 @@
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;
import java.net.UnknownHostException;
import java.util.Date;
/**
* `WxDumpApplication` 类是整个 Spring Boot 应用的启动类，它承担着启动应用、配置相关功能以及在启动成功后向控制台输出应用启动相关信息的职责。
* 通过 `@SpringBootApplication` 注解表明这是一个 Spring Boot 应用的主配置类，同时结合其他相关注解开启诸如事务管理、AOP 代理、定时任务等功能，方便在应用中使用对应的特性，
* 并且在 `main` 方法中完成应用上下文的创建、获取应用运行的相关配置信息（如端口、上下文路径等），最后将启动耗时、当前时间以及应用可访问的本地和网络地址等信息输出到控制台，便于开发者了解应用启动情况。
*
* @author xcs
* @date 2023年12月21日 17时02分
**/
@SpringBootApplication
// 开启 Spring 框架中的事务管理功能，允许在应用中使用注解（如 `@Transactional`）来方便地管理数据库事务，确保数据操作的一致性和完整性，例如在涉及多个数据库操作的业务方法中，通过该注解可以控制这些操作要么全部成功提交，要么全部回滚。
@EnableTransactionManagement
public class WxDumpApplication {
public static void main(String[] args) throws UnknownHostException {
// 记录应用启动的开始时间，通过调用 `System.currentTimeMillis` 方法获取当前系统时间的毫秒数，作为应用启动的时间戳记录下来，
// 后续可以通过与应用启动完成后的时间戳做差值运算，得到应用启动所花费的时间，用于向用户展示启动耗时情况。
long startTime = System.currentTimeMillis();
// 启动 Spring Boot 应用，调用 `SpringApplication.run` 方法，传入当前启动类（`WxDumpApplication.class`）以及启动参数（`args`）作为参数，
// 该方法会执行一系列的 Spring Boot 初始化操作，包括加载配置文件、创建 Spring 应用上下文、扫描并实例化各种组件（如 `Controller`、`Service`、`Repository` 等），最终返回一个可配置的应用上下文对象 `context`，用于后续获取应用的运行时配置等信息。
ConfigurableApplicationContext context = SpringApplication.run(WxDumpApplication.class, args);
// 记录应用启动的结束时间，同样通过调用 `System.currentTimeMillis` 方法获取当前系统时间的毫秒数，作为应用启动完成的时间戳，用于后续计算启动耗时。
long endTime = System.currentTimeMillis();
// 获取应用运行的端口号，通过应用上下文对象（`context`）的 `getEnvironment` 方法获取应用的运行环境配置对象，
// 再调用其 `getProperty` 方法尝试获取名为 `"server.port"` 的配置属性值，如果不存在该属性，则使用默认值 `"8080"`，
// 这个端口号是应用对外提供服务所监听的端口，后续用于构建应用的访问地址信息。
String port = context.getEnvironment().getProperty("server.port", "8080");
// 获取应用的上下文路径，通过应用上下文对象（`context`）的 `getEnvironment` 方法获取应用的运行环境配置对象，
// 再调用其 `getProperty` 方法尝试获取名为 `"server.servlet.context-path"` 的配置属性值，如果不存在该属性，则使用默认值 `""`（表示根路径），
// 上下文路径通常用于在应用部署到服务器时，作为应用的访问前缀，与端口号等信息一起构成完整的访问地址。
String contextPath = context.getEnvironment().getProperty("server.servlet.context-path", "");
// 获取本地主机的 IP 地址，通过调用 `InetAddress.getLocalHost` 方法获取本地主机的网络地址信息对象，再调用其 `getHostAddress` 方法获取对应的 IP 地址字符串，
// 这个 IP 地址用于构建应用在网络环境下可访问的地址，区别于本地回环地址（`localhost`），方便其他设备在同一网络中访问该应用。
String localHostAddress = InetAddress.getLocalHost().getHostAddress();
// 构建应用在本地访问的 URL 地址，按照 `http://localhost:<port><contextPath>` 的格式拼接字符串，其中 `<port>` 是前面获取到的端口号，`<contextPath>` 是获取到的应用上下文路径，
// 这个地址方便开发者在本地通过浏览器等方式访问正在运行的应用，用于本地的调试和测试等操作。
String localUrl = "http://localhost:" + port + contextPath;
// 构建应用在网络环境下访问的 URL 地址，按照 `http://<localHostAddress>:<port><contextPath>` 的格式拼接字符串，其中 `<localHostAddress>` 是前面获取到的本地主机 IP 地址，`<port>` 是端口号，`<contextPath>` 是应用上下文路径，
// 这个地址使得同一网络中的其他设备可以通过该地址访问到正在运行的应用，实现应用的网络访问功能。
String networkUrl = "http://" + localHostAddress + ":" + port + contextPath;
// 向控制台输出应用启动成功的提示信息以及启动耗时，通过 `System.out.println` 方法输出字符串 `"DONE successfully in "` 加上启动耗时（`endTime - startTime` 的差值，单位为毫秒）再加上 `"ms"`，
// 告知用户应用已经成功启动以及花费了多长时间完成启动过程，方便用户了解应用启动的效率情况。
System.out.println("DONE successfully in " + (endTime - startTime) + "ms");
// 向控制台输出当前时间信息，通过创建一个 `Date` 类的实例（表示当前时间），并将其作为参数传递给 `System.out.println` 方法，输出当前的日期和时间信息，
// 让用户知晓应用启动完成时的具体时间点，方便记录和参考。
System.out.println("Time: " + new Date());
// 输出一个用于装饰性的 ASCII 字符边框的上边框，通过 `System.out.println` 方法输出特定格式的字符串，形成一个可视化的边框效果，用于对后续输出的应用访问地址等重要信息进行视觉上的区分和美化，增强控制台输出信息的可读性。
System.out.println("╔════════════════════════════════════════════════════╗");
// 输出应用访问地址相关的提示信息，通过 `System.out.println` 方法输出字符串 `"║ App listening at: ║"`，告知用户接下来将展示应用可以被访问的地址信息，起到引导性的作用。
System.out.println("║ App listening at: ║");
// 输出应用在本地访问的地址信息，通过 `System.out.println` 方法输出字符串 `"║ > Local: "` 加上前面构建好的本地访问 URL 地址（`localUrl`）再加上空格进行对齐和美化，
// 向用户明确展示应用在本地可以通过什么地址进行访问，方便用户进行本地调试等操作。
System.out.println("║ > Local: " + localUrl + " ");
// 输出应用在网络环境下访问的地址信息，通过 `System.out.println` 方法输出字符串 `"║ > Network: "` 加上前面构建好的网络访问 URL 地址（`networkUrl`）再加上空格进行对齐和美化，
// 告知用户应用在网络中可以通过什么地址被其他设备访问，方便在多设备协同等场景下使用该应用。
System.out.println("║ > Network: " + networkUrl + " ");
// 输出一个空行，用于在地址信息和后续提示信息之间进行视觉上的分隔，通过 `System.out.println` 方法输出一个空字符串来实现，增强控制台输出信息的层次感和可读性。
System.out.println("║ ║");
// 输出一个引导性的提示信息，告知用户现在可以使用上面展示的地址在浏览器中打开应用，通过 `System.out.println` 方法输出相应的字符串内容，方便用户快速了解如何进一步操作使用应用。
System.out.println("║ Now you can open browser with the above addresses↑ ║");
// 输出一个用于装饰性的 ASCII 字符边框的下边框，通过 `System.out.println` 方法输出特定格式的字符串，与前面的上边框对应，形成一个完整的边框效果，对整个应用启动相关信息的输出进行视觉上的包裹，使其更加清晰和美观。
System.out.println("╚════════════════════════════════════════════════════╝");
}
}

65
wx-dump-admin/src/main/java/com/xcs/wx/aop/RepositoryAspect.java
Unescape View File

@ -1,65 +0,0 @@
package com.xcs.wx.aop;
import cn.hutool.core.annotation.AnnotationUtil;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.dynamic.datasource.toolkit.DynamicDataSourceContextHolder;
import com.xcs.wx.util.DSNameUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
/**
* 多微信数据源动态切换拦截
* 该类作为一个切面（Aspect），用于拦截特定方法的执行，实现根据注解来动态切换数据源的功能。
* 主要应用场景是在涉及多个微信相关数据源的情况下，根据不同的业务方法所在类上的注解，灵活切换数据源进行数据操作。
* @author xcs.
* @date 2024年6月27日14:29:32
*/
@Slf4j
@Aspect
@Component
public class RepositoryAspect {
/**
* 环绕通知方法，用于拦截指定包下的方法执行，并在方法执行前后进行数据源的切换操作。
* 拦截的是 com.xcs.wx.repository 及其子包下所有公共方法的执行。
* @param joinPoint 连接点对象，代表了被拦截到的方法调用，可以通过它获取方法相关的各种信息，如目标对象、方法参数等。
* @return 被拦截方法执行后的返回结果，如果方法有返回值则返回相应的值，若没有返回值则返回相应类型的默认值（如 void 方法返回 null）。
* @throws Throwable 如果在方法执行过程中或者数据源切换等相关操作中出现异常，则会向上抛出。.
*/
@Around("execution(public * com.xcs.wx.repository..*.*(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
// 获取当前正在使用的数据源名称并保存起来，以便后续在方法执行完毕后恢复到该数据源。
// peek()方法用于查看当前线程下设置的数据源名称，但不移除（如果有的话）。
String previousDs = DynamicDataSourceContextHolder.peek();
try {
// 获取拦截方法所在的类，通过连接点对象可以拿到目标对象，进而获取其对应的类。
// 后续会基于这个类去查找是否有特定的数据源切换相关注解。
Class<?> targetClass = joinPoint.getTarget().getClass();
// 获取类上的@DS注解，这个注解通常用于标记该类对应的方法操作应该使用哪个具体的数据源。
// AnnotationUtil是hutool工具库提供的用于操作注解的工具类，这里用于获取指定类型的注解实例。
DS dsAnnotation = AnnotationUtil.getAnnotation(targetClass, DS.class);
// 有指定的注解，说明该类对应的方法需要切换到特定的数据源进行操作。
if (dsAnnotation!= null) {
// 根据注解中配置的数据源相关信息（通常是一个标识数据源的字符串等），通过DSNameUtil工具类获取实际要切换到的数据源名称，
// 然后将该数据源名称设置到DynamicDataSourceContextHolder中，实现数据源的切换。
// push()方法会将指定的数据源名称设置到当前线程下，使得后续的数据操作可以使用该数据源。
DynamicDataSourceContextHolder.push(DSNameUtil.getDSName(dsAnnotation.value()));
}
// 执行被拦截的方法，让业务逻辑正常进行，其返回结果会作为整个环绕通知方法最终的返回值（如果有返回值的话）。
return joinPoint.proceed();
} finally {
// 恢复之前的ds，无论方法执行过程中是否发生异常，都需要保证数据源能恢复到之前的状态。
// 如果之前保存的数据源名称不为空，说明之前存在使用的数据源，那么将其重新设置回去，使得后续操作可以继续使用该数据源。
if (previousDs!= null) {
DynamicDataSourceContextHolder.push(previousDs);
} else {
// 如果之前保存的数据源名称为空，说明可能之前没有设置过数据源或者是需要清除当前线程下设置的数据源相关信息，
// 调用clear()方法进行清除操作，将数据源相关状态重置。
DynamicDataSourceContextHolder.clear();
}
}
}
}

85
wx-dump-admin/src/main/java/com/xcs/wx/config/ExceptionAdviceConfig.java
Unescape View File

@ -1,85 +0,0 @@
package com.xcs.wx.config;
import com.baomidou.dynamic.datasource.exception.CannotFindDataSourceException;
import com.xcs.wx.domain.vo.ResponseVO;
import com.xcs.wx.exception.BizException;
import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.MyBatisSystemException;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
/**
* @author xcs
* @date 2023年12月25日 17时29分111
* 该类用于统一处理项目中的各类异常，并返回相应的错误信息响应。
* 它通过Spring的 @RestControllerAdvice 注解标记，表明这是一个全局的异常处理类，
* 可以对被 @Controller 或 @RestController 标注的控制器中抛出的异常进行处理。
* 同时，使用 @ResponseStatus(HttpStatus.OK) 注解设置默认的响应状态码为 HttpStatus.OK，
* 表示即使发生异常，响应的HTTP状态码也会被设置为200（具体业务错误信息在响应体中体现）。
**/
@Slf4j
@RestControllerAdvice
@ResponseStatus(HttpStatus.OK)
public class ExceptionAdviceConfig {
/**
* 捕获BizException异常的处理方法。
* 当项目中抛出BizException类型的异常时，该方法会被触发执行。
* @param e 捕获到的BizException异常实例，通过这个参数可以获取异常中的相关信息，比如异常代码和异常消息等。
* @return 返回一个ResponseVO<String>类型的对象，用于封装错误信息并返回给客户端，
* 这里调用ResponseVO的error方法，传入从BizException中获取的异常代码（e.getCode()）和异常消息（e.getMsg()）来构造响应信息。
**/
@ExceptionHandler(BizException.class)
public ResponseVO<String> handleException(BizException e) {
return ResponseVO.error(e.getCode(), e.getMsg());
}
/**
* 捕获MyBatisSystemException异常的处理方法。
* 当项目中抛出MyBatisSystemException类型的异常时，会进入该方法进行处理。
* @param e 捕获到的MyBatisSystemException异常实例。
* @return 返回一个ResponseVO<String>类型的对象，根据异常的具体原因构造不同的错误信息返回给客户端。
**/
@ExceptionHandler(MyBatisSystemException.class)
public ResponseVO<String> myBatisSystemException(MyBatisSystemException e) {
// 数据库未就绪状态
// 判断异常原因链中最底层的异常是否是CannotFindDataSourceException类型，
// 如果是，则说明是因为找不到数据源导致的数据库未就绪问题。
if (e.getCause().getCause() instanceof CannotFindDataSourceException) {
return ResponseVO.error(-1, "微信数据库未就绪状态,请先点击左侧解密工具进行数据解密！");
}
// 如果不是上述特定的数据源找不到的情况，就记录下该MyBatisSystemException异常的详细信息到日志中（通过log对象，由lombok的@Slf4j注解生成）。
log.error("mybatis system exception", e);
// 然后统一返回一个表示系统异常的通用错误信息响应给客户端。
return ResponseVO.error(-1, "系统异常");
}
/**
* 捕获RuntimeException异常的处理方法。
* RuntimeException是Java中运行时异常的基类，该方法用于处理项目运行过程中抛出的所有未被显式捕获的运行时异常。
* @param e 捕获到的RuntimeException异常实例。
* @return 返回一个ResponseVO<String>类型的对象，先将RuntimeException异常的详细信息记录到日志中，
* 再返回一个表示系统异常的通用错误信息响应给客户端。
**/
@ExceptionHandler(RuntimeException.class)
public ResponseVO<String> handleException(RuntimeException e) {
log.error("runtime exception", e);
return ResponseVO.error(-1, "系统异常");
}
/**
* 捕获Exception异常的处理方法。
* Exception是所有异常的基类（除了Error及其子类），该方法可以捕获项目中几乎所有类型的异常，
* 是一种兜底的异常处理方式，确保即使出现未预料到的异常也能有相应的处理逻辑，返回合适的错误信息给客户端。
* @param e 捕获到的Exception异常实例。
* @return 返回一个ResponseVO<String>类型的对象，先将Exception异常的详细信息记录到日志中，
* 再返回一个表示系统异常的通用错误信息响应给客户端。
**/
@ExceptionHandler(Exception.class)
public ResponseVO<String> handleException(Exception e) {
log.error("exception", e);
return ResponseVO.error(-1, "系统异常");
}
}

39
wx-dump-admin/src/main/java/com/xcs/wx/config/MybatisPlusConfig.java
Unescape View File

@ -1,39 +0,0 @@
package com.xcs.wx.config;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* MybatisPlus配置类，用于对MybatisPlus在当前项目中的相关配置进行设置，
* 例如添加插件等功能，以满足项目与数据库交互过程中的特定需求。
* 该类由作者xcs在2023年12月29日16时10分创建。
*
* @author xcs
* @date 2023年12月29日 16时10分
**/
@Configuration // 表明这个类是一个配置类，Spring会自动扫描并加载这个类中的配置信息
@MapperScan({"com.xcs.wx.mapper"}) // 配置Mybatis的Mapper接口扫描路径，告诉Spring去哪里扫描Mybatis的Mapper接口，
// 这样Spring就能自动创建对应的Mapper代理对象并注入到其他需要使用的地方，此处指定扫描 "com.xcs.wx.mapper" 包下的所有Mapper接口
public class MybatisPlusConfig {
/**
* 添加分页插件的方法，通过Spring的 @Bean 注解将返回的对象注册为一个Bean，使其可以被Spring容器管理并在需要的地方进行依赖注入。
* 这个方法创建并配置了MybatisPlus的拦截器，用于实现分页功能。
*
* @return MybatisPlusInterceptor对象，包含了配置好的分页拦截器，用于在MybatisPlus执行数据库操作时拦截并处理分页相关逻辑
*/
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
// 创建一个MybatisPlusInterceptor对象，它是MybatisPlus用于添加各种拦截器的总拦截器，多个拦截器可以通过它来统一管理和添加
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 向MybatisPlusInterceptor中添加一个分页拦截器（PaginationInnerInterceptor），用于处理分页相关的逻辑。
// 这里指定了数据库类型为SQLITE，意味着这个分页插件会针对SQLITE数据库的特点来进行分页操作，
// 如果后续切换数据库，此处的数据库类型参数也需要相应修改以适配新的数据库分页语法等情况。
interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.SQLITE));
return interceptor;
}
}

34
wx-dump-admin/src/main/java/com/xcs/wx/config/UseStaticResourceConfig.java
Unescape View File

@ -1,34 +0,0 @@
package com.xcs.wx.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
/**
* 该类用于配置Spring Web MVC相关的静态资源处理逻辑，
* 通过实现WebMvcConfigurer接口来自定义配置，作者为xcs，创建于2024年01月26日11时46分。
*
* @author xcs
* @date 2024年01月26日11时46分
**/
@Configuration // 表明这是一个Spring配置类，Spring容器会扫描并加载该类，识别其中定义的Bean以及配置信息。
@EnableWebMvc // 启用Spring Web MVC的功能，它会导入一系列默认的配置，使得开发者可以更加灵活地定制Web相关的配置内容，
// 例如视图解析、消息转换器等，不过使用这个注解时需要注意可能会覆盖掉Spring Boot的一些自动配置内容，通常用于需要完全自定义Web配置的场景。
public class UseStaticResourceConfig implements WebMvcConfigurer {
/**
* 重写WebMvcConfigurer接口中的addResourceHandlers方法，用于配置静态资源的处理器和对应资源的位置。
* 通过该方法可以告诉Spring MVC去哪里查找和加载静态资源，使得在Web应用中可以正确访问到如HTML、CSS、JavaScript等静态文件。
*
* @param registry ResourceHandlerRegistry对象，用于注册资源处理器以及对应的资源位置，通过它来添加静态资源的处理规则。
*/
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
// 向ResourceHandlerRegistry中添加一个资源处理器的配置规则。
// addResourceHandler("/**")表示对所有路径（即任意请求路径）下的请求进行处理，匹配所有的URL路径模式。
// addResourceLocations("file:../html/")指定了静态资源的实际位置，这里是相对路径，表示在项目的上级目录中的html文件夹下查找对应的静态资源文件，
// 例如当浏览器请求某个静态页面时，Spring MVC会根据这个配置去指定的位置查找并返回相应的文件内容，从而实现静态资源的正确加载和展示。
registry.addResourceHandler("/**").addResourceLocations("file:../html/");
}
}

49
wx-dump-admin/src/main/java/com/xcs/wx/config/WeChatOffsetProperties.java
Unescape View File

@ -1,49 +0,0 @@
package com.xcs.wx.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import java.util.Map;
/**
* 微信参数偏移量配置类，用于配置微信相关不同版本下各个参数的偏移量信息，
* 通过Spring的相关机制可以方便地从配置文件中读取并绑定对应属性的值，
* 由作者xcs在2023年12月25日10时05分创建。
*
* @author xcs
* @date 2023年12月25日10时05分
**/
@Data
// 使用Lombok的 @Data 注解，会自动为类生成Getter、Setter、toString、equals和hashCode等方法，简化代码编写，减少样板代码量。
@Configuration(proxyBeanMethods = false)
// 表明这个类是一个Spring配置类，但将proxyBeanMethods设置为false，意味着在创建该类的Bean实例时，
// 不会为其创建基于CGLIB的代理对象（除非有其他明确需要代理的情况），这样可以提高性能，避免不必要的代理开销，
// 适用于配置类中的方法只是简单返回配置相关对象，不存在方法调用间依赖关系的场景。
@ConfigurationProperties(prefix = "wechat-offset")
// 该注解用于将配置文件（如application.properties或application.yml等）中以 "wechat-offset" 为前缀的属性值绑定到这个类对应的属性上，
// 方便进行配置的集中管理和注入使用。
public class WeChatOffsetProperties {
/**
* 微信各个版本对应的偏移量配置，通过一个Map来存储，
* 其中键为微信版本号（通常是字符串形式的版本标识），值为对应的VersionConfig类型对象，
* 该对象包含了特定版本下不同参数的偏移量信息。
*/
private Map<String, VersionConfig> version;
/**
* VersionConfig内部类，用于封装微信特定版本下具体参数的偏移量信息，
* 同样借助Lombok的 @Data 注解自动生成常用方法。
*/
@Data
public static class VersionConfig {
// 对应微信昵称参数在特定版本下的偏移量，以Long类型存储，具体偏移量数值应该从配置文件中读取并绑定过来，
// 偏移量的含义可能与微信数据存储结构、解析相关，用于在处理微信数据时进行相应的位置调整等操作（取决于具体业务场景）。
private Long nickname;
// 对应微信账号参数在特定版本下的偏移量，功能类似上述昵称偏移量，用于账号相关数据处理时的位置或数值调整等情况。
private Long account;
// 对应微信手机号参数在特定版本下的偏移量，用于手机号相关数据在特定版本下的适配处理。
private Long mobile;
}
}

24
wx-dump-admin/src/main/java/com/xcs/wx/constant/ChatRoomConstant.java
Unescape View File

@ -1,24 +0,0 @@
package com.xcs.wx.constant;
/**
* ChatRoomConstant类，用于定义与群聊相关的常量。
* 在整个项目中，如果涉及到群聊相关的逻辑判断、数据处理等操作，
* 可以使用这里定义的常量来保证代码的一致性以及提高代码的可读性和可维护性。
* 该类由作者xcs在2024年01月25日16时34分创建。
*
* @author xcs
* @date 2024年01月25日16时34分
**/
public class ChatRoomConstant {
// 将构造函数设置为私有，这样外部就无法通过 new 关键字来实例化这个类，
// 因为这个类的作用只是用来定义常量，不需要创建它的实例对象，符合常量类的设计规范。
private ChatRoomConstant() {
}
// 定义一个公共的静态常量字符串，名为 CHATROOM_SUFFIX，其值为 "@chatroom"。
// 从命名来看，这个常量可能用于标识群聊相关的一些特征，比如在处理聊天对象名称、消息发送目标等场景中，
// 通过判断是否包含这个后缀来确定是不是群聊相关的操作或者对象，方便在整个项目的群聊相关业务逻辑中统一使用。
public static final String CHATROOM_SUFFIX = "@chatroom";
}

142
wx-dump-admin/src/main/java/com/xcs/wx/constant/DataSourceType.java
Unescape View File

@ -1,142 +0,0 @@
package com.xcs.wx.constant;
import cn.hutool.extra.spring.SpringUtil;
import com.baomidou.dynamic.datasource.DynamicRoutingDataSource;
import com.xcs.wx.service.UserService;
import javax.sql.DataSource;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* 数据源类型枚举类，用于定义项目中各种不同的数据源名称相关的常量，
* 同时提供了一些方法来根据特定规则获取相关的数据源名称列表，方便在数据库操作等相关业务逻辑中使用，
* 由作者xcs在2023年12月25日16时41分创建。
*
* @author xcs
* @date 2023年12月25日16时41分
**/
public class DataSourceType {
// 定义一个表示小程序数据库的常量字符串，其值为 "Applet.db"，
// 在涉及到小程序相关数据存储和查询等操作时，可通过该常量来指定对应的数据源。
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相关的数据库名称列表的方法，该方法会尝试获取当前用户信息，
* 根据用户信息构建匹配模式，进而筛选出符合要求的数据库名称列表。
* 如果获取当前用户信息失败（返回null），则返回一个空的列表。
*
* @return 符合MSG*.db模式的数据库名称列表，如果当前用户信息为空则返回空列表
*/
public static List<String> getMsgDb() {
// 通过SpringUtil工具类从Spring容器中获取UserService的实例，
// 并调用其currentUser方法获取当前用户信息（这里假设currentUser方法返回的是用户的唯一标识，比如用户ID等）。
String wxId = SpringUtil.getBean(UserService.class).currentUser();
// 进行空校验，如果获取到的用户标识为null，说明无法确定当前用户，
// 此时直接返回一个空的列表，避免后续操作出现空指针异常等问题。
if (wxId == null) {
return Collections.emptyList();
}
// 如果用户标识不为空，则调用私有方法getDb，传入根据用户标识构建的匹配模式字符串，获取符合要求的数据库名称列表。
return getDb(wxId + "#" + "MSG.*\\.db");
}
/**
* 根据给定的模式字符串匹配数据库名称的私有方法，
* 它从Spring容器中获取动态数据源对象，获取所有数据源的名称集合，
* 然后筛选出符合给定模式的数据源名称，并按照自然顺序（字典序）进行降序排序后返回。
*
* @param pattern 需要匹配的字符串模式，通常是类似正则表达式的形式，用于筛选数据源名称
* @return 符合给定模式的数据库名称列表，已按自然顺序降序排序
*/
private static List<String> getDb(String pattern) {
// 通过SpringUtil工具类从Spring容器中获取DynamicRoutingDataSource的实例，
// 该数据源类型支持动态切换数据源，用于获取项目中配置的所有数据源相关信息。
DynamicRoutingDataSource dynamicRoutingDataSource = SpringUtil.getBean(DynamicRoutingDataSource.class);
// 调用DynamicRoutingDataSource的getDataSources方法获取所有已配置的数据源，
// 返回一个Map，其中键为数据源名称，值为对应的javax.sql.DataSource对象。
Map<String, DataSource> dataSources = dynamicRoutingDataSource.getDataSources();
// 使用Java 8的Stream API对数据源名称集合（keySet）进行操作，
// 首先通过filter方法筛选出名称符合给定模式（使用matches方法进行正则匹配）的数据源名称，
// 然后使用sorted方法按照自然顺序（Comparator.naturalOrder()）进行降序排序，
// 最后通过collect方法将筛选并排序后的数据源名称收集到一个List中并返回。
return dataSources.keySet().stream()
.filter(key -> key.matches(pattern))
.sorted(Comparator.naturalOrder())
.collect(Collectors.toList());
}
}

28
wx-dump-admin/src/main/java/com/xcs/wx/constant/SqliteConstant.java
Unescape View File

@ -1,28 +0,0 @@
package com.xcs.wx.constant;
/**
* SqliteConstant类，用于定义与SQLite数据库相关的常量。
* 在项目中涉及到与SQLite数据库进行连接、配置等操作时，
* 可以使用这里定义的常量来保证代码的一致性，提高代码的可读性和可维护性，
* 该类由作者xcs在2024年1月20日21时12分51秒创建。
*
* @author xcs
* @date 2024年1月20日21:12:51
*/
public class SqliteConstant {
/**
* 定义一个公共的静态常量字符串，表示SQLite数据库连接URL的前缀。
* 在构建SQLite数据库连接字符串时，通常会以这个前缀开头，
* 后面跟上具体的数据库文件路径等信息，以此来标识这是一个指向SQLite数据库的连接请求。
*/
public static final String URL_PREFIX = "jdbc:sqlite:";
/**
* 定义一个公共的静态常量字符串，用于指定SQLite数据库的驱动类名称。
* 当使用Java的JDBC（Java Database Connectivity）来连接SQLite数据库时，
* 需要加载对应的驱动类，这里定义的常量就是该驱动类的全限定类名，
* 方便在配置数据库连接相关代码中统一引用，确保正确加载驱动来建立与SQLite数据库的连接。
*/
public static final String DRIVER_CLASS_NAME = "org.sqlite.JDBC";
}

95
wx-dump-admin/src/main/java/com/xcs/wx/controller/ChatRoomController.java
Unescape View File

@ -1,95 +0,0 @@
package com.xcs.wx.controller;
import com.xcs.wx.domain.dto.ChatRoomDTO;
import com.xcs.wx.domain.vo.ChatRoomDetailVO;
import com.xcs.wx.domain.vo.ChatRoomVO;
import com.xcs.wx.domain.vo.PageVO;
import com.xcs.wx.domain.vo.ResponseVO;
import com.xcs.wx.service.ChatRoomService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* ChatRoomController类，作为Spring MVC中的控制器，用于处理与群聊相关的HTTP请求，
* 并调用对应的服务层方法来实现具体的业务逻辑，然后将处理结果以合适的格式返回给客户端，
* 由作者xcs在2024年01月08日16时03分创建。
*
* @author xcs
* @date 2024年01月08日 16时03分
**/
@RestController
// 该注解表明这个类是一个Spring RESTful风格的控制器，意味着它会处理HTTP请求并返回JSON、XML等格式的数据响应，
// 而不是像传统的视图模板那样返回HTML页面。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有带有 @NonNull 注解的final字段或者没有初始化的final字段生成构造函数，
// 在这里它会为下面的 chatRoomService 字段生成对应的构造函数注入，简化了依赖注入的代码编写。
@RequestMapping("/api/chatroom")
// 用于定义该控制器处理的请求的基础路径，所有该控制器中定义的请求映射方法的路径都将基于这个基础路径进行拼接，
// 例如下面的 "/list"、"/detail"、"/export" 等路径实际对应的完整请求路径就是 "/api/chatroom/list"、"/api/chatroom/detail"、"/api/chatroom/export" 等。
public class ChatRoomController {
private final ChatRoomService chatRoomService;
// 通过依赖注入的方式引入ChatRoomService服务层的实例，用于调用服务层提供的与群聊相关的业务方法，
// 比如查询群聊列表、获取群聊详情、导出群聊等操作，具体的业务逻辑实现在ChatRoomService中完成。
/**
* 查询群聊列表的方法，用于处理获取群聊列表的HTTP GET请求，接收一个ChatRoomDTO对象作为查询参数，
* 通过调用服务层的方法获取群聊列表信息，并将结果包装在ResponseVO中返回给客户端。
*
* @param chatRoomDTO 查询参数，包含了各种用于筛选、分页等查询群聊列表的条件信息，
* 例如可能包含页码、每页数量、群聊名称关键词等相关字段，具体取决于业务需求定义。
* @return ResponseVO<List<ChatRoomVO>>，返回一个ResponseVO包装类型，其泛型为ChatRoomVO的列表，
* ResponseVO用于统一封装响应的状态码、消息以及实际的数据内容，方便客户端解析和处理响应结果，
* 这里的ChatRoomVO是用于展示给客户端的群聊信息视图对象，包含了群聊相关的部分关键属性，比如群聊名称、群聊人数等。
*/
@GetMapping("/list")
public ResponseVO<List<ChatRoomVO>> list(ChatRoomDTO chatRoomDTO) {
// 调用ChatRoomService的queryChatRoom方法，传入查询参数chatRoomDTO，
// 该方法会根据传入的查询条件去数据库或者其他数据源中查询符合要求的群聊列表信息，
// 返回的结果包装在PageVO中，PageVO通常用于分页相关的场景，包含了当前页的数据列表、当前页码、总记录数等信息。
PageVO<ChatRoomVO> pageVO = chatRoomService.queryChatRoom(chatRoomDTO);
// 使用ResponseVO的静态方法ok创建一个成功响应的ResponseVO对象，
// 将从PageVO中获取的群聊记录列表（pageVO.getRecords()）、当前页码（pageVO.getCurrent()）以及总记录数（pageVO.getTotal()）作为参数传入，
// 这样就将查询到的群聊列表信息以及分页相关信息一起封装在ResponseVO中返回给客户端了。
return ResponseVO.ok(pageVO.getRecords(), pageVO.getCurrent(), pageVO.getTotal());
}
/**
* 查询群聊详情的方法，处理获取指定群聊详情信息的HTTP GET请求，接收群聊名称作为请求参数，
* 通过调用服务层方法获取对应的群聊详情信息，并包装在ResponseVO中返回给客户端。
*
* @param chatRoomName 群聊名称，作为请求参数，用于唯一标识要查询详情的群聊，客户端通过传递具体的群聊名称来获取该群聊的详细信息，
* 比如群聊的成员列表、创建时间、群公告等详细内容（具体取决于业务中ChatRoomDetailVO的定义）。
* @return ResponseVO<ChatRoomDetailVO>，返回一个ResponseVO包装类型，其泛型为ChatRoomDetailVO，
* ChatRoomDetailVO是包含了群聊详细信息的视图对象，这里将通过服务层查询到的群聊详情信息封装在ResponseVO中返回给客户端，
* 以便客户端展示群聊的详细情况。
*/
@GetMapping("/detail")
public ResponseVO<ChatRoomDetailVO> detail(@RequestParam String chatRoomName) {
// 调用ChatRoomService的queryChatRoomDetail方法，传入群聊名称chatRoomName，
// 该方法会根据传入的群聊名称去查找对应的群聊详细信息，返回一个ChatRoomDetailVO对象，
// 然后使用ResponseVO的静态方法ok创建一个成功响应的ResponseVO对象，将查询到的群聊详情对象作为参数传入，
// 最终将包含群聊详情信息的ResponseVO返回给客户端。
return ResponseVO.ok(chatRoomService.queryChatRoomDetail(chatRoomName));
}
/**
* 导出群聊的方法，处理执行群聊导出操作的HTTP GET请求，
* 通过调用服务层方法执行群聊导出的业务逻辑，并将导出结果的相关信息（比如导出文件的路径、导出状态等，此处假设返回的是一个字符串表示相关信息）包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<String>，返回一个ResponseVO包装类型，其泛型为String，
* 这里将服务层执行群聊导出操作后返回的相关结果信息（以字符串形式）封装在ResponseVO中返回给客户端，
* 客户端可以根据返回的信息来判断导出是否成功以及获取相关的导出结果内容（比如提示用户去哪里下载导出文件等）。
*/
@GetMapping("/export")
public ResponseVO<String> export() {
return ResponseVO.ok(chatRoomService.exportChatRoom());
}
}

98
wx-dump-admin/src/main/java/com/xcs/wx/controller/ContactController.java
Unescape View File

@ -1,98 +0,0 @@
package com.xcs.wx.controller;
import com.xcs.wx.domain.dto.ContactDTO;
import com.xcs.wx.domain.vo.*;
import com.xcs.wx.service.ContactService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* ContactController类，作为Spring MVC框架中的控制器，用于处理与联系人相关的HTTP请求，
* 并借助ContactService服务层来实现具体的业务逻辑，最后将处理结果以合适的格式返回给客户端，
* 由作者xcs在2023年12月22日14时16分创建。
*
* @author xcs
* @date 2023年12月22日 14时16分
**/
@RestController
// 该注解表明这个类是一个Spring RESTful风格的控制器，意味着它主要用于处理HTTP请求并返回JSON、XML等格式的数据响应，
// 而不是像传统的MVC模式那样返回视图模板（如HTML页面）。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 在这里就是为下面的contactService字段生成对应的构造函数注入，使得Spring容器可以通过构造函数注入的方式将ContactService的实例注入进来，简化了依赖注入的代码编写。
@RequestMapping("/api/contact")
// 用于定义该控制器所处理请求的基础路径，后续在这个控制器中定义的各个请求映射方法的路径都会基于这个基础路径进行拼接，
// 例如下面的 "/list"、"/all"、"/label"、"/export" 这些路径对应的完整请求路径就是 "/api/contact/list"、"/api/contact/all"、"/api/contact/label"、"/api/contact/export" 等。
public class ContactController {
private final ContactService contactService;
// 通过依赖注入的方式引入ContactService的实例，ContactService是服务层的接口或者类，它封装了与联系人相关的各种业务逻辑方法，
// 例如查询联系人、获取所有联系人、查询联系人标签以及导出联系人等操作，具体的业务实现细节在ContactService及其实现类中完成。
/**
* 查询联系人的方法，用于处理获取联系人列表的HTTP GET请求，接收一个ContactDTO对象作为请求参数，
* 通过调用ContactService的相关方法查询联系人信息，并将结果包装在ResponseVO中返回给客户端。
*
* @param contactDTO 请求参数，它是一个数据传输对象（DTO），通常包含了用于筛选、分页等查询联系人的条件信息，
* 比如可能包含查询关键字、页码、每页显示数量等字段，具体的字段内容取决于业务需求中对联系人查询条件的定义。
* @return ResponseVO<List<ContactVO>>，返回一个ResponseVO包装类型，其泛型是ContactVO的列表，
* ResponseVO用于统一封装响应的状态码、提示消息以及实际的数据内容，方便客户端统一解析和处理响应结果，
* 这里的ContactVO是用于展示给客户端的联系人信息视图对象，包含了联系人相关的部分关键属性，例如联系人姓名、头像、联系方式等（具体属性依业务定义）。
*/
@GetMapping("/list")
public ResponseVO<List<ContactVO>> list(ContactDTO contactDTO) {
// 调用ContactService的queryContact方法，传入ContactDTO对象作为查询条件，
// 该方法会依据传入的条件去数据库或者其他数据源中查找符合要求的联系人信息，返回的结果包装在PageVO中，
// PageVO通常用于分页相关的场景，它包含了当前页的数据记录列表（这里就是联系人信息列表）、当前页码以及总记录数等信息。
PageVO<ContactVO> pageVO = contactService.queryContact(contactDTO);
// 使用ResponseVO的静态方法ok创建一个表示成功响应的ResponseVO对象，
// 并将从PageVO中获取的联系人记录列表（pageVO.getRecords()）、当前页码（pageVO.getCurrent()）以及总记录数（pageVO.getTotal()）作为参数传入，
// 这样就把查询到的联系人列表信息以及分页相关信息一起封装进ResponseVO中返回给客户端了。
return ResponseVO.ok(pageVO.getRecords(), pageVO.getCurrent(), pageVO.getTotal());
}
/**
* 查询所有联系人的方法，用于处理获取全部联系人信息的HTTP GET请求，
* 该方法会调用ContactService的queryAllContact方法获取所有联系人信息，并将结果包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<List<AllContactVO>>，返回一个ResponseVO包装类型，其泛型为AllContactVO的列表，
* AllContactVO同样是用于展示联系人信息的视图对象，但可能与ContactVO在包含的属性等方面有所不同，
* 具体取决于业务中对查询所有联系人时需要返回的信息的定义，这里将通过服务层查询到的所有联系人信息封装在ResponseVO中返回给客户端。
*/
@GetMapping("/all")
public ResponseVO<List<AllContactVO>> all() {
return ResponseVO.ok(contactService.queryAllContact());
}
/**
* 查询联系人标签的方法，用于处理获取联系人标签信息的HTTP GET请求，
* 通过调用ContactService的queryContactLabel方法获取联系人标签信息，并将结果包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<List<ContactLabelVO>>，返回一个ResponseVO包装类型，其泛型为ContactLabelVO的列表，
* ContactLabelVO是用于展示联系人标签信息的视图对象，包含了标签的名称、相关联系人数量等属性（具体依业务定义），
* 这里把通过服务层查询到的联系人标签信息封装在ResponseVO中返回给客户端，方便客户端展示和处理联系人标签相关内容。
*/
@GetMapping("/label")
public ResponseVO<List<ContactLabelVO>> label() {
return ResponseVO.ok(contactService.queryContactLabel());
}
/**
* 导出联系人的方法，用于处理执行联系人导出操作的HTTP GET请求，
* 通过调用ContactService的exportContact方法执行联系人导出的业务逻辑，并将导出结果相关信息（比如导出文件的路径、导出状态等，此处假设以字符串形式表示）包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<String>，返回一个ResponseVO包装类型，其泛型为String，
* 这里将服务层执行联系人导出操作后返回的相关结果信息封装在ResponseVO中返回给客户端，
* 客户端可以依据返回的信息来判断联系人导出是否成功以及获取相关的导出结果内容（例如提示用户去哪里下载导出的联系人文件等）。
*/
@GetMapping("/export")
public ResponseVO<String> export() {
return ResponseVO.ok(contactService.exportContact());
}
}

82
wx-dump-admin/src/main/java/com/xcs/wx/controller/ContactHeadImgController.java
Unescape View File

@ -1,82 +0,0 @@
package com.xcs.wx.controller;
import com.xcs.wx.service.ContactHeadImgService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
/**
* ContactHeadImgController类，作为Spring MVC框架下的控制器，主要负责处理与联系人头像相关的HTTP请求，
* 通过调用ContactHeadImgService服务层提供的方法来获取联系人头像数据，并将其正确地返回给客户端，
* 由作者xcs在2024年6月18日15时45分17秒创建。
*
* @author xcs
* @date 2024年6月18日15:45:17
**/
@Slf4j
// 使用Lombok的 @Slf4j 注解，会自动为该类生成一个名为log的SLF4J日志记录器对象，方便在代码中记录日志信息，
// 例如记录操作的执行情况、出现的错误等，便于后续的调试和问题排查。
@RestController
// 该注解表明这个类是一个Spring RESTful风格的控制器，意味着它主要用来处理HTTP请求，并以JSON、XML等格式或者直接返回数据（如这里的图片字节流）来响应请求，
// 而不是像传统的MVC模式那样返回视图页面（如HTML页面）。
@RequiredArgsConstructor
// 借助Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 在这里就是为下面的contactHeadImgService字段生成对应的构造函数注入，使得Spring容器可以通过构造函数注入的方式将ContactHeadImgService的实例注入进来，简化了依赖注入相关的代码编写。
@RequestMapping("/api/contact/headImg")
// 用于定义该控制器所处理请求的基础路径，后续在此控制器内定义的各个请求映射方法对应的完整请求路径都基于这个基础路径进行拼接，
// 例如下面的 "/avatar" 路径对应的完整请求路径就是 "/api/contact/headImg/avatar"，用于明确该控制器下不同接口的访问路径。
public class ContactHeadImgController {
private final ContactHeadImgService contactHeadImgService;
// 通过依赖注入的方式引入ContactHeadImgService的实例，ContactHeadImgService是服务层的接口或类，它封装了获取联系人头像相关的业务逻辑方法，
// 例如根据用户名等条件查找并返回对应的联系人头像数据，具体的业务实现细节在ContactHeadImgService及其实现类中完成。
/**
* avatar方法，用于处理获取指定用户头像的HTTP GET请求，接收用户名和HttpServletResponse对象作为参数，
* 通过调用服务层方法获取用户头像的字节数据，并将其以合适的格式通过HttpServletResponse返回给客户端，
* 如果获取头像数据失败，则返回相应的错误状态码给客户端。
*
* @param userName 用户名，作为请求参数，用于唯一标识要获取头像的用户，服务层会依据这个用户名去查找对应的头像数据，
* 客户端通过传递具体的用户名来请求获取该用户的头像信息。
* @param response HttpServletResponse对象，用于设置响应的相关属性（如内容类型、内容长度等）以及输出响应数据（头像字节流）给客户端，
* 是与HTTP响应相关操作的关键对象，比如设置响应头信息、向客户端发送响应内容等都通过它来完成。
*/
@GetMapping("/avatar")
public void avatar(String userName, HttpServletResponse response) {
// 调用ContactHeadImgService的avatar方法，传入用户名userName，尝试获取该用户对应的头像字节数据，
// 如果获取成功，返回的avatarBytes就是头像的字节数组形式的数据，否则返回null，表示未找到对应的头像数据。
byte[] avatarBytes = contactHeadImgService.avatar(userName);
if (avatarBytes!= null) {
// 设置响应的内容类型为 "image/gif"，表示返回给客户端的数据是GIF格式的图片，
// 这里假设头像数据是GIF格式，如果实际情况中头像格式有多种可能，可能需要根据头像实际格式进行更灵活的设置。
response.setContentType("image/gif");
// 设置响应内容的长度，即头像字节数组的长度，让客户端能够准确知道接收的数据大小，便于正确处理数据。
response.setContentLength(avatarBytes.length);
try (OutputStream os = response.getOutputStream()) {
// 通过从HttpServletResponse获取的输出流对象，将头像字节数据写入到输出流中，
// 这样数据就会通过HTTP响应发送给客户端，客户端接收到数据后可以根据设置的内容类型进行相应的展示（如在页面上显示图片）。
os.write(avatarBytes);
// 刷新输出流，确保数据被及时、完整地发送出去，避免数据滞留在缓冲区中未发送的情况。
os.flush();
} catch (IOException e) {
// 如果在向输出流写入数据或者刷新输出流等操作过程中出现IO异常，
// 使用自动生成的日志记录器log记录错误信息，方便后续排查问题，
// "avatar fail" 是自定义的错误提示信息，用于简单描述出现问题的操作，e是捕获到的具体IOException异常对象，会记录详细的异常堆栈信息。
log.error("avatar fail", e);
}
} else {
// 如果未获取到头像字节数据（avatarBytes为null），则设置HTTP响应的状态码为404（HttpServletResponse.SC_NOT_FOUND），
// 表示客户端请求的资源（这里就是指定用户的头像）未找到，告知客户端请求的头像不存在，让客户端做出相应的处理（如显示默认头像等）。
response.setStatus(HttpServletResponse.SC_NOT_FOUND);
}
}
}

107
wx-dump-admin/src/main/java/com/xcs/wx/controller/DashboardController.java
Unescape View File

@ -1,107 +0,0 @@
package com.xcs.wx.controller;
import com.xcs.wx.domain.vo.*;
import com.xcs.wx.service.DashboardService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* DashboardController类，作为Spring MVC框架下的控制器，主要负责处理与仪表盘相关的HTTP请求，
* 通过调用DashboardService服务层提供的各种业务方法来获取相应的数据，并将这些数据以合适的格式封装在ResponseVO中返回给客户端，
* 由作者xcs在2024年01月15日11时26分创建。
*
* @author xcs
* @date 2024年01月15日 11时26分
**/
@RestController
// 该注解表明这个类是一个Spring RESTful风格的控制器，意味着它主要用于处理HTTP请求，并返回JSON、XML等格式的数据响应，
// 而不是像传统的MVC模式那样返回视图页面（如HTML页面），适用于构建前后端分离项目中的接口层。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 在这里就是为下面的dashBoardService字段生成对应的构造函数注入，使得Spring容器能够通过构造函数注入的方式将DashboardService的实例注入进来，简化了依赖注入的代码编写。
@RequestMapping("/api/dashboard")
// 用于定义该控制器所处理请求的基础路径，后续在此控制器内定义的各个请求映射方法对应的完整请求路径都基于这个基础路径进行拼接，
// 例如下面的 "/statsPanel"、"/msgTypeDistribution" 等路径对应的完整请求路径就是 "/api/dashboard/statsPanel"、"/api/dashboard/msgTypeDistribution" 等，
// 以此来清晰地划分和组织不同功能接口的访问路径。
public class DashboardController {
private final DashboardService dashBoardService;
// 通过依赖注入的方式引入DashboardService的实例，DashboardService是服务层的接口或类，它封装了与仪表盘相关的各种业务逻辑方法，
// 例如获取统计面板数据、消息类型分布统计数据、不同时间段消息数量统计数据以及联系人互动频率统计数据等，具体的业务实现细节在DashboardService及其实现类中完成。
/**
* statsPanel方法，用于处理获取统计面板数据的HTTP GET请求，
* 通过调用DashboardService的statsPanel方法获取相应数据，并将其封装在ResponseVO中返回给客户端。
*
* @return ResponseVO<StatsPanelVO>，返回一个ResponseVO包装类型，其泛型为StatsPanelVO，
* ResponseVO用于统一封装响应的状态码、提示消息以及实际的数据内容，方便客户端统一解析和处理响应结果，
* StatsPanelVO是用于展示统计面板相关信息的视图对象，具体包含哪些属性取决于业务中对统计面板展示内容的定义，
* 例如可能包含总消息数、总联系人数量、各类消息占比等综合统计信息，这里将通过服务层获取到的统计面板数据封装在ResponseVO中返回给客户端。
*/
@GetMapping("/statsPanel")
public ResponseVO<StatsPanelVO> statsPanel() {
return ResponseVO.ok(dashBoardService.statsPanel());
}
/**
* msgTypeDistribution方法，用于处理获取微信消息类型及其分布统计数据的HTTP GET请求，
* 通过调用DashboardService的msgTypeDistribution方法获取相应数据，并将其封装在ResponseVO中返回给客户端。
*
* @return ResponseVO<List<MsgTypeDistributionVO>>，返回一个ResponseVO包装类型，其泛型为MsgTypeDistributionVO的列表，
* MsgTypeDistributionVO是用于展示微信消息类型及其分布情况的视图对象，包含消息类型名称、该类型消息数量、占比等属性（具体依业务定义），
* 这里的列表表示可以包含多种消息类型的分布统计信息，将通过服务层获取到的消息类型分布数据封装在ResponseVO中返回给客户端，
* 方便客户端展示微信消息在不同类型下的分布情况，例如文本消息、图片消息、语音消息等各自的数量占比情况。
*/
@GetMapping("/msgTypeDistribution")
public ResponseVO<List<MsgTypeDistributionVO>> msgTypeDistribution() {
return ResponseVO.ok(dashBoardService.msgTypeDistribution());
}
/**
* countRecentMsgs方法，用于处理获取统计过去15天每天的发送和接收消息数量数据的HTTP GET请求，
* 通过调用DashboardService的countRecentMsgs方法获取相应数据，并将其封装在ResponseVO中返回给客户端。
*
* @return ResponseVO<List<CountRecentMsgsVO>>，返回一个ResponseVO包装类型，其泛型为CountRecentMsgsVO的列表，
* CountRecentMsgsVO是用于展示每天消息数量情况的视图对象，包含日期以及对应的发送消息数量、接收消息数量等属性（具体依业务定义），
* 这里的列表可以呈现过去15天内每天的消息数量变化情况，将通过服务层获取到的相应数据封装在ResponseVO中返回给客户端，
* 便于客户端展示消息数量随时间的变化趋势，比如查看近期消息活跃度的波动情况。
*/
@GetMapping("/countRecentMsgs")
public ResponseVO<List<CountRecentMsgsVO>> countRecentMsgs() {
return ResponseVO.ok(dashBoardService.countRecentMsgs());
}
/**
* topContacts方法，用于处理获取最近一个月内微信互动最频繁的前10位联系人数据的HTTP GET请求，
* 通过调用DashboardService的topContacts方法获取相应数据，并将其封装在ResponseVO中返回给客户端。
*
* @return ResponseVO<List<TopContactsVO>>，返回一个ResponseVO包装类型，其泛型为TopContactsVO的列表，
* TopContactsVO是用于展示联系人互动频率排名情况的视图对象，包含联系人名称、互动次数等属性（具体依业务定义），
* 这里的列表展示了互动最频繁的前10位联系人信息，将通过服务层获取到的相关数据封装在ResponseVO中返回给客户端，
* 方便客户端展示在近期内与哪些联系人互动较为频繁，例如可以用于分析重要联系人或者社交活跃度等情况。
*/
@GetMapping("/topContacts")
public ResponseVO<List<TopContactsVO>> topContacts() {
return ResponseVO.ok(dashBoardService.topContacts());
}
/**
* queryRecentUsedKeyWord方法，用于处理获取查询最近使用的关键字数据的HTTP GET请求，
* 通过调用DashboardService的queryRecentUsedKeyWord方法获取相应数据，并将其封装在ResponseVO中返回给客户端。
*
* @return ResponseVO<List<RecentUsedKeyWordVO>>，返回一个ResponseVO包装类型，其泛型为RecentUsedKeyWordVO的列表，
* RecentUsedKeyWordVO是用于展示最近使用关键字情况的视图对象，包含关键字内容、使用次数等属性（具体依业务定义），
* 这里的列表可以呈现出近期内用户在微信中经常使用的关键字信息，将通过服务层获取到的相应数据封装在ResponseVO中返回给客户端，
* 有助于分析用户的搜索习惯、关注热点等情况，例如查看用户经常搜索的话题或者联系人等关键字内容。
*/
@GetMapping("/queryRecentUsedKeyWord")
public ResponseVO<List<RecentUsedKeyWordVO>> queryRecentUsedKeyWord() {
return ResponseVO.ok(dashBoardService.queryRecentUsedKeyWord());
}
}

104
wx-dump-admin/src/main/java/com/xcs/wx/controller/DatabaseController.java
Unescape View File

@ -1,104 +0,0 @@
package com.xcs.wx.controller;
import cn.hutool.system.SystemUtil;
import com.xcs.wx.domain.dto.DecryptDTO;
import com.xcs.wx.domain.vo.DatabaseVO;
import com.xcs.wx.domain.vo.ResponseVO;
import com.xcs.wx.service.DatabaseService;
import lombok.RequiredArgsConstructor;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import java.io.IOException;
import java.util.List;
/**
* DatabaseController类，作为Spring MVC框架下的控制器，主要负责处理与数据库相关的HTTP请求，
* 例如数据库解密以及获取数据库相关信息等操作，通过调用DatabaseService服务层的方法来实现具体业务逻辑，
* 并将处理结果以合适的形式（如SseEmitter或ResponseVO包装的形式）返回给客户端，由作者xcs在2024年01月20日14时35分创建。
*
* @author xcs
* @date 2024年01月20日 14时35分
**/
@RestController
// 该注解表明这个类是一个Spring RESTful风格的控制器，意味着它主要用于处理HTTP请求，并返回JSON、XML等格式的数据响应，
// 而不是像传统的MVC模式那样返回视图页面（如HTML页面），适用于构建前后端分离项目中的接口层。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 在这里就是为下面的databaseService字段生成对应的构造函数注入，使得Spring容器能够通过构造函数注入的方式将DatabaseService的实例注入进来，简化了依赖注入的代码编写。
@RequestMapping("/api/database")
// 用于定义该控制器所处理请求的基础路径，后续在此控制器内定义的各个请求映射方法对应的完整请求路径都基于这个基础路径进行拼接，
// 例如下面的 "/decrypt"、"/getDatabase" 路径对应的完整请求路径就是 "/api/database/decrypt"、"/api/database/getDatabase" 等，
// 以此来清晰地划分和组织不同功能接口的访问路径。
public class DatabaseController {
private final DatabaseService databaseService;
// 通过依赖注入的方式引入DatabaseService的实例，DatabaseService是服务层的接口或类，它封装了与数据库操作相关的各种业务逻辑方法，
// 比如数据库解密的具体逻辑、获取数据库相关信息等操作，具体的业务实现细节在DatabaseService及其实现类中完成。
/**
* decrypt方法，用于处理数据库解密的HTTP GET请求，它采用了服务器推送事件（Server-Sent Events，SSE）机制，
* 通过创建一个SseEmitter对象来异步地向客户端推送解密过程中的相关消息和最终结果，同时会先检查JDK版本是否满足要求，
* 若不满足则向客户端返回相应的错误提示信息，并结束SseEmitter的推送流程。
*
* @param decryptDTO 一个数据传输对象（DTO），用于传递数据库解密相关的参数信息，例如可能包含数据库加密密钥、要解密的数据库标识等具体的解密相关数据，
* 具体的字段内容取决于业务中对数据库解密操作所需参数的定义。
* @return SseEmitter，返回一个SseEmitter对象，客户端可以通过该对象监听服务器推送的事件消息，以获取数据库解密过程中的进度信息或者最终结果，
* 这种异步推送的方式适用于解密操作可能耗时较长的情况，避免客户端长时间等待而出现请求超时等问题。
*/
@GetMapping("/decrypt")
public SseEmitter decrypt(DecryptDTO decryptDTO) {
// 创建一个SseEmitter对象，传入超时时间为0L，表示无超时限制（也可根据实际需求设置合适的超时时间），
// 该对象用于向客户端发送服务器推送事件，可用于实时推送数据库解密过程中的状态信息等内容给客户端。
SseEmitter emitter = new SseEmitter(0L);
// 启动一个新的线程来执行异步操作，这样可以避免在主线程中执行耗时的数据库解密操作而阻塞其他请求的处理，
// 使得整个服务能够更高效地处理多个并发请求，提高系统的响应性能。
new Thread(() -> {
// 通过hutool工具库的SystemUtil获取当前JDK的版本信息，并获取其版本号对应的整数值，
// 用于判断当前JDK版本是否满足数据库解密操作的要求（这里要求JDK版本至少为11）。
if (SystemUtil.getJavaInfo().getVersionInt() < 1100) {
try {
// 如果JDK版本小于1100（对应JDK 11），则通过SseEmitter向客户端发送一个错误提示信息，
// 消息格式设置为JSON（通过MediaType.APPLICATION_JSON指定），告知客户端微信解密必须要求JDK 11以上版本，请更换JDK版本。
emitter.send(ResponseVO.error(-1, "微信解密必须要求JDK11以上版本,请更换JDK版本。"), MediaType.APPLICATION_JSON);
} catch (IOException e) {
// 如果在向客户端发送消息过程中出现IO异常，将该异常包装成一个运行时异常抛出，
// 这样在当前线程中就会终止执行，并可以在合适的地方（比如线程的异常处理机制或者日志记录中）进行相应的处理和记录。
throw new RuntimeException(e);
} finally {
// 无论是否成功发送消息，都要调用SseEmitter的complete方法来关闭这个推送连接，
// 表示此次推送流程结束，释放相关资源，避免资源泄漏等问题。
emitter.complete();
}
return;
}
// 如果JDK版本满足要求，则调用DatabaseService的decrypt方法，传入SseEmitter对象和decryptDTO参数，
// 开始执行数据库解密操作，在解密过程中可以通过SseEmitter向客户端推送相关的进度信息、最终结果等内容，
// 具体的解密逻辑以及推送消息的实现细节在DatabaseService的decrypt方法中完成。
databaseService.decrypt(emitter, decryptDTO);
}).start();
// 将创建并配置好的SseEmitter对象返回给客户端，客户端可以通过该对象来接收服务器推送的数据库解密相关消息。
return emitter;
}
/**
* getDatabase方法，用于处理获取数据库相关信息的HTTP GET请求，接收一个微信用户标识（wxId）作为参数，
* 通过调用DatabaseService的getDatabase方法获取相应的数据库信息，并将结果包装在ResponseVO中返回给客户端。
*
* @param wxId 微信用户标识，用于唯一确定要获取数据库信息所属的用户，服务层会根据这个标识去查找对应的数据库相关信息，
* 例如可能查找该用户关联的所有数据库列表、数据库的一些配置信息等（具体取决于业务中DatabaseVO的定义以及服务层的实现逻辑）。
* @return ResponseVO<List<DatabaseVO>>，返回一个ResponseVO包装类型，其泛型为DatabaseVO的列表，
* ResponseVO用于统一封装响应的状态码、提示消息以及实际的数据内容，方便客户端统一解析和处理响应结果，
* DatabaseVO是用于展示数据库相关信息的视图对象，包含数据库名称、数据库路径、数据库大小等属性（具体依业务定义），
* 这里将通过服务层获取到的数据库信息列表封装在ResponseVO中返回给客户端，方便客户端展示和处理用户相关的数据库信息。
*/
@GetMapping("/getDatabase")
public ResponseVO<List<DatabaseVO>> decrypt(String wxId) {
return ResponseVO.ok(databaseService.getDatabase(wxId));
}
}

94
wx-dump-admin/src/main/java/com/xcs/wx/controller/ExportController.java
Unescape View File

@ -1,94 +0,0 @@
package com.xcs.wx.controller;
import lombok.RequiredArgsConstructor;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.core.io.UrlResource;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.io.IOException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.nio.file.Paths;
/**
* ExportController类，作为Spring MVC框架下的控制器，主要负责处理文件下载相关的HTTP请求，
* 用于实现从服务器端将指定文件提供给客户端进行下载的功能，由作者xcs在2024年01月05日15时56分创建。
*
* @author xcs
* @date 2024年01月05日 15时56分
**/
@Controller
// 该注解用于标识这个类是一个Spring MVC的控制器，它可以处理HTTP请求并返回视图或者数据响应，
// 与@RestController不同的是，它默认会按照视图解析机制去查找并返回对应的视图模板（如HTML页面等），
// 不过在这里主要是用于处理文件下载这种不需要返回视图的情况，也能正常工作，主要是借助了ResponseEntity来返回文件资源相关的响应。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 如果类中有这样的字段，Spring可以通过构造函数注入的方式将相应的依赖注入进来，简化了依赖注入的代码编写，
// 不过在这段代码中暂时没有看到这样的依赖注入字段展示出来。
@RequestMapping("/api/export")
// 用于定义该控制器所处理请求的基础路径，后续在此控制器内定义的各个请求映射方法对应的完整请求路径都基于这个基础路径进行拼接，
// 例如下面的 "/download" 路径对应的完整请求路径就是 "/api/export/download"，以此来清晰地划分和组织不同功能接口的访问路径。
public class ExportController {
/**
* download方法，用于处理文件下载的HTTP GET请求，接收一个表示文件路径的参数，
* 根据该路径查找对应的文件资源，进行一系列的处理（如文件名编码、设置响应头信息等）后，
* 将文件资源以合适的形式通过ResponseEntity返回给客户端，使得客户端能够下载该文件，
* 如果文件不存在，则返回相应的404状态码响应告知客户端文件未找到。
*
* @param path 表示要下载文件的路径，通过请求参数传入，客户端需要传递准确的文件在服务器端的存储路径，
* 该路径的格式需要符合服务器端文件系统的规范，例如在Windows下可能是类似 "C:/files/myfile.xlsx" 的格式，
* 在Linux下可能是 "/home/user/files/myfile.xlsx" 的格式等，具体取决于服务器的操作系统和文件存储配置情况。
* @return ResponseEntity<Resource>，返回一个ResponseEntity对象，其泛型为Resource类型，
* ResponseEntity用于构建包含各种HTTP响应信息（如状态码、响应头、响应体等）的完整响应对象，
* Resource是Spring中用于抽象表示资源的接口，在这里实际使用的是FileSystemResource或UrlResource等实现类来表示具体的文件资源，
* 通过这样的返回形式，将文件资源以及相关的响应配置（如响应头中设置的文件名、内容类型等）一起返回给客户端，实现文件下载功能。
* @throws IOException 如果在文件查找、读取或者处理文件名编码等过程中出现IO相关的异常，则会抛出该异常，
* 需要在调用该方法的地方进行相应的异常处理，例如在更高层的控制器异常处理机制中进行统一处理或者返回合适的错误响应给客户端。
*/
@GetMapping("download")
public ResponseEntity<Resource> download(@RequestParam String path) throws IOException {
// 使用Paths工具类的静态方法get，根据传入的文件路径字符串创建一个Path对象，
// Path对象用于在Java NIO中表示文件或目录的路径，方便后续对文件路径进行操作，比如判断文件是否存在等。
Path filePath = Paths.get(path);
// 创建一个FileSystemResource对象，它是Resource接口的一个实现类，用于基于文件系统来表示一个文件资源，
// 通过传入Path对象对应的文件实例化该资源对象，这样就可以通过这个对象对文件进行相关操作，比如判断文件是否存在、获取文件名等。
Resource resource = new FileSystemResource(filePath.toFile());
// 处理文件不存在的情况，如果通过Resource对象判断文件不存在（调用exists方法返回false），
// 则使用ResponseEntity的静态方法notFound创建一个表示404状态码（资源未找到）的ResponseEntity对象并返回，
// 这样客户端接收到这个响应就知道请求下载的文件不存在了。
if (!resource.exists()) {
return ResponseEntity.notFound().build();
}
// 对文件名进行编码处理，使用URLEncoder按照UTF-8字符集对Resource对象获取到的文件名进行编码，
// 这是为了确保文件名在HTTP响应中能够正确传输，特别是包含非ASCII字符的文件名，避免出现文件名乱码等问题，
// 同时将编码后字符串中的 "+" 号替换为 "%20"，因为在HTTP协议中，空格通常用 "%20" 来表示，确保文件名在客户端能被正确解析。
String encodedFilename = URLEncoder.encode(resource.getFilename(), StandardCharsets.UTF_8.name()).replace("+", "%20");
// 构建Content-Disposition响应头的值，用于告诉客户端如何处理响应体中的内容，
// "attachment" 表示让客户端将响应内容作为附件进行下载，而不是在浏览器中直接打开等其他处理方式，
// "filename*=UTF-8''" + encodedFilename 部分则是指定了下载文件的文件名，采用UTF-8编码格式，并使用编码后的文件名，
// 这样客户端在下载文件时就能以正确的文件名保存文件了。
String contentDisposition = "attachment; filename*=UTF-8''" + encodedFilename;
// 使用ResponseEntity的静态方法ok创建一个表示200状态码（请求成功）的ResponseEntity对象构建器，
// 然后通过链式调用的方式依次设置响应的内容类型（ContentType）为 "application/vnd.ms-excel"，
// 这里假设下载的文件是Excel文件格式，可根据实际下载文件的类型进行相应修改，比如下载图片可以设置为 "image/jpeg" 等合适的类型，
// 接着设置 "Content-Disposition" 响应头为上面构建好的值，最后将表示文件资源的Resource对象作为响应体（body）设置进去，
// 完成整个ResponseEntity对象的构建并返回给客户端，从而实现将文件以正确的配置提供给客户端进行下载的功能。
return ResponseEntity.ok()
.contentType(MediaType.parseMediaType("application/vnd.ms-excel"))
.header("Content-Disposition", contentDisposition)
.body(resource);
}
}

64
wx-dump-admin/src/main/java/com/xcs/wx/controller/FeedsController.java
Unescape View File

@ -1,64 +0,0 @@
package com.xcs.wx.controller;
import com.xcs.wx.domain.dto.FeedsDTO;
import com.xcs.wx.domain.vo.FeedsVO;
import com.xcs.wx.domain.vo.PageVO;
import com.xcs.wx.domain.vo.ResponseVO;
import com.xcs.wx.service.FeedsService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* FeedsController类，作为Spring MVC框架下的控制器，主要负责处理与朋友圈相关的HTTP请求，
* 通过调用FeedsService服务层提供的方法来实现查询朋友圈信息的业务逻辑，并将结果以合适的格式返回给客户端，
* 由作者xcs在2024年01月04日13时48分创建。
*
* @author xcs
* @date 2024年01月04日 13时48分
**/
@RestController
// 该注解表明这个类是一个Spring RESTful风格的控制器，意味着它主要用于处理HTTP请求，并返回JSON、XML等格式的数据响应，
// 而不是像传统的MVC模式那样返回视图页面（如HTML页面），适用于构建前后端分离项目中的接口层，方便与前端进行数据交互。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 在这里就是为下面的feedsService字段生成对应的构造函数注入，使得Spring容器能够通过构造函数注入的方式将FeedsService的实例注入进来，简化了依赖注入的代码编写。
@RequestMapping("/api/feeds")
// 用于定义该控制器所处理请求的基础路径，后续在此控制器内定义的各个请求映射方法对应的完整请求路径都基于这个基础路径进行拼接，
// 例如下面的 "/list" 路径对应的完整请求路径就是 "/api/feeds/list"，以此来清晰地划分和组织不同功能接口的访问路径，明确该接口是用于朋友圈相关操作的。
public class FeedsController {
private final FeedsService feedsService;
// 通过依赖注入的方式引入FeedsService的实例，FeedsService是服务层的接口或类，它封装了与朋友圈相关的各种业务逻辑方法，
// 例如这里的queryFeeds方法用于根据特定条件查询朋友圈信息，具体的业务实现细节在FeedsService及其实现类中完成。
/**
* list方法，用于处理查询朋友圈信息的HTTP GET请求，接收一个FeedsDTO对象作为请求参数，
* 通过调用FeedsService的queryFeeds方法获取朋友圈信息，并将查询结果包装在ResponseVO中返回给客户端。
*
* @param feedsDTO 请求参数，它是一个数据传输对象（DTO），通常包含了用于筛选、分页等查询朋友圈信息的条件信息，
* 比如可能包含查询的时间范围、发布人、关键词等相关字段，具体取决于业务中对朋友圈查询条件的定义，
* 以便从众多朋友圈动态中筛选出符合要求的内容。
* @return ResponseVO<List<FeedsVO>>，返回一个ResponseVO包装类型，其泛型为FeedsVO的列表，
* ResponseVO用于统一封装响应的状态码、提示消息以及实际的数据内容，方便客户端统一解析和处理响应结果，
* FeedsVO是用于展示朋友圈动态信息的视图对象，包含了朋友圈内容的相关关键属性，例如发布者头像、昵称、发布时间、动态内容等（具体依业务定义），
* 这里将通过服务层查询到的朋友圈动态列表信息封装在ResponseVO中返回给客户端，方便客户端展示朋友圈内容给用户查看。
*/
@GetMapping("/list")
public ResponseVO<List<FeedsVO>> list(FeedsDTO feedsDTO) {
// 调用FeedsService的queryFeeds方法，传入FeedsDTO对象作为查询条件，
// 该方法会依据传入的条件去数据库或者其他数据源中查找符合要求的朋友圈动态信息，返回的结果包装在PageVO中，
// PageVO通常用于分页相关的场景，它包含了当前页的数据记录列表（这里就是朋友圈动态信息列表）、当前页码以及总记录数等信息。
PageVO<FeedsVO> pageVO = feedsService.queryFeeds(feedsDTO);
// 使用ResponseVO的静态方法ok创建一个表示成功响应的ResponseVO对象，
// 并将从PageVO中获取的朋友圈动态记录列表（pageVO.getRecords()）、当前页码（pageVO.getCurrent()）以及总记录数（pageVO.getTotal()）作为参数传入，
// 这样就把查询到的朋友圈动态列表信息以及分页相关信息一起封装进ResponseVO中返回给客户端了。
return ResponseVO.ok(pageVO.getRecords(), pageVO.getCurrent(), pageVO.getTotal());
}
}

86
wx-dump-admin/src/main/java/com/xcs/wx/controller/ImageController.java
Unescape View File

@ -1,86 +0,0 @@
package com.xcs.wx.controller;
import com.xcs.wx.service.ImageService;
import lombok.RequiredArgsConstructor;
import org.springframework.core.io.Resource;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
/**
* ImageController类，作为Spring MVC框架下的控制器，主要负责处理与图片相关的HTTP请求，
* 通过调用ImageService服务层提供的不同方法，实现根据不同条件（如MD5值、路径等）下载图片的功能，
* 并将图片资源以合适的形式通过ResponseEntity返回给客户端，由作者xcs在2024年1月24日16时41分52秒创建。
*
* @author xcs
* @date 2024年1月24日16:41:52
*/
@Controller
// 该注解用于标识这个类是一个Spring MVC的控制器，它可以处理HTTP请求并返回视图或者数据响应。
// 在这里主要是借助ResponseEntity来返回图片资源相关的响应，而不是返回视图模板（如HTML页面），用于实现图片下载相关的接口功能。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 在这里就是为下面的imageService字段生成对应的构造函数注入，使得Spring容器可以通过构造函数注入的方式将ImageService的实例注入进来，简化了依赖注入的代码编写。
@RequestMapping("/api/image")
// 用于定义该控制器所处理请求的基础路径，后续在此控制器内定义的各个请求映射方法对应的完整请求路径都基于这个基础路径进行拼接，
// 例如下面的 "/downloadImgMd5"、"/downloadImg"、"/downloadImgFormLocal" 这些路径对应的完整请求路径就是 "/api/image/downloadImgMd5"、"/api/image/downloadImg"、"/api/image/downloadImgFormLocal" 等，
// 以此来清晰地划分和组织不同功能接口的访问路径，明确各个接口是用于处理特定条件下的图片下载操作。
public class ImageController {
private final ImageService imageService;
// 通过依赖注入的方式引入ImageService的实例，ImageService是服务层的接口或类，它封装了与图片相关的各种业务逻辑方法，
// 例如根据MD5值查找并获取对应的图片资源、依据路径下载图片以及从本地路径获取图片资源等具体的业务操作，具体的业务实现细节在ImageService及其实现类中完成。
/**
* downloadImgMd5方法，用于处理根据图片的MD5值下载图片的HTTP GET请求，接收一个表示图片MD5值的字符串参数，
* 通过调用ImageService的downloadImgMd5方法，获取对应的图片资源，并将其以ResponseEntity<Resource>的形式返回给客户端，
* 使得客户端能够获取并展示该图片，这里的MD5值通常用于唯一标识图片，方便在系统中快速查找和验证图片的完整性等操作。
*
* @param md5 Md5值，作为请求参数，用于唯一确定要下载的图片，客户端需要传递准确的图片MD5值，
* 服务层会根据这个MD5值去查找对应的图片资源，该MD5值应该是事先通过某种算法（如标准的MD5哈希算法）计算得出的图片特征码。
* @return ResponseEntity<Resource>，返回一个ResponseEntity对象，其泛型为Resource类型，
* ResponseEntity用于构建包含各种HTTP响应信息（如状态码、响应头、响应体等）的完整响应对象，
* Resource是Spring中用于抽象表示资源的接口，在这里实际返回的可能是代表图片文件的资源对象，
* 通过这样的返回形式，将图片资源以及相关的响应配置（如响应头中设置的内容类型等）一起返回给客户端，实现图片下载功能。
*/
@GetMapping("/downloadImgMd5")
public ResponseEntity<Resource> downloadImgMd5(@RequestParam String md5) {
return imageService.downloadImgMd5(md5);
}
/**
* downloadImg方法，用于处理根据指定路径下载图片的HTTP GET请求，接收一个表示图片路径的字符串参数，
* 通过调用ImageService的downloadImg方法获取对应的图片资源，并将其以ResponseEntity<Resource>的形式返回给客户端，
* 这里的路径可能是图片在服务器端存储的相对路径或者绝对路径等，具体取决于系统的存储配置和业务逻辑设定。
*
* @param path Md5值，此处参数名可能有误，应该是表示图片路径的字符串参数（可根据实际情况调整），作为请求参数，
* 用于确定要下载的图片所在的位置，客户端需要传递准确的图片路径信息，服务层会依据这个路径去查找并获取对应的图片资源。
* @return ResponseEntity<Resource>，返回形式及含义与上述downloadImgMd5方法类似，
* 也是将通过服务层获取到的图片资源以及相关响应配置通过ResponseEntity对象返回给客户端，实现基于路径的图片下载功能。
*/
@GetMapping("/downloadImg")
public ResponseEntity<Resource> downloadImg(@RequestParam String path) {
return imageService.downloadImg(path);
}
/**
* downloadImgFormLocal方法，用于处理根据本地路径下载图片的HTTP GET请求，接收一个表示本地图片路径的字符串参数，
* 通过调用ImageService的downloadImgFormLocal方法获取对应的图片资源，并将其以ResponseEntity<Resource>的形式返回给客户端，
* 这里强调的是本地路径，意味着图片资源是位于服务器本地文件系统中的特定位置，通过该路径可以直接定位到对应的图片文件进行下载操作。
*
* @param localPath 本地图片路径，作为请求参数，用于明确指定服务器本地文件系统中要下载图片的具体位置，
* 客户端需要传递准确的本地图片路径，例如在Windows下可能是类似 "C:/images/myPic.jpg" 的格式，
* 在Linux下可能是 "/home/user/images/myPic.jpg" 的格式等，服务层会根据这个路径查找并获取对应的本地图片资源。
* @return ResponseEntity<Resource>，返回形式及含义同前面的下载图片相关方法，
* 即把从服务层获取到的本地图片资源以及相应的响应配置通过ResponseEntity对象返回给客户端，实现从本地获取图片并下载的功能。
*/
@GetMapping("/downloadImgFormLocal")
public ResponseEntity<Resource> downloadImgFormLocal(@RequestParam String localPath) {
return imageService.downloadImgFormLocal(localPath);
}
}

32
wx-dump-admin/src/main/java/com/xcs/wx/controller/IndexController.java
Unescape View File

@ -1,32 +0,0 @@
package com.xcs.wx.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* IndexController类，作为Spring MVC框架下的控制器，主要用于处理根路径以及特定格式路径的请求，
* 并返回对应的视图页面（在这里返回的视图名称为 "index"），通常用于配置项目的默认首页或者统一处理一些基础路径相关的请求，
* 由作者xcs在2024年01月26日11时34分创建。
*
* @author xcs
* @date 2024年01月26日 11时34分
**/
@Controller
// 该注解用于标识这个类是一个Spring MVC的控制器，意味着它可以处理HTTP请求并按照Spring的视图解析机制返回对应的视图页面，
// 与@RestController不同，它不是主要用于返回数据（如JSON格式数据）响应，而是更侧重于返回视图相关的响应，像HTML页面等。
public class IndexController {
/**
* index方法，用于处理特定路径请求，并返回名为 "index" 的视图页面。
* 通过@RequestMapping注解配置了路径匹配规则，能够拦截根路径（"/"）以及符合特定正则表达式规则的路径（"/{path:[^.]*}"），
* 这样在浏览器访问这些匹配的路径时，都会由这个方法来处理并返回对应的视图。
*
* @return String类型的视图名称 "index"，Spring MVC会根据配置的视图解析器去查找对应的视图资源（例如在特定目录下的index.html文件等），
* 并将其渲染后返回给客户端（如在浏览器中展示对应的HTML页面内容）。
*/
@RequestMapping(value = {"/", "/{path:[^.]*}"})
public String index() {
return "index";
}
}

74
wx-dump-admin/src/main/java/com/xcs/wx/controller/MsgController.java
Unescape View File

@ -1,74 +0,0 @@
package com.xcs.wx.controller;
import com.xcs.wx.domain.vo.MsgVO;
import com.xcs.wx.domain.vo.ResponseVO;
import com.xcs.wx.service.MsgService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* MsgController类，作为Spring MVC框架下的控制器，主要负责处理与消息相关的HTTP请求，
* 通过调用MsgService服务层提供的方法来实现查询消息、导出聊天记录等具体业务逻辑，
* 并将处理结果以合适的格式（使用ResponseVO进行封装）返回给客户端，由作者xcs在2023年12月25日17时06分创建。
*
* @author xcs
* @date 2023年12月25日 17时06分
**/
@RestController
// 该注解表明这个类是一个Spring RESTful风格的控制器，意味着它主要用于处理HTTP请求，并返回JSON、XML等格式的数据响应，
// 而不是像传统的MVC模式那样返回视图页面（如HTML页面），适用于构建前后端分离项目中的接口层，方便与前端进行数据交互。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 在这里就是为下面的msgService字段生成对应的构造函数注入，使得Spring容器能够通过构造函数注入的方式将MsgService的实例注入进来，简化了依赖注入的代码编写。
@RequestMapping("/api/msg")
// 用于定义该控制器所处理请求的基础路径，后续在此控制器内定义的各个请求映射方法对应的完整请求路径都基于这个基础路径进行拼接，
// 例如下面的 "/list"、"/export" 路径对应的完整请求路径就是 "/api/msg/list"、"/api/msg/export" 等，以此来清晰地划分和组织不同功能接口的访问路径，明确各接口是用于消息相关操作的。
public class MsgController {
private final MsgService msgService;
// 通过依赖注入的方式引入MsgService的实例，MsgService是服务层的接口或类，它封装了与消息相关的各种业务逻辑方法，
// 例如根据指定条件查询消息、将指定对话的聊天记录导出等操作，具体的业务实现细节在MsgService及其实现类中完成。
/**
* list方法，用于处理查询消息的HTTP GET请求，接收两个请求参数，分别是对话者标识（talker）和下一个序列号（nextSequence），
* 通过调用MsgService的queryMsg方法按照这两个参数所确定的条件去查询消息，并将查询结果包装在ResponseVO中返回给客户端。
*
* @param talker 对话者标识，作为请求参数，用于唯一确定参与对话的一方或者多方（具体取决于业务中对话者的定义方式），
* 例如在微信中可能是用户的微信号、用户名等能唯一标识用户的信息，服务层会依据这个标识去查找与之相关的消息记录，
* 客户端需要传递准确的对话者标识来获取对应的消息内容。
* @param nextSequence 下一个序列号，也是请求参数，通常用于分页或者按顺序获取消息的场景，
* 它可能表示上一次查询到的最后一条消息的序列号，此次查询从这个序列号之后的消息开始获取，
* 以此实现消息的分批加载等功能，具体含义和使用方式取决于业务中对消息序列号的定义和消息查询逻辑的设计。
* @return ResponseVO<List<MsgVO>>，返回一个ResponseVO包装类型，其泛型为MsgVO的列表，
* ResponseVO用于统一封装响应的状态码、提示消息以及实际的数据内容，方便客户端统一解析和处理响应结果，
* MsgVO是用于展示消息内容及相关信息的视图对象，包含了消息的具体文本内容、发送时间、消息类型（如文本消息、图片消息等）等属性（具体依业务定义），
* 这里将通过服务层查询到的符合条件的消息列表信息封装在ResponseVO中返回给客户端，方便客户端展示消息给用户查看，或者进行后续的消息处理操作。
*/
@GetMapping("/list")
public ResponseVO<List<MsgVO>> list(@RequestParam String talker, @RequestParam Long nextSequence) {
return ResponseVO.ok(msgService.queryMsg(talker, nextSequence));
}
/**
* export方法，用于处理导出聊天记录的HTTP GET请求，接收一个表示对话者标识的请求参数（talker），
* 通过调用MsgService的exportMsg方法将指定对话者的聊天记录进行导出操作，并将导出结果相关信息（比如导出文件的路径、导出状态等，此处假设以字符串形式表示）包装在ResponseVO中返回给客户端。
*
* @param talker 对话者标识，用于唯一确定要导出聊天记录所属的对话者，客户端传递具体的对话者标识，
* 服务层会根据这个标识去查找对应的聊天记录，并执行导出操作，例如在微信场景下可以是某个好友的微信号等信息。
* @return ResponseVO<String>，返回一个ResponseVO包装类型，其泛型为String，
* 这里将服务层执行聊天记录导出操作后返回的相关结果信息（以字符串形式）封装在ResponseVO中返回给客户端，
* 客户端可以依据返回的信息来判断聊天记录导出是否成功以及获取相关的导出结果内容（例如提示用户去哪里下载导出的聊天记录文件等）。
*/
@GetMapping("/export")
public ResponseVO<String> export(@RequestParam String talker) {
return ResponseVO.ok(msgService.exportMsg(talker));
}
}

77
wx-dump-admin/src/main/java/com/xcs/wx/controller/RecoverContactController.java
Unescape View File

@ -1,77 +0,0 @@
package com.xcs.wx.controller;
import com.xcs.wx.domain.dto.RecoverContactDTO;
import com.xcs.wx.domain.vo.RecoverContactVO;
import com.xcs.wx.domain.vo.ResponseVO;
import com.xcs.wx.service.RecoverContactService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* RecoverContactController类，作为Spring MVC框架下的控制器，主要负责处理与找回联系人相关的HTTP请求，
* 通过调用RecoverContactService服务层提供的方法来实现查询找回联系人信息以及导出相关联系人的业务逻辑，
* 并将处理结果以合适的格式（使用ResponseVO进行封装）返回给客户端，由作者xcs在2024年01月04日13时48分创建。
*
* @author xcs
* @date 2024年01月04日 13时48分
**/
@RestController
// 该注解表明这个类是一个Spring RESTful风格的控制器，意味着它主要用于处理HTTP请求，并返回JSON、XML等格式的数据响应，
// 而不是像传统的MVC模式那样返回视图页面（如HTML页面），适用于构建前后端分离项目中的接口层，方便与前端进行数据交互。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 在这里就是为下面的recoverContactService字段生成对应的构造函数注入，使得Spring容器能够通过构造函数注入的方式将RecoverContactService的实例注入进来，简化了依赖注入的代码编写。
@RequestMapping("/api/recover/contact")
// 用于定义该控制器所处理请求的基础路径，后续在此控制器内定义的各个请求映射方法对应的完整请求路径都基于这个基础路径进行拼接，
// 例如下面的 "/list"、"/export" 路径对应的完整请求路径就是 "/api/recover/contact/list"、"/api/recover/contact/export" 等，
// 以此来清晰地划分和组织不同功能接口的访问路径，明确各接口是用于找回联系人相关操作的。
public class RecoverContactController {
private final RecoverContactService recoverContactService;
// 通过依赖注入的方式引入RecoverContactService的实例，RecoverContactService是服务层的接口或类，它封装了与找回联系人相关的各种业务逻辑方法，
// 例如根据特定条件查询可找回的联系人信息、执行联系人导出操作等，具体的业务实现细节在RecoverContactService及其实现类中完成。
/**
* list方法，用于处理查询找回联系人信息的HTTP GET请求，接收一个RecoverContactDTO对象作为请求参数，
* 通过调用RecoverContactService的queryRecoverContact方法按照该参数所确定的条件去查询找回联系人的相关信息，
* 并将查询结果包装在ResponseVO中返回给客户端。
*
* @param recoverContactDTO 请求参数，它是一个数据传输对象（DTO），通常包含了用于筛选、查找可找回联系人的条件信息，
* 比如可能包含联系人曾经的一些关键标识信息、丢失联系人的大致时间范围等相关字段，具体取决于业务中对找回联系人查询条件的定义，
* 以便从众多历史记录或相关数据源中筛选出符合要求的可找回联系人信息。
* @return ResponseVO<List<RecoverContactVO>>，返回一个ResponseVO包装类型，其泛型为RecoverContactVO的列表，
* ResponseVO用于统一封装响应的状态码、提示消息以及实际的数据内容，方便客户端统一解析和处理响应结果，
* RecoverContactVO是用于展示找回联系人相关信息的视图对象，包含了联系人的关键属性，例如联系人姓名、联系方式、最后联系时间等（具体依业务定义），
* 这里将通过服务层查询到的符合条件的找回联系人列表信息封装在ResponseVO中返回给客户端，方便客户端展示这些联系人信息给用户查看，
* 或者进行后续的联系人恢复等相关操作。
*/
@GetMapping("/list")
public ResponseVO<List<RecoverContactVO>> list(RecoverContactDTO recoverContactDTO) {
// 调用RecoverContactService的queryRecoverContact方法，传入RecoverContactDTO对象作为查询条件，
// 该方法会依据传入的条件去数据库或者其他数据源中查找符合要求的找回联系人信息，然后直接将查询结果封装在ResponseVO中返回给客户端，
// 使用ResponseVO的静态方法ok创建一个表示成功响应的ResponseVO对象，并将查询到的找回联系人信息列表作为参数传入，
// 这样就把查询到的找回联系人列表信息封装进ResponseVO中返回给客户端了。
return ResponseVO.ok(recoverContactService.queryRecoverContact(recoverContactDTO));
}
/**
* export方法，用于处理导出找回联系人相关信息的HTTP GET请求，
* 通过调用RecoverContactService的exportRecoverContact方法执行联系人导出的业务逻辑，
* 并将导出结果相关信息（比如导出文件的路径、导出状态等，此处假设以字符串形式表示）包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<String>，返回一个ResponseVO包装类型，其泛型为String，
* 这里将服务层执行找回联系人导出操作后返回的相关结果信息（以字符串形式）封装在ResponseVO中返回给客户端，
* 客户端可以依据返回的信息来判断联系人导出是否成功以及获取相关的导出结果内容（例如提示用户去哪里下载导出的联系人文件等）。
*/
@GetMapping("/export")
public ResponseVO<String> export() {
return ResponseVO.ok(recoverContactService.exportRecoverContact());
}
}

53
wx-dump-admin/src/main/java/com/xcs/wx/controller/SessionController.java
Unescape View File

@ -1,53 +0,0 @@
package com.xcs.wx.controller;
import com.xcs.wx.domain.vo.ResponseVO;
import com.xcs.wx.domain.vo.SessionVO;
import com.xcs.wx.service.SessionService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* SessionController类，作为Spring MVC框架下的控制器，主要负责处理与会话相关的HTTP请求，
* 通过调用SessionService服务层提供的方法来实现查询会话列表的业务逻辑，
* 并将处理结果以合适的格式（使用ResponseVO进行封装）返回给客户端，由作者xcs在2023年12月21日17时38分创建。
*
* @author xcs
* @date 2023年12月21日17时38分
**/
@RestController
// 该注解表明这个类是一个Spring RESTful风格的控制器，意味着它主要用于处理HTTP请求，并返回JSON、XML等格式的数据响应，
// 而不是像传统的MVC模式那样返回视图页面（如HTML页面），适用于构建前后端分离项目中的接口层，方便与前端进行数据交互。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 在这里就是为下面的sessionService字段生成对应的构造函数注入，使得Spring容器能够通过构造函数注入的方式将SessionService的实例注入进来，简化了依赖注入的代码编写。
@RequestMapping("/api/session")
// 用于定义该控制器所处理请求的基础路径，后续在此控制器内定义的各个请求映射方法对应的完整请求路径都基于这个基础路径进行拼接，
// 例如下面的 "/list" 路径对应的完整请求路径就是 "/api/session/list"，以此来清晰地划分和组织不同功能接口的访问路径，明确该接口是用于会话相关操作的。
public class SessionController {
private final SessionService sessionService;
// 通过依赖注入的方式引入SessionService的实例，SessionService是服务层的接口或类，它封装了与会话相关的各种业务逻辑方法，
// 例如这里的querySession方法用于查询会话列表，具体的业务实现细节在SessionService及其实现类中完成。
/**
* list方法，用于处理查询会话列表的HTTP GET请求，
* 通过调用SessionService的querySession方法获取会话列表信息，并将查询结果包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<List<SessionVO>>，返回一个ResponseVO包装类型，其泛型为SessionVO的列表，
* ResponseVO用于统一封装响应的状态码、提示消息以及实际的数据内容，方便客户端统一解析和处理响应结果，
* SessionVO是用于展示会话相关信息的视图对象，包含了会话的关键属性，例如会话的对方标识（比如聊天对象的用户名、ID等）、
* 最后一条消息内容、最后消息发送时间等（具体依业务定义），这里将通过服务层查询到的会话列表信息封装在ResponseVO中返回给客户端，
* 方便客户端展示会话列表给用户查看，或者进行后续的会话相关操作（如切换会话、查看会话详情等）。
*/
@GetMapping("/list")
public ResponseVO<List<SessionVO>> list() {
return ResponseVO.ok(sessionService.querySession());
}
}

127
wx-dump-admin/src/main/java/com/xcs/wx/controller/UserController.java
Unescape View File

@ -1,127 +0,0 @@
package com.xcs.wx.controller;
import com.xcs.wx.domain.vo.UserInfoVO;
import com.xcs.wx.domain.vo.UserVO;
import com.xcs.wx.domain.vo.ResponseVO;
import com.xcs.wx.domain.vo.WeChatConfigVO;
import com.xcs.wx.service.UserService;
import com.xcs.wx.service.WeChatService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* UserController类，作为Spring MVC框架下的控制器，主要负责处理与用户相关的各类HTTP请求，
* 通过调用UserService和WeChatService服务层提供的不同方法，实现诸如查询微信配置信息、获取用户各类信息以及切换用户等业务逻辑，
* 并将处理结果以合适的格式（使用ResponseVO进行封装）返回给客户端，由作者xcs在2024年6月15日16时05分49秒创建。
*
* @author xcs
* @date 2024年6月15日16:05:49
*/
@RestController
// 该注解表明这个类是一个Spring RESTful风格的控制器，意味着它主要用于处理HTTP请求，并返回JSON、XML等格式的数据响应，
// 而不是像传统的MVC模式那样返回视图页面（如HTML页面），适用于构建前后端分离项目中的接口层，方便与前端进行数据交互。
@RequiredArgsConstructor
// 使用Lombok的 @RequiredArgsConstructor 注解，会为类中所有被标记为final且未初始化的字段生成构造函数，
// 在这里就是为下面的userService和weChatService字段生成对应的构造函数注入，使得Spring容器能够通过构造函数注入的方式将UserService和WeChatService的实例注入进来，简化了依赖注入的代码编写。
@RequestMapping("/api/user")
// 用于定义该控制器所处理请求的基础路径，后续在此控制器内定义的各个请求映射方法对应的完整请求路径都基于这个基础路径进行拼接，
// 例如下面的 "/readWeChatConfig"、"/userInfo" 等路径对应的完整请求路径就是 "/api/user/readWeChatConfig"、"/api/user/userInfo" 等，
// 以此来清晰地划分和组织不同功能接口的访问路径，明确各接口是用于用户相关操作的。
public class UserController {
private final UserService userService;
private final WeChatService weChatService;
// 通过依赖注入的方式引入UserService和WeChatService的实例，
// UserService是服务层的接口或类，它封装了与用户自身信息相关的各种业务逻辑方法，如获取用户头像、昵称、查询所有用户以及切换用户等操作；
// WeChatService则是封装了与微信相关配置信息查询等业务逻辑的服务层接口或类，具体的业务实现细节在它们各自的实现类中完成。
/**
* readWeChatConfig方法，用于处理查询微信信息的HTTP GET请求，
* 通过调用WeChatService的readWeChatConfig方法获取微信配置相关信息，并将查询结果包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<List<WeChatConfigVO>>，返回一个ResponseVO包装类型，其泛型为WeChatConfigVO的列表，
* ResponseVO用于统一封装响应的状态码、提示消息以及实际的数据内容，方便客户端统一解析和处理响应结果，
* WeChatConfigVO是用于展示微信配置信息的视图对象，包含了诸如微信的一些功能开关设置、版本相关配置、服务器连接配置等属性（具体依业务定义），
* 这里将通过服务层查询到的微信配置信息列表封装在ResponseVO中返回给客户端，方便客户端展示微信配置情况或者进行相关的配置处理操作。
*/
@GetMapping("/readWeChatConfig")
public ResponseVO<List<WeChatConfigVO>> readWeChatConfig() {
return ResponseVO.ok(weChatService.readWeChatConfig());
}
/**
* userInfo方法，用于处理获取用户头像等用户详细信息的HTTP GET请求，
* 通过调用UserService的userInfo方法获取用户详细信息，并将查询结果（以UserInfoVO对象形式）包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<UserInfoVO>，返回一个ResponseVO包装类型，其泛型为UserInfoVO，
* UserInfoVO是用于展示用户详细信息的视图对象，包含了用户头像、昵称、性别、地区等多方面的个人信息（具体依业务定义），
* 这里将通过服务层获取到的用户详细信息封装在ResponseVO中返回给客户端，方便客户端展示用户的完整信息给用户查看或者进行其他相关操作。
*/
@GetMapping("/userInfo")
public ResponseVO<UserInfoVO> userInfo() {
return ResponseVO.ok(userService.userInfo());
}
/**
* avatar方法，用于处理获取用户头像的HTTP GET请求，
* 通过调用UserService的avatar方法获取用户头像相关信息（此处假设以字符串形式返回，比如头像的存储路径或者网络地址等，具体取决于业务实现），
* 并将查询结果包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<String>，返回一个ResponseVO包装类型，其泛型为String，
* 这里将服务层执行获取用户头像操作后返回的相关结果信息（以字符串形式）封装在ResponseVO中返回给客户端，
* 客户端可以依据返回的信息来获取用户头像（比如展示头像图片等）。
*/
@GetMapping("/avatar")
public ResponseVO<String> avatar() {
return ResponseVO.ok(userService.avatar());
}
/**
* nickname方法，用于处理获取用户昵称的HTTP GET请求，
* 通过调用UserService的nickname方法获取用户昵称信息，并将查询结果包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<String>，返回一个ResponseVO包装类型，其泛型为String，
* 这里将服务层获取到的用户昵称信息封装在ResponseVO中返回给客户端，方便客户端展示用户的昵称给用户查看或者进行其他相关操作。
*/
@GetMapping("/nickname")
public ResponseVO<String> nickname() {
return ResponseVO.ok(userService.nickname());
}
/**
* users方法，用于处理获取所有用户信息的HTTP GET请求，
* 通过调用UserService的users方法获取所有用户相关信息，并将查询结果（以用户信息视图对象列表形式）包装在ResponseVO中返回给客户端。
*
* @return ResponseVO<List<UserVO>>，返回一个ResponseVO包装类型，其泛型为UserVO的列表，
* UserVO是用于展示用户基本信息的视图对象，包含了诸如用户名、用户ID等基本属性（具体依业务定义），
* 这里将通过服务层查询到的所有用户信息列表封装在ResponseVO中返回给客户端，方便客户端展示用户列表等相关操作（比如展示用户选择界面等）。
*/
@GetMapping("/users")
public ResponseVO<List<UserVO>> users() {
return ResponseVO.ok(userService.users());
}
/**
* switchUser方法，用于处理切换用户的HTTP PUT请求，接收一个表示要切换到的用户ID（wxId）作为参数，
* 通过调用UserService的switchUser方法执行用户切换的业务逻辑，成功切换后返回一个表示成功的ResponseVO对象给客户端。
*
* @param wxId wxId，作为请求参数，用于明确指定要切换到的目标用户的唯一标识（如用户在系统中的ID等），客户端传递具体的用户ID，
* 服务层会根据这个ID去执行切换用户的相关操作，比如更新当前登录用户的状态、加载目标用户的相关配置和数据等。
* @return ResponseVO<String>，返回一个ResponseVO包装类型，其泛型为String，
* 这里返回一个表示成功的提示信息（固定为 "切换成功"）封装在ResponseVO中返回给客户端，告知客户端用户切换操作已顺利完成，
* 客户端可以依据此信息进行相应的界面更新等后续操作。
*/
@PutMapping("/switchUser")
public ResponseVO<String> switchUser(String wxId) {
userService.switchUser(wxId);
return ResponseVO.ok("切换成功");
}
}

153
wx-dump-admin/src/main/java/com/xcs/wx/domain/ChatRoom.java
Unescape View File

@ -1,153 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import org.apache.ibatis.type.ByteArrayTypeHandler;
/**
* ChatRoom类用于表示群聊相关的信息，在系统中对应数据库里存储群聊数据的实体，它将群聊的各种属性整合在一起，
* 方便与数据库进行交互以及在业务逻辑中对群聊相关的数据进行操作和传递，例如在创建群聊、查询群聊详情、更新群聊信息等业务场景中发挥作用。
* @author xcs
* &#064;date 2024年01月08日 09时45分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，像通过调用getChatRoomName()、getUserNameList()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要访问群聊的具体属性信息时，比如查看群聊名称、获取群聊成员用户名列表等，这些getter方法能提供便捷的数据访问途径，便于后续业务逻辑使用这些数据。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当群聊的显示名称列表发生变化，
// 可以通过调用setDisplayNameList(String newDisplayNameList)方法来更新displayNameList属性的值，从而保证对象的属性能够灵活地反映群聊相关信息的实际变化情况，增强了属性的可操作性。
// - 生成toString方法，该方法能将ChatRoom对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前群聊对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个ChatRoom对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及群聊对象比较的业务逻辑中（如判断两个群聊的配置是否一致等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@TableName(value = "ChatRoom", autoResultMap = true)
// @TableName注解来自于MyBatis Plus框架，用于指定该实体类对应的数据库表名，这里表明ChatRoom类对应的数据库表名为"ChatRoom"。
// 而autoResultMap = true这个配置表示自动构建结果映射，方便在查询数据库返回结果时，能自动将结果集的数据映射到该类的属性上，
// 减少了手动配置结果映射的繁琐过程，特别是当表结构和类结构有一定对应关系时，能更便捷地进行数据库与实体类之间的数据交互。
public class ChatRoom {
/**
* 聊天室名称，作为主键。它以字符串（String）类型存储，是用于唯一标识一个群聊的关键信息，
// 在整个系统中，不同的群聊应该具有不同的名称，通过这个名称可以在数据库操作（如查询、更新、删除等）以及业务逻辑处理中准确地定位到具体的群聊，
// 同时在用户界面展示群聊列表等场景下，也是用户识别不同群聊的重要依据之一。
*/
@TableId("ChatRoomName")
// @TableId注解用于指定该属性对应的数据库表中的主键字段名，这里表明在数据库表"ChatRoom"中，主键字段名为"ChatRoomName"，
// 即将类中的chatRoomName属性与数据库表中的主键列进行了关联，确保了在数据库操作时，能根据这个主键进行准确的记录定位和操作。
private String chatRoomName;
/**
* 用户名列表，以文本形式存储。使用字符串（String）类型来保存群聊中所有成员的用户名信息，这些用户名可能是以某种特定的格式拼接在一起，
// 例如用逗号隔开各个用户名等形式，方便在需要获取群聊成员、进行成员相关的业务逻辑判断（如判断某个用户是否在群聊中）以及与其他系统模块交互传递成员信息等场景下使用。
*/
@TableField("UserNameList")
// @TableField注解用于指定该属性对应的数据库表中的字段名，这里表示在数据库表"ChatRoom"中，该属性对应名为"UserNameList"的字段，
// 明确了类属性与数据库表字段之间的映射关系，确保数据的正确存储和读取。
private String userNameList;
/**
* 显示名称列表，以文本形式存储。同样是字符串类型，用于存储群聊成员在该群聊中对外展示的显示名称列表，
// 与用户名不同，显示名称可能更具个性化、友好化，方便在群聊界面展示成员信息时使用，其存储格式可能和用户名列表类似，也是按照一定规则拼接的字符串形式，
// 用于在展示群聊成员、进行成员显示相关的业务处理（如更新成员显示名称等）场景中发挥作用。
*/
@TableField("DisplayNameList")
private String displayNameList;
/**
* 聊天室标志，默认为 0。使用整数（Integer）类型，这个标志可以用于表示群聊的某种特定状态或者属性分类等情况，
// 具体含义取决于业务的具体定义，例如可以用不同的整数值来区分普通群聊、加密群聊、临时群聊等不同类型的群聊，初始默认值为0，在创建群聊或者初始化相关数据时会用到这个默认值，
// 后续可根据业务需求对其进行修改和判断，以实现不同的业务逻辑处理。
*/
@TableField("ChatRoomFlag")
private Integer chatRoomFlag;
/**
* 聊天室拥有者的标识，默认为 0。以整数类型存储，用于唯一标识群聊的创建者或者拥有者，
// 在涉及群聊权限管理（如只有拥有者能进行某些特定操作，像修改群聊设置等）、群聊归属判断以及相关业务逻辑中起着关键作用，初始默认值为0，
// 当创建群聊时会确定具体的拥有者标识并进行相应赋值，后续也可以根据业务规则对其进行更新和查询等操作。
*/
@TableField("Owner")
private Integer owner;
/**
* 是否显示名称的标志，默认为 0。同样为整数类型，用于控制群聊成员在群聊界面中是否展示显示名称，
// 例如值为1时表示显示成员的显示名称，值为0则不显示，方便根据不同的业务场景或者用户偏好来设置群聊成员名称的展示情况，在群聊界面展示相关的业务逻辑中会用到这个标志进行判断和处理。
*/
@TableField("IsShowName")
private Integer isShowName;
/**
* 自己在聊天室中的显示名称。以字符串类型存储自己在当前群聊中对外展示的名称，这个名称可能是用户自行设置的个性化称呼，
// 用于在群聊中让其他成员识别自己，与前面的显示名称列表有所不同，它特指当前用户自己在该群聊中的展示名称，在群聊交互、展示自身信息等场景中发挥作用。
*/
@TableField("SelfDisplayName")
private String selfDisplayName;
/**
* 预留字段1。以整数类型存在，在软件开发中，预留字段通常是为了应对未来可能的业务扩展或者功能变化而提前在数据库表结构和实体类中设置的字段，
// 目前可能暂时没有具体的使用场景，但当后续需要增加新的属性或者功能时，可以利用这些预留字段进行扩展，避免了频繁修改数据库表结构和实体类结构带来的复杂性和风险。
*/
@TableField("Reserved1")
private Integer reserved1;
/**
* 预留字段2。以字符串类型设置，和预留字段1类似，也是为了后续业务扩展预留的空间，只是其数据类型为字符串，可用于存储一些文本形式的扩展信息，
// 具体内容和用途会根据未来业务发展的需求来确定。
*/
@TableField("Reserved2")
private String reserved2;
/**
* 预留字段3。使用整数类型，同样作为未来可能新增业务属性的预留空间，在当前阶段不参与主要的业务逻辑处理，但在系统升级、功能拓展时可能会被赋予相应的含义和使用方式。
*/
@TableField("Reserved3")
private Integer reserved3;
/**
* 预留字段4。以字符串类型存储，是另一个为后续业务变化准备的文本形式的预留字段，以备不时之需，方便在不改动现有主要业务逻辑的基础上进行功能的扩展和完善。
*/
@TableField("Reserved4")
private String reserved4;
/**
* 预留字段5。为整数类型，继续为未来可能的业务拓展预留，在数据库表和实体类结构中提前占位，等待合适的业务场景出现后再进行具体的使用和赋值。
*/
@TableField("Reserved5")
private Integer reserved5;
/**
* 预留字段6。以字符串类型存在，同样是为了应对后续业务发展而预留的文本相关字段，具体用途和存储内容将根据未来业务调整来确定。
*/
@TableField("Reserved6")
private String reserved6;
/**
* 聊天室数据，以 BLOB（Binary Large Object，二进制大对象）形式存储。使用字节数组（byte[]）类型来承载，
// 这种形式常用于存储一些比较复杂、非结构化或者二进制格式的数据，比如群聊的一些特殊配置信息、历史聊天记录的二进制备份等，
// 通过指定typeHandler = ByteArrayTypeHandler.class，使用字节数组类型处理器来处理该字段与数据库之间的数据转换，确保二进制数据能够正确地在数据库中存储和读取，
// 满足一些特殊的业务数据存储需求，特别是当数据不适合用常规的文本或简单数值类型表示时，就可以利用这个字段进行存储。
*/
@TableField(value = "RoomData", typeHandler = ByteArrayTypeHandler.class)
private byte[] roomData;
/**
* 预留字段7。以整数类型存在，作为后续业务扩展的预留空间，暂时没有明确的业务含义，等待未来根据实际情况进行功能拓展时再做具体使用。
*/
@TableField("Reserved7")
private Integer reserved7;
/**
* 预留字段8。以字符串类型存在，同样是为了应对未来业务变化而预留的文本相关字段，目前处于备用状态，以备后续业务需求出现时能够灵活应对。
*/
@TableField("Reserved8")
private String reserved8;
}

135
wx-dump-admin/src/main/java/com/xcs/wx/domain/ChatRoomInfo.java
Unescape View File

@ -1,135 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* ChatRoomInfo类用于表示群聊信息相关的数据结构，它在系统中主要负责承载和传递群聊的详细信息，
* 例如在展示群聊详情、更新群聊公告、管理群聊状态等业务场景中发挥作用，通过将这些信息整合在一个类中，
* 便于与数据库进行交互以及在不同模块之间进行统一的数据传递和处理，提高代码的可读性和可维护性。
* @author xcs
* &#064;date 2024年01月09日 14时53分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，像通过调用getChatRoomName()、getAnnouncement()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要访问群聊信息的具体属性信息时，比如查看群聊名称、获取群聊公告内容等，这些getter方法能提供便捷的数据访问途径，便于后续业务逻辑使用这些数据。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当群聊公告内容发生变化，
// 可以通过调用setAnnouncement(String newAnnouncement)方法来更新announcement属性的值，从而保证对象的属性能够灵活地反映群聊信息的实际变化情况，增强了属性的可操作性。
// - 生成toString方法，该方法能将ChatRoomInfo对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前群聊信息对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个ChatRoomInfo对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及群聊信息对象比较的业务逻辑中（如判断两个群聊的信息是否一致等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@TableName("ChatRoomInfo")
// @TableName注解来自MyBatis Plus框架，用于指定该实体类对应的数据库表名，这里表明ChatRoomInfo类对应的数据库表名为"ChatRoomInfo"，
// 明确了该类与数据库表之间的映射关系，方便后续进行数据库操作（如数据的插入、查询、更新、删除等）时能准确地找到对应的表，确保数据的正确交互。
public class ChatRoomInfo {
/**
* 聊天室名称，作为主键。以字符串（String）类型存储，它是用于唯一标识一个群聊的关键信息，
// 在整个系统中，不同的群聊应该具有不同的名称，通过这个名称可以在数据库操作（如查询、更新、删除等）以及业务逻辑处理中准确地定位到具体的群聊，
// 同时在用户界面展示群聊列表、查看群聊详情等场景下，也是用户识别不同群聊的重要依据之一，并且作为主键，它在数据库表的关联、索引等操作中起着核心作用。
*/
@TableId("ChatRoomName")
// @TableId注解用于指定该属性对应的数据库表中的主键字段名，这里表明在数据库表"ChatRoomInfo"中，主键字段名为"ChatRoomName"，
// 即将类中的chatRoomName属性与数据库表中的主键列进行了关联，确保了在数据库操作时，能根据这个主键进行准确的记录定位和操作，保证数据的完整性和一致性。
private String chatRoomName;
/**
* 聊天室公告内容。以字符串（String）类型保存群聊的公告信息，公告通常是群管理员或者相关负责人发布的，用于向群聊成员传达一些重要的消息、规则或者通知等内容，
// 在群聊界面展示公告板块或者成员查看群聊相关规定等场景中会展示这个公告内容，并且可以通过相应的业务逻辑对其进行编辑、更新操作，方便群聊的管理和信息传达。
*/
@TableField("Announcement")
// @TableField注解用于指定该属性对应的数据库表中的字段名，这里表示在数据库表"ChatRoomInfo"中，该属性对应名为"Announcement"的字段，
// 明确了类属性与数据库表字段之间的映射关系，确保数据的正确存储和读取，便于与数据库进行交互来获取和修改公告内容信息。
private String announcement;
/**
* 信息版本号，默认为 0。使用整数（Integer）类型，用于记录群聊信息（尤其是公告内容等可能会更新变化的部分）的版本情况，
// 每次对群聊相关重要信息进行修改时，可以递增这个版本号，通过比较版本号可以判断不同成员所看到的群聊信息是否是最新的，
// 也有助于在一些数据同步、历史记录查看以及版本管理相关的业务逻辑中发挥作用，初始默认值为0，方便在创建群聊或者首次设置相关信息时进行初始化操作。
*/
@TableField("InfoVersion")
private Integer infoVersion;
/**
* 公告编辑者。以字符串（String）类型存储发布或者最近一次编辑群聊公告的人员的标识信息，这个标识可以是用户名、昵称或者其他能唯一确定编辑者身份的字符串形式，
// 在需要追溯公告来源、查看谁有权限修改公告以及进行相关的操作记录查询等业务场景中，公告编辑者属性起着重要作用，便于对群聊公告的编辑历史和责任归属进行管理。
*/
@TableField("AnnouncementEditor")
private String announcementEditor;
/**
* 公告发布时间，存储为时间戳，默认为 0。以长整数（Long）类型来存储公告发布那一刻的时间信息，时间戳一般是以某个特定的起始时间（如1970年1月1日00:00:00 UTC）为基准，
// 到公告实际发布时刻所经过的毫秒数或者秒数（具体取决于系统的时间精度设定），通过这个时间戳，可以准确判断公告的时效性、进行公告的排序展示（按照发布时间先后顺序），
// 以及在一些基于时间范围的查询（如查看某一时间段内发布的公告）等业务场景中发挥作用，初始默认值为0，在发布公告时会更新为实际的发布时间戳值。
*/
@TableField("AnnouncementPublishTime")
private Long announcementPublishTime;
/**
* 聊天室状态，默认为 0。以整数（Integer）类型表示群聊当前所处的状态，具体的状态值含义取决于业务的具体定义，
// 例如可以用不同的整数值来区分群聊正常、群聊被封禁、群聊维护中等等不同的状态情况，初始默认值为0，在创建群聊或者进行群聊状态变更操作时会用到这个默认值，
// 并且可以根据业务需求对其进行修改和判断，以实现不同的业务逻辑处理，比如根据群聊状态决定是否允许成员发送消息等操作。
*/
@TableField("ChatRoomStatus")
private Integer chatRoomStatus;
/**
* 预留字段1。以整数（Integer）类型存在，在软件开发中，预留字段通常是为了应对未来可能的业务扩展或者功能变化而提前在数据库表结构和实体类中设置的字段，
// 目前可能暂时没有具体的使用场景，但当后续需要增加新的属性或者功能时，可以利用这些预留字段进行扩展，避免了频繁修改数据库表结构和实体类结构带来的复杂性和风险。
*/
@TableField("Reserved1")
private Integer reserved1;
/**
* 预留字段2。以字符串（String）类型设置，和预留字段1类似，也是为了后续业务扩展预留的空间，只是其数据类型为字符串，可用于存储一些文本形式的扩展信息，
// 具体内容和用途会根据未来业务发展的需求来确定。
*/
@TableField("Reserved2")
private String reserved2;
/**
* 预留字段3。使用整数（Integer）类型，同样作为未来可能新增业务属性的预留空间，在当前阶段不参与主要的业务逻辑处理，但在系统升级、功能拓展时可能会被赋予相应的含义和使用方式。
*/
@TableField("Reserved3")
private Integer reserved3;
/**
* 预留字段4。以字符串（String）类型存储，是另一个为后续业务变化准备的文本形式的预留字段，以备不时之需，方便在不改动现有主要业务逻辑的基础上进行功能的扩展和完善。
*/
@TableField("Reserved4")
private String reserved4;
/**
* 预留字段5。为整数（Integer）类型，继续为未来可能的业务拓展预留，在数据库表和实体类结构中提前占位，等待合适的业务场景出现后再进行具体的使用和赋值。
*/
@TableField("Reserved5")
private Integer reserved5;
/**
* 预留字段6。以字符串（String）类型存在，同样是为了应对后续业务发展而预留的文本相关字段，具体用途和存储内容将根据未来业务调整来确定。
*/
@TableField("Reserved6")
private String reserved6;
/**
* 预留字段7。以整数（Integer）类型存在，作为后续业务扩展的预留空间，暂时没有明确的业务含义，等待未来根据实际情况进行功能拓展时再做具体使用。
*/
@TableField("Reserved7")
private Integer reserved7;
/**
* 预留字段8。以字符串（String）类型存在，同样是为了应对未来业务变化而预留的文本相关字段，目前处于备用状态，以备后续业务需求出现时能够灵活应对。
*/
@TableField("Reserved8")
private String reserved8;
}

257
wx-dump-admin/src/main/java/com/xcs/wx/domain/Contact.java
Unescape View File

@ -1,257 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* Contact类用于表示联系人相关的信息，在系统中对应数据库里存储联系人数据的实体，它整合了联系人各方面的属性，
* 方便与数据库进行交互以及在业务逻辑中对联系人相关的数据进行操作、传递和处理，例如在联系人的添加、查询、修改、删除以及展示等业务场景中发挥作用。
* @author xcs
* &#064;date 2023年12月22日 10时59分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体作用如下：
// - 自动生成所有私有属性对应的getter方法，例如通过调用getUserName()、getAlias()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要访问联系人的具体属性信息时，比如查看联系人的用户名、别名等，这些getter方法能提供便捷的数据访问途径，便于后续业务逻辑使用这些数据。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当联系人的备注信息发生变化，
// 可以通过调用setRemark(String newRemark)方法来更新remark属性的值，从而保证对象的属性能够灵活地反映联系人相关信息的实际变化情况，增强了属性的可操作性。
// - 生成toString方法，该方法能将Contact对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前联系人对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个Contact对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及联系人对象比较的业务逻辑中（如判断两个联系人的信息是否一致等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@TableName(value = "Contact", autoResultMap = true)
// @TableName注解来自于MyBatis Plus框架，用于指定该实体类对应的数据库表名，这里表明Contact类对应的数据库表名为"Contact"。
// 而autoResultMap = true这个配置表示自动构建结果映射，方便在查询数据库返回结果时，能自动将结果集的数据映射到该类的属性上，
// 减少了手动配置结果映射的繁琐过程，特别是当表结构和类结构有一定对应关系时，能更便捷地进行数据库与实体类之间的数据交互。
public class Contact {
/**
* 用户名，作为主键。以字符串（String）类型存储，它是用于唯一标识一个联系人的关键信息，
// 在整个系统中，不同的联系人应该具有不同的用户名，通过这个用户名可以在数据库操作（如查询、更新、删除等）以及业务逻辑处理中准确地定位到具体的联系人，
// 同时在用户界面展示联系人列表等场景下，也是用户识别不同联系人的重要依据之一，并且作为主键，它在数据库表的关联、索引等操作中起着核心作用。
*/
@TableId(value = "UserName")
// @TableId注解用于指定该属性对应的数据库表中的主键字段名，这里表明在数据库表"Contact"中，主键字段名为"UserName"，
// 即将类中的userName属性与数据库表中的主键列进行了关联，确保了在数据库操作时，能根据这个主键进行准确的记录定位和操作，保证数据的完整性和一致性。
private String userName;
/**
* 别名。以字符串（String）类型保存联系人的别名信息，别名可能是用户为联系人另外设置的一个便于称呼或者识别的名称，
// 它可以与用户名、昵称等有所不同，在一些特定的业务场景下（如快捷查找、特定分组标识等），别名能够提供更方便的操作方式，用于辅助对联系人的管理和使用。
*/
@TableField("Alias")
// @TableField注解用于指定该属性对应的数据库表中的字段名，这里表示在数据库表"Contact"中，该属性对应名为"Alias"的字段，
// 明确了类属性与数据库表字段之间的映射关系，确保数据的正确存储和读取，便于与数据库进行交互来获取和修改别名信息。
private String alias;
/**
* 加密用户名。以字符串（String）类型存储经过加密处理后的用户名信息，加密的目的通常是为了保护用户隐私，
// 在涉及数据传输、存储或者一些需要增强安全性的业务场景中，对用户名进行加密可以防止用户名被恶意获取和利用，
// 并且在特定的验证、解密等相关业务逻辑中会使用到这个加密后的用户名信息。
*/
@TableField("EncryptUserName")
private String encryptUserName;
/**
* 删除标志，默认为0。使用整数（Integer）类型，这个标志用于表示联系人是否已被删除的状态，
// 一般来说，0表示联系人未被删除，而其他特定的值（如1等，具体取决于业务定义）可以表示联系人已被删除，
// 在进行数据清理、查询有效联系人列表或者恢复已删除联系人等业务操作时，会依据这个删除标志来进行相应的逻辑处理。
*/
@TableField("DelFlag")
private Integer delFlag;
/**
* 类型，默认为0。以整数类型表示联系人的类型，具体的类型划分取决于业务的具体设定，
// 例如可以用不同的整数值来区分是好友、公众号、企业联系人等不同类型的联系人，初始默认值为0，在创建或初始化联系人信息时会用到这个默认值，
// 后续可根据实际情况对其进行修改和判断，以实现不同类型联系人对应的业务逻辑处理。
*/
@TableField("Type")
private Integer type;
/**
* 验证标志，默认为0。同样为整数类型，用于表示联系人是否经过验证等相关状态，
// 比如在添加好友等场景中，0可能表示未验证，1表示已验证通过等情况，在涉及联系人验证相关的业务逻辑（如显示验证提示、限制未验证联系人的部分操作等）中会用到这个标志进行判断和处理。
*/
@TableField("VerifyFlag")
private Integer verifyFlag;
/**
* 预留字段1。以整数（Integer）类型存在，在软件开发中，预留字段通常是为了应对未来可能的业务扩展或者功能变化而提前在数据库表结构和实体类中设置的字段，
// 目前可能暂时没有具体的使用场景，但当后续需要增加新的属性或者功能时，可以利用这些预留字段进行扩展，避免了频繁修改数据库表结构和实体类结构带来的复杂性和风险。
*/
@TableField("Reserved1")
private Integer reserved1;
/**
* 预留字段2。以整数（Integer）类型设置，和预留字段1类似，也是为了后续业务扩展预留的空间，
// 其具体用途会根据未来业务发展的需求来确定，在当前阶段不参与主要的业务逻辑处理，但为系统升级、功能拓展提前做好了准备。
*/
@TableField("Reserved2")
private Integer reserved2;
/**
* 预留字段3。以字符串（String）类型存储，同样是为了后续业务扩展预留的空间，可用于存储一些文本形式的扩展信息，
// 具体内容和用途将根据未来业务调整来确定，方便在不改动现有主要业务逻辑的基础上进行功能的扩展和完善。
*/
@TableField("Reserved3")
private String reserved3;
/**
* 预留字段4。以字符串（String）类型存在，也是为了应对未来业务变化而预留的文本相关字段，以备后续业务需求出现时能够灵活应对，
// 目前处于备用状态，等待合适的业务场景出现后再进行具体的使用。
*/
@TableField("Reserved4")
private String reserved4;
/**
* 备注信息。以字符串（String）类型保存用户为联系人添加的备注内容，备注可以是对联系人的一些个性化描述、相关备注事项等，
// 方便用户更好地识别和记忆联系人，例如可以备注联系人的工作单位、与自己的关系等信息，在查看联系人详情、进行联系人分类管理等场景中会展示和使用备注信息。
*/
@TableField("Remark")
private String remark;
/**
* 昵称。以字符串（String）类型存储联系人对外展示的称呼，也就是昵称，它通常是联系人自行设置或者用户为其设定的一个比较友好、个性化的名称，
// 在联系人列表展示、聊天界面等场景中，昵称更便于用户直观地识别联系人，增强了用户与联系人之间交互的友好性。
*/
@TableField("NickName")
private String nickName;
/**
* 标签ID列表。以字符串（String）类型保存与联系人相关的标签ID信息，这些标签可以用于对联系人进行分类、分组等管理操作，
// 例如可以用不同的标签来区分工作联系人、生活联系人、兴趣爱好相同的联系人等，标签ID列表可能是以某种特定格式（如逗号分隔的ID字符串等）存储多个标签的标识信息，
// 在进行联系人筛选、分类查询等业务场景中会用到这些标签ID信息。
*/
@TableField("LabelIDList")
private String labelIdList;
/**
* 域列表。以字符串（String）类型存储联系人所属的域相关信息，域的概念可能因业务场景而异，
// 比如在企业应用中可以表示不同的部门、项目组等划分，在社交应用中可能表示不同的社交圈子等，通过域列表可以更清晰地对联系人进行组织和管理，
// 在涉及联系人归属范围判断、跨域操作限制等业务逻辑中会使用到域列表信息。
*/
@TableField("DomainList")
private String domainList;
/**
* 聊天室类型。以整数（Integer）类型表示联系人所在的聊天室（如果涉及群聊相关场景）的类型，
// 具体的聊天室类型划分取决于业务定义，例如可以区分普通群聊、临时群聊、特定主题群聊等不同类型，在群聊相关的业务处理（如群聊功能权限判断、群聊分类统计等）中会用到这个属性进行区分和操作。
*/
@TableField("ChatRoomType")
private Integer chatRoomType;
/**
* 昵称的拼音首字母。以字符串（String）类型存储联系人昵称的拼音首字母信息，
// 这个属性通常用于实现一些便捷的查找、排序功能，比如按照拼音首字母对联系人进行排序，或者通过输入拼音首字母快速定位联系人等，
// 方便用户在大量联系人中更高效地查找和操作特定的联系人。
*/
@TableField("PYInitial")
private String pyInitial;
/**
* 昵称的完整拼音。以字符串（String）类型保存联系人昵称的完整拼音信息，与拼音首字母类似，
// 完整拼音也可用于更精准的查找、排序以及一些基于拼音的匹配等业务操作，例如实现模糊拼音搜索联系人等功能，进一步提升联系人查找的便捷性。
*/
@TableField("QuanPin")
private String quanPin;
/**
* 备注的拼音首字母。以字符串（String）类型存储联系人备注信息的拼音首字母，同样可用于辅助查找、排序等操作，
// 特别是当用户对备注内容有印象但记不清具体文字时，可以通过拼音首字母来快速定位对应的联系人，提高操作效率。
*/
@TableField("RemarkPYInitial")
private String remarkPyInitial;
/**
* 备注的完整拼音。以字符串（String）类型保存联系人备注的完整拼音，其作用与备注的拼音首字母类似，
// 可以基于完整拼音实现更细致的查找、匹配等功能，方便用户根据备注相关的拼音信息来操作联系人。
*/
@TableField("RemarkQuanPin")
private String remarkQuanPin;
/**
* 大头像URL。以字符串（String）类型存放联系人的大头像对应的网络链接地址，在需要展示联系人较大尺寸头像的业务场景中（如联系人详情页面等），
// 通过这个链接可以获取对应的大头像图片并进行展示，让用户更清晰地查看联系人头像，提升用户体验和视觉效果。
*/
@TableField("BigHeadImgUrl")
private String bigHeadImgUrl;
/**
* 小头像URL。以字符串（String）类型保存联系人的小头像对应的网络链接地址，与大头像相对应，
// 小头像可能在一些列表展示等场景中使用，以节省空间同时又能让用户大致识别联系人，通过这个链接可以获取小头像图片进行展示，满足不同场景下的头像展示需求。
*/
@TableField("SmallHeadImgUrl")
private String smallHeadImgUrl;
/**
* 头像的MD5值。以字符串（String）类型存储联系人头像文件的MD5值，MD5是一种常用的哈希算法生成的摘要信息，
// 在这里主要用于验证头像文件的完整性、唯一性以及进行头像文件的比对等操作，例如在头像更新时，可以通过比较MD5值来判断头像是否真正发生了变化，
// 或者在从不同来源获取头像时，验证其是否是同一个头像文件，确保头像数据的准确性和一致性。
*/
@TableField("HeadImgMd5")
private String headImgMd5;
/**
* 聊天室通知标志，默认为0。以整数（Integer）类型表示是否接收该联系人所在聊天室（如果是群聊场景）的通知消息，
// 0通常表示不接收通知，而其他值（如1等，具体取决于业务定义）可以表示接收通知，在群聊消息提醒设置、根据用户偏好控制通知等业务逻辑中会用到这个标志进行判断和处理。
*/
@TableField("ChatRoomNotify")
private Integer chatRoomNotify;
/**
* 预留字段5。以整数（Integer）类型存在，同样是为了未来业务扩展预留的空间，暂时没有明确的业务含义，
// 等待未来根据实际情况进行功能拓展时再做具体使用，为系统的可扩展性提供了一定的灵活性。
*/
@TableField("Reserved5")
private Integer reserved5;
/**
* 预留字段6。以字符串（String）类型存储，也是为后续业务变化准备的文本相关字段，目前没有具体用途，
// 以备后续业务需求出现时能够灵活应对，确保系统可以在不大量改动现有结构的基础上进行功能的扩充。
*/
@TableField("Reserved6")
private String reserved6;
/**
* 预留字段7。以字符串（String）类型存在，同样作为预留的文本字段，用于应对未来可能出现的业务调整和功能扩展需求，
// 其具体内容和使用方式将根据后续业务发展来确定。
*/
@TableField("Reserved7")
private String reserved7;
/**
* 预留字段8。以整数（Integer）类型存在，为未来可能新增的业务属性预留空间，在当前阶段不参与主要的业务逻辑处理，
// 但在系统后续升级、功能拓展时可能会被赋予相应的含义和使用方式，便于系统的持续发展和优化。
*/
@TableField("Reserved8")
private Integer reserved8;
/**
* 预留字段9。以整数（Integer）类型设置，也是作为未来业务扩展的预留部分，其具体作用和用途有待后续根据业务变化来确定，
// 提前设置这些预留字段可以减少因业务拓展带来的数据库和代码结构频繁变动的问题。
*/
@TableField("Reserved9")
private Integer reserved9;
/**
* 预留字段10。以字符串（String）类型存储，同样是为了后续业务发展预留的文本形式的字段，方便在需要时添加新的文本相关信息，
// 增强系统对未来业务需求变化的适应性。
*/
@TableField("Reserved10")
private String reserved10;
/**
* 预留字段11。以字符串（String）类型存在，也是为了应对未来业务变化而预留的文本相关字段，目前处于备用状态，
// 等待合适的业务场景出现后再进行具体的使用，有助于系统在长期发展中保持可扩展性。
*/
@TableField("Reserved11")
private String reserved11;}

72
wx-dump-admin/src/main/java/com/xcs/wx/domain/ContactHeadImg.java
Unescape View File

@ -1,72 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import org.apache.ibatis.type.ByteArrayTypeHandler;
/**
* ContactHeadImg类是联系人头像表对应的实体类，用于在系统中表示和处理与联系人头像相关的数据，
* 它将联系人头像的关键信息整合在一起，方便与数据库进行交互，例如在存储、查询、更新联系人头像数据等业务场景中发挥作用，
* 确保联系人头像相关的数据能在系统中准确地流转和管理。
* @author xcs
* &#064;date 2023年12月22日 10时59分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，像通过调用getUsrName()、getCreateTime()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要访问联系人头像相关的具体属性信息时，比如查看用户名、获取头像创建时间等，这些getter方法能提供便捷的数据访问途径，便于后续业务逻辑使用这些数据。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当联系人头像的MD5值发生变化，
// 可以通过调用setHeadImgMd5(String newHeadImgMd5)方法来更新headImgMd5属性的值，从而保证对象的属性能够灵活地反映联系人头像相关信息的实际变化情况，增强了属性的可操作性。
// - 生成toString方法，该方法能将ContactHeadImg对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前联系人头像对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个ContactHeadImg对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及联系人头像对象比较的业务逻辑中（如判断两个联系人头像的相关属性是否一致等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@TableName("ContactHeadImg1")
// @TableName注解来自MyBatis Plus框架，用于指定该实体类对应的数据库表名，这里表明ContactHeadImg类对应的数据库表名为"ContactHeadImg1"，
// 明确了该类与数据库表之间的映射关系，方便后续进行数据库操作（如数据的插入、查询、更新、删除等）时能准确地找到对应的表，确保数据的正确交互。
public class ContactHeadImg {
/**
* 用户名，主键。以字符串（String）类型存储，它是用于唯一标识与该头像相关联的联系人的关键信息，
// 在整个系统中，不同联系人的头像数据通过这个用户名进行区分，通过这个用户名可以在数据库操作（如查询、更新、删除等）以及业务逻辑处理中准确地定位到具体联系人的头像记录，
// 并且作为主键，它在数据库表的关联、索引等操作中起着核心作用，确保数据的完整性和一致性，方便对联系人头像数据进行精准的管理。
*/
@TableId("usrName")
// @TableId注解用于指定该属性对应的数据库表中的主键字段名，这里表明在数据库表"ContactHeadImg1"中，主键字段名为"usrName"，
// 即将类中的usrName属性与数据库表中的主键列进行了关联，确保了在数据库操作时，能根据这个主键进行准确的记录定位和操作。
private String usrName;
/**
* 创建时间。以整数（Integer）类型存储联系人头像数据的创建时间信息，这个时间可以是某个特定时间格式转换后的整数值，
// 例如可能是以时间戳（从某个固定起始时间点到头像创建时刻所经过的秒数或毫秒数，常见以1970年1月1日00:00:00 UTC为起始点）的形式存在，
// 在头像管理中，创建时间可用于判断头像的新旧程度、进行头像历史记录查询以及按照时间顺序对头像数据进行排序等业务操作，方便对头像数据的生命周期进行管理。
*/
@TableField("createTime")
// @TableField注解用于指定该属性对应的数据库表中的字段名，这里表示在数据库表"ContactHeadImg1"中，该属性对应名为"createTime"的字段，
// 明确了类属性与数据库表字段之间的映射关系，确保数据的正确存储和读取，便于与数据库进行交互来获取和修改创建时间信息。
private Integer createTime;
/**
* 小头像数据。以字节数组（byte[]）类型存储联系人的小头像的具体图像数据，使用ByteArrayTypeHandler类作为类型处理器，
// 因为图像数据本身是二进制格式的，字节数组能够很好地承载这些二进制数据，方便在数据库中进行存储和读取，在需要展示联系人小头像的业务场景中（比如联系人列表中以较小尺寸展示头像），
// 可以通过读取这个字节数组数据还原出小头像图像进行展示，满足不同场景下对联系人头像展示的需求。
*/
@TableField(value = "smallHeadBuf", typeHandler = ByteArrayTypeHandler.class)
private byte[] smallHeadBuf;
/**
* 头像MD5值。以字符串（String）类型存储联系人头像文件的MD5值，MD5是一种常用的哈希算法生成的摘要信息，
// 在这里主要用于验证头像数据的完整性、唯一性以及进行头像文件的比对等操作，例如在头像更新时，可以通过比较MD5值来判断头像是否真正发生了变化，
// 或者在从不同来源获取头像时，验证其是否是同一个头像文件，确保头像数据的准确性和一致性，保障系统中联系人头像相关业务的正常运行。
*/
@TableField("m_headImgMD5")
private String headImgMd5;
}

83
wx-dump-admin/src/main/java/com/xcs/wx/domain/ContactHeadImgUrl.java
Unescape View File

@ -1,83 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* ContactHeadImgUrl类是用于表示联系人头像相关信息的实体类，在系统中主要负责承载和传递联系人头像的关键属性数据，
* 例如在展示联系人头像、头像数据验证以及应对未来可能的功能扩展等业务场景中发挥作用，通过将这些信息整合在一个类中，
* 便于与数据库进行交互以及在不同模块之间进行统一的数据传递和处理，提高代码的可读性和可维护性。
* @author xcs
* &#064;date 2023年12月21日 18时31分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，像通过调用getUsrName()、getSmallHeadImgUrl()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要访问联系人头像相关的具体属性信息时，比如查看用户名、获取小头像或大头像的URL地址等，这些getter方法能提供便捷的数据访问途径，便于后续业务逻辑使用这些数据。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当联系人的大头像图片的URL地址发生变化，
// 可以通过调用setBigHeadImgUrl(String newBigHeadImgUrl)方法来更新bigHeadImgUrl属性的值，从而保证对象的属性能够灵活地反映联系人头像相关信息的实际变化情况，增强了属性的可操作性。
// - 生成toString方法，该方法能将ContactHeadImgUrl对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前联系人头像对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个ContactHeadImgUrl对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及联系人头像对象比较的业务逻辑中（如判断两个联系人的头像相关属性是否一致等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@TableName("ContactHeadImgUrl")
// @TableName注解来自MyBatis Plus框架，用于指定该实体类对应的数据库表名，这里表明ContactHeadImgUrl类对应的数据库表名为"ContactHeadImgUrl"，
// 明确了该类与数据库表之间的映射关系，方便后续进行数据库操作（如数据的插入、查询、更新、删除等）时能准确地找到对应的表，确保数据的正确交互。
public class ContactHeadImgUrl {
/**
* 用户名。以字符串（String）类型存储，它是用于唯一标识与该头像相关联的联系人的关键信息，
// 在整个系统中，不同联系人的头像信息通过这个用户名进行区分，通过这个用户名可以在数据库操作（如查询、更新、删除等）以及业务逻辑处理中准确地定位到具体联系人的头像记录，
// 并且在展示联系人头像、进行头像相关数据管理等场景下，也是重要的关联依据，确保头像数据与对应的联系人能准确匹配。
*/
@TableId("usrName")
// @TableId注解用于指定该属性对应的数据库表中的主键字段名，这里表明在数据库表"ContactHeadImgUrl"中，主键字段名为"usrName"，
// 即将类中的usrName属性与数据库表中的主键列进行了关联，确保了在数据库操作时，能根据这个主键进行准确的记录定位和操作，保证数据的完整性和一致性。
private String usrName;
/**
* 小头像图片的URL地址。以字符串（String）类型存放联系人小头像图片对应的网络链接地址，在需要展示联系人小头像的业务场景中（比如联系人列表中以较小尺寸展示头像），
// 通过这个URL地址，系统可以从相应的服务器或者存储位置获取小头像图片并进行展示，满足不同展示场景对头像尺寸和展示效果的需求，方便用户快速识别联系人。
*/
@TableField("smallHeadImgUrl")
// @TableField注解用于指定该属性对应的数据库表中的字段名，这里表示在数据库表"ContactHeadImgUrl"中，该属性对应名为"smallHeadImgUrl"的字段，
// 明确了类属性与数据库表字段之间的映射关系，确保数据的正确存储和读取，便于与数据库进行交互来获取和修改小头像图片的URL地址信息。
private String smallHeadImgUrl;
/**
* 大头像图片的URL地址。同样以字符串类型存储联系人大头像图片对应的网络链接地址，与小头像相对应，大头像通常在查看联系人详细信息等场景下展示，
// 通过这个URL地址，系统可以获取大头像图片进行展示，能让用户更清晰地查看联系人头像细节，提升用户体验，同时也方便根据不同的业务需求灵活切换头像展示的尺寸。
*/
@TableField("bigHeadImgUrl")
private String bigHeadImgUrl;
/**
* 头像图片的MD5校验值。以字符串（String）类型存储联系人头像图片的MD5值，MD5是一种常用的哈希算法生成的摘要信息，
// 在这里主要用于验证头像图片的完整性、唯一性以及进行头像文件的比对等操作，例如在头像更新时，可以通过比较MD5值来判断头像是否真正发生了变化，
// 或者在从不同来源获取头像时，验证其是否是同一个头像文件，确保头像数据的准确性和一致性，保障系统中联系人头像相关业务的正常运行。
*/
@TableField("headImgMd5")
private String headImgMd5;
/**
* 预留字段0，可能用于未来的扩展或特定的内部用途。以整数（Integer）类型存在，在软件开发中，预留字段通常是为了应对未来可能的业务扩展或者功能变化而提前在数据库表结构和实体类中设置的字段，
// 目前可能暂时没有具体的使用场景，但当后续需要增加新的属性或者功能时，可以利用这些预留字段进行扩展，避免了频繁修改数据库表结构和实体类结构带来的复杂性和风险。
*/
@TableField("reverse0")
private Integer reverse0;
/**
* 预留字段1，同样可能用于未来的扩展或特定的内部用途。以字符串（String）类型设置，和预留字段0类似，也是为了后续业务扩展预留的空间，
// 其具体内容和用途会根据未来业务发展的需求来确定，在当前阶段不参与主要的业务逻辑处理，但为系统升级、功能拓展提前做好了准备。
*/
@TableField("reverse1")
private String reverse1;
}

76
wx-dump-admin/src/main/java/com/xcs/wx/domain/ContactLabel.java
Unescape View File

@ -1,76 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* 联系人标签
* 这个类用于表示联系人标签相关的实体信息，通过MyBatis Plus的注解来映射数据库表中的字段，
* 借助Lombok的 @Data 注解自动生成常用的Getter、Setter、ToString等方法，简化代码编写。
*
* @author xcs
* &#064;date 2023年12月22日 16时53分
**/
@Data
@TableName("ContactLabel") // 表明该实体类对应的数据库表名为 "ContactLabel"，用于MyBatis Plus与数据库表进行关联映射
public class ContactLabel {
/**
* 标签Id
* 通过 @TableId 注解指定该字段对应数据库表中的主键列，名为 "LabelId"，用于唯一标识每个联系人标签记录。
*/
@TableId("LabelId")
private String labelId;
/**
* 标签名称
* 使用 @TableField 注解表明该字段对应数据库表中的 "LabelName" 列，用于存储联系人标签的具体名称。
*/
@TableField("LabelName")
private String labelName;
/**
* 预留字段1。
* 该字段对应数据库表中的 "Reserved1" 列，可能用于未来功能扩展等预留用途，目前为Integer类型，具体含义根据业务需求而定。
*/
@TableField("Reserved1")
private Integer reserved1;
/**
* 预留字段2。
* 对应数据库表中的 "Reserved2" 列，同样是预留字段，用于可能的后续业务拓展，当前是Integer类型，其具体作用由业务场景决定。
*/
@TableField("Reserved2")
private Integer reserved2;
/**
* 预留字段3。
* 此为数据库表中 "Reserved3" 列对应的实体字段，预留下来以满足后续可能的业务变化，是String类型，其具体存储内容和使用场景有待后续确定。
*/
@TableField("Reserved3")
private String reserved3;
/**
* 预留字段4。
* 与数据库表中的 "Reserved4" 列关联，作为预留字段存在，方便未来根据业务发展添加新的功能逻辑，类型为String，实际用途依据具体业务而定。
*/
@TableField("Reserved4")
private String reserved4;
/**
* 预留字段5。
* 对应数据库表的 "Reserved5" 列，属于预留性质的字段，为String类型，以备后续业务需要而使用，具体功能需结合业务需求明确。
*/
@TableField("Reserved5")
private String reserved5;
/**
* 响应数据
* 关联数据库表中的 "RespData" 列，用于存储和该联系人标签相关的响应数据，具体数据格式和内容取决于具体的业务逻辑和交互情况。
*/
@TableField("RespData")
private String respData;
}

50
wx-dump-admin/src/main/java/com/xcs/wx/domain/FTSContactContent.java
Unescape View File

@ -1,50 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* FTSContactContent
* 该类表示与联系人相关的内容实体，用于映射数据库中对应的表结构，通过MyBatis Plus的相关注解来定义与数据库表字段的关联关系，
* 同时借助Lombok的 @Data 注解来自动生成常用的Getter、Setter、ToString等方法，减少代码编写的重复性工作。
*
* @author xcs
* &#064;date 2024年6月14日15:12:27
**/
@Data
@TableName(value = "FTSContact15_content", autoResultMap = true)
// @TableName注解用于指定该实体类对应的数据库表名是 "FTSContact15_content"，autoResultMap = true表示自动映射结果集，方便查询结果的映射处理
public class FTSContactContent {
/**
* 本地唯一标识符，自增。
* 该字段作为实体的唯一标识，对应数据库表中的 "docid" 列，通过 @TableId 注解进行标识，并且其类型设置为自增（IdType.AUTO），
* 意味着在向数据库插入新记录时，该值会按照数据库的自增规则自动生成，方便对每条记录进行区分和索引。
*/
@TableId(value = "docid", type = IdType.AUTO)
private Integer docId;
/**
* alias
* 使用 @TableField 注解表明该字段对应数据库表中的 "c0alias" 列，用于存储联系人的别名信息，具体的别名内容根据实际业务场景下的联系人设置而定。
*/
@TableField("c0alias")
private String alias;
/**
* nickname
* 通过 @TableField 注解关联数据库表中的 "c1nickname" 列，该字段用于存放联系人的昵称，是识别联系人的常用称呼方式之一，其具体值由用户设置或者业务逻辑赋值。
*/
@TableField("c1nickname")
private String nickname;
/**
* c2remark
* 对应数据库表的 "c2remark" 列，这个字段通常用于存储对联系人的备注信息，比如关于联系人的特殊说明、备注标签等，方便用户更好地识别和管理联系人。
*/
@TableField("c2remark")
private String remark;
}

63
wx-dump-admin/src/main/java/com/xcs/wx/domain/FTSRecentUsed.java
Unescape View File

@ -1,63 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* FTSRecentUsed类用于表示最近使用关键字相关的信息，在系统中主要负责承载和传递与用户近期查询所使用关键字的关键属性数据，
* 例如在实现搜索历史记录、根据用户常用搜索内容进行个性化推荐等业务场景中发挥作用，通过将这些信息整合在一个类中，
* 便于与数据库进行交互以及在不同模块之间进行统一的数据传递和处理，提高代码的可读性和可维护性。
* @author xcs
* &#064;date 2024年01月23日 11时09分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，像通过调用getQueryText()、getUsername()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要访问最近使用关键字相关的具体属性信息时，比如查看查询的内容、获取用户名等，这些getter方法能提供便捷的数据访问途径，便于后续业务逻辑使用这些数据。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当查询的内容发生变化，
// 可以通过调用setQueryText(String newQueryText)方法来更新queryText属性的值，从而保证对象的属性能够灵活地反映最近使用关键字相关信息的实际变化情况，增强了属性的可操作性。
// - 生成toString方法，该方法能将FTSRecentUsed对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前最近使用关键字对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个FTSRecentUsed对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及最近使用关键字对象比较的业务逻辑中（如判断两个用户的搜索历史记录是否一致等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@TableName("FTSRecentUsed15")
// @TableName注解来自MyBatis Plus框架，用于指定该实体类对应的数据库表名，这里表明FTSRecentUsed类对应的数据库表名为"FTSRecentUsed15"，
// 明确了该类与数据库表之间的映射关系，方便后续进行数据库操作（如数据的插入、查询、更新、删除等）时能准确地找到对应的表，确保数据的正确交互。
public class FTSRecentUsed {
/**
* 查询的内容。以字符串（String）类型存储用户最近进行查询操作时所输入的关键字内容，
// 这是体现用户搜索意图的关键信息，通过记录这些查询内容，可以分析用户的兴趣点、常用搜索需求等，
// 在搜索历史展示、基于历史搜索进行智能提示或者个性化推荐等业务场景中，查询的内容属性起着重要作用，便于为用户提供更贴合需求的服务。
*/
@TableId("queryText")
// @TableId注解用于指定该属性对应的数据库表中的主键字段名，这里表明在数据库表"FTSRecentUsed15"中，主键字段名为"queryText"，
// 即将类中的queryText属性与数据库表中的主键列进行了关联，确保了在数据库操作时，能根据这个主键进行准确的记录定位和操作，保证数据的完整性和一致性。
private String queryText;
/**
* 用户名。以整数（Integer）类型存储进行查询操作的用户的标识信息，这个用户名可能是以系统内部特定的编码形式存在，
// 通过这个用户名可以区分不同用户的搜索历史记录，明确各条最近使用关键字是属于哪个具体用户的，方便在多用户环境下进行数据的准确管理和个性化服务的提供，
// 例如为不同用户分别展示其对应的搜索历史，或者基于不同用户的搜索习惯进行针对性的推荐等操作。
*/
@TableField("username")
// @TableField注解用于指定该属性对应的数据库表中的字段名，这里表示在数据库表"FTSRecentUsed15"中，该属性对应名为"username"的字段，
// 明确了类属性与数据库表字段之间的映射关系，确保数据的正确存储和读取，便于与数据库进行交互来获取和修改用户名信息。
private Integer username;
/**
* 修改时间。以字符串（String）类型保存最近一次对该条搜索关键字记录进行修改（比如更新其使用时间等操作）的时间信息，
// 时间的存储格式可能是常见的日期时间格式（如"yyyy-MM-dd HH:mm:ss"等），通过这个修改时间，可以了解用户使用关键字的时间顺序、判断关键字的时效性，
// 在搜索历史排序展示（按照时间先后顺序展示近期使用的关键字）、清理过期的搜索记录等业务操作中会用到这个属性，方便对搜索历史数据进行有效的管理。
*/
@TableField("updateTime")
private String updateTime;
}

110
wx-dump-admin/src/main/java/com/xcs/wx/domain/Feeds.java
Unescape View File

@ -1,110 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* Feeds类用于表示朋友圈相关的信息，在系统中对应数据库里存储朋友圈动态数据的实体，它整合了朋友圈动态各方面的关键属性，
* 方便与数据库进行交互以及在业务逻辑中对朋友圈相关的数据进行操作、传递和处理，例如在朋友圈动态的发布、查询、展示、状态管理等业务场景中发挥作用。
* @author xcs
* &#064;date 2024年01月03日 16时41分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，例如通过调用getFeedId()、getCreateTime()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要访问朋友圈动态的具体属性信息时，比如查看动态的唯一标识ID、获取创建时间等，这些getter方法能提供便捷的数据访问途径，便于后续业务逻辑使用这些数据。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当朋友圈动态的内容文本发生变化，
// 可以通过调用setContent(String newContent)方法来更新content属性的值，从而保证对象的属性能够灵活地反映朋友圈动态相关信息的实际变化情况，增强了属性的可操作性。
// - 生成toString方法，该方法能将Feeds对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前朋友圈动态对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个Feeds对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及朋友圈动态对象比较的业务逻辑中（如判断两条朋友圈动态的信息是否一致等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@TableName(value = "FeedsV20", autoResultMap = true)
// @TableName注解来自于MyBatis Plus框架，用于指定该实体类对应的数据库表名，这里表明Feeds类对应的数据库表名为"FeedsV20"。
// 而autoResultMap = true这个配置表示自动构建结果映射，方便在查询数据库返回结果时，能自动将结果集的数据映射到该类的属性上，
// 减少了手动配置结果映射的繁琐过程，特别是当表结构和类结构有一定对应关系时，能更便捷地进行数据库与实体类之间的数据交互。
public class Feeds {
/**
* 动态的唯一标识ID。以长整数（Long）类型存储，它是用于在整个系统中唯一标识一条朋友圈动态的关键信息，
// 不同的朋友圈动态应该具有不同的ID，通过这个ID可以在数据库操作（如查询、更新、删除等）以及业务逻辑处理中准确地定位到具体的动态记录，
// 同时在朋友圈的各种业务场景中，比如查看特定动态详情、进行动态的排序展示等，也是重要的依据，方便对朋友圈动态进行精准的管理和操作。
*/
@TableId("FeedId")
// @TableId注解用于指定该属性对应的数据库表中的主键字段名，这里表明在数据库表"FeedsV20"中，主键字段名为"FeedId"，
// 即将类中的feedId属性与数据库表中的主键列进行了关联，确保了在数据库操作时，能根据这个主键进行准确的记录定位和操作，保证数据的完整性和一致性。
private Long feedId;
/**
* 创建时间，存储为整数形式。使用整数（Integer）类型来保存朋友圈动态创建那一刻的时间信息，这个时间的存储形式可能是时间戳（例如从某个固定起始时间点到动态创建时刻所经过的秒数或毫秒数，常见以1970年1月1日00:00:00 UTC为起始点），
// 也可能是经过特定格式转换后的整数值，在朋友圈动态管理中，创建时间可用于按照时间顺序对动态进行排序展示（如按发布时间先后展示朋友圈）、进行动态历史记录查询以及判断动态的时效性等业务操作，方便对朋友圈动态的生命周期进行管理。
*/
@TableField("CreateTime")
// @TableField注解用于指定该属性对应的数据库表中的字段名，这里表示在数据库表"FeedsV20"中，该属性对应名为"CreateTime"的字段，
// 明确了类属性与数据库表字段之间的映射关系，确保数据的正确存储和读取，便于与数据库进行交互来获取和修改创建时间信息。
private Integer createTime;
/**
* 故障ID，用于记录相关故障信息。以整数（Integer）类型存储，这个属性主要用于在朋友圈动态出现异常情况时，关联对应的故障记录ID，
// 例如当动态发布失败、展示出现问题等故障发生时，可以通过这个故障ID去查找具体的故障原因、相关的报错日志等详细信息，便于进行故障排查和系统维护，保障朋友圈功能的正常运行。
*/
@TableField("FaultId")
private Integer faultId;
/**
* 动态的类型。同样为整数（Integer）类型，用于区分不同种类的朋友圈动态，具体的类型划分取决于业务的具体定义，
// 比如可以用不同的整数值来表示是纯文本动态、图文动态、视频动态等不同类型，在朋友圈动态的展示、处理逻辑中，会根据这个类型属性来采取不同的展示方式、业务操作，以满足多样化的朋友圈功能需求。
*/
@TableField("Type")
private Integer type;
/**
* 发布用户的用户名。以字符串（String）类型存储发布这条朋友圈动态的用户的用户名信息，通过这个用户名可以明确知道是哪位用户发布了该动态，
// 在朋友圈的展示、权限管理等业务场景中起着重要作用，比如只展示当前用户及其好友的朋友圈动态，就需要通过这个用户名来判断动态的发布者与当前用户的关系，从而决定是否展示该动态。
*/
@TableField("UserName")
private String userName;
/**
* 动态的状态。以整数（Integer）类型表示朋友圈动态当前所处的状态，具体的状态值含义取决于业务的具体设定，
// 例如可以用不同的整数值来区分动态是正常发布状态、已删除状态、审核中状态（如果有审核机制的话）等不同情况，在朋友圈动态的管理、操作判断等业务逻辑中会依据这个状态属性来进行相应的处理。
*/
@TableField("Status")
private Integer status;
/**
* 扩展标志，用于存储额外信息。以整数（Integer）类型存在，这个属性可以用于承载一些额外的、与朋友圈动态相关的标志信息，具体含义取决于业务的具体需求，
// 例如可以通过不同的位来表示是否开启了某些扩展功能（如动态是否可评论、是否可转发等扩展功能的标志位），方便在业务逻辑中根据这些标志来实现更丰富、灵活的朋友圈功能。
*/
@TableField("ExtFlag")
private Integer extFlag;
/**
* 隐私标志，指示动态的隐私级别。同样是整数（Integer）类型，用于设定和表示朋友圈动态的隐私程度，不同的整数值对应不同的隐私级别，
// 比如0表示公开，所有人都能看到；1表示仅好友可见；2表示仅自己可见等等，在朋友圈动态的展示权限控制方面起着关键作用，根据用户设置的隐私标志来决定哪些用户能够查看对应的动态内容。
*/
@TableField("PrivFlag")
private Integer privFlag;
/**
* 字符串ID，可能用于关联其他数据。以字符串（String）类型存储，它的具体用途取决于业务场景，有可能是用于和其他相关数据表进行关联，
// 通过这个字符串ID去匹配其他表中的对应记录，实现更复杂的数据关联和业务逻辑处理，例如关联到动态的评论表、点赞表等相关数据，方便对朋友圈动态的附属信息进行统一管理和操作。
*/
@TableField("StringId")
private String stringId;
/**
* 动态的内容文本。以字符串（String）类型保存朋友圈动态具体的内容信息，如果是纯文本动态，这里就直接存储文本内容；
// 如果是图文、视频等类型的动态，这里可能存储的是对内容的简要描述等文本信息，在朋友圈动态的展示环节，这个属性的值就是用户实际看到的动态文字内容，是朋友圈动态的核心展示部分之一。
*/
@TableField("Content")
private String content;
}

64
wx-dump-admin/src/main/java/com/xcs/wx/domain/HardLinkImageAttribute.java
Unescape View File

@ -1,64 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import org.apache.ibatis.type.ByteArrayTypeHandler;
/**
* 图片链接表
* 此类用于表示图片链接相关的实体信息，对应数据库中存储图片链接相关属性的表结构，借助MyBatis Plus的注解来建立与数据库表字段的映射关系，
* 同时利用Lombok的 @Data 注解自动生成如Getter、Setter等常用方法，以简化代码编写过程，方便在业务逻辑中对该实体对象进行操作。
*
* @author xcs
* &#064;date 2024年01月04日 17时55分
**/
@Data
@TableName(value = "HardLinkImageAttribute", autoResultMap = true)
// @TableName注解用于指定该实体类对应的数据库表名为 "HardLinkImageAttribute"，autoResultMap = true表示自动映射结果集，便于在查询等操作后将数据库结果准确映射到该实体对象上
public class HardLinkImageAttribute {
/**
* 动态的唯一标识ID。
* 通过 @TableId 注解将该字段与数据库表中的 "Md5Hash" 列对应起来，作为每条记录的唯一标识，这里使用Long类型，用于区分不同的图片链接相关记录，通常基于特定算法生成，比如MD5哈希值等方式来保证唯一性。
*/
@TableId("Md5Hash")
private Long md5Hash;
/**
* 发布用户的用户名。
* 使用 @TableField 注解表明该字段对应数据库表中的 "DirID1" 列，用于存储发布该图片链接对应的发布用户的用户名，以此来关联图片与发布者，便于后续权限管理、溯源等业务操作。
*/
@TableField("DirID1")
private String dirId1;
/**
* 发布用户的用户名。
* 同样通过 @TableField 注解关联数据库表中的 "DirID2" 列，也是用于存放发布用户的用户名，可能在多用户、多角色等复杂业务场景下从不同角度来标识发布者相关信息，具体作用取决于业务逻辑设定。
*/
@TableField("DirID2")
private String dirId2;
/**
* 发布用户的用户名。
* 该字段对应数据库表中名为 "Md5" 的列，使用了 ByteArrayTypeHandler 类型处理器，用于处理字节数组类型的数据，这里可能是将用户名以字节数组形式存储（不过从语义上更可能是存储图片的MD5值等二进制相关数据来唯一标识图片本身，此处注释按原代码表意先写为用户名，如有误需按实际业务调整），以满足特定的数据库存储和读取需求。
*/
@TableField(value = "Md5", typeHandler = ByteArrayTypeHandler.class)
private byte[] md5;
/**
* 发布用户的用户名。
* 由 @TableField 注解关联到数据库表的 "ModifyTime" 列，用于记录图片链接相关信息的修改时间，方便跟踪图片的更新情况以及进行数据版本管理等业务操作。
*/
@TableField("ModifyTime")
private String modifyTime;
/**
* 发布用户的用户名。
* 通过 @TableField 注解对应数据库表中的 "FileName" 列，用于存储图片对应的文件名，便于直观地识别图片，也有助于在文件系统等相关操作中进行查找、展示等操作。
*/
@TableField("FileName")
private String fileName;
}

90
wx-dump-admin/src/main/java/com/xcs/wx/domain/HardLinkVideoAttribute.java
Unescape View File

@ -1,90 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import org.apache.ibatis.type.ByteArrayTypeHandler;
/**
* HardLinkVideoAttribute类用于表示视频链接相关的信息，在系统中对应数据库里存储视频链接相关数据的实体，
* 它将视频链接涉及的各项关键属性整合在一起，方便与数据库进行交互以及在业务逻辑中对视频链接相关的数据进行操作、传递和处理，
* 例如在视频分享、视频管理以及基于视频链接进行相关业务操作等场景中发挥作用。
* @author xcs
* &#064;date 2024年02月07日 15时24分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，例如通过调用getMd5Hash()、getDirId1()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要访问视频链接相关的具体属性信息时，比如查看动态的唯一标识ID、获取发布用户的用户名等，这些getter方法能提供便捷的数据访问途径，便于后续业务逻辑使用这些数据。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当视频的文件名发生变化，
// 可以通过调用setFileName(String newFileName)方法来更新fileName属性的值，从而保证对象的属性能够灵活地反映视频链接相关信息的实际变化情况，增强了属性的可操作性。
// - 生成toString方法，该方法能将HardLinkVideoAttribute对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前视频链接对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个HardLinkVideoAttribute对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及视频链接对象比较的业务逻辑中（如判断两条视频链接的相关属性是否一致等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@TableName(value = "HardLinkVideoAttribute", autoResultMap = true)
// @TableName注解来自于MyBatis Plus框架，用于指定该实体类对应的数据库表名，这里表明HardLinkVideoAttribute类对应的数据库表名为"HardLinkVideoAttribute"。
// 而autoResultMap = true这个配置表示自动构建结果映射，方便在查询数据库返回结果时，能自动将结果集的数据映射到该类的属性上，
// 减少了手动配置结果映射的繁琐过程，特别是当表结构和类结构有一定对应关系时，能更便捷地进行数据库与实体类之间的数据交互。
public class HardLinkVideoAttribute {
/**
* 动态的唯一标识ID。以长整数（Long）类型存储，它是用于在整个系统中唯一标识一个视频链接相关记录的关键信息，
// 不同的视频链接记录应该具有不同的ID，通过这个ID可以在数据库操作（如查询、更新、删除等）以及业务逻辑处理中准确地定位到具体的记录，
// 同时在视频链接相关的各种业务场景中，比如查看特定视频链接详情、进行视频链接的排序展示等，也是重要的依据，方便对视频链接进行精准的管理和操作，
// 这里使用MD5哈希值（假设MD5Hash代表的是基于视频相关特征生成的MD5哈希值）作为唯一标识，有助于保证数据的唯一性和准确性。
*/
@TableId("Md5Hash")
// @TableId注解用于指定该属性对应的数据库表中的主键字段名，这里表明在数据库表"HardLinkVideoAttribute"中，主键字段名为"Md5Hash"，
// 即将类中的md5Hash属性与数据库表中的主键列进行了关联，确保了在数据库操作时，能根据这个主键进行准确的记录定位和操作，保证数据的完整性和一致性。
private Long md5Hash;
/**
* 发布用户的用户名。以字符串（String）类型存储发布该视频链接的用户的用户名信息，通过这个用户名可以明确知道是哪位用户发布了对应的视频链接，
// 在视频链接的权限管理、归属判断以及相关业务场景中起着重要作用，比如判断当前用户是否有权限查看、操作该视频链接，或者统计不同用户发布视频链接的情况等，都需要依据这个用户名来进行相应的处理。
*/
@TableField("DirID1")
// @TableField注解用于指定该属性对应的数据库表中的字段名，这里表示在数据库表"HardLinkVideoAttribute"中，该属性对应名为"DirID1"的字段，
// 明确了类属性与数据库表字段之间的映射关系，确保数据的正确存储和读取，便于与数据库进行交互来获取和修改用户名信息。不过此处字段名"DirID1"看起来不太直观表示用户名，
// 可能在具体业务中有其特定含义或映射关系，需结合实际业务场景进一步理解。
private String dirId1;
/**
* 发布用户的用户名。同样以字符串类型存储发布该视频链接的用户的用户名信息，这里再次出现可能是基于数据库表结构设计或者业务逻辑中对用户标识有不同的关联或使用方式，
// 例如可能从不同维度来关联用户与视频链接的关系，具体含义需要参照具体的业务规则和数据库设计来确定，但总体来说都是用于明确视频链接发布者身份的重要属性。
*/
@TableField("DirID2")
private String dirId2;
/**
* 发布用户的用户名。以字节数组（byte[]）类型存储，使用ByteArrayTypeHandler类作为类型处理器，此处虽然注释写的是发布用户的用户名，但从数据类型来看不太符合常规用户名的存储形式，
// 有可能它存储的是基于视频相关内容（比如视频文件本身）计算出的MD5值（如果按照合理推测，可能和前面提到的MD5Hash有一定关联但又不同的用途），用于数据验证、唯一性判断或者与其他系统交互时识别视频的关键标识等，
// 具体作用还是要结合整个系统关于视频链接处理的业务逻辑来准确理解。
*/
@TableField(value = "Md5", typeHandler = ByteArrayTypeHandler.class)
private byte[] md5;
/**
* 发布用户的用户名。以字符串（String）类型保存该视频链接相关信息的最后修改时间，这个修改时间可以是按照某种特定格式（如常见的日期时间格式"yyyy-MM-dd HH:mm:ss"等）存储的文本信息，
// 在视频链接的管理中，通过这个修改时间可以了解视频链接相关数据的更新情况，比如判断是否有新的变动、进行历史记录查询以及按照时间顺序对视频链接进行排序展示等业务操作，方便对视频链接的生命周期进行管理，
// 不过这里同样字段名"ModifyTime"更直观表示修改时间，和注释里“发布用户的用户名”不太相符，应按照实际业务场景准确理解其含义。
*/
@TableField("ModifyTime")
private String modifyTime;
/**
* 发布用户的用户名。以字符串（String）类型存储视频文件的名称信息，文件名是视频的一个重要标识属性，方便用户在查看、管理视频链接时能够直观地识别对应的视频内容，
// 同时在文件存储、检索以及与其他系统进行文件相关交互等业务场景中，文件名也起着关键作用，有助于准确地定位和操作具体的视频文件对应的链接信息。
*/
@TableField("FileName")
private String fileName;
}

227
wx-dump-admin/src/main/java/com/xcs/wx/domain/Msg.java
Unescape View File

@ -1,227 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import org.apache.ibatis.type.ByteArrayTypeHandler;
/**
* 消息
* 该类用于表示消息相关的实体信息，对应数据库中存储消息各项属性的表结构，借助MyBatis Plus的一系列注解来建立与数据库表字段的映射关系，
* 同时利用Lombok的 @Data 注解自动生成如Getter、Setter等常用方法，方便在业务逻辑中对消息实体对象进行操作、传递以及持久化等处理。
*
* @author xcs
* &#064;date 2023年12月25日 15时08分
**/
@Data
@TableName(value = "MSG", autoResultMap = true)
// @TableName注解用于指定该实体类对应的数据库表名为 "MSG"，autoResultMap = true表示自动映射结果集，确保在进行数据库查询等操作后能准确地将结果映射到该实体对象的各个属性上
public class Msg {
/**
* 本地唯一标识符，自增。
* 通过 @TableId 注解将该字段与数据库表中的 "localId" 列对应起来，作为每条消息记录在本地的唯一标识，其类型为Integer，且设置为自增（IdType.AUTO），
* 意味着在向数据库插入新的消息记录时，该值会按照数据库的自增规则自动生成，方便在本地系统中对不同消息进行区分、索引以及关联其他相关数据。
*/
@TableId(value = "localId", type = IdType.AUTO)
private Integer localId;
/**
* 聊天对象的 ID。
* 使用 @TableField 注解表明该字段对应数据库表中的 "TalkerId" 列，用于存储与这条消息相关的聊天对象的唯一标识符，通过该ID可以关联到具体的聊天对象信息，
* 例如在多用户聊天场景下确定消息是发送给哪个用户或者来自哪个用户的。
*/
@TableField("TalkerId")
private Integer talkerId;
/**
* 消息服务器 ID。
* 借助 @TableField 注解关联数据库表中的 "MsgSvrID" 列，该字段用于存放消息在服务器端的唯一标识符，服务器可以凭借此ID对消息进行管理、转发、存储等操作，
* 它在整个消息流转过程中起到了在服务器层面标识消息的重要作用。
*/
@TableField("MsgSvrID")
private String msgSvrId;
/**
* 消息类型。
* 通过 @TableField 注解对应数据库表中的 "Type" 列，用于区分不同种类的消息，比如文本消息、图片消息、语音消息等，不同的消息类型在展示、处理等方面往往有不同的逻辑，
* 可以根据该字段的值来决定后续对消息采取何种具体的业务操作。
*/
@TableField("Type")
private Integer type;
/**
* 消息子类型。
* 同样由 @TableField 注解关联到数据库表的 "SubType" 列，在消息已经有了大的类型划分基础上，进一步细分消息的子类型，例如对于图片消息，可能还会区分是静态图片还是动态图片等更细致的分类，
* 以便更精准地处理和展示不同特性的消息内容。
*/
@TableField("SubType")
private Integer subType;
/**
* 发送者标识（是否为发送者）。
* 使用 @TableField 注解表明该字段对应数据库表中的 "IsSender" 列，用于标识当前这条消息的发送者身份，一般以特定的数值（如1表示是发送者，0表示不是等）来体现，
* 有助于在聊天记录等场景下清晰地判断消息的流向和归属。
*/
@TableField("IsSender")
private Integer isSender;
/**
* 消息创建时间。
* 由 @TableField 注解关联到数据库表的 "CreateTime" 列，用于记录消息创建的时间戳，通常以整数形式表示，方便按照时间顺序对消息进行排序、查询以及分析消息的时效性等，
* 例如可以实现按时间查找历史消息、统计不同时间段内的消息数量等功能。
*/
@TableField("CreateTime")
private Integer createTime;
/**
* 序列号，默认为 0。
* 通过 @TableField 注解对应数据库表中的 "Sequence" 列，序列号常用于在消息传输、处理等流程中保证消息的顺序性以及唯一性等，初始值默认为0，
* 在一些复杂的消息交互场景下，可能会根据特定规则进行更新和使用，以确保消息不会出现乱序等问题。
*/
@TableField("Sequence")
private Long sequence;
/**
* 扩展状态，默认为 0。
* 借助 @TableField 注解关联数据库表中的 "StatusEx" 列，该字段用于存储消息的扩展状态信息，初始值设为0，具体的扩展状态含义可能根据业务需求而定，
* 比如可以表示消息是否经过特殊处理、是否处于某种临时状态等额外的状态描述。
*/
@TableField("StatusEx")
private Integer statusEx;
/**
* 扩展标志。
* 使用 @TableField 注解表明该字段对应数据库表中的 "FlagEx" 列，用于设置消息的一些扩展标志，这些标志可以携带额外的业务相关信息，例如是否加急、是否需要回执等，
* 通过对这些标志位的判断来执行不同的业务逻辑。
*/
@TableField("FlagEx")
private Integer flagEx;
/**
* 消息状态。
* 通过 @TableField 注解关联到数据库表的 "Status" 列，用于表示消息当前所处的常规状态，比如已发送、已接收、已读等常见的消息状态，方便对消息的流转情况进行跟踪和管理，
* 根据该状态可以决定是否需要进行下一步的业务操作，如更新界面显示等。
*/
@TableField("Status")
private Integer status;
/**
* 消息服务器序列号。
* 由 @TableField 注解对应数据库表中的 "MsgServerSeq" 列，在服务器端对消息进行管理时使用的序列号，有助于服务器按照顺序准确地处理、转发消息，
* 保证消息在服务器层面的有序性和准确性，与前面提到的本地序列号等可能有不同的用途和作用范围。
*/
@TableField("MsgServerSeq")
private Integer msgServerSeq;
/**
* 消息序列号。
* 借助 @TableField 注解关联数据库表中的 "MsgSequence" 列，也是用于标识消息顺序的一个序列号，可能在整个消息传递链路（包括客户端和服务器端交互等）中起到统一的顺序标识作用，
* 具体使用方式和与其他序列号的关系取决于具体的消息处理架构和业务逻辑。
*/
@TableField("MsgSequence")
private Integer msgSequence;
/**
* 聊天者字符串。
* 使用 @TableField 注解表明该字段对应数据库表中的 "StrTalker" 列，通常用于以字符串形式存储聊天对象的相关标识信息，可能是用户名、昵称或者其他可以唯一识别聊天者的文本内容，
* 方便在界面展示等场景下直观地显示消息对应的聊天对象。
*/
@TableField("StrTalker")
private String strTalker;
/**
* 消息内容字符串。
* 通过 @TableField 注解对应数据库表中的 "StrContent" 列，用于存放消息的具体文本内容，当消息类型为文本消息时，该字段就承载了实际要传达的文字信息，
* 在展示、存储以及后续分析等业务操作中都起着关键作用。
*/
@TableField("StrContent")
private String strContent;
/**
* 显示内容。
* 由 @TableField 注解关联到数据库表的 "DisplayContent" 列，该字段用于存储消息最终展示给用户的内容，有时候消息的原始内容可能经过一些处理（如表情替换、格式转换等）才呈现给用户，
* 这个字段就记录了经过处理后实际显示的内容。
*/
@TableField("DisplayContent")
private String displayContent;
/**
* 保留字段 0，默认为 0。
* 使用 @TableField 注解表明该字段对应数据库表中的 "Reserved0" 列，属于预留字段，初始值设为0，主要是为了应对未来可能的业务扩展或者功能变化，
* 方便在不修改现有数据库表结构和大部分代码逻辑的基础上添加新的属性或功能需求。
*/
@TableField("Reserved0")
private Integer reserved0;
/**
* 保留字段 1，默认为 0。
* 同样借助 @TableField 注解关联数据库表中的 "Reserved1" 列，也是预留字段，默认值为0，其作用和 Reserved0 类似，是为后续业务拓展预留的空间，具体如何使用取决于未来的业务发展方向。
*/
@TableField("Reserved1")
private Integer reserved1;
/**
* 保留字段 2，默认为 0。
* 通过 @TableField 注解对应数据库表中的 "Reserved2" 列，此为预留字段且初始值设为0，为将来可能出现的新业务场景或者功能添加预先准备的可扩展字段，具体用途有待后续根据业务需求确定。
*/
@TableField("Reserved2")
private Integer reserved2;
/**
* 保留字段 3，默认为 0。
* 由 @TableField 注解关联数据库表中的 "Reserved3" 列，同样是预留字段，默认值是0，在未来业务发生变化，需要在消息实体中添加新的属性时，可以利用该字段进行扩展，而不用大规模改动数据库结构等。
*/
@TableField("Reserved3")
private Integer reserved3;
/**
* 保留字段 4，文本类型。
* 使用 @TableField 注解表明该字段对应数据库表中的 "Reserved4" 列，作为预留的文本类型字段，可为后续添加与消息相关的文本描述信息等预留空间，
* 比如可以用于存储消息的备注、额外的说明文字等内容，具体使用方式根据未来业务需求而定。
*/
@TableField("Reserved4")
private String reserved4;
/**
* 保留字段 5，文本类型。
* 借助 @TableField 注解关联数据库表中的 "Reserved5" 列，也是预留的文本类型字段，和 Reserved4 类似，用于应对未来可能出现的需要在消息实体中添加文本相关信息的业务场景，
* 方便进行业务功能的扩展和完善。
*/
@TableField("Reserved5")
private String reserved5;
/**
* 保留字段 6，文本类型。
* 通过 @TableField 注解对应数据库表中的 "Reserved6" 列，同样是为了业务扩展预留的文本类型字段，当后续有新的文本相关的业务需求与消息相关联时，可以利用该字段来存储相应信息，
* 保证代码和数据库结构具有一定的可扩展性。
*/
@TableField("Reserved6")
private String reserved6;
/**
* 压缩内容，二进制大对象。
* 该字段对应数据库表中名为 "CompressContent" 的列，使用了 ByteArrayTypeHandler 类型处理器来处理字节数组类型的数据，用于存储消息经过压缩后的内容，
* 在一些场景下，为了节省存储空间或者提高传输效率，会对消息内容（比如图片、语音等大文件对应的消息内容）进行压缩处理，这里就存放压缩后的二进制数据，方便后续解压缩以及还原消息内容等操作。
*/
@TableField(value = "CompressContent", typeHandler = ByteArrayTypeHandler.class)
private byte[] compressContent;
/**
* 额外字节信息，二进制大对象。
* 通过 @TableField 注解关联数据库表中的 "BytesExtra" 列，同样使用 ByteArrayTypeHandler 类型处理器来处理字节数组类型的数据，用于存储与消息相关的额外字节信息，
* 这些额外信息可能是对消息的补充说明、附加的数据部分等，具体内容和用途取决于具体的业务场景和消息处理逻辑。
*/
@TableField(value = "BytesExtra", typeHandler = ByteArrayTypeHandler.class)
private byte[] bytesExtra;
/**
* 传输字节信息，二进制大对象。
* 使用 @TableField 注解表明该字段对应数据库表中的 "BytesTrans" 列，采用 ByteArrayTypeHandler 类型处理器来处理字节数组类型的数据，用于存储消息在传输过程中的相关字节信息，
* 比如可能包含传输协议的头部信息、校验码等，有助于保证消息在网络传输中的完整性和准确性。
*/
@TableField(value = "BytesTrans", typeHandler = ByteArrayTypeHandler.class)
private byte[] bytesTrans;
}

137
wx-dump-admin/src/main/java/com/xcs/wx/domain/Session.java
Unescape View File

@ -1,137 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* Session类用于表示会话相关的信息，在系统中对应数据库里存储会话数据的实体，它整合了会话各个方面的关键属性，
* 方便与数据库进行交互以及在业务逻辑中对会话相关的数据进行操作、传递和处理，例如在会话列表展示、消息管理、会话状态跟踪等业务场景中发挥作用。
* @author xcs
* &#064;date 2023年12月21日 17时05分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，例如通过调用getUsrName()、getUnReadCount()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要访问会话的具体属性信息时，比如查看用户名、获取未读消息计数等，这些getter方法能提供便捷的数据访问途径，便于后续业务逻辑使用这些数据。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当会话的内容发生变化，
// 可以通过调用setContent(String newContent)方法来更新content属性的值，从而保证对象的属性能够灵活地反映会话相关信息的实际变化情况，增强了属性的可操作性。
// - 生成toString方法，该方法能将Session对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前会话对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个Session对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及会话对象比较的业务逻辑中（如判断两个会话的信息是否一致等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@TableName("Session")
// @TableName注解来自MyBatis Plus框架，用于指定该实体类对应的数据库表名，这里表明Session类对应的数据库表名为"Session"，
// 明确了该类与数据库表之间的映射关系，方便后续进行数据库操作（如数据的插入、查询、更新、删除等）时能准确地找到对应的表，确保数据的正确交互。
public class Session {
/**
* 用户名。以字符串（String）类型存储，它是用于唯一标识参与会话的用户的关键信息，
// 在整个系统中，不同用户的会话记录通过这个用户名进行区分，通过这个用户名可以在数据库操作（如查询、更新、删除等）以及业务逻辑处理中准确地定位到具体用户的会话相关记录，
// 并且在展示会话列表、判断会话归属等场景下，也是重要的依据，确保会话数据与对应的用户能准确匹配。
*/
@TableId("strUsrName")
// @TableId注解用于指定该属性对应的数据库表中的主键字段名，这里表明在数据库表"Session"中，主键字段名为"strUsrName"，
// 即将类中的usrName属性与数据库表中的主键列进行了关联，确保了在数据库操作时，能根据这个主键进行准确的记录定位和操作，保证数据的完整性和一致性。
private String usrName;
/**
* 未读消息计数。以整数（Integer）类型存储，表示当前会话中用户尚未阅读的消息数量，
// 在会话列表展示等场景中，这个计数可以直观地提示用户有多少新消息等待查看，方便用户及时了解是否有未处理的消息，
// 同时在消息提醒、未读消息管理等业务逻辑中起着重要作用，例如可以根据未读消息数量决定是否进行特殊的提醒标识等操作。
*/
@TableField("nUnReadCount")
// @TableField注解用于指定该属性对应的数据库表中的字段名，这里表示在数据库表"Session"中，该属性对应名为"nUnReadCount"的字段，
// 明确了类属性与数据库表字段之间的映射关系，确保数据的正确存储和读取，便于与数据库进行交互来获取和修改未读消息计数信息。
private Integer unReadCount;
/**
* 父引用，可能指向与此会话相关联的其他实体。以字符串（String）类型存储，这个属性的具体含义取决于业务的具体设定，
// 它可能用于关联到会话所属的某个更高层级的实体（比如会话所在的分组、聊天窗口等），或者指向与该会话有特定关联关系的其他对象，
// 在涉及会话的组织架构、关联关系梳理以及复杂业务逻辑处理中会用到这个属性来建立不同实体之间的联系。
*/
@TableField("parentRef")
private String parentRef;
/**
* 用户昵称。以字符串（String）类型存储参与会话的用户的昵称信息，昵称通常是用户对外展示的一个比较个性化、友好的称呼，
// 在会话展示等场景中，昵称更便于用户直观地识别会话对象，增强了用户与用户之间交互的友好性，相较于用户名，昵称更具亲和力，方便用户快速知晓对方身份。
*/
@TableField("strNickName")
private String nickName;
/**
* 会话状态。以整数（Integer）类型表示会话当前所处的状态，具体的状态值含义取决于业务的具体定义，
// 例如可以用不同的整数值来区分会话是正常开启状态、已关闭状态、冻结状态等不同情况，在会话的管理、操作判断等业务逻辑中会依据这个状态属性来进行相应的处理，
// 比如根据会话状态决定是否允许发送消息等操作。
*/
@TableField("nStatus")
private Integer status;
/**
* 发送状态标识。同样为整数（Integer）类型，用于表示消息在会话中的发送情况，例如可以用不同的值来表示消息已成功发送、正在发送、发送失败等不同的发送状态，
// 在消息发送的相关业务逻辑中，通过这个标识可以判断消息是否准确传达，便于进行后续的处理，比如重新发送失败的消息等操作。
*/
@TableField("nIsSend")
private Integer isSend;
/**
* 会话内容。以字符串（String）类型保存会话中的具体消息内容，这是会话的核心信息之一，
// 无论是文本消息、表情等都可以以相应的文本形式存储在这里（如果涉及复杂的多媒体消息等可能会有其他关联处理方式），在展示会话历史记录、查看具体消息详情等场景中会用到这个属性来呈现消息内容。
*/
@TableField("strContent")
private String content;
/**
* 消息类型。以整数（Integer）类型表示会话中消息的类型，具体的类型划分取决于业务的具体设定，
// 例如可以用不同的整数值来区分是文本消息、图片消息、语音消息、视频消息等不同类型的消息，在消息的展示、处理逻辑中，会根据这个类型属性来采取不同的展示方式、业务操作，
// 以满足多样化的消息交互需求，比如对于图片消息要进行图片加载展示，对于语音消息要提供播放功能等。
*/
@TableField("nMsgType")
private Integer msgType;
/**
* 本地消息ID。以整数（Integer）类型存储在本地系统中为每条消息分配的唯一标识符，
// 通过这个ID可以在本地数据库或者相关存储中准确地定位到具体的消息记录，方便进行消息的查询、更新、删除等操作，
// 同时在消息的关联、排序以及与其他系统交互涉及消息标识等业务场景中起着重要作用，确保消息管理的准确性和便捷性。
*/
@TableField("nMsgLocalID")
private Integer msgLocalId;
/**
* 消息状态。以整数（Integer）类型表示消息当前所处的状态，具体的状态值含义取决于业务的具体设定，
// 类似消息的发送状态，但可能涵盖更广泛的情况，比如消息是否已读、是否被撤回、是否审核通过（如果有审核机制的话）等不同状态，
// 在消息管理、消息提醒以及相关业务逻辑中会依据这个状态属性来进行相应的处理，例如根据消息是否已读来决定是否取消未读提醒等操作。
*/
@TableField("nMsgStatus")
private Integer msgStatus;
/**
* 消息时间戳。以整数（Integer）类型存储消息发送或接收的时间信息，这个时间戳一般是以某个特定的起始时间（如1970年1月1日00:00:00 UTC）为基准，
// 到消息实际发送或接收时刻所经过的秒数或者毫秒数（具体取决于系统的时间精度设定），通过这个时间戳，可以准确判断消息的先后顺序、进行消息的排序展示（按照时间顺序），
// 以及在一些基于时间范围的查询（如查看某一时间段内的消息记录）等业务场景中发挥作用，方便对会话中的消息进行时间维度的管理。
*/
@TableField("nTime")
private Integer time;
/**
* 编辑过的内容。以字符串（String）类型存储会话中消息被编辑后的内容信息，在一些支持消息编辑功能的系统中，
// 当用户对已发送的消息进行修改后，修改后的内容就会存储在这里，方便在查看消息历史记录时能够体现消息的变化情况，同时也便于进行相关的业务逻辑处理，比如记录消息编辑的日志等操作。
*/
@TableField("editContent")
private String editContent;
/**
* 标记是否有其他人@我。以整数（Integer）类型表示在会话中是否有其他用户提及了当前用户（通过@的方式），
// 例如值为1表示有其他人@我，值为0表示没有，在消息提醒、重点消息关注等业务逻辑中会用到这个标识，方便用户快速定位到与自己相关的重要消息内容。
*/
@TableField("othersAtMe")
private Integer othersAtMe;
}

52
wx-dump-admin/src/main/java/com/xcs/wx/domain/SqliteMaster.java
Unescape View File

@ -1,52 +0,0 @@
package com.xcs.wx.domain;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* SQLite 数据库中的一个系统表
* 该类用于映射SQLite数据库中名为 "sqlite_master" 的系统表结构，通过MyBatis Plus的相关注解来建立类的属性与数据库表字段之间的对应关系，
* 并且借助Lombok的 @Data 注解自动生成常用的Getter、Setter等方法，方便在操作数据库以及业务逻辑处理中对该表对应的数据进行访问和修改等操作。
*
* @author xcs
* &#064;date 2024年6月13日09:18:29
*/
@Data
@TableName("sqlite_master")
// @TableName注解用于指定该实体类对应的数据库表名为 "sqlite_master"，表明这个类是与SQLite数据库中的该系统表相关联的实体映射类
public class SqliteMaster {
/**
* type
* 使用 @TableField 注解将该字段与数据库表中的 "type" 列相对应，在 "sqlite_master" 系统表中，"type" 字段通常用于表示数据库对象的类型，
* 比如可能是 'table'（表示表）、'index'（表示索引）、'view'（表示视图）等不同类型，通过该字段可以知晓对应记录所描述的数据库对象具体属于哪一类。
*/
@TableField("type")
private String type;
/**
* tblName
* 通过 @TableField 注解关联数据库表中的 "tbl_name" 列，该字段用于存储数据库对象（常见的如数据表）的名称，
* 在查询 "sqlite_master" 系统表时，可以通过这个字段获取到具体某个数据库对象（例如某张表）的名字，方便后续对该对象进行相关操作或者获取其详细信息。
*/
@TableField("tbl_name")
private String tblName;
/**
* rootPage
* 借助 @TableField 注解对应数据库表中的 "rootpage" 列，在SQLite数据库的内部存储结构中，"rootpage" 字段往往与数据库对象的存储位置或者起始页面等相关，
* 具体含义和用途更偏向于数据库底层的存储管理方面，通过该字段的值可以了解到对应数据库对象在存储层面的一些关键信息（比如数据存储的起始位置等）。
*/
@TableField("rootpage")
private String rootPage;
/**
* sql
* 使用 @TableField 注解表明该字段对应数据库表中的 "sql" 列，在 "sqlite_master" 系统表中，"sql" 字段通常存放着用于创建对应数据库对象的SQL语句，
* 例如如果是一张表，这里就会记录创建该表时使用的完整CREATE TABLE语句，通过读取该字段内容，可以清楚地知道数据库对象最初是如何被定义和创建的。
*/
@TableField("sql")
private String sql;
}

156
wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/CompressContentBO.java
Unescape View File

@ -1,156 +0,0 @@
package com.xcs.wx.domain.bo;
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类，用于表示一种特定的业务对象（BO，Business Object），从类名推测可能与压缩内容相关，
* 该类主要用于在Java对象和XML数据格式之间进行转换以及处理相关的数据结构，由作者xcs在2024年01月16日14时59分创建。
*
* @author xcs
* @date 2024年01月16日 14时59分
**/
@Data
// 使用Lombok的 @Data 注解，会自动为类生成常用的方法，如Getter、Setter、toString、equals和hashCode等方法，
// 简化了手动编写这些常规方法的代码量，方便对类中的属性进行访问和操作。
@JsonIgnoreProperties(ignoreUnknown = true)
// 这个注解用于告诉Jackson（一个常用的JSON处理库）在进行JSON序列化和反序列化时，忽略那些在JSON数据中存在但在Java对象中没有对应属性的字段，
// 这样可以避免因未知字段而导致的反序列化错误，提高程序的兼容性和容错性，尤其是在处理可能来自不同数据源的JSON数据时很有用。
@JacksonXmlRootElement(localName = "msg")
// 该注解用于指定在将Java对象转换为XML格式时，整个XML文档的根元素名称为 "msg"，使得生成的XML结构符合特定的格式要求，便于与外部系统进行基于XML的数据交互。
public class CompressContentBO {
@JacksonXmlProperty(localName = "appmsg")
private AppMsg appMsg;
// 使用 @JacksonXmlProperty 注解来指定在XML格式中对应的元素名称为 "appmsg"，表示该属性在XML序列化和反序列化时与名为 "appmsg" 的XML元素相关联，
// 这里的AppMsg是一个内部静态类，它用于进一步封装与 "appmsg" 元素相关的详细数据结构。
@JacksonXmlProperty(localName = "fromusername")
private String fromUsername;
// 同样，指定该属性对应的XML元素名为 "fromusername"，用于存储从XML中解析出的或者要转换为XML的对应元素的值，这里存储的可能是发送者的用户名等相关信息。
@JacksonXmlProperty(localName = "scene")
private int scene;
// 对应XML中的 "scene" 元素，可能表示某种场景相关的数值信息，具体含义取决于业务中对这个字段的定义，例如不同的业务操作场景、消息来源场景等。
@JacksonXmlProperty(localName = "appinfo")
private AppInfo appInfo;
// 关联XML中的 "appinfo" 元素，AppInfo也是一个内部静态类，用于承载与应用信息相关的具体数据，比如应用的版本、名称等内容。
@JacksonXmlProperty(localName = "titile")
private String titile;
// 这里应该是拼写错误，正确的可能是 "title"（可根据实际业务情况确认），用于对应XML中的同名元素，存储相关的标题类信息，比如消息标题等。
/**
* AppMsg内部静态类，用于表示与 "appmsg" XML元素对应的嵌套数据结构，
* 进一步细化了在整个业务对象中与特定消息或应用消息相关的详细信息。
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class AppMsg {
@JacksonXmlProperty(localName = "title")
private String title;
// 对应 "appmsg" 元素下的 "title" 子元素，通常用于存储消息的标题内容，比如文章标题、推送消息标题等。
@JacksonXmlProperty(localName = "sourcedisplayname")
private String sourceDisplayName;
// 关联 "appmsg" 元素下的 "sourcedisplayname" 子元素，可能表示消息来源的显示名称，例如公众号名称、应用来源的展示名称等。
@JacksonXmlProperty(localName = "des")
private String des;
// 对应 "appmsg" 元素下的 "des" 子元素，这里可能是拼写错误，推测正确的是 "desc"（表示描述），用于存储相关的描述信息，如消息的简介等内容（可根据业务确认）。
@JacksonXmlProperty(localName = "url")
private String url;
// 关联 "appmsg" 元素下的 "url" 子元素，一般用于存储一个链接地址，比如点击消息后跳转的网页地址、应用内页面的链接等。
@JacksonXmlProperty(localName = "action")
private String action;
// 对应 "appmsg" 元素下的 "action" 子元素，可能表示针对该消息可以执行的操作类型，例如打开链接、分享、评论等具体操作（依业务而定）。
@JacksonXmlProperty(localName = "type")
private int type;
// 关联 "appmsg" 元素下的 "type" 子元素，用于表示消息的类型，不同的数值可能对应不同种类的消息，比如文本消息、图片消息、链接消息等（由业务定义具体类型规则）。
@JacksonXmlProperty(localName = "showtype")
private int showType;
// 对应 "appmsg" 元素下的 "showtype" 子元素，可能用于表示消息的展示类型，例如是列表展示、卡片展示或者其他特定的展示形式（取决于业务需求）。
@JacksonXmlProperty(localName = "refermsg")
private ReferMsg referMsg;
// 关联 "appmsg" 元素下的 "refermsg" 子元素，ReferMsg是内部的又一层嵌套静态类，用于承载与引用消息相关的详细信息，比如引用消息的来源、内容等。
@JacksonXmlProperty(localName = "weappinfo")
private WeAppInfo weAppInfo;
// 对应 "appmsg" 元素下的 "weappinfo" 子元素，WeAppInfo同样是内部嵌套静态类，用于存放与小程序相关的信息，比如小程序图标地址、页面缩略图地址等。
/**
* ReferMsg内部静态类，用于表示与 "refermsg" XML元素对应的详细数据结构，
* 主要聚焦于引用消息相关的具体属性内容。
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class ReferMsg {
@JacksonXmlProperty(localName = "type")
private int type;
// 对应 "refermsg" 元素下的 "type" 子元素，可能用于表示引用消息本身的类型，同样不同数值对应不同类型的引用消息（依业务定义）。
@JacksonXmlProperty(localName = "svrid")
private long svrId;
// 关联 "refermsg" 元素下的 "svrid" 子元素，可能是服务器端为该引用消息分配的唯一标识ID，用于区分不同的引用消息等操作。
@JacksonXmlProperty(localName = "fromusr")
private String fromUsr;
// 对应 "refermsg" 元素下的 "fromusr" 子元素，用于存储引用消息的发送者相关信息，比如发送者用户名等。
@JacksonXmlProperty(localName = "displayname")
private String displayName;
// 关联 "refermsg" 元素下的 "displayname" 子元素，可能表示引用消息发送者的显示名称，类似于昵称等展示给用户的称呼信息。
@JacksonXmlProperty(localName = "content")
private String content;
// 对应 "refermsg" 元素下的 "content" 子元素，用于存储引用消息的具体内容，比如文本内容等。
@JacksonXmlProperty(localName = "msgsource")
private String msgSource;
// 关联 "refermsg" 元素下的 "msgsource" 子元素，用于表示引用消息的来源渠道，例如来自哪个公众号、哪个应用等。
}
/**
* WeAppInfo内部静态类，用于表示与 "weappinfo" XML元素对应的小程序相关信息的数据结构，
* 包含小程序图标地址、页面缩略图地址等相关属性。
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class WeAppInfo {
@JacksonXmlProperty(localName = "weappiconurl")
private String weAppIconUrl;
// 对应 "weappinfo" 元素下的 "weappiconurl" 子元素，用于存储小程序的图标对应的网络地址，方便在界面上展示小程序的图标。
@JacksonXmlProperty(localName = "weapppagethumbrawurl")
private String weAppPageThumbRawUrl;
// 关联 "weappinfo" 元素下的 "weapppagethumbrawurl" 子元素，用于存储小程序页面缩略图的原始网络地址，可用于在展示小程序相关信息时展示页面缩略图。
}
}
/**
* AppInfo内部静态类，用于表示与 "appinfo" XML元素对应的应用信息相关的数据结构，
* 包含应用的版本号、名称等属性，用于描述相关应用的基础信息。
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class AppInfo {
@JacksonXmlProperty(localName = "version")
private int version;
// 对应 "appinfo" 元素下的 "version" 子元素，用于存储应用的版本号信息，便于判断应用的新旧程度以及是否需要更新等操作。
@JacksonXmlProperty(localName = "appname")
private String appName;
// 关联 "appinfo" 元素下的 "appname" 子元素，用于存储应用的名称，用于明确该应用的标识等情况。
}
}

36
wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/DecryptBO.java
Unescape View File

@ -1,36 +0,0 @@
package com.xcs.wx.domain.bo;
import lombok.AllArgsConstructor;
import lombok.Data;
/**
* DecryptBO类，作为一种业务对象（BO，Business Object），通常用于在业务逻辑层传递与解密操作相关的数据，
* 从类名及类中的属性来看，主要是封装了需要解密的文件相关信息以及解密后文件的相关信息，由作者xcs在2023年12月10日20时21分02秒创建。
*
* @author xcs
* @date 2023年12月10日20:21:02
*/
@Data
// 使用Lombok的 @Data 注解，会自动为类生成常用的方法，如Getter、Setter、toString、equals和hashCode等方法，
// 这样在其他代码中就可以方便地获取和设置类中的属性值，以及进行对象的比较、打印等操作，简化了手动编写这些常规方法的代码量。
@AllArgsConstructor
// 使用Lombok的 @AllArgsConstructor 注解，会为该类生成一个包含所有参数的构造函数，
// 这样在创建DecryptBO类的实例时，可以通过传入相应的参数值来初始化对象的属性，方便对象的创建和属性赋值操作。
public class DecryptBO {
/**
* input属性，用于存储输入要解密的文件相关信息，
* 具体可能是文件的路径（例如在本地文件系统中的绝对路径或者相对路径），也可能是文件的标识等内容，
* 取决于业务中对解密操作输入参数的具体定义方式，其作用是明确指出需要进行解密处理的文件来源。
*/
private String input;
/**
* output属性，用于存储解密后的文件相关信息，
* 同样可能是解密后文件在文件系统中的存储路径，方便后续对解密结果文件进行查找、使用等操作，
* 它定义了解密操作完成后生成的文件的相关存储位置或者标识信息，便于业务逻辑中其他部分对解密结果的处理。
*/
private String output;
}

235
wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/MsgBO.java
Unescape View File

@ -1,235 +0,0 @@
package com.xcs.wx.domain.bo;
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类，作为一种业务对象（BO，Business Object），主要用于在Java对象和XML数据格式之间进行转换以及处理微信消息相关的数据结构，
* 通过一系列的Jackson注解来定义XML元素与Java类属性之间的映射关系，由作者xcs在2024年01月16日14时59分创建。
*
* @author xcs
* @date 2024年01月16日 14时59分
**/
@Data
// 使用Lombok的 @Data 注解，会自动为类生成常用的方法，如Getter、Setter、toString、equals和hashCode等方法，
// 方便在其他代码中对类中的属性进行访问、赋值以及进行对象的比较、打印等操作，减少了手动编写这些常规方法的代码量。
@JsonIgnoreProperties(ignoreUnknown = true)
// 这个注解用于告诉Jackson（一个常用的JSON处理库，在这里也用于处理XML与Java对象的转换）在进行XML序列化和反序列化时，
// 忽略那些在XML数据中存在但在Java对象中没有对应属性的字段，避免因未知字段而导致的反序列化错误，增强程序处理不同来源XML数据的兼容性和容错性。
@JacksonXmlRootElement(localName = "msg")
// 该注解用于指定在将Java对象转换为XML格式时，整个XML文档的根元素名称为 "msg"，以此确定生成的XML结构的顶层元素名称，
// 便于符合特定的XML数据格式要求，从而与外部系统（可能是微信相关的服务端等）进行基于XML的数据交互。
public class MsgBO {
@JacksonXmlProperty(localName = "img")
public Img img;
// 使用 @JacksonXmlProperty 注解来指定该属性在XML格式中对应的元素名称为 "img"，表示在XML序列化和反序列化时，
// 这个属性与名为 "img" 的XML元素相关联，Img是一个内部静态类，用于进一步封装与图片相关的详细信息。
@JacksonXmlProperty(localName = "emoji")
private Emoji emoji;
// 同样通过 @JacksonXmlProperty 注解，将该属性与XML中的 "emoji" 元素相对应，Emoji也是内部静态类，
// 用于承载与表情符号（Emoji）相关的各种详细属性信息，方便处理微信消息中涉及表情的相关数据。
/**
* Img内部静态类，用于表示与 "img" XML元素对应的图片相关详细信息的数据结构，
* 包含了图片在微信消息中涉及的加密、尺寸、链接、校验等多方面的属性。
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class Img {
@JacksonXmlProperty(isAttribute = true, localName = "aeskey")
public String aesKey;
// 使用 @JacksonXmlProperty 注解，并设置 isAttribute = true，表示这个属性对应的是XML元素的属性（而不是子元素），
// 其对应的XML元素 "img" 的属性名为 "aeskey"，通常用于存储图片加密相关的密钥信息，比如用于解密图片数据的对称密钥等。
@JacksonXmlProperty(isAttribute = true, localName = "encryver")
public String encryVer;
// 同样对应 "img" 元素的属性 "encryver"，可能表示图片加密的版本信息，用于区分不同加密算法或加密参数设置下的图片加密情况。
@JacksonXmlProperty(isAttribute = true, localName = "cdnthumbaeskey")
public String cdnThumbAesKey;
// 对应 "img" 元素的属性 "cdnthumbaeskey"，一般是与图片缩略图（在内容分发网络CDN上的缩略图）加密相关的密钥，用于处理缩略图的解密操作等。
@JacksonXmlProperty(isAttribute = true, localName = "cdnthumburl")
public String cdnThumbUrl;
// 关联 "img" 元素的属性 "cdnthumburl"，用于存储图片缩略图在CDN上的网络地址，方便在界面上展示图片的缩略图时获取相应资源。
@JacksonXmlProperty(isAttribute = true, localName = "cdnthumblength")
public int cdnThumbLength;
// 对应 "img" 元素的属性 "cdnthumblength"，表示图片缩略图的数据长度，可用于验证数据完整性或者预估加载时间等操作。
@JacksonXmlProperty(isAttribute = true, localName = "cdnthumbheight")
public int cdnThumbHeight;
// 关联 "img" 元素的属性 "cdnthumbheight"，用于存储图片缩略图的高度信息，以像素等单位表示，便于在展示等场景中进行布局和显示控制。
@JacksonXmlProperty(isAttribute = true, localName = "cdnthumbwidth")
public int cdnThumbWidth;
// 对应 "img" 元素的属性 "cdnthumbwidth"，表示图片缩略图的宽度信息，同样以像素等单位计量，用于图片展示相关的尺寸适配等操作。
@JacksonXmlProperty(isAttribute = true,localName = "cdnmidheight")
public int cdnMidHeight;
// 对应 "img" 元素的属性 "cdnmidheight"，可能表示图片中等尺寸版本（相对于缩略图和高清图而言）的高度信息，用于不同显示需求下的图片展示操作。
@JacksonXmlProperty(isAttribute = true, localName = "cdnmidwidth")
public int cdnMidWidth;
// 关联 "img" 元素的属性 "cdnmidwidth"，存储图片中等尺寸版本的宽度信息，配合高度信息用于图片的展示和布局调整等。
@JacksonXmlProperty(isAttribute = true, localName = "cdnhdheight")
public int cdnHdHeight;
// 对应 "img" 元素的属性 "cdnhdheight"，用于存储图片高清版本的高度信息，在需要高质量图片展示的场景下使用。
@JacksonXmlProperty(isAttribute = true, localName = "cdnhdwidth")
public int cdnHdWidth;
// 关联 "img" 元素的属性 "cdnhdwidth"，表示图片高清版本的宽度信息，与高度信息共同确定高清图片的尺寸，便于正确展示高质量图片。
@JacksonXmlProperty(isAttribute = true, localName = "cdnmidimgurl")
public String cdnMidImgUrl;
// 对应 "img" 元素的属性 "cdnmidimgurl"，用于存储图片中等尺寸版本的网络地址，方便根据不同的显示需求加载相应尺寸的图片资源。
@JacksonXmlProperty(isAttribute = true, localName = "length")
public int length;
// 关联 "img" 元素的属性 "length"，表示图片原始数据的长度，用于数据完整性校验、资源管理等操作，比如判断图片大小是否符合预期等。
@JacksonXmlProperty(isAttribute = true, localName = "md5")
public String md5;
// 对应 "img" 元素的属性 "md5"，存储图片的MD5校验和信息，用于验证图片数据在传输、存储过程中是否被篡改，确保数据的准确性和完整性。
@JacksonXmlProperty(isAttribute = true, localName = "hevc_mid_size")
public int hevcMidSize;
// 对应 "img" 元素的属性 "hevc_mid_size"，可能与图片采用高效视频编码（HEVC）格式下的中等尺寸相关的一些大小参数有关，
// 比如文件大小、编码后的数据量等，具体取决于业务中对图片编码相关属性的定义和使用场景。
@JacksonXmlProperty(isAttribute = true, localName = "originsourcemd5")
public String originSourceMd5;
// 关联 "img" 元素的属性 "originsourcemd5"，可能是图片原始数据源的MD5校验和，用于进一步追溯和验证图片来源数据的准确性等情况。
}
/**
* Emoji内部静态类，用于表示与 "emoji" XML元素对应的表情符号（Emoji）相关详细信息的数据结构，
* 涵盖了表情符号从发送者、接收者、类型到各种展示、加密、关联链接等多方面的属性内容。
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class Emoji {
@JacksonXmlProperty(isAttribute = true, localName = "fromusername")
private String fromUsername;
// 使用 @JacksonXmlProperty 注解并设置为属性映射，对应 "emoji" 元素的属性 "fromusername"，用于存储发送表情符号的用户的用户名信息，
// 便于明确表情的发送来源，比如在聊天记录中追溯是哪位用户发送了该表情。
@JacksonXmlProperty(isAttribute = true, localName = "tousername")
private String toUsername;
// 对应 "emoji" 元素的属性 "tousername"，用于存储表情符号接收者的用户名信息，确定表情发送的目标对象，
// 在多用户聊天场景等情况下有助于区分不同接收者收到的表情情况。
@JacksonXmlProperty(isAttribute = true, localName = "type")
private String type;
// 关联 "emoji" 元素的属性 "type"，用于表示表情符号的类型，不同的类型可能对应不同的表情图案、动画效果或者业务含义等，
// 例如静态表情、动态表情等不同分类，具体由业务中对表情类型的定义来确定。
@JacksonXmlProperty(isAttribute = true, localName = "idbuffer")
private String idBuffer;
// 对应 "emoji" 元素的属性 "idbuffer"，可能是表情符号在系统中的唯一标识缓冲区相关信息，用于在内部对表情进行区分和管理，
// 比如在表情资源查找、匹配等操作中发挥作用。
@JacksonXmlProperty(isAttribute = true, localName = "md5")
private String md5;
// 关联 "emoji" 元素的属性 "md5"，存储表情符号相关数据的MD5校验和信息，用于验证表情数据的完整性，确保在传输、存储过程中没有被篡改。
@JacksonXmlProperty(isAttribute = true, localName = "len")
private String len;
// 对应 "emoji" 元素的属性 "len"，可能表示表情符号相关数据的长度信息，例如字节长度等，可用于资源管理、数据校验等操作。
@JacksonXmlProperty(isAttribute = true, localName = "productid")
private String productId;
// 关联 "emoji" 元素的属性 "productid"，可能是与表情符号所属产品、系列相关的唯一标识，比如某个特定主题表情包的产品ID等，
// 便于对表情进行分类、授权等管理操作。
@JacksonXmlProperty(isAttribute = true, localName = "androidmd5")
private String androidMd5;
// 对应 "emoji" 元素的属性 "androidmd5"，可能是专门针对安卓平台上表情符号相关数据的MD5校验和，用于在安卓设备端验证数据完整性等操作，
// 考虑到不同平台可能对表情的存储、处理方式略有差异，单独设置这样的属性有助于针对性的管理。
@JacksonXmlProperty(isAttribute = true, localName = "androidlen")
private String androidLen;
// 关联 "emoji" 元素的属性 "androidlen"，可能表示安卓平台上表情符号相关数据的长度信息，用于适配安卓设备的资源管理等需求。
@JacksonXmlProperty(isAttribute = true, localName = "s60v3md5")
private String s60v3Md5;
// 对应 "emoji" 元素的属性 "s60v3md5"，可能是针对塞班S60v3系统平台上表情符号相关数据的MD5校验和，用于该平台下的数据完整性验证等操作，
// 体现了对不同历史平台的兼容和数据管理考虑。
@JacksonXmlProperty(isAttribute = true, localName = "s60v3len")
private String s60v3Len;
// 关联 "emoji" 元素的属性 "s60v3len"，表示塞班S60v3系统平台上表情符号相关数据的长度信息，满足该平台下的资源管理等相关需求。
@JacksonXmlProperty(isAttribute = true, localName = "s60v5md5")
private String s60v5Md5;
// 对应 "emoji" 元素的属性 "s60v5md5"，类似地，是针对塞班S60v5系统平台上表情符号相关数据的MD5校验和，用于对应平台的数据验证操作。
@JacksonXmlProperty(isAttribute = true, localName = "s60v5len")
private String s60v5Len;
// 关联 "emoji" 元素的属性 "s60v5len"，表示塞班S60v5系统平台上表情符号相关数据的长度信息，以便在该平台上进行合适的资源处理。
@JacksonXmlProperty(isAttribute = true, localName = "cdnurl")
private String cdnUrl;
// 对应 "emoji" 元素的属性 "cdnurl"，用于存储表情符号相关资源在内容分发网络（CDN）上的网络地址，方便快速加载表情图片等资源，
// 提高表情在不同客户端展示的效率和速度。
@JacksonXmlProperty(isAttribute = true, localName = "designerid")
private String designerId;
// 关联 "emoji" 元素的属性 "designerid"，可能是表情符号的设计者的唯一标识，用于版权管理、来源追溯等操作，
// 比如查看某个表情是由哪位设计师创作的，便于相关权益管理和信息展示。
@JacksonXmlProperty(isAttribute = true, localName = "thumburl")
private String thumbUrl;
// 对应 "emoji" 元素的属性 "thumburl"，用于存储表情符号缩略图的网络地址，在一些界面展示场景中，先展示缩略图再加载完整表情，
// 可以提高用户体验和界面响应速度。
@JacksonXmlProperty(isAttribute = true, localName = "encrypturl")
private String encryptUrl;
// 关联 "emoji" 元素的属性 "encrypturl"，可能是表情符号相关资源加密后的网络地址，在需要安全传输和存储表情数据的场景下使用，
// 例如涉及隐私表情或者付费表情包等情况，确保数据的保密性。
@JacksonXmlProperty(isAttribute = true, localName = "aeskey")
private String aesKey;
// 对应 "emoji" 元素的属性 "aeskey"，通常用于存储表情符号相关数据加密的密钥信息，比如采用对称加密算法时的加密密钥，
// 用于在合适的时候对加密的表情数据进行解密操作，保障数据的安全性和完整性。
@JacksonXmlProperty(isAttribute = true, localName = "externurl")
private String externUrl;
// 关联 "emoji" 元素的属性 "externurl"，可能是表情符号关联的外部链接地址，例如点击表情后跳转到的相关网页、推广页面等，
// 拓展了表情符号在业务中的功能和交互性。
@JacksonXmlProperty(isAttribute = true, localName = "externmd5")
private String externMd5;
// 对应 "emoji" 元素的属性 "externmd5"，存储与表情符号关联的外部资源（如通过外部链接指向的资源）的MD5校验和信息，
// 用于验证外部资源数据的完整性，防止外部链接指向的资源被篡改等情况。
@JacksonXmlProperty(isAttribute = true, localName = "width")
private String width;
// 关联 "emoji" 元素的属性 "width"，用于存储表情符号相关图片资源的宽度信息，以像素等单位表示，便于在界面展示时进行布局和尺寸适配。
@JacksonXmlProperty(isAttribute = true, localName = "height")
private String height;
// 对应 "emoji" 元素的属性 "height"，表示表情符号相关图片资源的高度信息，同样以像素等单位计量，与宽度信息一起用于正确展示表情图片。
@JacksonXmlProperty(isAttribute = true, localName = "tpurl")
private String tpUrl;
// 关联 "emoji" 元素的属性 "tpurl"，可能是表情符号的某种特定用途的链接地址（具体含义取决于业务定义），例如用于查看表情详情、
// 进行表情相关操作的链接等，丰富了表情符号在业务逻辑中的交互操作可能性。
@JacksonXmlProperty(isAttribute = true, localName = "tpauthkey")
private String tpAuthKey;
// 对应 "emoji" 元素的属性 "tpauthkey"，可能是用于访问上述特定链接（tpurl）的授权密钥，确保只有授权用户能够进行相关的操作，
// 保障表情相关交互操作的安全性和权限管理。
@JacksonXmlProperty(isAttribute = true, localName = "attachedtext")
private String attachedText;
// 关联 "emoji" 元素的属性 "attachedtext"，用于存储与表情符号相关联的附加文本信息，例如表情的说明文字、提示语等，

251
wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/TimelineObjectBO.java
Unescape View File

@ -1,251 +0,0 @@
package com.xcs.wx.domain.bo;
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类，作为一种业务对象（BO，Business Object），主要用于在Java对象和XML数据格式之间进行转换以及处理与时间线相关的数据结构，
* 通过一系列的Jackson注解来定义XML元素与Java类属性之间的映射关系，方便在业务逻辑中对时间线相关信息进行操作和传递，由作者xcs在2024年01月03日17时47分创建。
*
* @author xcs
* @date 2024年01月03日 17时47分
**/
@Data
// 使用Lombok的 @Data 注解，会自动为类生成常用的方法，如Getter、Setter、toString、equals和hashCode等方法，
// 这样在其他代码中就可以方便地获取和设置类中的属性值，以及进行对象的比较、打印等操作，减少了手动编写这些常规方法的代码量。
@JsonIgnoreProperties(ignoreUnknown = true)
// 这个注解用于告诉Jackson（一个常用的JSON处理库，在这里也用于处理XML与Java对象的转换）在进行XML序列化和反序列化时，
// 忽略那些在XML数据中存在但在Java对象中没有对应属性的字段，避免因未知字段而导致的反序列化错误，增强程序处理不同来源XML数据的兼容性和容错性。
@JacksonXmlRootElement(localName = "TimelineObject")
// 该注解用于指定在将Java对象转换为XML格式时，整个XML文档的根元素名称为 "TimelineObject"，以此确定生成的XML结构的顶层元素名称，
// 便于符合特定的XML数据格式要求，从而与外部系统（可能是微信相关的服务端等）进行基于XML的数据交互。
public class TimelineObjectBO {
@JacksonXmlProperty(localName = "id")
private String id;
// 使用 @JacksonXmlProperty 注解来指定该属性在XML格式中对应的元素名称为 "id"，表示在XML序列化和反序列化时，
// 这个属性与名为 "id" 的XML元素相关联，通常用于存储时间线对象的唯一标识信息，比如每条时间线记录的编号等，便于区分不同的时间线记录。
@JacksonXmlProperty(localName = "username")
private String username;
// 同样通过 @JacksonXmlProperty 注解，将该属性与XML中的 "username" 元素相对应，用于存储与时间线相关的用户名信息，
// 例如发布这条时间线内容的用户名称，可用于追溯信息来源等操作。
@JacksonXmlProperty(localName = "createTime")
private Long createTime;
// 对应XML中的 "createTime" 元素，用于存储时间线对象创建的时间戳信息，一般以毫秒等时间单位表示，方便按时间顺序对时间线记录进行排序、查询等操作。
@JacksonXmlProperty(localName = "contentDesc")
private String contentDesc;
// 关联 "contentDesc" 元素，用于存储对时间线内容的描述信息，比如简单介绍这条时间线记录所代表的事件、消息等内容，便于用户快速了解其大致含义。
@JacksonXmlProperty(localName = "contentDescShowType")
private String contentDescShowType;
// 对应 "contentDescShowType" 元素，可能用于表示内容描述信息的展示类型，例如是文本形式展示、以特定格式的卡片展示等不同展示方式，
// 具体取决于业务中对时间线内容展示的设计要求。
@JacksonXmlProperty(localName = "contentDescScene")
private String contentDescScene;
// 关联 "contentDescScene" 元素，可能表示内容描述信息所处的场景信息，比如是在朋友圈场景、公众号推送场景等不同业务场景下的描述情况，
// 有助于根据不同场景对时间线内容进行针对性处理和展示。
@JacksonXmlProperty(localName = "private")
private String asPrivate;
// 对应 "private" 元素，这里属性名使用 "asPrivate" 可能是为了避免与Java关键字冲突，用于表示时间线内容是否为私有属性，
// 例如是否仅特定用户可见等隐私相关设置，方便进行权限控制和隐私管理。
@JacksonXmlProperty(localName = "sightFolded")
private String sightFolded;
// 关联 "sightFolded" 元素，可能表示时间线内容在展示时是否被折叠的状态信息，比如在列表展示时某些内容可以折叠起来，用户点击展开查看详细，
// 用于控制时间线内容的展示效果和用户交互方式。
@JacksonXmlProperty(localName = "showFlag")
private String showFlag;
// 对应 "showFlag" 元素，用于表示时间线内容的展示标识信息，可能通过不同的值来控制是否展示、以何种方式展示等情况，例如是否置顶展示等设置。
@JacksonXmlProperty(localName = "appInfo")
private AppInfo appInfo;
// 使用 @JacksonXmlProperty 注解将该属性与 "appInfo" 元素相关联，AppInfo是一个内部静态类，用于进一步封装与应用相关的详细信息，
// 比如应用的版本、名称等，可能涉及到时间线内容所关联的应用情况，例如是通过哪个微信小程序或者公众号应用产生的时间线记录等。
@JacksonXmlProperty(localName = "sourceUserName")
private String sourceUserName;
// 对应 "sourceUserName" 元素，用于存储时间线内容的来源用户名称信息，和前面的 "username" 可能有所不同，
// 这里更强调最初产生这条时间线内容的源头用户，例如是转发内容时原作者的用户名等情况。
@JacksonXmlProperty(localName = "sourceNickName")
private String sourceNickName;
// 关联 "sourceNickName" 元素，用于存储来源用户的昵称信息，以更友好、易读的方式展示来源用户，便于用户识别和区分不同来源的时间线内容。
@JacksonXmlProperty(localName = "statisticsData")
private String statisticsData;
// 对应 "statisticsData" 元素，可能用于存储与时间线内容相关的统计数据信息，比如阅读量、点赞数、评论数等统计指标，方便进行数据分析和展示。
@JacksonXmlProperty(localName = "statExtStr")
private String statExtStr;
// 关联 "statExtStr" 元素，可能是用于存储扩展的统计相关字符串信息，比如额外的统计维度、细分的数据等，进一步丰富统计相关的数据内容。
@JacksonXmlProperty(localName = "ContentObject")
private ContentObject contentObject;
// 使用 @JacksonXmlProperty 注解将该属性与 "ContentObject" 元素相关联，ContentObject是一个内部静态类，
// 用于承载时间线内容主体相关的详细信息，例如内容的样式、包含的媒体资源等情况，是时间线内容核心数据的封装。
@JacksonXmlProperty(localName = "publicUserName")
private String publicUserName;
// 对应 "publicUserName" 元素，可能用于存储与时间线内容公开相关的用户名称信息，例如是负责将内容设置为公开状态的管理员用户名等情况，
// 具体含义取决于业务中对公开属性和用户关联的设计。
@JacksonXmlProperty(localName = "location")
private Location location;
// 关联 "location" 元素，Location是一个内部静态类，用于存储时间线内容相关的地理位置信息，比如发布内容时所在的地点信息，
// 方便进行基于位置的展示、搜索等功能实现。
@JacksonXmlProperty(localName = "streamvideo")
private StreamVideo streamVideo;
// 使用 @JacksonXmlProperty 注解将该属性与 "streamvideo" 元素相关联，StreamVideo是一个内部静态类，
// 用于封装与流媒体视频（如视频动态等）相关的信息，比如视频的链接地址、缩略图地址等，适用于时间线中包含视频内容的情况。
/**
* AppInfo内部静态类，用于表示与 "appInfo" XML元素对应的应用相关详细信息的数据结构，
* 包含应用的标识、版本、名称、安装链接等多方面属性，用于描述时间线内容所关联应用的具体情况。
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class AppInfo {
@JacksonXmlProperty(localName = "id")
private String id;
// 对应 "appInfo" 元素下的 "id" 子元素，用于存储应用的唯一标识信息，方便在系统中准确识别和区分不同的应用，例如应用的编号等。
@JacksonXmlProperty(localName = "version")
private String version;
// 关联 "appInfo" 元素下的 "version" 子元素，用于存储应用的版本信息，便于判断应用的新旧程度以及是否需要更新等操作，确保功能的兼容性。
@JacksonXmlProperty(localName = "appName")
private String appName;
// 对应 "appInfo" 元素下的 "appName" 子元素，用于存储应用的名称，以明确该应用的标识，方便用户识别和与其他应用进行区分。
@JacksonXmlProperty(localName = "installUrl")
private String installUrl;
// 关联 "appInfo" 元素下的 "installUrl" 子元素，用于存储应用的安装链接地址，在需要引导用户安装相关应用时，可以提供该链接方便用户操作。
@JacksonXmlProperty(localName = "fromUrl")
private String fromUrl;
// 对应 "appInfo" 元素下的 "fromUrl" 子元素，可能表示应用来源的链接地址，例如是从哪个官方网站、应用商店等渠道获取该应用的相关信息，
// 用于追溯应用的来源和合法性等情况。
@JacksonXmlProperty(localName = "isForceUpdate")
private String isForceUpdate;
// 关联 "appInfo" 元素下的 "isForceUpdate" 子元素，用于表示是否强制用户更新应用的标识信息，比如设置为 "true" 则提示用户必须更新应用才能继续使用某些功能等。
@JacksonXmlProperty(localName = "isHidden")
private String isHidden;
// 对应 "appInfo" 元素下的 "isHidden" 子元素，用于表示应用是否被隐藏的状态信息，例如在某些界面展示中可以根据这个属性决定是否显示该应用相关内容。
}
/**
* ContentObject内部静态类，用于表示与 "ContentObject" XML元素对应的时间线内容主体相关详细信息的数据结构，
* 涵盖内容的样式、描述、标题、包含的媒体资源等多方面属性，是对时间线核心内容的详细封装。
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class ContentObject {
@JacksonXmlProperty(localName = "contentStyle")
private Integer contentStyle;
// 对应 "ContentObject" 元素下的 "contentStyle" 子元素，用于存储时间线内容的样式相关信息，例如是以文本、图片、视频等何种形式展示的样式编号，
// 方便根据不同样式进行相应的展示处理和样式调整。
@JacksonXmlProperty(localName = "description")
private String description;
// 关联 "ContentObject" 元素下的 "description" 子元素，用于存储时间线内容的详细描述信息，进一步补充和细化对内容的介绍，
// 比前面的 "contentDesc" 可能更详细全面，便于用户深入了解时间线所代表的具体内容。
@JacksonXmlProperty(localName = "title")
private String title;
// 对应 "ContentObject" 元素下的 "title" 子元素，用于存储时间线内容的标题信息，以简洁明了的方式概括内容主题，便于用户快速识别和定位感兴趣的内容。
@JacksonXmlProperty(localName = "contentUrl")
private String contentUrl;
// 关联 "ContentObject" 元素下的 "contentUrl" 子元素，用于存储时间线内容对应的链接地址，例如点击标题可以跳转到的详细内容页面的网址等，
// 方便用户查看完整的时间线相关信息。
@JacksonXmlProperty(localName = "mediaList")
private List<Media> mediaList;
// 使用 @JacksonXmlProperty 注解将该属性与 "mediaList" 子元素相关联，MediaList是一个List类型，其中元素为Media类型的内部静态类，
// 用于存储时间线内容包含的多个媒体资源相关信息，比如图片、视频等媒体文件的详细属性，方便处理和展示时间线中的多媒体内容。
/**
* Media内部静态类，用于表示与 "mediaList" 元素中的每个媒体资源对应的详细信息的数据结构，
* 包含媒体的标识、类型、标题、描述、隐私属性、用户数据、子类型、视频大小以及相关的链接和缩略图等多方面属性，
* 全面描述了每个媒体资源的情况。
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class Media {
@JacksonXmlProperty(localName = "id")
private String id;
// 对应 "media" 元素下的 "id" 子元素，用于存储媒体资源的唯一标识信息，便于在系统中区分不同的媒体文件，例如图片的编号、视频的ID等。
@JacksonXmlProperty(localName = "type")
private String type;
// 关联 "media" 元素下的 "type" 子元素，用于表示媒体资源的类型信息，例如 "image"（图片）、"video"（视频）、"audio"（音频）等不同类型的标识，
// 方便根据类型进行相应的处理和展示逻辑。
@JacksonXmlProperty(localName = "title")
private String title;
// 对应 "media" 元素下的 "title" 子元素，用于存储媒体资源的标题信息，类似于内容标题，以简洁的方式概括媒体所表达的主题内容，便于用户识别。
@JacksonXmlProperty(localName = "description")
private String description;
// 关联 "media" 元素下的 "description" 子元素，用于存储媒体资源的详细描述信息，进一步介绍媒体的内容、特点等情况，帮助用户更好地了解。
@JacksonXmlProperty(localName = "private")
private String asPrivate;
// 对应 "media" 元素下的 "private" 子元素，同样是为了避免与Java关键字冲突，用于表示媒体资源是否为私有属性，涉及隐私和访问权限控制等情况。
@JacksonXmlProperty(localName = "userData")
private String userData;
// 关联 "media" 元素下的 "userData" 子元素，用于存储与媒体资源相关的用户自定义数据信息，例如用户添加的备注、标签等内容，方便个性化管理。
@JacksonXmlProperty(localName = "subType")
private String subType;
// 对应 "media" 元素下的 "subType" 子元素，用于表示媒体资源的子类型信息，比如视频类型下可能进一步细分的格式类型（如MP4、AVI等），
// 更细致地描述媒体资源的具体特性，便于针对性处理。
@JacksonXmlProperty(localName = "videoSize")
private String videoSize;
// 关联 "media" 元素下的 "videoSize" 子元素，用于存储视频媒体资源的大小信息，一般以字节等单位表示，方便进行资源管理和展示相关提示（如加载提示等）。
@JacksonXmlProperty(localName = "url")
private Url url;
// 使用 @JacksonXmlProperty 注解将该属性与 "url" 子元素相关联，Url是一个内部静态类，用于封装媒体资源对应的链接相关详细信息，
// 比如链接的类型、MD5校验和以及实际的链接地址等，确保正确获取和使用媒体资源。
@JacksonXmlProperty(localName = "thumb")
private Thumb thumb;
// 关联 "media" 元素下的 "thumb" 子元素，Thumb是一个内部静态类，用于存储媒体资源缩略图相关的详细信息，例如缩略图的类型和实际的缩略图地址，
// 方便在展示媒体列表等场景中先展示缩略图，提高用户体验和界面加载速度。
@JacksonXmlProperty(localName = "size")
private String size;
// 对应 "media" 元素下的 "size" 子元素，用于存储媒体资源的大小信息，和前面的 "videoSize" 类似，但可能更通用，适用于各种类型媒体的大小描述。
}
/**
* Url内部静态类，用于表示与 "media" 元素中的 "url" 子元素对应的链接相关详细信息的数据结构，
* 通过属性映射和文本内容映射的方式，定义了链接的类型、MD5校验和以及实际的链接地址等属性，
* 确保对媒体资源链接的准确表示和处理。
*/
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class Url {
@JacksonXmlProperty(isAttribute = true)
private int type;
// 使用 @JacksonXmlProperty 注解并设置 isAttribute = true，表示这个属性对应的是XML元素的属性（而不是子元素），
// 对应 "url" 元素的属性 "type"，用于存储链接的类型信息

32
wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/UserBO.java
Unescape View File

@ -1,32 +0,0 @@
package com.xcs.wx.domain.bo;
import lombok.Builder;
import lombok.Data;
// UserBO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
@Builder
//自动生成一种被称为 “建造者（Builder）” 模式的代码实现
public class UserBO {
//初始化文件目录...
private String basePath;
//初始化微信id..
private String wxId;
//初始化昵称..
private String nickname;
//初始化版本号..
private String version;
//初始化账号..
private String account;
//初始化手机号
private String mobile;
}

37
wx-dump-admin/src/main/java/com/xcs/wx/domain/bo/VoipMsgBO.java
Unescape View File

@ -1,37 +0,0 @@
package com.xcs.wx.domain.bo;
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;
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
@JsonIgnoreProperties(ignoreUnknown = true)
//这个注解告诉Jackson在进行JSON反序列化时，忽略那些在目标对象中不存在对应属性的未知属性
//防止因为额外的、不认识的JSON字段而抛出异常
@JacksonXmlRootElement(localName = "voipmsg")
//用于指定在将对象序列化为XML时，这个类对应的XML根元素的名称为"voipmsg"
public class VoipMsgBO {
@JacksonXmlProperty(localName = "VoIPBubbleMsg")
private VoIPBubbleMsg voIPBubbleMsg;
//使用JacksonXmlProperty注解指定这个字段在序列化为XML时对应的元素名称为"VoIPBubbleMsg"
//它的类型是内部定义的VoIPBubbleMsg类，用于封装相关的数据
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public static class VoIPBubbleMsg {
//定义了一个内部静态类，同样使用了Data注解和JsonIgnoreProperties注解，具备和外部类类似的功能
@JacksonXmlCData
@JacksonXmlProperty(localName = "msg")
private String msg;
//@JacksonXmlCData注解表示这个字段在序列化为XML时，其内容会被包裹在<![CDATA[...]]>中
//通常用于包含可能包含特殊XML字符（如<、>等）的数据，防止XML解析出错
//@JacksonXmlProperty注解指定该字段在XML中的元素名称为"msg"，它用于存储一个字符串类型的消息内容
}
}

21
wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/ChatRoomDTO.java
Unescape View File

@ -1,21 +0,0 @@
package com.xcs.wx.domain.dto;
import lombok.Data;
import lombok.EqualsAndHashCode;
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
@EqualsAndHashCode(callSuper = true)
//Lombok 提供的便捷工具，用于自动帮你生成equals和hashCode方法的实现代码，减少手动编写这些相对样板化代码的工作量
public class ChatRoomDTO extends PageDTO {
//初始化群聊标题...
private String chatRoomTitle;
//初始化群昵称...
private String selfDisplayName;
//初始化创建人...
private String createBy;
}

23
wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/ContactDTO.java
Unescape View File

@ -1,23 +0,0 @@
package com.xcs.wx.domain.dto;
import lombok.Data;
import lombok.EqualsAndHashCode;
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
@EqualsAndHashCode(callSuper = true)
//Lombok 提供的便捷工具，用于自动帮你生成equals和hashCode方法的实现代码，减少手动编写这些相对样板化代码的工作量
public class ContactDTO extends PageDTO {
//初始化备注
private String remark;
//初始化昵称
private String nickName;
//初始化标签id
private String labels;
//初始化描述
private String describe;
}

32
wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/DecryptDTO.java
Unescape View File

@ -1,32 +0,0 @@
package com.xcs.wx.domain.dto;
import lombok.Data;
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class DecryptDTO {
//初始化pid
private int pid;
//初始化文件目录
private String basePath;
//初始化微信id
private String wxId;
//初始化昵称
private String nickname;
//初始化版本号
private String version;
//初始化账号
private String account;
//初始化手机号
private String mobile;
}

25
wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/FeedsDTO.java
Unescape View File

@ -1,25 +0,0 @@
package com.xcs.wx.domain.dto;
import lombok.Data;
import lombok.EqualsAndHashCode;
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
@EqualsAndHashCode(callSuper = true)
//Lombok 提供的便捷工具，用于自动帮你生成equals和hashCode方法的实现代码，减少手动编写这些相对样板化代码的工作量
public class FeedsDTO extends PageDTO {
//初始化用户名
private String userName;
//初始化开始时间
private Long startTime;
//初始化结束时间
private Long endTime;
}

15
wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/PageDTO.java
Unescape View File

@ -1,15 +0,0 @@
package com.xcs.wx.domain.dto;
import lombok.Data;
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class PageDTO {
//初始化当前页数
private Long current;
//初始化页数大小
private Long pageSize;
}

20
wx-dump-admin/src/main/java/com/xcs/wx/domain/dto/RecoverContactDTO.java
Unescape View File

@ -1,20 +0,0 @@
package com.xcs.wx.domain.dto;
//导入库
import lombok.Data;
import lombok.EqualsAndHashCode;
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
@EqualsAndHashCode(callSuper = true)
//Lombok 提供的便捷工具，用于自动帮你生成equals和hashCode方法的实现代码，减少手动编写这些相对样板化代码的工作量
public class RecoverContactDTO extends PageDTO{
//初始化nickname
private String nickname;
//初始化c2remark
private String remark;
}

19
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/AllContactVO.java
Unescape View File

@ -1,19 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import lombok.Data;
//AllContactVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class AllContactVO {
//用户名
private String userName;
//昵称。
private String nickName;
}

27
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/CardLinkVO.java
Unescape View File

@ -1,27 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.Data;
// CardLinkVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class CardLinkVO {
//title
private String title;
//sourceDisplayName
private String sourceDisplayName;
//des
private String des;
// url
private String url;
}

54
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ChatRoomDetailVO.java
Unescape View File

@ -1,54 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import java.util.List;
// ChatRoomDetailVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class ChatRoomDetailVO {
//群聊名称
private String chatRoomName;
//群聊标题
private String chatRoomTitle;
// 自己在聊天室中的显示名称。
private String selfDisplayName;
//创建人
private String createBy;
//头像
private String headImgUrl;
//预留字段2
@JsonIgnore
//在处理 JSON 序列化和反序列化时，控制对象的属性是否参与序列化和反序列化过程
private String reserved2;
//roomData
@JsonIgnore
//在处理 JSON 序列化和反序列化时，控制对象的属性是否参与序列化和反序列化过程
private byte[] roomData;
//群聊信息
private ChatRoomInfoVO chatRoomInfo;
//群成员
private List<ChatRoomMemberVO> members;
}

39
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ChatRoomInfoVO.java
Unescape View File

@ -1,39 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import lombok.Data;
//ChatRoomInfoVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
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;
}

35
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ChatRoomMemberVO.java
Unescape View File

@ -1,35 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import lombok.Data;
//ChatRoomMemberVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class ChatRoomMemberVO {
/**
*初始化微信id
*/
private String wxId;
/**
* 初始化备注
*/
private String remark;
/**
* 初始化简介
*/
private Integer state;
/**
* 初始化头像
*/
private String headImgUrl;
}

53
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ChatRoomVO.java
Unescape View File

@ -1,53 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
//ChatRoomVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
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;
}

19
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ContactLabelVO.java
Unescape View File

@ -1,19 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import lombok.Data;
//ContactLabelVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class ContactLabelVO {
//标签Id
private String labelId;
//标签名称
private String labelName;
}

45
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ContactVO.java
Unescape View File

@ -1,45 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import lombok.Data;
import java.util.List;
//ContactVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
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;
}

23
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/CountRecentMsgsVO.java
Unescape View File

@ -1,23 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import lombok.Data;
// CountRecentMsgsVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class CountRecentMsgsVO {
// 类型
private String type;
//值
private Long value;
//分类
private String category;
}

19
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/DatabaseVO.java
Unescape View File

@ -1,19 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import lombok.Data;
//DatabaseVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class DatabaseVO {
//文件路径
private String filePath;
//文件大小
private String fileSize;
}

31
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/DecryptVO.java
Unescape View File

@ -1,31 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import lombok.Builder;
import lombok.Data;
//DecryptVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
@Builder
//在编译阶段自动生成一些 Java 样板代码，如构造函数、getter/setter 方法等，以减少开发人员编写的冗余代码量。
public class DecryptVO {
//文件名称
private String fileName;
//文件大小
private String fileSize;
//当前进度
private int currentProgress;
//总数量
private int total;
}

90
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ExportChatRoomVO.java
Unescape View File

@ -1,90 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.ColumnWidth;
import com.alibaba.excel.annotation.write.style.ContentStyle;
import com.alibaba.excel.enums.poi.HorizontalAlignmentEnum;
import lombok.Data;
// ExportChatRoomVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
@ContentStyle(horizontalAlignment = HorizontalAlignmentEnum.CENTER)
//用于自定义某种内容的样式。
// 其中horizontalAlignment = HorizontalAlignmentEnum.CENTER表示设置内容的水平对齐方式为居中。
public class ExportChatRoomVO {
//群号
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("群号")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String chatRoomName;
//群聊名称
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("群聊名称")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String chatRoomTitle;
//备注
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("备注")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String selfDisplayName;
//创建人
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("创建人")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String createBy;
//群聊是否已经解散
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("群聊是否已经解散")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private Boolean dissolution;
//是否为企业微信群
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("是否为企业微信群")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private Boolean enterprise;
//群聊数据
@ExcelIgnore
//它的主要作用是在将 Java 对象的数据导出到 Excel 文件或者从 Excel 文件读取数据并映射到 Java 对象时
// ，指定被该注解标记的属性将被忽略。
private byte[] roomData;
//群聊人数
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("群聊人数")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private Integer memberCount;
}

72
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ExportContactVO.java
Unescape View File

@ -1,72 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.ColumnWidth;
import com.alibaba.excel.annotation.write.style.ContentStyle;
import com.alibaba.excel.enums.poi.HorizontalAlignmentEnum;
import lombok.Data;
// ExportContactVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
@ContentStyle(horizontalAlignment = HorizontalAlignmentEnum.CENTER)
//用于自定义某种内容的样式。
// 其中horizontalAlignment = HorizontalAlignmentEnum.CENTER表示设置内容的水平对齐方式为居中。
public class ExportContactVO {
//用户名
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("微信Id")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String userName;
// 别名
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("微信号")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String alias;
//备注
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("备注")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String remark;
// 昵称
@ColumnWidth(30)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("昵称")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String nickName;
//描述
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("描述")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String describe;
//标签Id
@ColumnWidth(20)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("标签Id")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String labelIdList;
}

81
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ExportMsgVO.java
Unescape View File

@ -1,81 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.ColumnWidth;
import com.alibaba.excel.annotation.write.style.ContentStyle;
import com.alibaba.excel.enums.poi.HorizontalAlignmentEnum;
import lombok.Data;
//ExportMsgVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
@ContentStyle(horizontalAlignment = HorizontalAlignmentEnum.CENTER)
//用于自定义某种内容的样式。
// 其中horizontalAlignment = HorizontalAlignmentEnum.CENTER表示设置内容的水平对齐方式为居中。
public class ExportMsgVO {
//消息服务器 ID
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("消息Id")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String msgSvrId;
//聊天人Id
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用，这里的 “25” 应该是代表某种宽度的度量单位，
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("聊天人Id")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String wxId;
//消息类型
@ColumnWidth(10)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("类型")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private Integer type;
//消息子类型
@ColumnWidth(10)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("子类型")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private Integer subType;
// 是否为发送者
@ColumnWidth(15)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("是否发送者")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private Integer isSender;
//消息创建时间
@ColumnWidth(25)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("创建时间")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String strCreateTime;
//消息内容字符串
@ColumnWidth(80)
//一个用于指定列宽度的注解。通常在表格相关的编程场景中使用
// 可能是像素（px）、点（pt）或者字符宽度等，具体取决于使用这个注解的框架或库的定义。
@ExcelProperty("消息内容")
//用于在将数据导出到 Excel 文件或者从 Excel 文件读取数据时，对 Excel 中的列进行标识。
private String strContent;
}

31
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/FeedsLocationVO.java
Unescape View File

@ -1,31 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import lombok.Data;
//FeedsLocationVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class FeedsLocationVO {
//poiClassifyId
private String poiClassifyId;
//poiName
private String poiName;
//poiAddress
private String poiAddress;
//poiClassifyType
private Integer poiClassifyType;
//city
private String city;
}

19
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/FeedsMediaVO.java
Unescape View File

@ -1,19 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import lombok.Data;
//FeedsMediaVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class FeedsMediaVO {
//大图Url
private String url;
// 缩略图Url
private String thumb;
}

81
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/FeedsVO.java
Unescape View File

@ -1,81 +0,0 @@
package com.xcs.wx.domain.vo;
//导入库
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import java.util.List;
//FeedsVO
@Data
//使用Lombok的Data注解，会自动为类中的非静态、非final字段生成对应的getter、setter方法
//以及toString、equals、hashCode方法，简化代码编写，减少样板代码量
public class FeedsVO {
//动态的唯一标识ID。
private Long feedId;
//创建时间，存储为整数形式。
@JsonIgnore
//在处理 JSON 序列化和反序列化时，控制对象的属性是否参与序列化和反序列化过程
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
//在处理 JSON 序列化和反序列化时，控制对象的属性是否参与序列化和反序列化过程
private String content;
//内容描述
private String contentDesc;
//媒体内容
private List<FeedsMediaVO> medias;
// 位置
private FeedsLocationVO location;
//联系人头像
private String headImgUrl;
}

45
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/MsgTypeDistributionVO.java
Unescape View File

@ -1,45 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
/**
* MsgTypeDistributionVO类是一个值对象（Value Object，VO），在分层架构的软件系统中，
* VO通常扮演着在不同层（比如业务逻辑层与表现层之间）传递数据的角色，它可以将相关的数据进行封装，
* 以一种简单、清晰的结构进行传递，避免各层之间直接传递复杂的数据结构或者过多零散的数据，
* 在这里它的作用大概率是用于传递消息类型分布相关的数据结构，例如统计不同类型消息各自出现的频次等情况时，
* 方便在系统内不同模块间进行数据的流转和共享。
*
* @author xcs
**/
@Data
// @Data注解由Lombok库提供，它的功能非常实用，会自动为该类生成一系列常用的方法。
// 具体来说，它会为类中的每一个私有属性自动生成对应的getter方法（用于获取属性的值）和setter方法（用于设置属性的值），
// 同时还会生成toString方法（方便将对象以字符串形式展示，常用于调试或者日志输出等场景，能直观看到对象的属性值情况）、
// hashCode方法（在涉及基于哈希的数据结构，如HashMap等，进行对象存储和查找等操作时会用到，用于快速定位对象）以及
// equals方法（用于比较两个对象是否在逻辑上相等，即属性值是否都相等）等，通过使用这个注解，大大简化了代码编写过程中
// 手动去编写这些重复且常规的方法的工作量，让代码更加简洁、易读和易维护。
@AllArgsConstructor
// @AllArgsConstructor注解同样来自Lombok库，它会自动为这个类生成一个包含所有参数的构造函数。
// 例如对于这个MsgTypeDistributionVO类，就会生成一个构造函数，其参数顺序和类型与类中的属性声明顺序和类型一致，
// 像这样：public MsgTypeDistributionVO(String type, Integer value) {...}，
// 这样在创建该类的对象实例时，就可以很方便地通过传入对应参数来完成对象的初始化，提高了代码的便利性和可读性，
// 尤其是当需要一次性为对象的多个属性赋值时，不用再逐个调用setter方法来设置属性值了。
public class MsgTypeDistributionVO {
/**
* 用于表示消息的类型，此处定义为字符串类型（String），是因为消息类型往往具有多样化的特点，
* 比如可能是文本消息类型（可以用类似"TEXT"这样的字符串表示）、图片消息类型（如"IMAGE"）等具体的分类标识，
* 通过这样的字符串形式，可以方便地进行消息类型的区分、判断以及后续基于类型的业务逻辑处理等操作。
*/
private String type;
/**
* 表示对应消息类型的数量，定义为整数类型（Integer），它的含义通常是统计某类消息出现的次数等情况，
* 例如在一个聊天记录的统计分析场景中，可能会统计出文本消息出现了100次，那么对于消息类型为"TEXT"的这个对象实例，
* 其value属性的值就会被设置为100，以此来反映不同消息类型在数量方面的分布情况，方便后续进行数据展示、
* 分析对比或者基于数量的业务规则判断等操作。
*/
private Integer value;
}

196
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/MsgVO.java
Unescape View File

@ -1,196 +0,0 @@
package com.xcs.wx.domain.vo;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
/**
* MsgVO类作为一个值对象（Value Object，VO），在整个系统架构中起着传递消息相关数据的重要作用。
* 它将各类与消息相关的属性整合在一起，方便在不同的业务层（如数据访问层、业务逻辑层、展示层等）之间进行数据传递，
* 确保各层之间对于消息数据的交互具有统一、清晰的格式，避免了数据传递的混乱和复杂性。
*
* @author xcs
**/
@Data
// @Data注解是由Lombok库提供的便捷注解，它会自动为该类生成多个实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，通过这些方法，外部代码可以方便地获取类中各个属性的值，
// 这在访问对象的具体属性信息时非常有用，例如获取消息的类型、内容等。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够对类中的属性进行赋值操作，
// 便于根据业务需求动态地修改对象的属性值，比如更新消息的创建时间、聊天者信息等。
// - 自动生成toString方法，该方法将对象以一种易于阅读的字符串形式表示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速直观地查看对象的具体状态，了解各个属性的当前取值情况。
// - 自动生成hashCode方法，这个方法在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会被用到，
// 它根据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便快速查找和比较对象。
// - 自动生成equals方法，用于比较两个MsgVO对象是否在逻辑上相等，即判断它们的所有属性值是否都完全相同，
// 在涉及对象比较的业务逻辑中（如判断两条消息是否完全一致），该方法起着关键作用。
// 通过使用@Data注解，大大减少了手动编写这些重复且基础的方法的工作量，使代码更加简洁、易读和易维护。
public class MsgVO {
/**
* 本地唯一标识符，通常由数据库系统按照自增规则来生成，用于在本地环境中唯一地标识每一条消息记录。
* 例如，在数据库的消息表中，每当插入一条新的消息数据时，这个标识符的值就会自动增加一个固定的步长（常为1），
* 这使得在本地进行消息的查询、排序、关联其他相关数据表（如通过外键关联消息与发送者、接收者等信息）时，
* 能够准确无误地定位到具体的某条消息，保证了数据操作的准确性和唯一性，是消息在本地存储和管理中的重要标识。
*/
private Integer localId;
/**
* 消息服务器 ID，由消息服务器端为每一条消息分配的独一无二的标识符，在整个消息服务器的运行环境中，
* 凭借这个ID，服务器能够精准地对消息进行各种操作，比如消息的存储（确定消息在服务器存储系统中的具体位置）、
* 转发（根据ID找到要转发的消息并发送到指定的目标地址）、检索（按照不同的查询条件通过这个ID快速定位消息）等，
* 它是消息在服务器层面进行管理和流转的核心依据，确保了服务器对大量消息处理的有序性和准确性。
*/
private String msgSvrId;
/**
* 消息类型，采用整数类型来表示不同种类的消息，这是一种常见的消息分类方式。
* 例如，在一个具体的业务系统中，可以定义1代表文本消息，2代表图片消息，3代表语音消息，4代表视频消息等等，
* 具体的数值与消息类型的对应规则由系统的业务逻辑所确定。通过这个字段，在处理消息的各个环节（如消息展示、
* 存储格式选择、业务规则应用等）中，能够快速判断出消息所属的大致类别，进而采取相应的、符合该类型特点的处理方式。
*/
private Integer type;
/**
* 消息子类型，是对消息类型进一步细化的分类标识，用于在同一大类消息下更精确地区分不同的消息变体或特性。
* 以图片消息为例（当type字段表示图片消息对应的数值时），子类型可以根据图片的分辨率高低（如高清图片、普通图片）、
* 图片的格式（如JPEG格式、PNG格式）、图片的来源渠道（是用户上传的、系统自动生成的还是从第三方获取的）等因素进行细分，
* 这样在具体的业务处理过程中，就可以针对这些不同的子类型情况，执行更为细致、贴合实际需求的操作，
* 比如对不同格式的图片采用不同的解码方式进行展示等，使消息处理更加精准和灵活。
*/
private Integer subType;
/**
* 序列号，主要用于体现消息的发送顺序或者在一组相关消息中的排列次序。
* 在很多实际应用场景中，比如即时通讯软件的聊天会话里，每发送一条消息，服务器或客户端会为其分配一个递增的序列号，
* 按照消息发送的先后顺序依次编号。这个序列号在多个方面有着重要作用，例如在消息的排序展示上，确保用户看到的消息
* 按照正确的时间顺序排列；在消息重传、丢失检测等网络传输相关的业务逻辑中，可以通过比较序列号来判断消息的完整性
* 和先后顺序；在多端同步消息时，也依靠序列号来保证不同设备上消息顺序的一致性，维持消息流的连贯性和逻辑性。
*/
private Long sequence;
/**
* 是否为发送者，使用整数来表示消息的来源角色，常见的约定是1表示该消息是由发送方发出的，而0表示这条消息是接收方收到的。
* 通过这个简单的标识字段，在消息处理的业务逻辑中，能够清晰地区分消息的流向，从而针对发送方和接收方的不同情况，
* 实施不同的处理策略。例如对于发送方，可能需要关注消息发送是否成功、是否需要记录发送时间等；对于接收方，则着重考虑
* 消息的展示方式、是否已读标记等相关处理，有助于将消息处理流程按照发送和接收两个不同的方向进行合理划分和细化。
*/
private Integer isSender;
/**
* 消息创建时间，以时间戳的形式进行记录，时间戳一般是指从某个特定的起始时间点（通常是1970年1月1日00:00:00 UTC，即Unix时间戳的起始时间）
* 到消息实际创建那一刻所经过的毫秒数或者秒数（具体取决于系统的时间精度设置）。借助这个时间戳，在众多业务场景中都能发挥重要作用，
* 比如可以通过比较不同消息的创建时间来确定消息的先后顺序，实现消息按时间排序展示；也可以根据创建时间筛选出特定时间段内的消息，
* 满足用户查看某一时刻或某一区间内消息记录的需求；在数据分析方面，还能基于时间戳统计不同时间段内消息的发送量等情况，
* 对消息的时效性和时间维度的分析提供了有力的数据支持。
*/
private Long createTime;
/**
* 消息创建时间的字符串表示形式，它是将前面提到的时间戳按照一定的日期时间格式转换而来的，便于在需要将时间信息以更直观、
* 符合人类阅读习惯的方式展示给用户或者在某些特定业务要求必须使用字符串格式时间的场景中使用。常见的格式可能有"yyyy-MM-dd HH:mm:ss"
* （表示年-月-日 时:分:秒）等，例如在即时通讯软件的聊天界面上，消息旁边显示的发送时间就是以这种易于理解的字符串形式呈现的，
* 让用户能够清晰地知晓消息的发送时刻，提升了用户体验和对时间信息的可读性。
*/
private String strCreateTime;
/**
* 消息内容字符串，对于文本消息而言，这个字段直接承载了具体的文本内容，也就是用户实际输入并发送的文字信息。
* 而对于其他非文本类型的消息（如图像、语音、视频等），它可能会以一种特定的、与业务相关的字符串格式来表示该消息的核心内容
* 或者相关描述信息。例如对于图片消息，可能存储的是图片的一些基本属性信息以字符串形式拼接而成的内容；对于语音消息，
* 也许是语音的时长、格式等相关信息组成的字符串。总之，这个字段是消息承载具体信息的关键部分，在消息展示、内容处理等
* 业务逻辑中处于核心地位，是用户最为关注的消息属性之一。
*/
private String strContent;
/**
* 引用消息内容，主要用于在回复消息、转发消息或者引用消息进行其他操作的场景中，存储被引用的那条消息的部分内容。
* 比如在回复他人消息时，为了让回复内容更具针对性和连贯性，常常会引用对方之前发送的部分关键文字内容，此时这个字段就会
* 保存被引用的那部分文字，以便在展示回复消息时，能够清晰地呈现出消息之间的引用关系，让接收方更好地理解整个消息的上下文，
* 知晓回复内容与之前消息的关联，增强消息交互的逻辑性和连贯性。
*/
private String referMsgContent;
/**
* 聊天者字符串，通常以字符串的形式存储参与聊天的主体的相关标识信息，这可能是聊天对方的用户名、昵称，
* 也有可能是在整个系统内为该用户分配的唯一标识字符串（如用户ID的字符串表示形式）等。在多用户聊天的环境中，
* 通过这个字段可以快速且准确地确定每一条消息对应的聊天对象是谁，方便在查找特定用户的聊天记录、对不同用户的消息
* 进行分类展示以及实现基于用户的消息统计等业务场景中使用，确保消息与具体的聊天者能够紧密关联起来，避免消息归属的混淆。
*/
private String strTalker;
/**
* 头像，用于存放与聊天者或者消息相关主体的头像相关的信息，其存储形式多样，常见的有头像对应的网络链接（例如在网页应用中，
* 通过这个链接可以从服务器上获取头像图片进行展示）、本地文件路径（如果是桌面应用，头像文件存储在本地磁盘时的路径），
* 或者是将头像图片经过某种编码方式（如Base64编码）转换后的字符串形式等。无论采用哪种存储形式，目的都是为了在界面上能够
* 正确地展示出聊天相关人员的头像，使用户可以直观地识别聊天对象的身份特征，提升用户体验和界面的友好性。
*/
private String avatar;
/**
* 图片地址Md5，它是通过对图片的地址（这个地址可以是网络上的图片URL，也可以是本地存储图片的文件路径等）运用MD5算法计算
* 得到的一个哈希值，并以字符串形式进行存储。MD5哈希值具有唯一性和固定长度的特点，利用这一特性，在很多业务场景中可以发挥作用，
* 比如验证图片地址的唯一性，避免重复添加相同的图片资源；在图片缓存机制中，通过比较图片地址的MD5值来判断是否已经缓存过该图片，
* 进而决定是否需要重新下载；在图片资源管理方面，也可以通过MD5值来快速查找和比对图片地址，确保图片相关操作的准确性和高效性。
*/
private String imgMd5;
/**
* 图片缩略图，用于存储图片的缩略图相关信息，其存储形式通常与图片本身类似，可能是缩略图对应的网络链接（方便在网页端快速加载展示）、
* Base64编码后的字符串表示（便于在某些特定的数据传输或存储场景中使用）等。缩略图的主要作用在于，在需要展示图片的场景中，
* 尤其是当图片数量较多或者网络环境不佳、加载完整图片速度较慢的情况下，先展示缩略图能够让用户快速了解图片的大致内容和外观，
* 起到一个预览的效果，同时也能提高页面的整体加载速度，改善用户的浏览体验，而当用户需要查看图片的详细内容时，再加载完整图片。
*/
private String thumb;
/**
* 图片，这个字段用于存储图片的完整信息，同样，其存储形式可以是图片的网络链接（比如在网页应用中通过链接获取并展示图片）、
* Base64编码后的字符串（在一些需要将图片数据嵌入到其他数据结构中传输或存储的场景下使用）等，具体取决于业务系统中图片的
* 存储和传递策略。当需要在界面上完整地展示图片的详细内容、对图片进行进一步的操作（如放大查看、编辑等）时，就会依赖这个字段
* 所存储的图片信息来实现相应功能。
*/
private String image;
/**
* 表情Url，主要用于存储表情符号对应的网络链接信息，在即时通讯、社交软件等应用场景中，用户在发送消息时常常会使用表情来丰富
* 表达内容，而系统则需要根据这个表情Url去获取对应的表情图片，并在消息展示界面上正确地加载和显示出来，让用户看到生动形象的表情，
* 增强消息的趣味性和情感表达，提升用户之间的交互体验。
*/
private String emojiUrl;
/**
* compressContent，用于存储经过压缩处理后的消息内容，以字节数组的形式存在。之所以采用字节数组，是因为消息内容经过压缩后，
* 通常呈现为二进制数据的形式，字节是表示二进制数据的基本单位，所以用字节数组来存储最为合适。同时，这个字段标注了@JsonIgnore注解，
* 意味着在进行JSON序列化（将Java对象转换为JSON格式的字符串，常用于网络传输、数据存储等场景）和反序列化（将JSON格式的字符串转换回Java对象）操作时，
* 这个字段会被忽略，不会被包含在最终生成的JSON数据或者从JSON数据解析生成的对象中。这通常是因为该字段所存储的压缩内容主要是为了在系统内部
* 节省网络传输带宽、减少存储体积等目的而存在的，不需要对外进行展示或者传输给其他外部系统，仅在内部处理消息相关逻辑时发挥作用。
*/
@JsonIgnore
private byte[] compressContent;
/**
* bytesExtra，同样是以字节数组的形式来存储一些与消息相关的额外数据，这些数据的具体内容和用途取决于具体的业务需求，
* 它可能包含消息的加密校验信息（例如对消息进行加密后，存储一些用于验证解密后消息是否正确的校验码等信息）、特定的元数据（如消息的来源IP地址、
* 消息经过的中间服务器标识等额外的描述性信息）等。与compressContent字段一样，也标注了@JsonIgnore注解，在JSON序列化和反序列化时会被忽略，
* 只在系统内部针对消息的特殊处理逻辑中使用，辅助完成一些特定的业务功能，保障消息处理的完整性和准确性。
*/
@JsonIgnore
private byte[] bytesExtra;
/**
* 小程序信息，通过WeAppInfoVO这个自定义的值对象来承载小程序相关的详细信息。WeAppInfoVO类应该是另外定义的一个专门用于描述小程序属性的数据结构，
* 在这里的MsgVO类中，weAppInfo字段通过引用这个值对象来存储小程序的各种相关信息，例如小程序的名称（方便用户识别是哪个小程序）、小程序的ID（在系统中唯一标识该小程序）、
* 小程序页面路径（用于指定进入小程序后展示的具体页面等情况）等内容。当消息中涉及小程序相关的展示、交互等业务场景时（比如用户在聊天窗口中分享小程序链接，
* 接收方收到消息后需要展示小程序的相关信息并支持点击进入小程序等操作），这个字段所包含的WeAppInfoVO对象就能够完整地传递小程序的各项属性，
* 便于在不同的业务层之间进行数据传递和处理，确保小程序相关的功能能够正常实现。
*/
private WeAppInfoVO weAppInfo;
/**
* 卡片链接，借助CardLinkVO这个自定义的值对象来存储卡片链接相关的详细信息。CardLinkVO类想必也是专门为描述卡片链接属性而设计的，
* 它可以存储卡片标题（用于在界面上展示卡片时让用户快速了解链接的大致内容）、卡片描述（提供更详细的关于链接指向内容的介绍）、
* 链接地址（明确点击卡片后要跳转到的具体网址等信息）等内容。在消息中如果包含了卡片形式的内容（比如分享网页链接时，在消息中以卡片样式展示链接信息），
* 利用这个字段所包含的CardLinkVO对象，就可以准确无误地传递卡片的完整信息，方便在界面上以美观、直观的方式展示卡片外观，并且实现用户点击卡片后
* 顺利跳转到对应链接的功能，提升消息中链接分享等场景下的用户体验。
*/
private CardLinkVO cardLink;}

66
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/PageVO.java
Unescape View File

@ -1,66 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.List;
/**
* PageVO类是一个通用的分页数据值对象（Value Object，VO），在处理分页相关业务逻辑时发挥着重要作用。
* 它通过使用泛型 <T>，使得这个类能够灵活适配不同类型的数据分页需求，无论是存储用户信息、商品信息，还是其他任何业务对象的分页数据，
* 都可以借助该类进行统一的封装和传递，增强了代码的通用性和复用性。常用于在数据访问层获取分页数据后，传递给业务逻辑层进行处理，
* 或者从业务逻辑层传递到展示层用于页面展示等场景，确保分页相关的数据在不同层之间能够清晰、规范地流转。
*
* @author xcs
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体包括：
// - 为类中的每一个私有属性自动生成对应的getter方法，方便外部代码获取各个属性的值。例如，在其他类中可以通过调用getCurrent()方法获取当前页数，
// 调用getPageSize()方法获取每页显示的数据条数等，这有助于对分页相关属性进行访问和使用。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值。比如，根据用户的选择改变当前页数或者每页显示的数量等，
// 增强了对象属性值的可修改性和灵活性。
// - 生成toString方法，该方法能将PageVO对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前分页对象的具体状态，了解各个分页属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将PageVO对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个PageVO对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及分页数据比较的业务逻辑中（如判断两个分页结果是否一致），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@AllArgsConstructor
// @AllArgsConstructor注解同样来自Lombok库，它会自动为这个类生成一个包含所有参数的构造函数。
// 对于PageVO类来说，这个构造函数的参数顺序和类型与类中的属性声明顺序和类型是一一对应的，
// 即构造函数形如：public PageVO(Long current, Long pageSize, Long total, List<T> records) {...}。
// 这样在创建PageVO对象实例时，就可以很方便地一次性传入当前页数、页数大小、总页数以及查询结果数据列表这些参数来完成对象的初始化，
// 提高了代码创建分页对象的便利性和可读性，尤其是在需要同时为多个属性赋值时，避免了逐个调用setter方法来设置属性值的繁琐操作。
public class PageVO<T> {
/**
* 当前页数，表示当前所处的页码位置，通常从1开始计数（具体计数起始值可能根据业务约定有所不同，但多数情况下为1）。
* 例如，当用户在分页列表中查看第三页的数据时，这个属性的值就会被设置为3。它是用户在分页浏览数据时进行定位和导航的重要依据，
* 通过改变这个值，用户可以切换到不同的页面查看相应的数据内容，同时在业务逻辑中，也常依据当前页数来计算数据的偏移量等信息，
* 以便从数据源准确地获取对应页面的数据记录。
*/
private Long current;
/**
* 页数大小，指的是每页显示的数据记录数量，例如每页显示10条记录时，该属性的值就会被设置为10。
* 它决定了每次分页查询时返回的数据量多少，合理设置页数大小有助于在展示大量数据时，既保证页面不会一次性加载过多数据导致性能问题，
* 又能让用户方便地浏览和查找所需信息，是分页展示数据时控制数据量的关键因素，同时也会影响总页数的计算以及分页导航的相关逻辑。
*/
private Long pageSize;
/**
* 总页数，是根据总的数据记录数量以及设定的每页大小计算得出的，表示整个数据集按照当前设定的每页显示数量划分后，总共会形成的页数。
* 比如，总共有100条数据记录，每页大小设置为10条，那么总页数就是10页（计算方式通常为总记录数除以每页大小，向上取整得到总页数）。
* 总页数用于界定分页导航的边界范围，在界面上展示分页导航栏（如显示上一页、下一页、跳转到指定页等操作按钮）时，会依据总页数来判断是否显示相应的按钮，
* 防止出现超出总页数范围的无效操作，同时也有助于在业务逻辑中对分页整体情况进行判断和控制。
*/
private Long total;
/**
* 查询条件，使用泛型List<T>来存储具体的查询结果数据记录，这里的T可以是任意类型，具体取决于实际业务中分页查询所针对的数据类型。
* 例如，如果是对用户信息进行分页查询，T就可以是代表用户信息的自定义类（如UserVO类），这个列表中就会存放当前页所包含的具体用户信息对象；
* 如果是对商品信息进行分页查询，T则可以是商品信息类（如ProductVO类），列表中就存储相应的商品信息对象。它承载了当前页要展示给用户的数据内容，
* 是分页数据值对象的核心部分，通过这个属性可以方便地获取和操作当前页的具体数据记录，用于页面展示、后续的数据处理等业务场景。
*/
private List<T> records;
}

41
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/RecentUsedKeyWordVO.java
Unescape View File

@ -1,41 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
/**
* RecentUsedKeyWordVO类是一个值对象（Value Object，VO），在系统中主要用于封装和传递与最近使用的关键字相关的数据。
* 它在涉及搜索功能、消息处理、数据分析等诸多业务场景中发挥作用，通过将关键字信息整合在这个VO类中，方便在系统的不同模块、
* 不同层次之间进行统一的传递和处理，确保各个部分对关键字相关的数据有着清晰、一致的操作对象，有助于提高代码的可读性和可维护性。
*
* @author xcs
**/
@Data
// @Data注解由Lombok库提供，它为该类自动生成了多个常用的方法，具体如下：
// - 自动生成对应的getter方法，通过这个方法（名为getText()）可以方便地从对象中获取关键字的字符串内容，
// 在其他类需要访问这个关键字信息时，只需调用该方法即可，使得对关键字属性的访问更加便捷、规范。
// - 自动生成对应的setter方法（名为setText(String text)），允许外部代码根据业务需求对关键字进行修改，
// 例如当用户输入了新的最近使用关键字时，可以通过调用这个setter方法来更新对象中的关键字内容，增强了对象属性的可操作性。
// - 生成toString方法，该方法能将RecentUsedKeyWordVO对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及关键字的具体值，
// 在调试程序或者记录日志等场景下，通过打印对象的toString结果，可以快速查看当前关键字的具体情况，有助于排查问题和了解对象状态。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它根据对象的关键字属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便快速查找和比较对象。
// - 生成equals方法，用于比较两个RecentUsedKeyWordVO对象是否在逻辑上相等，也就是判断它们所包含的关键字内容是否完全相同，
// 在涉及关键字比较的业务逻辑中（比如判断两个最近使用的关键字是否一致），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@AllArgsConstructor
// @AllArgsConstructor注解同样来自Lombok库，它会自动为这个类生成一个包含所有参数的构造函数，
// 对于RecentUsedKeyWordVO类而言，构造函数的形式为：public RecentUsedKeyWordVO(String text) {...}，
// 这意味着在创建该类的对象实例时，只需要传入表示关键字的字符串参数即可完成对象的初始化，操作非常简便，
// 提高了创建对象时传递关键字数据的便利性和代码的可读性，使得代码在实例化这类对象时更加简洁明了。
public class RecentUsedKeyWordVO {
/**
* 关键字，以字符串（String）类型来存储具体的关键字内容。在实际应用场景中，这个关键字可以是用户在搜索框中近期输入的搜索词语，
* 比如在搜索引擎应用里，用户多次搜索“旅游攻略”“美食推荐”等，这些词语就可以作为最近使用的关键字被封装在这个对象中进行传递和处理；
* 也可以是在聊天应用中用户近期频繁使用的聊天关键词，像“工作进展”“周末活动”等，方便根据这些关键字进行相关的聊天记录查找、统计分析，
* 或者为用户提供更贴合其使用习惯的智能回复等功能，它代表了系统中需要重点关注、传递以及后续进行业务逻辑处理的关键文本信息。
*/
private String text;
}

68
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/RecoverContactVO.java
Unescape View File

@ -1,68 +0,0 @@
package com.xcs.wx.domain.vo;
import com.alibaba.excel.annotation.ExcelIgnore;
import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.ColumnWidth;
import lombok.Data;
/**
* RecoverContactVO类是一个值对象（Value Object，VO），通常用于在系统不同模块之间传递与恢复联系人相关的数据结构，
* 例如在从数据存储层获取联系人恢复相关信息后传递给业务逻辑层进行处理，或者将处理后的联系人信息传递给导出工具（如用于Excel导出）等场景中使用，
* 起到整合和传递联系人关键数据的作用，使数据流转更加清晰、规范。
*
* @author xcs
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体包括：
// - 自动生成所有私有属性对应的getter方法，方便外部代码获取各个属性的值，例如通过调用getDocId()、getAlias()等方法来获取相应属性内容，
// 这有助于在其他类中访问RecoverContactVO对象的具体属性信息。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，比如可以通过调用setAlias(String alias)等方法来更新属性值，
// 增强了对象属性的可操作性，便于数据的动态变化和处理。
// - 生成toString方法，该方法能将RecoverContactVO对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个RecoverContactVO对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及对象比较的业务逻辑中（如判断两个联系人信息是否一致），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
public class RecoverContactVO {
/**
* 本地唯一标识符，通常由数据库等存储机制按照自增规则来生成，用于在本地系统环境中唯一地标识每一条联系人相关的记录。
* 例如在数据库的联系人表中，每当插入一条新的联系人数据时，这个标识符的值就会自动增加一个固定的步长（常为1），
* 方便后续对联系人信息进行查询、排序、关联其他相关数据表（如通过外键关联联系人与所属分组等信息）时，能够准确无误地定位到具体的某条联系人记录，
* 保证了数据操作的准确性和唯一性。这里使用了@ExcelIgnore注解，表示在使用阿里巴巴的Excel操作相关工具进行数据导出或导入等操作时，
* 忽略这个字段，即不会将该字段的数据写入到Excel文件中，也不会从Excel文件中读取对应的数据到这个字段，因为该字段可能主要用于本地系统内部的标识，
* 对外导出展示等场景通常不需要体现。
*/
@ExcelIgnore
private Integer docId;
/**
* alias，从语义上看可能表示联系人的别名（比如在微信中可能类似微信号等），使用了@ExcelProperty注解来指定在Excel文件中的表头名称为“微信号”，
* 这意味着当使用阿里巴巴的Excel操作工具将RecoverContactVO对象的数据导出到Excel文件时，这个字段的数据会对应到表头为“微信号”的列下。
* 同时，使用了@ColumnWidth注解并设置宽度为50，表示在Excel文件中该列的宽度会被设置为50个单位（具体单位根据Excel操作库的设定来确定），
* 这样可以控制该列在Excel中展示时的宽度，使表格展示更加美观、清晰，方便查看相应的数据内容。
*/
@ExcelProperty("微信号")
@ColumnWidth(50)
private String alias;
/**
* nickname，很明显表示联系人的昵称，通过@ExcelProperty注解将其在Excel文件中的表头名称指定为“昵称”，
* 当进行Excel相关操作时，这个字段的数据就会准确地填充到对应表头为“昵称”的列中，便于直观地展示联系人的昵称信息。
* 并且使用@ColumnWidth注解设置列宽为100，确保昵称列在Excel文件中有合适的宽度来展示可能较长的昵称内容，避免出现数据显示不全的情况。
*/
@ExcelProperty("昵称")
@ColumnWidth(100)
private String nickname;
/**
* c2remark，从命名推测可能是联系人的备注信息，同样使用@ExcelProperty注解将其对应的Excel表头名称定义为“备注”，
* 使得在导出到Excel文件时，该字段的数据能正确地放置在表头为“备注”的列下，方便查看联系人对应的备注内容。
* 而@ColumnWidth(100)的设置也是为了给备注列提供足够的宽度，以完整展示可能较为详细的备注信息，提升Excel文件中数据展示的可读性和完整性。
*/
@ExcelProperty("备注")
@ColumnWidth(100)
private String remark;
}

134
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/ResponseVO.java
Unescape View File

@ -1,134 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.Data;
/**
* ResponseVO类是一个通用的响应数据值对象（Value Object，VO），常用于在系统不同模块或层之间传递操作的响应结果信息，
* 例如在服务层处理完业务逻辑后，将处理结果封装到该对象中返回给控制层，再由控制层将其转换为合适的格式（如JSON格式）返回给前端等调用方，
* 使得响应数据的结构清晰、规范，便于调用方统一处理不同操作的结果情况。
*
* @author xcs
* &#064;date 2023年12月25日 17时31分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 为类中的每一个私有属性自动生成对应的getter方法，方便外部代码获取各个属性的值，例如可以通过调用getSuccess()获取业务编码状态，
// 通过getErrorCode()获取错误编码等，便于对响应结果中的各部分信息进行访问和后续处理。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，比如在构建响应对象时，
// 通过调用setSuccess(boolean success)方法来设置业务是否成功等，增强了对象属性值的可修改性和灵活性。
// - 生成toString方法，该方法能将ResponseVO对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前响应对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个ResponseVO对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及响应结果比较的业务逻辑中（如判断两次相同操作的响应是否一致），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
public class ResponseVO<T> {
/**
* 业务编码，使用布尔类型（Boolean）来表示业务操作是否成功，通常true表示业务处理成功，false表示业务处理出现问题或失败，
* 这是调用方首先关注的关键信息之一，用于快速判断整体业务的执行情况，以便后续根据该状态进行不同的处理逻辑，例如成功时展示数据，
* 失败时提示相应的错误信息等。
*/
private Boolean success;
/**
* 错误编码，当业务操作出现错误时，通过这个整数类型（Integer）的字段来记录具体的错误代码，不同的错误代码可以对应不同类型的错误情况，
* 例如在一个Web应用中，1001可能表示数据库连接错误，1002表示参数验证不通过等，方便在系统中对错误进行分类、定位以及统一的处理，
* 特别是在日志记录、错误提示给前端等场景下，可以依据错误编码快速知晓具体的错误原因类别，进而采取相应的解决措施。
*/
private Integer errorCode;
/**
* 错误消息，以字符串（String）类型存储详细的错误描述信息，当业务出现错误时，这个字段会给出具体的错误提示内容，
* 相比于错误编码更加直观易懂，例如“数据库连接超时，请检查网络配置”“用户名格式不符合要求，请重新输入”等，方便开发人员调试问题以及将
* 具体的错误情况反馈给前端展示给用户，让用户清楚了解操作失败的原因所在。
*/
private String errorMessage;
/**
* 页数，用于在涉及分页相关业务操作的响应结果中，表示当前返回数据所在的页码信息，通常在查询列表数据并分页返回时使用，
* 例如当查询用户列表数据分页展示时，这个字段会告知调用方当前返回的这部分数据是第几页的内容，方便前端进行分页导航等相关逻辑的处理，
* 其值一般从1开始计数（具体根据业务约定可能会有不同），与其他分页相关的属性（如total属性）配合使用来完整呈现分页情况。
*/
private Long page;
/**
* 总数量，同样是在分页相关业务场景中使用，用于表示符合查询条件的所有数据的总条数，结合page属性以及每页显示的数据量（通常由其他相关配置确定），
* 可以计算出总页数等分页相关信息，方便前端等调用方全面了解数据的整体规模以及分页情况，例如总共有100条用户数据，当前返回第2页，每页显示10条，
* 调用方就能通过这些信息清晰知晓分页的整体状态以及剩余未获取的数据情况等。
*/
private Long total;
/**
* 展示类型，使用整数类型来表示数据展示的不同方式或样式等相关分类信息，具体含义和取值取决于业务的具体设定，
* 例如在一个具有多种数据展示模板的系统中，1可能表示列表形式展示，2表示卡片形式展示等，通过这个字段可以让调用方知晓如何对返回的数据进行合适的展示处理，
* 不过具体的含义需要结合业务实际情况来明确，不同的业务场景下其用途和取值规则会有所差异。
*/
private Integer showType;
/**
* 数据，通过泛型（T）来表示具体的业务数据内容，它可以是任意类型的数据，取决于实际业务操作所返回的数据类型，
* 比如在查询用户信息的业务中，T可以是代表用户信息的自定义类（如UserVO），这里就存放具体的用户信息对象列表；在查询商品信息时，
* T则可以是商品信息类（如ProductVO），用于承载相应的商品数据，它是响应结果中真正包含业务核心信息的部分，也是调用方在业务成功时重点关注获取的内容。
*/
private T data;
/**
* 成功静态方法，用于便捷地创建表示业务成功的ResponseVO对象实例，并且封装传入的数据。
* 它接收一个泛型类型的数据参数（data），该参数代表业务操作成功后要返回的具体业务数据，然后创建一个ResponseVO对象，
* 将业务编码（success）设置为true，表示业务成功，同时把传入的数据设置到data属性中，最后返回这个构建好的ResponseVO对象，
* 方便在业务层等代码中快速返回成功的响应结果，避免了手动创建对象并逐个设置属性的繁琐操作，提高了代码的简洁性和编写效率。
*
* @param data 数据，即业务操作成功后要返回的具体业务数据，其类型由泛型T决定，可以是任意符合业务需求的类型。
* @param <T> 泛型对象，用于使该方法能适配不同类型的业务数据返回情况，增强方法的通用性。
* @return ResponseVO<T>，返回构建好的表示业务成功的ResponseVO对象实例，包含传入的业务数据以及设置好的业务成功状态。
*/
public static <T> ResponseVO<T> ok(T data) {
ResponseVO<T> wrapper = new ResponseVO<>();
wrapper.setSuccess(true);
wrapper.setData(data);
return wrapper;
}
/**
* 另一个成功静态方法，相较于上面的ok(T data)方法，此方法除了封装业务数据外，还额外设置了页数（page）和总数量（total）属性，
* 适用于分页查询业务成功且需要返回分页相关信息的场景。它接收业务数据（data）以及表示当前页数（page）和总数量（total）的参数，
* 同样先创建一个ResponseVO对象，然后将业务编码设置为true，把传入的数据设置到data属性，再分别设置page和total属性的值，
* 最后返回构建好的包含分页信息的成功响应对象，方便在分页查询操作成功时准确地向调用方传递业务数据以及分页情况。
*
* @param data 数据，即分页查询业务操作成功后要返回的具体业务数据，其类型由泛型T决定，可以是任意符合业务需求的类型。
* @param <T> 泛型对象，用于使该方法能适配不同类型的业务数据返回情况，增强方法的通用性。
* @param page 页数，用于指定当前返回数据所在的页码，其值一般从1开始计数（根据业务约定可能有不同）。
* @param total 总数量，用于表示符合查询条件的所有数据的总条数，与page属性配合体现分页情况。
* @return ResponseVO<T>，返回构建好的表示分页查询业务成功的ResponseVO对象实例，包含传入的业务数据、设置好的业务成功状态以及分页相关信息。
*/
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;
}
/**
* 失败静态方法，用于创建表示业务失败的ResponseVO对象实例，并设置相应的错误编码（errorCode）和错误消息（errorMessage）属性，
* 方便在业务出现错误时统一返回包含错误信息的响应结果给调用方。它接收表示错误编码和错误消息的参数，创建ResponseVO对象后，
* 将业务编码（success）设置为false，表示业务失败，设置传入的错误编码到errorCode属性，设置传入的错误消息到errorMessage属性，
* 同时将展示类型（showType）设置为一个默认值（这里设置为2，具体含义可能根据业务而定），最后返回构建好的表示业务失败的ResponseVO对象，
* 使得在业务逻辑中出现错误情况时，能够规范、便捷地返回相应的错误响应，便于调用方知晓具体的错误情况并进行后续处理。
*
* @param <T> 泛型对象，虽然在业务失败时通常不涉及具体业务数据的返回，但通过保持泛型定义，使该方法在形式上与其他成功方法保持一致，
* 增强整个ResponseVO类在构建响应对象时的通用性和统一性，这里T可以是任意类型（实际业务失败时一般不关注其具体类型）。
* @return ResponseVO<T>，返回构建好的表示业务失败的ResponseVO对象实例，包含设置好的业务失败状态、错误编码以及错误消息等信息。
*/
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;
}
}

68
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/SessionVO.java
Unescape View File

@ -1,68 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.Data;
/**
* SessionVO类是一个值对象（Value Object，VO），在系统中通常用于封装和传递与会话相关的数据信息，
* 比如在即时通讯、在线客服等涉及会话场景的业务中，方便在不同模块（如数据获取层、业务逻辑层、展示层等）之间传递完整的会话数据结构，
* 确保各层之间对会话相关信息的交互有着统一、清晰的格式，有助于提高代码的可读性以及后续的维护性。
*
* @author xcs
* &#064;date 2023年12月21日 18时13分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，通过这些方法（例如getUserName()、getNickName()等），外部代码可以方便地获取类中各个属性的值，
// 这在访问会话相关的具体属性信息时非常有用，比如在展示会话信息时获取用户名、用户昵称等内容。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够对类中的属性进行赋值操作，便于根据业务需求动态地修改对象的属性值，
// 例如当用户更新了昵称，就可以通过调用setNickName(String newNickName)方法来更新nickName属性的值。
// - 生成toString方法，该方法能将SessionVO对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前会话对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，这个方法在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会被用到，
// 它根据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便快速查找和比较对象。
// - 生成equals方法，用于比较两个SessionVO对象是否在逻辑上相等，即判断它们的所有属性值是否都完全相同，
// 在涉及会话对象比较的业务逻辑中（如判断两个会话是否为同一用户、同一时间等情况），该方法起着关键作用。
// 通过使用@Data注解，大大减少了手动编写这些重复且基础的方法的工作量，使代码更加简洁、易读和易维护。
public class SessionVO {
/**
* 用户名，以字符串（String）类型存储用户在系统中的名称标识，这个名称一般具有唯一性，
* 常用于用户登录、系统内部对用户的区分以及在涉及用户相关操作的业务逻辑中进行准确的用户定位等，
* 在会话场景中，通过用户名可以明确知道是哪个用户参与了此次会话，是会话相关信息中重要的基础属性之一。
*/
private String userName;
/**
* 用户昵称，同样是字符串类型，是用户对外展示的一个称呼，相较于用户名可能更加个性化、易读，
* 用户可以自行设置和修改昵称，在会话场景中，昵称通常会展示给其他参与会话的人员，方便他人更友好、直观地识别用户，
* 增强了会话中的用户交互体验和信息展示的友好性。
*/
private String nickName;
/**
* 会话内容，存储具体的会话文本信息，也就是参与会话的用户之间交流的内容，以字符串形式体现，
* 它是会话的核心部分，承载着用户之间传递的消息、想法等关键信息，在展示会话记录、分析会话内容等业务场景中是重点关注的属性。
*/
private String content;
/**
* 消息时间戳，采用整数（Integer）类型来记录消息发送或产生的时间点，一般是以某个特定的起始时间为基准（如Unix时间戳以1970年1月1日00:00:00 UTC为起点），
* 到消息实际产生时刻所经过的秒数或者毫秒数等（具体取决于系统的时间精度设定），通过这个时间戳，可以准确判断会话中消息的先后顺序、
* 消息的时效性，也便于在进行会话记录的排序、筛选特定时间段内的会话等业务操作时作为时间依据，确保会话在时间维度上的准确性和有序性。
*/
private Integer time;
/**
* 短时间，以字符串类型存储经过格式化后的相对简短的时间表示形式，它通常是将前面的消息时间戳按照一定的简单格式转换而来，
* 例如“10:30”（表示10点30分）、“昨天 15:20”等形式，便于在会话界面等场景中以一种更简洁、符合用户阅读习惯的方式展示消息的时间，
* 让用户能够快速知晓会话发生的大致时间，提升用户查看会话记录时对时间信息的可读性和便捷性。
*/
private String shortTime;
/**
* 头像Url，以字符串形式存放用户头像对应的网络链接地址，在需要展示用户头像的会话界面等场景中，
* 通过这个链接，系统可以从服务器或者其他指定的网络位置获取头像图片并进行展示，使用户能够直观地识别参与会话的用户身份，
* 进一步丰富会话界面的信息展示，提升用户体验和会话交互的可视化效果。
*/
private String headImgUrl;
}

62
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/StatsPanelVO.java
Unescape View File

@ -1,62 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
/**
* StatsPanelVO类是一个值对象（Value Object，VO），主要用于封装和传递与统计面板相关的数据结构，
* 通常在涉及展示系统相关统计信息的业务场景中发挥作用，比如在即时通讯软件的个人信息统计页面、管理后台的概况统计板块等地方，
* 方便将不同维度的统计数据整合在一起，在系统的不同模块、不同层次之间进行统一的传递和展示，确保统计数据的流转清晰、规范，便于后续处理和展示操作。
*
* @author xcs
* &#064;date 2024年01月23日 17时25分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，通过这些方法（例如getContact()、getChatRoom()等），外部代码可以方便地获取类中各个属性的值，
// 这在访问统计面板相关的具体属性信息时非常有用，比如在前端页面展示统计数据时获取联系人数量、群聊数量等内容，便于进行数据展示和后续处理。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够对类中的属性进行赋值操作，便于根据业务需求动态地修改对象的属性值，
// 例如当有新的联系人添加或者消息收发情况发生变化时，可以通过调用相应的setter方法来更新对象中的属性值，增强了对象属性的可操作性和灵活性。
// - 生成toString方法，该方法能将StatsPanelVO对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前统计面板对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个StatsPanelVO对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及统计数据比较的业务逻辑中（如判断不同时间段或者不同用户的统计面板数据是否一致），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@AllArgsConstructor
// @AllArgsConstructor注解同样来自Lombok库，它会自动为这个类生成一个包含所有参数的构造函数，
// 对于StatsPanelVO类而言，构造函数的形式为：public StatsPanelVO(Integer contact, Integer chatRoom, Integer sent, Integer received) {...}，
// 这意味着在创建该类的对象实例时，只需要依次传入表示联系人数量、群聊数量、今日发送消息数量以及今日接收消息数量的整数参数，即可完成对象的初始化，
// 操作非常简便，提高了创建对象时传递统计数据的便利性和代码的可读性，使得代码在实例化这类对象时更加简洁明了。
public class StatsPanelVO {
/**
* 联系人数量，使用整数（Integer）类型来存储系统中联系人的个数统计值，这个数量统计涵盖了用户所有的个人联系人，
* 例如在即时通讯软件里，包括好友、关注的人等不同类型的联系人总和，通过这个属性可以直观地展示用户社交关系网络中联系人方面的规模情况，
* 是统计面板上反映用户社交资源的一个重要指标，常用于在个人信息页面或者系统概况展示中让用户了解自己的社交人脉数量等情况。
*/
private Integer contact;
/**
* 群聊数量，同样以整数类型记录用户所参与的群聊的个数，在很多社交、协作类的应用中，群聊是多人交流互动的重要方式，
* 这个属性能够体现用户在群体交流方面的参与程度和规模，比如展示用户加入了多少个工作群、兴趣交流群等，是统计面板中用于呈现用户群体社交活动情况的关键指标之一，
* 方便用户对自己参与的群聊整体情况有清晰的认知，也有助于系统从群聊维度进行相关的数据分析和管理。
*/
private Integer chatRoom;
/**
* 今日发送消息数量，以整数来表示在当前这一天内用户发送出去的消息的总条数，它从消息发送的角度反映了用户当天的活跃程度和交流频率，
* 在即时通讯、社交互动等应用场景中，这个统计数据可以帮助用户了解自己当天的沟通情况，同时对于系统来说，也能基于这样的数据进行用户行为分析、
* 消息流量监控等相关操作，是衡量用户当日信息输出情况的重要量化指标，常用于每日活跃情况统计、消息使用频率分析等业务场景中展示。
*/
private Integer sent;
/**
* 今日接受消息数量，也是整数类型，用于统计当天用户接收到的消息的总条数，与今日发送消息数量相对应，
* 从消息接收端体现用户当天的信息获取情况，同样能反映用户的活跃程度以及在社交互动中的受关注程度等，
* 例如在一些社交平台上，通过对比发送和接收消息数量可以分析出用户是更倾向于主动发起交流还是更多地作为信息接收者参与互动，
/是统计面板里展示用户当日信息流入情况的关键统计数据，在多种数据分析和用户行为洞察的业务场景中有着重要作用。
*/
private Integer received;
}

55
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/TopContactsVO.java
Unescape View File

@ -1,55 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.Data;
/**
* TopContactsVO类是一个值对象（Value Object，VO），通常用于在系统中封装和传递与重要联系人相关的数据结构，
* 比如在即时通讯软件展示常联系的好友列表、社交平台呈现互动频繁的联系人排行等业务场景下，方便整合相关联系人的关键信息，
* 并在系统的不同模块、不同层级之间进行统一的传递和处理，使得数据流转更加清晰、有条理，便于后续的展示、分析等操作。
*
* @author xcs
* &#064;date 2024年01月06日 15时38分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体作用如下：
// - 自动生成所有私有属性对应的getter方法，例如通过调用getUserName()、getNickName()等方法，外部代码可以方便地获取类中各个属性的值，
// 这在需要访问联系人的具体属性信息时非常有用，比如在前端页面展示联系人信息时获取用户名、昵称等内容，便于数据的展示和使用。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当联系人更新了昵称，
// 可以通过调用setNickName(String newNickName)方法来更新nickName属性的值，增强了对象属性的可操作性和灵活性。
// - 生成toString方法，该方法能将TopContactsVO对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前对象所代表的联系人的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个TopContactsVO对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及联系人对象比较的业务逻辑中（如判断两个联系人是否为同一人等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
public class TopContactsVO {
/**
* 用户名，以字符串（String）类型存储用户在系统中的唯一标识名称，这个名称通常具有唯一性，
* 在系统内部的诸多业务逻辑中（如用户登录、数据关联、权限管理等）依靠用户名来准确地定位和区分不同的用户，
* 在TopContactsVO类所涉及的场景里，通过用户名可以明确知道是哪个具体的用户被列为重要联系人，是联系人相关信息中关键的基础属性之一。
*/
private String userName;
/**
* 昵称，同样是字符串类型，它是用户对外展示的一个比较个性化、友好的称呼，用户可以自行设置和修改昵称，
* 相较于用户名，昵称更加通俗易懂、便于记忆，在展示联系人信息时，昵称往往更能直观地让其他用户识别是谁，
* 增强了联系人展示的友好性和可读性，也是联系人相关信息中重要的用于展示和识别的属性。
*/
private String nickName;
/**
* 头像，以字符串形式存放用户头像对应的网络链接地址或者本地存储路径（具体取决于系统的实现方式），
* 在需要展示联系人头像的业务场景中（如联系人列表、聊天界面等），通过这个地址或路径，系统可以获取相应的头像图片并进行展示，
* 使得用户能够直观地通过头像识别联系人身份，丰富了联系人信息的展示内容，提升用户体验和视觉识别效果。
*/
private String headImgUrl;
/**
* total，使用长整数（Long）类型来存储与该联系人相关的某个统计总量数值，具体代表的含义取决于业务场景，
* 例如可能表示与该联系人的聊天消息总条数、互动次数总和、文件传输总量等，它是用于衡量该联系人在某个维度上与当前用户关联程度的量化指标，
* 通过这个属性可以对不同的重要联系人进行排序、对比等操作，便于筛选出真正互动频繁、联系紧密的联系人，在呈现重要联系人相关统计情况时起着关键作用。
*/
private Long total;
}

70
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/UserInfoVO.java
Unescape View File

@ -1,70 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.Data;
/**
* UserInfoVO类是一个值对象（Value Object，VO），主要用于封装和传递与用户信息相关的数据，
* 在系统的不同模块、不同层级之间起到整合并传递用户关键信息的作用，例如在用户注册、登录后信息获取，
* 或者在不同业务功能模块间需要共享用户基础资料等场景下使用，确保用户信息的传递具有统一、清晰的格式，
* 便于后续对用户数据进行处理、展示以及其他相关操作，有助于提高代码的可读性和可维护性。
*
* @author xcs
* &#064;date 2024年6月28日16:13:53
*/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，像通过调用getBasePath()、getWxId()等方法，外部代码可以方便地获取类中各个属性的值，
// 这在需要访问用户具体属性信息时非常有用，比如在展示用户详情页面时获取文件目录、微信Id等内容，便于数据展示与后续使用。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当用户更新了手机号，
// 可以通过调用setMobile(String newMobile)方法来更新mobile属性的值，增强了对象属性的可操作性和灵活性。
// - 生成toString方法，该方法能将UserInfoVO对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前用户信息对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个UserInfoVO对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及用户对象比较的业务逻辑中（如判断两个用户信息是否一致），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
public class UserInfoVO {
/**
* 文件目录，以字符串（String）类型存储与用户相关的文件所在的路径信息，这个路径可以是本地磁盘上的文件夹路径，
* 例如在某个本地应用中，用户上传的文件、生成的配置文件等可能都存放在该指定的文件目录下；也可以是网络存储中的特定路径，
* 具体取决于系统的架构和文件存储的实现方式。它用于定位和管理与该用户相关的各类文件，是涉及文件操作以及用户数据管理时的重要属性之一。
*/
private String basePath;
/**
* 微信Id，同样是字符串类型，用于唯一标识用户在微信生态系统（或者相关使用微信授权登录等场景的系统）中的身份，
* 类似于一个独特的账号标识，通过这个Id可以在微信相关的服务器端、客户端等进行用户的精准定位、数据关联以及各种业务操作，
* 在整合微信相关功能或者基于微信账号进行用户认证、信息同步等业务场景中，微信Id是关键的用户标识属性。
*/
private String wxId;
/**
* 昵称，也是字符串类型，是用户对外展示的一个比较个性化、友好的称呼，用户可以自行设置和修改昵称，
* 相较于账号等相对固定且较为正式的标识，昵称更加通俗易懂、便于记忆，在社交互动、用户展示等场景中，昵称往往更能直观地让其他用户识别是谁，
* 是增强用户之间交互友好性和识别度的重要属性，也是体现用户个性化的关键元素之一。
*/
private String nickname;
/**
* 版本号，以字符串形式记录用户所使用的软件、系统或者某个特定功能模块的版本标识信息，例如在手机应用中，
* 版本号可能呈现为“1.0.1”这样的格式，它用于区分不同阶段发布的软件版本，方便进行版本管理、功能更新提示以及兼容性判断等操作，
* 当涉及软件升级、不同版本间功能差异处理等业务场景时，版本号就是一个重要的参考依据，确保系统能根据用户的版本情况准确地提供相应服务。
*/
private String version;
/**
* 账号，以字符串类型存储用户在系统中用于登录、认证等操作的主要标识信息，这个账号可以是用户自行注册的用户名，
* 也可以是邮箱、手机号等其他可作为登录凭证的信息（具体取决于系统的登录验证机制），是用户进入系统、获取相应服务的重要“钥匙”，
* 在用户登录、权限管理以及涉及用户身份验证的诸多业务逻辑中起着核心的标识作用。
*/
private String account;
/**
* 手机号，同样是字符串类型，存储用户的手机号码信息，手机号在很多系统中不仅可作为登录账号的一种形式，
* 还常用于身份验证（如接收验证码进行注册、登录、修改重要信息等操作）、消息通知（如接收系统推送的短信提醒）以及关联其他服务（如与手机号绑定的第三方账号授权等），
/是与用户联系紧密且具有多种重要用途的关键属性，在涉及用户安全验证、信息推送以及多平台账号整合等业务场景中有着重要地位。
*/
private String mobile;
}

61
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/UserVO.java
Unescape View File

@ -1,61 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
/**
* UserVO类是一个值对象（Value Object，VO），在系统中主要用于封装和传递与用户相关的关键数据，
* 通常在涉及用户展示、用户状态管理以及不同模块间传递用户信息等业务场景中发挥作用，
* 能够使相关的用户数据以一种统一、清晰的结构在系统各部分之间流转，便于后续的操作与处理，提高代码的可读性和可维护性。
* @author xcs
* &#064;date 2023年12月10日20:21:02
*/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体作用如下：
// - 自动生成所有私有属性对应的getter方法，例如通过调用getWxId()、getNickname()等方法，外部代码能够方便地获取类中各个属性的值，
// 在需要展示用户信息、根据用户属性进行相关业务逻辑判断等场景下，这些getter方法能便捷地提供对应属性的数据访问途径。
// - 自动生成所有私有属性对应的setter方法，使得外部代码可以根据业务需求动态地修改对象的属性值，比如当用户更新了昵称，
// 可以通过调用setNickname(String newNickname)方法来更新nickname属性的值，从而保证对象属性能够灵活地反映用户数据的变化。
// - 生成toString方法，该方法会将UserVO对象以一种直观、易于阅读的字符串形式展示出来，通常包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前用户对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个UserVO对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及用户对象比较的业务逻辑中（如判断两个用户是否为同一人、状态是否一致等情况），该方法能够准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@AllArgsConstructor
// @AllArgsConstructor注解同样来自Lombok库，它会自动为这个类生成一个包含所有参数的构造函数，
// 对于UserVO类而言，构造函数的形式为：public UserVO(String wxId, String nickname, String avatar, boolean current) {...}，
// 这意味着在创建该类的对象实例时，只需要依次传入微信Id（wxId）、昵称（nickname）、头像（avatar）以及当前选中状态（current）这些参数，
// 即可完成对象的初始化操作，这种方式提高了创建用户对象时传递数据的便利性和代码的可读性，使代码在实例化该类对象时更加简洁明了。
public class UserVO {
/**
* wxId，以字符串（String）类型存储用户在微信相关系统（或与之相关联、使用微信授权等的系统）中的唯一标识，
* 类似于一个独一无二的身份编码，通过这个标识，系统能够在众多用户中精准地定位到具体的某一位用户，
* 常用于用户数据的查询、关联以及各种涉及用户身份识别的业务操作中，是用户相关信息中非常关键的基础属性。
*/
private String wxId;
/**
* 昵称，同样为字符串类型，是用户对外展示的一个比较个性化、友好的称呼，用户可以自行设置和修改昵称，
* 在社交互动、用户列表展示等场景中，昵称往往更能直观地让其他用户识别是谁，相比于较为固定和正式的账号等标识，
* 昵称更具亲和力，能增强用户之间交互的友好性，也是体现用户个性化特征的重要属性之一。
*/
private String nickname;
/**
* 头像，以字符串形式存放用户头像对应的网络链接地址或者本地存储路径（具体取决于系统的实现方式），
* 在需要展示用户头像的业务场景中（如用户列表、聊天界面等），通过这个地址或路径，系统可以获取相应的头像图片并进行展示，
* 使得用户能够直观地通过头像识别其他用户的身份，丰富了用户信息的展示内容，提升了用户体验和视觉识别效果。
*/
private String avatar;
/**
* 当前选中状态，使用布尔类型（boolean）来表示用户当前是否处于被选中的状态，例如在一个多选用户的操作界面中，
* true表示该用户当前被选中了，false则表示未被选中，这个属性常用于用户界面交互中对用户选择情况的记录和判断，
* 以便后续根据用户的选择执行相应的业务操作，比如批量操作选中的用户、展示选中用户的特定信息等。
*/
private boolean current;
}

55
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/WeAppInfoVO.java
Unescape View File

@ -1,55 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.Data;
/**
* WeAppInfoVO类是一个值对象（Value Object，VO），在系统中主要用于封装和传递与小程序（WeApp）相关的详细信息，
* 例如在即时通讯软件中涉及小程序分享、在相关应用里展示小程序详情等业务场景下，方便将小程序的各项关键属性整合在一起，
* 并在不同模块、不同层级之间进行统一的传递和处理，确保小程序信息的流转清晰、规范，便于后续进行展示、操作等相关业务逻辑的实现。
* @author xcs
* &#064;date 2024年01月17日 14时19分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，像通过调用getTitle()、getSourceDisplayName()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要展示小程序信息，例如在前端页面呈现小程序的标题、来源显示名称等内容时，这些getter方法能便捷地提供对应属性的数据访问途径，便于信息展示。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，比如当小程序的标题发生变化，
// 可以通过调用setTitle(String newTitle)方法来更新title属性的值，保证对象属性能够灵活地反映小程序相关信息的变化，增强了属性的可操作性。
// - 生成toString方法，该方法能将WeAppInfoVO对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前小程序信息对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个WeAppInfoVO对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及小程序信息比较的业务逻辑中（如判断两个小程序的相关属性是否一致），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
public class WeAppInfoVO {
/**
* title，以字符串（String）类型存储小程序的标题信息，标题通常是对小程序主要功能、特点或者所属业务领域的简要概括，
* 用于在小程序展示列表、分享卡片、相关介绍页面等场景中，让用户快速了解这个小程序大致是做什么的，是小程序对外展示时重要的标识性信息之一，
* 方便用户在众多小程序中快速识别和区分不同的小程序。
*/
private String title;
/**
* sourceDisplayName，同样为字符串类型，用于表示小程序的来源显示名称，它可能体现的是小程序的开发者、所属机构或者发布渠道等相关信息，
* 在展示小程序详情、进行来源追溯或者对小程序进行分类管理等业务场景中，这个属性能够帮助用户和系统更好地了解小程序的背景情况，
/也是小程序相关信息中重要的用于展示和识别的属性之一。
*/
private String sourceDisplayName;
/**
* weAppIconUrl，以字符串形式存放小程序图标的网络链接地址（通常情况下），在需要展示小程序外观形象的业务场景中（如小程序列表展示、分享界面等），
* 通过这个网络链接，系统可以获取对应的图标图片并进行展示，使得用户能够直观地通过图标识别小程序，增强小程序的视觉辨识度和用户体验，
//是小程序信息展示中重要的可视化元素相关属性。
*/
private String weAppIconUrl;
/**
* weAppPageThumbRawUrl，也是以字符串类型存储小程序页面缩略图的原始网络链接地址，在一些场景下，比如当用户分享小程序内的某个页面，
//或者查看小程序特定页面的预览图时，通过这个链接可以获取到相应页面的缩略图进行展示，让用户提前了解页面的大致内容和布局，
//是用于呈现小程序页面相关视觉信息的重要属性，有助于提升用户对小程序页面内容的认知和交互体验。
*/
private String weAppPageThumbRawUrl;
}

98
wx-dump-admin/src/main/java/com/xcs/wx/domain/vo/WeChatConfigVO.java
Unescape View File

@ -1,98 +0,0 @@
package com.xcs.wx.domain.vo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.RequiredArgsConstructor;
/**
* WeChatConfigVO类是一个值对象（Value Object，VO），主要用于封装和传递与微信相关配置信息的数据结构，
* 在涉及微信客户端、相关应用对接微信功能或者对微信账号进行管理等业务场景中发挥作用，
* 它能够将微信不同维度的关键配置数据整合在一起，方便在系统的不同模块、不同层级之间进行统一的传递和处理，
* 确保微信配置信息的流转清晰、规范，便于后续基于这些配置进行相应的业务操作和功能实现，提高代码的可读性和可维护性。
* @author xcs
* &#064;date 2023年12月25日 09时38分
**/
@Data
// @Data注解由Lombok库提供，它会自动为这个类生成一系列实用的方法，具体如下：
// - 自动生成所有私有属性对应的getter方法，例如通过调用getPid()、getBaseAddress()等方法，外部代码可以方便地获取类中各个属性的值，
// 在需要访问微信配置的具体属性信息时，比如查看进程Id、基址等内容，这些getter方法能提供便捷的数据访问途径，便于后续业务逻辑使用这些数据。
// - 自动生成所有私有属性对应的setter方法，使得外部代码能够根据业务需求动态地修改对象的属性值，例如当微信账号发生变更，
// 可以通过调用setAccount(String newAccount)方法来更新account属性的值，从而保证对象的属性能够灵活地反映微信配置信息的实际变化情况，增强了属性的可操作性。
// - 生成toString方法，该方法能将WeChatConfigVO对象以一种直观、易于阅读的字符串形式展示出来，通常会包含类名以及各个属性的值，
// 在调试程序时，通过打印对象的toString结果，可以快速查看当前微信配置对象的具体状态，了解各个属性的取值情况，便于排查问题。
// - 生成hashCode方法，在将对象存储到基于哈希的集合（如HashMap、HashSet等）中时会用到这个方法，
// 它依据对象的属性值计算出一个唯一的哈希码，用于确定对象在哈希集合中的存储位置，方便在集合中快速查找和比较对象。
// - 生成equals方法，用于比较两个WeChatConfigVO对象是否在逻辑上相等，也就是判断它们的所有属性值是否都完全相同，
// 在涉及微信配置对象比较的业务逻辑中（如判断不同环境下微信配置是否一致等情况），该方法能准确地进行对象的相等性判断。
// 通过使用@Data注解，大大减少了手动编写这些常规方法的工作量，让代码更加简洁、易读且易于维护。
@RequiredArgsConstructor
// @RequiredArgsConstructor注解同样来自Lombok库，它会基于类中被声明为final的非空字段自动生成一个构造函数，
// 要求在创建对象实例时，必须传入这些被标记为必需的参数，以此保证对象在初始化时关键属性有值，增强了对象创建的规范性和数据完整性。
@AllArgsConstructor
// @AllArgsConstructor注解也由Lombok库提供，它会自动为这个类生成一个包含所有参数的构造函数，
// 即构造函数的形式为：public WeChatConfigVO(Integer pid, Long baseAddress, String version, String nickname, String account, String mobile, String basePath, String wxId) {...}，
// 这意味着在创建该类的对象实例时，只需要依次传入进程Id（pid）、基址（baseAddress）、版本号（version）、昵称（nickname）、账号（account）、
// 手机号（mobile）、文件目录（basePath）以及微信Id（wxId）这些参数，即可完成对象的初始化操作，这种方式提高了创建对象时传递微信配置数据的便利性和代码的可读性，
// 使代码在实例化该类对象时更加简洁明了，不过需要注意同时使用@RequiredArgsConstructor和@AllArgsConstructor时，要根据实际情况合理使用构造函数。
public class WeChatConfigVO {
/**
* 进程Id，使用整数（Integer）类型存储微信相关进程的唯一标识符，在操作系统中，每个运行的进程都有一个对应的Id，
//通过这个Id可以对微信进程进行管理、监控以及与其他进程进行交互等操作，例如判断微信进程是否正常运行、获取其资源占用情况等，
//是在涉及微信运行状态管理以及与系统层面交互时重要的基础属性之一。
*/
private Integer pid;
/**
* 基址，以长整数（Long）类型表示，在内存管理以及与微信程序底层交互等场景中有着重要意义，
//它通常指的是微信程序在内存中的起始地址，通过这个基址可以进一步定位和访问微信程序在内存中的其他数据结构、模块等，
//对于一些涉及微信内存数据读取、修改以及与底层代码交互的高级操作（比如插件开发、逆向分析等情况），基址是关键的参考信息之一。
*/
private Long baseAddress;
/**
* 版本号，以字符串（String）形式记录微信程序当前的版本标识信息，例如“8.0.1”这样的格式，
//版本号用于区分不同阶段发布的微信版本，方便进行版本管理、功能更新提示以及兼容性判断等操作，
//在涉及微信升级、不同版本间功能差异处理、与其他系统或插件的兼容性适配等业务场景中，版本号是重要的参考依据，
//确保系统能根据微信的版本情况准确地提供相应服务或进行相应的业务逻辑调整。
*/
private String version;
/**
* 昵称，同样是字符串类型，是用户在微信中对外展示的一个比较个性化、友好的称呼，用户可以自行设置和修改昵称，
//在微信的社交互动场景中，如聊天界面、好友列表展示等，昵称往往更能直观地让其他用户识别是谁，相比于账号等相对固定且较为正式的标识，
//昵称更具亲和力，是体现用户个性化以及方便用户之间交互识别的重要属性之一。
*/
private String nickname;
/**
* 账号，以字符串类型存储用户在微信中用于登录、认证等操作的主要标识信息，这个账号通常是用户注册时填写的手机号码、邮箱或者自定义的用户名等，
//是用户进入微信、获取相应服务的重要“钥匙”，在微信的用户登录、权限管理以及涉及用户身份验证的诸多业务逻辑中起着核心的标识作用。
*/
private String account;
/**
* 手机号，也是字符串类型，存储用户的手机号码信息，手机号在微信中不仅可作为登录账号的一种形式，
//还常用于身份验证（如接收验证码进行注册、登录、修改重要信息等操作）、消息通知（如接收微信推送的短信提醒）以及关联其他服务（如与手机号绑定的第三方账号授权等），
//是与用户联系紧密且具有多种重要用途的关键属性，在涉及微信用户安全验证、信息推送以及多平台账号整合等业务场景中有着重要地位。
*/
private String mobile;
/**
* 文件目录，以字符串类型存储与微信相关的文件所在的路径信息，这个路径可以是本地磁盘上微信安装目录下的特定文件夹路径，
//例如存储聊天记录文件、缓存文件、用户自定义配置文件等的文件夹所在位置，也可以是网络存储中与微信相关文件的特定路径（在一些特殊的企业级应用或者云服务场景下），
//它用于定位和管理与微信相关的各类文件，是涉及微信文件操作以及数据管理时的重要属性之一。
*/
private String basePath;
/**
* 微信Id，同样是字符串类型，用于唯一标识用户在微信生态系统中的身份，类似于一个独特的账号标识，
//通过这个Id可以在微信的服务器端、客户端等进行用户的精准定位、数据关联以及各种业务操作，
//在整合微信相关功能或者基于微信账号进行用户认证、信息同步等业务场景中，微信Id是关键的用户标识属性。
*/
private String wxId;
}

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save