[Change] 将RankingMode和RankingContentType从PixivURL分离, 并增加Parser, 顺便整理单行过长的代码;

[Add] RankingMode, RankingModeParser 从PixivURL分离并增加对应Parser;
[Add] RankingContentType, RankingContentTypeParser 从PixivURL分离并增加对应Parser;
[Delete] PixivURL 分离RankingMode和RankingContentType两个枚举类;
[Add] BotEventHandler 注册两个新的Parser;
[Change] BotCommandProcess 适配更改, 调整`ranking`命令的"type"和"mode"参数数据类型;
[Change] DateParser, PagesQualityParser 调整包路径;
[Change] BotAdminCommandProcess, CacheStoreCentral, Main, PixivDownload, PixivDownloadTest, RandomRankingArtworksSender, RankingUpdateTimer 适配更改;

.github/ISSUE_TEMPLATE/Bug_Report.md

@@ -1,26 +1,35 @@
 ---
-name: Bug Report
-about: Use this template to feedback bugs.
+name: Bug 反馈
+about: 使用这个模板反馈应用问题。
 title: ''
 labels: bug
 assignees: ''
 
 ---
 
-## Environmental information ##
-OS(e.g: Windows 10 1909): 
-Java(e.g: Oracle Jdk 8.242): 
-Issue version(versionTag or commitId): 
+## 环境信息 ##
+系统(例如: Windows 10 1909): ``
+Java版本(例如: Oracle Jdk 8.242): ``
+<!-- 如果直接使用发布版，那么就填写发布版版本号（v开头） -->
+<!-- 如果你通过编译运行的方式运行开发版，请你填写运行所使用的Commit Id -->
+发生问题所在的版本: ``
 
-## Problem description ##
-// Describe the problem in as much detail as possible here  
+## 问题描述 ##
+<!-- 尽可能的清晰描述问题的信息 -->
 
-## Expected behavior ##
-// What will this function do under normal circumstances?  
+## 预期行为 ##
+<!-- 你觉得正常情况下应该会发生什么？ -->
 
-## Actual behavior ##
-// But what does this feature actually look like?  
+## 实际行为 ##
+<!-- 实际上这个功能做了什么？ -->
 
-## Recurrence steps ##
-// What can we do to recreate this situation?  
+## 复现步骤 ##
+<!-- 将复现步骤详细的写出，如果是偶发问题，可以写已知的，触发几率高的方法 -->
 1.
+
+## 相关信息 ##
+### 日志  ###
+<!-- 如果日志涉及了问题，请务必将日志一同提交，这对排查问题非常有用 -->
+```
+
+```

.github/ISSUE_TEMPLATE/Feature_Report.md

@@ -0,0 +1,11 @@
+---
+name: 功能/想法 提议
+about: 使用这个模板将你对应用的想法提出来，或许我们会采纳！
+title: ''
+labels: function, question
+assignees: ''
+
+---
+
+<!-- 如果可以，尽可能的清晰、详细的表达你的想法 -->
+<!-- 没关系的，我们会进一步向你交流以尝试了解你的想法！ -->

Dockerfile.sample

@@ -1,10 +1,11 @@
-FROM openjdk:8u252-jre
+FROM openjdk:14
 
+COPY --from=hengyunabc/arthas:latest /opt/arthas /opt/arthas
 ENV jarFileName=ContentGrabbingJi-exec.jar
 ENV CGJ_REDIS_URI="127.0.0.1:6379"
 ENV CGJ_PROXY=""
 RUN mkdir /data/
+ENTRYPOINT ["/usr/java/openjdk-14/bin/java", "-Duser.timezone=GMT+8"]
+CMD ["-Dcgj.logsPath=/data/logs", "-jar", "/CGJ.jar", "botMode", "-botDataDir=/data"]
 
 COPY ${jarFileName} /CGJ.jar
-
-CMD ["java", "-Dcgj.logsPath=/data/logs", "-jar", "/CGJ.jar", "botMode", "-botDataDir=/data"]

README.md

@@ -1,41 +1,119 @@
-# ContentGrabbingJi #
-Pixiv爬虫一只，同时也是一个机器人/插件！
+# ContentGrabbingJi - 色图姬 #
+一个以高性能、高效率为目标，多平台/框架支持、持续维护的 Pixiv 聊天机器人；  
+色图姬存在的目的最初是作为**爬虫 + 机器人**的形式开发，在开发过程中逐渐以多聊天平台，高效率为目标进行。
 
-## 支持的机器人平台 ##
-- [Mirai](https://github.com/mamoe/mirai)
-- [CoolQ](https://cqp.cc)(基于[`SpringCQ`](https://github.com/lz1998/spring-cq), 不支持多账号使用, 需要使用[`CQHttp`](https://cqhttp.cc/)插件)
+## 安装 ##
+### 通过 Jar 文件部署 ###
+1. 从项目的[版本页面](https://github.com/LamGC/ContentGrabbingJi/releases)下载最新版色图姬主程序 jar 文件。
+2. 准备一个目录，用于存放运行数据（这里以 `./runData` 为例子）。
+3. 将通过 PixivLoginProxyServer 获得的 Pixiv 登录会话文件放置在目录中（`./runData/cookies.store`）。
+4. 使用命令 `java -jar <CGJ.jar> buildPassword -password "QQ机器人账号的密码"` 构造一个登录用的密码。
+5. 在数据目录创建一个配置文件 `bot.properties`，并添加如下内容：
+    ```properties
+    bot.qq=<机器人QQ账号>
+    bot.password=<通过buildPassword获得的密码>
+    ```
+6. 在数据目录创建新文件夹 `setting`，并创建一个全局配置文件 `global.properties`，然后设置如下内容：
+    ```properties
+    # 该配置为全局配置文件, 当群组没有特定配置时, 将使用全局配置.
+    # 管理员QQ (必填)
+    admin.adminId=<管理员QQ号>
+    # 是否允许r18作品
+    image.allowR18=false
+    # 查询排行榜默认的长度(比如15就是发送1~15名的作品), 该选项请适当调整, 设置过长可能导致超出聊天平台的最长消息长度, 导致发送失败!
+    ranking.itemCountLimit=15
+    # 排行榜图片数量(比如排行榜长度为15, 可以设置前10名有图片, 后5名没有图片), 调整该配置可有效控制消息发送所需时间.
+    ranking.imageCountLimit=15
+    # 搜索结果缓存时间, 默认2小时, 单位毫秒
+    cache.searchBody.expire=7200000
+    # 搜索结果长度. 该选项请适当调整, 设置过长可能导致超出聊天平台的最长消息长度, 导致发送失败!
+    search.itemCountLimit=8
+    ```
+    （管理员 QQ 的作用/用法将在下面详细说明。）
+7. 配置完成后，准备一台 Redis 服务端，用于缓存数据。
+8. Redis 服务器准备好后，使用命令启动色图姬：  
+    `java -jar <CGJ.jar> botMode -botDataDir <数据目录> -redisAddress <Redis服务器地址> [-proxy 代理服务器地址]`
+9. 完成！好好享受！
 
-## Usage ##
-> 注意: 运行色图姬前, 你需要准备一个Pixiv账号的会话Cookie存储文件, 否则色图姬将无法运行.  
-> 详见[PixivLoginProxyServer](https://github.com/LamGC/PixivLoginProxyServer)项目的[Readme](https://github.com/LamGC/PixivLoginProxyServer/blob/master/README.md).  
+### 通过 Docker 部署 ###
+使用 Docker 将可以更好的管理色图姬所使用的资源，和管理色图姬的运行。
+(正在完善中...)
 
-### Arguments ###
-> ENV参数名为环境变量名, 用于给Docker容器提供设置方式.  
+## 使用 ##
+### 普通用户 ###
+将色图姬部署完成，并且让色图姬在某个平台登录完成后，你就可以通过聊天平台向色图姬发起会话了！  
+使用 `.cgj` 向色图姬询问帮助信息！  
 
-- 通用参数
-  - `-proxy` / `ENV: CGJ_PROXY`: (**可选**) 设置代理
-    - 格式: `协议://地址:端口`
-    - 示例: `socks5://127.0.0.1:1080`
-- 机器人参数
-  - `-botDataDir` / `ENV: CGJ_BOT_DATA_DIR`: (**可选**) 设置`botMode`运行模式下机器人数据存储目录
-    - 格式: `路径`
-    - 示例: `./data`
-    - 默认: `./`
-  - `-redisAddress` / `ENV: CGJ_REDIS_URI`: (**必填, 计划支持可选**) Redis服务器地址
-    - 格式: `地址:端口`
-    - 示例: `127.0.0.1:6379`
+另外，由于色图姬在开发过程中直接使用了原本应用在命令行中的参数解析工具，所以你需要了解一下色图姬命令的格式，  
+色图姬的命令格式为：
+```bash
+.cgj <命令> -<参数名> <参数值> ...
+```
+如果色图姬无法识别你的命令，那么它会发送一次帮助信息给你。
 
-> 例如以BotMode启动应用: `java -jar CGJ.jar botMode -proxy "socks5://127.0.0.1:1080 -redisAddress 127.0.0.1:6379`
+### 管理员用户 ###
+你应该注意到了，在部署过程中，你需要设置一个管理员 QQ 的配置，色图姬支持通过命令来管理色图姬的运行。  
+目前支持的管理员命令：
+```bash
+# 清除缓存(慎用)
+# 该操作将会清除Redis服务器内的所有数据, 以及色图姬下载到本地的所有图片缓存.
+.cgjadmin cleanCache
 
-### Commands ###
-- `pluginMode`: CoolQ插件模式(依赖[酷Q机器人](https://cqp.cc/), 支持与CoolQ其他插件共存, 性能耗损大)
-- `botMode`: Mirai独立模式(机器人独立运行, 不支持与其他插件共存, 性能耗损小)
-- `collectionDownload`: 收藏下载, 以原图画质下载Cookie所属账号的所有收藏作品
-- `getRecommends`: 将访问主页获得的推荐作品全部以原图画质下载
-- `getRankingIllust`: 以原图画质下载指定排行榜类型的全部作品
-- `search`: 搜索指定内容并获取相关作品信息(不下载)
+# 设置配置项
+# 如果不使用group参数, 则设置全局配置
+# 注意: 配置项设置后需要使用`.cgjadmin saveProperties`才会保存到文件中, 
+# 如不保存, 则仅能在本次运行中生效(或使用`.cgjadmin loadProperties`重新加载后失效).
+.cgjadmin setProperty <-key 配置项名> <-value 配置项新值> [-group 指定群组]
 
-> 注意: 除去机器人模式外, 其他功能后续可能会出现改动.
+# 查询配置项
+# 如果不使用group参数, 则查询全局配置
+.cgjadmin getProperty <-key 配置项名> [-group 指定群组]
+
+# 保存所有配置
+.cgjadmin saveProperties
+
+# 读取所有配置
+# 使用 reload 参数将会重载所有配置, 而不是覆盖读取
+.cgjadmin loadProperties [-reload]
+
+# 运行定时更新任务
+# 可指定要更新数据的日期
+.cgjadmin runUpdateTask [-date yyyy-MM-dd]
+
+# 增加群组作品推送
+# 如果增加了original参数, 则图片为原图发送
+# 如果不指定group参数, 则群组为命令发送所在群组
+# 最长发送时间 = 最短发送时间 + 随机时间范围
+.cgjadmin addPushGroup [-group 指定群组号] [-minTime 最短发送时间] [-floatTime 随机时间范围] [-rankingStart 排行榜起始排名] 
+                       [-rankingStop 排行榜结束排名] [-mode 排行榜模式] [-type 排行榜类型] [-original]
+
+# 删除群组推送功能
+# 如果不指定group参数, 则群组为命令发送所在群组
+.cgjadmin removePushGroup [-group 指定群组号]
+
+# 加载作品推送配置
+.cgjadmin loadPushList
+
+# 保存作品推送配置
+.cgjadmin savePushList
+
+# 获取被报告的作品列表
+# 该命令会返回被其他用户报告其存在问题的作品列表
+.cgjadmin getReportList
+
+# 解封被报告的作品
+.cgjadmin unBanArtwork <-id 被ban作品的Id>
+
+```
+
+## 贡献 ##
+**向色图姬贡献不一定需要编程知识，向色图姬项目提出意见，反馈问题同样会为色图姬项目提供很大的帮助！**  
+如果你在使用色图姬的过程中，遇到了 Bug，可以通过色图姬项目的 **Issues** 使用[ Bug 反馈模板](https://github.com/LamGC/ContentGrabbingJi/issues/new?assignees=&labels=bug&template=Bug_Report.md&title=)向色图姬提供 Bug 信息。  
+如果是为色图姬提供一些新功能想法，或者对色图姬有什么意见，则可以使用[功能/意见提议模板](https://github.com/LamGC/ContentGrabbingJi/issues/new?assignees=&labels=function%2C+question&template=Feature_Report.md&title=)反馈你的想法！
+
+如果你会 Java 开发，又想为色图姬提供一些新功能，可以通过 Fork 仓库的方法，实现后发起 PR，合并到色图姬项目中！  
+向色图姬贡献代码，需要遵循一些贡献事项，如果你的代码不符合这些事项，PR有可能会被关闭！  
+> 注意：色图姬的初衷并没有任何恶意的意图，如果尝试向色图姬提供恶意功能或代码，PR 将会被拒绝、关闭。
 
 ## LICENSE ##
 本项目基于 `GNU Affero General Public License 3.0` 开源许可协议开源，  

documents/interfaces/Pixiv排行榜接口.md

@@ -41,16 +41,15 @@ GET https://www.pixiv.net/ranking.php
    :-:    |:-:| :-:  | :-:  | :-:
 daily     |`√`|`√`|`√`|`√`
 weekly    |`√`|`√`|`√`|`√`
-monthly   |`√`|`√`|×|`√`
-rookie    |`√`|`√`|×|`√`
-original  |`√`|×|×|×
-male      |`√`|×|×|×
-female    |`√`|×|×|×
+monthly   |`√`|`√`| × |`√`
+rookie    |`√`|`√`| × |`√`
+original  |`√`| × | × | ×
+male      |`√`| × | × | ×
+female    |`√`| × | × | ×
 daily_r18 |`√`|`√`|`√`|`√`
 weekly_r18|`√`|`√`|`√`|`√`
-male_r18  |`√`|×|×|×
-female_r18|`√`|×|×|×
-
+male_r18  |`√`| × | × | ×
+female_r18|`√`| × | × | ×
 
 ### 返回数据 ###
 #### 数据示例 ####

documents/interfaces/Pixiv搜索接口.md

@@ -16,14 +16,17 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
 ### 参数 ###
 #### Url参数 ####
 - `Type`: 内容类型
-    - illustrations(插画)
-    - top(推荐)
-    - manga(漫画)
-    - novels(小说)
+    - `artworks` - 所有类型
+    - `top` - 推荐
+    - `illustrations` - 插画
+    - `manga` - 漫画
+    - `novels` - 小说
+    - `tags` - 查询标签信息
 - `Content`: 搜索内容
 
 #### GET参数 ####
 ##### 必填 #####
+> 注意：除 `tags` 类型外，其他内容类型都需要以下参数。
 - `word`: 与搜索内容一致 (经测试似乎可以省略)
 - `s_mode`: 匹配模式
     - `s_tag`: 标签，部分一致
@@ -82,7 +85,8 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
                         "風景",
                         "空",
                         "草",
-                        "雲"],
+                        "雲"
+                    ],
                     "userId":"31507675",
                     "userName":"昏omeme",
                     "width":1600,
@@ -155,7 +159,8 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
                         "女の子",
                         "カラス",
                         "风景",
-                        "線路"],
+                        "線路"
+                    ],
                     "userId":"1069005",
                     "userName":"へちま",
                     "width":2000,
@@ -310,24 +315,10 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
     }
 }
 ```
+> 注意：根据 Url 参数中 `Type` 的不同，返回数据的属性也会出现差异，  
+  详见字段说明下的【请求 Url 中的 Type 与返回数据中属性的关系】表格
+
 #### 字段说明 ####
-- `novel`: (`Object`) 小说搜索结果
-    - `data`: (`Object`) 搜索结果(仅当前页数)
-        - (待补充)
-    - `total`: (`number`) 搜索结果总量
-- `popular`: (`Object`) 受欢迎的搜索结果
-- `relatedTags`: (`string[]`) 与搜索结果相关的标签
-- `tagTranslation`: (`Object`) 相关标签的翻译信息
-    - `{Attr: 标签名}`: 标签名为属性名
-        - `语言名(例如 中文是 zh)`: (`string`) 标签翻译名
-- `zoneConfig`: (`Object`) 猜测是广告相关信息?
-- `extraData`: (`Object`) 扩展信息
-    - `meta`: (`Object`) 网页元数据
-        - `title`: (`string`) 网页标题
-        - `description`: 搜索结果说明内容
-        - `descriptionHeader`: (`string`) 说明内容的Html代码
-        - `alternateLanguages`: (`Object`) 不明链接?
-            - `{语言名}`: 对应语言的链接
 - `illustManga`: (`Object`) 漫画和插画的搜索结果
     - `total`: (`number`) 搜索结果总量
     - `data`: (`Object[]`) 搜索结果(仅当前页数)
@@ -362,4 +353,45 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
         - `createDate`: (`string`) 作品创建时间(或者是完成时间?)
         - `updateDate`: (`string`) 作品上传时间
         - `profileImageUrl`: (`string`) 作者用户头像图片链接
-        
+    - `bookmarkRanges`: (`Object[]`) 收藏数范围(推测是用于按收藏数搜索而使用)
+        - `min`: (`number`) 最小收藏数, 值为 `null` 则无限制
+        - `max`: (`number`) 最大收藏数, 值为 `null` 则无限制
+- `illust`: (`Object`) 插画作品搜索结果
+    - **与`illustManga`结构相同**
+- `manga`: (`Object`) 漫画作品搜索结果
+    - **与`illustManga`结构相同**
+- `novel`: (`Object`) 小说搜索结果
+    - **与`illustManga`结构相同**
+- `popular`: (`Object`) 受欢迎的搜索结果
+    - `recent`: (`Object[]`) 近期推荐
+        - **与`illustManga.data.{element}`结构相同**
+    - `permanent`: (`Object[]`) 旧作品推荐
+        - **与`illustManga.data.{element}`结构相同**
+- `relatedTags`: (`string[]`) 与搜索结果相关的原始标签名
+- `tagTranslation`: (`Object`) 相关标签的翻译信息
+    - `{Attr: 标签名}`: 标签名为属性名, 对应 `relatedTags` 中的原始标签名
+        - `语言名(例如 中文是 zh)`: (`string`) 标签翻译名
+- `zoneConfig`: (`Object`) 猜测是广告相关信息?
+- `extraData`: (`Object`) 扩展信息
+    - `meta`: (`Object`) 网页元数据
+        - `title`: (`string`) 网页标题
+        - `description`: 搜索结果说明内容
+        - `descriptionHeader`: (`string`) 说明内容的Html代码
+        - `alternateLanguages`: (`Object`) 不明链接?
+            - `{语言名}`: 对应语言的链接
+
+##### 请求 Url 中的 Type 与返回数据中属性的关系 #####
+> 表中数据可能有错误，如发现问题，可在发起 Issue 并附上不在该表中情况（例如）的请求信息和返回数据，经确认后将会更新文档。  
+
+类型|illustManga|illust|manga|novel
+:--|:-:|:-:|:-:|:-:
+`artworks`     |√|×|×|×
+`top`          |√|×|×|?
+`illustrations`|×|√|×|×
+`manga`        |×|×|√|×
+`novels`       |×|×|×|√
+
+符号解释:  
+- `√`: 该属性一定存在
+- `?`: 该属性可能存在
+- `×`: 该属性不存在

documents/interfaces/Pixiv搜索推荐候选接口.md

@@ -0,0 +1,47 @@
+## 搜索推荐接口 ##
+### 说明 ###
+可用于优化搜索内容。
+
+### 接口地址 ###
+```
+GET https://www.pixiv.net/rpc/cps.php?
+```
+
+- 是否需要登录: `否`
+- 是否为Pixiv标准接口返回格式: `否`
+- 是否需要Referer请求头: `是`
+
+> 补充: Referer请求头只要是Pixiv的就可以了.
+
+### 参数 ###
+Url参数:
+- `keyword`: 搜索内容
+
+> 注意: 搜索内容需要进行Url编码（空格要转换成`%20`而不是`+`）
+### 请求示例 ###
+```
+GET https://www.pixiv.net/rpc/cps.php?keyword=幸运星
+```
+
+### 返回数据 ###
+#### 数据示例 ####
+```json
+{
+    "candidates":[
+        {
+            "tag_name":"\u3089\u304d\u2606\u3059\u305f",
+            "access_count":"68286498",
+            "tag_translation":"\u5e78\u8fd0\u661f",
+            "type":"tag_translation"
+        }, // ...
+    ]
+}
+```
+#### 字段说明 ####
+- `candidates`: (`Object[]`) 搜索推荐候选列表
+    - `tag_name`: (`string`) 推荐词原名
+    - `access_count`: (`string` -> `number`) 推荐词访问量
+    - `tag_translation`: (`string`) 推荐词对应翻译名
+    - `type`: (`string`) 推荐词类型
+        - `tag_translation`: 标签翻译信息
+        - `prefix`: 前缀

documents/interfaces/Pixiv预加载数据.md

@@ -0,0 +1,319 @@
+## Pixiv预加载数据 ##
+### 说明 ###
+作品预加载数据仅在加载作品页面时存在，处理后删除。
+### 接口地址 ###
+```
+GET https://www.pixiv.net/artworks/{IllustId}
+```
+
+- 是否需要登录: `是`
+- 是否为Pixiv标准接口返回格式: `否`
+- 是否需要Referer请求头: `否`
+
+### 参数 ###
+Url参数:
+- `IllustId`: 作品Id
+
+### 请求示例 ###
+```
+GET https://www.pixiv.net/artworks/82647306
+```
+
+### 返回数据 ###
+> 注意: 该接口返回HTML格式数据，并不是JSON格式数据。
+预加载数据需要对返回的Html数据进行解析，路径如下：
+- CSS Select: meta#meta-preload-data
+- html>head>meta#meta-preload-data
+
+获得标签后，获取`content`属性即可获得预加载数据内容
+
+#### 数据示例 ####
+```json
+{
+    "timestamp":"2020-07-01T11:32:30+09:00",
+    "illust":{
+        "82647306":{
+            "illustId":"82647306",
+            "illustTitle":"水着キャルちゃん！",
+            "illustComment":"水着のキャルちゃんはかわいいぞ！！",
+            "id":"82647306",
+            "title":"水着キャルちゃん！",
+            "description":"水着のキャルちゃんはかわいいぞ！！",
+            "illustType":0,
+            "createDate":"2020-06-29T12:28:06+00:00",
+            "uploadDate":"2020-06-29T12:28:06+00:00",
+            "restrict":0,
+            "xRestrict":0,
+            "sl":2,
+            "urls":{
+                "mini":"https://i.pximg.net/c/48x48/img-master/img/2020/06/29/21/28/06/82647306_p0_square1200.jpg",
+                "thumb":"https://i.pximg.net/c/250x250_80_a2/img-master/img/2020/06/29/21/28/06/82647306_p0_square1200.jpg",
+                "small":"https://i.pximg.net/c/540x540_70/img-master/img/2020/06/29/21/28/06/82647306_p0_master1200.jpg",
+                "regular":"https://i.pximg.net/img-master/img/2020/06/29/21/28/06/82647306_p0_master1200.jpg",
+                "original":"https://i.pximg.net/img-original/img/2020/06/29/21/28/06/82647306_p0.jpg"
+            },
+            "tags":{
+                "authorId":"55859246",
+                "isLocked":false,
+                "tags":[
+                    {
+                        "tag":"プリンセスコネクト!Re:Dive",
+                        "locked":true,
+                        "deletable":false,
+                        "userId":"55859246",
+                        "translation":{
+                            "en":"公主连结Re:Dive"
+                        },
+                        "userName":"秋鳩むぎ"
+                    }, // ...
+                ],
+                "writable":true
+            },
+            "alt":"#プリンセスコネクト!Re:Dive 水着キャルちゃん！ - 秋鳩むぎ的插画",
+            "storableTags":[
+                "_bee-JX46i",
+                "nAtxkwJ5Sy",
+                "q303ip6Ui5"
+            ],
+            "userId":"55859246",
+            "userName":"秋鳩むぎ",
+            "userAccount":"pigeonwheat",
+            "userIllusts":{
+                "82647306":{
+                    "illustId":"82647306",
+                    "illustTitle":"水着キャルちゃん！",
+                    "id":"82647306",
+                    "title":"水着キャルちゃん！",
+                    "illustType":0,
+                    "xRestrict":0,
+                    "restrict":0,
+                    "sl":2,
+                    "url":"https://i.pximg.net/c/250x250_80_a2/img-master/img/2020/06/29/21/28/06/82647306_p0_square1200.jpg",
+                    "description":"水着のキャルちゃんはかわいいぞ！！",
+                    "tags":[
+                        "プリンセスコネクト!Re:Dive",
+                        "キャル(プリコネ)",
+                        "おへそ"
+                    ],
+                    "userId":"55859246",
+                    "userName":"秋鳩むぎ",
+                    "width":2000,
+                    "height":3000,
+                    "pageCount":1,
+                    "isBookmarkable":true,
+                    "bookmarkData":null,
+                    "alt":"#プリンセスコネクト!Re:Dive 水着キャルちゃん！ - 秋鳩むぎ的插画",
+                    "isAdContainer":false,
+                    "titleCaptionTranslation":{
+                        "workTitle":null,
+                        "workCaption":null
+                    },
+                    "createDate":"2020-06-29T21:28:06+09:00",
+                    "updateDate":"2020-06-29T21:28:06+09:00",
+                    "seriesId":null,
+                    "seriesTitle":null
+                }
+            },
+            "likeData":false,
+            "width":2000,
+            "height":3000,
+            "pageCount":1,
+            "bookmarkCount":39,
+            "likeCount":31,
+            "commentCount":2,
+            "responseCount":0,
+            "viewCount":239,
+            "isHowto":false,
+            "isOriginal":false,
+            "imageResponseOutData":[
+            ],
+            "imageResponseData":[
+            ],
+            "imageResponseCount":0,
+            "pollData":null,
+            "seriesNavData":null,
+            "descriptionBoothId":null,
+            "descriptionYoutubeId":null,
+            "comicPromotion":null,
+            "fanboxPromotion":null,
+            "contestBanners":[
+            ],
+            "isBookmarkable":true,
+            "bookmarkData":null,
+            "contestData":null,
+            "zoneConfig":{
+                "responsive":{
+                    "url":"https://pixon.ads-pixiv.net/show?zone_id=illust_responsive&format=js&s=1&up=0&a=22&ng=w&l=zh&uri=%2Fartworks%2F_PARAM_&is_spa=1&K=59bba275c645c&ab_test_digits_first=32&yuid=NDJ3gQk&suid=Pggb9mua3yznnr7lz&num=5efbf5be273&t=_bee-JX46i&t=b8b4-hqot7&t=kY01H5r3Pd"
+                },
+                "rectangle":{
+                    "url":"https://pixon.ads-pixiv.net/show?zone_id=illust_rectangle&format=js&s=1&up=0&a=22&ng=w&l=zh&uri=%2Fartworks%2F_PARAM_&is_spa=1&K=59bba275c645c&ab_test_digits_first=32&yuid=NDJ3gQk&suid=Pggb9mua42776dfuu&num=5efbf5be810&t=_bee-JX46i&t=b8b4-hqot7&t=kY01H5r3Pd"
+                },
+                "500x500":{
+                    "url":"https://pixon.ads-pixiv.net/show?zone_id=bigbanner&format=js&s=1&up=0&a=22&ng=w&l=zh&uri=%2Fartworks%2F_PARAM_&is_spa=1&K=59bba275c645c&ab_test_digits_first=32&yuid=NDJ3gQk&suid=Pggb9mua442sjsueo&num=5efbf5be568&t=_bee-JX46i&t=b8b4-hqot7&t=kY01H5r3Pd"
+                },
+                "header":{
+                    "url":"https://pixon.ads-pixiv.net/show?zone_id=header&format=js&s=1&up=0&a=22&ng=w&l=zh&uri=%2Fartworks%2F_PARAM_&is_spa=1&K=59bba275c645c&ab_test_digits_first=32&yuid=NDJ3gQk&suid=Pggb9mua45spzoimt&num=5efbf5be155&t=_bee-JX46i&t=b8b4-hqot7&t=kY01H5r3Pd"
+                },
+                "footer":{
+                    "url":"https://pixon.ads-pixiv.net/show?zone_id=footer&format=js&s=1&up=0&a=22&ng=w&l=zh&uri=%2Fartworks%2F_PARAM_&is_spa=1&K=59bba275c645c&ab_test_digits_first=32&yuid=NDJ3gQk&suid=Pggb9mua47f9zcoim&num=5efbf5be400&t=_bee-JX46i&t=b8b4-hqot7&t=kY01H5r3Pd"
+                },
+                "expandedFooter":{
+                    "url":"https://pixon.ads-pixiv.net/show?zone_id=multiple_illust_viewer&format=js&s=1&up=0&a=22&ng=w&l=zh&uri=%2Fartworks%2F_PARAM_&is_spa=1&K=59bba275c645c&ab_test_digits_first=32&yuid=NDJ3gQk&suid=Pggb9mua4928ct0yw&num=5efbf5be471&t=_bee-JX46i&t=b8b4-hqot7&t=kY01H5r3Pd"
+                },
+                "logo":{
+                    "url":"https://pixon.ads-pixiv.net/show?zone_id=logo_side&format=js&s=1&up=0&a=22&ng=w&l=zh&uri=%2Fartworks%2F_PARAM_&is_spa=1&K=59bba275c645c&ab_test_digits_first=32&yuid=NDJ3gQk&suid=Pggb9mua4aqu6i4sr&num=5efbf5be844&t=_bee-JX46i&t=b8b4-hqot7&t=kY01H5r3Pd"
+                }
+            },
+            "extraData":{
+                "meta":{
+                    "title":"#プリンセスコネクト!Re:Dive 水着キャルちゃん！ - 秋鳩むぎ的插画 - pixiv",
+                    "description":"この作品 「水着キャルちゃん！」 は 「プリンセスコネクト!Re:Dive」「キャル(プリコネ)」 等のタグがつけられた「秋鳩むぎ」さんのイラストです。 「水着のキャルちゃんはかわいいぞ！！」",
+                    "canonical":"https://www.pixiv.net/artworks/82647306",
+                    "alternateLanguages":{
+                        "ja":"https://www.pixiv.net/artworks/82647306",
+                        "en":"https://www.pixiv.net/en/artworks/82647306"
+                    },
+                    "descriptionHeader":"本作「水着キャルちゃん！」为附有「プリンセスコネクト!Re:Dive」「キャル(プリコネ)」等标签的插画。",
+                    "ogp":{
+                        "description":"水着のキャルちゃんはかわいいぞ！！",
+                        "image":"https://embed.pixiv.net/decorate.php?illust_id=82647306",
+                        "title":"#プリンセスコネクト!Re:Dive 水着キャルちゃん！ - 秋鳩むぎ的插画 - pixiv",
+                        "type":"article"
+                    },
+                    "twitter":{
+                        "description":"水着のキャルちゃんはかわいいぞ！！",
+                        "image":"https://embed.pixiv.net/decorate.php?illust_id=82647306",
+                        "title":"水着キャルちゃん！",
+                        "card":"summary_large_image"
+                    }
+                }
+            },
+            "titleCaptionTranslation":{
+                "workTitle":null,
+                "workCaption":null
+            }
+        }
+    },
+    "user":{
+        "55859246":{
+            "userId":"55859246",
+            "name":"秋鳩むぎ",
+            "image":"https://i.pximg.net/user-profile/img/2020/06/29/21/20/14/18907670_b3f87d819f705ec418f120cd57f9dc41_50.jpg",
+            "imageBig":"https://i.pximg.net/user-profile/img/2020/06/29/21/20/14/18907670_b3f87d819f705ec418f120cd57f9dc41_170.jpg",
+            "premium":false,
+            "isFollowed":false,
+            "isMypixiv":false,
+            "isBlocking":false,
+            "background":null,
+            "partial":0
+        }
+    }
+}
+```
+#### 字段说明 ####
+- `timestamp`: (`string`) 请求时间
+- `illust`: (`Object`) 作品预加载信息
+    - `{illustId}`: 作品ID(跟页面请求的IllustId一样)
+        - `illustId`: (`string` -> `number`) 作品Id
+        - `illustTitle`: (`string`) 作品标题
+        - `illustComment`: (`string`) 作品说明
+        - `id`: (`string` -> `number`) 与`illustId`一致, 猜测是以兼容旧版本为目录而存在
+        - `title`: (`string`) 与`illustTitle`一致, 猜测是以兼容旧版本为目录而存在
+        - `description`: (`string`) 作品说明
+        - `illustType`: (`number`) 作品类型
+            - `0`: 插画作品
+            - `1`: 漫画作品
+            - `2`: 动图作品
+        - `createDate`: (`string`) 作品创建时间(或者是完成时间?)
+        - `updateDate`: (`string`) 作品上传时间
+        - `restrict`: (`number`) 作品限制级(意义不明, 可能是兼容性问题?)?
+        - `xRestrict`: (`number`) 作品是否为限制级, 基本准确, 少部分不一定(看Pixiv审核怎么理解了)
+            - `0`: 非限制级内容(即非R18作品)
+            - `1`: 限制级内容(即R18作品)
+        - `sl`: (`number`) 不明?
+        - `urls`: (`string`) 作品图片链接, 需要`Referer`请求头
+            - `mini`: (`string`) 小尺寸预览图
+            - `thumb`: (`string`) 小尺寸预览图
+            - `small`: (`string`) 小尺寸预览图
+            - `regular`: (`string`) 经压缩，没啥画质损失的原尺寸预览图
+            - `original`: (`string`) 原图
+        - `tags`: (`Object`) 作品标签信息
+            - `authorId`: (`string` -> `number`) 作者用户Id
+            - `isLocked`: (`boolean`) 标签是否锁定(即不可被访客更改)
+            - `tags`: (`Object[]`) 标签信息数组
+                - `tag`: (`string`) 标签原始名
+                - `locked`: (`boolean`) 标签是否不可更改
+                - `deletable`: (`boolean`) 标签能否被删除?
+                - `userId`: (`string` -> `number`) 用户Id
+                - `translation`: (`Object`) 标签翻译
+                    - `{语种}`: 翻译名
+                - `userName`: (`string`) 用户名
+        - `alt`: (`string`) 简略介绍信息(在图片加载失败时可提供给`img`标签使用)
+        - `storableTags`: (`string[]`) 不明?
+        - `userId`: (`string` -> `number`) 作者用户Id
+        - `userName`: (`string`) 作者用户名
+        - `userAccount`: (`string`) 作者登录名
+        - `userIllusts`: (`Object`) 作品信息?
+            - `{IllustId}`: 与请求IllustId一样
+                - (请转到：Pixiv作品信息获取接口.md)
+        - `likeData`: (`boolean?`) 不明?
+        - `width`: (`number`) 作品长度
+        - `height`: (`number`) 作品高度
+        - `pageCount`: (`number`) 作品页数
+        - `bookmarkCount`: (`number`) 作品公开的收藏数
+        - `likeCount`: (`number`) 作品喜欢(点赞)数
+        - `commentCount`: (`number`) 作品评论数
+        - `responseCount`: (`number`) 作品响应数?
+        - `viewCount`: (`number`) 作品阅览数
+        - `isHowto`: (`boolean`) 不明?
+        - `isOriginal`: (`boolean`) 不明?
+        - `imageResponseOutData`: (`Unknown[]`) 不明?
+        - `imageResponseData`: (`Unknown[]`) 不明?
+        - `imageResponseCount`: (`number`) 不明?
+        - `pollData`: (`Unknown`) 不明?
+        - `seriesNavData`: (`Unknown`)  不明?
+        - `descriptionBoothId`: (`Unknown`)  不明?
+        - `descriptionYoutubeId`: (`Unknown`)  不明?
+        - `comicPromotion`: (`Unknown`)  不明?
+        - `fanboxPromotion`: (`Unknown`)  不明?
+        - `contestBanners`: (`Unknown[]`)  不明? 
+        // TODO 待补充
+
+        - `isBookmarkable`: (`boolean`) 不明?
+        - `bookmarkData`: (`Unknown`) 不明?
+        - `contestData`: (`Unknown`) 不明?
+        - `zoneConfig`: (`Object`) 猜测是广告信息?
+            - (基本不用, 忽略...)
+        - `extraData`: (`Object`) 扩展数据
+            - `meta`: (`Object`) 元数据
+                - `title`: (`string`) 网页标题
+                - `description`: (`string`) Pixiv生成的作品说明
+                - `canonical`: (`string`) 作品页面链接
+                - `alternateLanguages`: (`Object`) 不同语言的作品页面链接
+                    - `{语种}`: (`string`) 对应语种的作品链接
+                - `descriptionHeader`: (`string`) 说明文档(不过似乎是对应了会话所属账号的语种?)
+                - `ogp`: (`Object`) 猜测是某平台的分享数据?
+                    - `description`: (`string`) 说明内容
+                    - `image`: (`string`) 预览图链接
+                    - `title`: (`string`) 分享标题
+                    - `type`: (`string`) 分享类型?
+                - `twitter`: (`Object`)
+                    - `description`: (`string`) 说明内容
+                    - `image`: (`string`) 预览图链接
+                    - `title`: (`string`) 分享标题
+                    - `card`: (`string`) 分享类型?
+        - `titleCaptionTranslation`: (`Object`) 不明?
+            - `workTitle`: (`Unknown`) 不明?
+            - `workCaption`: (`Unknown`) 不明?
+- `user`: (`Object`) 作者预加载信息
+    - `{userId}`: 可通过`illust.{illustId}.userId`获得
+        - `userId`: (`string` -> `number`) 作者用户Id
+        - `name`: (`string`) 作者用户名
+        - `image`: (`string`) 作者用户头像(小尺寸)
+        - `imageBig`: (`string`) 作者用户头像(大尺寸)
+        - `premium`: (`boolean`) 作者是否为Pixiv会员
+        - `isFollowed`: (`boolean`) 当前会话用户是否已关注
+        - `isMypixiv`: (`boolean`) 是否为当前会话本人?
+        - `isBlocking`: (`boolean`) 是否正在被封禁
+        - `background`: (`Object`) 背景图片?
+        - `partial`: (`number`) 不明?

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>net.lamgc</groupId>
     <artifactId>ContentGrabbingJi</artifactId>
-    <version>2.5.2-20200610.4-SNAPSHOT</version>
+    <version>2.5.2-20200709.1-SNAPSHOT</version>
 
     <licenses>
         <license>
@@ -27,7 +27,7 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
-        <mirai.CoreVersion>1.0.2</mirai.CoreVersion>
+        <mirai.CoreVersion>1.0.4</mirai.CoreVersion>
         <mirai.JaptVersion>1.1.1</mirai.JaptVersion>
         <kotlin.version>1.3.71</kotlin.version>
         <ktor.version>1.3.2</ktor.version>
@@ -94,7 +94,7 @@
         <dependency>
             <groupId>net.lamgc</groupId>
             <artifactId>java-utils</artifactId>
-            <version>1.2.0_20200517.1-SNAPSHOT</version>
+            <version>1.3.1</version>
         </dependency>
         
         <dependency>
@@ -121,7 +121,7 @@
         <dependency>
             <groupId>net.lz1998</groupId>
             <artifactId>spring-cq</artifactId>
-            <version>4.14.0.6</version>
+            <version>4.15.0.1</version>
             <exclusions>
                 <exclusion>
                     <groupId>ch.qos.logback</groupId>
@@ -162,11 +162,6 @@
             <artifactId>ktor-server-core</artifactId>
             <version>${ktor.version}</version>
         </dependency>
-        <dependency>
-            <groupId>net.lamgc</groupId>
-            <artifactId>PixivLoginProxyServer</artifactId>
-            <version>1.1.1</version>
-        </dependency>
         <dependency>
             <groupId>com.squareup</groupId>
             <artifactId>gifencoder</artifactId>
@@ -177,6 +172,12 @@
             <artifactId>jline</artifactId>
             <version>3.15.0</version>
         </dependency>
+        <dependency>
+            <groupId>com.google.inject</groupId>
+            <artifactId>guice</artifactId>
+            <version>4.2.3</version>
+        </dependency>
+
     </dependencies>
 
 </project>

src/main/java/net/lamgc/cgj/Main.java

@@ -1,7 +1,5 @@
 package net.lamgc.cgj;
 
-import com.github.monkeywie.proxyee.proxy.ProxyConfig;
-import com.github.monkeywie.proxyee.proxy.ProxyType;
 import com.google.common.base.Strings;
 import com.google.gson.Gson;
 import com.google.gson.JsonArray;
@@ -10,15 +8,13 @@ import com.google.gson.JsonObject;
 import net.lamgc.cgj.bot.boot.ApplicationBoot;
 import net.lamgc.cgj.bot.boot.BotGlobal;
 import net.lamgc.cgj.bot.framework.cli.ConsoleMain;
-import net.lamgc.cgj.bot.framework.coolq.CQConfig;
+import net.lamgc.cgj.bot.framework.coolq.SpringCQApplication;
 import net.lamgc.cgj.bot.framework.mirai.MiraiMain;
-import net.lamgc.cgj.pixiv.PixivDownload;
-import net.lamgc.cgj.pixiv.PixivSearchBuilder;
-import net.lamgc.cgj.pixiv.PixivURL;
-import net.lamgc.plps.PixivLoginProxyServer;
+import net.lamgc.cgj.pixiv.*;
 import net.lamgc.utils.base.runner.Argument;
 import net.lamgc.utils.base.runner.ArgumentsRunner;
 import net.lamgc.utils.base.runner.Command;
+import net.lamgc.utils.encrypt.MessageDigestUtils;
 import org.apache.http.HttpHost;
 import org.apache.http.HttpResponse;
 import org.apache.http.client.CookieStore;
@@ -27,20 +23,15 @@ import org.apache.http.util.EntityUtils;
 import org.apache.tomcat.util.http.fileupload.util.Streams;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 import java.io.*;
 import java.nio.charset.StandardCharsets;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.*;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
 
-@SpringBootApplication
 public class Main {
 
     private final static Logger log = LoggerFactory.getLogger(Main.class);
@@ -52,6 +43,14 @@ public class Main {
     private static HttpHost proxy;
 
     public static void main(String[] args) throws IOException, ClassNotFoundException {
+        if(args.length != 0 && args[0].equalsIgnoreCase("buildpassword")) {
+            ArgumentsRunner.run(Main.class, args);
+        } else {
+            standardStart(args);
+        }
+    }
+
+    private static void standardStart(String[] args) throws IOException, ClassNotFoundException {
         log.info("ContentGrabbingJi 正在启动...");
         log.debug("Args: {}, LogsPath: {}", Arrays.toString(args), System.getProperty("cgj.logsPath"));
         log.debug("运行目录: {}", System.getProperty("user.dir"));
@@ -62,16 +61,9 @@ public class Main {
         proxy = BotGlobal.getGlobal().getProxy();
         File cookieStoreFile = new File(BotGlobal.getGlobal().getDataStoreDir(), "cookies.store");
         if(!cookieStoreFile.exists()) {
-            log.warn("未找到cookies.store文件, 是否启动PixivLoginProxyServer? (yes/no)");
-            try(Scanner scanner = new Scanner(System.in)) {
-                if(scanner.nextLine().trim().equalsIgnoreCase("yes")) {
-                    startPixivLoginProxyServer();
-                } else {
-                    System.exit(1);
-                    return;
-                }
-            }
-            
+            log.warn("未找到cookies.store文件, 请检查数据存放目录下是否存在'cookies.store'文件！");
+            System.exit(1);
+            return;
         }
         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(cookieStoreFile));
         cookieStore = (CookieStore) ois.readObject();
@@ -85,6 +77,13 @@ public class Main {
         System.exit(0);
     }
 
+    @Command
+    public static void buildPassword(@Argument(name = "password") String password) {
+        System.out.println("Password: " +
+                Base64.getEncoder().encodeToString(MessageDigestUtils.encrypt(password.getBytes(),
+                MessageDigestUtils.Algorithm.MD5)));
+    }
+
     @Command
     public static void botMode(@Argument(name = "args", force = false) String argsStr) {
         MiraiMain main = new MiraiMain();
@@ -99,17 +98,7 @@ public class Main {
 
     @Command
     public static void pluginMode(@Argument(name = "args", force = false) String argsStr) {
-        log.info("酷Q机器人根目录: {}", BotGlobal.getGlobal().getDataStoreDir().getPath());
-        CQConfig.init();
-        Pattern pattern = Pattern.compile("/\\s*(\".+?\"|[^:\\s])+((\\s*:\\s*(\".+?\"|[^\\s])+)|)|(\".+?\"|[^\"\\s])+");
-        Matcher matcher = pattern.matcher(Strings.nullToEmpty(argsStr));
-        ArrayList<String> argsList = new ArrayList<>();
-        while (matcher.find()) {
-            argsList.add(matcher.group());
-        }
-        String[] args = new String[argsList.size()];
-        argsList.toArray(args);
-        SpringApplication.run(Main.class, args);
+        new SpringCQApplication().start(argsStr);
     }
 
     @Command
@@ -191,18 +180,18 @@ public class Main {
         date = format.format(queryDate);
 
         log.info("查询时间: {}", date);
-        PixivURL.RankingMode rankingMode = PixivURL.RankingMode.MODE_DAILY;
-        PixivURL.RankingContentType contentType = null;
+        RankingMode rankingMode = RankingMode.MODE_DAILY;
+        RankingContentType contentType = null;
         if(mode != null) {
             try {
-                rankingMode = PixivURL.RankingMode.valueOf(mode);
+                rankingMode = RankingMode.valueOf(mode);
             } catch (IllegalArgumentException e) {
                 log.warn("不支持的RankingMode: {}", mode);
             }
         }
         if(content != null) {
             try {
-                contentType = PixivURL.RankingContentType.valueOf(content);
+                contentType = RankingContentType.valueOf(content);
             } catch (IllegalArgumentException e) {
                 log.warn("不支持的RankingContentType: {}", content);
             }
@@ -224,7 +213,8 @@ public class Main {
 
         log.info("正在调用方法...");
         try {
-            pixivDownload.getRankingAsInputStream(contentType, rankingMode, queryDate, range, PixivDownload.PageQuality.ORIGINAL, (rank, link, rankInfo, inputStream) -> {
+            pixivDownload.getRankingAsInputStream(contentType, rankingMode, queryDate, range,
+                    PixivDownload.PageQuality.ORIGINAL, (rank, link, rankInfo, inputStream) -> {
                 try {
                     ZipEntry entry = new ZipEntry("Rank" + rank + "-" + link.substring(link.lastIndexOf("/") + 1));
                     entry.setComment(rankInfo.toString());
@@ -254,24 +244,24 @@ public class Main {
             @Argument(name = "excludeKeywords", force = false) String excludeKeywords,
             @Argument(name = "contentOption", force = false) String contentOption
     ) throws IOException {
-        PixivSearchBuilder searchBuilder = new PixivSearchBuilder(Strings.isNullOrEmpty(content) ? "" : content);
+        PixivSearchLinkBuilder searchBuilder = new PixivSearchLinkBuilder(Strings.isNullOrEmpty(content) ? "" : content);
         if (type != null) {
             try {
-                searchBuilder.setSearchType(PixivSearchBuilder.SearchType.valueOf(type.toUpperCase()));
+                searchBuilder.setSearchType(PixivSearchLinkBuilder.SearchType.valueOf(type.toUpperCase()));
             } catch (IllegalArgumentException e) {
                 log.warn("不支持的SearchType: {}", type);
             }
         }
         if(area != null) {
             try {
-                searchBuilder.setSearchArea(PixivSearchBuilder.SearchArea.valueOf(area));
+                searchBuilder.setSearchArea(PixivSearchLinkBuilder.SearchArea.valueOf(area));
             } catch (IllegalArgumentException e) {
                 log.warn("不支持的SearchArea: {}", area);
             }
         }
         if(contentOption != null) {
             try {
-                searchBuilder.setSearchContentOption(PixivSearchBuilder.SearchContentOption.valueOf(contentOption));
+                searchBuilder.setSearchContentOption(PixivSearchLinkBuilder.SearchContentOption.valueOf(contentOption));
             } catch (IllegalArgumentException e) {
                 log.warn("不支持的SearchContentOption: {}", contentOption);
             }
@@ -310,35 +300,39 @@ public class Main {
 
         JsonObject resultBody = jsonObject.getAsJsonObject("body");
 
-        for(PixivSearchBuilder.SearchArea searchArea : PixivSearchBuilder.SearchArea.values()) {
-            if(!resultBody.has(searchArea.jsonKey) || resultBody.getAsJsonObject(searchArea.jsonKey).getAsJsonArray("data").size() == 0) {
-                //log.info("返回数据不包含 {}", searchArea.jsonKey);
-                continue;
-            }
-            JsonArray illustsArray = resultBody
-                    .getAsJsonObject(searchArea.jsonKey).getAsJsonArray("data");
-            log.info("已找到与 {} 相关插图信息({})：", content, searchArea.name().toLowerCase());
-            int count = 1;
-            for (JsonElement jsonElement : illustsArray) {
-                JsonObject illustObj = jsonElement.getAsJsonObject();
-                if(!illustObj.has("illustId")) {
+        for(PixivSearchAttribute attribute : PixivSearchAttribute.values()) {
+            for(String attrName : attribute.attributeNames) {
+                if(!resultBody.has(attrName) ||
+                        resultBody.getAsJsonObject(attrName).getAsJsonArray("data").size() == 0) {
+                    //log.info("返回数据不包含 {}", attrName);
                     continue;
                 }
-                int illustId = illustObj.get("illustId").getAsInt();
-                StringBuilder builder = new StringBuilder("[");
-                illustObj.get("tags").getAsJsonArray().forEach(el -> builder.append(el.getAsString()).append(", "));
-                builder.replace(builder.length() - 2, builder.length(), "]");
-                log.info("{} ({} / {})\n\t作品id: {}, \n\t作者名(作者id): {} ({}), \n\t作品标题: {}, \n\t作品Tags: {}, \n\t作品链接: {}",
-                        searchArea.name(),
-                        count++,
-                        illustsArray.size(),
-                        illustId,
-                        illustObj.get("userName").getAsString(),
-                        illustObj.get("userId").getAsInt(),
-                        illustObj.get("illustTitle").getAsString(),
-                        builder,
-                        PixivURL.getPixivRefererLink(illustId)
-                );
+                JsonArray illustsArray = resultBody
+                        .getAsJsonObject(attrName).getAsJsonArray("data");
+                log.info("已找到与 {} 相关插图信息({})：", content, attribute.name().toLowerCase());
+                int count = 1;
+                for (JsonElement jsonElement : illustsArray) {
+                    JsonObject illustObj = jsonElement.getAsJsonObject();
+                    if(!illustObj.has("illustId")) {
+                        continue;
+                    }
+                    int illustId = illustObj.get("illustId").getAsInt();
+                    StringBuilder builder = new StringBuilder("[");
+                    illustObj.get("tags").getAsJsonArray().forEach(el -> builder.append(el.getAsString()).append(", "));
+                    builder.replace(builder.length() - 2, builder.length(), "]");
+                    log.info("{} ({} / {})\n\t作品id: {}, \n\t作者名(作者id): {} ({}), " +
+                                    "\n\t作品标题: {}, \n\t作品Tags: {}, \n\t作品链接: {}",
+                            attribute.name(),
+                            count++,
+                            illustsArray.size(),
+                            illustId,
+                            illustObj.get("userName").getAsString(),
+                            illustObj.get("userId").getAsInt(),
+                            illustObj.get("illustTitle").getAsString(),
+                            builder,
+                            PixivURL.getPixivRefererLink(illustId)
+                    );
+                }
             }
         }
     }
@@ -349,57 +343,6 @@ public class Main {
         log.info("这里啥都没有哟w");
     }
 
-    private static void saveCookieStoreToFile() throws IOException {
-        log.info("正在保存CookieStore...");
-        File outputFile = new File(BotGlobal.getGlobal().getDataStoreDir(), "cookies.store");
-        if(!outputFile.exists() && !outputFile.createNewFile()){
-            log.error("保存CookieStore失败.");
-            return;
-        }
-        ObjectOutputStream stream = new ObjectOutputStream(new FileOutputStream(outputFile));
-        stream.writeObject(cookieStore);
-        stream.flush();
-        stream.close();
-        log.info("CookieStore保存成功.");
-    }
-
-    private static void startPixivLoginProxyServer(){
-        ProxyConfig proxyConfig = null;
-        if(proxy != null) {
-            proxyConfig = new ProxyConfig(ProxyType.HTTP, proxy.getHostName(), proxy.getPort());
-        }
-        PixivLoginProxyServer proxyServer = new PixivLoginProxyServer(proxyConfig);
-        Thread proxyServerStartThread = new Thread(() -> {
-            log.info("启动代理服务器...");
-            proxyServer.start(1006);
-            log.info("代理服务器已关闭.");
-        });
-        proxyServerStartThread.setName("LoginProxyServerThread");
-        proxyServerStartThread.start();
-        //System.console().readLine();
-        
-        log.info("登录完成后, 使用\"done\"命令结束登录过程.");
-        try(Scanner scanner = new Scanner(System.in)) {
-            while(true) {
-                if (scanner.nextLine().equalsIgnoreCase("done")) {
-                    log.info("关闭PLPS服务器...");
-                    proxyServer.close();
-                    cookieStore = proxyServer.getCookieStore();
-                    try {
-                        log.info("正在保存CookieStore...");
-                        saveCookieStoreToFile();
-                        log.info("CookieStore保存完成.");
-                    } catch (IOException e) {
-                        log.error("CookieStore保存时发生异常, 本次CookieStore仅可在本次运行使用.", e);
-                    }
-                    break;
-                } else {
-                    log.warn("要结束登录过程, 请使用\"done\"命令.");
-                }
-            }
-        }
-    }
-
     private static File getStoreDir() {
         if(!storeDir.exists() && !storeDir.mkdirs()) {
             log.error("创建文件夹失败!");

src/main/java/net/lamgc/cgj/bot/BotAdminCommandProcess.java

@@ -9,7 +9,8 @@ import net.lamgc.cgj.bot.boot.BotGlobal;
 import net.lamgc.cgj.bot.message.MessageSenderBuilder;
 import net.lamgc.cgj.bot.message.MessageSource;
 import net.lamgc.cgj.pixiv.PixivDownload;
-import net.lamgc.cgj.pixiv.PixivURL;
+import net.lamgc.cgj.pixiv.RankingContentType;
+import net.lamgc.cgj.pixiv.RankingMode;
 import net.lamgc.utils.base.runner.Argument;
 import net.lamgc.utils.base.runner.Command;
 import org.slf4j.Logger;
@@ -118,16 +119,16 @@ public class BotAdminCommandProcess {
             return "排行榜范围选取错误！";
         }
 
-        PixivURL.RankingContentType type;
-        PixivURL.RankingMode mode;
+        RankingContentType type;
+        RankingMode mode;
         try {
-            type = PixivURL.RankingContentType.valueOf("TYPE_" + rankingContentType.toUpperCase());
+            type = RankingContentType.valueOf("TYPE_" + rankingContentType.toUpperCase());
         } catch(IllegalArgumentException e) {
             return "无效的排行榜类型参数！";
         }
 
         try {
-            mode = PixivURL.RankingMode.valueOf("MODE_" + rankingMode.toUpperCase());
+            mode = RankingMode.valueOf("MODE_" + rankingMode.toUpperCase());
         } catch(IllegalArgumentException e) {
             return "无效的排行榜模式参数！";
         }
@@ -225,10 +226,13 @@ public class BotAdminCommandProcess {
         } catch(NoSuchElementException ignored) {
         }
 
-        int rankingStart = setting.has(RANKING_SETTING_RANKING_START) ? setting.get(RANKING_SETTING_RANKING_START).getAsInt() : 1;
-        int rankingEnd = setting.has(RANKING_SETTING_RANKING_END) ? setting.get(RANKING_SETTING_RANKING_END).getAsInt() : 150;
-        PixivURL.RankingMode rankingMode = PixivURL.RankingMode.MODE_DAILY;
-        PixivURL.RankingContentType rankingContentType = PixivURL.RankingContentType.TYPE_ILLUST;
+        int rankingStart = setting.has(RANKING_SETTING_RANKING_START) ?
+                setting.get(RANKING_SETTING_RANKING_START).getAsInt() : 1;
+        int rankingEnd = setting.has(RANKING_SETTING_RANKING_END) ?
+                setting.get(RANKING_SETTING_RANKING_END).getAsInt() : 150;
+
+        RankingMode rankingMode = RankingMode.MODE_DAILY;
+        RankingContentType rankingContentType = RankingContentType.TYPE_ILLUST;
         PixivDownload.PageQuality pageQuality = PixivDownload.PageQuality.REGULAR;
 
         if(rankingStart <= 0 || rankingStart > 500) {
@@ -246,7 +250,7 @@ public class BotAdminCommandProcess {
         if(setting.has(RANKING_SETTING_RANKING_MODE)) {
             String value = setting.get(RANKING_SETTING_RANKING_MODE).getAsString().trim().toUpperCase();
             try {
-                rankingMode = PixivURL.RankingMode.valueOf(value.startsWith("MODE_") ? value : "MODE_" + value);
+                rankingMode = RankingMode.valueOf(value.startsWith("MODE_") ? value : "MODE_" + value);
             } catch(IllegalArgumentException e) {
                 log.warn("群组ID [{}] - 无效的RankingMode设定值, 将重置为默认值: {}", id, value);
             }
@@ -254,7 +258,7 @@ public class BotAdminCommandProcess {
         if(setting.has(RANKING_SETTING_RANKING_CONTENT_TYPE)) {
             String value = setting.get(RANKING_SETTING_RANKING_CONTENT_TYPE).getAsString().trim().toUpperCase();
             try {
-                rankingContentType = PixivURL.RankingContentType.valueOf(value.startsWith("TYPE_") ? value : "TYPE_" + value);
+                rankingContentType = RankingContentType.valueOf(value.startsWith("TYPE_") ? value : "TYPE_" + value);
             } catch(IllegalArgumentException e) {
                 log.warn("群组ID [{}] - 无效的RankingContentType设定值: {}", id, value);
             }
@@ -270,7 +274,7 @@ public class BotAdminCommandProcess {
         }
 
         AutoSender sender = new RandomRankingArtworksSender(
-                MessageSenderBuilder.getMessageSender(MessageSource.Group, id),
+                MessageSenderBuilder.getMessageSender(MessageSource.GROUP, id),
                 id,
                 rankingStart,
                 rankingEnd,
@@ -293,7 +297,10 @@ public class BotAdminCommandProcess {
      * @throws NoSuchElementException 当这个群号没有定时器的时候抛出异常
      */
     @Command
-    public static String removePushGroup(@Argument(name = "$fromGroup") long fromGroup, @Argument(name = "group", force = false) long id) {
+    public static String removePushGroup(
+            @Argument(name = "$fromGroup") long fromGroup,
+            @Argument(name = "group", force = false) long id
+    ) {
         long group = id <= 0 ? fromGroup : id;
         RandomIntervalSendTimer.getTimerById(group).destroy();
         pushInfoMap.remove(group);
@@ -324,7 +331,8 @@ public class BotAdminCommandProcess {
             log.debug("{} - Report: {}", illustIdStr, report);
             String reason = report.get("reason").isJsonNull() ? "" : report.get("reason").getAsString();
             msgBuilder.append(count).append(". 作品Id: ").append(illustIdStr)
-                    .append("(").append(dateFormat.format(new Date(report.get("reportTime").getAsLong()))).append(")：\n")
+                    .append("(").append(
+                            dateFormat.format(new Date(report.get("reportTime").getAsLong()))).append(")：\n")
                     .append("报告者QQ：").append(report.get("fromQQ").getAsLong()).append("\n")
                     .append("报告所在群：").append(report.get("fromGroup").getAsLong()).append("\n")
                     .append("报告原因：\n").append(reason).append("\n");

src/main/java/net/lamgc/cgj/bot/BotCode.java

@@ -64,7 +64,7 @@ public class BotCode {
 
     private String platformName;
     private String functionName;
-    private Hashtable<String, String> parameter = new Hashtable<>();
+    private final Hashtable<String, String> parameter = new Hashtable<>();
 
     /**
      * 构造一个机器功能码

src/main/java/net/lamgc/cgj/bot/BotCommandProcess.java

@@ -8,12 +8,12 @@ import net.lamgc.cgj.bot.boot.BotGlobal;
 import net.lamgc.cgj.bot.cache.CacheStore;
 import net.lamgc.cgj.bot.cache.CacheStoreCentral;
 import net.lamgc.cgj.bot.cache.JsonRedisCacheStore;
-import net.lamgc.cgj.bot.event.BufferMessageEvent;
-import net.lamgc.cgj.bot.sort.PreLoadDataComparator;
-import net.lamgc.cgj.pixiv.PixivDownload;
+import net.lamgc.cgj.bot.event.BufferedMessageSender;
+import net.lamgc.cgj.bot.sort.PreLoadDataAttribute;
+import net.lamgc.cgj.bot.sort.PreLoadDataAttributeComparator;
+import net.lamgc.cgj.pixiv.*;
 import net.lamgc.cgj.pixiv.PixivDownload.PageQuality;
-import net.lamgc.cgj.pixiv.PixivSearchBuilder;
-import net.lamgc.cgj.pixiv.PixivURL;
+import net.lamgc.cgj.util.PixivUtils;
 import net.lamgc.utils.base.runner.Argument;
 import net.lamgc.utils.base.runner.Command;
 import org.slf4j.Logger;
@@ -23,6 +23,7 @@ import java.io.File;
 import java.io.IOException;
 import java.text.SimpleDateFormat;
 import java.util.*;
+import java.util.regex.Pattern;
 
 @SuppressWarnings({"SameParameterValue"})
 public class BotCommandProcess {
@@ -38,6 +39,8 @@ public class BotCommandProcess {
 
     private final static RankingUpdateTimer updateTimer = new RankingUpdateTimer();
 
+    private final static int SEARCH_PAGE_MAX_ITEM = 60;
+
     public static void initialize() {
         log.info("正在初始化...");
 
@@ -90,7 +93,8 @@ public class BotCommandProcess {
      */
     @Command(commandName = "info")
     public static String artworkInfo(@Argument(name = "$fromGroup") long fromGroup,
-                                     @Argument(name = "id") int illustId) {
+                                     @Argument(name = "id") int illustId)
+    throws InterruptedException {
         if(illustId <= 0) {
             return "这个作品Id是错误的！";
         }
@@ -100,21 +104,21 @@ public class BotCommandProcess {
                 return "阅览禁止：该作品已被封印！！";
             }
 
-            JsonObject illustPreLoadData = CacheStoreCentral.getIllustPreLoadData(illustId, false);
+            JsonObject illustPreLoadData = CacheStoreCentral.getCentral().getIllustPreLoadData(illustId, false);
             // 在 Java 6 开始, 编译器会将用'+'进行的字符串拼接将自动转换成StringBuilder拼接
             return "色图姬帮你了解了这个作品的信息！\n" + "---------------- 作品信息 ----------------" +
                     "\n作品Id: " + illustId +
                     "\n作品标题：" + illustPreLoadData.get("illustTitle").getAsString() +
                     "\n作者(作者Id)：" + illustPreLoadData.get("userName").getAsString() +
                     "(" + illustPreLoadData.get("userId").getAsInt() + ")" +
-                    "\n点赞数：" + illustPreLoadData.get(PreLoadDataComparator.Attribute.LIKE.attrName).getAsInt() +
-                    "\n收藏数：" + illustPreLoadData.get(PreLoadDataComparator.Attribute.BOOKMARK.attrName).getAsInt() +
-                    "\n围观数：" + illustPreLoadData.get(PreLoadDataComparator.Attribute.VIEW.attrName).getAsInt() +
-                    "\n评论数：" + illustPreLoadData.get(PreLoadDataComparator.Attribute.COMMENT.attrName).getAsInt() +
-                    "\n页数：" + illustPreLoadData.get(PreLoadDataComparator.Attribute.PAGE.attrName).getAsInt() + "页" +
+                    "\n点赞数：" + illustPreLoadData.get(PreLoadDataAttribute.LIKE.attrName).getAsInt() +
+                    "\n收藏数：" + illustPreLoadData.get(PreLoadDataAttribute.BOOKMARK.attrName).getAsInt() +
+                    "\n围观数：" + illustPreLoadData.get(PreLoadDataAttribute.VIEW.attrName).getAsInt() +
+                    "\n评论数：" + illustPreLoadData.get(PreLoadDataAttribute.COMMENT.attrName).getAsInt() +
+                    "\n页数：" + illustPreLoadData.get(PreLoadDataAttribute.PAGE.attrName).getAsInt() + "页" +
                     "\n作品链接：" + artworksLink(fromGroup, illustId) + "\n" +
                     "---------------- 作品图片 ----------------\n" +
-                    CacheStoreCentral.getImageById(fromGroup, illustId, PageQuality.REGULAR, 1) + "\n" +
+                    CacheStoreCentral.getCentral().getImageById(fromGroup, illustId, PageQuality.REGULAR, 1) + "\n" +
                     "使用 \".cgj image -id " +
                     illustId +
                     "\" 获取原图。\n如有不当作品，可使用\".cgj report -id " +
@@ -139,9 +143,14 @@ public class BotCommandProcess {
             @Argument(name = "$fromGroup") long fromGroup,
             @Argument(force = false, name = "date") Date queryTime,
             @Argument(force = false, name = "force") boolean force,
-            @Argument(force = false, name = "mode", defaultValue = "DAILY") String contentMode,
-            @Argument(force = false, name = "type", defaultValue = "ILLUST") String contentType
-    ) {
+            @Argument(force = false, name = "mode", defaultValue = "DAILY") RankingMode contentMode,
+            @Argument(force = false, name = "type", defaultValue = "ALL") RankingContentType contentType,
+            @Argument(force = false, name = "p", defaultValue = "1") int pageIndex
+    ) throws InterruptedException {
+        if(pageIndex <= 0) {
+            return "色图姬找不到指定页数的排行榜!";
+        }
+
         Date queryDate = queryTime;
         if (queryDate == null) {
             queryDate = new Date();
@@ -161,33 +170,13 @@ public class BotCommandProcess {
             }
         }
 
-        PixivURL.RankingMode mode;
-        try {
-            String rankingModeValue = contentMode.toUpperCase();
-            mode = PixivURL.RankingMode.valueOf(rankingModeValue.startsWith("MODE_") ?
-                    rankingModeValue : "MODE_" + rankingModeValue);
-        } catch (IllegalArgumentException e) {
-            log.warn("无效的RankingMode值: {}", contentMode);
-            return "参数无效, 请查看帮助信息";
-        }
-
-        PixivURL.RankingContentType type;
-        try {
-            String contentTypeValue = contentType.toUpperCase();
-            type = PixivURL.RankingContentType.valueOf(
-                    contentTypeValue.startsWith("TYPE_") ? contentTypeValue : "TYPE_" + contentTypeValue);
-        } catch (IllegalArgumentException e) {
-            log.warn("无效的RankingContentType值: {}", contentType);
-            return "参数无效, 请查看帮助信息";
-        }
-
-        if(!type.isSupportedMode(mode)) {
+        if(!contentType.isSupportedMode(contentMode)) {
             log.warn("RankingContentType不支持指定的RankingMode.(ContentType: {}, RankingMode: {})",
-                    type.name(), mode.name());
+                    contentType.name(), contentMode.name());
             return "不支持的内容类型或模式!";
         }
 
-        StringBuilder resultBuilder = new StringBuilder(mode.name() + " - 以下是 ")
+        StringBuilder resultBuilder = new StringBuilder(contentMode.name() + " - 以下是 ")
                 .append(new SimpleDateFormat("yyyy-MM-dd").format(queryDate)).append(" 的Pixiv插画排名榜前十名：\n");
         try {
             int index = 0;
@@ -209,8 +198,10 @@ public class BotCommandProcess {
                 log.warn("配置项 {} 的参数值格式有误!", imageLimitPropertyKey);
             }
 
-            List<JsonObject> rankingInfoList = CacheStoreCentral
-                    .getRankingInfoByCache(type, mode, queryDate, 1, Math.max(0, itemLimit), false);
+            int startsIndex = itemLimit * pageIndex - (itemLimit - 1);
+            List<JsonObject> rankingInfoList = CacheStoreCentral.getCentral()
+                    .getRankingInfoByCache(contentType, contentMode, queryDate,
+                            Math.max(1, startsIndex), Math.max(0, itemLimit), false);
             if(rankingInfoList.isEmpty()) {
                 return "无法查询排行榜，可能排行榜尚未更新。";
             }
@@ -228,8 +219,8 @@ public class BotCommandProcess {
                         .append(pagesCount).append("p.\n");
                 if (index <= imageLimit) {
                     resultBuilder
-                            .append(CacheStoreCentral
-                                    .getImageById(fromGroup, illustId, PixivDownload.PageQuality.REGULAR, 1))
+                            .append(CacheStoreCentral.getCentral()
+                                    .getImageById(fromGroup, illustId, PageQuality.REGULAR, 1))
                             .append("\n");
                 }
             }
@@ -259,32 +250,32 @@ public class BotCommandProcess {
             @Argument(name = "$fromGroup") long fromGroup,
             @Argument(force = false, name = "mode", defaultValue = "DAILY") String contentMode,
             @Argument(force = false, name = "type", defaultValue = "ILLUST") String contentType) {
-        PixivURL.RankingMode mode;
+        RankingMode mode;
         try {
             String rankingModeValue = contentMode.toUpperCase();
-            mode = PixivURL.RankingMode.valueOf(rankingModeValue.startsWith("MODE_") ?
+            mode = RankingMode.valueOf(rankingModeValue.startsWith("MODE_") ?
                     rankingModeValue : "MODE_" + rankingModeValue);
         } catch (IllegalArgumentException e) {
             log.warn("无效的RankingMode值: {}", contentMode);
             return "参数无效, 请查看帮助信息";
         }
 
-        PixivURL.RankingContentType type;
+        RankingContentType type;
         try {
             String contentTypeValue = contentType.toUpperCase();
-            type = PixivURL.RankingContentType.valueOf(
+            type = RankingContentType.valueOf(
                     contentTypeValue.startsWith("TYPE_") ? contentTypeValue : "TYPE_" + contentTypeValue);
         } catch (IllegalArgumentException e) {
             log.warn("无效的RankingContentType值: {}", contentType);
             return "参数无效, 请查看帮助信息";
         }
 
-        BufferMessageEvent event = new BufferMessageEvent();
+        BufferedMessageSender bufferedSender = new BufferedMessageSender();
         RandomRankingArtworksSender artworksSender = 
-            new RandomRankingArtworksSender(event, fromGroup, 1, 200, mode, type,
+            new RandomRankingArtworksSender(bufferedSender, fromGroup, 1, 200, mode, type,
                     PageQuality.ORIGINAL);
         artworksSender.send();
-        return event.getBufferMessage();
+        return bufferedSender.getBufferContent();
     }
 
     /**
@@ -309,14 +300,11 @@ public class BotCommandProcess {
             @Argument(name = "in", force = false) String includeKeywords,
             @Argument(name = "ex", force = false) String excludeKeywords,
             @Argument(name = "option", force = false) String contentOption,
-            @Argument(name = "page", force = false, defaultValue = "1") int pagesIndex
-    ) throws IOException {
-        log.info("正在执行搜索...");
-        JsonObject resultBody = CacheStoreCentral
-                .getSearchBody(content, type, area, includeKeywords, excludeKeywords, contentOption);
-
-        StringBuilder result = new StringBuilder("内容 " + content + " 的搜索结果：\n");
-        log.debug("正在处理信息...");
+            @Argument(name = "p", force = false, defaultValue = "1") int pagesIndex
+    ) throws IOException, InterruptedException {
+        PixivSearchLinkBuilder searchLinkBuilder = PixivUtils.buildSearchLinkBuilderFromString(content, type, area,
+                        includeKeywords, excludeKeywords, contentOption, pagesIndex);
+        log.debug("正在执行搜索...");
         int limit = 8;
         try {
             limit = Integer.parseInt(SettingProperties.
@@ -324,85 +312,112 @@ public class BotCommandProcess {
         } catch (Exception e) {
             log.warn("参数转换异常!将使用默认值(" + limit + ")", e);
         }
+
         int totalCount = 0;
-        for (PixivSearchBuilder.SearchArea searchArea : PixivSearchBuilder.SearchArea.values()) {
-            if (!resultBody.has(searchArea.jsonKey) ||
-                    resultBody.getAsJsonObject(searchArea.jsonKey).getAsJsonArray("data").size() == 0) {
-                log.debug("返回数据不包含 {}", searchArea.jsonKey);
-                continue;
-            }
-            JsonArray illustsArray = resultBody
-                    .getAsJsonObject(searchArea.jsonKey).getAsJsonArray("data");
-            ArrayList<JsonElement> illustsList = new ArrayList<>();
-            illustsArray.forEach(illustsList::add);
-            illustsList.sort(new PreLoadDataComparator(PreLoadDataComparator.Attribute.LIKE));
+        StringBuilder result = new StringBuilder("内容 " + content + " 的搜索结果：\n");
+        List<JsonObject> artworkList = getSearchResult(searchLinkBuilder, fromGroup, limit, pagesIndex);
+        artworkList.sort(new PreLoadDataAttributeComparator(PreLoadDataAttribute.LIKE));
+        int startIndex = limit * pagesIndex - limit + 1;
+        int pageStartIndex = startIndex % SEARCH_PAGE_MAX_ITEM;
+        for(int index = pageStartIndex; totalCount < limit && index < artworkList.size(); index++) {
+            int illustId = artworkList.get(index - 1).get("illustId").getAsInt();
+            // 预加载数据有更多信息可以提供
+            JsonObject artworkPreLoadData = CacheStoreCentral.getCentral()
+                    .getIllustPreLoadData(illustId, false);
 
-            log.info("已找到与 {} 相关插图信息({})：", content, searchArea.name().toLowerCase());
-            int count = 1;
-            for (JsonElement jsonElement : illustsList) {
-                if (count > limit) {
-                    break;
-                }
-                JsonObject illustObj = jsonElement.getAsJsonObject();
-                if (!illustObj.has("illustId")) {
-                    continue;
-                }
-                int illustId = illustObj.get("illustId").getAsInt();
-                StringBuilder builder = new StringBuilder("[");
-                illustObj.get("tags").getAsJsonArray().forEach(el -> builder.append(el.getAsString()).append(", "));
-                builder.replace(builder.length() - 2, builder.length(), "]");
-                log.debug("{} ({} / {})\n\t作品id: {}, \n\t作者名(作者id): {} ({}), \n\t" +
-                                "作品标题: {}, \n\t作品Tags: {}, \n\t页数: {}页, \n\t作品链接: {}",
-                        searchArea.name(),
-                        count,
-                        illustsList.size(),
-                        illustId,
-                        illustObj.get("userName").getAsString(),
-                        illustObj.get("userId").getAsInt(),
-                        illustObj.get("illustTitle").getAsString(),
-                        builder,
-                        illustObj.get("pageCount").getAsInt(),
-                        PixivURL.getPixivRefererLink(illustId)
-                );
-
-                String imageMsg =
-                        CacheStoreCentral.getImageById(fromGroup, illustId, PixivDownload.PageQuality.REGULAR, 1);
-                if (isNoSafe(illustId, SettingProperties.getProperties(fromGroup), false)) {
-                    log.warn("作品Id {} 为R-18作品, 跳过.", illustId);
-                    continue;
-                } else if(isReported(illustId)) {
-                    log.warn("作品Id {} 被报告, 正在等待审核, 跳过该作品.", illustId);
-                    continue;
-                }
-
-                JsonObject illustPreLoadData = CacheStoreCentral.getIllustPreLoadData(illustId, false);
-                result.append(searchArea.name()).append(" (").append(count).append(" / ")
-                        .append(limit).append(")\n\t作品id: ").append(illustId)
-                        .append(", \n\t作者名: ").append(illustObj.get("userName").getAsString())
-                        .append("\n\t作品标题: ").append(illustObj.get("illustTitle").getAsString())
-                        .append("\n\t作品页数: ").append(illustObj.get("pageCount").getAsInt()).append("页")
-                        .append("\n\t点赞数：")
-                        .append(illustPreLoadData.get(PreLoadDataComparator.Attribute.LIKE.attrName).getAsInt())
-                        .append("\n\t收藏数：")
-                        .append(illustPreLoadData.get(PreLoadDataComparator.Attribute.BOOKMARK.attrName).getAsInt())
-                        .append("\n\t围观数：")
-                        .append(illustPreLoadData.get(PreLoadDataComparator.Attribute.VIEW.attrName).getAsInt())
-                        .append("\n\t评论数：")
-                        .append(illustPreLoadData.get(PreLoadDataComparator.Attribute.COMMENT.attrName).getAsInt())
-                        .append("\n").append(imageMsg).append("\n");
-                count++;
-                totalCount++;
-            }
-            if (count > limit) {
-                break;
-            }
+            // 构造消息内容
+            result.append(startIndex++).append(". （").append(artworkPreLoadData.get("illustId").getAsInt()).append("） ")
+                    .append(artworkPreLoadData.get("illustTitle").getAsString());
+            result.append("\n\t").append("作者：").append(artworkPreLoadData.get("userName").getAsString());
+            result.append("\n\t").append("作品页数：").append(artworkPreLoadData.get("pageCount").getAsInt()).append(" 页");
+            result.append("\n\t").append("点赞数：")
+                    .append(artworkPreLoadData.get(PreLoadDataAttribute.LIKE.attrName).getAsInt()).append(" 页");
+            result.append("\n\t").append("收藏数：")
+                    .append(artworkPreLoadData.get(PreLoadDataAttribute.BOOKMARK.attrName).getAsInt()).append(" 页");
+            result.append("\n\t").append("围观数：")
+                    .append(artworkPreLoadData.get(PreLoadDataAttribute.VIEW.attrName).getAsInt()).append(" 页");
+            result.append("\n\t").append("评论数：")
+                    .append(artworkPreLoadData.get(PreLoadDataAttribute.COMMENT.attrName).getAsInt()).append(" 页");
+            result.append(CacheStoreCentral.getCentral()
+                    .getImageById(fromGroup, illustId, PageQuality.REGULAR, 1)).append("\n");
+            totalCount++;
         }
+
         return totalCount <= 0 ?
                 "搜索完成，未找到相关作品。" :
                 Strings.nullToEmpty(result.toString()) + "预览图片并非原图，使用“.cgj image -id 作品id”获取原图\n" +
                 "如有不当作品，可使用\".cgj report -id 作品id\"向色图姬反馈。";
     }
 
+    /**
+     * 获取 length 涉及的多个页的搜索结果.
+     * 例如:
+     *  pageMaxItem = 60;
+     *  length = 150;
+     *  page = 3;
+     * 那么:
+     *  endItemIndex = length * page = 450;
+     *  startItemIndex = endItemIndex - length + 1 = 301;
+     *  startPageIndex = ceil(startItemIndex / pageMaxItem) = 6;
+     *  pageRange = ceil((endItemIndex - length + 1) / pageMaxItem) = 3;
+     *  endPageIndex = startPageIndex - pageRange - 1 = 8;
+     * 该方法将会取搜索结果的 6 ~ 8 页结果并返回;
+     * @param searchLinkBuilder 已构造好除 Page 参数外其他参数的 {@link PixivSearchLinkBuilder}
+     * @param length 所需结果的范围
+     * @param page 所需结果的页数
+     * @return 返回包含范围的涉及页面所有搜索结果.
+     * @throws IOException 如获取发生异常则抛出.
+     */
+    private static List<JsonObject> getSearchResult(PixivSearchLinkBuilder searchLinkBuilder, long groupId, int length, int page) throws IOException {
+        List<JsonObject> artworkList = new ArrayList<>(length);
+
+        int endsItemIndex = length * page;
+        int startsItemIndex = endsItemIndex - length + 1;
+        int startPageIndex = (int) Math.ceil(startsItemIndex / (double) SEARCH_PAGE_MAX_ITEM);
+        int pageRange = (int) Math.ceil((endsItemIndex - startsItemIndex) / (double) SEARCH_PAGE_MAX_ITEM);
+        PixivSearchAttribute areaAttribute = PixivSearchAttribute.valueOf(searchLinkBuilder.getSearchArea().toString());
+        Properties properties = SettingProperties.getProperties(groupId);
+        int expectedQuantity = pageRange * SEARCH_PAGE_MAX_ITEM;
+        for(int pageIndex = startPageIndex;
+            pageIndex <= startPageIndex + pageRange - 1 || artworkList.size() < length || artworkList.size() < expectedQuantity;
+            pageIndex++) {
+            searchLinkBuilder.setPage(pageIndex);
+            JsonObject searchBody = CacheStoreCentral.getCentral().getSearchBody(searchLinkBuilder);
+            for(String areaAttributeName : areaAttribute.attributeNames) {
+                JsonObject areaResult = searchBody.getAsJsonObject(areaAttributeName);
+                if(areaResult == null || !areaResult.has("data")) {
+                    log.debug("作品类型属性 {} 无搜索结果, 跳过...", areaAttributeName);
+                    continue;
+                }
+
+                JsonArray areaArray = areaResult.getAsJsonArray("data");
+                for(JsonElement element : areaArray) {
+                    JsonObject artworkInfo = element.getAsJsonObject();
+                    if(!artworkInfo.has("illustId")) {
+                        log.warn("发现未含有illustId的JsonObject: '{}'", artworkInfo.toString());
+                        continue;
+                    }
+                    final int illustId = artworkInfo.get("illustId").getAsInt();
+                    if(isNoSafe(illustId, properties, false)) {
+                        log.warn("作品 {} 为R18作品, 跳过.", illustId);
+                        continue;
+                    } else if(isReported(illustId)) {
+                        log.warn("作品 {} 被报告, 跳过.", illustId);
+                        continue;
+                    }
+                    artworkList.add(artworkInfo);
+                }
+            }
+        }
+
+        // 去重
+        Set<JsonObject> hashSet = new HashSet<>(artworkList.size());
+        hashSet.addAll(artworkList);
+        artworkList.clear();
+        artworkList.addAll(hashSet);
+        return artworkList;
+    }
+
     /**
      * 获取作品页面的下载链接
      * @param illustId 作品Id
@@ -463,7 +478,7 @@ public class BotCommandProcess {
 
     static void clearCache() {
         log.warn("正在清除所有缓存...");
-        CacheStoreCentral.clearCache();
+        CacheStoreCentral.getCentral().clearCache();
         File imageStoreDir = new File(BotGlobal.getGlobal().getDataStoreDir(), "data/image/cgj/");
         File[] listFiles = imageStoreDir.listFiles();
         if (listFiles == null) {
@@ -482,9 +497,9 @@ public class BotCommandProcess {
             @Argument(name = "$fromGroup") long fromGroup,
             @Argument(name = "id") int illustId,
             @Argument(name = "quality", force = false) PixivDownload.PageQuality quality,
-            @Argument(name = "page", force = false, defaultValue = "1") int pageIndex
-    ) {
-        return CacheStoreCentral.getImageById(fromGroup, illustId, quality, pageIndex);
+            @Argument(name = "p", force = false, defaultValue = "1") int pageIndex
+    ) throws InterruptedException {
+        return CacheStoreCentral.getCentral().getImageById(fromGroup, illustId, quality, pageIndex);
     }
 
     /**
@@ -521,6 +536,10 @@ public class BotCommandProcess {
         return reportStore.exists(String.valueOf(illustId));
     }
 
+    /**
+     * Tag过滤表达式
+     */
+    private final static Pattern tagPattern = Pattern.compile(".*R-*18.*");
     /**
      * 检查指定作品是否为r18
      * @param illustId 作品Id
@@ -532,12 +551,12 @@ public class BotCommandProcess {
      */
     public static boolean isNoSafe(int illustId, Properties settingProp, boolean returnRaw)
             throws IOException, NoSuchElementException {
-        JsonObject illustInfo = CacheStoreCentral.getIllustInfo(illustId, false);
+        JsonObject illustInfo = CacheStoreCentral.getCentral().getIllustInfo(illustId, false);
         JsonArray tags = illustInfo.getAsJsonArray("tags");
         boolean rawValue = illustInfo.get("xRestrict").getAsInt() != 0;
         if(!rawValue) {
             for(JsonElement tag : tags) {
-                boolean current = tag.getAsString().matches("R-*18") || tag.getAsString().contains("R18");
+                boolean current = tagPattern.matcher(tag.getAsString()).matches();
                 if (current) {
                     rawValue = true;
                     break;

src/main/java/net/lamgc/cgj/bot/RandomIntervalSendTimer.java

@@ -4,7 +4,6 @@ import com.google.common.base.Throwables;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.lang.reflect.Field;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 
@@ -13,7 +12,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
  */
 public class RandomIntervalSendTimer extends TimerTask {
 
-    private final static Timer timer = new Timer("Thread-RIST", true);
+    private final static Timer timer = new Timer("Thread-RandomIntervalSendTimer", true);
     private final static Logger log = LoggerFactory.getLogger(RandomIntervalSendTimer.class);
     private final static Map<Long, RandomIntervalSendTimer> timerMap = new HashMap<>();
 
@@ -23,7 +22,7 @@ public class RandomIntervalSendTimer extends TimerTask {
     private final long time;
     private final int floatTime;
     private final AtomicBoolean loop = new AtomicBoolean();
-    private final AtomicBoolean start = new AtomicBoolean();
+    private final AtomicBoolean running = new AtomicBoolean();
     private final String hashId = Integer.toHexString(this.hashCode());
 
 
@@ -77,12 +76,17 @@ public class RandomIntervalSendTimer extends TimerTask {
      * @param startNow 现在开始
      * @param loop 是否循环
      */
-    private RandomIntervalSendTimer(long timerId, AutoSender sender, long time, int floatTime, boolean startNow, boolean loop) {
+    private RandomIntervalSendTimer(
+            long timerId,
+            AutoSender sender,
+            long time,
+            int floatTime,
+            boolean startNow,
+            boolean loop) {
         this.timerId = timerId;
         this.sender = sender;
         this.time = time;
         this.floatTime = floatTime;
-        timerMap.put(timerId, this);
         if(startNow) {
             start(loop);
         }
@@ -102,28 +106,29 @@ public class RandomIntervalSendTimer extends TimerTask {
         Date nextDate = new Date();
         nextDate.setTime(nextDate.getTime() + nextDelay);
         log.info("定时器 {} 下一延迟: {}ms ({})", hashId, nextDelay, nextDate);
-        if(start.get()) {
-            try {
-                Field state = this.getClass().getSuperclass().getDeclaredField("state");
-                state.setAccessible(true);
-                state.setInt(this, 0);
-                state.setAccessible(false);
-            } catch (NoSuchFieldException | IllegalAccessException e) {
-                e.printStackTrace();
-                return;
-            }
+        if(running.get()) {
+            reset();
+            return;
         }
-        start.set(true);
+        running.set(true);
         timer.schedule(this, nextDelay);
     }
 
+    public void reset() {
+        timerMap.put(timerId, (RandomIntervalSendTimer) clone());
+    }
+
     @Override
     public void run() {
+        log.info("定时器 {} 开始执行...(Sender: {}@{})", this.hashId, sender.getClass().getSimpleName(), sender.hashCode());
         try {
             sender.send();
         } catch (Exception e) {
-            log.error("定时器 {} 执行时发生异常:\n{}", Integer.toHexString(this.hashCode()), Throwables.getStackTraceAsString(e));
+            log.error("定时器 {} 执行时发生异常:\n{}",
+                    Integer.toHexString(this.hashCode()),
+                    Throwables.getStackTraceAsString(e));
         }
+        log.info("定时器 {} 执行结束.", this.hashId);
         if (this.loop.get()) {
             start();
         }
@@ -135,7 +140,7 @@ public class RandomIntervalSendTimer extends TimerTask {
      */
     @Override
     public boolean cancel() {
-        start.set(false);
+        running.set(false);
         loop.set(false);
         return super.cancel();
     }
@@ -148,4 +153,18 @@ public class RandomIntervalSendTimer extends TimerTask {
         timerMap.remove(this.timerId);
     }
 
+    /**
+     * 克隆一个参数完全一样的TimerTask对象.
+     * @return 返回对象不同, 参数相同的TimerTask对象.
+     */
+    @Override
+    @SuppressWarnings("MethodDoesntCallSuperMethod")
+    public Object clone() {
+        RandomIntervalSendTimer newTimerTask = new RandomIntervalSendTimer(
+                this.timerId, this.sender,
+                time, floatTime,
+                running.get(), loop.get());
+        this.destroy();
+        return newTimerTask;
+    }
 }

src/main/java/net/lamgc/cgj/bot/RandomRankingArtworksSender.java

@@ -4,7 +4,8 @@ import com.google.gson.JsonObject;
 import net.lamgc.cgj.bot.cache.CacheStoreCentral;
 import net.lamgc.cgj.bot.message.MessageSender;
 import net.lamgc.cgj.pixiv.PixivDownload;
-import net.lamgc.cgj.pixiv.PixivURL;
+import net.lamgc.cgj.pixiv.RankingContentType;
+import net.lamgc.cgj.pixiv.RankingMode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -22,8 +23,8 @@ public class RandomRankingArtworksSender extends AutoSender {
     private final long groupId;
     private final int rankingStart;
     private final int rankingStop;
-    private final PixivURL.RankingMode mode;
-    private final PixivURL.RankingContentType contentType;
+    private final RankingMode mode;
+    private final RankingContentType contentType;
     private final PixivDownload.PageQuality quality;
 
     /**
@@ -40,8 +41,8 @@ public class RandomRankingArtworksSender extends AutoSender {
             MessageSender messageSender,
             int rankingStart,
             int rankingStop,
-            PixivURL.RankingMode mode,
-            PixivURL.RankingContentType contentType,
+            RankingMode mode,
+            RankingContentType contentType,
             PixivDownload.PageQuality quality) {
         this(messageSender, 0, rankingStart, rankingStop, mode, contentType, quality);
     }
@@ -62,8 +63,8 @@ public class RandomRankingArtworksSender extends AutoSender {
             long groupId,
             int rankingStart,
             int rankingStop,
-            PixivURL.RankingMode mode,
-            PixivURL.RankingContentType contentType,
+            RankingMode mode,
+            RankingContentType contentType,
             PixivDownload.PageQuality quality) {
         super(messageSender);
         this.groupId = groupId;
@@ -73,7 +74,8 @@ public class RandomRankingArtworksSender extends AutoSender {
         this.rankingStart = rankingStart > 0 ? rankingStart : 1;
         this.rankingStop = rankingStop > 0 ? rankingStop : 150;
         if(this.rankingStart > this.rankingStop) {
-            throw new IndexOutOfBoundsException("rankingStart=" + this.rankingStart + ", rankingStop=" + this.rankingStop);
+            throw new IndexOutOfBoundsException(
+                    "rankingStart=" + this.rankingStart + ", rankingStop=" + this.rankingStop);
         }
         this.quality = quality == null ? PixivDownload.PageQuality.REGULAR : quality;
     }
@@ -92,7 +94,7 @@ public class RandomRankingArtworksSender extends AutoSender {
 
         int selectRanking = rankingStart + new Random().nextInt(rankingStop - rankingStart + 1);
         try {
-            List<JsonObject> rankingList = CacheStoreCentral.getRankingInfoByCache(
+            List<JsonObject> rankingList = CacheStoreCentral.getCentral().getRankingInfoByCache(
                     contentType,
                     mode,
                     queryDate,
@@ -119,7 +121,7 @@ public class RandomRankingArtworksSender extends AutoSender {
             String message = "#美图推送 - 今日排行榜 第 " + rankingInfo.get("rank").getAsInt() + " 名\n" +
                     "标题：" + rankingInfo.get("title").getAsString() + "(" + illustId + ")\n" +
                     "作者：" + rankingInfo.get("user_name").getAsString() + "\n" +
-                    CacheStoreCentral.getImageById(0, illustId, quality, 1) +
+                    CacheStoreCentral.getCentral().getImageById(0, illustId, quality, 1) +
                     "\n如有不当作品，可使用\".cgj report -id " + illustId + "\"向色图姬反馈。";
             getMessageSender().sendMessage(message);
         } catch (Exception e) {

src/main/java/net/lamgc/cgj/bot/RankingUpdateTimer.java

@@ -2,7 +2,8 @@ package net.lamgc.cgj.bot;
 
 import net.lamgc.cgj.bot.event.BotEventHandler;
 import net.lamgc.cgj.bot.event.VirtualLoadMessageEvent;
-import net.lamgc.cgj.pixiv.PixivURL;
+import net.lamgc.cgj.pixiv.RankingContentType;
+import net.lamgc.cgj.pixiv.RankingMode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -64,14 +65,15 @@ public class RankingUpdateTimer {
 
         String dateStr = new SimpleDateFormat("yyyy-MM-dd").format(calendar.getTime());
         log.info("正在获取 {} 期排行榜数据...", calendar.getTime());
-        for (PixivURL.RankingMode rankingMode : PixivURL.RankingMode.values()) {
-            for (PixivURL.RankingContentType contentType : PixivURL.RankingContentType.values()) {
+        for (RankingMode rankingMode : RankingMode.values()) {
+            for (RankingContentType contentType : RankingContentType.values()) {
                 if(!contentType.isSupportedMode(rankingMode)) {
                     log.debug("不支持的类型, 填空值跳过...(类型: {}.{})", rankingMode.name(), contentType.name());
                 }
                 log.info("当前排行榜类型: {}.{}, 正在更新...", rankingMode.name(), contentType.name());
                 BotEventHandler.executeMessageEvent(new VirtualLoadMessageEvent(0,0,
-                                ".cgj ranking -type=" + contentType.name() + " -mode=" + rankingMode.name() + " -force -date " + dateStr));
+                                ".cgj ranking -type=" + contentType.name() +
+                                        " -mode=" + rankingMode.name() + " -force -date " + dateStr));
                 log.info("排行榜 {}.{} 负载指令已投递.", rankingMode.name(), contentType.name());
             }
         }

src/main/java/net/lamgc/cgj/bot/boot/BotGlobal.java

@@ -27,7 +27,7 @@ public final class BotGlobal {
 
     public static BotGlobal getGlobal() {
         if(instance == null) {
-            throw new IllegalStateException("");
+            throw new IllegalStateException("BotGlobal has not been initialized");
         }
         return instance;
     }

src/main/java/net/lamgc/cgj/bot/cache/AutoCleanTimer.java

@@ -18,7 +18,7 @@ public class AutoCleanTimer extends TimerTask {
     private final static Logger log = LoggerFactory.getLogger(AutoCleanTimer.class);
 
     static {
-        cleanTimer.schedule(new AutoCleanTimer(), 100L);
+        cleanTimer.schedule(new AutoCleanTimer(), 100L, 100L);
     }
 
     /**

src/main/java/net/lamgc/cgj/bot/cache/CacheStoreCentral.java

@@ -8,9 +8,13 @@ import net.lamgc.cgj.bot.BotCode;
 import net.lamgc.cgj.bot.BotCommandProcess;
 import net.lamgc.cgj.bot.SettingProperties;
 import net.lamgc.cgj.bot.boot.BotGlobal;
+import net.lamgc.cgj.exception.HttpRequestException;
 import net.lamgc.cgj.pixiv.PixivDownload;
-import net.lamgc.cgj.pixiv.PixivSearchBuilder;
-import net.lamgc.cgj.pixiv.PixivURL;
+import net.lamgc.cgj.pixiv.PixivSearchLinkBuilder;
+import net.lamgc.cgj.pixiv.RankingContentType;
+import net.lamgc.cgj.pixiv.RankingMode;
+import net.lamgc.cgj.util.Locker;
+import net.lamgc.cgj.util.LockerMap;
 import net.lamgc.cgj.util.URLs;
 import net.lamgc.utils.encrypt.MessageDigestUtils;
 import net.lz1998.cq.utils.CQCode;
@@ -31,55 +35,80 @@ import java.util.concurrent.atomic.AtomicInteger;
 @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
 public final class CacheStoreCentral {
 
-    private CacheStoreCentral() {}
-
     private final static Logger log = LoggerFactory.getLogger(CacheStoreCentral.class);
 
-    private final static Hashtable<String, File> imageCache = new Hashtable<>();
+    private static CacheStoreCentral central = new CacheStoreCentral();
 
-    private final static JsonRedisCacheStore imageChecksumCache =
+    public static CacheStoreCentral getCentral() {
+        if(central == null) {
+            initialCentral();
+        }
+        return central;
+    }
+
+    private synchronized static void initialCentral() {
+        if(central != null) {
+            return;
+        }
+
+        central = new CacheStoreCentral();
+    }
+
+    private final LockerMap<String> lockerMap = new LockerMap<>();
+
+    private CacheStoreCentral() {}
+
+    private final Hashtable<String, File> imageCache = new Hashtable<>();
+
+    private final CacheStore<JsonElement> imageChecksumCache =
             new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(),
                     "imageChecksum", BotGlobal.getGlobal().getGson());
 
+    /*
+     * 注意：
+     *      在启用了远端缓存的情况下, 不允许滥用本地缓存
+     *      只有在处理命令中需要短时间大量存取的缓存项才能进行本地缓存(例如PreLoadData需要在排序中大量获取);
+     *      如果没有短时间大量存取的需要, 切勿使用本地缓存
+     */
+
     /**
      * 作品信息缓存 - 不过期
      */
-    private final static CacheStore<JsonElement> illustInfoCache =
+    private final CacheStore<JsonElement> illustInfoCache =
             new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(),
                     "illustInfo", BotGlobal.getGlobal().getGson());
 
     /**
-     * 作品信息预加载数据 - 有效期 2 小时, 本地缓存有效期1 ± 0.25
+     * 作品信息预加载数据 - 有效期 2 小时, 本地缓存有效期 0.5 ± 0.25 小时
      */
-    private final static CacheStore<JsonElement> illustPreLoadDataCache =
+    private final CacheStore<JsonElement> illustPreLoadDataCache =
             CacheStoreUtils.hashLocalHotDataStore(
                     new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(),
-                            "illustPreLoadData", BotGlobal.getGlobal().getGson()),
-                    3600000, 900000);
+                            "illustPreLoadData", BotGlobal.getGlobal().getGson()), 600000, 120000);
     /**
      * 搜索内容缓存, 有效期 2 小时
      */
-    private final static CacheStore<JsonElement> searchBodyCache =
+    private final CacheStore<JsonElement> searchBodyCache =
             new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(),
                     "searchBody", BotGlobal.getGlobal().getGson());
 
     /**
      * 排行榜缓存, 不过期
      */
-    private final static CacheStore<List<JsonObject>> rankingCache =
+    private final CacheStore<List<JsonObject>> rankingCache =
             new JsonObjectRedisListCacheStore(BotGlobal.getGlobal().getRedisServer(),
                     "ranking", BotGlobal.getGlobal().getGson());
 
     /**
      * 作品页面下载链接缓存 - 不过期
      */
-    private final static CacheStore<List<String>> pagesCache =
+    private final CacheStore<List<String>> pagesCache =
             new StringListRedisCacheStore(BotGlobal.getGlobal().getRedisServer(), "imagePages");
 
     /**
      * 清空所有缓存
      */
-    public static void clearCache() {
+    public void clearCache() {
         imageCache.clear();
         illustInfoCache.clear();
         illustPreLoadDataCache.clear();
@@ -96,7 +125,8 @@ public final class CacheStoreCentral {
      * @param pageIndex 指定页面索引, 从1开始
      * @return 如果成功, 返回BotCode, 否则返回错误信息.
      */
-    public static String getImageById(long fromGroup, int illustId, PixivDownload.PageQuality quality, int pageIndex) {
+    public String getImageById(long fromGroup, int illustId, PixivDownload.PageQuality quality, int pageIndex)
+            throws InterruptedException {
         log.debug("IllustId: {}, Quality: {}, PageIndex: {}", illustId, quality.name(), pageIndex);
         if(pageIndex <= 0) {
             log.warn("指定的页数不能小于或等于0: {}", pageIndex);
@@ -118,7 +148,7 @@ public final class CacheStoreCentral {
 
         List<String> pagesList;
         try {
-            pagesList = CacheStoreCentral.getIllustPages(illustId, quality, false);
+            pagesList = getIllustPages(illustId, quality, false);
         } catch (IOException e) {
             log.error("获取下载链接列表时发生异常", e);
             return "发生网络异常，无法获取图片！";
@@ -147,10 +177,10 @@ public final class CacheStoreCentral {
                 ImageChecksum imageChecksum = getImageChecksum(illustId, pageIndex);
                 if(imageChecksum != null) {
                     try {
-                        log.debug("正在检查作品Id {} 第 {} 页图片文件 {} ...", illustId, pageIndex, imageFile.getName());
+                        log.trace("正在检查作品Id {} 第 {} 页图片文件 {} ...", illustId, pageIndex, imageFile.getName());
                         if (ImageChecksum.checkFile(imageChecksum, Files.readAllBytes(imageFile.toPath()))) {
                             imageCache.put(URLs.getResourceName(downloadLink), imageFile);
-                            log.debug("作品Id {} 第 {} 页缓存已补充.", illustId, pageIndex);
+                            log.trace("作品Id {} 第 {} 页缓存已补充.", illustId, pageIndex);
                             return getImageToBotCode(imageFile, false).toString();
                         } else {
                             log.warn("图片文件 {} 校验失败, 重新下载图片...", imageFile.getName());
@@ -171,13 +201,13 @@ public final class CacheStoreCentral {
                 }
             } catch (InterruptedException e) {
                 log.warn("图片缓存被中断", e);
-                return "(错误：图片获取超时)";
+                throw e;
             } catch (Throwable e) {
                 log.error("图片 {} 获取失败:\n{}", illustId + "p" + pageIndex, Throwables.getStackTraceAsString(e));
                 return "(错误: 图片获取出错)";
             }
         } else {
-            log.debug("图片 {} 缓存命中.", fileName);
+            log.trace("图片 {} 缓存命中.", fileName);
         }
 
         return getImageToBotCode(imageCache.get(fileName), false).toString();
@@ -190,7 +220,7 @@ public final class CacheStoreCentral {
      * @return 返回设定好参数的BotCode
      */
     @SuppressWarnings("SameParameterValue")
-    private static BotCode getImageToBotCode(File targetFile, boolean updateCache) {
+    private BotCode getImageToBotCode(File targetFile, boolean updateCache) {
         String fileName = Objects.requireNonNull(targetFile, "targetFile is null").getName();
         BotCode code = BotCode.parse(
                 CQCode.image(BotGlobal.getGlobal().getImageStoreDir().getName() + "/" + fileName));
@@ -208,22 +238,28 @@ public final class CacheStoreCentral {
      * @throws IOException 当Http请求发生异常时抛出
      * @throws NoSuchElementException 当作品未找到时抛出
      */
-    public static JsonObject getIllustInfo(int illustId, boolean flushCache)
+    public JsonObject getIllustInfo(int illustId, boolean flushCache)
             throws IOException, NoSuchElementException {
-        String illustIdStr = buildSyncKey(Integer.toString(illustId));
+        Locker<String> locker = buildSyncKey(Integer.toString(illustId));
+        String illustIdStr = locker.getKey();
         JsonObject illustInfoObj = null;
         if (!illustInfoCache.exists(illustIdStr) || flushCache) {
-            synchronized (illustIdStr) {
-                if (!illustInfoCache.exists(illustIdStr) || flushCache) {
-                    illustInfoObj = BotGlobal.getGlobal().getPixivDownload().getIllustInfoByIllustId(illustId);
-                    illustInfoCache.update(illustIdStr, illustInfoObj, null);
+            try {
+                locker.lock();
+                synchronized (locker) {
+                    if (!illustInfoCache.exists(illustIdStr) || flushCache) {
+                        illustInfoObj = BotGlobal.getGlobal().getPixivDownload().getIllustInfoByIllustId(illustId);
+                        illustInfoCache.update(illustIdStr, illustInfoObj, null);
+                    }
                 }
+            } finally {
+                locker.unlock();
             }
         }
 
         if(Objects.isNull(illustInfoObj)) {
             illustInfoObj = illustInfoCache.getCache(illustIdStr).getAsJsonObject();
-            log.debug("作品Id {} IllustInfo缓存命中.", illustId);
+            log.trace("作品Id {} IllustInfo缓存命中.", illustId);
         }
         return illustInfoObj;
     }
@@ -236,66 +272,79 @@ public final class CacheStoreCentral {
      * @return 成功返回JsonObject对象
      * @throws IOException 当Http请求处理发生异常时抛出
      */
-    public static JsonObject getIllustPreLoadData(int illustId, boolean flushCache) throws IOException {
-        String illustIdStr = buildSyncKey(Integer.toString(illustId));
+    public JsonObject getIllustPreLoadData(int illustId, boolean flushCache) throws IOException {
+        Locker<String> locker = buildSyncKey(Integer.toString(illustId));
+        String illustIdStr = locker.getKey();
         JsonObject result = null;
         if (!illustPreLoadDataCache.exists(illustIdStr) || flushCache) {
-            synchronized (illustIdStr) {
-                if (!illustPreLoadDataCache.exists(illustIdStr) || flushCache) {
-                    log.debug("IllustId {} 缓存失效, 正在更新...", illustId);
-                    JsonObject preLoadDataObj = BotGlobal.getGlobal().getPixivDownload()
-                            .getIllustPreLoadDataById(illustId)
-                            .getAsJsonObject("illust")
-                            .getAsJsonObject(Integer.toString(illustId));
+            try {
+                locker.lock();
+                synchronized (locker) {
+                    if (!illustPreLoadDataCache.exists(illustIdStr) || flushCache) {
+                        log.trace("IllustId {} 缓存失效, 正在更新...", illustId);
+                        JsonObject preLoadDataObj = BotGlobal.getGlobal().getPixivDownload()
+                                .getIllustPreLoadDataById(illustId)
+                                .getAsJsonObject("illust")
+                                .getAsJsonObject(Integer.toString(illustId));
 
-                    long expire = 7200 * 1000;
-                    String propValue = SettingProperties.
-                            getProperty(SettingProperties.GLOBAL, "cache.illustPreLoadData.expire", "7200000");
-                    log.debug("PreLoadData有效时间设定: {}", propValue);
-                    try {
-                        expire = Long.parseLong(propValue);
-                    } catch (Exception e) {
-                        log.warn("全局配置项 \"{}\" 值非法, 已使用默认值: {}", propValue, expire);
+                        long expire = 7200 * 1000;
+                        String propValue = SettingProperties.
+                                getProperty(SettingProperties.GLOBAL, "cache.illustPreLoadData.expire", "7200000");
+                        log.debug("PreLoadData有效时间设定: {}", propValue);
+                        try {
+                            expire = Long.parseLong(propValue);
+                        } catch (Exception e) {
+                            log.warn("全局配置项 \"{}\" 值非法, 已使用默认值: {}", propValue, expire);
+                        }
+
+                        result = preLoadDataObj;
+                        illustPreLoadDataCache.update(illustIdStr, preLoadDataObj, expire);
+                        log.trace("作品Id {} preLoadData缓存已更新(有效时间: {})", illustId, expire);
                     }
-
-                    result = preLoadDataObj;
-                    illustPreLoadDataCache.update(illustIdStr, preLoadDataObj, expire);
-                    log.debug("作品Id {} preLoadData缓存已更新(有效时间: {})", illustId, expire);
                 }
+            } finally {
+                locker.unlock();
             }
         }
 
         if(Objects.isNull(result)) {
             result = illustPreLoadDataCache.getCache(illustIdStr).getAsJsonObject();
-            log.debug("作品Id {} PreLoadData缓存命中.", illustId);
+            log.trace("作品Id {} PreLoadData缓存命中.", illustId);
         }
         return result;
     }
 
-    public static List<String> getIllustPages(int illustId, PixivDownload.PageQuality quality, boolean flushCache)
+    public List<String> getIllustPages(int illustId, PixivDownload.PageQuality quality, boolean flushCache)
             throws IOException {
-        String pagesSign = buildSyncKey(Integer.toString(illustId), ".", quality.name());
+        Locker<String> locker
+                = buildSyncKey(Integer.toString(illustId), ".", quality.name());
+        String pagesSign = locker.getKey();
         List<String> result = null;
         if (!pagesCache.exists(pagesSign) || flushCache) {
-            synchronized (pagesSign) {
-                if (!pagesCache.exists(pagesSign) || flushCache) {
-                    List<String> linkList = PixivDownload
-                            .getIllustAllPageDownload(BotGlobal.getGlobal().getPixivDownload().getHttpClient(),
-                                    BotGlobal.getGlobal().getPixivDownload().getCookieStore(), illustId, quality);
-                    result = linkList;
-                    pagesCache.update(pagesSign, linkList, null);
+            try {
+                locker.lock();
+                synchronized (locker) {
+                    if (!pagesCache.exists(pagesSign) || flushCache) {
+                        List<String> linkList = PixivDownload
+                                .getIllustAllPageDownload(BotGlobal.getGlobal().getPixivDownload().getHttpClient(),
+                                        BotGlobal.getGlobal().getPixivDownload().getCookieStore(), illustId, quality);
+                        result = linkList;
+                        pagesCache.update(pagesSign, linkList, null);
+                    }
                 }
+            } finally {
+                locker.unlock();
             }
         }
 
         if(Objects.isNull(result)) {
             result = pagesCache.getCache(pagesSign);
-            log.debug("作品Id {} Pages缓存命中.", illustId);
+            log.trace("作品Id {} Pages缓存命中.", illustId);
         }
         return result;
     }
 
-    private final static Random expireTimeFloatRandom = new Random();
+    private final Random expireTimeFloatRandom = new Random();
     /**
      * 获取排行榜
      * @param contentType 排行榜类型
@@ -307,9 +356,9 @@ public final class CacheStoreCentral {
      * @return 成功返回有值List, 失败且无异常返回空
      * @throws IOException 获取异常时抛出
      */
-    public static List<JsonObject> getRankingInfoByCache(PixivURL.RankingContentType contentType,
-                                                         PixivURL.RankingMode mode,
-                                                         Date queryDate, int start, int range, boolean flushCache)
+    public List<JsonObject> getRankingInfoByCache(RankingContentType contentType,
+                                                  RankingMode mode,
+                                                  Date queryDate, int start, int range, boolean flushCache)
             throws IOException {
         if(!contentType.isSupportedMode(mode)) {
             log.warn("试图获取不支持的排行榜类型已拒绝.(ContentType: {}, RankingMode: {})", contentType.name(), mode.name());
@@ -324,140 +373,105 @@ public final class CacheStoreCentral {
         }
 
         String date = new SimpleDateFormat("yyyyMMdd").format(queryDate);
-        String requestSign = buildSyncKey(contentType.name(), ".", mode.name(), ".", date);
+        Locker<String> locker
+                = buildSyncKey(contentType.name(), ".", mode.name(), ".", date);
+        String requestSign = locker.getKey();
         List<JsonObject> result = null;
         if(!rankingCache.exists(requestSign) || flushCache) {
-            synchronized(requestSign) {
-                if(!rankingCache.exists(requestSign) || flushCache) {
-                    log.debug("Ranking缓存失效, 正在更新...(RequestSign: {})", requestSign);
-                    List<JsonObject> rankingResult = BotGlobal.getGlobal().getPixivDownload()
-                            .getRanking(contentType, mode, queryDate, 1, 500);
-                    long expireTime = 0;
-                    if(rankingResult.size() == 0) {
-                        expireTime = 5400000 + expireTimeFloatRandom.nextInt(1800000);
-                        log.warn("数据获取失败, 将设置浮动有效时间以准备下次更新. (ExpireTime: {}ms)", expireTime);
+            try {
+                locker.lock();
+                synchronized (locker) {
+                    if (!rankingCache.exists(requestSign) || flushCache) {
+                        log.trace("Ranking缓存失效, 正在更新...(RequestSign: {})", requestSign);
+                        List<JsonObject> rankingResult = BotGlobal.getGlobal().getPixivDownload()
+                                .getRanking(contentType, mode, queryDate, 1, 500);
+                        long expireTime = 0;
+                        if (rankingResult.size() == 0) {
+                            expireTime = 5400000 + expireTimeFloatRandom.nextInt(1800000);
+                            log.warn("数据获取失败, 将设置浮动有效时间以准备下次更新. (ExpireTime: {}ms)", expireTime);
+                        }
+                        result = new ArrayList<>(rankingResult).subList(start - 1, start + range - 1);
+                        rankingCache.update(requestSign, rankingResult, expireTime);
+                        log.trace("Ranking缓存更新完成.(RequestSign: {})", requestSign);
                     }
-                    result = new ArrayList<>(rankingResult).subList(start - 1, start + range - 1);
-                    rankingCache.update(requestSign, rankingResult, expireTime);
-                    log.debug("Ranking缓存更新完成.(RequestSign: {})", requestSign);
                 }
+            } finally {
+                locker.unlock();
             }
         }
 
         if (Objects.isNull(result)) {
             result = rankingCache.getCache(requestSign, start - 1, range);
-            log.debug("RequestSign [{}] 缓存命中.", requestSign);
+            log.trace("RequestSign [{}] 缓存命中.", requestSign);
         }
-        log.debug("Result-Length: {}", result.size());
-        return PixivDownload.getRanking(result, start - 1, range);
+        return result;
     }
 
     /**
      * 获取搜索结果
-     * @param content 搜索内容
-     * @param type 类型
-     * @param area 范围
-     * @param includeKeywords 包含关键词
-     * @param excludeKeywords 排除关键词
-     * @param contentOption 内容类型
+     * @param searchBuilder 需要执行搜索的搜索链接构造器
      * @return 返回完整搜索结果
      * @throws IOException 当请求发生异常, 或接口返回异常信息时抛出.
      */
-    public static JsonObject getSearchBody(
-            String content,
-            String type,
-            String area,
-            String includeKeywords,
-            String excludeKeywords,
-            String contentOption) throws IOException {
-        PixivSearchBuilder searchBuilder = new PixivSearchBuilder(Strings.isNullOrEmpty(content) ? "" : content);
-        if (type != null) {
-            try {
-                searchBuilder.setSearchType(PixivSearchBuilder.SearchType.valueOf(type.toUpperCase()));
-            } catch (IllegalArgumentException e) {
-                log.warn("不支持的SearchType: {}", type);
-            }
-        }
-        if (area != null) {
-            try {
-                searchBuilder.setSearchArea(PixivSearchBuilder.SearchArea.valueOf(area));
-            } catch (IllegalArgumentException e) {
-                log.warn("不支持的SearchArea: {}", area);
-            }
-        }
-        if (contentOption != null) {
-            try {
-                searchBuilder.setSearchContentOption(PixivSearchBuilder.SearchContentOption.valueOf(contentOption));
-            } catch (IllegalArgumentException e) {
-                log.warn("不支持的SearchContentOption: {}", contentOption);
-            }
-        }
-
-        if (!Strings.isNullOrEmpty(includeKeywords)) {
-            for (String keyword : includeKeywords.split(";")) {
-                searchBuilder.removeExcludeKeyword(keyword.trim());
-                searchBuilder.addIncludeKeyword(keyword.trim());
-                log.debug("已添加关键字: {}", keyword);
-            }
-        }
-        if (!Strings.isNullOrEmpty(excludeKeywords)) {
-            for (String keyword : excludeKeywords.split(";")) {
-                searchBuilder.removeIncludeKeyword(keyword.trim());
-                searchBuilder.addExcludeKeyword(keyword.trim());
-                log.debug("已添加排除关键字: {}", keyword);
-            }
-        }
-
-        log.info("正在搜索作品, 条件: {}", searchBuilder.getSearchCondition());
-
-        String requestUrl = searchBuilder.buildURL().intern();
+    public JsonObject getSearchBody(PixivSearchLinkBuilder searchBuilder) throws IOException {
+        log.debug("正在搜索作品, 条件: {}", searchBuilder.getSearchCondition());
+        String requestUrl = searchBuilder.buildURL();
+        String searchIdentify =
+                requestUrl.substring(requestUrl.lastIndexOf("/", requestUrl.lastIndexOf("/") - 1) + 1);
+        Locker<String> locker =
+                buildSyncKey(searchIdentify);
         log.debug("RequestUrl: {}", requestUrl);
         JsonObject resultBody = null;
-        if(!searchBodyCache.exists(requestUrl)) {
-            synchronized (requestUrl) {
-                if (!searchBodyCache.exists(requestUrl)) {
-                    log.debug("searchBody缓存失效, 正在更新...");
-                    JsonObject jsonObject;
-                    HttpGet httpGetRequest = BotGlobal.getGlobal().getPixivDownload().
-                            createHttpGetRequest(requestUrl);
-                    HttpResponse response = BotGlobal.getGlobal().getPixivDownload().
-                            getHttpClient().execute(httpGetRequest);
+        if(!searchBodyCache.exists(searchIdentify)) {
+            try {
+                locker.lock();
+                synchronized (locker) {
+                    if (!searchBodyCache.exists(searchIdentify)) {
+                        log.trace("searchBody缓存失效, 正在更新...");
+                        JsonObject jsonObject;
+                        HttpGet httpGetRequest = BotGlobal.getGlobal().getPixivDownload().
+                                createHttpGetRequest(requestUrl);
+                        HttpResponse response = BotGlobal.getGlobal().getPixivDownload().
+                                getHttpClient().execute(httpGetRequest);
 
-                    String responseBody = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
-                    log.debug("ResponseBody: {}", responseBody);
-                    jsonObject = BotGlobal.getGlobal().getGson().fromJson(responseBody, JsonObject.class);
+                        String responseBody = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
+                        log.trace("ResponseBody: {}", responseBody);
+                        jsonObject = BotGlobal.getGlobal().getGson().fromJson(responseBody, JsonObject.class);
 
-                    if (jsonObject.get("error").getAsBoolean()) {
-                        log.error("接口请求错误, 错误信息: {}", jsonObject.get("message").getAsString());
-                        throw new IOException("Interface Request Error: " + jsonObject.get("message").getAsString());
+                        if (jsonObject.get("error").getAsBoolean()) {
+                            log.error("接口请求错误, 错误信息: {}", jsonObject.get("message").getAsString());
+                            throw new HttpRequestException(response.getStatusLine(), responseBody);
+                        }
+
+                        long expire = 7200 * 1000;
+                        String propValue = SettingProperties
+                                .getProperty(SettingProperties.GLOBAL, "cache.searchBody.expire", "7200000");
+                        try {
+                            expire = Long.parseLong(propValue);
+                        } catch (Exception e) {
+                            log.warn("全局配置项 \"{}\" 值非法, 已使用默认值: {}", propValue, expire);
+                        }
+                        resultBody = jsonObject;
+                        searchBodyCache.update(searchIdentify, jsonObject, expire);
+                        log.trace("searchBody缓存已更新(有效时间: {})", expire);
+                    } else {
+                        log.trace("搜索缓存命中.");
                     }
-
-                    long expire = 7200 * 1000;
-                    String propValue = SettingProperties
-                            .getProperty(SettingProperties.GLOBAL, "cache.searchBody.expire", "7200000");
-                    try {
-                        expire = Long.parseLong(propValue);
-                    } catch (Exception e) {
-                        log.warn("全局配置项 \"{}\" 值非法, 已使用默认值: {}", propValue, expire);
-                    }
-                    resultBody = jsonObject.getAsJsonObject().getAsJsonObject("body");
-                    searchBodyCache.update(requestUrl, jsonObject, expire);
-                    log.debug("searchBody缓存已更新(有效时间: {})", expire);
-                } else {
-                    log.debug("搜索缓存命中.");
                 }
+            } finally {
+                locker.unlock();
             }
         } else {
-            log.debug("搜索缓存命中.");
+            log.trace("搜索缓存命中.");
         }
 
         if(Objects.isNull(resultBody)) {
-            resultBody = searchBodyCache.getCache(requestUrl).getAsJsonObject().getAsJsonObject("body");
+            resultBody = searchBodyCache.getCache(searchIdentify).getAsJsonObject();
         }
-        return resultBody;
+        return resultBody.getAsJsonObject("body");
     }
 
-    protected static ImageChecksum getImageChecksum(int illustId, int pageIndex) {
+    protected ImageChecksum getImageChecksum(int illustId, int pageIndex) {
         String cacheKey = illustId + ":" + pageIndex;
         if(!imageChecksumCache.exists(cacheKey)) {
             return null;
@@ -466,7 +480,7 @@ public final class CacheStoreCentral {
         }
     }
 
-    protected static void setImageChecksum(ImageChecksum checksum) {
+    protected void setImageChecksum(ImageChecksum checksum) {
         String cacheKey = checksum.getIllustId() + ":" + checksum.getPage();
         imageChecksumCache.update(cacheKey, ImageChecksum.toJsonObject(checksum), 0);
     }
@@ -476,12 +490,12 @@ public final class CacheStoreCentral {
      * @param keys String对象
      * @return 合并后, 如果常量池存在合并后的结果, 则返回常量池中的对象, 否则存入常量池后返回.
      */
-    private static String buildSyncKey(String... keys) {
+    private Locker<String> buildSyncKey(String... keys) {
         StringBuilder sb = new StringBuilder();
         for (String string : keys) {
             sb.append(string);
         }
-        return sb.toString().intern();
+        return lockerMap.createLocker(sb.toString(), true);
     }
 
     /**

src/main/java/net/lamgc/cgj/bot/cache/HotDataCacheStore.java

@@ -75,6 +75,9 @@ public class HotDataCacheStore<T> implements CacheStore<T>, Cleanable {
             log.trace("Current缓存库更新完成.");
             result = parentResult;
         } else {
+            // 更新该Key的过期时间
+            current.update(key, result,
+                    expireTime + (expireFloatRange <= 0 ? 0 : random.nextInt(expireFloatRange)));
             log.trace("Current缓存库缓存命中.");
         }
         return result;
@@ -138,10 +141,14 @@ public class HotDataCacheStore<T> implements CacheStore<T>, Cleanable {
      * <p>该方法仅清理Current缓存库, 不会对上游缓存库造成影响.</p>
      */
     @Override
-    public void clean() {
-        for(String key : this.current.keys()) {
-            if(current.exists(key)) {
-                current.remove(key);
+    public void clean() throws Exception {
+        if(current instanceof Cleanable) {
+            ((Cleanable) current).clean();
+        } else {
+            for(String key : this.current.keys()) {
+                if (!current.exists(key)) {
+                    current.remove(key);
+                }
             }
         }
     }

src/main/java/net/lamgc/cgj/bot/cache/ImageCacheHandler.java

@@ -1,7 +1,7 @@
 package net.lamgc.cgj.bot.cache;
 
 import net.lamgc.cgj.bot.boot.BotGlobal;
-import net.lamgc.cgj.bot.cache.exception.HttpRequestException;
+import net.lamgc.cgj.exception.HttpRequestException;
 import net.lamgc.cgj.pixiv.PixivURL;
 import net.lamgc.cgj.util.URLs;
 import net.lamgc.utils.event.EventHandler;
@@ -38,7 +38,7 @@ public class ImageCacheHandler implements EventHandler {
         }
 
         try {
-            log.info("图片 {} Event正在进行...({})", event.getStoreFile().getName(), Integer.toHexString(event.hashCode()));
+            log.debug("图片 {} Event正在进行...({})", event.getStoreFile().getName(), Integer.toHexString(event.hashCode()));
             File storeFile = event.getStoreFile();
             log.debug("正在缓存图片 {} (Path: {})", storeFile.getName(), storeFile.getAbsolutePath());
             try {
@@ -66,7 +66,7 @@ public class ImageCacheHandler implements EventHandler {
                 throw requestException;
             }
 
-            log.debug("正在下载...(Content-Length: {}KB)", response.getEntity().getContentLength() / 1024);
+            log.trace("正在下载...(Content-Length: {}KB)", response.getEntity().getContentLength() / 1024);
             ByteArrayOutputStream bufferOutputStream = new ByteArrayOutputStream();
             try(FileOutputStream fileOutputStream = new FileOutputStream(storeFile)) {
                 Streams.copy(response.getEntity().getContent(), bufferOutputStream, false);
@@ -80,14 +80,14 @@ public class ImageCacheHandler implements EventHandler {
                             );
                 bufferInputStream.reset();
                 Streams.copy(bufferInputStream, fileOutputStream, false);
-                CacheStoreCentral.setImageChecksum(imageChecksum);
+                CacheStoreCentral.getCentral().setImageChecksum(imageChecksum);
             } catch (IOException e) {
                 log.error("下载图片时发生异常", e);
                 throw e;
             }
             event.getImageCache().put(URLs.getResourceName(event.getDownloadLink()), storeFile);
         } finally {
-            log.info("图片 {} Event结束({})", event.getStoreFile().getName(), Integer.toHexString(event.hashCode()));
+            log.debug("图片 {} Event结束({})", event.getStoreFile().getName(), Integer.toHexString(event.hashCode()));
             cacheQueue.remove(event);
         }
     }

src/main/java/net/lamgc/cgj/bot/cache/ImageCacheStore.java

@@ -7,7 +7,7 @@ import com.google.gson.JsonObject;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import net.lamgc.cgj.bot.cache.exception.HttpRequestException;
+import net.lamgc.cgj.exception.HttpRequestException;
 
 import java.util.Hashtable;
 import java.util.Map;
@@ -66,17 +66,17 @@ public final class ImageCacheStore {
             // 置任务状态
             task.taskState.set(TaskState.RUNNING);
 
-            Throwable throwable = null;
+            Future<Throwable> future = imageCacheExecutor.submit(() -> {
+                try {
+                    handler.getImageToCache(cacheObject);
+                } catch (Throwable e) {
+                    return e;
+                }
+                return null;
+            });
+            Throwable throwable;
             try {
-                throwable = imageCacheExecutor.submit(() -> {
-                    try {
-                        handler.getImageToCache(cacheObject);
-                    } catch (Throwable e) {
-                        return e;
-                    }
-                    return null;
-                }).get();
-
+                throwable = future.get();
                 if(throwable == null) {
                     task.taskState.set(TaskState.COMPLETE);
                 } else {
@@ -84,6 +84,12 @@ public final class ImageCacheStore {
                 }
             } catch (ExecutionException e) {
                 log.error("执行图片缓存任务时发生异常", e);
+                task.taskState.set(TaskState.ERROR);
+                return e.getCause();
+            } catch (InterruptedException e) {
+                future.cancel(true);
+                task.taskState.set(TaskState.ERROR);
+                throw e;
             }
             return throwable;
         } finally {

src/main/java/net/lamgc/cgj/bot/cache/LocalHashCacheStore.java

@@ -2,10 +2,7 @@ package net.lamgc.cgj.bot.cache;
 
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Date;
-import java.util.Hashtable;
-import java.util.Objects;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;
 
 /**
@@ -149,19 +146,22 @@ public class LocalHashCacheStore<T> implements CacheStore<T>, Cleanable {
     }
 
     @Override
-    public void clean() throws Exception {
+    public void clean() {
         Date currentDate = new Date();
+        Set<String> expireKeySet = new HashSet<>();
         cache.forEach((key, value) -> {
             if(value.isExpire(currentDate)) {
-                cache.remove(key);
+                expireKeySet.add(key);
             }
         });
+
+        expireKeySet.forEach(cache::remove);
     }
 
-    public static class CacheObject<T> implements Comparable<CacheObject<T>> {
+    private static class CacheObject<T> implements Comparable<CacheObject<T>> {
 
-        private AtomicReference<T> value;
-        private AtomicReference<Date> expire;
+        private final AtomicReference<T> value;
+        private final AtomicReference<Date> expire;
 
         public CacheObject(T value, Date expire) {
             this.value = new AtomicReference<>(value);

src/main/java/net/lamgc/cgj/bot/cache/RedisPoolCacheStore.java

@@ -51,27 +51,27 @@ abstract class RedisPoolCacheStore<T> implements CacheStore<T> {
 
     @Override
     public void update(String key, T value, Date expire) {
-        try (Jedis jedis = jedisPool.getResource()) {
+        executeJedisCommand(jedis -> {
             jedis.set(keyPrefix + key, parse(value));
             if(expire != null) {
                 jedis.pexpireAt(keyPrefix + key, expire.getTime());
                 log.debug("已设置Key {} 的过期时间(Expire: {})", key, expire.getTime());
             }
-        }
+        });
     }
 
     @Override
     public T getCache(String key) {
-        try (Jedis jedis = jedisPool.getResource()) {
+        return executeJedisCommand(jedis -> {
             return analysis(jedis.get(keyPrefix + key));
-        }
+        });
     }
 
     @Override
     public boolean exists(String key) {
-        try (Jedis jedis = jedisPool.getResource()) {
+        return executeJedisCommand(jedis -> {
             return jedis.exists(keyPrefix + key);
-        }
+        });
     }
 
     @Override
@@ -81,23 +81,21 @@ abstract class RedisPoolCacheStore<T> implements CacheStore<T> {
 
     @Override
     public boolean clear() {
-        try (Jedis jedis = jedisPool.getResource()) {
+        return executeJedisCommand(jedis -> {
             return jedis.flushDB().equalsIgnoreCase("ok");
-        }
+        });
     }
 
     @Override
     public Set<String> keys() {
-        try (Jedis jedis = jedisPool.getResource()) {
+        return executeJedisCommand(jedis -> {
             return jedis.keys(keyPrefix + "*");
-        }
+        });
     }
 
     @Override
     public boolean remove(String key) {
-        try (Jedis jedis = jedisPool.getResource()) {
-            return jedis.del(keyPrefix + key) == 1;
-        }
+        return executeJedisCommand(jedis -> jedis.del(keyPrefix + key) == 1);
     }
 
     /**

src/main/java/net/lamgc/cgj/bot/event/BotEventHandler.java

@@ -7,17 +7,18 @@ import net.lamgc.cgj.bot.BotAdminCommandProcess;
 import net.lamgc.cgj.bot.BotCommandProcess;
 import net.lamgc.cgj.bot.MessageEventExecutionDebugger;
 import net.lamgc.cgj.bot.SettingProperties;
-import net.lamgc.cgj.util.DateParser;
-import net.lamgc.cgj.util.PagesQualityParser;
+import net.lamgc.cgj.bot.util.parser.DateParser;
+import net.lamgc.cgj.bot.util.parser.PagesQualityParser;
+import net.lamgc.cgj.bot.util.parser.RankingContentTypeParser;
+import net.lamgc.cgj.bot.util.parser.RankingModeParser;
 import net.lamgc.cgj.util.TimeLimitThreadPoolExecutor;
 import net.lamgc.utils.base.runner.ArgumentsRunner;
 import net.lamgc.utils.base.runner.ArgumentsRunnerConfig;
 import net.lamgc.utils.base.runner.exception.DeveloperRunnerException;
 import net.lamgc.utils.base.runner.exception.NoSuchCommandException;
 import net.lamgc.utils.base.runner.exception.ParameterNoFoundException;
-import net.lamgc.utils.event.*;
 import net.lamgc.utils.event.EventObject;
-
+import net.lamgc.utils.event.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -26,7 +27,6 @@ import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -40,17 +40,15 @@ public class BotEventHandler implements EventHandler {
 
     private final static Logger log = LoggerFactory.getLogger(BotEventHandler.class);
 
-    private final static Map<Long, AtomicBoolean> muteStateMap = new Hashtable<>();
-
     /**
      * 消息事件执行器
      */
     private final static EventExecutor executor = new EventExecutor(new TimeLimitThreadPoolExecutor(
-            0,
-            Math.max(Runtime.getRuntime().availableProcessors(), 4),
-            Math.max(Math.max(Runtime.getRuntime().availableProcessors() * 2, 4), 32),
+            180000, // 3min limit
+            Math.max(Runtime.getRuntime().availableProcessors(), 4), // 4 ~ processors
+            Math.min(Math.max(Runtime.getRuntime().availableProcessors() * 2, 8), 32),// (8 ~ processors * 2) ~ 32
             30L,
-    TimeUnit.SECONDS,
+            TimeUnit.SECONDS,
             new LinkedBlockingQueue<>(1536),
             new ThreadFactoryBuilder()
                     .setNameFormat("CommandProcess-%d")
@@ -69,11 +67,21 @@ public class BotEventHandler implements EventHandler {
             return;
         }
 
+        executor.setEnableEventResend(true);
         executor.setEventUncaughtExceptionHandler(new EventUncaughtExceptionHandler() {
             private final Logger log = LoggerFactory.getLogger(this.getClass());
             @Override
-            public void exceptionHandler(Thread executeThread, EventHandler handler, Method handlerMethod, EventObject event, Throwable cause) {
-                log.error("发生未捕获异常:\nThread:{}, EventHandler: {}, HandlerMethod: {}, EventObject: {}\n{}",
+            public void exceptionHandler(
+                    Thread executeThread,
+                    EventHandler handler,
+                    Method handlerMethod,
+                    EventObject event,
+                    Throwable cause
+            ) {
+                log.error("EventExecutor@{} 发生未捕获异常:\n\t" +
+                                "Thread:{}\n\tEventHandler: {}\n\tHandlerMethod: {}\n\tEventObject: {}\n" +
+                        "------------------ Stack Trace ------------------\n{}",
+                        executor.hashCode(),
                         executeThread.getName(),
                         handler.toString(),
                         handlerMethod.getName(),
@@ -102,10 +110,11 @@ public class BotEventHandler implements EventHandler {
         ArgumentsRunnerConfig runnerConfig = new ArgumentsRunnerConfig();
         runnerConfig.setUseDefaultValueInsteadOfException(true);
         runnerConfig.setCommandIgnoreCase(true);
+
         runnerConfig.addStringParameterParser(new DateParser(new SimpleDateFormat("yyyy-MM-dd")));
         runnerConfig.addStringParameterParser(new PagesQualityParser());
-
-        log.debug("DateParser添加情况: {}", runnerConfig.hasStringParameterParser(Date.class));
+        runnerConfig.addStringParameterParser(new RankingModeParser());
+        runnerConfig.addStringParameterParser(new RankingContentTypeParser());
 
         processRunner = new ArgumentsRunner(BotCommandProcess.class, runnerConfig);
         adminRunner = new ArgumentsRunner(BotAdminCommandProcess.class, runnerConfig);
@@ -130,6 +139,7 @@ public class BotEventHandler implements EventHandler {
     /**
      * 投递消息事件
      * @param event 事件对象
+     * @param sync 是否同步执行事件
      */
     @NotAccepted
     public static void executeMessageEvent(MessageEvent event, boolean sync) throws InterruptedException {
@@ -137,7 +147,8 @@ public class BotEventHandler implements EventHandler {
         if(!event.getMessage().startsWith(ADMIN_COMMAND_PREFIX) &&
                 !Strings.isNullOrEmpty(debuggerName)) {
             try {
-                MessageEventExecutionDebugger debugger = MessageEventExecutionDebugger.valueOf(debuggerName.toUpperCase());
+                MessageEventExecutionDebugger debugger =
+                        MessageEventExecutionDebugger.valueOf(debuggerName.toUpperCase());
                 debugger.debugger.accept(executor, event, SettingProperties.getProperties(SettingProperties.GLOBAL),
                         MessageEventExecutionDebugger.getDebuggerLogger(debugger));
             } catch(IllegalArgumentException e) {
@@ -154,6 +165,9 @@ public class BotEventHandler implements EventHandler {
         }
     }
 
+    private final static Pattern MESSAGE_PATTERN =
+            Pattern.compile("/\\s*(\".+?\"|[^:\\s])+((\\s*:\\s*(\".+?\"|[^\\s])+)|)|(\".+?\"|[^\"\\s])+");
+
     /**
      * 以事件形式处理消息事件
      * @param event 消息事件对象
@@ -164,13 +178,9 @@ public class BotEventHandler implements EventHandler {
         log.debug(event.toString());
         if(mismatch(msg)) {
             return;
-        } else if(isMute(event.getFromGroup())) {
-            log.debug("机器人已被禁言, 忽略请求.");
-            return;
         }
 
-        Pattern pattern = Pattern.compile("/\\s*(\".+?\"|[^:\\s])+((\\s*:\\s*(\".+?\"|[^\\s])+)|)|(\".+?\"|[^\"\\s])+");
-        Matcher matcher = pattern.matcher(Strings.nullToEmpty(msg));
+        Matcher matcher = MESSAGE_PATTERN.matcher(Strings.nullToEmpty(msg));
         List<String> argsList = new ArrayList<>();
         while (matcher.find()) {
             String arg = matcher.group();
@@ -200,6 +210,7 @@ public class BotEventHandler implements EventHandler {
         args = Arrays.copyOf(args, args.length + 4);
         argsList.toArray(args);
 
+        String[] runnerArguments = args.length <= 1 ? new String[0] : Arrays.copyOfRange(args, 1, args.length);
         log.info("正在处理命令...");
         long time = System.currentTimeMillis();
         Object result;
@@ -209,10 +220,10 @@ public class BotEventHandler implements EventHandler {
                         .equals(SettingProperties.getProperty(0, "admin.adminId"))) {
                     result = "你没有执行该命令的权限！";
                 } else {
-                    result = adminRunner.run(args.length <= 1 ? new String[0] : Arrays.copyOfRange(args, 1, args.length));
+                    result = adminRunner.run(runnerArguments);
                 }
             } else {
-                result = processRunner.run(args.length <= 1 ? new String[0] : Arrays.copyOfRange(args, 1, args.length));
+                result = processRunner.run(runnerArguments);
             }
         } catch(NoSuchCommandException e) {
             result = "没有这个命令！请使用“.cgj”查看帮助说明！";
@@ -221,8 +232,8 @@ public class BotEventHandler implements EventHandler {
         } catch(DeveloperRunnerException e) {
             Throwable cause = e.getCause();
             if (cause instanceof InterruptedException) {
-                log.error("命令执行超时, 终止执行.");
-                result = "色图姬发现这个命令的处理时间太久了！所以打断了这个命令。";
+                log.error("命令执行超时, 终止执行.", cause);
+                result = "色图姬查阅图库太久，被赶出来了！";
             } else if(cause instanceof NoSuchElementException && cause.getMessage().startsWith("No work found: ")) {
                 String message = cause.getMessage();
                 log.error("指定作品不存在.(Id: {})", message.substring(message.lastIndexOf(": ") + 2));
@@ -233,22 +244,24 @@ public class BotEventHandler implements EventHandler {
             }
         }
         long processTime = System.currentTimeMillis() - time;
-        if(!Objects.isNull(result) && result instanceof String && !isMute(event.getFromGroup())) {
+        if(!Objects.isNull(result) && result instanceof String) {
             try {
                 int sendResult = event.sendMessage((String) result);
-                if(sendResult < 0) {
+                if (sendResult < 0) {
                     log.warn("消息发送失败, Sender {} 返回错误代码: {}", event.getClass().getName(), sendResult);
                 }
+            } catch(InterruptedException e) {
+                log.info("事件在发送消息时超时, 重新投递该事件.(Event: {})", event);
+                EventExecutor.resendCurrentEvent();
             } catch (Exception e) {
                 log.error("发送消息时发生异常", e);
             }
-        } else if(isMute(event.getFromGroup())) {
-            log.warn("命令反馈时机器人已被禁言, 跳过反馈.");
         }
         long totalTime = System.currentTimeMillis() - time;
         log.info("命令反馈完成.(事件耗时: {}ms, P: {}%({}ms), R: {}%({}ms))", totalTime,
                 String.format("%.3f", ((double) processTime / (double)totalTime) * 100F), processTime,
-                String.format("%.3f", ((double) (totalTime - processTime) / (double)totalTime) * 100F), totalTime - processTime);
+                String.format("%.3f", ((double) (totalTime - processTime) / (double)totalTime) * 100F),
+                totalTime - processTime);
     }
 
     /**
@@ -260,40 +273,4 @@ public class BotEventHandler implements EventHandler {
         return !message.startsWith(COMMAND_PREFIX) && !message.startsWith(ADMIN_COMMAND_PREFIX);
     }
 
-    private static boolean isMute(long groupId) {
-        Boolean mute = isMute(groupId, false);
-        return mute != null && mute;
-    }
-
-    /**
-     * 查询某群是否被禁言.
-     * @param groupId 群组Id
-     * @param rawValue 是否返回原始值(当没有该群状态, 且本参数为true时, 将返回null)
-     * @return 返回状态值, 如无该群禁言记录且rawValue = true, 则返回null
-     */
-    public static Boolean isMute(long groupId, boolean rawValue) {
-        if(groupId <= 0) {
-            return false;
-        }
-        AtomicBoolean state = muteStateMap.get(groupId);
-        if(state == null && rawValue) {
-            return null;
-        }
-        return state != null && state.get();
-    }
-
-    /**
-     * 设置机器人禁言状态.
-     * <p>设置该项可防止因机器人在禁言期间反馈请求导致被封号.</p>
-     * @param mute 如果被禁言, 传入true
-     */
-    public static void setMuteState(long groupId, boolean mute) {
-        if(!muteStateMap.containsKey(groupId)) {
-            muteStateMap.put(groupId, new AtomicBoolean(mute));
-        } else {
-            muteStateMap.get(groupId).set(mute);
-        }
-        log.warn("群组 {} 机器人禁言状态已变更: {}", groupId, mute ? "已禁言" : "已解除");
-    }
-
 }

src/main/java/net/lamgc/cgj/bot/event/BufferMessageEvent.java

@@ -1,70 +0,0 @@
-package net.lamgc.cgj.bot.event;
-
-import java.util.Objects;
-
-public class BufferMessageEvent extends MessageEvent {
-
-    private final StringBuffer buffer = new StringBuffer();
-
-    private final MessageEvent parent;
-
-    /**
-     * 以空消息空Id生成BufferMessageEvent
-     */
-    public BufferMessageEvent() {
-        super(0, 0, "");
-        parent = null;
-    }
-
-    /**
-     * 提供消息内容构造BufferMessageEvent
-     * @param message 传入的消息内容
-     */
-    public BufferMessageEvent(String message) {
-        super(0, 0, message);
-        parent = null;
-    }
-
-    /**
-     * 提供消息内容构和Id信息造BufferMessageEvent
-     * @param groupId 群组Id
-     * @param qqId 发送者Id
-     * @param message 传入的消息内容
-     */
-    public BufferMessageEvent(int groupId, int qqId, String message) {
-        super(groupId, qqId, message);
-        parent = null;
-    }
-
-    /**
-     * 使用事件构造BufferMessageEvent
-     * @param parentEvent 父级消息事件对象
-     */
-    public BufferMessageEvent(MessageEvent parentEvent) {
-        super(parentEvent.getFromGroup(), parentEvent.getFromQQ(), parentEvent.getMessage());
-        parent = parentEvent;
-    }
-
-    @Override
-    public int sendMessage(String message) {
-        buffer.append(message);
-        return 0;
-    }
-
-    /**
-     * 当提供了父级消息事件时, 本方法调用父级消息事件对象的{@code getImageUrl(String)}, 如果没有, 返回{@code null}
-     */
-    @Override
-    public String getImageUrl(String image) {
-        return Objects.isNull(this.parent) ? null : this.parent.getImageUrl(image);
-    }
-
-    /**
-     * 获取缓冲区消息内容
-     * @return 消息内容
-     */
-    public String getBufferMessage() {
-        return buffer.toString();
-    }
-
-}

src/main/java/net/lamgc/cgj/bot/event/BufferedMessageSender.java

@@ -0,0 +1,23 @@
+package net.lamgc.cgj.bot.event;
+
+import net.lamgc.cgj.bot.message.MessageSender;
+
+public class BufferedMessageSender implements MessageSender {
+
+    private final StringBuffer buffer = new StringBuffer();
+
+    @Override
+    public int sendMessage(String message) {
+        buffer.append(message);
+        return 0;
+    }
+
+    /**
+     * 从缓冲区中取出消息内容.
+     * @return 返回事件发送的消息内容.
+     */
+    public String getBufferContent() {
+        return buffer.toString();
+    }
+
+}

src/main/java/net/lamgc/cgj/bot/event/MessageEvent.java

@@ -57,7 +57,7 @@ public abstract class MessageEvent implements EventObject, MessageSender {
 
     @Override
     public String toString() {
-        return this.getClass().getSimpleName() + "{" +
+        return this.getClass().getSimpleName() + "@" + Integer.toHexString(this.hashCode()) + "{" +
                 "fromGroup=" + getFromGroup() +
                 ", fromQQ=" + getFromQQ() +
                 ", message='" + getMessage() + '\'' +

src/main/java/net/lamgc/cgj/bot/framework/cli/ConsoleMain.java

@@ -31,7 +31,7 @@ public class ConsoleMain {
         long groupId = Long.parseLong(lineReader.readLine("会话群组号:"));
         boolean isGroup = false;
         do {
-            String input = lineReader.readLine("App " + qqId + (isGroup ? "@" + groupId : "$private") + " >");
+            String input = lineReader.readLine("App " + qqId + (isGroup ? "@" + groupId : "#private") + " >");
             if(input.equalsIgnoreCase("#exit")) {
                 System.out.println("退出应用...");
                 break;

src/main/java/net/lamgc/cgj/bot/framework/cli/message/ConsoleMessageEvent.java

@@ -1,8 +1,8 @@
 package net.lamgc.cgj.bot.framework.cli.message;
 
 import net.lamgc.cgj.bot.event.MessageEvent;
-
-import java.util.Date;
+import net.lamgc.cgj.bot.message.MessageSenderBuilder;
+import net.lamgc.cgj.bot.message.MessageSource;
 
 public class ConsoleMessageEvent extends MessageEvent {
 
@@ -11,9 +11,15 @@ public class ConsoleMessageEvent extends MessageEvent {
     }
 
     @Override
-    public int sendMessage(String message) {
-        System.out.println(new Date() + " Bot: " + message);
-        return 0;
+    public int sendMessage(String message) throws Exception {
+        if(getFromGroup() <= 0) {
+            return MessageSenderBuilder
+                    .getMessageSender(MessageSource.PRIVATE, getFromQQ()).sendMessage(message);
+        } else {
+            return MessageSenderBuilder
+                    .getMessageSender(MessageSource.GROUP, getFromQQ()).sendMessage(message);
+        }
+
     }
 
     @Override

src/main/java/net/lamgc/cgj/bot/framework/cli/message/ConsoleMessageSender.java

@@ -1,13 +1,26 @@
 package net.lamgc.cgj.bot.framework.cli.message;
 
 import net.lamgc.cgj.bot.message.MessageSender;
+import net.lamgc.cgj.bot.message.MessageSource;
 
+import java.text.SimpleDateFormat;
 import java.util.Date;
 
 public class ConsoleMessageSender implements MessageSender {
+
+    private final static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+    private final MessageSource source;
+    private final long id;
+
+    ConsoleMessageSender(MessageSource source, long id) {
+        this.source = source;
+        this.id = id;
+    }
+
     @Override
     public synchronized int sendMessage(String message) {
-        System.out.println(new Date() + " Bot: " + message);
+        System.out.println(dateFormat.format(new Date()) + " Bot -> " +
+                (source == MessageSource.PRIVATE ? "#"  : "@") + id + ": " + message);
         return 0;
     }
 }

src/main/java/net/lamgc/cgj/bot/framework/cli/message/ConsoleMessageSenderFactory.java

@@ -6,10 +6,8 @@ import net.lamgc.cgj.bot.message.MessageSource;
 
 public class ConsoleMessageSenderFactory implements MessageSenderFactory {
 
-    private final static ConsoleMessageSender sender = new ConsoleMessageSender();
-
     @Override
     public MessageSender createMessageSender(MessageSource source, long id) {
-        return sender;
+        return new ConsoleMessageSender(source, id);
     }
 }

src/main/java/net/lamgc/cgj/bot/framework/coolq/CQConfig.java

@@ -1,27 +0,0 @@
-package net.lamgc.cgj.bot.framework.coolq;
-
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import net.lz1998.cq.CQGlobal;
-import net.lz1998.cq.EnableCQ;
-
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-
-@EnableCQ
-public class CQConfig {
-
-    public static void init() {
-        CQGlobal.pluginList.add(CQPluginMain.class);
-        CQGlobal.executor = new ThreadPoolExecutor(
-                (int) Math.ceil(Runtime.getRuntime().availableProcessors() / 2F),
-                Runtime.getRuntime().availableProcessors(),
-                25, TimeUnit.SECONDS,
-                new LinkedBlockingQueue<>(512),
-                new ThreadFactoryBuilder()
-                        .setNameFormat("Plugin-ProcessThread-%d")
-                        .build()
-        );
-    }
-
-}

src/main/java/net/lamgc/cgj/bot/framework/coolq/CQPluginMain.java

@@ -3,6 +3,7 @@ package net.lamgc.cgj.bot.framework.coolq;
 import net.lamgc.cgj.bot.boot.ApplicationBoot;
 import net.lamgc.cgj.bot.event.BotEventHandler;
 import net.lamgc.cgj.bot.framework.coolq.message.SpringCQMessageEvent;
+import net.lamgc.cgj.bot.framework.coolq.message.SpringCQMessageSenderFactory;
 import net.lamgc.utils.event.EventHandler;
 import net.lz1998.cq.event.message.CQDiscussMessageEvent;
 import net.lz1998.cq.event.message.CQGroupMessageEvent;
@@ -13,13 +14,15 @@ import net.lz1998.cq.robot.CoolQ;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;
 
+import java.util.concurrent.atomic.AtomicBoolean;
+
 @Component
+@SuppressWarnings("unused")
 public class CQPluginMain extends CQPlugin implements EventHandler {
 
+    private final static AtomicBoolean initialState = new AtomicBoolean();
+
     public CQPluginMain() {
-        // TODO(LamGC, 2020.04.21): SpringCQ无法适配MessageSenderBuilder
-        // MessageSenderBuilder.setCurrentMessageSenderFactory(new SpringCQMessageSenderFactory());
-        ApplicationBoot.initialBot();
         LoggerFactory.getLogger(CQPluginMain.class)
                 .info("BotEventHandler.COMMAND_PREFIX = {}", BotEventHandler.COMMAND_PREFIX);
     }
@@ -46,6 +49,13 @@ public class CQPluginMain extends CQPlugin implements EventHandler {
      * @return 是否拦截消息
      */
     private static int processMessage(CoolQ cq, CQMessageEvent event) {
+        SpringCQMessageSenderFactory.setCoolQ(cq);
+        synchronized (initialState) {
+            if(!initialState.get()) {
+                ApplicationBoot.initialBot();
+                initialState.set(true);
+            }
+        }
         if(BotEventHandler.mismatch(event.getMessage())) {
             return MESSAGE_IGNORE;
         }

src/main/java/net/lamgc/cgj/bot/framework/coolq/SpringCQApplication.java

@@ -0,0 +1,63 @@
+package net.lamgc.cgj.bot.framework.coolq;
+
+import com.google.common.base.Strings;
+import net.lamgc.cgj.bot.boot.BotGlobal;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.event.ApplicationFailedEvent;
+import org.springframework.context.ApplicationListener;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.event.ContextClosedEvent;
+import org.springframework.context.event.ContextStoppedEvent;
+
+import java.util.ArrayList;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+@SpringBootApplication
+public class SpringCQApplication {
+
+    private final static Logger log = LoggerFactory.getLogger(SpringCQApplication.class);
+
+    private final Object quitLock = new Object();
+
+    public void start(String argsStr) {
+        log.info("酷Q机器人根目录: {}", BotGlobal.getGlobal().getDataStoreDir().getPath());
+        Pattern pattern = Pattern.compile("/\\s*(\".+?\"|[^:\\s])+((\\s*:\\s*(\".+?\"|[^\\s])+)|)|(\".+?\"|[^\"\\s])+");
+        Matcher matcher = pattern.matcher(Strings.nullToEmpty(argsStr));
+        ArrayList<String> argsList = new ArrayList<>();
+        while (matcher.find()) {
+            argsList.add(matcher.group());
+        }
+        String[] args = new String[argsList.size()];
+        argsList.toArray(args);
+        ConfigurableApplicationContext context = SpringApplication.run(SpringCQApplication.class, args);
+        registerShutdownHook(context);
+        try {
+            synchronized (quitLock) {
+                quitLock.wait();
+            }
+        } catch (InterruptedException e) {
+            log.warn("发生中断, 退出SpringCQ...", e);
+        }
+    }
+
+    private void registerShutdownHook(ConfigurableApplicationContext context) {
+        context.addApplicationListener((ApplicationListener<ApplicationFailedEvent>)
+                event -> notifyThread());
+        context.addApplicationListener((ApplicationListener<ContextClosedEvent>)
+                event -> notifyThread());
+        context.addApplicationListener((ApplicationListener<ContextStoppedEvent>)
+                event -> notifyThread());
+        Runtime.getRuntime().addShutdownHook(new Thread(this::notifyThread));
+    }
+
+    private void notifyThread() {
+        synchronized (quitLock) {
+            quitLock.notify();
+        }
+    }
+
+}

src/main/java/net/lamgc/cgj/bot/framework/coolq/message/SpringCQMessageEvent.java

@@ -26,13 +26,13 @@ public class SpringCQMessageEvent extends MessageEvent {
         this.cq = Objects.requireNonNull(cq);
         MessageSource source;
         if(messageEvent instanceof CQGroupMessageEvent) {
-            source = MessageSource.Group;
+            source = MessageSource.GROUP;
         } else if (messageEvent instanceof CQDiscussMessageEvent) {
-            source = MessageSource.Discuss;
+            source = MessageSource.DISCUSS;
         } else {
-            source = MessageSource.Private;
+            source = MessageSource.PRIVATE;
         }
-        messageSender = new SpringCQMessageSender(cq, source, source == MessageSource.Private ? getFromQQ() : getFromGroup());
+        messageSender = new SpringCQMessageSender(cq, source, source == MessageSource.PRIVATE ? getFromQQ() : getFromGroup());
     }
 
     @Override

src/main/java/net/lamgc/cgj/bot/framework/coolq/message/SpringCQMessageSender.java

@@ -6,9 +6,9 @@ import net.lz1998.cq.robot.CoolQ;
 
 public class SpringCQMessageSender implements MessageSender {
 
-    private CoolQ coolQ;
-    private MessageSource source;
-    private long target;
+    private final CoolQ coolQ;
+    private final MessageSource source;
+    private final long target;
 
     public SpringCQMessageSender(CoolQ coolQ, MessageSource source, long target) {
         this.coolQ = coolQ;
@@ -19,11 +19,11 @@ public class SpringCQMessageSender implements MessageSender {
     @Override
     public int sendMessage(String message) {
         switch (source) {
-            case Private:
+            case PRIVATE:
                 return coolQ.sendPrivateMsg(target, message, false).getData().getMessageId();
-            case Group:
+            case GROUP:
                 return coolQ.sendGroupMsg(target, message, false).getData().getMessageId();
-            case Discuss:
+            case DISCUSS:
                 return coolQ.sendDiscussMsg(target, message, false).getData().getMessageId();
             default:
                 return -1;

src/main/java/net/lamgc/cgj/bot/framework/coolq/message/SpringCQMessageSenderFactory.java

@@ -6,13 +6,26 @@ import net.lamgc.cgj.bot.message.MessageSource;
 import net.lz1998.cq.robot.CoolQ;
 
 import java.util.Objects;
+import java.util.concurrent.atomic.AtomicReference;
 
 public class SpringCQMessageSenderFactory implements MessageSenderFactory {
 
-    private final static ThreadLocal<CoolQ> threadCoolQ = new ThreadLocal<>();
+    private final static AtomicReference<CoolQ> coolQ = new AtomicReference<>();
+
+    /**
+     * 设置CoolQ对象.
+     * <p>该方法仅接受第一次设置的CoolQ对象, 其他对象将会忽略.</p>
+     * @param coolQObj CoolQ对象
+     */
+    public static void setCoolQ(CoolQ coolQObj) {
+        if(coolQ.get() == null) {
+            coolQ.set(coolQObj);
+        }
+    }
+
     @Override
     public MessageSender createMessageSender(MessageSource source, long id) {
         return new SpringCQMessageSender(
-                Objects.requireNonNull(threadCoolQ.get(), "CoolQ object is not included in ThreadLocal"), source, id);
+                Objects.requireNonNull(coolQ.get(), "CoolQ object not ready"), source, id);
     }
 }

src/main/java/net/lamgc/cgj/bot/framework/mirai/MiraiMain.java

@@ -6,6 +6,7 @@ import net.lamgc.cgj.bot.event.BotEventHandler;
 import net.lamgc.cgj.bot.framework.mirai.message.MiraiMessageEvent;
 import net.lamgc.cgj.bot.framework.mirai.message.MiraiMessageSenderFactory;
 import net.lamgc.cgj.bot.message.MessageSenderBuilder;
+import net.lamgc.cgj.bot.util.GroupMuteManager;
 import net.mamoe.mirai.Bot;
 import net.mamoe.mirai.BotFactoryJvm;
 import net.mamoe.mirai.event.events.BotMuteEvent;
@@ -30,7 +31,9 @@ public class MiraiMain implements Closeable {
 
     private Bot bot;
 
-    private final static Properties botProperties = new Properties();
+    private final Properties botProperties = new Properties();
+
+    private final GroupMuteManager muteManager = new GroupMuteManager();
 
     public void init() {
         Runtime.getRuntime().addShutdownHook(new Thread(this::close));
@@ -73,9 +76,9 @@ public class MiraiMain implements Closeable {
         Events.subscribeAlways(FriendMessageEvent.class, this::executeMessageEvent);
         Events.subscribeAlways(TempMessageEvent.class, this::executeMessageEvent);
         Events.subscribeAlways(BotMuteEvent.class,
-                event -> BotEventHandler.setMuteState(event.getGroup().getId(), true));
+                event -> muteManager.setMuteState(event.getGroup().getId(), true));
         Events.subscribeAlways(BotUnmuteEvent.class,
-                event -> BotEventHandler.setMuteState(event.getGroup().getId(), false));
+                event -> muteManager.setMuteState(event.getGroup().getId(), false));
         bot.login();
         MessageSenderBuilder.setCurrentMessageSenderFactory(new MiraiMessageSenderFactory(bot));
         ApplicationBoot.initialBot();
@@ -87,11 +90,18 @@ public class MiraiMain implements Closeable {
      * @param message 消息事件对象
      */
     private void executeMessageEvent(MessageEvent message) {
+        log.debug("Mirai Message: {}", message);
         if(message instanceof GroupMessageEvent) {
-            GroupMessageEvent GroupMessageEvent = (GroupMessageEvent) message;
-            if(BotEventHandler.isMute(GroupMessageEvent.getGroup().getId(), true) == null) {
-                BotEventHandler.setMuteState(GroupMessageEvent.getGroup().getId(),
-                        ((GroupMessageEvent) message).getGroup().getBotMuteRemaining() != 0);
+            GroupMessageEvent groupMessageEvent = (GroupMessageEvent) message;
+            Boolean muteState = muteManager.isMute(groupMessageEvent.getGroup().getId(), true);
+            if(muteState == null) {
+                boolean mute = groupMessageEvent.getGroup().getBotMuteRemaining() != 0;
+                muteManager.setMuteState(groupMessageEvent.getGroup().getId(), mute);
+                if(mute) {
+                    return;
+                }
+            } else if(muteState) {
+                return;
             }
         }
         BotEventHandler.executeMessageEvent(MiraiMessageEvent.covertEventObject(message));

src/main/java/net/lamgc/cgj/bot/framework/mirai/message/MiraiMessageEvent.java

@@ -28,9 +28,9 @@ public class MiraiMessageEvent extends net.lamgc.cgj.bot.event.MessageEvent {
                 message.getSender().getId(), getMessageBodyWithoutSource(message.getMessage().toString()));
         this.messageObject = Objects.requireNonNull(message);
         if(message instanceof GroupMessageEvent) {
-            messageSender = new MiraiMessageSender(((GroupMessageEvent) message).getGroup(), MessageSource.Group);
+            messageSender = new MiraiMessageSender(((GroupMessageEvent) message).getGroup(), MessageSource.GROUP);
         } else {
-            messageSender = new MiraiMessageSender(message.getSender(), MessageSource.Private);
+            messageSender = new MiraiMessageSender(message.getSender(), MessageSource.PRIVATE);
         }
     }
 
@@ -45,9 +45,9 @@ public class MiraiMessageEvent extends net.lamgc.cgj.bot.event.MessageEvent {
         super(groupId, qqId, getMessageBodyWithoutSource(message.toString()));
         this.messageObject = Objects.requireNonNull(messageObject, "messageObject is null");
         if(groupId != 0) {
-            this.messageSender = new MiraiMessageSender(((GroupMessageEvent) messageObject).getGroup(), MessageSource.Group);
+            this.messageSender = new MiraiMessageSender(((GroupMessageEvent) messageObject).getGroup(), MessageSource.GROUP);
         } else {
-            this.messageSender = new MiraiMessageSender(messageObject.getSender(), MessageSource.Group);
+            this.messageSender = new MiraiMessageSender(messageObject.getSender(), MessageSource.GROUP);
         }
     }
 

src/main/java/net/lamgc/cgj/bot/framework/mirai/message/MiraiMessageSender.java

@@ -40,7 +40,7 @@ public class MiraiMessageSender implements MessageSender {
      * @throws NoSuchElementException 当在机器人好友列表或群列表里没有这个好友或群的时候抛出
      */
     public MiraiMessageSender(Bot bot, MessageSource source, long id) {
-        this(source == MessageSource.Private ? bot.getFriend(id) : bot.getGroup(id), source);
+        this(source == MessageSource.PRIVATE ? bot.getFriend(id) : bot.getGroup(id), source);
     }
 
     /**
@@ -151,7 +151,7 @@ public class MiraiMessageSender implements MessageSender {
                 synchronized (imageName) {
                     if(!imageIdCache.exists(imageName) ||
                             Strings.nullToEmpty(code.getParameter("updateCache")) .equalsIgnoreCase("true")) {
-                        log.debug("imageName [{}] 缓存失效或强制更新, 正在更新缓存...", imageName);
+                        log.trace("imageName [{}] 缓存失效或强制更新, 正在更新缓存...", imageName);
                         image = uploadImage0(new File(absolutePath));
                         String cacheExpireAt;
                         long expireTime = 864000000; // 10d
@@ -163,13 +163,13 @@ public class MiraiMessageSender implements MessageSender {
                             }
                         }
                         imageIdCache.update(imageName, image.getImageId(), expireTime);
-                        log.debug("imageName [{}] 缓存更新完成.(有效时间: {})", imageName, expireTime);
+                        log.trace("imageName [{}] 缓存更新完成.(有效时间: {})", imageName, expireTime);
                     } else {
-                        log.debug("ImageName: [{}] 缓存命中.", imageName);
+                        log.trace("ImageName: [{}] 缓存命中.", imageName);
                     }
                 }
             } else {
-                log.debug("ImageName: [{}] 缓存命中.", imageName);
+                log.trace("ImageName: [{}] 缓存命中.", imageName);
             }
 
             if(image == null) {

src/main/java/net/lamgc/cgj/bot/message/MessageSource.java

@@ -7,17 +7,17 @@ public enum MessageSource {
     /**
      * 私聊消息
      */
-    Private,
+    PRIVATE,
     /**
      * 群组消息
      */
-    Group,
+    GROUP,
     /**
      * 讨论组消息
      */
-    Discuss,
+    DISCUSS,
     /**
      * 未知来源
      */
-    Unknown
+    UNKNOWN
 }

src/main/java/net/lamgc/cgj/bot/sort/PreLoadDataAttribute.java

@@ -0,0 +1,41 @@
+package net.lamgc.cgj.bot.sort;
+
+@SuppressWarnings("unused")
+public enum PreLoadDataAttribute {
+    /**
+     * 按点赞数排序
+     */
+    LIKE("likeCount"),
+
+    /**
+     * 按页面数排序
+     */
+    PAGE("pageCount"),
+
+    /**
+     * 按收藏数排序
+     */
+    BOOKMARK("bookmarkCount"),
+
+    /**
+     * 按评论数排序
+     */
+    COMMENT("commentCount"),
+
+    /**
+     * 不明
+     */
+    RESPONSE("responseCount"),
+
+    /**
+     * 按查看次数排序
+     */
+    VIEW("viewCount"),
+    ;
+
+    public final String attrName;
+
+    PreLoadDataAttribute(String attrName) {
+        this.attrName = attrName;
+    }
+}

src/main/java/net/lamgc/cgj/bot/sort/PreLoadDataAttributeComparator.java

@@ -3,6 +3,8 @@ package net.lamgc.cgj.bot.sort;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import net.lamgc.cgj.bot.cache.CacheStoreCentral;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.util.Comparator;
@@ -10,11 +12,13 @@ import java.util.Comparator;
 /**
  * 收藏数比较器
  */
-public class PreLoadDataComparator implements Comparator<JsonElement> {
+public class PreLoadDataAttributeComparator implements Comparator<JsonElement> {
 
-    private final Attribute attribute;
+    private final static Logger log = LoggerFactory.getLogger(PreLoadDataAttributeComparator.class);
 
-    public PreLoadDataComparator(Attribute attribute) {
+    private final PreLoadDataAttribute attribute;
+
+    public PreLoadDataAttributeComparator(PreLoadDataAttribute attribute) {
         this.attribute = attribute;
     }
 
@@ -39,57 +43,17 @@ public class PreLoadDataComparator implements Comparator<JsonElement> {
             }
         }
         try {
-            JsonObject illustPreLoadData1 =
-                    CacheStoreCentral.getIllustPreLoadData(o1.getAsJsonObject().get("illustId").getAsInt(), false);
-            JsonObject illustPreLoadData2 =
-                    CacheStoreCentral.getIllustPreLoadData(o2.getAsJsonObject().get("illustId").getAsInt(), false);
+            JsonObject illustPreLoadData1 = CacheStoreCentral.getCentral()
+                    .getIllustPreLoadData(o1.getAsJsonObject().get("illustId").getAsInt(), false);
+            JsonObject illustPreLoadData2 = CacheStoreCentral.getCentral()
+                    .getIllustPreLoadData(o2.getAsJsonObject().get("illustId").getAsInt(), false);
             return Integer.compare(
                     illustPreLoadData2.get(attribute.attrName).getAsInt(),
                     illustPreLoadData1.get(attribute.attrName).getAsInt());
         } catch (IOException e) {
-            e.printStackTrace();
+            log.error("获取预加载数据失败", e);
             return 0;
         }
     }
 
-    public enum Attribute {
-        /**
-         * 按点赞数排序
-         */
-        LIKE("likeCount"),
-
-        /**
-         * 按页面数排序
-         */
-        PAGE("pageCount"),
-
-        /**
-         * 按收藏数排序
-         */
-        BOOKMARK("bookmarkCount"),
-
-        /**
-         * 按评论数排序
-         */
-        COMMENT("commentCount"),
-
-        /**
-         * 不明
-         */
-        RESPONSE("responseCount"),
-
-        /**
-         * 按查看次数排序
-         */
-        VIEW("viewCount"),
-        ;
-
-        public final String attrName;
-
-        Attribute(String attrName) {
-            this.attrName = attrName;
-        }
-    }
-
-
 }

src/main/java/net/lamgc/cgj/bot/util/GroupMuteManager.java

@@ -0,0 +1,48 @@
+package net.lamgc.cgj.bot.util;
+
+import java.util.Hashtable;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * 群禁言管理器.
+ * <p>该管理器用于存取群组禁言状态.</p>
+ */
+public class GroupMuteManager {
+
+    private final Map<Long, AtomicBoolean> muteStateMap = new Hashtable<>();
+
+    /**
+     * 查询某群是否被禁言.
+     * @param groupId 群组Id
+     * @param rawValue 是否返回原始值(当没有该群状态, 且本参数为true时, 将返回null)
+     * @return 返回状态值, 如无该群禁言记录且rawValue = true, 则返回null
+     */
+    public Boolean isMute(long groupId, boolean rawValue) {
+        if(groupId <= 0) {
+            return false;
+        }
+        AtomicBoolean state = muteStateMap.get(groupId);
+        if(state == null && rawValue) {
+            return null;
+        }
+        return state != null && state.get();
+    }
+
+    /**
+     * 设置机器人禁言状态.
+     * <p>设置该项可防止因机器人在禁言期间反馈请求导致被封号.</p>
+     * @param mute 如果被禁言, 传入true
+     */
+    public void setMuteState(long groupId, boolean mute) {
+        if(groupId <= 0) {
+            return;
+        }
+        if(!muteStateMap.containsKey(groupId)) {
+            muteStateMap.put(groupId, new AtomicBoolean(mute));
+        } else {
+            muteStateMap.get(groupId).set(mute);
+        }
+    }
+
+}

src/main/java/net/lamgc/cgj/bot/util/parser/DateParser.java

@@ -1,4 +1,4 @@
-package net.lamgc.cgj.util;
+package net.lamgc.cgj.bot.util.parser;
 
 import net.lamgc.utils.base.runner.StringParameterParser;
 

src/main/java/net/lamgc/cgj/bot/util/parser/PagesQualityParser.java

@@ -1,4 +1,4 @@
-package net.lamgc.cgj.util;
+package net.lamgc.cgj.bot.util.parser;
 
 import net.lamgc.cgj.pixiv.PixivDownload;
 import net.lamgc.utils.base.runner.StringParameterParser;

src/main/java/net/lamgc/cgj/bot/util/parser/RankingContentTypeParser.java

@@ -0,0 +1,29 @@
+package net.lamgc.cgj.bot.util.parser;
+
+import net.lamgc.cgj.pixiv.RankingContentType;
+import net.lamgc.utils.base.runner.StringParameterParser;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class RankingContentTypeParser implements StringParameterParser<RankingContentType> {
+
+    private final static Logger log = LoggerFactory.getLogger(RankingContentTypeParser.class);
+
+    @Override
+    public RankingContentType parse(String strValue) {
+        try {
+            if(strValue.toUpperCase().startsWith("TYPE_")) {
+                return RankingContentType.valueOf(strValue.toUpperCase());
+            }
+            return RankingContentType.valueOf("TYPE_" + strValue.toUpperCase());
+        } catch(IllegalArgumentException e) {
+            log.warn("无效的RankingContentType值: {}", strValue);
+            throw e;
+        }
+    }
+
+    @Override
+    public RankingContentType defaultValue() {
+        return RankingContentType.TYPE_ALL;
+    }
+}

src/main/java/net/lamgc/cgj/bot/util/parser/RankingModeParser.java

@@ -0,0 +1,29 @@
+package net.lamgc.cgj.bot.util.parser;
+
+import net.lamgc.cgj.pixiv.RankingMode;
+import net.lamgc.utils.base.runner.StringParameterParser;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class RankingModeParser implements StringParameterParser<RankingMode> {
+
+    private final static Logger log = LoggerFactory.getLogger(RankingModeParser.class);
+
+    @Override
+    public RankingMode parse(String strValue) {
+        try {
+            if(strValue.toUpperCase().startsWith("MODE_")) {
+                return RankingMode.valueOf(strValue.toUpperCase());
+            }
+            return RankingMode.valueOf("MODE_" + strValue.toUpperCase());
+        } catch(IllegalArgumentException e) {
+            log.warn("无效的RankingMode值: {}", strValue);
+            throw e;
+        }
+    }
+
+    @Override
+    public RankingMode defaultValue() {
+        return RankingMode.MODE_DAILY;
+    }
+}

src/main/java/net/lamgc/cgj/exception/HttpRequestException.java

@@ -1,4 +1,4 @@
-package net.lamgc.cgj.bot.cache.exception;
+package net.lamgc.cgj.exception;
 
 import java.io.IOException;
 import java.util.Objects;

src/main/java/net/lamgc/cgj/pixiv/PixivDownload.java

@@ -4,8 +4,8 @@ import com.google.gson.Gson;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
-import com.google.gson.reflect.TypeToken;
 import io.netty.handler.codec.http.HttpHeaderNames;
+import net.lamgc.cgj.exception.HttpRequestException;
 import org.apache.http.Header;
 import org.apache.http.HttpHost;
 import org.apache.http.HttpRequest;
@@ -56,10 +56,10 @@ public class PixivDownload {
         this.cookieStore = cookieStore;
         HttpClientBuilder builder = HttpClientBuilder.create();
         builder.setDefaultCookieStore(cookieStore);
-        // UA: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.122 Safari/537.36
         ArrayList<Header> defaultHeaders = new ArrayList<>(2);
         defaultHeaders.add(new BasicHeader("User-Agent",
-                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.122 Safari/537.36"));
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) " +
+                        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.122 Safari/537.36"));
         builder.setDefaultHeaders(defaultHeaders);
         builder.setProxy(proxy);
         httpClient = builder.build();
@@ -84,7 +84,8 @@ public class PixivDownload {
         Document document;
         ArrayList<String> linkList = new ArrayList<>();
         do {
-            request = new HttpGet(PixivURL.PIXIV_USER_COLLECTION_PAGE.replace("{pageIndex}", Integer.toString(++pageIndex)));
+            request = new HttpGet(PixivURL.PIXIV_USER_COLLECTION_PAGE
+                    .replace("{pageIndex}", Integer.toString(++pageIndex)));
             setCookieInRequest(request, cookieStore);
             log.debug("Request Link: " + request.getURI().toString());
             HttpResponse response = httpClient.execute(request);
@@ -99,10 +100,13 @@ public class PixivDownload {
 
             Gson gson = new Gson();
             for (String href : hrefList) {
-                HttpGet linkApiRequest = createHttpGetRequest(PixivURL.PIXIV_ILLUST_API_URL.replace("{illustId}", href.substring(href.lastIndexOf("/") + 1)));
+                HttpGet linkApiRequest = createHttpGetRequest(PixivURL.PIXIV_ILLUST_API_URL
+                        .replace("{illustId}", href.substring(href.lastIndexOf("/") + 1)));
                 log.debug(linkApiRequest.getURI().toString());
                 HttpResponse httpResponse = httpClient.execute(linkApiRequest);
-                JsonObject linkResult = gson.fromJson(EntityUtils.toString(httpResponse.getEntity()), JsonObject.class);
+                JsonObject linkResult =
+                        gson.fromJson(EntityUtils.toString(httpResponse.getEntity()), JsonObject.class);
+
                 if(linkResult.get("error").getAsBoolean()) {
                     log.error("接口返回错误信息: {}", linkResult.get("message").getAsString());
                     continue;
@@ -111,14 +115,17 @@ public class PixivDownload {
                 JsonArray linkArray = linkResult.get("body").getAsJsonArray();
                 for (int i = 0; i < linkArray.size(); i++) {
                     JsonObject linkObject = linkArray.get(i).getAsJsonObject().get("urls").getAsJsonObject();
-                    linkList.add(linkObject.get((quality == null ? PageQuality.ORIGINAL : quality).toString().toLowerCase()).getAsString());
+                    linkList.add(
+                            linkObject.get((quality == null ? PageQuality.ORIGINAL : quality).toString().toLowerCase())
+                            .getAsString()
+                    );
                 }
             }
         } while(!document.select(".pager-container>.next").isEmpty());
-        log.debug("获取完成.");
+        log.trace("获取完成.");
         AtomicInteger count = new AtomicInteger(1);
         linkList.forEach(link -> {
-            log.debug("Next Link [{}]: {}", count.getAndIncrement(), link);
+            log.trace("Next Link [{}]: {}", count.getAndIncrement(), link);
             InputStream imageInputStream = null;
             int tryCount = 0;
             do {
@@ -133,9 +140,9 @@ public class PixivDownload {
             } while(imageInputStream == null);
 
             try(InputStream imageInput = new BufferedInputStream(imageInputStream, 256 * 1024)) {
-                log.debug("调用回调方法...");
+                log.trace("调用回调方法...");
                 fn.accept(link, imageInput);
-                log.debug("回调方法调用完成.");
+                log.trace("回调方法调用完成.");
             } catch (IOException e) {
                 log.error("图片获取失败", e);
             }
@@ -153,7 +160,8 @@ public class PixivDownload {
         Document document = Jsoup.parse(EntityUtils.toString(response.getEntity()));
 
         HttpClient imageClient = HttpClientBuilder.create().build();
-        Elements elements = document.select(".gtm-illust-recommend-zone>.image-item>.gtm-illust-recommend-thumbnail-link");
+        Elements elements = document
+                .select(".gtm-illust-recommend-zone>.image-item>.gtm-illust-recommend-thumbnail-link");
         for(int illustIndex = 0; illustIndex < elements.size(); illustIndex++){
             String href = elements.get(illustIndex).attr("href");
             int illustId = Integer.parseInt(href.substring(href.lastIndexOf("/") + 1));
@@ -195,8 +203,14 @@ public class PixivDownload {
      * @param fn 回调函数
      * @throws IOException 当请求发生异常时抛出
      */
-    public void getRankingAsInputStream(PixivURL.RankingContentType contentType, PixivURL.RankingMode mode,
-                                        Date time, int range, PageQuality quality, RankingDownloadFunction fn) throws IOException {
+    public void getRankingAsInputStream(
+            RankingContentType contentType,
+            RankingMode mode,
+            Date time,
+            int range,
+            PageQuality quality,
+            RankingDownloadFunction fn
+    ) throws IOException {
         getRankingAsInputStream(contentType, mode, time, 1, range, quality, fn);
     }
 
@@ -211,16 +225,24 @@ public class PixivDownload {
      * @param fn 回调函数
      * @throws IOException 当请求发生异常时抛出
      */
-    public void getRankingAsInputStream(PixivURL.RankingContentType contentType, PixivURL.RankingMode mode,
-                                        Date time, int rankStart, int range, PageQuality quality, RankingDownloadFunction fn) throws IOException {
+    public void getRankingAsInputStream(
+            RankingContentType contentType,
+            RankingMode mode,
+            Date time,
+            int rankStart,
+            int range,
+            PageQuality quality,
+            RankingDownloadFunction fn
+    ) throws IOException {
         getRanking(contentType, mode, time, rankStart, range).forEach(rankInfo -> {
             int rank = rankInfo.get("rank").getAsInt();
             int illustId = rankInfo.get("illust_id").getAsInt();
             int authorId = rankInfo.get("user_id").getAsInt();
             String authorName = rankInfo.get("user_name").getAsString();
             String title = rankInfo.get("title").getAsString();
-            log.debug("当前到第 {}/{} 名(总共 {} 名), IllustID: {}, Author: ({}) {}, Title: {}", rank, rankStart + range - 1, range, illustId, authorId, authorName, title);
-            log.debug("正在获取PagesLink...");
+            log.trace("当前到第 {}/{} 名(总共 {} 名), IllustID: {}, Author: ({}) {}, Title: {}",
+                    rank, rankStart + range - 1, range, illustId, authorId, authorName, title);
+            log.trace("正在获取PagesLink...");
             List<String> linkList;
             try {
                 linkList = getIllustAllPageDownload(httpClient, this.cookieStore, illustId, quality);
@@ -235,55 +257,22 @@ public class PixivDownload {
             log.debug("PagesLink 获取完成, 总数: {}", linkList.size());
             for (int pageIndex = 0; pageIndex < linkList.size(); pageIndex++) {
                 String downloadLink = linkList.get(pageIndex);
-                log.debug("当前Page: {}/{}", pageIndex + 1, linkList.size());
-                try(InputStream imageInputStream = new BufferedInputStream(getImageAsInputStream(HttpClientBuilder.create().build(), downloadLink), 256 * 1024)) {
+                log.trace("当前Page: {}/{}", pageIndex + 1, linkList.size());
+                try(InputStream imageInputStream =
+                            new BufferedInputStream(
+                                    getImageAsInputStream(HttpClientBuilder.create().build(), downloadLink),
+                                    256 * 1024)
+                ) {
                     fn.download(rank, downloadLink, rankInfo.deepCopy(), imageInputStream);
                 } catch(IOException e) {
                     log.error("下载插画时发生异常", e);
                     return;
                 }
-                log.debug("完成.");
+                log.trace("完成.");
             }
         });
     }
 
-    /**
-     * 从JsonArray获取数据
-     * @param rankingList JsonArray对象
-     * @param rankStart 开始索引, 从0开始
-     * @param range 范围
-     * @return 返回List对象
-     */
-    public static List<JsonObject> getRanking(List<JsonObject> rankingList, int rankStart, int range) {
-        log.debug("正在读取JsonArray...(rankStart: {}, range: {})", rankStart, range);
-        ArrayList<JsonObject> results = new ArrayList<>(rankingList.size());
-        for (int rankIndex = rankStart; rankIndex < rankStart + range; rankIndex++) {
-            JsonElement jsonElement = rankingList.get(rankIndex - rankStart);
-            JsonObject rankInfo = jsonElement.getAsJsonObject();
-            int rank = rankInfo.get("rank").getAsInt();
-            int illustId = rankInfo.get("illust_id").getAsInt();
-            int authorId = rankInfo.get("user_id").getAsInt();
-            String authorName = rankInfo.get("user_name").getAsString();
-            String title = rankInfo.get("title").getAsString();
-            log.debug("Array-当前到第 {}/{} 名(总共 {} 名), IllustID: {}, Author: ({}) {}, Title: {}", rank, rankStart + range, range, illustId, authorId, authorName, title);
-            results.add(rankInfo);
-        }
-        log.debug("JsonArray读取完成.");
-        return results;
-    }
-
-    /**
-     * 从JsonArray获取数据
-     * @param rankingArray JsonArray对象
-     * @param rankStart 开始索引, 从0开始
-     * @param range 范围
-     * @return 返回List对象
-     */
-    public static List<JsonObject> getRanking(JsonArray rankingArray, int rankStart, int range) {
-        List<JsonObject> list = new Gson().fromJson(rankingArray, new TypeToken<List<JsonObject>>(){}.getType());
-        return getRanking(list, rankStart, range);
-    }
-
     /**
      * 获取排行榜.
      * <p>注意: 如果范围实际上没超出, 但返回排行榜不足, 会导致与实际请求的数量不符, 需要检查</p>
@@ -293,22 +282,24 @@ public class PixivDownload {
      * @param rankStart 开始排名, 从1开始
      * @param range 取范围
      * @return 成功返回有值List, 失败且无异常返回空
-     * @throws IllegalArgumentException 当{@linkplain net.lamgc.cgj.pixiv.PixivURL.RankingContentType RankingContentType}
-     *                                  与{@linkplain net.lamgc.cgj.pixiv.PixivURL.RankingMode RankingMode}互不兼容时抛出
+     * @throws IllegalArgumentException 当{@linkplain net.lamgc.cgj.pixiv.RankingContentType RankingContentType}
+     *                                  与{@linkplain net.lamgc.cgj.pixiv.RankingMode RankingMode}互不兼容时抛出
      * @throws IndexOutOfBoundsException 当排行榜选取范围超出排行榜范围时抛出(排行榜范围为 1 ~ 500 名)
      * @throws IOException 当Http请求发生异常时抛出, 或Http请求响应码非200时抛出
      */
-    public List<JsonObject> getRanking(PixivURL.RankingContentType contentType, PixivURL.RankingMode mode,
+    public List<JsonObject> getRanking(RankingContentType contentType, RankingMode mode,
                                            Date time, int rankStart, int range) throws IOException {
         Objects.requireNonNull(time);
         if(!Objects.requireNonNull(contentType).isSupportedMode(Objects.requireNonNull(mode))) {
-            throw new IllegalArgumentException("ContentType不支持指定的RankingMode: ContentType: " + contentType.name() + ", Mode: " + mode.name());
+            throw new IllegalArgumentException("ContentType不支持指定的RankingMode: ContentType: "
+                    + contentType.name() + ", Mode: " + mode.name());
         } else if(rankStart <= 0) {
             throw new IndexOutOfBoundsException("rankStart cannot be less than or equal to zero: " + rankStart);
         } else if(range <= 0) {
             throw new IndexOutOfBoundsException("range cannot be less than or equal to zero:" + range);
         } else if(rankStart + range - 1 > 500) {
-            throw new IndexOutOfBoundsException("排名选取范围超出了排行榜范围: rankStart=" + rankStart + ", range=" + range + ", length:" + (rankStart + range - 1));
+            throw new IndexOutOfBoundsException("排名选取范围超出了排行榜范围: rankStart="
+                    + rankStart + ", range=" + range + ", length:" + (rankStart + range - 1));
         }
 
         int startPages = (int) Math.max(1, Math.floor(rankStart / 50F));
@@ -320,18 +311,19 @@ public class PixivDownload {
         boolean canNext = true;
         for (int pageIndex = startPages; canNext && pageIndex <= endPages && count < range; pageIndex++) {
             HttpGet request = createHttpGetRequest(PixivURL.getRankingLink(contentType, mode, time, pageIndex, true));
-            log.debug("RequestUri: {}", request.getURI());
+            log.trace("RequestUri: {}", request.getURI());
             HttpResponse response = httpClient.execute(request);
             String responseBody = EntityUtils.toString(response.getEntity());
-            log.debug("ResponseBody: {}", responseBody);
+            log.trace("ResponseBody: {}", responseBody);
             if(response.getStatusLine().getStatusCode() != 200) {
-                throw new IOException("Http Response Error: '" + response.getStatusLine() + "', ResponseBody: '" + responseBody + '\'');
+                throw new HttpRequestException(response.getStatusLine(), responseBody);
             }
 
             JsonObject resultObject = gson.fromJson(responseBody, JsonObject.class);
             canNext = resultObject.get("next").getAsJsonPrimitive().isNumber();
             JsonArray resultArray = resultObject.getAsJsonArray("contents");
-            for (int resultIndex = startIndex; resultIndex < resultArray.size() && count < range; resultIndex++, count++) {
+            for (int resultIndex = startIndex;
+                 resultIndex < resultArray.size() && count < range; resultIndex++, count++) {
                 results.add(resultArray.get(resultIndex).getAsJsonObject());
             }
 
@@ -352,7 +344,7 @@ public class PixivDownload {
         HttpResponse response = httpClient.execute(request);
 
         if(response.getStatusLine().getStatusCode() != 200) {
-            throw new IOException("Http响应码非200: " + response.getStatusLine());
+            throw new HttpRequestException(response);
         }
 
         Document document = Jsoup.parse(EntityUtils.toString(response.getEntity()));
@@ -391,16 +383,22 @@ public class PixivDownload {
      * @return 返回该illust所有Page的下载链接
      * @throws IOException 当HttpClient在请求时发生异常, 或接口报错时抛出, 注意{@link IOException#getMessage()}
      */
-    public static List<String> getIllustAllPageDownload(HttpClient httpClient, CookieStore cookieStore, int illustId, PageQuality quality) throws IOException {
-        HttpGet linkApiRequest = new HttpGet(PixivURL.PIXIV_ILLUST_API_URL.replace("{illustId}", Integer.toString(illustId)));
+    public static List<String> getIllustAllPageDownload(
+            HttpClient httpClient,
+            CookieStore cookieStore,
+            int illustId,
+            PageQuality quality
+    ) throws IOException {
+        HttpGet linkApiRequest = new HttpGet(PixivURL.PIXIV_ILLUST_API_URL
+                .replace("{illustId}", Integer.toString(illustId)));
         setCookieInRequest(linkApiRequest, cookieStore);
         HttpResponse response = httpClient.execute(linkApiRequest);
         JsonObject resultObject = new Gson().fromJson(EntityUtils.toString(response.getEntity()), JsonObject.class);
 
         if(resultObject.get("error").getAsBoolean()) {
             String message = resultObject.get("message").getAsString();
-            log.debug("请求错误, 错误信息: {}", message);
-            throw new IOException(message);
+            log.warn("作品页面接口请求错误, 错误信息: {}", message);
+            throw new HttpRequestException(response.getStatusLine(), resultObject.toString());
         }
 
         JsonArray linkArray = resultObject.getAsJsonArray("body");
@@ -419,6 +417,7 @@ public class PixivDownload {
     /**
      * 插图质量
      */
+    @SuppressWarnings("unused")
     public enum PageQuality{
         /**
          * 原图画质
@@ -448,7 +447,8 @@ public class PixivDownload {
     @Deprecated
     public Set<Map.Entry<String, InputStream>> getCollectionAsInputStream(PageQuality quality) throws IOException {
         HashSet<Map.Entry<String, InputStream>> illustInputStreamSet = new HashSet<>();
-        getCollectionAsInputStream(quality, (link, inputStream) -> illustInputStreamSet.add(new AbstractMap.SimpleEntry<>(link, inputStream)));
+        getCollectionAsInputStream(quality, (link, inputStream) ->
+                illustInputStreamSet.add(new AbstractMap.SimpleEntry<>(link, inputStream)));
         return illustInputStreamSet;
     }
 
@@ -473,9 +473,11 @@ public class PixivDownload {
         request.addHeader(HttpHeaderNames.REFERER.toString(), referer);
 
         HttpResponse response = httpClient.execute(request);
-        log.debug("response: {}", response);
-        log.debug("Content Length: {}KB", Float.parseFloat(response.getFirstHeader(HttpHeaderNames.CONTENT_LENGTH.toString()).getValue()) / 1024F);
-        log.debug("{}", response.getFirstHeader(HttpHeaderNames.CONTENT_TYPE.toString()));
+        log.trace("response: {}", response);
+        log.trace("Content Length: {}KB",
+                Float.parseFloat(response.getFirstHeader(HttpHeaderNames.CONTENT_LENGTH.toString()).getValue()) / 1024F
+        );
+        log.trace(response.getFirstHeader(HttpHeaderNames.CONTENT_TYPE.toString()).toString());
         return response.getEntity().getContent();
     }
 
@@ -496,51 +498,12 @@ public class PixivDownload {
         } else {
             return false;
         }
-
     }
 
     /**
      * 获取作品信息
      * @param illustId 作品ID
-     * @return 成功获取返回JsonObject, 失败返回null, <br/>
-     *      Json示例: <br/>
-     *      <pre>
-     *          {
-     *         "illustId": "79584670",
-     *         "illustTitle": "このヤンキーはウブすぎる",
-     *         "id": "79584670",
-     *         "title": "このヤンキーはウブすぎる",
-     *         "illustType": 1,
-     *         "xRestrict": 0,
-     *         "restrict": 0,
-     *         "sl": 2,
-     *         "url": "https://i.pximg.net/c/360x360_70/img-master/img/2020/02/19/00/38/23/79584670_p0_square1200.jpg",
-     *         "description": "",
-     *         "tags": [
-     *           "漫画",
-     *           "オリジナル",
-     *           "創作",
-     *           "創作男女",
-     *           "コロさん、ポリさん此方です!",
-     *           "恋の予感",
-     *           "あまずっぺー",
-     *           "交換日記",
-     *           "続編希望!!",
-     *           "オリジナル10000users入り"
-     *         ],
-     *         "userId": "4778293",
-     *         "userName": "隈浪さえ",
-     *         "width": 3288,
-     *         "height": 4564,
-     *         "pageCount": 4,
-     *         "isBookmarkable": true,
-     *         "bookmarkData": null,
-     *         "alt": "#オリジナル このヤンキーはウブすぎる - 隈浪さえ的漫画",
-     *         "isAdContainer": false,
-     *         "profileImageUrl": "https://i.pximg.net/user-profile/img/2019/12/04/18/56/19/16639046_fea29ce38ea89b0cb2313b40b3a72f9a_50.jpg",
-     *         "type": "illust"
-     *       }
-     *      </pre>
+     * @return 成功获取返回JsonObject, 失败返回null.
      * @throws IOException 当请求发生异常, 或接口返回错误信息时抛出.
      * @throws NoSuchElementException 当该作品不存在时抛出异常
      */
@@ -548,11 +511,11 @@ public class PixivDownload {
         HttpGet request = createHttpGetRequest(PixivURL.getPixivIllustInfoAPI(illustId));
         HttpResponse response = httpClient.execute(request);
         String responseStr = EntityUtils.toString(response.getEntity());
-        log.debug("Response Content: {}", responseStr);
+        log.trace("Response Content: {}", responseStr);
         JsonObject responseObj = new Gson().fromJson(responseStr, JsonObject.class);
 
         if(responseObj.get("error").getAsBoolean()) {
-            throw new IOException(responseObj.get("message").getAsString());
+            throw new HttpRequestException(response.getStatusLine(), responseStr);
         }
 
         JsonArray illustsArray = responseObj.getAsJsonObject("body").getAsJsonArray("illusts");
@@ -566,7 +529,8 @@ public class PixivDownload {
 
     public static void setCookieInRequest(HttpRequest request, CookieStore cookieStore) {
         StringBuilder builder = new StringBuilder();
-        cookieStore.getCookies().forEach(cookie -> builder.append(cookie.getName()).append("=").append(cookie.getValue()).append("; "));
+        cookieStore.getCookies().forEach(cookie ->
+                builder.append(cookie.getName()).append("=").append(cookie.getValue()).append("; "));
         request.setHeader(HttpHeaderNames.COOKIE.toString(), builder.toString());
     }
 

src/main/java/net/lamgc/cgj/pixiv/PixivSearchAttribute.java

@@ -0,0 +1,22 @@
+package net.lamgc.cgj.pixiv;
+
+/**
+ * 搜索结果的属性枚举类.
+ * <p>按照请求的{@link PixivSearchLinkBuilder.SearchArea}获取所支持的属性数组</p>
+ */
+public enum PixivSearchAttribute {
+
+    ARTWORKS("illustManga"),
+    TOP("illustManga", "novel"),
+    ILLUSTRATIONS("illust"),
+    MANGA("manga"),
+    NOVELS("novel")
+    ;
+
+    public final String[] attributeNames;
+
+    PixivSearchAttribute(String... attributeNames) {
+        this.attributeNames = attributeNames;
+    }
+
+}

src/main/java/net/lamgc/cgj/pixiv/PixivSearchLinkBuilder.java

@@ -8,6 +8,7 @@ import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.HashSet;
 import java.util.Objects;
+import java.util.Set;
 
 /**
  * Pixiv搜索URL构造器
@@ -15,8 +16,8 @@ import java.util.Objects;
  * @author LamGC
  * @see PixivURL#PIXIV_SEARCH_CONTENT_URL
  */
-@SuppressWarnings("ALL")
-public class PixivSearchBuilder {
+@SuppressWarnings({"unused", "UnusedReturnValue"})
+public class PixivSearchLinkBuilder {
 
     private final String content;
 
@@ -26,8 +27,8 @@ public class PixivSearchBuilder {
     private SearchOrder searchOrder = SearchOrder.DATE_D;
     private SearchContentOption searchContentOption = SearchContentOption.ALL;
 
-    private HashSet<String> includeKeywords = new HashSet<>(0);
-    private HashSet<String> excludeKeywords = new HashSet<>(0);
+    private final Set<String> includeKeywords = new HashSet<>(0);
+    private final Set<String> excludeKeywords = new HashSet<>(0);
 
     private int page = 1;
 
@@ -42,7 +43,7 @@ public class PixivSearchBuilder {
     private Date startDate = null;
     private Date endDate = null;
 
-    public PixivSearchBuilder(String searchContent) {
+    public PixivSearchLinkBuilder(String searchContent) {
         this.content = Objects.requireNonNull(searchContent);
     }
 
@@ -99,7 +100,7 @@ public class PixivSearchBuilder {
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
-        PixivSearchBuilder that = (PixivSearchBuilder) o;
+        PixivSearchLinkBuilder that = (PixivSearchLinkBuilder) o;
         return page == that.page &&
                 wgt == that.wgt &&
                 hgt == that.hgt &&
@@ -141,7 +142,7 @@ public class PixivSearchBuilder {
 
     @Override
     public String toString() {
-        return "PixivSearchBuilder{" +
+        return "PixivSearchLinkBuilder{" +
                 "content='" + content + '\'' +
                 ", searchArea=" + searchArea +
                 ", searchMode=" + searchMode +
@@ -161,15 +162,15 @@ public class PixivSearchBuilder {
                 '}';
     }
 
-    public PixivSearchBuilder setSearchArea(SearchArea searchArea) {
+    public String getContent() {
+        return content;
+    }
+
+    public PixivSearchLinkBuilder setSearchArea(SearchArea searchArea) {
         this.searchArea = Objects.requireNonNull(searchArea);
         return this;
     }
 
-    /**
-     * 获取搜索区域
-     * @return 返回搜索区域对象
-     */
     public SearchArea getSearchArea() {
         return searchArea;
     }
@@ -202,50 +203,78 @@ public class PixivSearchBuilder {
         return searchContent.toString();
     }
 
-    public PixivSearchBuilder setSearchMode(SearchMode searchMode) {
+    public PixivSearchLinkBuilder setSearchMode(SearchMode searchMode) {
         this.searchMode = Objects.requireNonNull(searchMode);
         return this;
     }
 
-    public PixivSearchBuilder setSearchType(SearchType searchType) {
+    public SearchMode getSearchMode() {
+        return searchMode;
+    }
+
+    public PixivSearchLinkBuilder setSearchType(SearchType searchType) {
         this.searchType = Objects.requireNonNull(searchType);
         return this;
     }
 
-    public PixivSearchBuilder setSearchOrder(SearchOrder searchOrder) {
+    public SearchType getSearchType() {
+        return searchType;
+    }
+
+    public PixivSearchLinkBuilder setSearchOrder(SearchOrder searchOrder) {
         this.searchOrder = Objects.requireNonNull(searchOrder);
         return this;
     }
 
-    public PixivSearchBuilder setSearchContentOption(SearchContentOption searchContentOption) {
+    public SearchOrder getSearchOrder() {
+        return searchOrder;
+    }
+
+    public PixivSearchLinkBuilder setSearchContentOption(SearchContentOption searchContentOption) {
         this.searchContentOption = Objects.requireNonNull(searchContentOption);
         return this;
     }
 
-    public PixivSearchBuilder setRatioOption(RatioOption ratioOption) {
+    public SearchContentOption getSearchContentOption() {
+        return searchContentOption;
+    }
+
+    public PixivSearchLinkBuilder setRatioOption(RatioOption ratioOption) {
         this.ratioOption = Objects.requireNonNull(ratioOption);
         return this;
     }
 
-    public PixivSearchBuilder setDateRange(Date startDate, Date endDate) {
+    public RatioOption getRatioOption() {
+        return ratioOption;
+    }
+
+    public PixivSearchLinkBuilder setDateRange(Date startDate, Date endDate) {
         this.startDate = startDate;
         this.endDate = endDate;
         return this;
     }
 
-    public PixivSearchBuilder setMaxSize(int width, int height) {
+    public Date getStartDate() {
+        return startDate;
+    }
+
+    public Date getEndDate() {
+        return endDate;
+    }
+
+    public PixivSearchLinkBuilder setMaxSize(int width, int height) {
         this.wgt = width;
         this.hgt = height;
         return this;
     }
 
-    public PixivSearchBuilder setMinSize(int width, int height) {
+    public PixivSearchLinkBuilder setMinSize(int width, int height) {
         this.wlt = width;
         this.hlt = height;
         return this;
     }
 
-    public PixivSearchBuilder setPage(int pageIndex) {
+    public PixivSearchLinkBuilder setPage(int pageIndex) {
         if (pageIndex <= 0) {
             throw new IllegalArgumentException("Invalid pageIndex: " + pageIndex);
         }
@@ -253,26 +282,38 @@ public class PixivSearchBuilder {
         return this;
     }
 
-    public PixivSearchBuilder addExcludeKeyword(String keyword) {
+    public int getPage() {
+        return page;
+    }
+
+    public PixivSearchLinkBuilder addExcludeKeyword(String keyword) {
         excludeKeywords.add(keyword);
         return this;
     }
 
-    public PixivSearchBuilder removeExcludeKeyword(String keyword) {
+    public PixivSearchLinkBuilder removeExcludeKeyword(String keyword) {
         excludeKeywords.remove(keyword);
         return this;
     }
 
-    public PixivSearchBuilder addIncludeKeyword(String keyword) {
+    public PixivSearchLinkBuilder addIncludeKeyword(String keyword) {
         includeKeywords.add(keyword);
         return this;
     }
 
-    public PixivSearchBuilder removeIncludeKeyword(String keyword) {
+    public PixivSearchLinkBuilder removeIncludeKeyword(String keyword) {
         includeKeywords.remove(keyword);
         return this;
     }
 
+    public Set<String> getIncludeKeywords() {
+        return new HashSet<>(includeKeywords);
+    }
+
+    public Set<String> getExcludeKeywords() {
+        return new HashSet<>(excludeKeywords);
+    }
+
     /**
      * 搜索区域
      */
@@ -304,13 +345,18 @@ public class PixivSearchBuilder {
          */
         NOVELS("novel");
 
+        /**
+         * 可用的Json属性名
+         * @deprecated 该属性信息以移至 {@link PixivSearchAttribute}
+         * @see PixivSearchAttribute
+         */
+        @Deprecated
         public final String jsonKey;
 
         SearchArea(String jsonKey) {
             this.jsonKey = jsonKey;
         }
 
-
     }
 
     /**
@@ -409,5 +455,4 @@ public class PixivSearchBuilder {
 
     }
 
-
 }

src/main/java/net/lamgc/cgj/pixiv/PixivURL.java

@@ -1,7 +1,6 @@
 package net.lamgc.cgj.pixiv;
 
 import java.text.SimpleDateFormat;
-import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.GregorianCalendar;
@@ -10,55 +9,56 @@ import java.util.GregorianCalendar;
  * 目前已整理的一些Pixiv接口列表
  */
 @SuppressWarnings("unused")
-public class PixivURL {
+public final class PixivURL {
 
+    private PixivURL() {}
 
-    public static final String PIXIV_INDEX_URL = "https://www.pixiv.net";
+    public final static String PIXIV_INDEX_URL = "https://www.pixiv.net";
 
     /**
      * P站预登陆url
      */
-    public static final String PIXIV_LOGIN_PAGE_URL = "https://accounts.pixiv.net/login?lang=zh&source=pc&view_type=page&ref=wwwtop_accounts_index";
+    public final static String PIXIV_LOGIN_PAGE_URL = "https://accounts.pixiv.net/login?lang=zh&source=pc&view_type=page&ref=wwwtop_accounts_index";
 
     /**
      * P站登录请求url
      */
-    public static final String PIXIV_LOGIN_URL = "https://accounts.pixiv.net/api/login?lang=zh";
+    public final static String PIXIV_LOGIN_URL = "https://accounts.pixiv.net/api/login?lang=zh";
 
     /**
      * P站搜索请求url
-     * @deprecated 该接口已被替换, 请使用{@link PixivSearchBuilder}构造搜索Url
-     * @see PixivSearchBuilder
+     * @deprecated 该接口已被替换, 请使用{@link PixivSearchLinkBuilder}构造搜索Url
+     * @see PixivSearchLinkBuilder
      */
     @Deprecated
-    private static final String PIXIV_SEARCH_URL = "https://www.pixiv.net/search.php";
+    private final static String PIXIV_SEARCH_URL = "https://www.pixiv.net/search.php";
 
     /**
      * P站搜索用户url
      * 需要替换的参数:
      * {nick} - 用户昵称、部分名称
-     * @deprecated 该接口已被替换, 请使用{@link PixivSearchBuilder}构造搜索Url
-     * @see PixivSearchBuilder
+     * @deprecated 该接口已被替换, 请使用{@link PixivSearchLinkBuilder}构造搜索Url
+     * @see PixivSearchLinkBuilder
      */
     @Deprecated
-    public static final String PIXIV_SEARCH_USER_URL = PIXIV_SEARCH_URL + "?s_mode=s_usr&nick={nick}";
+    public final static String PIXIV_SEARCH_USER_URL = PIXIV_SEARCH_URL + "?s_mode=s_usr&nick={nick}";
 
     /**
      * P站搜索插画url
      * 需要替换的参数:
      * {word} - 插画相关文本
-     * @deprecated 该接口已被替换, 请使用{@link PixivSearchBuilder}构造搜索Url
-     * @see PixivSearchBuilder
+     * @deprecated 该接口已被替换, 请使用{@link PixivSearchLinkBuilder}构造搜索Url
+     * @see PixivSearchLinkBuilder
      */
     @Deprecated
-    public static final String PIXIV_SEARCH_TAG_URL = PIXIV_SEARCH_URL + "?s_mode=s_tag&word={word}";
+    public final static String PIXIV_SEARCH_TAG_URL = PIXIV_SEARCH_URL + "?s_mode=s_tag&word={word}";
 
     /**
      * P站插图下载链接获取url
      * 需要替换的文本:
      * {illustId} - 插画ID
      */
-    public static final String PIXIV_ILLUST_API_URL = "https://www.pixiv.net/ajax/illust/{illustId}/pages";
+    public final static String PIXIV_ILLUST_API_URL = "https://www.pixiv.net/ajax/illust/{illustId}/pages";
 
     /**
      * P站用户插图列表获取API
@@ -67,42 +67,42 @@ public class PixivURL {
      * {userId} - 用户ID
      */
     //{"error":false,"message":"","body":{"illusts":{"74369837":null,"70990542":null,"70608653":null,"69755191":null,"69729450":null,"69729416":null,"69503608":null,"69288766":null,"69083882":null,"69051458":null,"68484200":null,"68216927":null,"68216866":null,"68192333":null,"67915106":null,"67914932":null,"67854803":null,"67854745":null,"67854670":null,"67787211":null,"67772199":null,"67770637":null,"67754861":null,"67754804":null,"67754726":null,"67740486":null,"67740480":null,"67740450":null,"67740434":null,"67726337":null,"67499196":null,"67499163":null,"67499145":null,"67499111":null,"67499085":null,"67499038":null,"67498987":null,"67473178":null,"66271465":null,"63682753":null,"63682697":null,"59385148":null,"59383265":null,"59383240":null,"59383227":null,"59383173":null},"manga":[],"novels":[],"mangaSeries":[],"novelSeries":[],"pickup":[],"bookmarkCount":{"public":{"illust":1,"novel":0},"private":{"illust":0,"novel":0}}}}
-    public static final String PIXIV_USER_ILLUST_LIST_URL = "https://www.pixiv.net/ajax/user/{userId}/profile/all";
+    public final static String PIXIV_USER_ILLUST_LIST_URL = "https://www.pixiv.net/ajax/user/{userId}/profile/all";
 
     /**
      * 能够同时获取插图信息的用户插图列表获取API
      * 需要替换的文本:
      * {userId} - 用户ID
      */
-    public static final String PIXIV_USER_TOP_ILLUST_LIST_URL = "https://www.pixiv.net/ajax/user/{userId}/profile/top";
+    public final static String PIXIV_USER_TOP_ILLUST_LIST_URL = "https://www.pixiv.net/ajax/user/{userId}/profile/top";
 
     /**
      * P站单图详情页url
      * 需要替换的文本:
      * {illustId} - 插画ID
      */
-    public static final String PIXIV_ILLUST_MEDIUM_URL = "https://www.pixiv.net/member_illust.php?mode=medium&illust_id={illustId}";
+    public final static String PIXIV_ILLUST_MEDIUM_URL = "https://www.pixiv.net/member_illust.php?mode=medium&illust_id={illustId}";
 
     /**
      * P站多图详情页url
      * 需要替换的文本:
      * {illustId} - 插画ID
      */
-    public static final String PIXIV_ILLUST_MANGA_URL = "https://www.pixiv.net/member_illust.php?mode=manga&illust_id={illustId}";
+    public final static String PIXIV_ILLUST_MANGA_URL = "https://www.pixiv.net/member_illust.php?mode=manga&illust_id={illustId}";
 
     /**
      * P站用户页面url
      * 需要替换的文本:
      * {userId} - 用户ID
      */
-    public static final String PIXIV_USER_URL = "https://www.pixiv.net/member.php?id={userId}";
+    public final static String PIXIV_USER_URL = "https://www.pixiv.net/member.php?id={userId}";
 
     /**
      * P站插图信息获取API
      * 这个API能获取插图基本信息，但不能获取大小
      * 请使用{@link #getPixivIllustInfoAPI(int[])}获取URL
      */
-    private static final String PIXIV_GET_ILLUST_INFO_URL = "https://www.pixiv.net/ajax/illust/recommend/illusts?";
+    private final static String PIXIV_GET_ILLUST_INFO_URL = "https://www.pixiv.net/ajax/illust/recommend/illusts?";
 
     /**
      * P站获取用户所有插图ID的Api
@@ -110,7 +110,15 @@ public class PixivURL {
      * 需要替换的文本:
      * {userId} - 用户ID
      */
-    public static final String PIXIV_GET_USER_ALL_ILLUST_ID_URL = "https://www.pixiv.net/ajax/user/{userId}/profile/all";
+    public final static String PIXIV_GET_USER_ALL_ILLUST_URL = "https://www.pixiv.net/ajax/user/{userId}/profile/all";
+
+    /**
+     * P站获取用户推荐插画及用户基本数据
+     * 这个API能获得作者的部分(推荐)作品, 每个作品有详细数据, 还能获取作者主页信息(比如主页说明, 看板图)
+     * 需要替换的文本:
+     * {userId} - 用户ID
+     */
+    public final static String PIXIV_GET_USER_TOP_ILLUST_URL = "https://www.pixiv.net/ajax/user/{userId}/profile/top";
 
     /**
      * P站标签搜索URL
@@ -118,7 +126,7 @@ public class PixivURL {
      * 需要替换的文本:
      * {content} - 大致tag内容
      */
-    public static final String PIXIV_TAG_SEARCH_URL = "https://www.pixiv.net/ajax/search/tags/{content}";
+    public final static String PIXIV_TAG_SEARCH_URL = "https://www.pixiv.net/ajax/search/tags/{content}";
 
     /**
      * 获取动图下载链接和拼接数据.
@@ -128,11 +136,17 @@ public class PixivURL {
      */
     public final static String PIXIV_GET_UGOIRA_META_URL = "https://www.pixiv.net/ajax/illust/{illustId}/ugoira_meta";
 
+    /**
+     * 获取自己帐号的部分数据(目前仅能获取: 关注数, 粉丝数和看板图)
+     * 需要登录.
+     */
+    public final static String PIXIV_GET_USER_EXTRA_URL = "https://www.pixiv.net/ajax/user/extra";
+
     /**
      * 请求时带上需要退出的Cookies
      * 无论成功与否都会返回302重定向到{@linkplain #PIXIV_LOGIN_PAGE_URL 登录页面}
      */
-    public static final String PIXIV_LOGOUT_URL = "https://www.pixiv.net/logout.php";
+    public final static String PIXIV_LOGOUT_URL = "https://www.pixiv.net/logout.php";
 
     /**
      * 构造P站获取插图信息的Api Url
@@ -194,7 +208,13 @@ public class PixivURL {
      * @param pageIndex 页数，一页50位，总共10页
      * @return 返回构建好的链接
      */
-    public static String getRankingLink(RankingContentType contentType, RankingMode mode, Date time, int pageIndex, boolean json){
+    public static String getRankingLink(
+            RankingContentType contentType,
+            RankingMode mode,
+            Date time,
+            int pageIndex,
+            boolean json
+    ){
         StringBuilder linkBuilder = new StringBuilder(PIXIV_RANKING_LINK);
         linkBuilder.append("mode=").append(mode == null ? RankingMode.MODE_DAILY.modeParam : mode.modeParam);
         if(contentType != null && !contentType.equals(RankingContentType.TYPE_ALL)){
@@ -220,137 +240,12 @@ public class PixivURL {
         return linkBuilder.toString();
     }
 
-    /**
-     * 排名榜模式
-     */
-    public enum RankingMode{
-        /**
-         * 每天
-         */
-        MODE_DAILY("daily"),
-        /**
-         * 每周
-         */
-        MODE_WEEKLY("weekly"),
-        /**
-         * 每月
-         */
-        MODE_MONTHLY("monthly"),
-        /**
-         * 新人
-         */
-        MODE_ROOKIE("rookie"),
-        /**
-         * 原创
-         */
-        MODE_ORIGINAL("original"),
-        /**
-         * 受男性喜欢
-         */
-        MODE_MALE("male"),
-        /**
-         * 受女性喜欢
-         */
-        MODE_FEMALE("female"),
-
-        /**
-         * 每天 - R18
-         */
-        MODE_DAILY_R18("daily_r18"),
-        /**
-         * 每周 - R18
-         */
-        MODE_WEEKLY_R18("weekly_r18"),
-        /**
-         * 受男性喜欢 - R18
-         */
-        MODE_MALE_R18("male_r18"),
-        /**
-         * 受女性喜欢 - R18
-         */
-        MODE_FEMALE_R18("female_r18"),
-        ;
-        public String modeParam;
-
-        RankingMode(String modeParamName){
-            this.modeParam = modeParamName;
-        }
-    }
-
     /**
      * Pixiv搜索接口.<br/>
-     * 要使用该链接请使用{@link PixivSearchBuilder}构造链接.<br/>
+     * 要使用该链接请使用{@link PixivSearchLinkBuilder}构造链接.<br/>
      * 需要替换的参数: <br/>
      * content - 搜索内容
      */
     final static String PIXIV_SEARCH_CONTENT_URL = "https://www.pixiv.net/ajax/search/{area}/{content}?word={content}";
 
-    /**
-     * 排名榜类型
-     */
-    public enum RankingContentType{
-        TYPE_ALL("", RankingMode.values()),
-        /**
-         * 插画
-         * 支持的时间类型: 每天, 每周, 每月, 新人
-         */
-        TYPE_ILLUST("illust",
-                new RankingMode[]{
-                        RankingMode.MODE_DAILY,
-                        RankingMode.MODE_MONTHLY,
-                        RankingMode.MODE_WEEKLY,
-                        RankingMode.MODE_ROOKIE,
-                        RankingMode.MODE_DAILY_R18,
-                        RankingMode.MODE_WEEKLY_R18,
-                }
-        ),
-        /**
-         * 动图
-         * 支持的时间类型:每天, 每周
-         */
-        TYPE_UGOIRA("ugoira",
-                new RankingMode[]{
-                        RankingMode.MODE_DAILY,
-                        RankingMode.MODE_WEEKLY,
-                        RankingMode.MODE_DAILY_R18,
-                        RankingMode.MODE_WEEKLY_R18
-                }
-        ),
-        /**
-         * 漫画
-         * 支持的时间类型: 每天, 每周, 每月, 新人
-         */
-        TYPE_MANGA("manga",
-                new RankingMode[]{
-                        RankingMode.MODE_DAILY,
-                        RankingMode.MODE_MONTHLY,
-                        RankingMode.MODE_WEEKLY,
-                        RankingMode.MODE_ROOKIE,
-                        RankingMode.MODE_DAILY_R18,
-                        RankingMode.MODE_WEEKLY_R18,
-                }
-        )
-        ;
-
-        String typeName;
-
-        private final RankingMode[] supportedMode;
-
-        RankingContentType(String typeName, RankingMode[] supportedMode){
-            this.typeName = typeName;
-            this.supportedMode = supportedMode;
-        }
-
-        /**
-         * 检查指定RankingMode是否支持
-         * @param mode 要检查的RankingMode项
-         * @return 如果支持返回true
-         */
-        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
-        public boolean isSupportedMode(RankingMode mode) {
-            return Arrays.binarySearch(supportedMode, mode) >= 0;
-        }
-
-    }
-
 }

src/main/java/net/lamgc/cgj/pixiv/PixivUgoiraBuilder.java

@@ -1,5 +1,6 @@
 package net.lamgc.cgj.pixiv;
 
+import com.google.common.io.ByteStreams;
 import com.google.gson.Gson;
 import com.google.gson.JsonArray;
 import com.google.gson.JsonObject;
@@ -7,11 +8,11 @@ import com.squareup.gifencoder.GifEncoder;
 import com.squareup.gifencoder.Image;
 import com.squareup.gifencoder.ImageOptions;
 import io.netty.handler.codec.http.HttpHeaderNames;
+import net.lamgc.cgj.exception.HttpRequestException;
 import org.apache.http.HttpResponse;
 import org.apache.http.client.HttpClient;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.util.EntityUtils;
-import org.apache.tomcat.util.http.fileupload.util.Streams;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -46,12 +47,12 @@ public final class PixivUgoiraBuilder {
         log.debug("Request Url: {}", request.getURI());
         HttpResponse response = httpClient.execute(request);
         String bodyStr = EntityUtils.toString(response.getEntity());
-        log.debug("JsonBodyStr: {}", bodyStr);
+        log.trace("JsonBodyStr: {}", bodyStr);
         JsonObject resultObject = new Gson().fromJson(bodyStr, JsonObject.class);
         if(resultObject.get("error").getAsBoolean()) {
             String message = resultObject.get("message").getAsString();
             log.error("获取动图元数据失败!(接口报错: {})", message);
-            throw new IOException(message);
+            throw new HttpRequestException(response.getStatusLine(), bodyStr);
         } else if(!resultObject.has("body")) {
             String message = "接口返回数据不存在body属性, 可能接口发生改变!";
             log.error(message);
@@ -126,14 +127,13 @@ public final class PixivUgoiraBuilder {
         HashMap<String, InputStream> frameMap = new HashMap<>(frames.size());
         while((entry = zipInputStream.getNextEntry()) != null) {
             log.trace("ZipEntry {} 正在接收...", entry);
-            Streams.copy(zipInputStream, cacheOutputStream, false);
+            ByteStreams.copy(zipInputStream, cacheOutputStream);
             frameMap.put(entry.getName(), new ByteArrayInputStream(cacheOutputStream.toByteArray()));
             log.trace("ZipEntry {} 已接收完成.", entry);
             cacheOutputStream.reset();
         }
 
-
-        InputStream firstFrameInput = frameMap.get("000000.jpg");
+        InputStream firstFrameInput = frameMap.get(frames.get(0).getAsJsonObject().get("file").getAsString());
         BufferedImage firstFrame = ImageIO.read(firstFrameInput);
         firstFrameInput.reset();
         if(width != firstFrame.getWidth() || height != firstFrame.getHeight()) {
@@ -173,15 +173,15 @@ public final class PixivUgoiraBuilder {
     private void getUgoiraImageSize() throws IOException {
         log.debug("正在从Pixiv获取动图尺寸...");
         HttpGet request = new HttpGet(PixivURL.getPixivIllustInfoAPI(illustId));
-        log.debug("Request Url: {}", request.getURI());
+        log.trace("Request Url: {}", request.getURI());
         HttpResponse response = httpClient.execute(request);
         String responseBody = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
-        log.debug("ResponseBody: {}", responseBody);
+        log.trace("ResponseBody: {}", responseBody);
         JsonObject resultObject = new Gson().fromJson(responseBody, JsonObject.class);
         if(resultObject.get("error").getAsBoolean()) {
             String message = resultObject.get("message").getAsString();
             log.error("接口返回错误: {}", message);
-            throw new IOException(message);
+            throw new HttpRequestException(response.getStatusLine(), responseBody);
         }
 
         JsonArray illustsArray = resultObject.getAsJsonObject("body").getAsJsonArray("illusts");

src/main/java/net/lamgc/cgj/pixiv/RankingContentType.java

@@ -0,0 +1,75 @@
+package net.lamgc.cgj.pixiv;
+
+import java.util.Arrays;
+
+/**
+ * 排名榜类型
+ */
+public enum RankingContentType{
+    /**
+     * 所有类型.
+     * 支持所有Mode.
+     */
+    TYPE_ALL("", RankingMode.values()),
+    /**
+     * 插画
+     * 支持的时间类型: 每天, 每周, 每月, 新人
+     */
+    TYPE_ILLUST("illust",
+            new RankingMode[]{
+                    RankingMode.MODE_DAILY,
+                    RankingMode.MODE_MONTHLY,
+                    RankingMode.MODE_WEEKLY,
+                    RankingMode.MODE_ROOKIE,
+                    RankingMode.MODE_DAILY_R18,
+                    RankingMode.MODE_WEEKLY_R18,
+            }
+    ),
+    /**
+     * 动图
+     * 支持的时间类型:每天, 每周
+     */
+    TYPE_UGOIRA("ugoira",
+            new RankingMode[]{
+                    RankingMode.MODE_DAILY,
+                    RankingMode.MODE_WEEKLY,
+                    RankingMode.MODE_DAILY_R18,
+                    RankingMode.MODE_WEEKLY_R18
+            }
+    ),
+    /**
+     * 漫画
+     * 支持的时间类型: 每天, 每周, 每月, 新人
+     */
+    TYPE_MANGA("manga",
+            new RankingMode[]{
+                    RankingMode.MODE_DAILY,
+                    RankingMode.MODE_MONTHLY,
+                    RankingMode.MODE_WEEKLY,
+                    RankingMode.MODE_ROOKIE,
+                    RankingMode.MODE_DAILY_R18,
+                    RankingMode.MODE_WEEKLY_R18,
+            }
+    )
+    ;
+
+    String typeName;
+
+    private final RankingMode[] supportedMode;
+
+    RankingContentType(String typeName, RankingMode[] supportedMode){
+        this.typeName = typeName;
+        this.supportedMode = supportedMode;
+    }
+
+    /**
+     * 检查指定RankingMode是否支持
+     * @param mode 要检查的RankingMode项
+     * @return 如果支持返回true
+     */
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
+    public boolean isSupportedMode(RankingMode mode) {
+        return Arrays.binarySearch(supportedMode, mode) >= 0;
+    }
+
+}

src/main/java/net/lamgc/cgj/pixiv/RankingMode.java

@@ -0,0 +1,58 @@
+package net.lamgc.cgj.pixiv;
+
+/**
+ * 排名榜模式
+ */
+public enum RankingMode{
+    /**
+     * 每天
+     */
+    MODE_DAILY("daily"),
+    /**
+     * 每周
+     */
+    MODE_WEEKLY("weekly"),
+    /**
+     * 每月
+     */
+    MODE_MONTHLY("monthly"),
+    /**
+     * 新人
+     */
+    MODE_ROOKIE("rookie"),
+    /**
+     * 原创
+     */
+    MODE_ORIGINAL("original"),
+    /**
+     * 受男性喜欢
+     */
+    MODE_MALE("male"),
+    /**
+     * 受女性喜欢
+     */
+    MODE_FEMALE("female"),
+
+    /**
+     * 每天 - R18
+     */
+    MODE_DAILY_R18("daily_r18"),
+    /**
+     * 每周 - R18
+     */
+    MODE_WEEKLY_R18("weekly_r18"),
+    /**
+     * 受男性喜欢 - R18
+     */
+    MODE_MALE_R18("male_r18"),
+    /**
+     * 受女性喜欢 - R18
+     */
+    MODE_FEMALE_R18("female_r18"),
+    ;
+    public String modeParam;
+
+    RankingMode(String modeParamName){
+        this.modeParam = modeParamName;
+    }
+}

src/main/java/net/lamgc/cgj/proxy/PixivAccessProxyServer.java

@@ -1,149 +0,0 @@
-package net.lamgc.cgj.proxy;
-
-import com.github.monkeywie.proxyee.intercept.HttpProxyIntercept;
-import com.github.monkeywie.proxyee.intercept.HttpProxyInterceptInitializer;
-import com.github.monkeywie.proxyee.intercept.HttpProxyInterceptPipeline;
-import com.github.monkeywie.proxyee.intercept.common.CertDownIntercept;
-import com.github.monkeywie.proxyee.proxy.ProxyConfig;
-import com.github.monkeywie.proxyee.server.HttpProxyServer;
-import com.github.monkeywie.proxyee.server.HttpProxyServerConfig;
-import io.netty.channel.Channel;
-import io.netty.handler.codec.http.HttpHeaderNames;
-import io.netty.handler.codec.http.HttpHeaders;
-import io.netty.handler.codec.http.HttpRequest;
-import io.netty.handler.codec.http.HttpResponse;
-import org.apache.http.client.CookieStore;
-import org.apache.http.impl.cookie.BasicClientCookie;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.net.HttpCookie;
-import java.util.Date;
-import java.util.List;
-
-/**
- * 登录成功后提供CookieStore, 然后由程序自动登录Pixiv
- * @author LamGC
- */
-public class PixivAccessProxyServer {
-
-    private final Logger log = LoggerFactory.getLogger(PixivAccessProxyServer.class);
-
-    private final HttpProxyServer proxyServer;
-
-    private final CookieStore cookieStore;
-
-    public PixivAccessProxyServer(CookieStore cookieStore){
-        this(cookieStore, null);
-    }
-
-    public PixivAccessProxyServer(CookieStore cookieStore, ProxyConfig proxyConfig){
-        HttpProxyServerConfig config = new HttpProxyServerConfig();
-        this.cookieStore = cookieStore;
-        config.setHandleSsl(true);
-        this.proxyServer = new HttpProxyServer();
-        this.proxyServer
-                .serverConfig(config)
-                .proxyConfig(proxyConfig)
-                .proxyInterceptInitializer(new HttpProxyInterceptInitializer(){
-                    @Override
-                    public void init(HttpProxyInterceptPipeline pipeline) {
-                        pipeline.addLast(new CertDownIntercept());
-                        pipeline.addLast(new HttpProxyIntercept(){
-
-                            private boolean match(HttpRequest request){
-                                String host = request.headers().get(HttpHeaderNames.HOST);
-                                return host.equalsIgnoreCase("pixiv.net") || host.contains(".pixiv.net");
-                            }
-
-                            @Override
-                            public void beforeRequest(Channel clientChannel, HttpRequest httpRequest, HttpProxyInterceptPipeline pipeline) throws Exception {
-                                log.info("URL: " + httpRequest.headers().get(HttpHeaderNames.HOST) + httpRequest.uri());
-                                if(!match(httpRequest)){
-                                    super.beforeRequest(clientChannel, httpRequest, pipeline);
-                                    return;
-                                }
-                                log.info("正在注入Cookies...");
-                                HttpHeaders requestHeaders = httpRequest.headers();
-                                if(requestHeaders.contains(HttpHeaderNames.COOKIE)){
-                                    log.info("原请求存在自带Cookies, 正在清除Cookies...");
-                                    log.debug("原Cookies: {}", requestHeaders.getAsString(HttpHeaderNames.COOKIE));
-                                    requestHeaders.remove(HttpHeaderNames.COOKIE);
-                                }
-                                StringBuilder cookieBuilder = new StringBuilder();
-                                cookieStore.getCookies().forEach(cookie -> {
-                                    if(cookie.isExpired(new Date())){
-                                        return;
-                                    }
-                                    cookieBuilder.append(cookie.getName()).append("=").append(cookie.getValue()).append("; ");
-                                });
-                                log.info("Cookies构造完成, 结果: " + cookieBuilder.toString());
-                                requestHeaders.add(HttpHeaderNames.COOKIE, cookieBuilder.toString());
-                                log.info("Cookies注入完成.");
-
-                                super.beforeRequest(clientChannel, httpRequest, pipeline);
-                            }
-
-                            @Override
-                            public void afterResponse(Channel clientChannel, Channel proxyChannel, HttpResponse httpResponse, HttpProxyInterceptPipeline pipeline) throws Exception {
-                                if(!match(pipeline.getHttpRequest())){
-                                    super.afterResponse(clientChannel, proxyChannel, httpResponse, pipeline);
-                                    return;
-                                }
-                                log.info("正在更新Response Cookie...(Header Name: " + HttpHeaderNames.SET_COOKIE + ")");
-                                List<String> responseCookies = httpResponse.headers().getAll(HttpHeaderNames.SET_COOKIE);
-                                responseCookies.forEach(value -> {
-                                    /*if(check(value)){
-                                        log.info("黑名单Cookie, 已忽略: " + value);
-                                        return;
-                                    }*/
-                                    log.info("Response Cookie: " + value);
-                                    BasicClientCookie cookie = parseRawCookie(value);
-                                    cookieStore.addCookie(cookie);
-                                });
-                                httpResponse.headers().remove(HttpHeaderNames.SET_COOKIE);
-                                super.afterResponse(clientChannel, proxyChannel, httpResponse, pipeline);
-                            }
-
-                            protected BasicClientCookie parseRawCookie(String rawCookie) {
-                                List<HttpCookie> cookies = HttpCookie.parse(rawCookie);
-                                if (cookies.size() < 1)
-                                    return null;
-                                HttpCookie httpCookie = cookies.get(0);
-                                BasicClientCookie cookie = new BasicClientCookie(httpCookie.getName(), httpCookie.getValue());
-                                if (httpCookie.getMaxAge() >= 0) {
-                                    Date expiryDate = new Date(System.currentTimeMillis() + httpCookie.getMaxAge() * 1000);
-                                    cookie.setExpiryDate(expiryDate);
-                                }
-                                if (httpCookie.getDomain() != null)
-                                    cookie.setDomain(httpCookie.getDomain());
-                                if (httpCookie.getPath() != null)
-                                    cookie.setPath(httpCookie.getPath());
-                                if (httpCookie.getComment() != null)
-                                    cookie.setComment(httpCookie.getComment());
-                                cookie.setSecure(httpCookie.getSecure());
-                                return cookie;
-                            }
-                        });
-                    }
-                });
-    }
-
-    public void start(int port){
-        this.proxyServer.start(port);
-    }
-
-    public void close(){
-        this.proxyServer.close();
-    }
-
-    /**
-     * 导出CookieStore.
-     * 注意!该方法导出的CookieStore不适用于ApacheHttpClient, 如需使用则需要进行转换.
-     * @return CookieStore对象
-     */
-    public CookieStore getCookieStore(){
-        return this.cookieStore;
-    }
-
-}

src/main/java/net/lamgc/cgj/util/Locker.java

@@ -0,0 +1,65 @@
+package net.lamgc.cgj.util;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class Locker<K> {
+
+    private final LockerMap<K> fromMap;
+
+    private final K key;
+
+    private final boolean autoDestroy;
+
+    private final AtomicInteger lockCount = new AtomicInteger(0);
+
+    /**
+     * 构造一个锁对象
+     * @param map 所属LockerMap
+     * @param key 所属Key
+     */
+    Locker(LockerMap<K> map, K key, boolean autoDestroy) {
+        this.fromMap = map;
+        this.key = key;
+        this.autoDestroy = autoDestroy;
+    }
+
+    /**
+     * 上锁
+     */
+    public void lock() {
+        lockCount.incrementAndGet();
+    }
+
+    /**
+     * 解锁
+     */
+    public void unlock() {
+        int newValue = lockCount.decrementAndGet();
+        if(newValue <= 0 && autoDestroy) {
+            destroy();
+        }
+    }
+
+    /**
+     * 获取锁对象所属Key
+     */
+    public K getKey() {
+        return key;
+    }
+
+    /**
+     * 销毁锁对象
+     */
+    public void destroy() {
+        fromMap.destroyLocker(this);
+    }
+
+    @Override
+    public String toString() {
+        return "Locker@" + this.hashCode() + "{" +
+                "fromMap=" + fromMap +
+                ", key=" + key +
+                '}';
+    }
+
+}

src/main/java/net/lamgc/cgj/util/LockerMap.java

@@ -0,0 +1,31 @@
+package net.lamgc.cgj.util;
+
+import java.util.HashMap;
+
+public class LockerMap<K> {
+
+    private final HashMap<K, Locker<K>> lockerHashMap = new HashMap<>();
+
+    /**
+     * 创建锁
+     * @param key Key
+     * @return 如果Key所属锁存在, 则返回对应锁, 否则返回新锁
+     */
+    public Locker<K> createLocker(K key, boolean autoDestroy) {
+        if(lockerHashMap.containsKey(key)) {
+            return lockerHashMap.get(key);
+        }
+        Locker<K> newLocker = new Locker<>(this, key, autoDestroy);
+        lockerHashMap.put(key, newLocker);
+        return newLocker;
+    }
+
+    /**
+     * 销毁锁
+     * @param locker 锁对象
+     */
+    public void destroyLocker(Locker<K> locker) {
+        lockerHashMap.remove(locker.getKey());
+    }
+
+}

src/main/java/net/lamgc/cgj/util/PixivUtils.java

@@ -0,0 +1,84 @@
+package net.lamgc.cgj.util;
+
+import com.google.common.base.Strings;
+import net.lamgc.cgj.pixiv.PixivSearchLinkBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Pixiv工具类
+ */
+public final class PixivUtils {
+
+    private final static Logger log = LoggerFactory.getLogger(PixivUtils.class);
+
+    private PixivUtils() {}
+
+    /**
+     * 快速构造一个PixivSearchLinkBuilder
+     * @param content 搜索内容
+     * @param type 搜索类型
+     * @param area 搜索范围
+     * @param includeKeywords 包含关键词
+     * @param excludeKeywords 排除关键词
+     * @param contentOption 内容级别选项
+     * @param pageIndex 搜索页数
+     * @return 返回PixivSearchLinkBuilder对象
+     * @see PixivSearchLinkBuilder
+     */
+    public static PixivSearchLinkBuilder buildSearchLinkBuilderFromString(
+            String content,
+            String type,
+            String area,
+            String includeKeywords,
+            String excludeKeywords,
+            String contentOption,
+            int pageIndex
+    ) {
+        PixivSearchLinkBuilder searchBuilder = new PixivSearchLinkBuilder(Strings.isNullOrEmpty(content) ? "" : content);
+        if (type != null) {
+            try {
+                searchBuilder.setSearchType(PixivSearchLinkBuilder.SearchType.valueOf(type.trim().toUpperCase()));
+            } catch (IllegalArgumentException e) {
+                log.warn("不支持的SearchType: {}", type);
+            }
+        }
+        if (area != null) {
+            try {
+                searchBuilder.setSearchArea(PixivSearchLinkBuilder.SearchArea.valueOf(area.trim().toUpperCase()));
+            } catch (IllegalArgumentException e) {
+                log.warn("不支持的SearchArea: {}", area);
+            }
+        }
+        if (contentOption != null) {
+            try {
+                searchBuilder.setSearchContentOption(
+                        PixivSearchLinkBuilder.SearchContentOption.valueOf(contentOption.trim().toUpperCase()));
+            } catch (IllegalArgumentException e) {
+                log.warn("不支持的SearchContentOption: {}", contentOption);
+            }
+        }
+
+        if (!Strings.isNullOrEmpty(includeKeywords)) {
+            for (String keyword : includeKeywords.split(";")) {
+                searchBuilder.removeExcludeKeyword(keyword.trim());
+                searchBuilder.addIncludeKeyword(keyword.trim());
+                log.trace("已添加关键字: {}", keyword);
+            }
+        }
+        if (!Strings.isNullOrEmpty(excludeKeywords)) {
+            for (String keyword : excludeKeywords.split(";")) {
+                searchBuilder.removeIncludeKeyword(keyword.trim());
+                searchBuilder.addExcludeKeyword(keyword.trim());
+                log.trace("已添加排除关键字: {}", keyword);
+            }
+        }
+
+        if(pageIndex > 0) {
+            searchBuilder.setPage(pageIndex);
+        }
+
+        return searchBuilder;
+    }
+
+}

src/main/java/net/lamgc/cgj/util/TimeLimitThreadPoolExecutor.java

@@ -2,6 +2,7 @@ package net.lamgc.cgj.util;
 
 import java.util.*;
 import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 
 /**
@@ -22,29 +23,53 @@ public class TimeLimitThreadPoolExecutor extends ThreadPoolExecutor {
      */
     private final AtomicLong timeoutCheckInterval = new AtomicLong(100);
 
-    private final Map<Thread, AtomicLong> workerThreadMap = new Hashtable<>();
+    private final Map<Thread, MonitorInfo> workerThreadMap = new Hashtable<>();
 
     private final Thread timeoutCheckThread = createTimeoutCheckThread();
 
-    public TimeLimitThreadPoolExecutor(long executeLimitTime, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
+    public TimeLimitThreadPoolExecutor(long executeLimitTime,
+                                       int corePoolSize,
+                                       int maximumPoolSize,
+                                       long keepAliveTime,
+                                       TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue) {
         super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
         setInitialTime(executeLimitTime);
         timeoutCheckThread.start();
     }
 
-    public TimeLimitThreadPoolExecutor(long executeLimitTime, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
+    public TimeLimitThreadPoolExecutor(long executeLimitTime,
+                                       int corePoolSize,
+                                       int maximumPoolSize,
+                                       long keepAliveTime,
+                                       TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue,
+                                       ThreadFactory threadFactory) {
         super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
         setInitialTime(executeLimitTime);
         timeoutCheckThread.start();
     }
 
-    public TimeLimitThreadPoolExecutor(long executeLimitTime, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
+    public TimeLimitThreadPoolExecutor(long executeLimitTime,
+                                       int corePoolSize,
+                                       int maximumPoolSize,
+                                       long keepAliveTime,
+                                       TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue,
+                                       RejectedExecutionHandler handler) {
         super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
         setInitialTime(executeLimitTime);
         timeoutCheckThread.start();
     }
 
-    public TimeLimitThreadPoolExecutor(long executeLimitTime, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
+    public TimeLimitThreadPoolExecutor(long executeLimitTime,
+                                       int corePoolSize,
+                                       int maximumPoolSize,
+                                       long keepAliveTime,
+                                       TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue,
+                                       ThreadFactory threadFactory,
+                                       RejectedExecutionHandler handler) {
         super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
         setInitialTime(executeLimitTime);
         timeoutCheckThread.start();
@@ -107,14 +132,17 @@ public class TimeLimitThreadPoolExecutor extends ThreadPoolExecutor {
             while (true) {
                 try {
                     long interval = this.timeoutCheckInterval.get();
+                    //noinspection BusyWait 用于等待超时
                     Thread.sleep(interval);
 
                     // 检查是否存在超时的任务
-                    workerThreadMap.forEach((thread, time) -> {
-                        long currentTime = time.getAndAdd(interval);
-                        if(currentTime > executeTimeLimit.get()) {
-                            if(!thread.isInterrupted()) {
+                    final long executeTimeLimit = this.executeTimeLimit.get();
+                    workerThreadMap.forEach((thread, info) -> {
+                        long currentTime = info.getTimeRemaining().getAndAdd(interval);
+                        if(currentTime > executeTimeLimit) {
+                            if(!info.getNotifyInterrupted().get() && !thread.isInterrupted()) {
                                 thread.interrupt();
+                                info.getNotifyInterrupted().set(true);
                             }
                         }
                     });
@@ -130,7 +158,7 @@ public class TimeLimitThreadPoolExecutor extends ThreadPoolExecutor {
 
     @Override
     protected void beforeExecute(Thread t, Runnable r) {
-        workerThreadMap.put(t, new AtomicLong());
+        workerThreadMap.put(t, new MonitorInfo());
         super.beforeExecute(t, r);
     }
 
@@ -145,4 +173,20 @@ public class TimeLimitThreadPoolExecutor extends ThreadPoolExecutor {
         this.timeoutCheckThread.interrupt();
         super.terminated();
     }
+
+    private static class MonitorInfo {
+
+        private final AtomicLong timeRemaining = new AtomicLong();
+
+        private final AtomicBoolean notifyInterrupted = new AtomicBoolean(false);
+
+        public AtomicBoolean getNotifyInterrupted() {
+            return notifyInterrupted;
+        }
+
+        public AtomicLong getTimeRemaining() {
+            return timeRemaining;
+        }
+    }
+
 }

src/main/resources/application.properties

@@ -1,2 +0,0 @@
-server.port=8081
-server.tomcat.max-threads=1

src/main/resources/application.yml

@@ -0,0 +1,12 @@
+server:
+  port: 8081
+
+spring:
+  cq:
+    plugin-list:
+      - net.lamgc.cgj.bot.framework.coolq.CQPluginMain
+    event:
+      corePoolSize: 8
+      maxPoolSize: 16
+      keepAliveTime: 25000
+      workQueueSize: 1024

src/main/resources/log4j2.xml

@@ -34,6 +34,9 @@
         </Console>
 
         <RollingFile name="rollingFile" fileName="${logsDir}/latest.log" filePattern="${logsDir}/running.%-d{yyyy-MM-dd_HH-mm-ss}.log.gz">
+            <Filters>
+                <ThresholdFilter level="DEBUG" onMatch="ACCEPT" onMismatch="DENY"/>
+            </Filters>
             <PatternLayout charset="${charset}">
                 <MarkerPatternSelector defaultPattern="${standard_pattern}">
                     <PatternMatch key="mirai" pattern="${mirai_pattern}" />
@@ -46,7 +49,8 @@
     </Appenders>
 
     <Loggers>
-        <Root level="TRACE">
+        <Logger level="INFO" name="org.apache.http"/>
+        <Root level="DEBUG">
             <AppenderRef ref="STANDARD_STDOUT"/>
             <AppenderRef ref="STANDARD_STDERR"/>
             <AppenderRef ref="rollingFile"/>

src/test/java/net/lamgc/cgj/bot/util/GroupMuteManagerTest.java

@@ -0,0 +1,30 @@
+package net.lamgc.cgj.bot.util;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class GroupMuteManagerTest {
+
+    @Test
+    public void muteStateTest() {
+        GroupMuteManager manager = new GroupMuteManager();
+        Assert.assertNull(manager.isMute(1, true)); // 未设置的群组返回null
+        Assert.assertFalse(manager.isMute(1, false)); // 未设置就返回false
+        manager.setMuteState(1, true); // mute == true
+        Assert.assertNotNull(manager.isMute(1, true)); // 第一次设置后不为null
+        Assert.assertTrue(manager.isMute(1, false)); // 确保条件正常
+        manager.setMuteState(2, true); // 不能出现不同群号的冲突
+        manager.setMuteState(1, false);
+        Assert.assertTrue(manager.isMute(2, false));
+        Assert.assertNotNull(manager.isMute(1, true)); // 变更为false后依然不能返回null
+        Assert.assertFalse(manager.isMute(1, false));
+    }
+
+    @Test
+    public void invalidGroupIdTest() {
+        GroupMuteManager manager = new GroupMuteManager();
+        manager.setMuteState(-1, true); // 设置应该是无效的
+        Assert.assertFalse(manager.isMute(-1, false)); // 由于设置无效, 返回false即可
+    }
+
+}

src/test/java/net/lamgc/cgj/pixiv/PixivDownloadTest.java

@@ -133,7 +133,7 @@ public class PixivDownloadTest {
         zos.setLevel(9);
         log.info("正在调用方法...");
         try {
-            pixivDownload.getRankingAsInputStream(null, PixivURL.RankingMode.MODE_DAILY_R18, queryDate, 500, PixivDownload.PageQuality.ORIGINAL, (rank, link, rankInfo, inputStream) -> {
+            pixivDownload.getRankingAsInputStream(null, RankingMode.MODE_DAILY_R18, queryDate, 500, PixivDownload.PageQuality.ORIGINAL, (rank, link, rankInfo, inputStream) -> {
                 try {
                     ZipEntry entry = new ZipEntry("Rank" + rank + "-" + link.substring(link.lastIndexOf("/") + 1));
                     entry.setComment(rankInfo.toString());

src/test/java/net/lamgc/cgj/pixiv/PixivSearchBuilderTest.java

@@ -1,26 +0,0 @@
-package net.lamgc.cgj.pixiv;
-
-import org.junit.Assert;
-import org.junit.Test;
-
-public class PixivSearchBuilderTest {
-
-    @Test
-    public void buildTest() {
-        PixivSearchBuilder builder = new PixivSearchBuilder("hololive");
-        //builder.addExcludeKeyword("fubuki").addExcludeKeyword("minato");
-        builder.addIncludeKeyword("35").addIncludeKeyword("okayu").addIncludeKeyword("百鬼あやめ");
-        System.out.println(builder.buildURL());
-    }
-
-    @Test
-    public void equalsTest() {
-        Assert.assertEquals(new PixivSearchBuilder("风景"), new PixivSearchBuilder("风景"));
-    }
-
-    @Test
-    public void hashCodeTest() {
-        Assert.assertEquals(new PixivSearchBuilder("风景").hashCode(), new PixivSearchBuilder("风景").hashCode());
-    }
-
-}

src/test/java/net/lamgc/cgj/pixiv/PixivSearchLinkBuilderTest.java

@@ -0,0 +1,25 @@
+package net.lamgc.cgj.pixiv;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class PixivSearchLinkBuilderTest {
+
+    @Test
+    public void buildTest() {
+        PixivSearchLinkBuilder builder = new PixivSearchLinkBuilder("hololive");
+        builder.addIncludeKeyword("35").addIncludeKeyword("okayu").addIncludeKeyword("百鬼あやめ");
+        System.out.println(builder.buildURL());
+    }
+
+    @Test
+    public void equalsTest() {
+        Assert.assertEquals(new PixivSearchLinkBuilder("风景"), new PixivSearchLinkBuilder("风景"));
+    }
+
+    @Test
+    public void hashCodeTest() {
+        Assert.assertEquals(new PixivSearchLinkBuilder("风景").hashCode(), new PixivSearchLinkBuilder("风景").hashCode());
+    }
+
+}

src/test/java/net/lamgc/cgj/util/LockerMapTest.java

@@ -0,0 +1,18 @@
+package net.lamgc.cgj.util;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class LockerMapTest {
+
+    @Test
+    public void createAndFinalizeTest() {
+        LockerMap<String> map = new LockerMap<>();
+        Locker<String> locker = map.createLocker("Test", true);
+        Assert.assertEquals(locker, map.createLocker("Test", true));
+        locker.lock();
+        locker.unlock();
+        System.gc();
+    }
+
+}

src/test/java/net/lamgc/cgj/util/TimeLimitThreadPoolExecutorTest.java

@@ -2,26 +2,37 @@ package net.lamgc.cgj.util;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.TimeUnit;
 
 public class TimeLimitThreadPoolExecutorTest {
 
+    private final static Logger log = LoggerFactory.getLogger(TimeLimitThreadPoolExecutorTest.class);
+
     @Test
     public void timeoutTest() throws InterruptedException {
         TimeLimitThreadPoolExecutor executor = new TimeLimitThreadPoolExecutor(1000, 1, 1, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(50));
-        System.out.println(executor.isTerminated());
-        System.out.println(executor.isShutdown());
+        log.info("ThreadPoolExecutor.isTerminated: {}", executor.isTerminated());
+        log.info("ThreadPoolExecutor.isShutdown: {}", executor.isShutdown());
 
         executor.setTimeoutCheckInterval(150);
-        System.out.println("当前设定: ETL: " + executor.getExecuteTimeLimit() + "ms, TCI: " + executor.getTimeoutCheckInterval() + "ms");
+        log.info("当前设定: ExecuteTimeLimit: {}ms, CheckInterval: {}ms", executor.getExecuteTimeLimit(),
+                executor.getTimeoutCheckInterval());
         executor.execute(() -> {
             try {
-                Thread.sleep(5 * 1000);
+                Thread.sleep(5000);
             } catch (InterruptedException e) {
                 System.out.println("线程 " + Thread.currentThread().getName() + " 被中断");
             }
+
+            try {
+                Thread.sleep(1000);
+            } catch (InterruptedException e) {
+                Assert.fail("Multiple interrupts occurred");
+            }
         });
         executor.shutdown();
         Assert.assertTrue(executor.awaitTermination(5 * 1000, TimeUnit.MILLISECONDS));