diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/ChatRoomService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/ChatRoomService.java index 8414eed..b356b1c 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/ChatRoomService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/ChatRoomService.java @@ -7,6 +7,8 @@ import com.xcs.wx.domain.vo.PageVO; /** * 群聊服务 + * 该接口定义了一系列与群聊相关的操作方法，为业务逻辑层提供了统一的服务接口规范， + * 具体的实现类需要实现这些方法来完成相应的群聊功能，例如查询群聊、获取群聊详情以及导出群聊等操作。 * * @author xcs * @date 2023年12月31日18:18:58 @@ -15,24 +17,34 @@ public interface ChatRoomService { /** * 查询群聊 + * 根据传入的查询条件（ChatRoomDTO对象），从数据源（可能是数据库、缓存或者其他存储介质）中查询符合条件的群聊信息， + * 并以分页的形式返回查询结果，结果封装在PageVO对象中，其中ChatRoomVO用于表示单个群聊的相关视图信息， + * PageVO用于处理分页相关逻辑，包含了如总记录数、当前页数据等分页属性。 * - * @param chatRoomDTO 查询条件 - * @return ChatRoomVO + * @param chatRoomDTO 查询条件，该对象包含了各种用于筛选群聊的条件参数，例如群聊名称、创建时间范围、成员数量范围等， + * 根据具体业务需求来定义其内部的属性，通过传递该对象可以灵活地查询不同条件下的群聊信息。 + * @return ChatRoomVO，返回一个PageVO类型的对象，代表分页后的群聊信息列表，调用者可以通过该对象获取具体的群聊视图信息以及分页相关数据。 */ PageVO queryChatRoom(ChatRoomDTO chatRoomDTO); /** * 查询群聊详情 + * 根据传入的群聊名称（唯一标识一个群聊的关键信息，当然实际业务中也可能通过其他唯一标识来查询，这里以群聊名称为例）， + * 从数据源中获取对应的群聊的详细信息，这些详细信息可能包含群聊的创建者、成员列表、聊天记录统计等丰富内容， + * 并将这些详细信息封装在ChatRoomDetailVO对象中返回给调用者，方便调用者展示或者进一步处理群聊的详细情况。 * - * @param chatRoomName 群聊名称 - * @return ChatRoomDetailVO + * @param chatRoomName 群聊名称，用于定位要查询详情的具体群聊，是一个表示群聊名称的字符串，在业务场景中应保证其唯一性， + * @return ChatRoomDetailVO，返回一个ChatRoomDetailVO类型的对象，其内部包含了所查询群聊的详细信息，供调用者使用。 */ ChatRoomDetailVO queryChatRoomDetail(String chatRoomName); /** * 导出群聊 + * 执行将群聊相关信息导出的操作，具体导出的格式为excel（当然也可以根据业务需求扩展为其他格式）， + * 并返回导出的群聊excel文件在系统中的存储地址（文件路径），调用者可以通过该地址获取到导出的文件， + * 例如提供给用户下载或者进行其他后续处理操作。 * - * @return 群聊excel地址 + * @return 群聊excel地址，返回一个字符串类型的文件路径，指向存储导出的群聊excel文件的具体位置，方便后续进行相关操作。 */ String exportChatRoom(); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactHeadImgService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactHeadImgService.java index 64b7e0b..4d2c92f 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactHeadImgService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactHeadImgService.java @@ -2,6 +2,9 @@ package com.xcs.wx.service; /** * 联系人头像 + * 此接口用于定义与联系人头像相关的服务操作，它为具体的业务逻辑实现类提供了一个统一的规范， + * 表明需要实现获取联系人头像的功能，后续的实现类要按照这个接口定义来完成相应的业务逻辑处理， + * 例如从数据库、文件系统或者通过网络请求等方式获取指定联系人的头像数据。 * * @author xcs * @date 2023年12月31日18:18:58 @@ -10,9 +13,13 @@ public interface ContactHeadImgService { /** * 头像 + * 该方法的主要作用是根据传入的用户名（用于唯一标识一个联系人），从相应的数据源（比如存储用户头像的数据库表、文件存储位置等） + * 获取对应的联系人头像数据，并以字节数组的形式返回。字节数组形式便于后续进行如展示头像（在前端进行字节数据解析展示图像）、 + * 保存头像到本地等各种操作。 * - * @param userName 用户名 - * @return 头像字节 + * @param userName 用户名，是一个字符串类型的参数，用于明确要获取头像的具体联系人，在业务场景中， + * 每个用户名应该唯一对应一个联系人，这样才能准确获取到相应联系人的头像信息。 + * @return 头像字节，返回一个字节数组，数组中的字节数据构成了对应联系人头像的图像信息，调用者可以利用这些字节数据进行进一步处理。 */ byte[] avatar(String userName); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactLabelService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactLabelService.java index c8f4aea..bcae49e 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactLabelService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactLabelService.java @@ -1,11 +1,13 @@ package com.xcs.wx.service; import com.xcs.wx.domain.vo.ContactLabelVO; - import java.util.List; /** * 联系人表情服务 + * 该接口定义了与联系人标签相关的服务操作规范，旨在为具体的业务逻辑实现类提供统一的接口标准， + * 后续实现类需依照此接口定义来实现相应的功能，比如从数据库、缓存或者其他存储介质中获取联系人标签信息等操作， + * 以此为整个系统提供查询联系人标签相关的服务。 * * @author xcs * @date 2023年12月31日18:18:58 @@ -14,8 +16,12 @@ public interface ContactLabelService { /** * 查询联系人标签 + * 此方法用于从相关数据源（例如存储联系人标签信息的数据库表、配置文件等地方）中查询所有联系人的标签信息， + * 将查询到的多个联系人标签信息统一封装在ContactLabelVO对象中，然后以列表（List）的形式返回，方便调用者获取并处理这些标签数据， + * 例如可以用于在界面上展示联系人的标签分类情况、根据标签进行联系人筛选等操作。 * - * @return ContactLabel + * @return ContactLabel，返回一个List类型的列表，其中ContactLabelVO对象包含了单个联系人标签的详细信息， + * 如标签名称、标签描述、所属分组等（具体取决于业务中ContactLabelVO对象的定义属性），整个列表代表了所有查询到的联系人标签信息集合。 */ List queryContactLabel(); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactService.java index f47c01f..72388e0 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/ContactService.java @@ -5,11 +5,12 @@ import com.xcs.wx.domain.vo.AllContactVO; import com.xcs.wx.domain.vo.ContactLabelVO; import com.xcs.wx.domain.vo.ContactVO; import com.xcs.wx.domain.vo.PageVO; - import java.util.List; /** * 联系人服务 + * 该接口定义了一系列与联系人相关的操作服务，为业务逻辑层提供了统一的接口规范， + * 具体的实现类需要按照这些接口定义来实现相应功能，以满足系统中对联系人信息进行查询、导出等业务需求。 * * @author xcs * @date 2023年12月22日14:49:52 @@ -18,30 +19,43 @@ public interface ContactService { /** * 查询联系人 + * 根据传入的查询条件（ContactDTO对象），从对应的数据源（如数据库、缓存等存储介质）中查询符合条件的联系人信息， + * 并以分页的形式返回查询结果。返回结果封装在PageVO对象中，其中ContactVO用于表示单个联系人的相关视图信息， + * PageVO用于处理分页相关逻辑，包含了如总记录数、当前页数据等分页属性，方便调用者进行分页展示和数据处理。 * - * @param contactDTO 查询条件 - * @return ContactVO + * @param contactDTO 查询条件，该对象包含了各种用于筛选联系人的条件参数，例如联系人姓名、所属分组、添加时间范围等， + * 根据具体业务需求来定义其内部的属性，通过传递该对象可以灵活地查询不同条件下的联系人信息。 + * @return ContactVO，返回一个PageVO类型的对象，代表分页后的联系人信息列表，调用者可通过该对象获取具体的联系人视图信息以及分页相关数据。 */ PageVO queryContact(ContactDTO contactDTO); /** * 查询所有联系人 + * 此方法用于从数据源中获取所有联系人的信息，不进行任何筛选条件限制，将查询到的所有联系人信息分别封装在AllContactVO对象中， + * 然后以列表（List）的形式返回，方便调用者获取全部联系人数据，例如用于全量展示联系人列表或者进行整体数据统计等操作。 * - * @return AllContactVO + * @return AllContactVO，返回一个List类型的列表，其中AllContactVO对象包含了单个联系人的详细信息， + * 具体的详细信息内容取决于业务中AllContactVO对象的定义属性，整个列表代表了系统中所有联系人的信息集合。 */ List queryAllContact(); /** * 查询联系人标签 + * 从数据源（例如存储联系人标签信息的数据库表、配置文件等）中查询所有联系人的标签信息，将查询到的多个联系人标签信息统一封装在ContactLabelVO对象中， + * 然后以列表（List）的形式返回，便于调用者获取并处理这些标签数据，比如用于展示联系人的标签分类情况、根据标签进行联系人筛选等操作。 * - * @return ContactLabel + * @return ContactLabel，返回一个List类型的列表，其中ContactLabelVO对象包含了单个联系人标签的详细信息， + * 如标签名称、标签描述、所属分组等（具体取决于业务中ContactLabelVO对象的定义属性），整个列表代表了所有查询到的联系人标签信息集合。 */ List queryContactLabel(); /** * 导出联系人 + * 执行将联系人相关信息导出的操作，具体导出的格式为excel（当然也可根据业务需求扩展为其他格式）， + * 并返回导出的联系人excel文件在系统中的存储地址（文件路径），调用者可通过该地址获取到导出的文件， + * 例如提供给用户下载或者进行其他后续处理操作。 * - * @return 联系人excel地址 + * @return 联系人excel地址，返回一个字符串类型的文件路径，指向存储导出的联系人excel文件的具体位置，方便后续进行相关操作。 */ String exportContact(); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/DashboardService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/DashboardService.java index f6419fc..b56f685 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/DashboardService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/DashboardService.java @@ -6,6 +6,8 @@ import java.util.List; /** * 仪表台服务 + * 该接口定义了一系列与仪表台相关的数据查询和统计功能服务，旨在为业务逻辑层提供统一的接口规范， + * 方便具体的实现类按照这些规范去实现相应功能，进而为上层应用或前端展示提供所需的仪表台相关数据，例如统计面板数据、消息分布情况等。 * * @author xcs * @date 2024年1月23日17:24:36 @@ -14,36 +16,56 @@ public interface DashboardService { /** * 统计面板 + * 此方法用于获取仪表台的统计面板相关数据，这些数据通常是对系统内一些关键指标进行综合统计后的结果， + * 例如总的消息数量、联系人数量、群聊数量等各类汇总信息，将这些统计信息封装在StatsPanelVO对象中返回， + * 方便调用者获取并展示在对应的统计面板界面上，让用户能够直观地了解系统的整体概况。 * - * @return StatsPanelVO + * @return StatsPanelVO，返回一个StatsPanelVO类型的对象，其内部包含了各种统计面板相关的数据属性（具体取决于业务中StatsPanelVO对象的定义）， + * 调用者可以通过该对象获取相应的统计信息进行展示和后续处理。 */ StatsPanelVO statsPanel(); /** * 消息类型分布 + * 用于获取系统内消息类型的分布情况数据，比如文本消息、图片消息、语音消息等不同类型消息各自所占的比例或者数量等信息， + * 把这些关于消息类型分布的数据分别封装在MsgTypeDistributionVO对象中，然后以列表（List）的形式返回， + * 方便调用者对消息类型分布情况进行展示、分析或者基于此数据进行进一步的业务决策等操作。 * - * @return MsgTypeDistributionVO + * @return MsgTypeDistributionVO，返回一个List类型的列表，其中MsgTypeDistributionVO对象包含了单个消息类型相关的分布信息， + * 如消息类型名称、对应的数量或占比等（具体取决于业务中MsgTypeDistributionVO对象的定义属性），整个列表呈现了系统内消息类型的整体分布情况。 */ List msgTypeDistribution(); /** * 消息趋势 + * 主要负责获取系统内消息的趋势数据，例如近一段时间内（如近一周、近一个月等）消息数量的变化趋势情况， + * 把这些消息趋势相关的数据封装在CountRecentMsgsVO对象中，以列表（List）的形式返回，调用者可以利用这些数据来绘制消息趋势图表、 + * 分析消息量的增减变化规律等，便于对系统消息情况进行动态监测和分析。 * - * @return MsgTrendVO + * @return MsgTrendVO，返回一个List类型的列表，其中CountRecentMsgsVO对象包含了不同时间点对应的消息数量等趋势相关信息， + * 具体的信息内容根据业务需求而定，整个列表展示了消息数量随时间变化的趋势情况。 */ List countRecentMsgs(); /** * 消息排行 + * 该方法用于获取系统内消息相关的排行情况数据，例如按照联系人发送消息的数量进行排序，得到消息发送量最多的前几位联系人信息， + * 或者按照群聊的活跃程度（以消息数量衡量等方式）进行排行等，将这些排行相关的数据封装在TopContactsVO对象中，以列表（List）的形式返回， + * 方便调用者展示消息排行情况，例如在界面上展示消息最活跃的联系人榜单等操作。 * - * @return MsgTrendVO + * @return MsgTrendVO，返回一个List类型的列表，其中TopContactsVO对象包含了排行相关的具体信息， + * 如联系人名称、对应的消息数量、排名情况等（具体取决于业务中TopContactsVO对象的定义属性），整个列表呈现了系统内消息相关的排行情况。 */ List topContacts(); /** * 查询最近使用的关键字 + * 用于获取系统内用户最近使用过的关键字信息，这些关键字可能是在聊天过程中搜索、发送消息等场景下使用的关键词， + * 通过该方法可以收集并返回这些关键字，将它们封装在RecentUsedKeyWordVO对象中，以列表（List）的形式返回， + * 方便调用者进行展示或者基于关键字进行一些数据分析、功能优化等操作，例如根据热门关键字来推荐相关聊天内容等。 * - * @return 返回关键字 + * @return 返回关键字，返回一个List类型的列表，其中RecentUsedKeyWordVO对象包含了单个关键字相关的信息， + * 如关键字内容、使用频率、最后使用时间等（具体取决于业务中RecentUsedKeyWordVO对象的定义属性），整个列表呈现了系统内最近使用的关键字情况。 */ List queryRecentUsedKeyWord(); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/DatabaseService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/DatabaseService.java index 0ce9bfe..f3220dd 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/DatabaseService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/DatabaseService.java @@ -8,6 +8,9 @@ import java.util.List; /** * 注册数据源 + * 该接口主要定义了与数据源相关的操作服务，涉及数据库解密以及获取数据库列表等功能， + * 为具体的业务逻辑实现类提供统一的接口规范，以满足系统在处理数据源相关业务时的需求， + * 例如对加密的数据库进行解密操作、获取指定微信账号（wxId）对应的数据库信息等。 * * @author xcs * @date 2023年12月25日19:28:37 @@ -16,17 +19,27 @@ public interface DatabaseService { /** * 数据库解密 + * 此方法用于对数据库进行解密操作。它接收一个SseEmitter对象和一个DecryptDTO对象作为参数， + * SseEmitter对象是Spring框架中用于服务器推送事件（Server-Sent Events，简称SSE）的机制相关对象， + * 在这里可用于向客户端发送解密过程中的相关事件信息，比如解密进度、解密状态等，使得客户端能够实时了解解密情况。 + * 而DecryptDTO对象则包含了进行数据库解密所需的具体信息，例如加密密钥、数据库标识等（具体取决于业务中DecryptDTO对象的定义）， + * 通过这些信息来执行相应的数据库解密逻辑。 * - * @param emitter sse发送事件对象 - * @param decryptDTO 解密信息 + * @param emitter sse发送事件对象，用于实现服务器向客户端推送解密相关事件信息，方便客户端实时知晓解密进度和状态等情况。 + * @param decryptDTO 解密信息，包含了解密数据库所需要的各项具体参数，是进行数据库解密操作的关键依据。 */ void decrypt(SseEmitter emitter, DecryptDTO decryptDTO); /** * 获取数据库列表 + * 该方法的功能是根据传入的微信账号标识（wxId），从相应的数据源（可能是配置文件、数据库存储等地方）中查询获取对应的数据库信息列表， + * 并将每个数据库的相关信息封装在DatabaseVO对象中，最后以列表（List）的形式返回。返回的列表包含了该微信账号下所有相关数据库的详细信息， + * 例如数据库名称、数据库版本、数据库存储路径等（具体取决于业务中DatabaseVO对象的定义属性），方便调用者获取并处理这些数据库相关数据， + * 比如展示给用户查看或者在其他业务逻辑中进一步使用这些数据库信息。 * - * @param wxId wxId - * @return DatabaseVO + * @param wxId wxId，用于唯一标识一个微信账号，通过该标识来定位和获取与之对应的数据库列表信息，确保获取到正确的数据库集合。 + * @return DatabaseVO，返回一个List类型的列表，其中每个DatabaseVO对象代表一个数据库的详细信息， + * 整个列表呈现了指定微信账号下的所有数据库情况。 */ List getDatabase(String wxId); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/DecryptService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/DecryptService.java index 921e596..8e25052 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/DecryptService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/DecryptService.java @@ -4,6 +4,8 @@ import com.xcs.wx.domain.bo.DecryptBO; /** * 解密服务 + * 该接口主要定义了针对特定内容进行解密操作的服务规范，旨在为具体的业务逻辑实现类提供统一的接口标准， + * 以便实现与解密相关的功能，比如根据给定的密钥对特定的输入文件等内容进行解密处理，满足系统在数据安全方面涉及解密的业务需求。 * * @author xcs * @date 2023年12月10日19:27:01 @@ -12,9 +14,10 @@ public interface DecryptService { /** * 解密 - * - * @param password 秘钥 - * @param decryptBO 输入文件 + * 此方法用于执行解密操作，它接收两个关键参数，一个是表示密钥的字符串 `password`，另一个是 `DecryptBO` 类型的对象 `decryptBO`。 + * `password` 参数作为解密的关键要素，相当于打开加密内容的“钥匙”，其具体格式和要求取决于所采用的加密解密算法以及业务规则设定， + * @param password 秘钥，是用于解密操作的关键字符串，其取值需符合对应加密算法要求的格式和规则，用于解开加密内容。 + * @param decryptBO 输入文件，实际上是一个包含了待解密内容相关关键信息的对象，为解密操作提供具体的操作对象和相关必要数据，例如文件相关的属性等情况。 */ void wechatDecrypt(String password, DecryptBO decryptBO); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/FeedsService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/FeedsService.java index 3bb33ba..7f27825 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/FeedsService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/FeedsService.java @@ -6,6 +6,8 @@ import com.xcs.wx.domain.vo.PageVO; /** * 朋友圈服务 + * 该接口定义了与朋友圈相关的操作服务，为业务逻辑层提供了统一的接口规范，具体的实现类需要按照此规范实现相应功能， + * 旨在满足系统中对朋友圈信息进行查询等业务需求，例如按照一定的分页规则查询朋友圈动态内容等操作。 * * @author xcs * @date 2024年1月3日17:25:26 @@ -14,9 +16,13 @@ public interface FeedsService { /** * 查询朋友圈 + * 依据传入的FeedsDTO对象（该对象包含了分页相关的参数，例如页码、每页显示的记录数等，也可能包含一些用于筛选朋友圈内容的其他条件参数， + * 具体取决于业务中对FeedsDTO对象的定义），从对应的数据源（如数据库、缓存等存储朋友圈数据的地方）中查询符合条件的朋友圈信息， + * 并以分页的形式返回查询结果。返回的结果会封装在PageVO对象中，其中FeedsVO用于表示单条朋友圈动态的相关视图信息， + * 比如朋友圈内容、发布者信息、发布时间等，PageVO则用于处理分页相关的逻辑，包含了如总记录数、当前页数据等分页属性，方便调用者进行分页展示和数据处理。 * - * @param feedsDTO 分页参数 - * @return FeedsVO + * @param feedsDTO 分页参数，是一个包含了各种用于查询朋友圈信息的条件参数的对象，重点包含分页相关设置，通过它可以灵活地指定查询的范围和筛选条件。 + * @return FeedsVO，返回一个PageVO类型的对象，代表分页后的朋友圈信息列表，调用者可以通过该对象获取具体的朋友圈动态视图信息以及分页相关数据。 */ PageVO queryFeeds(FeedsDTO feedsDTO); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/ImageService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/ImageService.java index 6d13906..a477dd1 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/ImageService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/ImageService.java @@ -5,6 +5,8 @@ import org.springframework.http.ResponseEntity; /** * 图片服务 + * 该接口定义了一系列与图片相关的下载操作服务，为业务逻辑层提供统一的接口规范，方便具体的实现类按照这些规范去实现相应功能， + * 以满足系统在获取图片资源时的不同需求，例如通过图片的MD5值、网络地址或者本地路径来下载对应的图片资源等操作。 * * @author xcs * @date 2024年1月18日22:06:46 @@ -13,25 +15,36 @@ public interface ImageService { /** * 通过Md5来下载图片 + * 此方法的功能是依据传入的图片的MD5值（md5参数），从相应的数据源（可能是图片存储服务器、缓存等地方，这些地方以MD5值作为图片的唯一标识来进行管理和检索） + * 查找并下载对应的图片资源。它返回一个ResponseEntity类型的对象，ResponseEntity用于封装整个HTTP响应的相关信息， + * 包括响应状态码、响应头以及响应体等，在这里可以通过它来向调用者返回下载图片操作的执行结果，例如是否成功下载、返回的图片资源情况等； + * Resource则代表实际的图片资源内容，其内部可以是对图片文件的各种抽象表示，方便后续进行如展示图片、保存图片到本地等进一步操作。 * - * @param md5 md5 - * @return ResponseEntity + * @param md5 md5，是一个字符串类型的参数，代表图片的MD5值，它在系统中作为图片的唯一标识，用于准确地定位并获取对应的图片资源，确保下载到正确的图片。 + * @return ResponseEntity，返回一个ResponseEntity类型的对象，通过该对象可以获取下载图片操作对应的HTTP响应信息以及实际的图片资源， + * 调用者可以根据响应状态码判断下载是否成功，并从Resource中获取图片内容进行后续处理。 */ ResponseEntity downloadImgMd5(String md5); /** * 下载图片 + * 根据传入的图片地址（path参数，通常是一个网络地址，比如URL形式的网络图片链接，指向图片在网络上的存储位置）， + * 从该地址对应的位置下载图片资源。同样返回一个ResponseEntity对象，用于告知调用者下载操作的结果以及返回对应的图片资源， + * 方便调用者进行后续处理，例如在网页端展示图片或者将图片保存到本地等操作。 * - * @param path 图片地址 - * @return ResponseEntity + * @param path 图片地址，是一个字符串类型的参数，代表图片在网络上的存储位置链接，通过这个地址去获取对应的图片资源并下载下来。 + * @return ResponseEntity，返回一个ResponseEntity类型的对象，用于传递下载图片的结果和对应的图片资源，调用者据此进行后续操作。 */ ResponseEntity downloadImg(String path); /** * 下载图片 + * 按照传入的本地路径（localPath参数，即图片在本地文件系统中的存储路径，例如 "C:/images/myPic.jpg" 这样的形式）， + * 从本地磁盘相应位置读取并获取图片资源，将其封装在ResponseEntity对象中返回，调用者可以通过该对象获取到本地图片资源， + * 用于在本地应用程序中展示、编辑或者进行其他相关操作。 * - * @param localPath 图片地址 - * @return ResponseEntity + * @param localPath 图片地址，是一个字符串类型的参数，指明图片在本地文件系统中的具体存储位置，以便准确地读取并获取对应的图片资源进行下载操作。 + * @return ResponseEntity，返回一个ResponseEntity类型的对象，用于返回从本地获取的图片资源以及对应的下载操作结果信息，方便后续使用。 */ ResponseEntity downloadImgFormLocal(String localPath); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/MsgService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/MsgService.java index f28390b..5def1a9 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/MsgService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/MsgService.java @@ -6,6 +6,8 @@ import java.util.List; /** * 消息服务 + * 该接口定义了与消息相关的操作服务，为业务逻辑层提供统一的接口规范，方便具体的实现类依据这些规范实现相应功能， + * 以此来满足系统中对消息查询、聊天记录导出等业务需求，例如获取指定聊天人的消息列表以及将和某聊天人的聊天记录导出为文件等操作。 * * @author xcs * @date 2023年12月25日15:05:09 @@ -14,18 +16,24 @@ public interface MsgService { /** * 查询消息 + * 此方法用于从对应的数据源（如数据库、缓存或者存储消息的其他介质）中，根据传入的参数查询符合条件的消息信息。 + * 将查询到的消息信息分别封装在 `MsgVO` 对象中，最后以列表（List）的形式返回，方便调用者获取并处理这些消息数据，例如在界面上展示聊天消息内容等操作。 * - * @param talker 聊天人的Id - * @param nextSequence 下一个序列号 - * @return MsgVO + * @param talker 聊天人的Id，是一个字符串类型的参数（具体类型也可能根据业务实际情况确定，这里假设为字符串便于唯一标识聊天对象），用于明确消息所属的聊天对象， + * 以此来筛选出对应的消息内容。 + * @param nextSequence 下一个序列号，通常为长整型（Long）数据，用于控制消息查询的起始位置或者顺序，辅助实现如分页查询、顺序获取等功能，按照业务规则来定位要查询的消息范围。 + * @return MsgVO，返回一个List类型的列表，其中 `MsgVO` 对象包含了单条消息的详细信息，如消息内容、发送时间、消息类型等（具体取决于业务中 `MsgVO` 对象的定义属性）， + * 整个列表呈现了符合查询条件的所有消息情况。 */ List queryMsg(String talker, Long nextSequence); /** * 导出聊天记录 + * 根据传入的聊天人的Id（`talker` 参数），将与该聊天对象的聊天记录进行导出操作，具体导出的格式可能是文本文件、Excel文件或者其他适合记录聊天内容的格式（取决于业务实现）， + * 并返回导出的聊天记录文件在系统中的存储地址（文件路径），调用者可以通过该地址获取到导出的文件，例如提供给用户下载或者进行其他后续处理操作。 * - * @param talker 聊天人的Id - * @return 文件地址 + * @param talker 聊天人的Id，用于唯一标识要导出聊天记录的具体聊天对象，确保准确地获取和导出与之相关的所有聊天记录信息。 + * @return 文件地址，返回一个字符串类型的文件路径，指向存储导出的聊天记录文件的具体位置，方便后续进行相关操作，如展示给用户下载链接等。 */ String exportMsg(String talker); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/RecoverContactService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/RecoverContactService.java index 76f63ce..aef66d2 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/RecoverContactService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/RecoverContactService.java @@ -2,11 +2,12 @@ package com.xcs.wx.service; import com.xcs.wx.domain.dto.RecoverContactDTO; import com.xcs.wx.domain.vo.RecoverContactVO; - import java.util.List; /** * 找回联系人服务 + * 该接口定义了与找回联系人相关的操作服务，为业务逻辑层提供统一的接口规范，具体的实现类需要按照这些规范来实现相应功能， + * 以满足系统中对找回已删除联系人以及相关数据处理的业务需求，例如查询可找回的联系人信息、导出已找回联系人相关数据等操作。 * * @author xcs * @date 2024年6月14日15:28:11 @@ -15,15 +16,21 @@ public interface RecoverContactService { /** * 找回好友 - * - * @return RecoverContactVO + * 根据传入的RecoverContactDTO对象（该对象包含了用于筛选和查找可找回好友的相关条件参数，例如好友删除时间范围、曾经的好友备注信息等， + * 具体取决于业务中RecoverContactDTO对象的定义），从对应的数据源（如数据库备份、缓存或者其他存储有联系人历史记录的地方）中查询符合条件的可找回好友信息， + * 将查询到的每个可找回好友的相关信息分别封装在RecoverContactVO对象中，最后以列表（List）的形式返回，方便调用者获取并处理这些可找回好友的数据， + * @return RecoverContactVO，返回一个List类型的列表，其中RecoverContactVO对象包含了单个可找回好友的详细信息， + * 如好友昵称、微信号、曾经的聊天记录概况等（具体取决于业务中RecoverContactVO对象的定义属性），整个列表呈现了所有符合条件的可找回好友情况。 */ List queryRecoverContact(RecoverContactDTO recoverContactDTO); /** * 删除已删除的好友 + * 执行将已找回的联系人（可能是之前误删除或者其他原因删除的好友）再次进行删除的操作，具体的删除逻辑可能涉及从数据库中移除相关记录、 + * 更新缓存等步骤（由具体实现类来完成这些具体操作细节），并返回一个地址（文件地址或者其他相关的标识地址，具体取决于业务实现方式）， + * 这个地址可能用于记录此次删除操作的相关日志文件存储位置、备份文件地址等，方便后续进行查看、审计等操作，例如可以查看删除了哪些已找回的好友等情况。 * - * @return 地址 + * @return 地址，返回一个字符串类型的地址，其具体含义和用途根据业务中对该操作的设计而定，一般是与此次删除已找回好友操作相关的文件或记录的存储位置等信息。 */ String exportRecoverContact(); } diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/SessionService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/SessionService.java index 60c188d..215685f 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/SessionService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/SessionService.java @@ -5,7 +5,8 @@ import com.xcs.wx.domain.vo.SessionVO; import java.util.List; /** - * 会话服务 + * 会话服务接口，定义了与会话相关的业务操作方法的规范，通常在面向接口编程的架构中， + * 具体的实现类会实现该接口并提供对应方法的实际逻辑，以此实现业务逻辑与调用方的解耦，方便进行不同实现方式的切换以及代码的可维护性和扩展性提升。 * * @author xcs * @date 2023年12月21日 17时16分 @@ -13,9 +14,12 @@ import java.util.List; public interface SessionService { /** - * 查询会话 + * 查询会话的方法，该方法用于获取会话相关信息，返回一个包含 `SessionVO` 类型对象的列表， + * 每个 `SessionVO` 对象应该封装了具体会话的详细信息（例如会话的参与方、会话的最后消息时间、未读消息数量等相关属性，具体取决于 `SessionVO` 类的定义）， + * 供调用方进行展示、进一步处理或者与其他业务逻辑整合等操作。 * - * @return SessionVO + * @return List 返回一个列表，列表中的元素为 `SessionVO` 类型的对象，代表了查询到的各个会话的信息， + * 如果没有查询到任何会话，则返回一个空列表，调用方需要根据返回结果进行相应的判断和后续处理。 */ List querySession(); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/UserService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/UserService.java index 4525b8b..ac936a4 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/UserService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/UserService.java @@ -7,7 +7,9 @@ import com.xcs.wx.domain.vo.UserVO; import java.util.List; /** - * 用户服务 + * 用户服务接口，用于定义与用户相关的各类业务操作方法的规范。 + * 在分层架构中，该接口作为用户服务层对外提供的统一接口，具体的实现类会实现这些方法来完成实际的业务逻辑处理， + * 这样使得不同层次之间实现解耦，方便业务逻辑的替换、扩展以及代码的维护等操作。 * * @author xcs * @date 2023年12月21日 17时16分 @@ -15,58 +17,88 @@ import java.util.List; public interface UserService { /** - * 用户信息 + * 获取用户信息的方法。 + * 该方法用于获取当前用户（具体取决于业务逻辑中如何定义“当前用户”，可能是登录状态下的某个用户等情况）的详细信息， + * 返回的 `UserInfoVO` 对象应该封装了诸如用户的基本资料（如性别、年龄等基础信息）、权限信息、扩展信息等相关内容（具体取决于 `UserInfoVO` 类的定义）， + * 供调用方进行展示、进一步分析或者与其他业务逻辑结合使用等操作。 * - * @return 用户信息 + * @return UserInfoVO 返回一个 `UserInfoVO` 类型的对象，代表了当前用户的详细信息，如果出现异常情况（比如获取信息失败等）， + * 则具体的实现类需要按照相应的异常处理机制进行处理，调用方需要根据业务场景判断如何应对可能出现的异常返回情况。 */ UserInfoVO userInfo(); /** - * 用户头像 + * 获取用户头像的方法。 + * 用于获取当前用户的头像信息，返回的字符串通常应该是头像图片的存储路径（可以是本地文件路径或者网络路径等形式，具体取决于业务中头像的存储和引用方式）， + * 或者是头像图片以某种编码格式（如Base64编码等）表示的字符串内容，以便调用方能够根据返回的信息展示用户头像，例如在界面上进行显示等操作。 * - * @return 头像 + * @return 头像，以字符串形式返回，代表用户头像相关的信息，如果获取头像过程中出现问题（如头像不存在、权限不足等情况）， + * 实现类需要进行相应的异常处理，返回的内容应符合调用方预期的表示头像信息的格式，调用方根据返回结果进行展示等后续操作。 */ String avatar(); /** - * 用户昵称 + * 获取用户昵称的方法。 + * 其功能是获取当前用户的昵称信息，返回的字符串即为用户在系统中显示的昵称内容， + * 调用方可以将获取到的昵称用于界面展示、消息发送时的显示等与用户标识相关的各种业务场景中。 * - * @return 头像 + * @return 头像，此处方法名虽然为 `nickname`，但返回注释写的“头像”可能是笔误，正确的应该是返回当前用户的昵称信息，以字符串形式返回， + * 如果出现获取昵称失败等异常情况，由具体的实现类进行相应处理，调用方根据返回的字符串（正常情况下为有效的昵称内容）进行后续使用。 */ String nickname(); /** - * 所有用户 + * 获取所有用户信息的方法。 + * 该方法旨在获取系统中所有用户（同样具体范围取决于业务定义，可能是某个应用内的所有注册用户等情况）的相关信息， + * 返回一个包含 `UserVO` 类型对象的列表，每个 `UserVO` 对象封装了单个用户的关键信息（比如用户ID、用户名、用户状态等，具体由 `UserVO` 类的定义决定）， + * 调用方可以利用这个列表进行遍历展示、统计用户数量、筛选特定用户等各种与用户集合相关的操作。 * - * @return wxIds + * @return List 返回一个列表，列表中的元素为 `UserVO` 类型的对象，代表了系统中各个用户的信息，如果没有任何用户（比如系统刚初始化还没有用户注册等情况）， + * 则返回一个空列表，调用方需要根据返回的列表情况进行相应的后续判断和处理，例如判断列表是否为空来决定是否进行用户信息展示等操作。 */ List users(); /** - * 切换用户 + * 切换用户的方法。 + * 用于在多用户场景下（例如一个应用支持多个账号登录切换等情况），将当前操作的用户切换为指定的用户， + * 通过传入要切换到的用户的唯一标识（`wxId`）来确定具体要切换的目标用户，具体的切换逻辑（如更新当前用户上下文、保存当前用户状态等操作）由实现类来完成， + * 调用方只需传入正确的 `wxId` 参数即可发起切换用户的请求，方法无返回值，重点在于执行切换操作本身。 * - * @param wxId wxId + * @param wxId wxId，以字符串形式传入，代表要切换到的目标用户的唯一标识，该标识在系统中应该能够唯一确定一个用户， + * 实现类根据这个传入的 `wxId` 来查找并执行相应的用户切换操作，若传入的 `wxId` 不符合要求（比如不存在对应的用户等情况）， + * 则实现类需要进行相应的错误处理，例如抛出异常提示调用方传入的参数有误等情况。 */ void switchUser(String wxId); /** - * 当前用户 + * 获取当前用户标识的方法。 + * 用于返回当前正在操作或者处于活跃状态的用户的唯一标识（通常以 `wxId` 表示），这个标识可以用于在系统中区分不同用户、进行用户相关数据的关联等操作， + * 返回的字符串即为当前用户的 `wxId`，调用方可以根据这个返回值确定当前操作的用户是谁，进而进行后续与该用户相关的业务操作。 * - * @return wxId + * @return wxId，以字符串形式返回，代表当前用户的唯一标识，若出现无法确定当前用户（比如系统出现异常导致用户上下文丢失等情况）， + * 则实现类需要按照相应的异常处理机制进行处理，调用方根据返回的字符串（正常情况下为有效的用户标识）进行后续使用。 */ String currentUser(); /** - * 保存用户 + * 保存用户信息的方法。 + * 用于将传入的用户相关信息（封装在 `UserBO` 对象中）保存到系统中，例如可以是新增用户时保存用户注册信息，或者修改用户信息后进行更新保存等操作， + * 具体的保存逻辑（如数据持久化到数据库、更新缓存中的用户信息等操作）由实现类根据业务需求和技术架构来完成， + * 传入的 `UserBO` 对象包含了要保存的用户详细信息（具体包含哪些属性由 `UserBO` 类的定义决定），方法无返回值，重点在于执行保存用户信息的操作本身。 * - * @param userBO 用户信息 + * @param userBO 用户信息，以 `UserBO` 类型的对象传入，该对象封装了要保存的用户的各类详细信息，实现类根据这个对象中的内容进行相应的保存操作， + * 若传入的 `UserBO` 对象不符合要求（比如缺少必要的关键信息等情况），则实现类需要进行相应的错误处理，例如抛出异常提示调用方传入的参数有误等情况。 */ void saveUser(UserBO userBO); /** - * 获取微信存储路径 + * 获取微信存储路径的方法。 + * 根据传入的用户唯一标识（`wxId`）获取对应的微信相关文件（比如聊天记录文件、用户配置文件等，具体取决于业务中微信文件存储的相关定义）在系统中的存储路径， + * 返回的字符串即为该用户对应的微信存储路径，调用方可以利用这个路径去访问、操作相关的微信文件（前提是具有相应的权限），例如读取聊天记录等操作。 * - * @param wxId wxId + * @param wxId wxId，以字符串形式传入，代表用户的唯一标识，通过这个标识来查找并确定对应的微信存储路径， + * 若传入的 `wxId` 对应的用户不存在或者没有配置微信存储路径等情况，实现类需要进行相应的错误处理， + * 例如返回空字符串或者抛出异常提示调用方无法获取对应的存储路径等情况，具体处理方式根据业务要求而定。 */ String getBasePath(String wxId); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/WeChatService.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/WeChatService.java index 85831c0..b23eb0c 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/WeChatService.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/WeChatService.java @@ -5,7 +5,9 @@ import com.xcs.wx.domain.vo.WeChatConfigVO; import java.util.List; /** - * 微信服务 + * 微信服务接口，定义了一系列与微信相关的操作方法规范，旨在为外部调用者提供统一的接口来获取微信相关的各类信息、 + * 进行微信进程相关操作以及读取微信进程内存中的数据等，不同的实现类可以根据具体的业务逻辑和底层实现技术来实现这些方法， + * 以此实现微信服务功能与其他业务模块的解耦，方便代码的维护、扩展以及在不同场景下的复用。 * * @author xcs * @date 2023年12月25日09:37:30 @@ -13,58 +15,87 @@ import java.util.List; public interface WeChatService { /** - * 获取微信配置信息 + * 获取微信配置信息的方法。 + * 该方法用于获取微信应用相关的配置信息，返回一个包含 `WeChatConfigVO` 类型对象的列表， + * 每个 `WeChatConfigVO` 对象应该封装了微信配置的具体内容（例如微信的网络配置、消息提醒配置、界面显示配置等相关属性，具体取决于 `WeChatConfigVO` 类的定义）， + * 调用方可以利用这些配置信息进行展示、根据配置进行相应的业务逻辑调整或者与其他模块协同工作等操作。 * - * @return WeChatDTO + * @return List 返回一个列表，列表中的元素为 `WeChatConfigVO` 类型的对象，代表了获取到的微信各项配置信息， + * 如果没有获取到任何配置信息（比如配置文件不存在、读取权限不足等情况），则返回一个空列表，调用方需要根据返回结果进行相应的判断和后续处理。 */ List readWeChatConfig(); /** - * 获取当前运行的微信进程的进程 ID。 - * - * @return 微信进程的进程 ID。如果未找到，返回空集合。 + * 获取当前运行的微信进程的进程 ID的方法。 + * 其功能是查找并返回当前正在运行的微信进程的唯一标识符（进程 ID），返回的是一个包含整数的列表， + + * @return 微信进程的进程 ID。如果未找到，返回空集合，以 `List` 形式返回，列表中的元素为微信进程的进程 ID， + * 若出现获取进程 ID 失败等异常情况（比如系统权限不足导致无法枚举进程等），实现类需要按照相应的异常处理机制进行处理， + * 调用方根据返回的列表情况进行后续使用（如遍历列表获取每个进程 ID 去做进一步操作等）。 */ List wechatPid(); /** - * 根据提供的进程 ID 找到相应进程的模块基地址。 + * 根据提供的进程 ID 找到相应进程的模块基地址的方法。 + * 此方法依据传入的微信进程的唯一标识符（进程 ID），在系统中查找该进程对应的模块（例如微信相关的动态链接库等模块）在内存中的基地址， + * 基地址是模块在进程内存空间中的起始位置，后续可以基于这个基地址结合偏移量等信息去准确访问模块内存储的各种微信相关数据（如账号信息、聊天记录等在内存中的具体位置）， + * 如果找不到对应的模块基地址（比如进程不存在、模块加载异常等情况），则返回0，调用方可以根据返回值判断是否成功获取基地址，并进行后续相应的操作。 * - * @param pid 目标进程的 ID。 - * @return 进程的模块基地址，如果找不到则返回 0。 + * @param pid 目标进程的 ID，以整数形式传入，用于唯一标识要查找模块基地址的微信进程，实现类根据这个传入的进程 ID 在系统中定位到对应的进程及其相关模块信息， + * 若传入的 `pid` 不符合要求（比如不存在对应的进程等情况），则实现类需要进行相应的错误处理，例如抛出异常提示调用方传入的参数有误等情况。 + * @return 进程的模块基地址，如果找不到则返回 0，返回的长整型数值代表了微信相关模块在进程内存空间中的起始地址， + * 供调用方后续结合其他信息（如偏移量等）进一步操作使用，若出现查找基地址失败等异常情况，按照上述说明返回相应的值并由实现类进行异常处理。 */ long baseAddress(int pid); /** - * 获取指定进程ID的可执行文件版本。 - * - * @param pid 进程ID。 - * @return 文件的版本号，如果无法获取，则返回 null。 + * 获取指定进程ID的可执行文件版本的方法。 + * 用于获取指定微信进程对应的可执行文件（比如微信客户端的主执行文件）的版本号信息，返回的字符串即为版本号内容（例如 "8.0.1" 这样的格式，具体格式取决于微信版本号的定义方式）， + * @param pid 进程ID，以整数形式传入，用于唯一标识要获取可执行文件版本的微信进程，实现类根据这个传入的进程 ID 定位到对应的微信可执行文件并尝试读取其版本号， + * 若传入的 `pid` 不符合要求（比如不存在对应的进程等情况），则实现类需要进行相应的错误处理，例如抛出异常提示调用方传入的参数有误等情况。 + * @return 文件的版本号，如果无法获取，则返回 null，以字符串形式返回版本号信息，若出现获取版本号失败等异常情况，按照上述说明返回相应的值并由实现类进行异常处理， + * 调用方根据返回的字符串（正常情况下为有效的版本号内容，若为 `null` 则表示获取失败）进行后续使用（如版本比较等操作）。 */ String getVersion(int pid); /** - * 根据进程ID获取微信ID。 + * 根据进程ID获取微信ID的方法。 + * 通过传入的微信进程的唯一标识符（进程 ID），获取对应的微信账号在系统中的唯一标识（微信ID），返回的字符串即为该微信账号的标识内容， + * 这个微信ID可以用于区分不同的微信账号，在涉及多账号相关的业务场景（如账号切换、消息推送定向到特定账号等操作）中发挥作用， + * 调用方根据返回的微信ID进行后续与特定微信账号相关的业务操作。 * - * @param pid 目标进程ID - * @return 微信ID + * @param pid 目标进程ID，以整数形式传入，用于唯一标识要获取微信ID的微信进程，实现类根据这个传入的进程 ID 查找并确定对应的微信账号的标识信息， + * 若传入的 `pid` 不符合要求（比如不存在对应的进程等情况），则实现类需要进行相应的错误处理，例如抛出异常提示调用方传入的参数有误等情况。 + * @return 微信ID，以字符串形式返回，代表对应微信进程的微信账号的唯一标识，若出现获取微信ID失败等异常情况，实现类需要按照相应的异常处理机制进行处理， + * 调用方根据返回的字符串（正常情况下为有效的微信ID内容）进行后续使用（如账号关联操作等）。 */ String getWxId(int pid); /** - * 从指定进程的指定内存地址读取信息。 + * 从指定进程的指定内存地址读取信息的方法。 + * 该方法尝试从给定的微信进程（通过进程 ID 标识）的特定内存地址中读取数据，返回的字符串即为从该内存地址读取到的信息内容（例如可能是微信聊天记录中的一条消息、用户昵称等信息）， + * 如果读取操作失败（比如内存访问权限不足、指定内存地址无效等情况），则返回 `null`，调用方根据返回值判断是否成功读取信息并进行后续相应的处理（如展示读取到的内容或者处理读取失败的情况等）。 * - * @param pid 目标进程的 ID。 - * @param address 要读取的内存地址。 - * @return 读取到的数据，如果失败则返回 null。 + * @param pid 目标进程的 ID，以整数形式传入，用于唯一标识要从中读取内存信息的微信进程，实现类根据这个传入的进程 ID 在系统中定位到对应的进程，并基于此进行内存读取操作， + * 若传入的 `pid` 不符合要求（比如不存在对应的进程等情况），则实现类需要进行相应的错误处理，例如抛出异常提示调用方传入的参数有误等情况。 + * @param address 要读取的内存地址，以长整型形式传入，代表在目标进程内存空间中要读取数据的具体位置，实现类根据这个传入的地址在对应的微信进程内存中进行读取操作， + * 若传入的 `address` 不符合要求（比如地址超出进程内存范围等情况），则实现类需要进行相应的错误处理，例如抛出异常提示调用方传入的参数有误等情况。 + * @return 读取到的数据，如果失败则返回 null，以字符串形式返回从指定内存地址读取到的信息内容，若出现读取信息失败等异常情况，按照上述说明返回相应的值并由实现类进行异常处理， + * 调用方根据返回的字符串（正常情况下为有效的信息内容，若为 `null` 则表示读取失败）进行后续使用（如展示读取到的内容等操作）。 */ String getInfo(int pid, long address); /** - * 获取指定进程和数据库路径下的密钥 + * 获取指定进程和数据库路径下的密钥的方法。 + * 其目的是在给定的微信进程（通过进程 ID 标识）以及对应的数据库路径下，查找并获取特定的密钥信息，返回的字符串即为找到的密钥内容， + * 这个密钥可能用于后续对微信数据库（例如聊天记录数据库、用户配置数据库等）进行解密、访问控制等相关操作， + * 如果未找到符合要求的密钥（比如数据库不存在、密钥匹配失败等情况），则返回 `null`，调用方根据返回值判断是否获取到密钥并进行后续相应的处理（如使用密钥进行解密操作或者处理获取失败的情况等）。 * - * @param pid 目标进程的进程ID - * @param dbPath 数据库路径 - * @return 返回找到的密钥，如果未找到则返回null + * @param pid 目标进程的进程ID，以整数形式传入，用于唯一标识要获取密钥的微信进程，实现类根据这个传入的进程 ID 定位到对应的进程，并结合传入的数据库路径进行密钥查找操作， + * @param dbPath 数据库路径，以字符串形式传入，指定了期望获取密钥所对应的数据库所在的文件路径，实现类根据这个路径找到对应的数据库并在相关的进程内存等范围内查找密钥， + * 若传入的 `dbPath` 不符合要求（比如路径不存在、格式错误等情况），则实现类需要进行相应的错误处理，例如抛出异常提示调用方传入的参数有误等情况。 + * @return 返回找到的密钥，如果未找到则返回null，以字符串形式返回找到的密钥内容，若出现获取密钥失败等异常情况，按照上述说明返回相应的值并由实现类进行异常处理， + * 调用方根据返回的字符串（正常情况下为有效的密钥内容，若为 `null` 则表示获取失败）进行后续使用（如使用密钥解密数据库等操作）。 */ String getKey(int pid, String dbPath); -} +} \ No newline at end of file diff --git a/wx-dump-admin/src/main/java/com/xcs/wx/service/impl/WeChatServiceImpl.java b/wx-dump-admin/src/main/java/com/xcs/wx/service/impl/WeChatServiceImpl.java index 3d5b7f9..f7f804c 100644 --- a/wx-dump-admin/src/main/java/com/xcs/wx/service/impl/WeChatServiceImpl.java +++ b/wx-dump-admin/src/main/java/com/xcs/wx/service/impl/WeChatServiceImpl.java @@ -29,7 +29,9 @@ import java.nio.file.Paths; import java.util.*; /** - * 微信服务实现类 + * 微信服务实现类，该类实现了WeChatService接口，用于提供与微信相关的特定业务逻辑处理方法。 + * 主要涉及到读取微信配置信息的功能，包括获取微信进程ID、校验微信版本、根据内存地址偏移量读取微信相关信息（如昵称、账号、手机号等）以及获取微信文件存储路径等操作， + * 在整个项目架构中处于服务层，为上层应用提供微信相关配置数据的查询和获取服务，以便进行后续的展示或者其他相关业务处理。 * * @author xcs * @date 2023年12月25日 09时37分 @@ -40,335 +42,476 @@ import java.util.*; public class WeChatServiceImpl implements WeChatService { /** - * 微信进程 + * 微信进程名称，定义为常量字符串，用于在后续查找微信进程相关操作中作为标识来确定目标进程， + * 通常操作系统中的微信可执行文件名为"WeChat.exe"，通过这个名称可以在进程列表中准确识别微信的进程。 */ private static final String EXE_NAME = "WeChat.exe"; /** - * 微信程序dll文件 + * 微信程序的动态链接库（dll）文件名称，定义为常量字符串，在涉及到与微信底层功能交互（可能通过调用该dll中的函数实现一些特定功能）时， + * 以此名称来定位和加载对应的dll文件，在Windows系统下微信相关的一些功能实现可能依赖于"WeChatWin.dll"这个文件。 */ private static final String MODULE_NAME = "WeChatWin.dll"; /** - * 文档目录 + * 文档目录的标识字符串，定义为常量，在后续涉及到文件路径相关操作中，如果需要定位到系统的文档目录相关位置时， + * 可以通过该标识来进行相应的判断或者拼接完整的文件路径，不同操作系统可能有不同的表示方式，这里采用了一种特定的表示形式（可能针对Windows系统）。 */ private static final String MY_DOCUMENT = "MyDocument:"; /** - * 注册表中 WeChat 的路径 + * 注册表中微信相关配置的路径，定义为常量字符串，在Windows操作系统中，应用程序通常会将一些配置信息存储在注册表中， + * 这里指定了微信在注册表中的存储路径，后续可以通过该路径去读取微信相关的配置键值，例如文件保存路径等信息。 */ private static final String WECHAT_REG_PATH = "Software\\Tencent\\WeChat"; /** - * 注册表键值名称 + * 注册表中用于存储微信文件保存路径的键值名称，定义为常量字符串，通过该名称可以在注册表中找到微信具体设置的文件保存路径信息， + * 用于后续获取微信相关文件存储位置等操作。 */ private static final String FILE_SAVE_PATH = "FileSavePath"; /** - * WeChat 文件夹名称 + * 微信文件所在文件夹的名称，定义为常量字符串，在构建微信文件相关的完整路径时，会使用到这个文件夹名称来确定具体的位置， + * 通常微信的各类数据文件会存放在以"WeChat Files"命名的文件夹下。 */ private static final String WECHAT_FILES_DIR = "\\WeChat Files"; /** - * WeChat 配置文件的路径 + * 微信配置文件的具体路径，定义为常量字符串，明确指出了微信配置文件在系统中的存放位置， + * 后续可能会通过读取该配置文件来获取更多微信相关的配置参数等信息（虽然当前代码中未体现对该文件的读取操作）。 */ private static final String CONFIG_FILE_PATH = "\\AppData\\Roaming\\Tencent\\WeChat\\All Users\\config\\3ebffe94.ini"; /** - * 微信内存地址偏移量配置 + * 微信内存地址偏移量配置对象，通过依赖注入获取，用于存储不同微信版本对应的内存地址偏移量信息， + * 在读取微信相关信息（如昵称、账号等）时，需要依据当前微信版本对应的偏移量来准确获取内存中的数据，不同版本可能偏移量不同。 */ private final WeChatOffsetProperties weChatOffsetConfig; + /** + * 读取微信配置信息的方法，整体流程是先获取微信的进程ID列表，若微信未启动（进程ID列表为空）则抛出异常， + * 然后遍历每个进程ID，进行版本校验、获取对应版本的偏移量，接着依据偏移量从内存中读取微信的各项信息（昵称、账号、手机号等）以及获取微信文件目录和微信ID等， + * 最后将这些信息封装为WeChatConfigVO对象添加到列表中并返回，若在过程中出现如版本不支持、未读取到偏移量等问题则抛出相应异常。 + * + * @return List 返回一个包含WeChatConfigVO对象的列表，每个WeChatConfigVO对象包含了微信的进程ID、基址、版本号以及从内存中读取的昵称、账号、手机号、文件目录、微信ID等配置信息， + * 用于展示微信的相关配置详情，方便在其他业务逻辑中使用这些信息进行进一步操作（如展示给用户查看、与其他系统集成等）。 + */ @Override public List readWeChatConfig() { - // 获取微信进程Id + // 获取微信进程Id，调用wechatPid方法来查找并获取正在运行的微信进程的ID列表，该方法内部可能通过与操作系统相关的进程查找机制（比如Windows系统的相关API调用）来实现， + // 获取到的进程ID列表将作为后续操作的基础，用于定位不同的微信运行实例。 List pidList = wechatPid(); - // 微信未登录 + // 微信未登录，通过判断获取到的微信进程ID列表是否为空来确定微信是否已经启动并运行， + // 如果为空表示没有找到正在运行的微信进程，说明微信尚未启动，此时抛出BizException异常，提示用户需要先打开微信才能继续后续操作。 if (pidList.isEmpty()) { throw new BizException(-1, "检测到微信尚未启动，请先打开微信以继续进行操作。"); } List weChatConfigVOList = new ArrayList<>(); - // 遍历微信Id列表 + // 遍历微信Id列表，通过循环遍历获取到的微信进程ID列表，对每个微信进程进行相关配置信息的读取和处理操作，构建对应的WeChatConfigVO对象并添加到列表中。 for (Integer pid : pidList) { - // 获取版本号 + // 获取版本号，调用getVersion方法并传入当前微信进程的ID（pid）作为参数，从对应的微信进程中获取其版本号信息， + // 该版本号后续会用于版本校验以及确定对应的内存地址偏移量等操作，获取版本号的具体实现可能涉及到读取微信进程内存中的特定数据或者其他相关机制。 String version = getVersion(pid); - // 支持最小的版本号 + // 支持最小的版本号，通过对weChatOffsetConfig对象（存储微信内存地址偏移量配置信息）中版本相关配置的键值集合进行操作， + // 使用stream流找到第一个键（也就是最早支持的最小版本号），若集合为空则默认使用"0.0.0.0"作为最小版本号，这个最小版本号用于后续和当前微信版本号进行比较校验。 String supportMinVersion = weChatOffsetConfig.getVersion().keySet().stream().findFirst().orElse("0.0.0.0"); - // 校验版本号 + // 校验版本号，调用compareVersions方法，传入最小支持版本号（supportMinVersion）和当前获取到的微信版本号（version）作为参数， + // 对微信版本进行校验，如果当前版本号小于最小支持版本号，说明当前微信版本不满足要求，抛出BizException异常，提示用户需要升级微信到最新版本，并告知当前的微信版本号。 if (compareVersions(supportMinVersion, version)) { throw new BizException(-1, "当前微信版本不支持,请升级微信最新版本,当前微信版本号:" + version); } - // 读取微信版本对应的偏移量 + // 读取微信版本对应的偏移量，调用getVersionConfig方法并传入当前微信版本号（version）作为参数，从weChatOffsetConfig对象中获取对应版本的内存地址偏移量配置信息， + // 这些偏移量对于准确从微信进程内存中读取相关信息（如昵称、账号等）至关重要，不同版本的微信可能在内存布局上有所不同，需要对应的偏移量来定位具体数据位置。 WeChatOffsetProperties.VersionConfig versionConfig = getVersionConfig(version); - // 未读取到偏移量 + // 未读取到偏移量，判断获取到的版本对应的偏移量配置对象是否为null，如果是null表示没有找到当前微信版本对应的偏移量信息， + // 可能是配置缺失等原因，此时抛出BizException异常，提示用户需要从Github获取最新代码，并告知当前的微信版本号。 if (versionConfig == null) { throw new BizException(-1, "未读取到偏移量配置,请从Github获取最新代码,当前微信版本号:" + version); } - // 获取微信的基址 + // 获取微信的基址，调用baseAddress方法并传入当前微信进程的ID（pid）作为参数，获取微信进程在内存中的基址信息， + // 基址是后续根据偏移量计算具体数据内存地址的基础，有了基址和偏移量就能准确找到需要读取的微信相关信息在内存中的位置。 long baseAddress = baseAddress(pid); - // 获取微信昵称 + // 获取微信昵称，调用getInfo方法，传入当前微信进程的ID（pid）以及计算得到的微信昵称在内存中的地址（通过基址加上对应版本的昵称偏移量，即baseAddress + versionConfig.getNickname()）作为参数， + // 从微信进程内存中读取并获取微信昵称信息，读取内存数据的具体实现可能涉及到与操作系统底层内存交互的相关操作（比如通过JNA库调用系统API等方式）。 String nickname = getInfo(pid, (baseAddress + versionConfig.getNickname())); - // 获取微信账号 + // 获取微信账号，同样调用getInfo方法，传入微信进程的ID（pid）以及计算出的微信账号在内存中的地址（baseAddress + versionConfig.getAccount()）作为参数， + // 从微信进程内存中读取并获取微信账号信息，原理和获取昵称类似，都是依据内存地址来定位和读取相应的数据。 String account = getInfo(pid, (baseAddress + versionConfig.getAccount())); - // 获取微信手机号 + // 获取微信手机号，再次调用getInfo方法，传入微信进程的ID（pid）以及微信手机号在内存中的地址（baseAddress + versionConfig.getMobile()）作为参数， + // 从微信进程内存中读取并获取微信手机号信息，以获取微信用户更多的身份标识相关信息。 String mobile = getInfo(pid, (baseAddress + versionConfig.getMobile())); - // 获取微信文件目录 + // 获取微信文件目录，调用getBasePath方法来获取微信相关文件在系统中的存储目录路径，该路径可能用于后续访问微信聊天记录、文件等相关数据的操作， + // 获取路径的具体实现可能涉及到读取注册表信息、解析配置文件或者其他系统相关的文件路径查找机制。 String basePath = getBasePath(); - // 获取微信Id + // 获取微信Id，调用getWxId方法并传入当前微信进程的ID（pid）作为参数，获取微信的唯一标识ID信息， + // 这个ID可能是在微信系统内部用于区分不同用户或者账号的标识，用于后续在业务逻辑中准确识别不同的微信实例。 String wxId = getWxId(pid); - // 返回配置信息 + // 返回配置信息，将获取到的微信进程ID（pid）、基址（baseAddress）、版本号（version）以及昵称（nickname）、账号（account）、手机号（mobile）、文件目录（basePath）、微信ID（wxId）等信息， + // 封装为一个WeChatConfigVO对象，并添加到weChatConfigVOList列表中，完成一个微信实例的配置信息收集，循环结束后将返回包含所有微信实例配置信息的列表。 weChatConfigVOList.add(new WeChatConfigVO(pid, baseAddress, version, nickname, account, mobile, basePath, wxId)); } return weChatConfigVOList; } /** - * 根据版本号查找匹配的内容 + * 根据版本号查找匹配的内容的方法。 + * 该方法的主要目的是在存储微信内存地址偏移量配置信息的集合中，依据给定的微信版本号查找对应的版本配置内容。 + * 首先尝试进行精准匹配，如果找不到精准匹配的版本号，则会查找版本号前三位相同的最新版本对应的配置内容，若都未找到则返回null。 * - * @param version 要查找的版本号 - * @return 返回匹配的版本内容，如果未找到则返回 null + * @param version 要查找的版本号，以字符串形式传入，代表需要获取其对应配置信息的微信版本标识，通过这个版本号在配置集合中进行匹配查找操作。 + * @return 返回匹配的版本内容，如果未找到则返回 null，返回的WeChatOffsetProperties.VersionConfig对象包含了对应版本的微信内存地址偏移量等配置信息， + * 这些信息可用于后续从微信进程内存中准确读取如昵称、账号等相关数据，若查找失败则返回null表示无法获取到对应版本的配置内容。 */ public WeChatOffsetProperties.VersionConfig getVersionConfig(String version) { + // 获取存储微信不同版本配置信息的映射表，通过weChatOffsetConfig对象（该对象在类中通过依赖注入获取，用于管理微信内存地址偏移量配置）的getVersion方法， + // 得到一个以版本号为键，WeChatOffsetProperties.VersionConfig对象为值的映射表，其中WeChatOffsetProperties.VersionConfig对象包含了对应版本的各种偏移量等详细配置信息。 Map versionConfigMap = weChatOffsetConfig.getVersion(); - // 尝试精准匹配 + // 尝试精准匹配，通过判断versionConfigMap映射表中是否包含传入的版本号（version）作为键，来确定是否存在精准匹配的版本配置信息。 if (versionConfigMap.containsKey(version)) { + // 如果存在精准匹配的版本号，直接从映射表中获取对应的WeChatOffsetProperties.VersionConfig对象并返回，该对象包含了此版本的相关偏移量等配置内容。 return versionConfigMap.get(version); } String matchingVersion = null; - // 遍历版本数据的所有版本号，找到匹配前三位相同的最新版本 + // 遍历版本数据的所有版本号，找到匹配前三位相同的最新版本。通过循环遍历versionConfigMap映射表中的所有键（即所有可用的版本号）， + // 对每个版本号进行前缀匹配判断以及版本新旧比较，目的是找到与传入版本号前三位相同且是这些匹配的版本号中最新的那个版本号。 for (String availableVersion : versionConfigMap.keySet()) { + // 调用isMatchingPrefix方法判断当前遍历到的可用版本号（availableVersion）与传入的版本号（version）前三位是否相同， + // 并且同时判断当前找到的匹配版本号（matchingVersion）是否为null（首次匹配或者之前没有找到更新的匹配版本号时为null）， + // 或者当前可用版本号（availableVersion）比已记录的匹配版本号（matchingVersion）更新（通过compareTo方法比较版本号大小，大于表示更新）， + // 如果满足这些条件，则将当前可用版本号记录为新的匹配版本号（matchingVersion）。 if (isMatchingPrefix(version, availableVersion) && (matchingVersion == null || availableVersion.compareTo(matchingVersion) > 0)) { matchingVersion = availableVersion; } } - // 返回匹配的版本内容，如果都没有匹配到则返回 null + // 返回匹配的版本内容，如果都没有匹配到则返回 null。判断最终找到的匹配版本号（matchingVersion）是否不为null， + // 如果不为null说明找到了合适的匹配版本（前三位相同的较新版本），则从versionConfigMap映射表中获取对应的WeChatOffsetProperties.VersionConfig对象并返回， + // 若仍然为null则表示没有找到任何匹配的版本配置信息，直接返回null。 return (matchingVersion != null) ? versionConfigMap.get(matchingVersion) : null; } /** - * 判断两个版本号前三位是否相同 + * 判断两个版本号前三位是否相同的方法。 + * 通过截取两个版本号的前三位字符并进行比较，来确定它们是否具有相同的前缀部分，以此判断是否满足某种匹配条件（可能用于版本相关的模糊匹配等场景）。 * - * @param version1 版本号1 - * @param version2 版本号2 - * @return 如果前三位相同返回 true，否则返回 false + * @param version1 版本号1，以字符串形式传入，代表要比较的第一个版本号，用于和另一个版本号对比其前缀部分是否相同。 + * @param version2 版本号2，以字符串形式传入，代表要比较的第二个版本号，与version1进行前缀部分的相等性判断操作。 + * @return 如果前三位相同返回 true，否则返回 false，返回的布尔值用于在调用处（如在查找版本配置的方法中）根据结果进行相应的逻辑处理， + * 例如决定是否将某个版本号作为匹配的版本号来获取对应的配置信息等。 */ private boolean isMatchingPrefix(String version1, String version2) { + // 通过调用substring方法分别截取version1和version2的前三位字符（从索引0开始，截取长度为5，这里可能是考虑到版本号格式中前三位比较关键且可能包含小数点等情况）， + // 然后使用equals方法比较这两个截取后的字符串是否相等，相等则表示前三位相同，返回true，否则返回false。 return version1.substring(0, 5).equals(version2.substring(0, 5)); } /** - * 获取当前运行的微信进程的进程 ID。 + * 获取当前运行的微信进程的进程 ID的方法。 + * 此方法借助Windows系统相关的API（通过JNA库进行调用）来枚举系统中的所有进程，从中筛选出微信（WeChat.exe）进程，并返回其进程ID列表， + * 如果没有找到微信进程则返回一个空列表（在调用处判断列表长度为0则表示未找到微信进程）。 * - * @return 微信进程的进程 ID。如果未找到，返回 0。 + * @return 微信进程的进程 ID。如果未找到，返回 0，实际上是返回一个包含整数（进程ID）的列表，列表中的每个元素对应一个正在运行的微信进程的ID， + * 这些进程ID可用于后续针对微信进程进行如读取内存数据、获取相关配置等特定操作，若没有找到微信进程则返回空列表（调用处可根据列表情况判断是否找到）。 */ @Override public List wechatPid() { + // 创建一个空的整数列表，用于存储后续查找到的微信进程的进程ID，初始时列表为空，随着遍历进程发现微信进程会逐个添加其进程ID进去。 List pidList = new ArrayList<>(); - // 实例化Kernel32库接口 + // 实例化Kernel32库接口，Kernel32是JNA库中用于与Windows系统的Kernel32.dll（包含了许多系统底层功能相关的函数，如进程管理等）进行交互的接口， + // 通过INSTANCE属性获取其单例实例，后续可以利用这个实例调用Kernel32.dll中提供的相关函数来实现进程相关的操作，比如创建进程快照、遍历进程等。 Kernel32 kernel32 = Kernel32.INSTANCE; - // 创建系统快照，用来枚举所有进程 + // 创建系统快照，用来枚举所有进程，调用Kernel32实例的CreateToolhelp32Snapshot函数，传入参数Tlhelp32.TH32CS_SNAPPROCESS表示创建一个用于枚举所有正在运行进程的快照， + // 第二个参数是一个WinDef.DWORD类型的0值（表示对所有进程进行快照，无特定筛选条件），该函数返回一个句柄（WinNT.HANDLE类型），代表创建的系统快照，通过这个快照可以遍历系统中的所有进程。 WinNT.HANDLE hSnapshot = kernel32.CreateToolhelp32Snapshot(Tlhelp32.TH32CS_SNAPPROCESS, new WinDef.DWORD(0)); - // 初始化进程入口结构体 + // 初始化进程入口结构体，通过创建Tlhelp32.PROCESSENTRY32.ByReference类型的对象pe32来初始化一个用于存储进程相关信息（如进程ID、进程名等）的结构体， + // 这个结构体将在后续遍历进程时用于获取每个进程的详细信息，ByReference表示这个结构体是按引用传递的，方便在相关函数调用中对其内部成员进行赋值操作。 Tlhelp32.PROCESSENTRY32.ByReference pe32 = new Tlhelp32.PROCESSENTRY32.ByReference(); - // 遍历所有进程 + // 遍历所有进程，通过调用Kernel32实例的Process32First函数，传入创建的系统快照句柄（hSnapshot）和初始化的进程入口结构体（pe32）作为参数， + // 尝试获取第一个进程的信息，如果获取成功（函数返回true），则进入循环开始遍历所有进程，在循环中不断调用Process32Next函数获取下一个进程的信息，直到遍历完所有进程。 if (kernel32.Process32First(hSnapshot, pe32)) { do { - // 获取进程名 + // 获取进程名，通过调用Native.toString函数将pe32结构体中的szExeFile成员（存储进程的可执行文件名，以字节数组形式存储）转换为字符串形式， + // 得到当前遍历到的进程的名称，用于后续与目标进程名（微信进程名）进行比较判断。 String exeName = Native.toString(pe32.szExeFile); - // 检查进程名是否为目标进程名 + // 检查进程名是否为目标进程名，通过比较获取到的进程名（exeName）与定义的微信进程名常量（EXE_NAME，即"WeChat.exe"）是否相等（忽略大小写比较）， + // 来确定当前遍历到的进程是否为微信进程。 if (exeName.equalsIgnoreCase(EXE_NAME)) { - // 返回找到的进程ID + // 返回找到的进程ID，如果当前进程是微信进程，将pe32结构体中的th32ProcessID成员（存储进程的ID，是一个DWORD类型，需要转换为整数类型）转换为整数， + // 并添加到pidList列表中，完成一个微信进程ID的收集操作，后续继续遍历其他进程重复此操作。 pidList.add(pe32.th32ProcessID.intValue()); } - // 继续遍历下一个进程 + // 继续遍历下一个进程，通过调用Process32Next函数继续获取下一个进程的信息，进行下一轮的进程名判断和相关操作，直到所有进程都遍历完毕。 } while (kernel32.Process32Next(hSnapshot, pe32)); } - // 关闭快照句柄 + // 关闭快照句柄，在遍历完所有进程后，调用Kernel32实例的CloseHandle函数，传入创建的系统快照句柄（hSnapshot）作为参数，关闭系统快照，释放相关资源。 kernel32.CloseHandle(hSnapshot); - // 如果没有找到进程，返回0 + // 如果没有找到进程，返回0，实际上是返回前面创建的pidList列表，若在遍历过程中没有找到微信进程，列表为空，在调用处可以根据列表的长度等情况判断是否找到微信进程。 return pidList; } /** - * 根据提供的进程 ID 找到相应进程的模块基地址。 + * 根据提供的进程 ID 找到相应进程的模块基地址的方法。 + * 此方法借助Windows系统相关的API（通过JNA库调用）来创建进程模块的快照，遍历该进程下的所有模块， + * 从中查找微信相关的动态链接库（DLL）模块，并返回其基地址，若找不到对应的微信DLL模块则返回0。 * - * @param pid 目标进程的 ID。 - * @return 进程的模块基地址，如果找不到则返回 0。 + * @param pid 目标进程的 ID，以整数形式传入，用于唯一标识要查找模块基地址的微信进程，通过这个ID可以在系统中定位到对应的进程及其相关模块信息。 + * @return 进程的模块基地址，如果找不到则返回 0，返回的长整型数值代表了微信相关DLL在进程内存空间中的起始地址， + * 该基地址后续可结合偏移量等信息用于准确访问DLL内部存储的各种微信相关数据（如昵称、账号等信息在内存中的具体位置计算）。 */ @Override public long baseAddress(int pid) { + // 实例化Kernel32库接口，Kernel32是JNA库中用于与Windows系统的Kernel32.dll（包含了许多系统底层功能相关的函数，如进程和模块管理等）进行交互的接口， + // 通过INSTANCE属性获取其单例实例，后续将利用这个实例调用Kernel32.dll中提供的相关函数来实现查找模块基地址的操作。 Kernel32 kernel32 = Kernel32.INSTANCE; - // 创建模块快照 + // 创建模块快照，调用Kernel32实例的CreateToolhelp32Snapshot函数，传入参数Tlhelp32.TH32CS_SNAPMODULE表示创建一个用于枚举指定进程中所有模块的快照， + // 第二个参数是一个WinDef.DWORD类型，将传入的进程ID（pid）转换为该类型后传入，表示针对此特定进程创建模块快照，该函数返回一个句柄（WinNT.HANDLE类型），代表创建的模块快照， + // 通过这个快照可以遍历该进程下的所有模块信息。 WinNT.HANDLE hModuleSnapshot = kernel32.CreateToolhelp32Snapshot(Tlhelp32.TH32CS_SNAPMODULE, new WinDef.DWORD(pid)); - // 确保快照创建成功 + // 确保快照创建成功，通过判断创建的模块快照句柄（hModuleSnapshot）是否不等于WinNT.INVALID_HANDLE_VALUE（无效句柄值，表示创建快照失败）， + // 如果不等于则说明快照创建成功，可以继续进行后续的模块遍历查找操作，否则直接返回0表示无法获取模块基地址（因为没有有效的快照来查找模块信息）。 if (!WinNT.INVALID_HANDLE_VALUE.equals(hModuleSnapshot)) { - // 初始化 MODULEENTRY32W 结构体的引用 + // 初始化 MODULEENTRY32W 结构体的引用，通过创建Tlhelp32.MODULEENTRY32W.ByReference类型的对象me32来初始化一个用于存储模块相关信息（如模块名、基地址等）的结构体， + // 这个结构体将在后续遍历模块时用于获取每个模块的详细信息，ByReference表示这个结构体是按引用传递的，方便在相关函数调用中对其内部成员进行赋值操作。 Tlhelp32.MODULEENTRY32W.ByReference me32 = new Tlhelp32.MODULEENTRY32W.ByReference(); - // 遍历所有模块 + // 遍历所有模块，通过调用Kernel32实例的Module32FirstW函数，传入创建的模块快照句柄（hModuleSnapshot）和初始化的模块入口结构体（me32）作为参数， + // 尝试获取第一个模块的信息，如果获取成功（函数返回true），则进入循环开始遍历所有模块，在循环中不断调用Module32NextW函数获取下一个模块的信息，直到遍历完该进程下的所有模块。 if (kernel32.Module32FirstW(hModuleSnapshot, me32)) { do { - // 从模块入口结构中读取模块名 + // 从模块入口结构中读取模块名，通过调用Native.toString函数将me32结构体中的szModule成员（存储模块的名称，以字节数组形式存储）转换为字符串形式， + // 得到当前遍历到的模块的名称，用于后续与目标微信DLL模块名进行比较判断。 String moduleName = Native.toString(me32.szModule); - // 检查是否为微信 DLL + // 检查是否为微信 DLL，通过比较获取到的模块名（moduleName）与定义的微信程序DLL文件名称常量（MODULE_NAME，即"WeChatWin.dll"）是否相等（忽略大小写比较）， + // 来确定当前遍历到的模块是否为微信相关的DLL模块。 if (MODULE_NAME.equalsIgnoreCase(moduleName)) { - // 返回微信 DLL 的基地址 + // 返回微信 DLL 的基地址，如果当前模块是微信相关的DLL模块，首先调用kernel32.CloseHandle函数关闭模块快照句柄（hModuleSnapshot）以释放相关资源， + // 然后通过Pointer.nativeValue函数获取me32结构体中modBaseAddr成员（存储模块的基地址，是一个Pointer类型）对应的原生指针值（转换为长整型）并返回， + // 这个值就是微信DLL在进程内存中的基地址，后续可基于此进行进一步的数据读取操作。 kernel32.CloseHandle(hModuleSnapshot); return Pointer.nativeValue(me32.modBaseAddr); } } while (kernel32.Module32NextW(hModuleSnapshot, me32)); } - // 关闭快照句柄 + // 关闭快照句柄，无论是否找到微信DLL模块，在遍历完模块后（或者在遍历开始前如果Module32FirstW返回false），都需要调用kernel32.CloseHandle函数， + // 传入模块快照句柄（hModuleSnapshot）作为参数，关闭模块快照，释放相关资源。 kernel32.CloseHandle(hModuleSnapshot); } - // 如果未找到微信 DLL，返回 0 + // 如果未找到微信 DLL，返回 0，若在遍历模块过程中没有找到对应的微信DLL模块，直接返回0表示无法获取到模块基地址， + // 调用该方法的地方可以根据返回值判断是否成功获取以及进行相应的后续处理。 return 0; } /** - * 从指定进程的指定内存地址读取信息。 + * 从指定进程的指定内存地址读取信息的方法。 + * 该方法先打开目标进程以获取读取内存的权限，然后分配一块内存缓冲区，尝试从指定的内存地址读取数据到缓冲区， + * 若读取成功则将缓冲区中的字节数据转换为字符串，并进行一些字符串处理（如截取到第一个空字符为止），最后返回处理后的字符串信息， + * 若读取失败或者字符串为空则返回null。 * - * @param pid 目标进程的 ID。 - * @param address 要读取的内存地址。 - * @return 读取到的数据，如果失败则返回 null。 + * @param pid 目标进程的 ID，以整数形式传入，用于唯一标识要从中读取内存信息的微信进程，通过这个ID可以在系统中定位到对应的进程并获取相应的内存访问权限等操作。 + * @param address 要读取的内存地址，以长整型形式传入，代表在目标进程内存空间中要读取数据的具体位置，该地址通常是基于进程的模块基地址加上相应的偏移量计算得到的。 + * @return 读取到的数据，如果失败则返回 null，返回的字符串包含了从指定内存地址读取到的信息内容（经过处理后，去除了可能多余的空字符等）， + * 例如可能是微信的昵称、账号等相关信息，若读取过程出现问题（如读取内存失败、没有有效数据等）则返回null。 */ @Override public String getInfo(int pid, long address) { + // 实例化Kernel32库接口，同前面的方法一样，Kernel32是用于与Windows系统的Kernel32.dll进行交互的接口，通过获取其单例实例， + // 后续可以调用其中相关函数来实现打开进程、读取内存等操作，为从指定进程内存地址读取信息做准备。 Kernel32 kernel32 = Kernel32.INSTANCE; - // 打开目标进程 + // 打开目标进程，调用Kernel32实例的OpenProcess函数，传入参数WinNT.PROCESS_VM_READ表示以读取进程内存的权限打开目标进程， + // 第二个参数false表示不继承句柄（在父子进程关系等场景下相关的句柄继承特性，这里不需要继承所以设为false），第三个参数传入进程ID（pid）， + // 该函数返回一个句柄（WinNT.HANDLE类型），代表打开的目标进程，后续可以通过这个句柄对进程内存进行读取操作。 WinNT.HANDLE process = kernel32.OpenProcess(WinNT.PROCESS_VM_READ, false, pid); - // 分配内存作为缓冲区读取数据 + // 分配内存作为缓冲区读取数据，首先定义一个缓冲区大小为64字节（这里的大小可以根据预期要读取的数据长度等因素进行调整，64字节只是一个初始设定值）， + // 通过创建Memory类的实例buffer来分配指定大小的内存空间作为缓冲区，用于存储从进程内存中读取的数据，同时创建一个IntByReference类型的对象read， + // 用于存储实际读取的字节数（后续读取内存操作后会对其进行赋值）。 int bufferSize = 64; Memory buffer = new Memory(bufferSize); IntByReference read = new IntByReference(); - // 从指定地址读取内存 + // 从指定地址读取内存，调用Kernel32实例的ReadProcessMemory函数，传入打开的进程句柄（process）、表示要读取的内存地址的Pointer类型对象（通过将长整型地址转换为Pointer类型）、 + // 分配好的缓冲区buffer、缓冲区大小bufferSize以及用于存储实际读取字节数的read对象作为参数，尝试从指定的内存地址读取数据到缓冲区中， + // 函数执行后会返回一个布尔值表示读取操作是否成功，将这个布尔值存储在success变量中用于后续判断。 boolean success = kernel32.ReadProcessMemory(process, new Pointer(address), buffer, bufferSize, read); if (success) { - // 将读取的字节转换为字符串 + // 将读取的字节转换为字符串，首先通过buffer.getByteArray方法从缓冲区中获取实际读取到的字节数组，参数0表示从缓冲区起始位置开始获取， + // read.getValue()表示获取的字节长度（即实际读取到的字节数），然后使用String的构造函数将字节数组转换为字符串，指定字符编码为默认编码（通常取决于系统设置）， + // 得到从内存中读取的数据内容，存储在data变量中。 byte[] dataBytes = buffer.getByteArray(0, read.getValue()); String data = new String(dataBytes, 0, read.getValue()); - // 查找第一个空字符（字符串结束标志） + // 查找第一个空字符（字符串结束标志），调用String的indexOf方法查找字符串data中第一个出现的空字符（'\0'）的位置索引， + // 如果找到了（返回值不为 -1），则说明字符串中存在表示结束的空字符，需要进行截取操作，去除后面多余的部分（可能是未初始化的内存数据等）。 int nullPos = data.indexOf('\0'); if (nullPos != -1) { - // 截取到第一个空字符为止的字符串 + // 截取到第一个空字符为止的字符串，通过调用String的substring方法，传入起始索引0和结束索引nullPos（即到第一个空字符位置）， + // 对data字符串进行截取操作，得到一个只包含有效数据（到空字符为止）的字符串，更新data变量的值。 data = data.substring(0, nullPos); } - // 返回读取的字符串，如果为空则返回 null + // 返回读取的字符串，如果为空则返回 null，先调用kernel32.CloseHandle函数关闭打开的进程句柄（process）以释放相关资源， + // 然后判断处理后的data字符串是否为空（通过isEmpty方法判断），如果为空则返回null，否则返回处理后的字符串内容，表示成功从指定内存地址读取到的有效信息。 kernel32.CloseHandle(process); return data.isEmpty() ? null : data; } - // 关闭进程句柄 + // 关闭进程句柄，若读取内存操作失败（success为false），同样需要调用kernel32.CloseHandle函数关闭打开的进程句柄（process），释放相关资源，然后直接返回null， + // 表示无法从指定内存地址获取到有效信息。 kernel32.CloseHandle(process); return null; } /** - * 获取指定进程和数据库路径下的密钥 + * 获取指定进程和数据库路径下的密钥的方法。 + * 该方法主要功能是在给定的目标进程（通过进程ID标识）以及对应的数据库路径下，尝试查找并获取符合特定验证条件的密钥。 + * 其过程涉及打开目标进程、根据不同平台标识扫描模块地址、选择合适的模块地址列表，然后在选定的地址范围内倒序遍历查找密钥， + * 若找到符合验证条件（通过 `verifyKey` 方法验证）的密钥则返回，若遍历完都未找到则返回 `null`。 * - * @param pid 目标进程的进程ID - * @param dbPath 数据库路径 - * @return 返回找到的密钥，如果未找到则返回null + * @param pid 目标进程的进程ID，以整数形式传入，用于唯一标识要从中查找密钥的目标进程，系统会依据这个ID来定位并操作对应的进程，例如打开进程获取内存访问权限等操作。 + * @param dbPath 数据库路径，以字符串形式传入，指定了期望获取密钥所对应的数据库所在的文件路径，后续会基于此路径构建完整的数据库文件名（如 `MicroMsg.db`）用于密钥验证等操作。 + * @return 返回找到的密钥，如果未找到则返回 `null`，返回的字符串表示找到的符合条件的密钥内容，若整个查找和验证过程都未发现合适的密钥，则返回 `null` 表示获取密钥失败。 */ @Override public String getKey(int pid, String dbPath) { - // 打开目标进程 + // 打开目标进程，调用Kernel32实例（通过JNA库与Windows系统的Kernel32.dll交互的接口实例）的OpenProcess函数来打开目标进程。 + // 传入的参数 `0x1F0FFF` 表示请求的访问权限，这个十六进制数值代表了一系列权限组合（具体对应着如进程的读取、写入、执行等相关权限，这里是满足后续操作所需的权限设置）， + // 第二个参数 `false` 表示不继承句柄（即该进程句柄不会被其他相关进程继承，在一些父子进程关系场景下涉及的句柄继承特性，这里不需要继承所以设为 `false`）， + // 第三个参数传入进程ID（pid），该函数执行后返回一个句柄（WinNT.HANDLE类型），代表打开的目标进程，后续可以通过这个句柄对进程内存进行相关操作，比如读取内存数据等，以此来查找密钥。 WinNT.HANDLE process = Kernel32.INSTANCE.OpenProcess(0x1F0FFF, false, pid); - // 定义不同平台对应的字节数组 + // 定义不同平台对应的字节数组，分别创建表示 "iphone\0"、"android\0"、"ipad\0" 的字节数组，这里添加的末尾 `\0` 可能是为了符合某种特定的字符串格式要求（比如在内存中存储或比较时的格式要求）， + // 这些字节数组后续会用于扫描进程模块中与不同平台相关的特定标识，以确定合适的模块地址范围来查找密钥，不同平台在内存中的存储模式或标识可能有所不同，通过这种方式进行区分。 byte[] iphoneByteArray = "iphone\0".getBytes(); byte[] androidByteArray = "android\0".getBytes(); byte[] ipadByteArray = "ipad\0".getBytes(); - // 用于存储不同平台的模块扫描结果 + // 用于存储不同平台的模块扫描结果，创建一个空的 `Pointer` 类型列表，用于存储通过 `patternScanModule` 方法扫描不同平台相关字节数组在进程模块中找到的地址信息， + // 这个列表后续会根据不同平台扫描结果的情况进行筛选和赋值，最终确定要在哪些模块地址范围内查找密钥。 List typeAddress = new ArrayList<>(); + // 调用 `patternScanModule` 方法，传入打开的进程句柄（process）和表示 "iphone" 平台标识的字节数组（iphoneByteArray）作为参数， + // 该方法会在进程的模块中扫描匹配此字节数组模式的地址信息，并返回一个包含 `Pointer` 类型地址的列表（表示找到的相关模块地址），将结果存储在 `typeAddress1` 变量中。 List typeAddress1 = patternScanModule(process, iphoneByteArray); + // 同样地，调用 `patternScanModule` 方法，传入进程句柄和表示 "android" 平台标识的字节数组（androidByteArray），扫描并获取对应的模块地址列表，存储在 `typeAddress2` 变量中。 List typeAddress2 = patternScanModule(process, androidByteArray); + // 再次调用 `patternScanModule` 方法，传入进程句柄和表示 "ipad" 平台标识的字节数组（ipadByteArray），获取 "ipad" 平台相关的模块地址列表，存储在 `typeAddress3` 变量中。 List typeAddress3 = patternScanModule(process, ipadByteArray); - // 优先选择长度至少为2的模块地址列表 + // 优先选择长度至少为2的模块地址列表，通过一系列条件判断来确定最终要使用的模块地址列表（存储在 `typeAddress` 变量中）。 + // 首先判断 `typeAddress1` 列表的大小是否大于等于2，如果满足则将 `typeAddress` 赋值为 `typeAddress1`，表示优先选择 "iphone" 平台相关且地址数量足够的模块地址范围来查找密钥。 if (typeAddress1.size() >= 2) { typeAddress = typeAddress1; } else if (typeAddress2.size() >= 2) { + // 如果 "iphone" 平台的地址列表不符合条件，再判断 "android" 平台的 `typeAddress2` 列表大小是否大于等于2，若满足则选择 "android" 平台相关的模块地址范围。 typeAddress = typeAddress2; } else if (typeAddress3.size() >= 2) { + // 若 "android" 平台的地址列表也不符合条件，接着判断 "ipad" 平台的 `typeAddress3` 列表大小是否大于等于2，满足则选择 "ipad" 平台相关的模块地址范围。 typeAddress = typeAddress3; } else if (!typeAddress1.isEmpty()) { + // 如果前面三个平台的地址列表长度都小于2，但 "iphone" 平台的地址列表不为空，说明虽然数量不足但也可以尝试使用，将 `typeAddress` 赋值为 `typeAddress1`。 typeAddress = typeAddress1; } else if (!typeAddress2.isEmpty()) { + // 若 "iphone" 平台地址列表为空，而 "android" 平台的地址列表不为空，将 `typeAddress` 赋值为 `typeAddress2`，选择 "android" 平台相关的模块地址范围（即使数量不足）。 typeAddress = typeAddress2; } else if (!typeAddress3.isEmpty()) { + // 同理，若前两个平台地址列表都为空，而 "ipad" 平台的地址列表不为空，将 `typeAddress` 赋值为 `typeAddress3`，选择 "ipad" 平台相关的模块地址范围来查找密钥。 typeAddress = typeAddress3; } - // 拼接MicroMsg数据库路径 + // 拼接MicroMsg数据库路径，将传入的数据库路径（dbPath）与 "\\Msg\\MicroMsg.db" 进行字符串拼接，构建出完整的微信消息数据库（MicroMsg.db）的文件路径， + // 这个完整路径后续会用于验证获取到的密钥是否与该数据库相关且有效（通过 `verifyKey` 方法进行验证），确保获取的密钥是对应此数据库的正确密钥。 String microMsg = dbPath + "\\Msg\\MicroMsg.db"; - // 获取倒序迭代器 + // 获取倒序迭代器，通过调用 `typeAddress` 列表的 `listIterator` 方法，并传入 `typeAddress.size()` 作为参数，获取一个指向列表末尾的列表迭代器， + // 这个迭代器可以用于从后往前（倒序）遍历 `typeAddress` 列表中的元素（即模块地址指针），方便后续按照特定顺序（倒序）在模块地址范围内查找密钥。 ListIterator pointerListIterator = typeAddress.listIterator(typeAddress.size()); - // 倒序遍历模块地址列表 + // 倒序遍历模块地址列表，通过 `while` 循环结合迭代器的 `hasPrevious` 方法，只要迭代器还有前一个元素（即还没遍历到列表开头），就持续进行循环操作， + // 在循环内获取上一个元素（模块地址指针），并将其转换为长整型的内存地址值，用于后续在该地址范围内查找密钥的操作。 while (pointerListIterator.hasPrevious()) { Pointer addressPointer = pointerListIterator.previous(); long address = Pointer.nativeValue(addressPointer); - // 在地址范围内以步长8递减遍历，读取密钥 + // 在地址范围内以步长8递减遍历，读取密钥，从当前模块地址（address）开始，以步长为8（这里的步长8可能与内存中数据存储结构或读取规则相关，比如按8字节对齐等情况）递减， + // 直到地址减少到不小于 `address - 2000` 的范围，在每个地址位置尝试读取密钥（通过调用 `readKey` 方法），并进行后续的验证操作。 for (long i = address; i >= (address - 2000); i -= 8) { - // 读取key + // 读取key，调用 `readKey` 方法，传入打开的进程句柄（process）和当前遍历到的内存地址（i）作为参数，尝试从该内存地址读取密钥内容， + // 读取到的密钥以字符串形式返回（如果读取成功的话），存储在 `key` 变量中，用于后续的验证判断。 String key = readKey(process, i); - // 如果密钥不为空且验证通过，则返回密钥 + // 如果密钥不为空且验证通过，则返回密钥，通过判断 `key` 变量是否不为 `null` 并且调用 `verifyKey` 方法验证 `key` 与构建好的数据库路径（microMsg）是否匹配成功， + // 如果两者条件都满足，说明找到了符合要求的密钥，直接将其返回，结束整个 `getKey` 方法的执行，表示成功获取到了密钥。 if (key != null && verifyKey(key, microMsg)) { return key; } } } - // 未找到匹配的密钥，返回null + // 未找到匹配的密钥，返回null，如果在整个倒序遍历模块地址列表以及在各个地址范围内查找和验证的过程中，都没有找到符合条件的密钥， + // 则最终返回 `null`，表示此次获取密钥的操作失败，调用该方法的地方可以根据返回值进行相应的处理，比如提示用户或者进行其他补救逻辑等。 return null; } /** - * 获取秘钥 + * 获取秘钥的方法，其功能是从指定的目标进程的内存地址中读取密钥信息。 + * 该方法先尝试从给定内存地址读取一个地址值，再依据这个读取到的地址去获取真正的密钥内容， + * 然后将密钥内容转换为十六进制字符串形式返回，如果在读取内存等操作过程中出现失败情况则返回 `null`。 * - * @param address 要读取的内存地址 - * @return 读取到的秘钥，如果失败则返回 null。 + * @param process 目标进程的句柄，通过 `WinNT.HANDLE` 类型传入，代表已经打开且具有相应访问权限的目标进程， + * 此句柄用于后续对该进程内存进行读取操作，是与目标进程交互的关键标识，由外部调用时传入（通常是先通过 `OpenProcess` 等方法打开进程获取到的）。 + * @param address 要读取的内存地址，以长整型形式传入，表示在目标进程内存空间中期望获取密钥相关信息的具体位置， + * 方法会从这个地址开始进行相应的内存读取和密钥提取操作。 + * @return 读取到的秘钥，如果失败则返回 `null`，返回的字符串为密钥内容以十六进制表示的形式， + * 若在读取内存、转换数据等操作过程中出现问题（例如无法读取指定内存地址的数据等情况）则返回 `null`，表示获取密钥失败。 */ private String readKey(WinNT.HANDLE process, long address) { + // 实例化Kernel32库接口，Kernel32是JNA库中用于与Windows系统的Kernel32.dll进行交互的接口， + // 通过 `INSTANCE` 属性获取其单例实例，后续利用这个实例调用Kernel32.dll中提供的相关函数来实现读取目标进程内存等操作， + // 这是与Windows底层系统进行内存交互操作的基础，以此来完成密钥读取相关的功能。 Kernel32 kernel32 = Kernel32.INSTANCE; - // 准备缓冲区用于读取内存 + // 准备缓冲区用于读取内存，创建一个 `Memory` 类型的对象 `buffer`，分配大小为8字节的内存空间作为缓冲区， + // 这个缓冲区用于第一次读取内存操作，目的是从指定的内存地址（`address`）读取一个地址值（可能是后续获取真正密钥所在位置的相关指针信息）， + // 同时创建一个 `IntByReference` 类型的对象 `bytesRead`，用于记录实际读取到的字节数，方便后续判断读取操作是否完整执行。 Memory buffer = new Memory(8); IntByReference bytesRead = new IntByReference(); - // 读取目标进程的内存地址 + + // 读取目标进程的内存地址，调用 `kernel32` 实例的 `ReadProcessMemory` 函数，传入打开的进程句柄（`process`）、 + // 表示要读取的内存地址的 `Pointer` 类型对象（通过将长整型地址 `address` 转换为 `Pointer` 类型）、准备好的缓冲区 `buffer`、 + // 缓冲区大小（强制转换为 `int` 类型，这里就是8字节）以及用于记录实际读取字节数的 `bytesRead` 对象作为参数， + // 尝试从指定的内存地址读取数据到缓冲区中，若读取操作失败（函数返回 `false`），则直接返回 `null`，表示无法获取到有效的数据用于后续操作。 if (!kernel32.ReadProcessMemory(process, new Pointer(address), buffer, (int) buffer.size(), bytesRead)) { return null; } - // 将缓冲区中的字节转换为长整型值 + // 将缓冲区中的字节转换为长整型值，首先通过 `ByteBuffer` 的 `wrap` 方法将缓冲区 `buffer` 中的字节数组（从索引0开始，长度为8字节）包装为一个 `ByteBuffer` 对象， + // 并通过 `order` 方法指定字节顺序为小端序（`ByteOrder.LITTLE_ENDIAN`），这是为了确保在多平台环境下数据解析的一致性，符合特定内存数据存储和解析的要求， + // 然后调用 `getLong` 方法从这个 `ByteBuffer` 对象中读取一个长整型值，这个值被认为是后续获取真正密钥所在的内存地址，存储在 `keyAddress` 变量中，为下一步读取密钥做准备。 ByteBuffer bufferWrap = ByteBuffer.wrap(buffer.getByteArray(0, 8)).order(ByteOrder.LITTLE_ENDIAN); long keyAddress = bufferWrap.getLong(); - // 准备一个缓冲区用于存放密钥 + // 准备一个缓冲区用于存放密钥，创建一个新的 `Memory` 类型对象 `keyBuffer`，分配大小为32字节的内存空间作为缓冲区， + // 这个缓冲区用于从前面计算得到的密钥内存地址（`keyAddress`）读取真正的密钥内容，同样大小32字节是根据密钥可能的存储长度等预先设定的一个合适大小。 Memory keyBuffer = new Memory(32); - // 从计算出的密钥地址读取密钥 + + // 从计算出的密钥地址读取密钥，再次调用 `kernel32` 实例的 `ReadProcessMemory` 函数，传入进程句柄（`process`）、 + // 表示密钥地址的 `Pointer` 类型对象（通过将长整型的 `keyAddress` 转换为 `Pointer` 类型）、准备好的密钥缓冲区 `keyBuffer`、 + // 密钥缓冲区大小（强制转换为 `int` 类型，即32字节）以及前面的 `bytesRead` 对象作为参数，尝试从计算出的密钥地址读取密钥数据到 `keyBuffer` 缓冲区中， + // 若读取操作失败（函数返回 `false`），则直接返回 `null`，表示无法获取到有效的密钥内容。 if (!kernel32.ReadProcessMemory(process, new Pointer(keyAddress), keyBuffer, (int) keyBuffer.size(), bytesRead)) { return null; } - // 将密钥转换为十六进制字符串 + // 将密钥转换为十六进制字符串，创建一个 `StringBuilder` 对象 `sb`，用于逐步构建密钥的十六进制表示字符串。 + // 首先获取 `keyBuffer` 缓冲区中的字节数组（从索引0开始，长度为32字节），存储在 `key` 变量中，这个字节数组就是读取到的密钥内容（以字节形式存在）， + // 然后通过 `Formatter` 结合 `try-with-resources` 语句来遍历字节数组中的每个字节，将其格式化为十六进制的字符串形式，并追加到 `sb` 对象中，最终形成完整的密钥十六进制表示字符串。 StringBuilder sb = new StringBuilder(); byte[] key = keyBuffer.getByteArray(0, 32); try (Formatter formatter = new Formatter(sb)) { @@ -376,7 +519,8 @@ public class WeChatServiceImpl implements WeChatService { formatter.format("%02x", b & 0xff); } } - // 返回密钥的十六进制表示 + // 返回密钥的十六进制表示，将构建好的密钥十六进制表示字符串（存储在 `sb` 对象中）通过 `toString` 方法转换为普通字符串并返回， + // 这个字符串就是最终获取到的密钥信息的表示形式，供调用该方法的地方使用（例如用于后续的密钥验证等操作）。 return sb.toString(); } @@ -389,110 +533,174 @@ public class WeChatServiceImpl implements WeChatService { */ private boolean verifyKey(String password, String dbFile) { // 创建File文件 + // 这个对象代表了磁盘上对应的实际文件，后续可以基于它进行文件读取等相关操作，用于获取文件内部的数据来进行密钥验证。 File file = new File(dbFile); try (FileInputStream fis = new FileInputStream(file)) { - // 文件大小 + // 文件大小，创建一个长度为5000字节的字节数组 `fileContent`，用于存储从文件中读取的内容， + // 这里设定5000字节是根据预期要读取的文件相关部分数据量大小来确定的，后续会从文件中读取相应字节数的数据到这个数组中，方便提取验证所需的关键信息。 byte[] fileContent = new byte[5000]; - // 读取内容 + // 读取内容，调用 `FileInputStream` 的 `read` 方法，将文件中的数据读取到 `fileContent` 字节数组中， + // 实际读取的字节数可能小于数组长度（取决于文件大小等情况），读取操作会从文件开头按顺序读取数据，后续将基于这些读取到的数据进行进一步的处理和验证。 fis.read(fileContent); - // 提取盐值 + // 提取盐值，通过 `Arrays.copyOfRange` 方法从 `fileContent` 字节数组中提取一部分数据作为盐值， + // 具体是从索引0开始，长度为16字节的子数组，在加密相关操作中，盐值通常用于增加密码安全性、防止彩虹表攻击等，提取出来的盐值将用于后续生成密钥等验证步骤。 byte[] salt = Arrays.copyOfRange(fileContent, 0, 16); - // 提取第一页 + // 提取第一页，同样使用 `Arrays.copyOfRange` 方法，从 `fileContent` 字节数组中提取代表文件“第一页”内容的部分数据， + // 提取范围是从索引16到4096（长度为4096 - 16 = 4080字节），这部分数据可能包含了与加密、验证相关的重要信息，后续会进一步从中提取更具体的内容用于验证操作。 byte[] firstPage = Arrays.copyOfRange(fileContent, 16, 4096); - // 提取第一页的内容与IV + // 提取第一页的内容与IV，再次使用 `Arrays.copyOfRange` 方法，从前面提取的“第一页”数据（`firstPage` 字节数组）中进一步提取其主体内容与初始向量（IV，Initialization Vector，在加密算法中常作为随机化因素使用）部分， + // 提取范围是从索引0到 `firstPage.length - 32`，即去除了末尾32字节的部分，这部分数据将作为后续验证计算的一部分依据。 byte[] firstPageBodyAndIv = Arrays.copyOfRange(firstPage, 0, firstPage.length - 32); - // 提取第一页的hashMac + // 提取第一页的hashMac，还是通过 `Arrays.copyOfRange` 方法，从“第一页”数据（`firstPage` 字节数组）中提取末尾部分的哈希消息认证码（hashMac）， + // 提取范围是从 `firstPage.length - 32` 到 `firstPage.length - 12`（长度为20字节），这个哈希值通常是对前面提取的主体内容等进行特定哈希计算得到的结果，用于验证数据的完整性和密钥的正确性。 byte[] firstPageHashMac = Arrays.copyOfRange(firstPage, firstPage.length - 32, firstPage.length - 12); - // 生成key + // 生成key，调用 `Pbkdf2HmacUtil` 工具类的 `pbkdf2Hmac` 方法，传入将密钥字符串（`password`）转换后的十六进制字节数组（通过 `HexUtil.decodeHex` 方法转换）、 + // 前面提取的盐值（`salt`）、迭代次数64000以及期望生成的密钥长度32字节作为参数，基于密码和盐值按照PBKDF2-HMAC算法生成一个新的密钥字节数组 `key`， + // 这个生成的密钥将用于后续与文件中提取的数据进行匹配验证操作，PBKDF2-HMAC算法常用于通过密码和盐值安全地生成加密密钥。 byte[] key = Pbkdf2HmacUtil.pbkdf2Hmac(HexUtil.decodeHex(password), salt, 64000, 32); byte[] macSalt = new byte[salt.length]; for (int i = 0; i < salt.length; i++) { + // 对盐值的每个字节进行异或操作，创建一个与盐值长度相同的新字节数组 `macSalt`，通过循环遍历盐值（`salt`）的每个字节， + // 将其与固定值58（十六进制为 `0x3A`）进行异或操作，得到新的字节值并存储到 `macSalt` 数组中，这个新的字节数组 `macSalt` 将在后续验证操作中使用， + // 异或操作在这里可能是某种特定加密验证逻辑中的一部分处理步骤，用于进一步处理盐值以适配验证过程。 macSalt[i] = (byte) (salt[i] ^ 58); } - // 秘钥匹配成功 + // 秘钥匹配成功，调用 `Pbkdf2HmacUtil` 工具类的 `checkKey` 方法，传入生成的密钥（`key`）、处理后的盐值（`macSalt`）、 + // 提取的第一页哈希消息认证码（`firstPageHashMac`）以及第一页主体内容与初始向量（`firstPageBodyAndIv`）作为参数， + // 该方法会基于这些数据进行特定的验证计算，若计算结果表明密钥与文件中的数据匹配，则返回 `true`，表示密钥验证成功；否则返回 `false`。 return Pbkdf2HmacUtil.checkKey(key, macSalt, firstPageHashMac, firstPageBodyAndIv); } catch (Exception e) { + // 如果在文件读取、数据提取或者密钥验证等过程中出现了任何异常（比如文件不存在、读取文件权限不足、验证计算过程出现错误等情况）， + // 通过 `log.error` 方法记录错误信息，"Verification key failed" 作为错误描述的标识，方便后续查看日志排查问题，`e` 是捕获到的具体异常对象， + // 然后直接返回 `false`，表示验证失败。 log.error("Verification key failed", e); } return false; } /** - * 列出并检索进程中指定已加载模块 + * 列出并检索进程中指定已加载模块的方法。 + * 该方法的主要功能是获取目标进程中已加载的各个模块的详细信息，通过调用Windows系统相关的API（借助JNA库）来枚举模块， + * 尝试获取每个模块的信息并存储到列表中，如果在枚举或获取模块信息过程中出现失败情况会记录相应警告日志，最终返回包含模块信息的列表。 * - * @param process 目标进程 + * @param process 目标进程，以 `WinNT.HANDLE` 类型传入，代表已经打开且具有相应访问权限的目标进程， + * 此句柄用于后续与该进程交互，如枚举其加载的模块等操作，是整个方法操作针对的具体进程对象，由外部调用时传入（通常是先通过 `OpenProcess` 等方法打开进程获取到的）。 + * @return 返回一个包含 `Psapi.MODULEINFO` 类型对象的列表，列表中的每个元素代表目标进程中一个已加载模块的详细信息， + * 若在枚举或获取模块信息过程中出现问题，可能返回一个空列表，表示无法成功获取到完整的模块信息。 */ private List enumProcessModule(WinNT.HANDLE process) { + // 创建一个空的列表，用于存储后续获取到的各个模块的详细信息，初始时列表为空，随着成功获取每个模块的信息会将其对应的 `Psapi.MODULEINFO` 对象添加到这个列表中。 List moduleInfos = new ArrayList<>(); - // 获取模块句柄列表 + + // 获取模块句柄列表，创建一个长度为1024的 `WinNT.HMODULE` 类型数组 `hModules`，用于存储目标进程中各个已加载模块的句柄信息， + // 这里设定数组长度为1024是一种初始的预估大小，期望能够容纳下进程中加载的模块句柄，实际情况中如果模块数量超过这个值可能需要进一步处理（不过通常是有一定合理性的预估大小）。 WinNT.HMODULE[] hModules = new WinNT.HMODULE[1024]; - // 指针大小 + + // 指针大小，计算存储所有模块句柄所需的字节数，通过将 `hModules` 数组的长度乘以 `Native.POINTER_SIZE`（这是通过JNA库获取的表示指针大小的常量值，通常在不同平台下有对应的正确字节数）， + // 得到理论上存储所有模块句柄应该需要的字节长度，这个值将作为后续调用相关函数时传入的参数，用于告知系统期望读取或写入的数据量大小等信息。 int cbNeeded = hModules.length * Native.POINTER_SIZE; - // 存储所有模块句柄所需的字节数 + + // 存储所有模块句柄所需的字节数，创建一个 `IntByReference` 类型的对象 `read`，用于存储实际读取或写入的字节数相关信息， + // 在后续调用相关系统函数（如 `EnumProcessModules` 等）时，函数会根据实际操作情况更新这个对象的值，以便后续判断操作是否完整执行以及获取实际操作的数据量等情况。 IntByReference read = new IntByReference(); - // 调用 EnumProcessModules 方法 + + // 调用 EnumProcessModules 方法，通过 `Psapi.INSTANCE`（这是JNA库中用于与Windows系统的 `Psapi.dll` 进行交互的接口实例，用于获取进程模块相关的功能函数）调用 `EnumProcessModules` 函数， + // 传入打开的目标进程句柄（`process`）、用于存储模块句柄的数组 `hModules`、前面计算得到的期望字节数 `cbNeeded` 以及用于记录实际操作字节数的 `read` 对象作为参数， + // 尝试枚举目标进程中已加载的所有模块，将模块句柄信息存储到 `hModules` 数组中，函数执行后返回一个布尔值 `success`，用于表示枚举操作是否成功。 boolean success = Psapi.INSTANCE.EnumProcessModules(process, hModules, cbNeeded, read); - // 读取模块失败 + + // 读取模块失败，如果枚举模块操作失败（即 `success` 为 `false`），通过 `log.warn` 方法记录警告信息，信息内容包含 "EnumProcessModules failed." 表示枚举模块失败的提示以及通过 `Native.getLastError` 方法获取的系统错误代码， + // 方便后续查看日志排查问题，然后直接返回当前的空 `moduleInfos` 列表，表示无法获取到模块信息，方法执行结束。 if (!success) { log.warn("EnumProcessModules failed. Error code: " + Native.getLastError()); return moduleInfos; } - // 遍历加载到的所有模块 + + // 遍历加载到的所有模块，通过循环遍历 `hModules` 数组中的每个元素（每个元素对应一个模块的句柄，可能为 `null` 表示无效或未获取到对应模块信息）， + // 对每个非 `null` 的模块句柄对应的模块进行详细信息获取操作，以此来收集所有已加载模块的完整信息。 for (WinDef.HMODULE hModule : hModules) { - // 模块不等于空的情况下 + // 模块不等于空的情况下，判断当前遍历到的模块句柄 `hModule` 是否不为 `null`，如果不为 `null` 则表示存在对应的有效模块，需要进一步获取其详细信息，进入下面的操作流程。 if (hModule != null) { - // 获取模块信息 + // 获取模块信息，创建一个 `Psapi.MODULEINFO` 类型的对象 `moduleInfo`，这个对象用于存储即将获取的模块详细信息， + // 包括模块的基地址、大小、入口点等相关信息，后续会通过调用系统函数来填充这个对象的各个成员变量。 Psapi.MODULEINFO moduleInfo = new Psapi.MODULEINFO(); - // 加载模块的详细信息 + + // 加载模块的详细信息，调用 `Psapi.INSTANCE` 的 `GetModuleInformation` 函数，传入目标进程句柄（`process`）、当前模块的句柄（`hModule`）、 + // 用于存储模块信息的 `moduleInfo` 对象以及 `moduleInfo` 对象的大小（通过 `moduleInfo.size()` 获取）作为参数，尝试获取指定模块的详细信息并填充到 `moduleInfo` 对象中， + // 函数执行后返回一个布尔值 `moduleInformationSuccess`，用于表示获取模块信息操作是否成功。 boolean moduleInformationSuccess = Psapi.INSTANCE.GetModuleInformation(process, hModule, moduleInfo, moduleInfo.size()); - // 读取失败 + + // 读取失败，如果获取模块详细信息的操作失败（即 `moduleInformationSuccess` 为 `false`），通过 `log.warn` 方法记录警告信息， + // 信息内容包含 "GetModuleInformation failed." 表示获取模块信息失败的提示以及通过 `Native.getLastError` 方法获取的系统错误代码，方便后续查看日志排查问题， + // 然后使用 `continue` 语句跳过当前循环，继续处理下一个模块（即继续遍历 `hModules` 数组中的下一个元素），不将当前失败的模块信息添加到列表中。 if (!moduleInformationSuccess) { log.warn("GetModuleInformation failed. Error code: " + Native.getLastError()); continue; } + + // 将获取到详细信息的模块对应的 `moduleInfo` 对象添加到 `moduleInfos` 列表中，完成一个模块信息的收集操作，后续继续遍历其他模块重复此过程， + // 直到遍历完 `hModules` 数组中所有有效的模块句柄对应的模块信息收集操作，最终 `moduleInfos` 列表将包含所有成功获取到详细信息的模块对象。 moduleInfos.add(moduleInfo); } } + return moduleInfos; } /** - * 通过模块名检索指定进程加载的模块信息 + * 通过模块名检索指定进程加载的模块信息的方法。 + * 该方法首先调用 `enumProcessModule` 方法获取指定进程中所有已加载模块的信息列表，然后遍历这个列表， + * 针对每个模块获取其文件名并判断是否以特定的模块名（`WeChatServiceImpl.MODULE_NAME`）结尾， + * 如果找到匹配的模块则返回其对应的 `Psapi.MODULEINFO` 对象，若遍历完所有模块都未找到匹配的则返回 `null`。 * - * @param process 指定的进程句柄 - * @return 包含模块信息的 Psapi.MODULEINFO 对象，如果未找到，则返回 null + * @param process 指定的进程句柄，以 `WinNT.HANDLE` 类型传入，代表已经打开且具有相应访问权限的目标进程， + * 此句柄用于后续与该进程交互，例如获取其加载的模块信息等操作，是整个方法操作针对的具体进程对象，由外部调用时传入（通常是先通过 `OpenProcess` 等方法打开进程获取到的）。 + * @return 包含模块信息的 `Psapi.MODULEINFO` 对象，如果未找到，则返回 `null`，返回的 `Psapi.MODULEINFO` 对象包含了匹配模块的详细信息，如模块的基地址、大小、入口点等， + * 若在遍历所有已加载模块后都没有找到文件名以指定模块名结尾的模块，则返回 `null`，表示未检索到符合要求的模块信息。 */ private Psapi.MODULEINFO moduleFromName(WinNT.HANDLE process) { - // 列出并检索进程中指定已加载模块 + // 列出并检索进程中指定已加载模块，调用 `enumProcessModule` 方法，传入目标进程句柄（`process`）作为参数， + // 该方法会返回一个包含 `Psapi.MODULEINFO` 类型对象的列表，列表中的每个元素代表目标进程中一个已加载模块的详细信息，将这个列表存储在 `moduleInfos` 变量中， + // 作为后续遍历查找特定模块的基础数据来源。 List moduleInfos = enumProcessModule(process); - // 遍历模块列表 + // 遍历模块列表，通过循环遍历 `moduleInfos` 列表中的每个 `Psapi.MODULEINFO` 类型的元素（每个元素对应一个已加载模块的详细信息）， + // 对每个模块进行相关操作，以查找文件名符合要求的特定模块。 for (Psapi.MODULEINFO moduleInfo : moduleInfos) { - // 创建用于存储模块文件名的字节数组 + // 创建用于存储模块文件名的字节数组，创建一个长度为 `WinNT.MAX_PATH`（这是一个预定义的常量，表示系统中文件路径的最大长度，通常足够存储模块文件名）的字节数组 `buffer`， + // 用于后续存储获取到的模块文件名信息，这个数组初始化为全0字节，等待被填充有效的文件名数据。 byte[] buffer = new byte[WinNT.MAX_PATH]; - // 根据模块的基址创建模块句柄 + // 根据模块的基址创建模块句柄，通过将当前遍历到的模块信息（`moduleInfo`）中的模块基址（`lpBaseOfDll` 成员变量，表示模块在进程内存空间中的起始地址）转换为 `WinNT.HANDLE` 类型， + // 创建一个新的模块句柄对象 `handle`，这个句柄后续会用于获取模块文件名的操作，它基于模块在内存中的基址来标识对应的模块实体，以便与系统函数交互获取相关信息。 WinNT.HANDLE handle = new WinNT.HANDLE(moduleInfo.lpBaseOfDll); - // 获取模块文件名并存储在 buffer 中 + // 获取模块文件名并存储在 buffer 中，调用 `Psapi.INSTANCE`（这是JNA库中用于与Windows系统的 `Psapi.dll` 进行交互的接口实例，用于获取进程模块相关的功能函数）的 `GetModuleFileNameExA` 函数， + // 传入目标进程句柄（`process`）、刚创建的模块句柄（`handle`）、用于存储文件名的字节数组 `buffer` 以及字节数组的长度（`buffer.length`）作为参数， + // 尝试获取指定模块的文件名信息，并将其存储到 `buffer` 字节数组中，函数执行后会按照系统的字符编码格式将文件名填充到数组中（可能包含结尾的空字符等情况）。 Psapi.INSTANCE.GetModuleFileNameExA(process, handle, buffer, buffer.length); - // 截取字符串，去除多余的字节，得到模块文件名 + // 截取字符串，去除多余的字节，得到模块文件名，调用 `ArrayUtil.sub` 方法（这应该是某个工具类中用于操作字节数组的方法，可能来自于如 `hutool` 等工具库）， + // 传入字节数组 `buffer`、起始索引0以及通过 `ArrayUtil.indexOf` 方法（同样来自相关工具库，用于查找字节数组中特定字节第一次出现的索引位置）找到的字节数组中第一个空字符（字节值为0，表示字符串结束）的索引位置作为参数， + // 从 `buffer` 字节数组中截取从起始到第一个空字符之前的部分，去除了可能多余的空字符及后面无效的字节，得到真正有效的模块文件名字节数组 `trimmedBytes`。 byte[] trimmedBytes = ArrayUtil.sub(buffer, 0, ArrayUtil.indexOf(buffer, (byte) 0)); - // 获得文件名 + // 获得文件名，通过使用 `String` 的构造函数，传入截取后的有效字节数组 `trimmedBytes` 以及默认的字符编码（通过 `Charset.defaultCharset()` 获取，通常是系统默认的字符编码方式）作为参数， + // 将字节数组转换为字符串形式，得到模块的文件名，存储在 `fileName` 变量中，方便后续进行文件名的匹配判断操作。 String fileName = new String(trimmedBytes, Charset.defaultCharset()); - // 判断模块文件名是否以指定的模块名结尾 + // 判断模块文件名是否以指定的模块名结尾，通过调用 `fileName` 字符串的 `endsWith` 方法，传入要匹配的模块名（`WeChatServiceImpl.MODULE_NAME`，这是在类中定义的常量，表示特定的模块名称）作为参数， + // 判断当前模块的文件名是否以这个指定的模块名结尾，如果满足这个条件，则说明找到了符合要求的模块，直接返回当前模块对应的 `moduleInfo` 对象，包含了该模块的详细信息，方法执行结束。 if (fileName.endsWith(WeChatServiceImpl.MODULE_NAME)) { return moduleInfo; } } - // 未找到匹配的模块，返回 null + // 未找到匹配的模块，返回 null，如果在遍历完 `moduleInfos` 列表中所有模块后，都没有找到文件名以指定模块名结尾的模块， + // 则表示未检索到符合要求的模块信息，此时返回 `null`，供调用该方法的地方根据返回值进行相应的处理，比如提示用户或者进行其他逻辑判断等操作。 return null; } @@ -503,35 +711,60 @@ public class WeChatServiceImpl implements WeChatService { * @param pattern 要扫描的模式字节数组 * @return 包含匹配的内存地址的列表 */ + /** + * 在指定进程的模块中按照特定模式扫描内存地址的方法。 + * 该方法首先获取指定进程中特定模块的信息，确定模块的基址和最大地址范围，然后在这个模块的内存范围内逐页进行模式扫描， + * 将扫描到符合给定模式的内存地址添加到列表中，最后返回包含所有找到的内存地址的列表，若模块不存在或者未扫描到匹配地址则返回空列表。 + * + * @param process 指定的进程句柄，以 `WinNT.HANDLE` 类型传入，代表已经打开且具有相应访问权限的目标进程， + * 此句柄用于后续与该进程交互，例如读取其模块内存等操作，是整个方法操作针对的具体进程对象，由外部调用时传入（通常是先通过 `OpenProcess` 等方法打开进程获取到的）。 + * @param pattern 要扫描的字节模式，以字节数组形式传入，代表在模块内存中期望匹配的特定字节序列模式， + * 方法会在模块的内存范围内查找出现这个字节模式的位置，将其对应的内存地址记录下来并返回。 + * @return 返回一个包含 `Pointer` 类型元素的列表，列表中的每个 `Pointer` 指向在模块内存中扫描到符合给定模式的内存地址， + * 若在扫描过程中没有找到任何匹配的内存地址（比如模块不存在或者模块内存中确实不存在符合模式的情况），则返回一个空列表，表示未发现符合要求的内存地址。 + */ private List patternScanModule(WinNT.HANDLE process, byte[] pattern) { - // 用于存储找到的内存地址的列表 + // 用于存储找到的内存地址的列表，创建一个空的 `List` 类型列表 `foundPointers`，用于后续存储在模块内存中扫描到符合给定模式的内存地址， + // 初始时列表为空，随着扫描过程中发现匹配的地址会将对应的 `Pointer` 对象添加到这个列表中。 List foundPointers = new ArrayList<>(); - // 通过模块名检索指定进程加载的模块信息 + // 通过模块名检索指定进程加载的模块信息，调用 `moduleFromName` 方法，传入目标进程句柄（`process`）作为参数， + // 该方法会尝试在进程已加载的模块中查找文件名以特定名称（在 `moduleFromName` 方法中定义的相关模块名，例如微信相关的特定模块名等）结尾的模块， + // 并返回对应的 `Psapi.MODULEINFO` 对象，这个对象包含了模块的详细信息（如基址、大小等），将返回的模块信息存储在 `moduleInfo` 变量中，作为后续扫描操作的基础。 Psapi.MODULEINFO moduleInfo = moduleFromName(process); - // 空校验 + // 空校验，判断通过 `moduleFromName` 方法获取到的模块信息是否为 `null`，如果是 `null` 则表示没有找到符合要求的模块， + // 此时直接返回当前的空 `foundPointers` 列表，表示无法进行内存地址扫描操作，方法执行结束，因为没有对应的模块就不存在可扫描的内存范围了。 if (moduleInfo == null) { return foundPointers; } - // 获取模块基址和模块最大地址 + // 获取模块基址和模块最大地址，通过 `Pointer.nativeValue` 方法将模块信息（`moduleInfo`）中的模块基址（`lpBaseOfDll` 成员变量，表示模块在进程内存空间中的起始地址）转换为长整型数值， + // 得到模块的基址 `baseAddress`，然后通过计算模块基址加上模块的镜像大小（`moduleInfo.SizeOfImage` 表示模块在内存中的占用空间大小）得到模块内存范围的最大地址 `maxAddress`， + // 同时将模块基址赋值给 `pageAddress`，用于后续在模块内存范围内逐页进行扫描操作时作为起始扫描地址，`pageAddress` 会随着扫描的推进不断更新。 long baseAddress = Pointer.nativeValue(moduleInfo.lpBaseOfDll); long maxAddress = Pointer.nativeValue(moduleInfo.lpBaseOfDll) + moduleInfo.SizeOfImage; long pageAddress = baseAddress; - // 循环扫描模块内存页 + // 循环扫描模块内存页，通过 `while` 循环，只要当前扫描的页面地址（`pageAddress`）小于模块内存的最大地址（`maxAddress`），就持续进行循环扫描操作， + // 在每次循环中对当前内存页面进行模式扫描，获取下一次扫描的起始地址以及该页面内匹配模式的内存地址列表，然后更新 `pageAddress` 继续下一轮扫描，直到扫描完整个模块内存范围。 while (pageAddress < maxAddress) { - // 扫描当前页的模式，并返回下一个扫描的起始地址和匹配的内存地址列表 + // 扫描当前页的模式，并返回下一个扫描的起始地址和匹配的内存地址列表，调用 `scanPatternPage` 方法，传入目标进程句柄（`process`）、当前扫描的页面起始地址（`pageAddress`）以及要扫描的字节模式（`pattern`）作为参数， + // 该方法会在当前内存页面内按照给定的字节模式进行扫描，返回一个包含两个元素的 `Pair` 对象，其中第一个元素是下一次扫描应该从哪个地址开始（可能是本页扫描完后下一页的起始地址等情况）， + // 第二个元素是一个包含 `Pointer` 类型的列表，表示在当前页面内扫描到符合给定模式的内存地址列表，将返回的 `Pair` 对象存储在 `pair` 变量中，方便后续提取相关信息进行操作。 Pair> pair = scanPatternPage(process, pageAddress, pattern); pageAddress = pair.getLeft(); - // 如果找到了匹配的内存地址，则添加到列表中 + // 如果找到了匹配的内存地址，则添加到列表中，判断 `pair` 对象中获取到的匹配内存地址列表（`pair.getRight()`）是否不为 `null`， + // 如果不为 `null` 说明在当前页面内找到了符合模式的内存地址，通过调用 `foundPointers.addAll` 方法将这些找到的内存地址全部添加到 `foundPointers` 列表中，完成一次页面扫描的地址收集操作， + // 后续继续循环扫描下一个页面，重复此过程，直到扫描完整个模块内存范围。 if (pair.getRight() != null) { foundPointers.addAll(pair.getRight()); } } - // 返回找到的内存地址列表 + + // 返回找到的内存地址列表，在扫描完整个模块内存范围后，将包含所有找到的符合给定模式的内存地址的 `foundPointers` 列表返回， + // 调用该方法的地方可以根据返回的列表进行后续操作，比如基于这些地址进一步读取内存数据或者进行其他相关逻辑处理等。 return foundPointers; } @@ -541,66 +774,66 @@ public class WeChatServiceImpl implements WeChatService { * @return 微信文件目录 */ public String getBasePath() { - // 默认微信文件路径设为 "MyDocument:" + // 默认微信文件路径设为 "MyDocument:"，这里的MY_DOCUMENT应该是一个预定义的常量，表示默认路径 String wechatDir = MY_DOCUMENT; - // 是否读取成功的标记 + // 是否读取成功的标记，初始化为false，表示尚未成功读取到微信文件路径 boolean readSuccess = false; + // 尝试从注册表读取WeChat的文件保存路径 try { - // 尝试从注册表读取 WeChat 的文件保存路径 + // 检查注册表中是否存在指定的WeChat相关键值，WinReg.HKEY_CURRENT_USER表示当前用户根键，WECHAT_REG_PATH是WeChat在注册表中的路径 if (Advapi32Util.registryKeyExists(WinReg.HKEY_CURRENT_USER, WECHAT_REG_PATH)) { - // 如果成功读取，设置 wechatDir 为读取的路径 + // 如果成功读取，设置wechatDir为读取的路径，通过Advapi32Util工具类从注册表获取指定键对应的值，FILE_SAVE_PATH可能是注册表中保存文件路径的键名 wechatDir = Advapi32Util.registryGetStringValue(WinReg.HKEY_CURRENT_USER, WECHAT_REG_PATH, FILE_SAVE_PATH); // 标记为读取成功 readSuccess = true; } } catch (Exception ignore) { - // 如果读取失败，设路径为 "MyDocument:" + // 如果读取注册表过程中出现异常，忽略异常，并将路径设为默认的 "MyDocument:"，也就是恢复初始的默认路径设置 wechatDir = MY_DOCUMENT; } - // 如果从注册表读取失败，尝试从配置文件读取 try { if (!readSuccess) { - // 获取用户主目录 + // 获取用户主目录，USERPROFILE是系统环境变量，表示当前用户的主目录路径 String userProfile = System.getenv("USERPROFILE"); - // 拼接 WeChat 配置文件的完整路径 + // 拼接WeChat配置文件的完整路径，CONFIG_FILE_PATH应该是相对于用户主目录的配置文件路径字符串，通过字符串拼接形成完整路径 String configPath = userProfile + CONFIG_FILE_PATH; - // 读取配置文件的所有行 + // 读取配置文件的所有行，通过Files.readAllLines方法读取指定路径的文件内容，并以行的形式返回一个List List lines = Files.readAllLines(Paths.get(configPath)); if (!lines.isEmpty()) { - // 如果文件不为空，设置 wechatDir 为读取的第一行内容 + // 如果文件不为空，设置wechatDir为读取的第一行内容，也就是取配置文件中的第一行作为微信文件路径 wechatDir = lines.get(0); } } } catch (IOException e) { - // 如果读取失败，设路径为 "MyDocument:" + // 如果读取配置文件过程中出现IO异常，将路径设为默认的 "MyDocument:" wechatDir = MY_DOCUMENT; } // 如果路径为 "MyDocument:"，尝试设置为Documents目录 if (MY_DOCUMENT.equals(wechatDir)) { try { - // 获取文档目录路径 + // 获取文档目录路径，创建一个足够长度的字符数组来存储路径，WinDef.MAX_PATH通常表示系统定义的最大路径长度 char[] documentsPath = new char[WinDef.MAX_PATH]; - // 尝试获取文档目录路径 + // 尝试获取文档目录路径，通过Shell32.INSTANCE.SHGetFolderPath方法获取指定类型的系统文件夹路径，这里获取个人文件夹（通常是Documents文件夹）路径，参数依次表示所有者窗口、文件夹类型、访问令牌等相关信息 int documentsPathSuccess = Shell32.INSTANCE.SHGetFolderPath(null, ShlObj.CSIDL_PERSONAL, null, ShlObj.SHGFP_TYPE_CURRENT, documentsPath).intValue(); // 如果成功获取文档目录路径 if (documentsPathSuccess == WinError.S_OK.intValue()) { - // 成功获取文档目录路径后，设置 wechatDir 为文档目录路径 + // 成功获取文档目录路径后，设置wechatDir为文档目录路径，通过Native.toString方法将字符数组转换为字符串形式的路径 wechatDir = Native.toString(documentsPath); } else { - // 如果获取失败，设置路径为用户主目录下的 "Documents" + // 如果获取失败，设置路径为用户主目录下的 "Documents"，通过字符串拼接的方式构建路径 wechatDir = System.getenv("USERPROFILE") + "\\Documents"; } } catch (Exception e) { - // 如果获取失败，设置路径为用户主目录下的 "Documents" + // 如果获取过程中出现异常，同样设置路径为用户主目录下的 "Documents" wechatDir = System.getenv("USERPROFILE") + "\\Documents"; } } - // 拼接 WeChat 文件目录路径 + // 拼接WeChat文件目录路径，WECHAT_FILES_DIR应该是WeChat文件所在目录相对于前面获取的基础路径的相对路径，将其与wechatDir拼接起来返回最终的微信文件目录路径 return wechatDir + WECHAT_FILES_DIR; } @@ -612,145 +845,173 @@ public class WeChatServiceImpl implements WeChatService { */ @Override public String getWxId(int pid) { - // 获取Kernel32实例 + // 获取Kernel32实例，Kernel32通常是用于操作Windows系统底层相关功能的类，这里获取其单例实例，以便后续调用相关系统函数 Kernel32 kernel32 = Kernel32.INSTANCE; - // 打开目标进程句柄 + + // 打开目标进程句柄，通过调用OpenProcess函数，参数0x1F0FFF表示访问权限相关的标志组合（具体权限含义需参照Windows系统相关文档），false表示不继承句柄，pid是传入的目标进程的ID WinNT.HANDLE process = kernel32.OpenProcess(0x1F0FFF, false, pid); - // 设置要匹配的模式字符串 + + // 设置要匹配的模式字符串，这里的模式 "\\Msg\\FTSContact" 可能是用于在进程内存中查找特定内容的特征字符串，具体匹配规则应该由patternScanAll方法定义 String pattern = "\\Msg\\FTSContact"; - // 在目标进程中扫描符合模式的内存位置 + + // 在目标进程中扫描符合模式的内存位置，调用patternScanAll方法进行扫描，返回匹配到的内存地址列表，参数10可能是与扫描范围、深度或者其他相关的控制参数（具体取决于该方法的实现） List addresses = patternScanAll(process, pattern, 10); - // 遍历匹配到的内存位置 + + // 遍历匹配到的内存位置，准备逐个分析这些位置上的数据以提取微信ID for (Pointer address : addresses) { - // 分配内存作为缓冲区读取数据 + // 分配内存作为缓冲区读取数据，设置缓冲区大小为80字节，用于后续从进程内存读取数据暂存到这里 int bufferSize = 80; Memory buffer = new Memory(bufferSize); IntByReference read = new IntByReference(); - // 从指定地址的前一部分开始读取内存，而不是从地址的确切位置开始。 + + // 从指定地址的前一部分开始读取内存，而不是从地址的确切位置开始，通过创建一个新的指针，其值为原地址值减去30，可能是根据内存数据结构特点，认为需要从这个偏移位置开始读取才有意义（具体取决于微信内存布局相关情况） Pointer offsetPointer = new Pointer(Pointer.nativeValue(address) - 30); - // 从指定地址读取内存数据 + + // 从指定地址读取内存数据，调用ReadProcessMemory函数尝试从目标进程内存的指定位置（offsetPointer指向的位置）读取数据到缓冲区buffer中，bufferSize指定读取的最大字节数，read用于返回实际读取的字节数 boolean success = kernel32.ReadProcessMemory(process, offsetPointer, buffer, bufferSize, read); + if (success) { - // 将读取的字节转换为字符串 + // 将读取的字节转换为字符串，先获取缓冲区中实际读取到的字节数组，然后使用Java的String构造函数将字节数组转换为字符串，指定正确的字符编码（这里使用默认编码，可能存在编码问题，可根据实际情况调整）和字节长度（read.getValue()表示实际读取的字节数） byte[] dataBytes = buffer.getByteArray(0, read.getValue()); String data = new String(dataBytes, 0, read.getValue()); - // 对字符串进行处理，提取微信ID信息 + + // 对字符串进行处理，提取微信ID信息，通过以 "\\Msg" 为分隔符进行分割，取分割后的第一部分，可能是认为微信ID相关信息在这之前的部分 data = data.split("\\\\Msg")[0]; - // 通过文件分隔符分割 + + // 通过文件分隔符（在Java中为 "\\"）分割字符串，目的可能是进一步细化提取微信ID的操作，将字符串按照文件路径类似的格式进行拆分 String[] newData = data.split("\\\\"); - // 取最后一个为微信Id + + // 取最后一个为微信Id，根据前面的分割逻辑，认为最后一个元素就是所需的微信ID，将其返回 return newData[newData.length - 1]; } } - // 关闭目标进程句柄 + + // 关闭目标进程句柄，操作完成后释放打开的进程句柄资源，调用CloseHandle函数进行关闭 kernel32.CloseHandle(process); - // 返回空 + + // 如果遍历完所有匹配的内存位置都没有成功提取到微信ID，则返回空，表示获取失败 return null; } /** * 在指定进程的虚拟地址空间中扫描所有符合指定模式的内存位置。 * - * @param process 指定进程的句柄 - * @param pattern 要匹配的模式字符串 - * @param findNum 最大匹配数量 - * @return 符合模式的内存位置列表 + * @param process 指定进程的句柄，通过该句柄来访问对应进程的虚拟地址空间等相关资源 + * @param pattern 要匹配的模式字符串，用于在进程内存中查找与之匹配的内容，具体匹配规则应该在内部的扫描逻辑中有相应定义 + * @param findNum 最大匹配数量，即控制最多找到多少个符合模式的内存位置后就停止扫描 + * @return 符合模式的内存位置列表，返回找到的所有符合要求的内存位置信息，以列表形式存储 */ public List patternScanAll(WinNT.HANDLE process, String pattern, int findNum) { - // 存储符合模式的内存位置列表 + // 存储符合模式的内存位置列表，初始化一个空的ArrayList，后续将把扫描到的符合要求的内存位置指针添加到这个列表中 List found = new ArrayList<>(); - // 根据系统架构设置用户空间限制 + + // 根据系统架构设置用户空间限制，通过获取系统属性 "os.arch" 判断系统架构，如果是 "amd64" 架构，设置用户空间限制为 0x7FFFFFFF0000L，否则（比如可能是32位架构等情况）设置为 0x7FFF0000L，这个限制用于界定扫描的虚拟地址空间范围 long userSpaceLimit = "amd64".equals(System.getProperty("os.arch")) ? 0x7FFFFFFF0000L : 0x7FFF0000L; - // 初始下一个扫描位置 + + // 初始下一个扫描位置，从虚拟地址空间的起始位置 0 开始扫描（通常情况下，初始化为 0 便于从头开始遍历地址空间查找匹配内容） long nextRegion = 0; - // 循环扫描直到达到用户空间限制或找到足够的匹配位置 + + // 循环扫描直到达到用户空间限制或找到足够的匹配位置，通过这个循环不断在进程的虚拟地址空间内按页进行扫描查找符合模式的内存位置 while (nextRegion < userSpaceLimit) { - // 执行单页扫描，获取扫描结果 + // 执行单页扫描，获取扫描结果，调用scanPatternPage方法对当前区域（以nextRegion指定起始位置）进行单页扫描，传入进程句柄、起始位置以及模式字符串对应的字节数组（将字符串转换为字节数组以便在底层进行匹配操作），返回一个包含下一个扫描位置和本页扫描匹配到的内存位置列表的Pair对象 Pair> pair = scanPatternPage(process, nextRegion, pattern.getBytes()); - // 更新下一个扫描位置 + + // 更新下一个扫描位置，从pair对象中获取下一个应该扫描的起始位置，以便继续在下一区域进行扫描查找 nextRegion = pair.getLeft(); - // 获取单页扫描的匹配位置列表 + + // 获取单页扫描的匹配位置列表，从pair对象中获取本页扫描得到的符合模式的内存位置列表 List pageFound = pair.getRight(); - // 如果单页扫描找到匹配位置，将其添加到总的匹配位置列表中 + // 如果单页扫描找到匹配位置，将其添加到总的匹配位置列表中，把本页扫描到的所有符合模式的内存位置添加到总的匹配位置列表found中，用于汇总所有扫描到的结果 if (!pageFound.isEmpty()) { found.addAll(pageFound); } - // 如果找到足够的匹配位置，跳出循环 + + // 如果找到足够的匹配位置，跳出循环，当已经找到的匹配位置数量超过了设定的最大匹配数量findNum时，就停止扫描循环，结束整个扫描过程 if (found.size() > findNum) { break; } } - // 返回符合模式的内存位置列表 + + // 返回符合模式的内存位置列表，将汇总后的所有符合模式的内存位置列表返回给调用者，完成整个扫描并返回结果的操作 return found; } /** * 扫描内存页 * - * @param process 指定进程的句柄 - * @param startAddress 开始的内存地址 - * @param pattern 要匹配的模式字符串 - * @return Pair + * @param process 指定进程的句柄，通过该句柄可以对相应进程的内存进行访问操作，比如读取内存数据、查询内存信息等 + * @param startAddress 开始的内存地址，指明从进程虚拟地址空间中的哪个位置开始进行本页的扫描操作 + * @param pattern 要匹配的模式字符串，以字节数组形式传入（通常是要在内存中查找与之匹配的内容所依据的特征模式，比如特定的字节序列等） + * @return Pair，返回一个包含两个元素的Pair对象，第一个元素表示下一个内存区域的起始地址（用于后续继续扫描其他区域），第二个元素是本页扫描找到的符合模式的内存位置列表 */ private Pair> scanPatternPage(WinNT.HANDLE process, long startAddress, byte[] pattern) { - // 获取内存基本信息 + // 获取内存基本信息，创建一个WinNT.MEMORY_BASIC_INFORMATION对象，用于存储查询到的指定虚拟内存地址相关的基本信息，比如内存区域的大小、状态、保护属性等 WinNT.MEMORY_BASIC_INFORMATION mbi = new WinNT.MEMORY_BASIC_INFORMATION(); - // 查询指定虚拟内存地址 + + // 查询指定虚拟内存地址，通过调用Kernel32.INSTANCE.VirtualQueryEx函数，传入进程句柄、要查询的起始内存地址（包装成Pointer类型）以及用于存储信息的mbi对象和其大小信息，来获取该起始地址对应的内存区域的基本情况 Kernel32.INSTANCE.VirtualQueryEx(process, new Pointer(startAddress), mbi, new BaseTSD.SIZE_T(mbi.size())); - // 计算下一个内存区域的起始地址 + + // 计算下一个内存区域的起始地址，根据当前内存区域的基地址（mbi.baseAddress）和区域大小（mbi.regionSize）来计算下一个内存区域应该从哪里开始，一般是当前区域结束后的位置，为后续继续扫描做准备 long nextRegion = Pointer.nativeValue(mbi.baseAddress) + mbi.regionSize.longValue(); - // 定义允许的内存保护标志 + + // 定义允许的内存保护标志，创建一个整数数组，列举出了允许进行扫描匹配操作的内存页面所具有的保护属性，例如可执行、可读可写等，只有符合这些保护属性的内存区域才会进一步进行模式匹配操作 int[] allowedProtections = {WinNT.PAGE_EXECUTE, WinNT.PAGE_EXECUTE_READ, WinNT.PAGE_EXECUTE_READWRITE, WinNT.PAGE_READWRITE, WinNT.PAGE_READONLY}; List foundPointer = new ArrayList<>(); - // 检查内存状态和保护标志是否符合要求 + // 检查内存状态和保护标志是否符合要求，判断当前内存区域的状态是否为已提交（MEM_COMMIT表示内存已分配且可访问）且其保护属性是否在允许的保护标志列表中，如果不满足条件，则直接返回包含下一个区域起始地址和空的匹配位置列表的Pair对象，意味着跳过本页的后续扫描操作 if (!(mbi.state.intValue() == WinNT.MEM_COMMIT && ArrayUtil.contains(allowedProtections, mbi.protect.intValue()))) { return Pair.of(nextRegion, foundPointer); } - // 创建一个 Native Memory 对象，用于存储从进程中读取的内存数据 + // 创建一个 Native Memory 对象，用于存储从进程中读取的内存数据，根据前面查询到的内存区域大小创建一个足够容量的Memory对象，以便后续将从进程内存中读取的数据存储到这里 Memory memory = new Memory(mbi.regionSize.intValue()); - // 创建一个引用对象，用于存储 ReadProcessMemory 函数返回的已读取字节数 + // 创建一个引用对象，用于存储ReadProcessMemory函数返回的已读取字节数，通过IntByReference对象可以在调用ReadProcessMemory后获取实际读取到的字节数量信息 IntByReference bytesRead = new IntByReference(); - // 从指定进程中读取内存数据，并将结果存储到 Native Memory 对象中 + + // 从指定进程中读取内存数据，并将结果存储到Native Memory对象中，调用Kernel32.INSTANCE.ReadProcessMemory函数，从指定进程（process）的指定起始地址（startAddress）读取内存数据，将数据存储到memory对象中，读取的最大字节数依据内存区域大小（mbi.regionSize.intValue()）来确定，同时通过bytesRead对象获取实际读取的字节数 Kernel32.INSTANCE.ReadProcessMemory(process, new Pointer(startAddress), memory, mbi.regionSize.intValue(), bytesRead); - // 从 Native Memory 对象中获取已读取的字节数，并创建一个字节数组存储读取的内存数据 + + // 从Native Memory对象中获取已读取的字节数，并创建一个字节数组存储读取的内存数据，从memory对象中获取实际读取到的字节数据，存放到新创建的字节数组buffer中，方便后续在这些数据中查找匹配的模式 byte[] buffer = memory.getByteArray(0, bytesRead.getValue()); - // 查找匹配的模式在内存中的起始位置 + // 查找匹配的模式在内存中的起始位置，调用findMatches函数在读取到的字节数组buffer中查找与传入的模式pattern匹配的起始位置，对于每个找到的起始位置，将其对应的内存地址（相对于本页起始地址startAddress的偏移量加上startAddress得到绝对地址）添加到foundPointer列表中，表示找到了符合模式的内存位置 for (int start : findMatches(buffer, pattern)) { foundPointer.add(new Pointer(startAddress + start)); } + + // 返回Pair对象，包含下一个内存区域的起始地址（用于后续扫描流程继续推进到下一个区域）以及本页扫描找到的符合模式的所有内存位置列表，完成本页扫描并返回结果的操作 return Pair.of(nextRegion, foundPointer); } /** * 在字节数组中查找匹配指定模式的位置索引数组。 * - * @param inputBytes 待查找的字节数组 - * @param patternBytes 要匹配的模式字节数组 - * @return 匹配位置索引数组 + * @param inputBytes 待查找的字节数组，也就是要在这个字节数组中去寻找是否存在与指定模式相匹配的部分 + * @param patternBytes 要匹配的模式字节数组，代表了期望在inputBytes中找到的特定字节序列模式 + * @return 匹配位置索引数组，返回一个整数数组，数组中的每个元素表示在inputBytes中找到的与patternBytes匹配的子数组的起始位置索引 */ private int[] findMatches(byte[] inputBytes, byte[] patternBytes) { - // 初始化匹配位置索引数组 + // 初始化匹配位置索引数组，先创建一个长度为0的空数组，后续会根据实际找到的匹配位置数量动态调整其大小并添加相应的索引值 int[] matches = new int[0]; - // 遍历待查找的字节数组 + // 遍历待查找的字节数组，从索引0开始，直到可以完整匹配模式字节数组的最后一个可能位置（即inputBytes长度减去patternBytes长度的位置，再往后就不够匹配整个模式了），每次循环检查当前位置开始是否能匹配上模式字节数组 for (int i = 0; i <= inputBytes.length - patternBytes.length; i++) { - // 假设当前位置开始存在匹配 + // 假设当前位置开始存在匹配，先默认当前位置开始的子数组与模式字节数组是匹配的，后续通过内层循环来验证这个假设是否成立 boolean match = true; - // 遍历模式字节数组，检查是否与待查找的子数组匹配 + // 遍历模式字节数组，检查是否与待查找的子数组匹配，从模式字节数组的索引0开始，逐个字节对比当前待查找字节数组中从i位置开始的对应字节，看是否完全一致 for (int j = 0; j < patternBytes.length; j++) { if (inputBytes[i + j] != patternBytes[j]) { - // 如果有不匹配的字节，标记为不匹配，并中断内层循环 + // 如果有不匹配的字节，标记为不匹配，并中断内层循环，一旦发现某个字节不一致，就说明从当前i位置开始不匹配模式字节数组，将match标记为false，并跳出内层循环，继续检查下一个i位置 match = false; break; } } - // 如果找到匹配的位置，将其添加到匹配位置索引数组中 + + // 如果找到匹配的位置，将其添加到匹配位置索引数组中，如果经过内层循环验证当前位置确实匹配成功（match为true），则需要把这个匹配位置的索引i添加到matches数组中。 + // 由于Java数组长度不可变，这里先创建一个新的长度比原数组大1的数组newMatches，然后将原数组matches中的元素复制到新数组对应位置，最后把新的匹配位置索引i添加到新数组末尾，再将新数组赋值给matches，完成匹配位置索引的添加操作 if (match) { int[] newMatches = new int[matches.length + 1]; System.arraycopy(matches, 0, newMatches, 0, matches.length); @@ -758,7 +1019,8 @@ public class WeChatServiceImpl implements WeChatService { matches = newMatches; } } - // 返回匹配位置索引数组 + + // 返回匹配位置索引数组，将最终包含所有匹配位置索引的数组返回给调用者，完成整个查找匹配位置索引的功能 return matches; } @@ -771,40 +1033,46 @@ public class WeChatServiceImpl implements WeChatService { @Override public String getVersion(int pid) { // 获取指定进程ID的可执行文件路径。 + // 调用名为getExecutablePath的方法（此处未展示其具体实现，但推测是根据进程ID查找对应可执行文件在磁盘上的存储路径）， + // 该路径将作为后续获取文件版本信息的基础，因为所有与文件版本相关的操作都需要基于正确的文件路径来进行。 + String filePath = getExecutablePath(pid); // 用于存储 'GetFileVersionInfoSize' 函数的额外信息（通常未使用）。 + // 被用于传递引用类型的数据（在Java中模拟类似C语言中的指针传递效果），并将其初始值设为0， IntByReference dwDummy = new IntByReference(); dwDummy.setValue(0); // 获取文件版本信息的大小。 + //通过Version.INSTANCE调用GetFileVersionInfoSize函数，这是Windows系统提供的用于获取文件版本信息大小的API函数， + // 通过JNA机制在Java中进行调用。传入文件路径（filePath）以及前面创建的用于接收额外信息的对象（dwDummy）， int versionLength = Version.INSTANCE.GetFileVersionInfoSize(filePath, dwDummy); - // 如果长度为0，表示没有版本信息。 + // 如果长度为0，表示没有版本信息。若返回的版本信息长度为0，意味着该文件不存在版本信息或者无法获取到版本信息，此时直接返回null，表示获取失败。 if (versionLength == 0) { return null; } - // 分配足够存储文件版本信息的缓冲区。 + // 分配足够存储文件版本信息的缓冲区。根据前面获取到的版本信息长度versionLength，创建一个字节数组buffer，用于后续存储从文件中读取出来的版本信息内容，确保缓冲区大小足够容纳这些信息。 byte[] buffer = new byte[versionLength]; - // 使用 JNA 的 Memory 类将缓冲区映射到内存。 + // 使用 JNA 的 Memory 类将缓冲区映射到内存。创建一个Pointer对象，通过JNA（Java Native Access）的Memory类将前面创建的字节数组buffer映射到内存中，方便后续与Windows API进行交互，以操作这些内存数据来获取文件版本信息（这是JNA操作内存的一种常见方式）。 Pointer lpData = new Memory(buffer.length); - // 获取文件版本信息。 + // 获取文件版本信息。调用Version.INSTANCE.GetFileVersionInfo函数，尝试从指定文件路径filePath处获取文件版本信息，传入相关参数（如起始位置设为0，信息长度为versionLength以及映射到内存的指针lpData），若获取失败（函数返回false），则返回null，表示无法获取到版本信息。 if (!Version.INSTANCE.GetFileVersionInfo(filePath, 0, versionLength, lpData)) { return null; } - // 用于存储 'VerQueryValue' 函数输出的文件版本信息指针。 + // 用于存储 'VerQueryValue' 函数输出的文件版本信息指针。创建一个PointerByReference对象，用于在后续调用VerQueryValue函数时接收返回的指向文件版本信息具体内容的指针（因为文件版本信息可能是一个较为复杂的数据结构，通过指针来定位具体部分）。 PointerByReference lplpBuffer = new PointerByReference(); - // 用于存储 'VerQueryValue' 函数输出的文件版本信息长度。 + // 用于存储 'VerQueryValue' 函数输出的文件版本信息长度。创建一个IntByReference对象，用于接收VerQueryValue函数返回的文件版本信息的实际长度，便于后续准确处理该部分信息。 IntByReference puLen = new IntByReference(); - // 查询具体的文件版本信息。 + // 查询具体的文件版本信息。调用Version.INSTANCE.VerQueryValue函数，尝试从已经获取到的内存中的文件版本信息（由lpData指向）里查询具体的版本相关内容，传入特定的查询路径（此处是"\\"，表示根路径，按相关规范来查询整体版本信息）以及前面创建的用于接收指针和长度的对象，如果查询成功（函数返回true），则进行后续的版本信息提取操作。 if (Version.INSTANCE.VerQueryValue(lpData, "\\", lplpBuffer, puLen)) { - // 将指针映射到 VS_FIXEDFILEINFO 结构。 + // 将指针映射到 VS_FIXEDFILEINFO 结构。通过获取到的指向版本信息的指针lplpBuffer.getValue()，创建一个VerRsrc.VS_FIXEDFILEINFO对象，将其与对应的内存位置关联起来，以便按照该结构定义来读取和解析版本信息（VS_FIXEDFILEINFO是Windows系统中定义的用于存储文件固定版本信息的结构体，这里通过JNA与之对应起来进行操作）。 VerRsrc.VS_FIXEDFILEINFO lplpBufStructure = new VerRsrc.VS_FIXEDFILEINFO(lplpBuffer.getValue()); lplpBufStructure.read(); - // 提取文件版本的主要部分和次要部分。 + // 提取文件版本的主要部分和次要部分。按照VS_FIXEDFILEINFO结构体中定义的成员变量（dwFileVersionMS和dwFileVersionLS分别存储了版本号的高位和低位部分），通过位运算提取出文件版本的四个部分，分别对应主版本号、次版本号等不同的版本分级（具体含义和格式遵循Windows系统对文件版本号的定义）。 long v1 = (lplpBufStructure.dwFileVersionMS.longValue() >> 16) & 0xffff; long v2 = lplpBufStructure.dwFileVersionMS.longValue() & 0xffff; long v3 = (lplpBufStructure.dwFileVersionLS.longValue() >> 16) & 0xffff; @@ -820,52 +1088,84 @@ public class WeChatServiceImpl implements WeChatService { /** * 获取给定进程ID的可执行文件路径。 + * 该方法的主要功能是依据传入的进程ID，借助Windows操作系统提供的相关API，尝试获取对应进程所关联的可执行文件的完整路径信息。 + * 如果在整个获取过程中，由于诸如权限不足、函数调用失败等原因，导致无法成功得到可执行文件的路径，那么将会返回null作为结果。 * - * @param pid 进程ID。 - * @return 可执行文件的完整路径，如果无法获取，则返回 null。 + * @param pid 进程ID。这是一个能够在操作系统层面唯一标识正在运行进程的整数值，通过它可以精准定位到特定的进程，进而去查找与之对应的可执行文件的具体存储位置路径。 + * @return 可执行文件的完整路径，如果无法获取，则返回 null。最终返回值为表示文件完整存储位置的字符串，例如 "C:\\Program Files\\SomeApp\\SomeApp.exe" 这样的格式；要是获取过程出现问题，未能成功获取到路径信息，就返回null给调用者来表明获取失败的情况。 */ private String getExecutablePath(int pid) { // 获取 Kernel32 实例，用于访问 Windows API 函数。 + // Kernel32是在Java中通过Java Native Access（JNA）方式来调用Windows系统底层API时常用的一个类，它相当于一个入口，提供了众多Windows API函数的调用接口。 + // 通过其INSTANCE属性获取单例实例，后续就能利用这个实例去调用各种Windows系统相关的函数，例如打开进程、查询进程信息以及操作进程相关资源等操作都依赖于此来与Windows操作系统底层进行交互。 Kernel32 kernel32 = Kernel32.INSTANCE; // 打开进程以查询信息。PROCESS_QUERY_INFORMATION 和 PROCESS_VM_READ // 是所需的访问权限，以获取进程的可执行文件路径。 + // 调用OpenProcess函数来尝试打开指定的进程，该函数需要传入几个关键参数。其中，WinNT.PROCESS_QUERY_INFORMATION | WinNT.PROCESS_VM_READ这个参数组合表示了对目标进程所需要的访问权限设定。 + // PROCESS_QUERY_INFORMATION权限允许当前代码去查询进程的各类相关信息，像这里要获取的可执行文件路径就依赖于这个权限；而PROCESS_VM_READ权限则使得可以读取进程的虚拟内存内容（虽然在这里主要目的是获取文件路径，但有些获取路径的实现机制可能涉及到读取内存相关操作，所以需要这个权限）。 + // 第二个参数false表示不需要继承句柄，在Windows操作系统多进程环境下，句柄的继承特性有其特定应用场景，这里我们不需要开启这个特性，所以设为false。 + // 最后传入的pid参数明确指定了要打开的是哪个进程，也就是与传入的这个进程ID相对应的进程。函数执行后会返回一个WinNT.HANDLE类型的进程句柄，这个句柄就像是一把“钥匙”，后续会通过它来对打开的这个进程进行各种查询等相关操作。 WinNT.HANDLE process = kernel32.OpenProcess(WinNT.PROCESS_QUERY_INFORMATION | WinNT.PROCESS_VM_READ, false, pid); try { // 确保成功获取到进程句柄。 + // 对前面通过OpenProcess函数获取到的进程句柄进行判断，只有当进程句柄不为null时，才说明成功打开了对应的目标进程，这样才有条件继续后续获取可执行文件路径的操作； + // 如果进程句柄为null，那就意味着打开进程这个步骤出现了问题，可能是因为当前代码运行的环境没有足够的权限、指定的进程ID对应的进程不存在或者其他一些异常情况导致的，这种情况下自然就没办法继续往下进行获取路径的流程了。 if (process != null) { // 分配字符数组以存储路径。 + // 创建一个字符数组path，其长度设定为WinDef.MAX_PATH，WinDef.MAX_PATH通常是Windows操作系统预先定义好的一个常量，代表了系统中路径字符串所能达到的最大长度。 + // 这么做是为了确保创建的这个数组有足够的空间来容纳可能很长的可执行文件路径字符串，防止出现因为数组长度不够而导致的缓冲区溢出等错误情况，从而能安全地接收即将通过API函数获取到的路径信息。 char[] path = new char[WinDef.MAX_PATH]; // 初始化大小为路径的最大长度。 + // 将size变量初始化为path数组的长度，也就是前面提到的WinDef.MAX_PATH的值，这个size变量后续会在调用QueryFullProcessImageName函数时作为一个参数传入，用于告知函数接收路径信息的缓冲区大小情况。 int size = path.length; // 调用 QueryFullProcessImageName 获取进程的完整路径。 + // 调用Kernel32.INSTANCE.QueryFullProcessImageName函数来尝试获取目标进程的完整可执行文件路径。这个函数的作用就是从已打开的进程（通过前面获取到的process句柄指定）中查询并获取其对应的可执行文件的完整路径信息。 + // 第一个参数process就是前面打开进程得到的句柄，用于明确是针对哪个进程进行操作；第二个参数0通常是一些固定的标志位设置（在这里按照常规用法传入0即可，具体不同取值对应不同的功能扩展，可参考Windows API文档）； + // 第三个参数path就是前面创建的用于存储路径字符串的字符数组，函数会将获取到的路径信息填充到这个数组中；第四个参数new IntByReference(size)是通过JNA中的IntByReference类型创建的一个对象，用于传递size变量的引用， + // 这样函数在执行过程中如果发现实际获取到的路径长度超过了传入的初始size值（这种情况可能发生在路径很长，超出了预先估计的WinDef.MAX_PATH长度时），会通过这个引用修改size的值，以便后续代码能知晓实际获取到的路径长度情况（不过这里没有对这种情况做进一步特殊处理，只是按照常规流程来获取路径）。 boolean success = Kernel32.INSTANCE.QueryFullProcessImageName(process, 0, path, new IntByReference(size)); // 如果成功获取路径，返回路径字符串。 + // 根据QueryFullProcessImageName函数的调用结果进行判断，如果返回值success为true，那就意味着成功获取到了目标进程的可执行文件路径信息，此时就可以将存储在path字符数组中的路径信息转换为Java中的字符串类型并返回。 + // 通过new String(path)操作将字符数组转换为字符串，同时调用trim()方法去除字符串两端可能存在的空白字符（比如空格、制表符等），以确保返回的路径字符串格式规范、干净整洁，然后将处理后的路径字符串作为最终结果返回给调用者。 if (success) { return new String(path).trim(); } } } finally { // 确保在操作完成后关闭进程句柄。 + // 在Java的异常处理机制中，finally块中的代码无论try块中的操作是否发生异常，都会被执行。这里的目的就是确保在完成了对进程的相关操作（无论是成功获取到路径还是获取过程中出现了异常）之后， + // 都要关闭之前通过OpenProcess函数打开的进程句柄，释放相关的系统资源。通过判断process句柄是否为null来确定是否成功打开过进程，如果不为null，就调用kernel32.CloseHandle(process)来关闭对应的进程句柄，避免出现资源泄漏等问题。 if (process != null) { kernel32.CloseHandle(process); } } // 如果无法获取路径，返回 null。 + // 如果在前面的整个流程中，无论是打开进程失败，还是获取可执行文件路径的操作失败，最终都没能成功得到有效的路径信息，那么就按照方法的定义，返回null来告知调用者获取可执行文件路径的操作没有成功完成。 return null; } /** * 去掉点比较版本号的方法 + * 该方法的主要作用是将传入的两个版本号字符串形式的数据，通过去除其中的点号（通常版本号格式如 "1.2.3"，这里去除点号后变为 "123" 这样的纯数字形式）， + * 再将其转换为长整型（Long）数据进行大小比较，以此来判断当前版本是否小于支持的最小版本，最终返回比较结果（true表示当前版本小于支持的最小版本，false表示大于等于）。 * - * @param supportMinVersion 支持的版本 - * @param currentVersion 当前版本 - * @return true or false + * @param supportMinVersion 支持的版本，即期望应用程序所支持的最低版本号，以字符串形式传入，例如 "1.2.3" 这样符合常见版本号格式的字符串。 + * @param currentVersion 当前版本，代表当前实际的版本号，同样以字符串形式传入，格式与支持的版本号格式一致，比如 "1.3.0" 等。 + * @return true or false，返回一个布尔值，若当前版本小于支持的最小版本则返回 true，否则返回 false，表示当前版本是否满足最低版本要求。 */ private boolean compareVersions(String supportMinVersion, String currentVersion) { + // 将支持的版本号字符串中的点号去除，并转换为长整型（Long）数据。 + // 首先调用replaceAll("\\.", "")方法，使用正则表达式 "\\."（在Java字符串中，需要用双反斜杠来表示一个真正的反斜杠，所以写成 "\\." 来匹配点号）来替换掉版本号字符串中的所有点号， long supportMinVersionLong = Long.parseLong(supportMinVersion.replaceAll("\\.", "")); + // 对当前版本号执行与处理支持的版本号相同的操作，即将当前版本号字符串中的点号去除，并转换为长整型（Long）数据。 + // 同样先使用replaceAll("\\.", "")方法去除当前版本号字符串（currentVersion）中的点号，将其转换为纯数字字符串，再通过Long.parseLong()方法将其转换为长整型， + // 得到的结果存储在currentVersionLong变量中，用于和前面转换后的支持的版本号对应的长整型数据进行比较。 long currentVersionLong = Long.parseLong(currentVersion.replaceAll("\\.", "")); + // 通过比较两个长整型版本号数据的大小，返回比较结果。 + // 比较currentVersionLong和supportMinVersionLong的大小关系，如果currentVersionLong小于supportMinVersionLong， + // 则说明当前版本低于支持的最小版本，按照方法的逻辑，返回 true；否则（即当前版本大于等于支持的最小版本）返回 false，以此来告知调用者当前版本是否满足最低版本要求。 return currentVersionLong < supportMinVersionLong; } -} +} \ No newline at end of file