Merge branch 'master' of github.com:LamGC/ContentGrabbingJi into add-framework-interface

[Change] Framework 适配FrameworkResources的更改, 将`getName`调整为`getIdentify`, 增加`getFrameworkName`方法用于获取框架名(可能会改为注解方式以防止更改);
[Change] FrameworkManager 适配Framework的更改, 增加`checkFramework`方法以对FrameworkName进行检查;
[Change] FrameworkManager, FrameworkResources 将FrameworkResources从FrameworkManager分离成单独的类;
[Change] ConsoleMain, MiraiMain, SpringCQApplication 适配相关更改;

README.md

@@ -1,19 +1,20 @@
 # ContentGrabbingJi - 色图姬 #
-一个以高性能、高效率为目标，多平台/框架支持、持续维护的 Pixiv 聊天机器人；  
+一个以高性能、高效率为目标，多平台/框架支持、持续维护的Pixiv聊天机器人  
+
 色图姬存在的目的最初是作为**爬虫 + 机器人**的形式开发，在开发过程中逐渐以多聊天平台，高效率为目标进行。
 
 ## 安装 ##
-### 通过 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`，并添加如下内容：
+### 通过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`，然后设置如下内容：
+6. 在数据目录创建新文件夹`setting`, 并创建一个全局配置文件`global.properties`, 然后设置如下内容:
     ```properties
     # 该配置为全局配置文件, 当群组没有特定配置时, 将使用全局配置.
     # 管理员QQ (必填)
@@ -29,14 +30,12 @@
     # 搜索结果长度. 该选项请适当调整, 设置过长可能导致超出聊天平台的最长消息长度, 导致发送失败!
     search.itemCountLimit=8
     ```
-    （管理员 QQ 的作用/用法将在下面详细说明。）
-7. 配置完成后，准备一台 Redis 服务端，用于缓存数据。
-8. Redis 服务器准备好后，使用命令启动色图姬：  
-    `java -jar <CGJ.jar> botMode -botDataDir <数据目录> -redisAddress <Redis服务器地址> [-proxy 代理服务器地址]`
+7. 配置完成后, 准备一台Redis服务端, 用于缓存数据.
+8. Redis服务器准备好后, 使用命令启动色图姬：`java -jar <CGJ.jar> botMode -botDataDir <数据目录> -redisAddress <Redis服务器地址> [-proxy 代理服务器地址]`
 9. 完成！好好享受！
 
-### 通过 Docker 部署 ###
-使用 Docker 将可以更好的管理色图姬所使用的资源，和管理色图姬的运行。
+### 通过Docker部署 ###
+使用Docker将可以更好的管理色图姬所使用的资源，和管理色图姬的运行。
 (正在完善中...)
 
 ## 使用 ##
@@ -52,7 +51,7 @@
 如果色图姬无法识别你的命令，那么它会发送一次帮助信息给你。
 
 ### 管理员用户 ###
-你应该注意到了，在部署过程中，你需要设置一个管理员 QQ 的配置，色图姬支持通过命令来管理色图姬的运行。  
+你应该注意到了，在部署过程中，你需要设置一个管理员QQ的配置，色图姬支持通过命令来管理色图姬的运行。  
 目前支持的管理员命令：
 ```bash
 # 清除缓存(慎用)
@@ -107,13 +106,13 @@
 ```
 
 ## 贡献 ##
-**向色图姬贡献不一定需要编程知识，向色图姬项目提出意见，反馈问题同样会为色图姬项目提供很大的帮助！**  
-如果你在使用色图姬的过程中，遇到了 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=)反馈你的想法！
+向色图姬贡献不一定需要编程知识，向色图姬项目提出意见，反馈问题同样会为色图姬项目提供很大的帮助！  
+如果你在使用色图姬的过程中，遇到了Bug，可以通过色图姬项目的**Issues**使用[Bug反馈模板](https://github.com/LamGC/ContentGrabbingJi/issues/new?assignees=&labels=bug&template=Bug_Report.md&title=)向色图姬提供Bug信息。  
+如果是为色图姬提供一些新功能想法，或者对色图姬有什么意见，则可以直接通过Issues发起讨论。
 
-如果你会 Java 开发，又想为色图姬提供一些新功能，可以通过 Fork 仓库的方法，实现后发起 PR，合并到色图姬项目中！  
+如果你会Java开发，又想为色图姬提供一些新功能，可以通过Fork仓库的方法，实现后发起PR，合并到色图姬项目中！  
 向色图姬贡献代码，需要遵循一些贡献事项，如果你的代码不符合这些事项，PR有可能会被关闭！  
-> 注意：色图姬的初衷并没有任何恶意的意图，如果尝试向色图姬提供恶意功能或代码，PR 将会被拒绝、关闭。
+> 注意：色图姬的初衷并没有任何恶意的意图，如果尝试向色图姬提供恶意功能或代码，PR将会被拒绝、关闭。
 
 ## LICENSE ##
 本项目基于 `GNU Affero General Public License 3.0` 开源许可协议开源，  

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

@@ -41,15 +41,16 @@ 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,17 +16,14 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
 ### 参数 ###
 #### Url参数 ####
 - `Type`: 内容类型
-    - `artworks` - 所有类型
-    - `top` - 推荐
-    - `illustrations` - 插画
-    - `manga` - 漫画
-    - `novels` - 小说
-    - `tags` - 查询标签信息
+    - illustrations(插画)
+    - top(推荐)
+    - manga(漫画)
+    - novels(小说)
 - `Content`: 搜索内容
 
 #### GET参数 ####
 ##### 必填 #####
-> 注意：除 `tags` 类型外，其他内容类型都需要以下参数。
 - `word`: 与搜索内容一致 (经测试似乎可以省略)
 - `s_mode`: 匹配模式
     - `s_tag`: 标签，部分一致
@@ -85,8 +82,7 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
                         "風景",
                         "空",
                         "草",
-                        "雲"
-                    ],
+                        "雲"],
                     "userId":"31507675",
                     "userName":"昏omeme",
                     "width":1600,
@@ -159,8 +155,7 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
                         "女の子",
                         "カラス",
                         "风景",
-                        "線路"
-                    ],
+                        "線路"],
                     "userId":"1069005",
                     "userName":"へちま",
                     "width":2000,
@@ -315,10 +310,24 @@ 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[]`) 搜索结果(仅当前页数)
@@ -353,45 +362,4 @@ 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`       |×|×|×|√
-
-符号解释:  
-- `√`: 该属性一定存在
-- `?`: 该属性可能存在
-- `×`: 该属性不存在
+        

pom.xml

@@ -100,7 +100,7 @@
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.13.1</version>
+            <version>4.12</version>
             <scope>test</scope>
         </dependency>
         <dependency>

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

@@ -7,6 +7,7 @@ import com.google.gson.JsonElement;
 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.FrameworkManager;
 import net.lamgc.cgj.bot.framework.cli.ConsoleMain;
 import net.lamgc.cgj.bot.framework.coolq.SpringCQApplication;
 import net.lamgc.cgj.bot.framework.mirai.MiraiMain;
@@ -88,19 +89,29 @@ public class Main {
 
     @Command
     public static void botMode(@Argument(name = "args", force = false) String argsStr) {
-        MiraiMain main = new MiraiMain();
-        main.init();
-        main.close();
+        try {
+            FrameworkManager.registerFramework(new MiraiMain()).join();
+        } catch (InterruptedException ignored) {
+
+        }
     }
 
     @Command
-    public static void consoleMode() throws IOException {
-        ConsoleMain.start();
+    public static void consoleMode() {
+        try {
+            FrameworkManager.registerFramework(new ConsoleMain()).join();
+        } catch (InterruptedException ignored) {
+
+        }
     }
 
     @Command
     public static void pluginMode(@Argument(name = "args", force = false) String argsStr) {
-        new SpringCQApplication().start(argsStr);
+        try {
+            FrameworkManager.registerFramework(new SpringCQApplication()).join();
+        } catch (InterruptedException ignored) {
+
+        }
     }
 
     @Command

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

@@ -13,10 +13,8 @@ import net.lamgc.cgj.bot.sort.PreLoadDataAttribute;
 import net.lamgc.cgj.bot.sort.PreLoadDataAttributeComparator;
 import net.lamgc.cgj.pixiv.PixivDownload;
 import net.lamgc.cgj.pixiv.PixivDownload.PageQuality;
-import net.lamgc.cgj.pixiv.PixivSearchAttribute;
 import net.lamgc.cgj.pixiv.PixivSearchLinkBuilder;
 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;
@@ -42,8 +40,6 @@ 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("正在初始化...");
 
@@ -147,13 +143,8 @@ public class BotCommandProcess {
             @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 = "ALL") String contentType,
-            @Argument(force = false, name = "p", defaultValue = "1") int pageIndex
+            @Argument(force = false, name = "type", defaultValue = "ALL") String contentType
     ) throws InterruptedException {
-        if(pageIndex <= 0) {
-            return "色图姬找不到指定页数的排行榜!";
-        }
-
         Date queryDate = queryTime;
         if (queryDate == null) {
             queryDate = new Date();
@@ -221,10 +212,8 @@ public class BotCommandProcess {
                 log.warn("配置项 {} 的参数值格式有误!", imageLimitPropertyKey);
             }
 
-            int startsIndex = itemLimit * pageIndex - (itemLimit - 1);
             List<JsonObject> rankingInfoList = CacheStoreCentral.getCentral()
-                    .getRankingInfoByCache(type, mode, queryDate,
-                            Math.max(1, startsIndex), Math.max(0, itemLimit), false);
+                    .getRankingInfoByCache(type, mode, queryDate, 1, Math.max(0, itemLimit), false);
             if(rankingInfoList.isEmpty()) {
                 return "无法查询排行榜，可能排行榜尚未更新。";
             }
@@ -325,9 +314,12 @@ public class BotCommandProcess {
             @Argument(name = "option", force = false) String contentOption,
             @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("正在执行搜索...");
+        JsonObject resultBody = CacheStoreCentral.getCentral()
+                .getSearchBody(content, type, area, includeKeywords, excludeKeywords, contentOption, pagesIndex);
+
+        StringBuilder result = new StringBuilder("内容 " + content + " 的搜索结果：\n");
+        log.debug("正在处理信息...");
         int limit = 8;
         try {
             limit = Integer.parseInt(SettingProperties.
@@ -335,112 +327,95 @@ public class BotCommandProcess {
         } catch (Exception e) {
             log.warn("参数转换异常!将使用默认值(" + limit + ")", e);
         }
-
         int totalCount = 0;
-        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);
+        for (PixivSearchLinkBuilder.SearchArea searchArea : PixivSearchLinkBuilder.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 PreLoadDataAttributeComparator(PreLoadDataAttribute.BOOKMARK));
 
-            // 构造消息内容
-            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++;
+            log.debug("已找到与 {} 相关插图信息({})：", 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;
+                try {
+                    imageMsg = CacheStoreCentral.getCentral()
+                            .getImageById(fromGroup, illustId, PixivDownload.PageQuality.REGULAR, 1);
+                } catch (NoSuchElementException e) {
+                    if(e.getMessage().startsWith("No work found: ")) {
+                        log.warn("作品 {} 不存在, 跳过该作品...", illustId);
+                        continue;
+                    }
+                    throw e;
+                }
+                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.getCentral()
+                        .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(PreLoadDataAttribute.LIKE.attrName).getAsInt())
+                        .append("\n\t收藏数：")
+                        .append(illustPreLoadData.get(PreLoadDataAttribute.BOOKMARK.attrName).getAsInt())
+                        .append("\n\t围观数：")
+                        .append(illustPreLoadData.get(PreLoadDataAttribute.VIEW.attrName).getAsInt())
+                        .append("\n\t评论数：")
+                        .append(illustPreLoadData.get(PreLoadDataAttribute.COMMENT.attrName).getAsInt())
+                        .append("\n").append(imageMsg).append("\n");
+                count++;
+                totalCount++;
+            }
+            if (count > limit) {
+                break;
+            }
         }
-
         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

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

@@ -402,28 +402,84 @@ public final class CacheStoreCentral {
             result = rankingCache.getCache(requestSign, start - 1, range);
             log.trace("RequestSign [{}] 缓存命中.", requestSign);
         }
-        return result;
+        return PixivDownload.getRanking(result, start - 1, range);
     }
 
     /**
      * 获取搜索结果
-     * @param searchBuilder 需要执行搜索的搜索链接构造器
+     * @param content 搜索内容
+     * @param type 类型
+     * @param area 范围
+     * @param includeKeywords 包含关键词
+     * @param excludeKeywords 排除关键词
+     * @param contentOption 内容类型
      * @return 返回完整搜索结果
      * @throws IOException 当请求发生异常, 或接口返回异常信息时抛出.
      */
-    public JsonObject getSearchBody(PixivSearchLinkBuilder searchBuilder) throws IOException {
+    public JsonObject getSearchBody(
+            String content,
+            String type,
+            String area,
+            String includeKeywords,
+            String excludeKeywords,
+            String contentOption,
+            int pageIndex
+    ) throws IOException {
+        PixivSearchLinkBuilder searchBuilder = new PixivSearchLinkBuilder(Strings.isNullOrEmpty(content) ? "" : content);
+        if (type != null) {
+            try {
+                searchBuilder.setSearchType(PixivSearchLinkBuilder.SearchType.valueOf(type.toUpperCase()));
+            } catch (IllegalArgumentException e) {
+                log.warn("不支持的SearchType: {}", type);
+            }
+        }
+        if (area != null) {
+            try {
+                searchBuilder.setSearchArea(PixivSearchLinkBuilder.SearchArea.valueOf(area));
+            } 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);
+        }
+
         log.debug("正在搜索作品, 条件: {}", searchBuilder.getSearchCondition());
-        String requestUrl = searchBuilder.buildURL();
-        String searchIdentify = requestUrl.substring(requestUrl.lastIndexOf("/", requestUrl.lastIndexOf("/") - 1) + 1);
+
         Locker<String> locker
-                = buildSyncKey(searchIdentify);
+                = buildSyncKey(searchBuilder.buildURL());
+        String requestUrl = locker.getKey();
         log.debug("RequestUrl: {}", requestUrl);
         JsonObject resultBody = null;
-        if(!searchBodyCache.exists(searchIdentify)) {
+        if(!searchBodyCache.exists(requestUrl)) {
             try {
                 locker.lock();
                 synchronized (locker) {
-                    if (!searchBodyCache.exists(searchIdentify)) {
+                    if (!searchBodyCache.exists(requestUrl)) {
                         log.trace("searchBody缓存失效, 正在更新...");
                         JsonObject jsonObject;
                         HttpGet httpGetRequest = BotGlobal.getGlobal().getPixivDownload().
@@ -448,8 +504,8 @@ public final class CacheStoreCentral {
                         } catch (Exception e) {
                             log.warn("全局配置项 \"{}\" 值非法, 已使用默认值: {}", propValue, expire);
                         }
-                        resultBody = jsonObject;
-                        searchBodyCache.update(searchIdentify, jsonObject, expire);
+                        resultBody = jsonObject.getAsJsonObject().getAsJsonObject("body");
+                        searchBodyCache.update(requestUrl, jsonObject, expire);
                         log.trace("searchBody缓存已更新(有效时间: {})", expire);
                     } else {
                         log.trace("搜索缓存命中.");
@@ -463,9 +519,9 @@ public final class CacheStoreCentral {
         }
 
         if(Objects.isNull(resultBody)) {
-            resultBody = searchBodyCache.getCache(searchIdentify).getAsJsonObject();
+            resultBody = searchBodyCache.getCache(requestUrl).getAsJsonObject().getAsJsonObject("body");
         }
-        return resultBody.getAsJsonObject("body");
+        return resultBody;
     }
 
     protected ImageChecksum getImageChecksum(int illustId, int pageIndex) {

src/main/java/net/lamgc/cgj/bot/framework/Framework.java

@@ -0,0 +1,41 @@
+package net.lamgc.cgj.bot.framework;
+
+public interface Framework {
+
+    /**
+     * 框架初始化方法
+     * @param resources 框架所分配到的资源.
+     * @throws Exception 当框架抛出异常时, 将不会继续运行框架.
+     * @see FrameworkResources
+     */
+    void init(FrameworkResources resources) throws Exception;
+
+    /**
+     * 框架运行方法
+     * @throws Exception 当框架抛出异常时, 将会终止框架的所有活动.
+     */
+    void run() throws Exception;
+
+    /**
+     * 关闭框架
+     * @throws Exception 即使该方法抛出异常, {@link FrameworkManager}依然会尝试向框架所属的线程发起中断, 以试图清除框架资源.
+     */
+    void close() throws Exception;
+
+    /**
+     * 获取框架标识名.
+     * <p>可根据需要自行调整框架标识名.</p>
+     * @return 返回标识名.
+     */
+    default String getIdentify() {
+        return this.getClass().getSimpleName() + "@" + Integer.toHexString(this.hashCode());
+    }
+
+    /**
+     * 获取框架名称.
+     * <p>框架名称不可更改.</p>
+     * @return 返回框架名称.
+     */
+    String getFrameworkName();
+
+}

src/main/java/net/lamgc/cgj/bot/framework/FrameworkManager.java

@@ -0,0 +1,75 @@
+package net.lamgc.cgj.bot.framework;
+
+import org.slf4j.Logger;
+
+import java.util.*;
+import java.util.regex.Pattern;
+
+public final class FrameworkManager {
+
+    private FrameworkManager() {}
+
+    private final static Map<Framework, FrameworkResources> resourcesMap = new HashMap<>();
+
+    private final static ThreadGroup frameworkRootGroup = new ThreadGroup("FrameworkRootGroup");
+
+    static {
+        Runtime.getRuntime()
+                .addShutdownHook(new Thread(FrameworkManager::shutdownAllFramework, "FrameworkManager-Shutdown"));
+    }
+
+    public static Thread registerFramework(Framework framework) {
+        checkFramework(framework);
+        FrameworkResources resources = new FrameworkResources(framework);
+        resourcesMap.put(framework, resources);
+        Thread frameworkThread = new Thread(resources.getFrameworkThreadGroup(),
+                () -> FrameworkManager.runFramework(framework), "FrameworkThread-" + framework.getIdentify());
+
+        frameworkThread.start();
+        return frameworkThread;
+    }
+
+    private static final Pattern FRAMEWORK_NAME_CHECK_PATTERN = Pattern.compile("^[A-Za-z0-9_\\-$]+$");
+    private static void checkFramework(Framework framework) {
+        if(!FRAMEWORK_NAME_CHECK_PATTERN.matcher(framework.getFrameworkName()).matches()) {
+            throw new IllegalStateException("Invalid Framework Name: " + framework.getFrameworkName());
+        }
+    }
+
+    public static Set<Framework> frameworkSet() {
+        return new HashSet<>(resourcesMap.keySet());
+    }
+
+    public static void shutdownAllFramework() {
+        for (Framework framework : resourcesMap.keySet()) {
+            FrameworkResources frameworkResources = resourcesMap.get(framework);
+            Logger frameworkLogger = frameworkResources.getLogger();
+            try {
+                frameworkLogger.info("正在关闭框架...");
+                framework.close();
+                frameworkLogger.info("框架已关闭.");
+                frameworkResources.getFrameworkThreadGroup().interrupt();
+                resourcesMap.remove(framework);
+            } catch(Throwable e) {
+                frameworkLogger.error("退出框架时发生异常", e);
+            }
+        }
+    }
+
+    static ThreadGroup getFrameworkRootGroup() {
+        return frameworkRootGroup;
+    }
+
+    private static void runFramework(Framework framework) {
+        FrameworkResources frameworkResources = resourcesMap.get(framework);
+        try {
+            framework.init(frameworkResources);
+            framework.run();
+        } catch(Throwable e) {
+            frameworkResources.getLogger().error("框架未捕获异常, 导致异常退出.", e);
+        } finally {
+            frameworkResources.getFrameworkThreadGroup().interrupt();
+        }
+    }
+
+}

src/main/java/net/lamgc/cgj/bot/framework/FrameworkResources.java

@@ -0,0 +1,35 @@
+package net.lamgc.cgj.bot.framework;
+
+import net.lamgc.cgj.bot.boot.BotGlobal;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+
+public class FrameworkResources {
+
+    private final static File frameworkDataStoreRootDir = new File(BotGlobal.getGlobal().getDataStoreDir(),
+            "frameworks/");
+
+    private final ThreadGroup frameworkThreadGroup;
+
+    private final Logger logger;
+
+    private final File frameworkDataStoreDir;
+
+    public FrameworkResources(Framework framework) {
+        frameworkThreadGroup = new ThreadGroup(FrameworkManager.getFrameworkRootGroup(),
+                "Framework-" + framework.getIdentify());
+        frameworkDataStoreDir = new File(frameworkDataStoreRootDir, framework.getClass().getSimpleName());
+        logger = LoggerFactory.getLogger("Framework-" + framework.getIdentify());
+    }
+
+    ThreadGroup getFrameworkThreadGroup() {
+        return frameworkThreadGroup;
+    }
+
+    public Logger getLogger() {
+        return logger;
+    }
+
+}

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

@@ -2,6 +2,9 @@ package net.lamgc.cgj.bot.framework.cli;
 
 import net.lamgc.cgj.bot.boot.ApplicationBoot;
 import net.lamgc.cgj.bot.event.BotEventHandler;
+import net.lamgc.cgj.bot.framework.Framework;
+import net.lamgc.cgj.bot.framework.FrameworkManager;
+import net.lamgc.cgj.bot.framework.FrameworkResources;
 import net.lamgc.cgj.bot.framework.cli.message.ConsoleMessageEvent;
 import net.lamgc.cgj.bot.framework.cli.message.ConsoleMessageSenderFactory;
 import net.lamgc.cgj.bot.message.MessageSenderBuilder;
@@ -12,13 +15,18 @@ import org.jline.terminal.TerminalBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
+import java.util.concurrent.atomic.AtomicBoolean;
 
-public class ConsoleMain {
+public class ConsoleMain implements Framework {
 
     private final static Logger log = LoggerFactory.getLogger(ConsoleMain.class);
+    private final AtomicBoolean quitState = new AtomicBoolean();
 
-    public static void start() throws IOException {
+    @Override
+    public void init(FrameworkResources resources) { }
+
+    @Override
+    public void run() throws Exception {
         MessageSenderBuilder.setCurrentMessageSenderFactory(new ConsoleMessageSenderFactory());
         ApplicationBoot.initialBot();
         LineReader lineReader = LineReaderBuilder.builder()
@@ -45,7 +53,22 @@ public class ConsoleMain {
             } catch (InterruptedException e) {
                 log.error("执行时发生中断", e);
             }
-        } while(true);
+        } while(!quitState.get());
     }
 
+    @Override
+    public void close() {
+        quitState.set(true);
+        Thread.currentThread().getThreadGroup().interrupt();
+    }
+
+    @Override
+    public String getIdentify() {
+        return this.toString();
+    }
+
+    @Override
+    public String getFrameworkName() {
+        return "console";
+    }
 }

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

@@ -1,9 +1,9 @@
 package net.lamgc.cgj.bot.framework.coolq;
 
-import com.google.common.base.Strings;
 import net.lamgc.cgj.bot.boot.BotGlobal;
+import net.lamgc.cgj.bot.framework.Framework;
+import net.lamgc.cgj.bot.framework.FrameworkResources;
 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;
@@ -12,28 +12,21 @@ 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 {
+public class SpringCQApplication implements Framework {
 
-    private final static Logger log = LoggerFactory.getLogger(SpringCQApplication.class);
+    private Logger log;
 
     private final Object quitLock = new Object();
 
-    public void start(String argsStr) {
+    @Override
+    public void init(FrameworkResources resources) {
+        this.log = resources.getLogger();
+    }
+
+    public void run() {
         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);
+        ConfigurableApplicationContext context = SpringApplication.run(SpringCQApplication.class);
         registerShutdownHook(context);
         try {
             synchronized (quitLock) {
@@ -42,22 +35,30 @@ public class SpringCQApplication {
         } catch (InterruptedException e) {
             log.warn("发生中断, 退出SpringCQ...", e);
         }
+
+        context.stop();
+        context.close();
     }
 
     private void registerShutdownHook(ConfigurableApplicationContext context) {
         context.addApplicationListener((ApplicationListener<ApplicationFailedEvent>)
-                event -> notifyThread());
+                event -> close());
         context.addApplicationListener((ApplicationListener<ContextClosedEvent>)
-                event -> notifyThread());
+                event -> close());
         context.addApplicationListener((ApplicationListener<ContextStoppedEvent>)
-                event -> notifyThread());
-        Runtime.getRuntime().addShutdownHook(new Thread(this::notifyThread));
+                event -> close());
+        Runtime.getRuntime().addShutdownHook(new Thread(this::close));
     }
 
-    private void notifyThread() {
+    public void close() {
         synchronized (quitLock) {
             quitLock.notify();
         }
     }
 
+    @Override
+    public String getFrameworkName() {
+        return "SpringCoolQ";
+    }
+
 }

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

@@ -3,6 +3,8 @@ package net.lamgc.cgj.bot.framework.mirai;
 import net.lamgc.cgj.bot.boot.ApplicationBoot;
 import net.lamgc.cgj.bot.boot.BotGlobal;
 import net.lamgc.cgj.bot.event.BotEventHandler;
+import net.lamgc.cgj.bot.framework.Framework;
+import net.lamgc.cgj.bot.framework.FrameworkResources;
 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;
@@ -25,7 +27,7 @@ import java.io.*;
 import java.util.Base64;
 import java.util.Properties;
 
-public class MiraiMain implements Closeable {
+public class MiraiMain implements Framework {
 
     private final Logger log = LoggerFactory.getLogger(MiraiMain.class);
 
@@ -35,7 +37,8 @@ public class MiraiMain implements Closeable {
 
     private final GroupMuteManager muteManager = new GroupMuteManager();
 
-    public void init() {
+    @Override
+    public void init(FrameworkResources resources) {
         Runtime.getRuntime().addShutdownHook(new Thread(this::close));
         try {
             Class.forName(BotEventHandler.class.getName());
@@ -72,6 +75,7 @@ public class MiraiMain implements Closeable {
 
         bot = BotFactoryJvm.newBot(Long.parseLong(botProperties.getProperty("bot.qq", "0")),
                 Base64.getDecoder().decode(botProperties.getProperty("bot.password", "")), configuration);
+        // TODO: 看看能不能单独订阅某个Bot?
         Events.subscribeAlways(GroupMessageEvent.class, this::executeMessageEvent);
         Events.subscribeAlways(FriendMessageEvent.class, this::executeMessageEvent);
         Events.subscribeAlways(TempMessageEvent.class, this::executeMessageEvent);
@@ -85,6 +89,12 @@ public class MiraiMain implements Closeable {
         bot.join();
     }
 
+    @Override
+    public void run() {
+        bot.login();
+        bot.join();
+    }
+
     /**
      * 处理消息事件
      * @param message 消息事件对象
@@ -92,14 +102,11 @@ public class MiraiMain implements Closeable {
     private void executeMessageEvent(MessageEvent message) {
         log.debug("Mirai Message: {}", message);
         if(message instanceof GroupMessageEvent) {
-            GroupMessageEvent groupMessageEvent = (GroupMessageEvent) message;
-            Boolean muteState = muteManager.isMute(groupMessageEvent.getGroup().getId(), true);
+            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;
-                }
+                muteManager.setMuteState(GroupMessageEvent.getGroup().getId(),
+                        ((GroupMessageEvent) message).getGroup().getBotMuteRemaining() != 0);
             } else if(muteState) {
                 return;
             }
@@ -110,6 +117,7 @@ public class MiraiMain implements Closeable {
     /**
      * 关闭机器人
      */
+    @Override
     public synchronized void close() {
         if(bot == null) {
             return;
@@ -120,4 +128,9 @@ public class MiraiMain implements Closeable {
         log.warn("机器人已关闭.");
     }
 
+    @Override
+    public String getFrameworkName() {
+        return "MiraiQQ";
+    }
+
 }

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

@@ -4,6 +4,7 @@ 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;
@@ -31,6 +32,7 @@ import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiConsumer;
 
+@SuppressWarnings("ALL")
 public class PixivDownload {
 
     private final static Logger log = LoggerFactory.getLogger(PixivDownload.class);
@@ -247,6 +249,43 @@ public class PixivDownload {
         });
     }
 
+    /**
+     * 从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.trace("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>
@@ -382,7 +421,6 @@ public class PixivDownload {
     /**
      * 插图质量
      */
-    @SuppressWarnings("unused")
     public enum PageQuality{
         /**
          * 原图画质

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

@@ -1,22 +0,0 @@
-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,7 +8,6 @@ import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.HashSet;
 import java.util.Objects;
-import java.util.Set;
 
 /**
  * Pixiv搜索URL构造器
@@ -16,7 +15,7 @@ import java.util.Set;
  * @author LamGC
  * @see PixivURL#PIXIV_SEARCH_CONTENT_URL
  */
-@SuppressWarnings({"unused", "UnusedReturnValue"})
+@SuppressWarnings("unused")
 public class PixivSearchLinkBuilder {
 
     private final String content;
@@ -27,8 +26,8 @@ public class PixivSearchLinkBuilder {
     private SearchOrder searchOrder = SearchOrder.DATE_D;
     private SearchContentOption searchContentOption = SearchContentOption.ALL;
 
-    private final Set<String> includeKeywords = new HashSet<>(0);
-    private final Set<String> excludeKeywords = new HashSet<>(0);
+    private final HashSet<String> includeKeywords = new HashSet<>(0);
+    private final HashSet<String> excludeKeywords = new HashSet<>(0);
 
     private int page = 1;
 
@@ -162,19 +161,11 @@ public class PixivSearchLinkBuilder {
                 '}';
     }
 
-    public String getContent() {
-        return content;
-    }
-
     public PixivSearchLinkBuilder setSearchArea(SearchArea searchArea) {
         this.searchArea = Objects.requireNonNull(searchArea);
         return this;
     }
 
-    public SearchArea getSearchArea() {
-        return searchArea;
-    }
-
     /**
      * 获取搜索条件.
      * @return 搜索条件内容
@@ -208,60 +199,32 @@ public class PixivSearchLinkBuilder {
         return this;
     }
 
-    public SearchMode getSearchMode() {
-        return searchMode;
-    }
-
     public PixivSearchLinkBuilder setSearchType(SearchType searchType) {
         this.searchType = Objects.requireNonNull(searchType);
         return this;
     }
 
-    public SearchType getSearchType() {
-        return searchType;
-    }
-
     public PixivSearchLinkBuilder setSearchOrder(SearchOrder searchOrder) {
         this.searchOrder = Objects.requireNonNull(searchOrder);
         return this;
     }
 
-    public SearchOrder getSearchOrder() {
-        return searchOrder;
-    }
-
     public PixivSearchLinkBuilder setSearchContentOption(SearchContentOption searchContentOption) {
         this.searchContentOption = Objects.requireNonNull(searchContentOption);
         return this;
     }
 
-    public SearchContentOption getSearchContentOption() {
-        return searchContentOption;
-    }
-
     public PixivSearchLinkBuilder setRatioOption(RatioOption ratioOption) {
         this.ratioOption = Objects.requireNonNull(ratioOption);
         return this;
     }
 
-    public RatioOption getRatioOption() {
-        return ratioOption;
-    }
-
     public PixivSearchLinkBuilder setDateRange(Date startDate, Date endDate) {
         this.startDate = startDate;
         this.endDate = endDate;
         return this;
     }
 
-    public Date getStartDate() {
-        return startDate;
-    }
-
-    public Date getEndDate() {
-        return endDate;
-    }
-
     public PixivSearchLinkBuilder setMaxSize(int width, int height) {
         this.wgt = width;
         this.hgt = height;
@@ -282,10 +245,6 @@ public class PixivSearchLinkBuilder {
         return this;
     }
 
-    public int getPage() {
-        return page;
-    }
-
     public PixivSearchLinkBuilder addExcludeKeyword(String keyword) {
         excludeKeywords.add(keyword);
         return this;
@@ -306,14 +265,6 @@ public class PixivSearchLinkBuilder {
         return this;
     }
 
-    public Set<String> getIncludeKeywords() {
-        return new HashSet<>(includeKeywords);
-    }
-
-    public Set<String> getExcludeKeywords() {
-        return new HashSet<>(excludeKeywords);
-    }
-
     /**
      * 搜索区域
      */
@@ -345,18 +296,13 @@ public class PixivSearchLinkBuilder {
          */
         NOVELS("novel");
 
-        /**
-         * 可用的Json属性名
-         * @deprecated 该属性信息以移至 {@link PixivSearchAttribute}
-         * @see PixivSearchAttribute
-         */
-        @Deprecated
         public final String jsonKey;
 
         SearchArea(String jsonKey) {
             this.jsonKey = jsonKey;
         }
 
+
     }
 
     /**
@@ -455,4 +401,5 @@ public class PixivSearchLinkBuilder {
 
     }
 
+
 }

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

@@ -1,84 +0,0 @@
-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;
-    }
-
-}