[Version] 更新版本(2.5.2-20200609.2-SNAPSHOT -> 2.5.2-20200610.1-SNAPSHOT);

[Change] log4j2.xml 调整mirai日志在STANDARD_STD*的输出级别;
[Change] MiraiToSlf4jLoggerAdapter 调整类命名(MiraiToSlf4jLogger -> MiraiToSlf4jLoggerAdapter);
2025-07-02 05:17:26 +00:00 · 2020-06-10 09:21:27 +08:00 · 2020-06-10 09:20:35 +08:00 · 2020-06-10 09:13:12 +08:00 · 2020-06-10 09:10:17 +08:00 · 2020-06-10 09:09:54 +08:00
31 changed files with 1613 additions and 569 deletions
--- a/documents/interfaces/Pixiv作品信息获取接口.md
+++ b/documents/interfaces/Pixiv作品信息获取接口.md
@ -0,0 +1,108 @@
+## Pixiv作品信息批量获取接口 ##
+### 说明 ###
+接口可一次获取多个作品的基础信息
+
+
+### 接口地址 ###
+```
+GET https://www.pixiv.net/ajax/illust/recommend/illusts
+```
+
+- 需要登录: `否`
+- 是否为Pixiv接口标准返回格式: `是`  
+### 参数 ###
+- `illust_ids[]`: 作品Id, 可重复添加该参数
+
+
+### 请求示例 ###
+```
+GET https://www.pixiv.net/ajax/illust/recommend/illusts?illust_ids[]=82030844&illust_ids[]=82029098&illust_ids[]=82028913
+```
+
+### 返回数据 ###
+#### 数据示例 ####
+```json
+{
+    "error":false,
+    "message":"",
+    "body":{
+        "illusts":[
+            {
+                "illustId":"82030844",
+                "illustTitle":"3rd anniversary",
+                "id":"82030844",
+                "title":"3rd anniversary",
+                "illustType":0,
+                "xRestrict":0,
+                "restrict":0,
+                "sl":2,
+                "url":"https:\/\/i.pximg.net\/c\/360x360_70\/custom-thumb\/img\/2020\/06\/02\/11\/24\/49\/82030844_p0_custom1200.jpg",
+                "description":"",
+                "tags":[
+                    "\u30a2\u30ba\u30fc\u30eb\u30ec\u30fc\u30f3",
+                    "\u6bd4\u53e1(\u30a2\u30ba\u30fc\u30eb\u30ec\u30fc\u30f3)",
+                    "\u6c34\u7740",
+                    "\u8db3\u88cf",
+                    "\u88f8\u8db3",
+                    "\u30a2\u30ba\u30fc\u30eb\u30ec\u30fc\u30f35000users\u5165\u308a",
+                    "\u30a2\u30ba\u30fc\u30eb\u30ec\u30fc\u30f310000users\u5165\u308a",
+                    "\u30dd\u30cb\u30fc\u30c6\u30fc\u30eb",
+                    "\u30db\u30eb\u30bf\u30fc\u30cd\u30c3\u30af"],
+                "userId":"6662895",
+                "userName":"ATDAN-",
+                "width":1500,
+                "height":844,
+                "pageCount":1,
+                "isBookmarkable":true,
+                "bookmarkData":null,
+                "alt":"#\u30a2\u30ba\u30fc\u30eb\u30ec\u30fc\u30f3 3rd anniversary - ATDAN-\u7684\u63d2\u753b",
+                "isAdContainer":false,
+                "titleCaptionTranslation":{
+                    "workTitle":null,
+                    "workCaption":null
+                },
+                "createDate":"2020-06-02T01:29:40+09:00",
+                "updateDate":"2020-06-02T11:24:49+09:00",
+                "profileImageUrl":"https:\/\/i.pximg.net\/user-profile\/img\/2016\/01\/11\/21\/46\/50\/10371466_80f6ad67eab3b8abd44a2fb74ddd1ba1_50.jpg",
+                "type":"illust"
+            }, // ...
+        ]
+    }
+}
+
+```
+#### 参数详解 ####
+- `illusts`: (`Object[]`) 存储查询作品信息的数组
+    - `illustId`: (`string` -> `number`) 作品Id
+    - `illustTitle`: (`string`) 作品标题
+    - `id`: (`string` -> `number`) 与`illustId`一致, 猜测是以兼容旧版本为目录而存在
+    - `title`: (`string`) 与`illustTitle`一致, 猜测是以兼容旧版本为目录而存在
+    - `illustType`: (`number`) 作品类型
+        - `0`: 插画作品
+        - `1`: 漫画作品
+        - `2`: 动图作品
+    - `xRestrict`: (`number`) 作品是否为限制级, 基本准确, 少部分不一定(看Pixiv审核怎么理解了)
+        - `0`: 非限制级内容(即非R18作品)
+        - `1`: 限制级内容(即R18作品)
+    - `restrict`: (`number`) 作品限制级(意义不明, 可能是兼容性问题?)?
+    - `sl`: (`number`) 不明?
+    - `url`: (`string`) 作品预览图链接, 需要`Referer`请求头
+    - `description`: (`string`) 作品说明
+    - `tags`: (`string[]`) 作品标签数组
+    - `userId`: (`string` -> `number`) 作者用户Id
+    - `userName`: (`string`) 作者用户名
+    - `width`: (`number`) 作品长度
+    - `height`: (`number`) 作品高度
+    - `pageCount`: (`number`) 作品页数
+    - `isBookmarkable`: (`boolean`) 不明?
+    - `alt`: (`string`) 简略介绍信息(在图片加载失败时可提供给`img`标签使用)
+    - `isAdContainer`: (`boolean`) 不明?
+    - `titleCaptionTranslation`: (`Object`) 不明?
+        - `workTitle`: (`Unknown`) 不明?
+        - `workCaption`: (`Unknown`) 不明?
+    - `createDate`: (`string`) 作品创建时间(或者是完成时间?)
+    - `updateDate`: (`string`) 作品上传时间
+    - `profileImageUrl`: (`string`) 作者用户头像图片链接
+    - `type`: (`string`) 作品类型名
+
+
--- a/documents/interfaces/Pixiv排行榜接口.md
+++ b/documents/interfaces/Pixiv排行榜接口.md
@ -5,7 +5,9 @@
 GET https://www.pixiv.net/ranking.php
 ```

- 需要登录: `是`
+- 是否需要登录: `是`
+- 是否为Pixiv标准接口返回格式: `否`
+- 是否需要Referer请求头: `否`
 ### 参数 ###
 > 提示: 该接口参数较为复杂，请结合表格查看

@ -113,7 +115,7 @@ female_r18|`√`|×|×|×
 }
 ```

-#### 参数详解 ####
+#### 字段说明 ####
 - `contents`: (`Object[]`) 排行榜数组, 最多50行排行榜信息
    - `illust_id`: (`number`) 作品Id
    - `title`: (`string`) 作品标题
@ -126,9 +128,24 @@ female_r18|`√`|×|×|×
    - `user_name`: (`string`) 画师用户名
    - `user_id`: (`number`) 画师用户Id
    - `profile_img`: (`string`) 画师用户头像
-    - `illust_content_type`: (`Object`) 作品内容信息
-        - 待补充
-    - `illust_series`: (`boolean`) 不明?
+    - `illust_content_type`: (`Object`) 作品内容信息(警告: 文档内容仅作为开发参考, 并不传播相关内容!!!)
+        - `sexual`: (`number`) 作品内容分级
+            - `0`: 全年龄
+            - `1`: 青少年
+            - `2`: 成人级
+        - `lo`: (`boolean`) 是否为loli作品
+        - `grotesque`: (`boolean`) 是否为怪诞作品
+        - `violent`: (`boolean`) 作品是否含有暴力/强暴相关元素
+        - `homosexual`: (`boolean`) 作品是否含有同性恋相关元素
+        - `drug`: (`boolean`) 作品是否含有药物相关元素
+        - `thoughts`: (`boolean`) 作品是否含有思维/记忆相关元素(这个属性翻译起来有些问题, 待纠正)?
+        - `antisocial`: (`boolean`) 作品是否含有反社会, 令人厌恶的相关元素
+        - `religion`: (`boolean`) 作品是否含有宗教, 信仰相关元素
+        - `original`: (`boolean`) 作品是否为原创作品
+        - `furry`: (`boolean`) 作品是否有兽人相关元素
+        - `bl`: (`boolean`) 作品是否有耽美相关元素
+        - `yuri`: (`boolean`) 作品是否有百合相关元素
+    - `illust_series`: (`boolean`) 是否为系列作品
    - `width`: (`number`) 作品宽度(建议以原图为准)
    - `height`: (`number`) 作品高度(建议以原图为准)
    - `rank`: (`number`) 本期排行榜排名
--- a/documents/interfaces/Pixiv接口文档模板.md
+++ b/documents/interfaces/Pixiv接口文档模板.md
@ -0,0 +1,32 @@
+## 接口名 ##
+### 说明 ###
+
+### 接口地址 ###
+```
+GET/POST https://www.pixiv.net/...
+```
+
+- 是否需要登录: `是/否`
+- 是否为Pixiv标准接口返回格式: `是/否`
+- 是否需要Referer请求头: `是/否`
+
+### 参数 ###
+
+### 请求示例 ###
+```
+GET/POST 
+---- Request Body ---- // 如果没有, 可以不写, 如没有记得删除
+
+```
+
+### 返回数据 ###
+#### 数据示例 ####
+```json
+// Object[] 中只留一个, 其他删除后保留逗号, 增加 '// ...' 注释
+
+```
+#### 字段说明 ####
+- `属性名`: (`JS类型`) 属性说明
+    - `对象属性名`: (`原始JS类型` -> `可转换JS类型`) 属性说明
+- `属性名`: (`JS类型1` / `JS类型2` / ...) 属性说明, 需要清晰说明在什么情况下类型为`JS类型1`, 什么情况下是`JS类型2`.
+- `不明属性`: (`Unknown`) 如果属性用途不明, 则在说明后面加上`?`符号, 类型不明则填`Unknown`.
--- a/documents/interfaces/Pixiv搜索接口.md
+++ b/documents/interfaces/Pixiv搜索接口.md
@ -9,9 +9,12 @@
 GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
 ```

- 需要登录: `是`
+- 是否需要登录: `是/否`
+- 是否为Pixiv标准接口返回格式: `是/否`
+- 是否需要Referer请求头: `否`

-### Url参数 ###
+### 参数 ###
+#### Url参数 ####
 - `Type`: 内容类型
    - illustrations(插画)
    - top(推荐)
@ -19,8 +22,8 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
    - novels(小说)
 - `Content`: 搜索内容

-### 参数 ###
-#### 必填 ####
+#### GET参数 ####
+##### 必填 #####
 - `word`: 与搜索内容一致 (经测试似乎可以省略)
 - `s_mode`: 匹配模式
    - `s_tag`: 标签，部分一致
@ -42,7 +45,7 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
    - `safe`: 排除成人内容
    - `r18`: 仅成人内容

-#### 选填 ####
+##### 选填 #####
 - `wlt`: 作品最低宽度(px)
 - `wgt`: 作品最高宽度(px)
 - `hlt`: 作品最低高度(px)
@ -56,3 +59,307 @@ GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{Param...}
 - `scd`: 过滤作品发布时间 - 结束时间(yyyy-MM-dd)
 - `(Unknown)`: 最小收藏数 (该参数为会员限定功能，后续补充)

+### 返回数据 ###
+#### 数据示例 ####
+```json
+{
+    "error":false,
+    "body":{
+        "illustManga":{
+            "data":[
+                {
+                    "illustId":"82130571",
+                    "illustTitle":"空の絵",
+                    "id":"82130571",
+                    "title":"空の絵",
+                    "illustType":0,
+                    "xRestrict":0,
+                    "restrict":0,
+                    "sl":2,
+                    "url":"https:\/\/i.pximg.net\/c\/250x250_80_a2\/img-master\/img\/2020\/06\/06\/17\/51\/14\/82130571_p0_square1200.jpg",
+                    "description":"",
+                    "tags":[
+                        "風景",
+                        "空",
+                        "草",
+                        "雲"],
+                    "userId":"31507675",
+                    "userName":"昏omeme",
+                    "width":1600,
+                    "height":1600,
+                    "pageCount":2,
+                    "isBookmarkable":true,
+                    "bookmarkData":null,
+                    "alt":"#風景 空の絵 - 昏omeme的插画",
+                    "isAdContainer":false,
+                    "titleCaptionTranslation":{
+                        "workTitle":null,
+                        "workCaption":null
+                    },
+                    "createDate":"2020-06-06T17:51:14+09:00",
+                    "updateDate":"2020-06-06T17:51:14+09:00",
+                    "profileImageUrl":"https:\/\/i.pximg.net\/user-profile\/img\/2020\/05\/06\/19\/21\/04\/18509741_e3166e69809c44d6926454ecaac89590_50.png"
+                }, // ...
+            ],
+            "total":165875,
+            "bookmarkRanges":[
+                {
+                    "min":null,
+                    "max":null
+                },
+                {
+                    "min":10000,
+                    "max":null
+                },
+                {
+                    "min":5000,
+                    "max":null
+                },
+                {
+                    "min":1000,
+                    "max":null
+                },
+                {
+                    "min":500,
+                    "max":null
+                },
+                {
+                    "min":300,
+                    "max":null
+                },
+                {
+                    "min":100,
+                    "max":null
+                },
+                {
+                    "min":50,
+                    "max":null
+                }
+            ]
+        },
+        "popular":{
+            "recent":[
+                {
+                    "illustId":"82062770",
+                    "illustTitle":"Still you remember",
+                    "id":"82062770",
+                    "title":"Still you remember",
+                    "illustType":0,
+                    "xRestrict":0,
+                    "restrict":0,
+                    "sl":2,
+                    "url":"https:\/\/i.pximg.net\/c\/250x250_80_a2\/img-master\/img\/2020\/06\/03\/18\/02\/15\/82062770_p0_square1200.jpg",
+                    "description":"",
+                    "tags":[
+                        "オリジナル",
+                        "女の子",
+                        "カラス",
+                        "风景",
+                        "線路"],
+                    "userId":"1069005",
+                    "userName":"へちま",
+                    "width":2000,
+                    "height":1415,
+                    "pageCount":1,
+                    "isBookmarkable":true,
+                    "bookmarkData":null,
+                    "alt":"#オリジナル Still you remember - へちま的插画",
+                    "isAdContainer":false,
+                    "titleCaptionTranslation":{
+                        "workTitle":null,
+                        "workCaption":null
+                    },
+                    "createDate":"2020-06-03T18:02:15+09:00",
+                    "updateDate":"2020-06-03T18:02:15+09:00",
+                    "profileImageUrl":"https:\/\/i.pximg.net\/user-profile\/img\/2013\/05\/10\/00\/38\/05\/6213543_c94edc0d13776214467bd0c47ee6491a_50.jpg"
+                }, // ...
+            ],
+            "permanent":[
+                {
+                    "illustId":"60993044",
+                    "illustTitle":"無題",
+                    "id":"60993044",
+                    "title":"無題",
+                    "illustType":0,
+                    "xRestrict":0,
+                    "restrict":0,
+                    "sl":2,
+                    "url":"https:\/\/i.pximg.net\/c\/250x250_80_a2\/img-master\/img\/2017\/01\/18\/13\/07\/46\/60993044_p0_square1200.jpg",
+                    "description":"",
+                    "tags":[
+                        "少女",
+                        "女の子",
+                        "原创",
+                        "オリジナル",
+                        "场景",
+                        "落書き",
+                        "創作",
+                        "背景",
+                        "风景",
+                        "オリジナル7500users入り"],
+                    "userId":"18811972",
+                    "userName":"淅洵",
+                    "width":3507,
+                    "height":2480,
+                    "pageCount":1,
+                    "isBookmarkable":true,
+                    "bookmarkData":null,
+                    "alt":"#少女 無題 - 淅洵的插画",
+                    "isAdContainer":false,
+                    "titleCaptionTranslation":{
+                        "workTitle":null,
+                        "workCaption":null
+                    },
+                    "createDate":"2017-01-18T13:07:46+09:00",
+                    "updateDate":"2017-01-18T13:07:46+09:00",
+                    "profileImageUrl":"https:\/\/i.pximg.net\/user-profile\/img\/2017\/05\/29\/17\/17\/49\/12623968_6cf3f1979e10643425972ae205a7920d_50.jpg"
+                }, // ...
+            ]
+        },
+        "relatedTags":[
+            "風景",
+            "背景",
+            "風景画",
+            "空",
+            "雲",
+            "創作",
+            "ファンタジー",
+            "夏",
+            "青",
+            "建物",
+            "青空",
+            "少女",
+            "東京",
+            "抽象画",
+            "男の子",
+            "透明水彩"
+        ],
+        "tagTranslation":{
+            "風景":{
+                "zh":"风景"
+            },
+            "背景":{
+                "zh":"background"
+            },
+            "風景画":{
+                "zh":"landscape painting"
+            },
+            "空":{
+                "zh":"sky"
+            },
+            "雲":{
+                "zh":"云"
+            },
+            "創作":{
+                "zh":"原创"
+            },
+            "ファンタジー":{
+                "zh":"奇幻"
+            },
+            "夏":{
+                "zh":"夏天"
+            },
+            "青":{
+                "zh":"蓝"
+            },
+            "建物":{
+                "zh":"building"
+            },
+            "青空":{
+                "zh":"蓝天"
+            },
+            "少女":{
+                "zh":"young girl"
+            },
+            "東京":{
+                "zh":"tokyo"
+            },
+            "抽象画":{
+                "zh":"abstract art"
+            },
+            "男の子":{
+                "zh":"男孩子"
+            },
+            "透明水彩":{
+                "zh":"transparent watercolor"
+            }
+        },
+        "zoneConfig":{
+            "header":{
+                "url":"https:\/\/pixon.ads-pixiv.net\/show?zone_id=header&format=js&s=1&up=0&a=22&ng=g&l=zh&uri=%2Fajax%2Fsearch%2Fartworks%2F_PARAM_&is_spa=1&K=59bba275c645c&ab_test_digits_first=20&yuid=FwdzEnA&suid=Pgfip96ymw5tvu9l9&num=5edb6277927"
+            },
+            "footer":{
+                "url":"https:\/\/pixon.ads-pixiv.net\/show?zone_id=footer&format=js&s=1&up=0&a=22&ng=g&l=zh&uri=%2Fajax%2Fsearch%2Fartworks%2F_PARAM_&is_spa=1&K=59bba275c645c&ab_test_digits_first=20&yuid=FwdzEnA&suid=Pgfip96yn1fgocj2&num=5edb6277775"
+            },
+            "infeed":{
+                "url":"https:\/\/pixon.ads-pixiv.net\/show?zone_id=illust_search_grid&format=js&s=1&up=0&a=22&ng=g&l=zh&uri=%2Fajax%2Fsearch%2Fartworks%2F_PARAM_&is_spa=1&K=59bba275c645c&ab_test_digits_first=20&yuid=FwdzEnA&suid=Pgfip96yn4t7cho88&num=5edb6277137"
+            }
+        },
+        "extraData":{
+            "meta":{
+                "title":"#风景のイラスト・マンガ作品(投稿超过10万件） - pixiv",
+                "description":"pixiv",
+                "canonical":"https:\/\/www.pixiv.net\/tags\/%E9%A3%8E%E6%99%AF",
+                "alternateLanguages":{
+                    "ja":"https:\/\/www.pixiv.net\/tags\/%E9%A3%8E%E6%99%AF",
+                    "en":"https:\/\/www.pixiv.net\/en\/tags\/%E9%A3%8E%E6%99%AF"
+                },
+                "descriptionHeader":"pixiv"
+            }
+        }
+    }
+}
+```
+#### 字段说明 ####
+- `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[]`) 搜索结果(仅当前页数)
+        - `illustId`: (`string` -> `number`) 作品Id
+        - `illustTitle`: (`string`) 作品标题
+        - `id`: (`string` -> `number`) 与`illustId`一致, 猜测是以兼容旧版本为目录而存在
+        - `title`: (`string`) 与`illustTitle`一致, 猜测是以兼容旧版本为目录而存在
+        - `illustType`: (`number`) 作品类型
+            - `0`: 插画作品
+            - `1`: 漫画作品
+            - `2`: 动图作品
+        - `xRestrict`: (`number`) 作品是否为限制级, 基本准确, 少部分不一定(看Pixiv审核怎么理解了)
+            - `0`: 非限制级内容(即非R18作品)
+            - `1`: 限制级内容(即R18作品)
+        - `restrict`: (`number`) 作品限制级(意义不明, 可能是兼容性问题?)?
+        - `sl`: (`number`) 不明?
+        - `url`: (`string`) 作品预览图链接, 需要`Referer`请求头
+        - `description`: (`string`) 作品说明
+        - `tags`: (`string[]`) 作品标签数组
+        - `userId`: (`string` -> `number`) 作者用户Id
+        - `userName`: (`string`) 作者用户名
+        - `width`: (`number`) 作品长度
+        - `height`: (`number`) 作品高度
+        - `pageCount`: (`number`) 作品页数
+        - `isBookmarkable`: (`boolean`) 不明?
+        - `bookmarkData`: (`Unknown`) 不明?
+        - `alt`: (`string`) 简略介绍信息(在图片加载失败时可提供给`img`标签使用)
+        - `isAdContainer`: (`boolean`) 不明?
+        - `titleCaptionTranslation`: (`Object`) 不明?
+            - `workTitle`: (`Unknown`) 不明?
+            - `workCaption`: (`Unknown`) 不明?
+        - `createDate`: (`string`) 作品创建时间(或者是完成时间?)
+        - `updateDate`: (`string`) 作品上传时间
+        - `profileImageUrl`: (`string`) 作者用户头像图片链接
+        
--- a/documents/interfaces/Pixiv首页数据接口.md
+++ b/documents/interfaces/Pixiv首页数据接口.md
@ -21,21 +21,21 @@ GET https://www.pixiv.net/ajax/top/{type}?mode={mode}&lang={lang}
 - `lang`: 语言(只写几个)
    - `zh`: 中文

-> 是否需要登录: `是`  
-> 是否为Pixiv接口标准返回格式: `是`  
-> 是否需要Referer请求头: `未知`
+- 是否需要登录: `是`  
+- 是否为Pixiv接口标准返回格式: `是`  
+- 是否需要Referer请求头: `是`

-请求Url示例:
+### 请求示例 ###
 ```
 GET https://www.pixiv.net/ajax/top/illust?mode=all&lang=zh
 ```

-响应示例:
+### 返回数据 ###
+#### 数据示例 ####
 ```
 (内容过长, 略)
 ```
-
-返回内容(Json):
+#### 字段说明 ####
 - `page`: 网页相关内容
    - `tags`: (`Object[]`) 热门标签
        - `tag`: (`String`) 标签名
--- a/documents/interfaces/search.txt
+++ b/documents/interfaces/search.txt
@ -1,24 +0,0 @@
-搜索标签信息：https://www.pixiv.net/ajax/search/tags/标签名
-
-搜索接口：
-https://www.pixiv.net/ajax/search/{Type}/搜索内容
-Type = illustrations(插画) / top(顶部?) / manga(漫画) / novels(小说)
-
-word=搜索内容 [参数可能不是必须的]
-s_mode=s_tag(标签-部分一致) / s_tag_full(标签-完全一致) / s_tc(标题、说明文字)
-type= all(插画、漫画、动图_动态插图) / illust_and_ugoira(插画、动图) / illust(插画) / manga(漫画) / ugoira(动图)
-p=页数 [超出页数的情况下将获取不到数据(即"body.illust.data"是空数组)]
-order=date(按旧排序) / date_d(按新排序) / Unknown(按热门度排序, 需要会员)
-mode= all(全部) / safe(全年龄) / r18(咳咳)
-
-可选参数：
-wlt=最小宽度像素
-wgt=最高宽度像素
-hlt=最小高度像素
-hgt=最高高度像素
-ratio=0.5(横图) / -0.5(纵图) / 0(正方形) [可能不能改变参数, 三个值是固定的]
-tool=使用工具, 不是很重要晚些再加
-scd=开始时间(yyyy-MM-dd)
-ecd=结束时间(yyyy-MM-dd)
-
-最小收藏数 = 收藏数限定参数为会员功能, 无法获取
--- a/pom.xml
+++ b/pom.xml
@ -6,7 +6,7 @@

    <groupId>net.lamgc</groupId>
    <artifactId>ContentGrabbingJi</artifactId>
-    <version>2.5.2-20200604.3-SNAPSHOT</version>
+    <version>2.5.2-20200610.1-SNAPSHOT</version>

    <repositories>
        <repository>
@ -19,7 +19,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-RC2-1</mirai.CoreVersion>
+        <mirai.CoreVersion>1.0.2</mirai.CoreVersion>
        <mirai.JaptVersion>1.1.1</mirai.JaptVersion>
        <kotlin.version>1.3.71</kotlin.version>
        <ktor.version>1.3.2</ktor.version>
@ -179,6 +179,11 @@
            <artifactId>gifencoder</artifactId>
            <version>0.10.1</version>
        </dependency>
+        <dependency>
+            <groupId>org.jline</groupId>
+            <artifactId>jline</artifactId>
+            <version>3.15.0</version>
+        </dependency>
    </dependencies>

 </project>
--- a/src/main/java/net/lamgc/cgj/Main.java
+++ b/src/main/java/net/lamgc/cgj/Main.java
@ -93,7 +93,7 @@ public class Main {
    }

    @Command
-    public static void consoleMode() {
+    public static void consoleMode() throws IOException {
        ConsoleMain.start();
    }

--- a/src/main/java/net/lamgc/cgj/bot/BotAdminCommandProcess.java
+++ b/src/main/java/net/lamgc/cgj/bot/BotAdminCommandProcess.java
@ -271,6 +271,7 @@ public class BotAdminCommandProcess {

        AutoSender sender = new RandomRankingArtworksSender(
                MessageSenderBuilder.getMessageSender(MessageSource.Group, id),
+                id,
                rankingStart,
                rankingEnd,
                rankingMode, rankingContentType,
--- a/src/main/java/net/lamgc/cgj/bot/BotCommandProcess.java
+++ b/src/main/java/net/lamgc/cgj/bot/BotCommandProcess.java
@ -1,91 +1,40 @@
 package net.lamgc.cgj.bot;

 import com.google.common.base.Strings;
-import com.google.common.base.Throwables;
-import com.google.gson.*;
-import io.netty.handler.codec.http.HttpHeaderNames;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
 import net.lamgc.cgj.bot.boot.BotGlobal;
-import net.lamgc.cgj.bot.cache.*;
+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.pixiv.PixivDownload.PageQuality;
 import net.lamgc.cgj.pixiv.PixivSearchBuilder;
 import net.lamgc.cgj.pixiv.PixivURL;
-import net.lamgc.cgj.pixiv.PixivDownload.PageQuality;
-import net.lamgc.cgj.pixiv.PixivURL.RankingContentType;
-import net.lamgc.cgj.pixiv.PixivURL.RankingMode;
-import net.lamgc.cgj.util.URLs;
 import net.lamgc.utils.base.runner.Argument;
 import net.lamgc.utils.base.runner.Command;
-import net.lz1998.cq.utils.CQCode;
-import org.apache.http.HttpResponse;
-import org.apache.http.client.methods.HttpGet;
-import org.apache.http.client.methods.HttpHead;
-import org.apache.http.util.EntityUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import java.io.File;
 import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
 import java.text.SimpleDateFormat;
 import java.util.*;
-import java.util.concurrent.atomic.AtomicInteger;

-@SuppressWarnings({"SynchronizationOnLocalVariableOrMethodParameter", "SameParameterValue"})
+@SuppressWarnings({"SameParameterValue"})
 public class BotCommandProcess {

-    private final static PixivDownload pixivDownload =
-            new PixivDownload(BotGlobal.getGlobal().getCookieStore(), BotGlobal.getGlobal().getProxy());
-
    private final static Logger log = LoggerFactory.getLogger(BotCommandProcess.class);

-    private final static File imageStoreDir = new File(BotGlobal.getGlobal().getDataStoreDir(), "data/image/cgj/");
-    private final static Gson gson = new GsonBuilder()
-            .serializeNulls()
-            .create();
-
-    /* -------------------- 缓存 -------------------- */
-
-    private final static Hashtable<String, File> imageCache = new Hashtable<>();
-
-    /**
-     * 作品信息缓存 - 不过期
-     */
-    private final static CacheStore<JsonElement> illustInfoCache =
-            new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(), "illustInfo", gson);
-
-    /**
-     * 作品信息预加载数据 - 有效期 2 小时, 本地缓存有效期1 ± 0.25
-     */
-    private final static CacheStore<JsonElement> illustPreLoadDataCache =
-            CacheStoreUtils.hashLocalHotDataStore(
-                new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(), "illustPreLoadData", gson),
-                3600000, 900000);
-    /**
-     * 搜索内容缓存, 有效期 2 小时
-     */
-    private final static CacheStore<JsonElement> searchBodyCache =
-            new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(), "searchBody", gson);
-
-    /**
-     * 排行榜缓存, 不过期
-     */
-    private final static CacheStore<List<JsonObject>> rankingCache =
-            new JsonObjectRedisListCacheStore(BotGlobal.getGlobal().getRedisServer(), "ranking", gson);
-
-    /**
-     * 作品页面下载链接缓存 - 不过期
-     */
-    private final static CacheStore<List<String>> pagesCache =
-            new StringListRedisCacheStore(BotGlobal.getGlobal().getRedisServer(), "imagePages");
-
    /**
     * 作品报告存储 - 不过期
     */
    public final static CacheStore<JsonElement> reportStore =
-            new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(), "report", gson);
+            new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(),
+                    "report", BotGlobal.getGlobal().getGson());

    private final static RankingUpdateTimer updateTimer = new RankingUpdateTimer();

@ -140,7 +89,8 @@ public class BotCommandProcess {
     * @return 返回作品信息
     */
    @Command(commandName = "info")
-    public static String artworkInfo(@Argument(name = "$fromGroup") long fromGroup, @Argument(name = "id") int illustId) {
+    public static String artworkInfo(@Argument(name = "$fromGroup") long fromGroup,
+                                     @Argument(name = "id") int illustId) {
        if(illustId <= 0) {
            return "这个作品Id是错误的！";
        }
@ -150,7 +100,7 @@ public class BotCommandProcess {
                return "阅览禁止：该作品已被封印！！";
            }

-            JsonObject illustPreLoadData = getIllustPreLoadData(illustId, false);
+            JsonObject illustPreLoadData = CacheStoreCentral.getIllustPreLoadData(illustId, false);
            // 在 Java 6 开始, 编译器会将用'+'进行的字符串拼接将自动转换成StringBuilder拼接
            return "色图姬帮你了解了这个作品的信息！\n" + "---------------- 作品信息 ----------------" +
                    "\n作品Id: " + illustId +
@ -164,7 +114,7 @@ public class BotCommandProcess {
                    "\n页数：" + illustPreLoadData.get(PreLoadDataComparator.Attribute.PAGE.attrName).getAsInt() + "页" +
                    "\n作品链接：" + artworksLink(fromGroup, illustId) + "\n" +
                    "---------------- 作品图片 ----------------\n" +
-                    getImageById(fromGroup, illustId, PageQuality.REGULAR, 1) + "\n" +
+                    CacheStoreCentral.getImageById(fromGroup, illustId, PageQuality.REGULAR, 1) + "\n" +
                    "使用 \".cgj image -id " +
                    illustId +
                    "\" 获取原图。\n如有不当作品，可使用\".cgj report -id " +
@ -214,7 +164,8 @@ public class BotCommandProcess {
        PixivURL.RankingMode mode;
        try {
            String rankingModeValue = contentMode.toUpperCase();
-            mode = PixivURL.RankingMode.valueOf(rankingModeValue.startsWith("MODE_") ? rankingModeValue : "MODE_" + rankingModeValue);
+            mode = PixivURL.RankingMode.valueOf(rankingModeValue.startsWith("MODE_") ?
+                    rankingModeValue : "MODE_" + rankingModeValue);
        } catch (IllegalArgumentException e) {
            log.warn("无效的RankingMode值: {}", contentMode);
            return "参数无效, 请查看帮助信息";
@ -223,7 +174,8 @@ public class BotCommandProcess {
        PixivURL.RankingContentType type;
        try {
            String contentTypeValue = contentType.toUpperCase();
-            type = PixivURL.RankingContentType.valueOf(contentTypeValue.startsWith("TYPE_") ? contentTypeValue : "TYPE_" + contentTypeValue);
+            type = PixivURL.RankingContentType.valueOf(
+                    contentTypeValue.startsWith("TYPE_") ? contentTypeValue : "TYPE_" + contentTypeValue);
        } catch (IllegalArgumentException e) {
            log.warn("无效的RankingContentType值: {}", contentType);
            return "参数无效, 请查看帮助信息";
@ -235,7 +187,8 @@ public class BotCommandProcess {
            return "不支持的内容类型或模式!";
        }

-        StringBuilder resultBuilder = new StringBuilder(mode.name() + " - 以下是 ").append(new SimpleDateFormat("yyyy-MM-dd").format(queryDate)).append(" 的Pixiv插画排名榜前十名：\n");
+        StringBuilder resultBuilder = new StringBuilder(mode.name() + " - 以下是 ")
+                .append(new SimpleDateFormat("yyyy-MM-dd").format(queryDate)).append(" 的Pixiv插画排名榜前十名：\n");
        try {
            int index = 0;
            int itemLimit = 10;
@ -256,7 +209,8 @@ public class BotCommandProcess {
                log.warn("配置项 {} 的参数值格式有误!", imageLimitPropertyKey);
            }

-            List<JsonObject> rankingInfoList = getRankingInfoByCache(type, mode, queryDate, 1, Math.max(0, itemLimit), false);
+            List<JsonObject> rankingInfoList = CacheStoreCentral
+                    .getRankingInfoByCache(type, mode, queryDate, 1, Math.max(0, itemLimit), false);
            if(rankingInfoList.isEmpty()) {
                return "无法查询排行榜，可能排行榜尚未更新。";
            }
@ -270,16 +224,21 @@ public class BotCommandProcess {
                String authorName = rankInfo.get("user_name").getAsString();
                String title = rankInfo.get("title").getAsString();
                resultBuilder.append(rank).append(". (id: ").append(illustId).append(") ").append(title)
-                        .append("(Author: ").append(authorName).append(",").append(authorId).append(") ").append(pagesCount).append("p.\n");
+                        .append("(Author: ").append(authorName).append(",").append(authorId).append(") ")
+                        .append(pagesCount).append("p.\n");
                if (index <= imageLimit) {
-                    resultBuilder.append(getImageById(fromGroup, illustId, PixivDownload.PageQuality.REGULAR, 1)).append("\n");
+                    resultBuilder
+                            .append(CacheStoreCentral
+                                    .getImageById(fromGroup, illustId, PixivDownload.PageQuality.REGULAR, 1))
+                            .append("\n");
                }
            }
        } catch (IOException e) {
            log.error("消息处理异常", e);
            return "排名榜获取失败！详情请查看机器人控制台。";
        }
-        return resultBuilder.append("如查询当前时间获取到昨天时间，则今日排名榜未更新。\n如有不当作品，可使用\".cgj report -id 作品id\"向色图姬反馈。").toString();
+        return resultBuilder.append("如查询当前时间获取到昨天时间，则今日排名榜未更新。\n" +
+                "如有不当作品，可使用\".cgj report -id 作品id\"向色图姬反馈。").toString();
    }

    /**
@ -296,13 +255,34 @@ public class BotCommandProcess {
     * 随机获取一副作品
     */
    @Command(commandName = "random")
-    public static String randomImage() {
+    public static String randomImage(
+            @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;
+        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 "参数无效, 请查看帮助信息";
+        }
+
        BufferMessageEvent event = new BufferMessageEvent();
        RandomRankingArtworksSender artworksSender = 
-            new RandomRankingArtworksSender(event, 1, 200, 
-            RankingMode.MODE_MALE, 
-            RankingContentType.TYPE_ALL, 
-            PageQuality.ORIGINAL);
+            new RandomRankingArtworksSender(event, fromGroup, 1, 200, mode, type,
+                    PageQuality.ORIGINAL);
        artworksSender.send();
        return event.getBufferMessage();
    }
@ -328,92 +308,12 @@ public class BotCommandProcess {
            @Argument(name = "area", force = false) String area,
            @Argument(name = "in", force = false) String includeKeywords,
            @Argument(name = "ex", force = false) String excludeKeywords,
-            @Argument(name = "contentOption", force = false) String contentOption,
+            @Argument(name = "option", force = false) String contentOption,
            @Argument(name = "page", force = false, defaultValue = "1") int pagesIndex
    ) throws IOException {
        log.info("正在执行搜索...");
-        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();
-        log.debug("RequestUrl: {}", requestUrl);
-        JsonObject resultBody = null;
-        if(!searchBodyCache.exists(requestUrl)) {
-            synchronized (requestUrl) {
-                if (!searchBodyCache.exists(requestUrl)) {
-                    log.debug("searchBody缓存失效, 正在更新...");
-                    JsonObject jsonObject;
-                    HttpGet httpGetRequest = pixivDownload.createHttpGetRequest(requestUrl);
-                    HttpResponse response = pixivDownload.getHttpClient().execute(httpGetRequest);
-
-                    String responseBody = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
-                    log.debug("ResponseBody: {}", responseBody);
-                    jsonObject = gson.fromJson(responseBody, JsonObject.class);
-
-                    if (jsonObject.get("error").getAsBoolean()) {
-                        log.error("接口请求错误, 错误信息: {}", jsonObject.get("message").getAsString());
-                        return "处理命令时发生错误！";
-                    }
-
-                    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("搜索缓存命中.");
-                }
-            }
-        } else {
-            log.debug("搜索缓存命中.");
-        }
-
-        if(Objects.isNull(resultBody)) {
-            resultBody = searchBodyCache.getCache(requestUrl).getAsJsonObject().getAsJsonObject("body");
-        }
+        JsonObject resultBody = CacheStoreCentral
+                .getSearchBody(content, type, area, includeKeywords, excludeKeywords, contentOption);

        StringBuilder result = new StringBuilder("内容 " + content + " 的搜索结果：\n");
        log.debug("正在处理信息...");
@ -424,8 +324,10 @@ 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) {
+            if (!resultBody.has(searchArea.jsonKey) ||
+                    resultBody.getAsJsonObject(searchArea.jsonKey).getAsJsonArray("data").size() == 0) {
                log.debug("返回数据不包含 {}", searchArea.jsonKey);
                continue;
            }
@ -449,7 +351,8 @@ public class BotCommandProcess {
                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作品链接: {}",
+                log.debug("{} ({} / {})\n\t作品id: {}, \n\t作者名(作者id): {} ({}), \n\t" +
+                                "作品标题: {}, \n\t作品Tags: {}, \n\t页数: {}页, \n\t作品链接: {}",
                        searchArea.name(),
                        count,
                        illustsList.size(),
@ -462,8 +365,9 @@ public class BotCommandProcess {
                        PixivURL.getPixivRefererLink(illustId)
                );

-                String imageMsg = getImageById(fromGroup, illustId, PixivDownload.PageQuality.REGULAR, 1);
-                if (isNoSafe(illustId, SettingProperties.getProperties(fromGroup), true)) {
+                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)) {
@ -471,7 +375,7 @@ public class BotCommandProcess {
                    continue;
                }

-                JsonObject illustPreLoadData = getIllustPreLoadData(illustId, false);
+                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())
@ -487,12 +391,16 @@ public class BotCommandProcess {
                        .append(illustPreLoadData.get(PreLoadDataComparator.Attribute.COMMENT.attrName).getAsInt())
                        .append("\n").append(imageMsg).append("\n");
                count++;
+                totalCount++;
            }
            if (count > limit) {
                break;
            }
        }
-        return Strings.nullToEmpty(result.toString()) + "预览图片并非原图，使用“.cgj image -id 作品id”获取原图\n如有不当作品，可使用\".cgj report -id 作品id\"向色图姬反馈。";
+        return totalCount <= 0 ?
+                "搜索完成，未找到相关作品。" :
+                Strings.nullToEmpty(result.toString()) + "预览图片并非原图，使用“.cgj image -id 作品id”获取原图\n" +
+                "如有不当作品，可使用\".cgj report -id 作品id\"向色图姬反馈。";
    }

    /**
@ -511,8 +419,13 @@ public class BotCommandProcess {
                log.warn("来源群 {} 查询的作品Id {} 为R18作品, 根据配置设定, 屏蔽该作品.", fromGroup, illustId);
                return "该作品已被封印！";
            }
-            List<String> pagesList = PixivDownload.getIllustAllPageDownload(pixivDownload.getHttpClient(), pixivDownload.getCookieStore(), illustId, quality);
-            StringBuilder builder = new StringBuilder("作品ID ").append(illustId).append(" 共有").append(pagesList.size()).append("页：").append("\n");
+            List<String> pagesList =
+                    PixivDownload.getIllustAllPageDownload(
+                            BotGlobal.getGlobal().getPixivDownload().getHttpClient(),
+                            BotGlobal.getGlobal().getPixivDownload().getCookieStore(),
+                            illustId, quality);
+            StringBuilder builder = new StringBuilder("作品ID ").append(illustId)
+                    .append(" 共有").append(pagesList.size()).append("页：").append("\n");
            int index = 0;
            for (String link : pagesList) {
                builder.append("Page ").append(++index).append(": ").append(link).append("\n");
@ -531,7 +444,8 @@ public class BotCommandProcess {
     * @return 返回作品在Pixiv的链接
     */
    @Command(commandName = "link")
-    public static String artworksLink(@Argument(name = "$fromGroup") long fromGroup, @Argument(name = "id") int illustId) {
+    public static String artworksLink(@Argument(name = "$fromGroup") long fromGroup,
+                                      @Argument(name = "id") int illustId) {
        try {
            if (isNoSafe(illustId, SettingProperties.getProperties(fromGroup), false)) {
                log.warn("作品Id {} 已被屏蔽.", illustId);
@ -547,120 +461,9 @@ public class BotCommandProcess {
        return PixivURL.getPixivRefererLink(illustId);
    }

-    /**
-     * 通过illustId获取作品图片
-     * @param fromGroup 来源群(系统提供)
-     * @param illustId 作品Id
-     * @param quality 图片质量
-     * @param pageIndex 指定页面索引, 从1开始
-     * @return 如果成功, 返回BotCode, 否则返回错误信息.
-     */
-    @Command(commandName = "image")
-    public static String getImageById(
-            @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) {
-        log.debug("IllustId: {}, Quality: {}, PageIndex: {}", illustId, quality.name(), pageIndex);
-
-        try {
-            if (isNoSafe(illustId, SettingProperties.getProperties(fromGroup), false)) {
-                log.warn("作品 {} 存在R-18内容且设置\"image.allowR18\"为false，将屏蔽该作品不发送.", illustId);
-                return "（根据设置，该作品已被屏蔽！）";
-            } else if(isReported(illustId)) {
-                log.warn("作品Id {} 被报告, 正在等待审核, 跳过该作品.", illustId);
-                return "（该作品已被封印）";
-            }
-        } catch (IOException e) {
-            log.warn("作品信息无法获取!", e);
-            return "（发生网络异常，无法获取图片！）";
-        }
-
-        List<String> pagesList;
-        try {
-            pagesList = getIllustPages(illustId, quality, false);
-        } catch (IOException e) {
-            log.error("获取下载链接列表时发生异常", e);
-            return "发生网络异常，无法获取图片！";
-        }
-
-        if(log.isDebugEnabled()) {
-            StringBuilder logBuilder = new StringBuilder("作品Id " + illustId + " 所有页面下载链接: \n");
-            AtomicInteger index = new AtomicInteger();
-            pagesList.forEach(item -> logBuilder.append(index.incrementAndGet()).append(". ").append(item).append("\n"));
-            log.debug(logBuilder.toString());
-        }
-
-        if (pagesList.size() < pageIndex || pageIndex <= 0) {
-            log.warn("指定的页数超出了总页数({} / {})", pageIndex, pagesList.size());
-            return "指定的页数超出了范围(总共 " + pagesList.size() + " 页)";
-        }
-
-        String downloadLink = pagesList.get(pageIndex - 1);
-        String fileName = URLs.getResourceName(Strings.nullToEmpty(downloadLink));
-        File imageFile = new File(getImageStoreDir(), downloadLink.substring(downloadLink.lastIndexOf("/") + 1));
-        log.debug("FileName: {}, DownloadLink: {}", fileName, downloadLink);
-        if(!imageCache.containsKey(fileName)) {
-            if(imageFile.exists()) {
-                HttpHead headRequest = new HttpHead(downloadLink);
-                headRequest.addHeader("Referer", PixivURL.getPixivRefererLink(illustId));
-                HttpResponse headResponse;
-                try {
-                    headResponse = pixivDownload.getHttpClient().execute(headRequest);
-                } catch (IOException e) {
-                    log.error("获取图片大小失败！", e);
-                    return "图片获取失败!";
-                }
-                String contentLengthStr = headResponse.getFirstHeader(HttpHeaderNames.CONTENT_LENGTH.toString()).getValue();
-                log.debug("图片大小: {}B", contentLengthStr);
-                if (imageFile.length() == Long.parseLong(contentLengthStr)) {
-                    imageCache.put(URLs.getResourceName(downloadLink), imageFile);
-                    log.debug("作品Id {} 第 {} 页缓存已补充.", illustId, pageIndex);
-                    return getImageToBotCode(imageFile, false).toString();
-                }
-            }
-
-            try {
-                Throwable throwable = ImageCacheStore.executeCacheRequest(new ImageCacheObject(imageCache, illustId, downloadLink, imageFile));
-                if(throwable != null) {
-                    throw throwable;
-                }
-            } catch (InterruptedException e) {
-                log.warn("图片缓存被中断", e);
-                return "(错误：图片获取超时)";
-            } catch (Throwable e) {
-                log.error("图片 {} 获取失败:\n{}", illustId + "p" + pageIndex, Throwables.getStackTraceAsString(e));
-                return "(错误: 图片获取出错)";
-            }
-        } else {
-            log.debug("图片 {} 缓存命中.", fileName);
-        }
-
-        return getImageToBotCode(imageCache.get(fileName), false).toString();
-    }
-
-    /**
-     * 通过文件获取图片的BotCode代码
-     * @param targetFile 图片文件
-     * @param updateCache 是否刷新缓存(只是让机器人重新上传, 如果上传接口有重复检测的话是无法处理的)
-     * @return 返回设定好参数的BotCode
-     */
-    private static BotCode getImageToBotCode(File targetFile, boolean updateCache) {
-        String fileName = Objects.requireNonNull(targetFile, "targetFile is null").getName();
-        BotCode code = BotCode.parse(CQCode.image(getImageStoreDir().getName() + "/" + fileName));
-        code.addParameter("absolutePath", targetFile.getAbsolutePath());
-        code.addParameter("imageName", fileName.substring(0, fileName.lastIndexOf(".")));
-        code.addParameter("updateCache", updateCache ? "true" : "false");
-        return code;
-    }
-
    static void clearCache() {
        log.warn("正在清除所有缓存...");
-        imageCache.clear();
-        illustInfoCache.clear();
-        illustPreLoadDataCache.clear();
-        pagesCache.clear();
-        searchBodyCache.clear();
+        CacheStoreCentral.clearCache();
        File imageStoreDir = new File(BotGlobal.getGlobal().getDataStoreDir(), "data/image/cgj/");
        File[] listFiles = imageStoreDir.listFiles();
        if (listFiles == null) {
@ -674,6 +477,16 @@ public class BotCommandProcess {
        log.warn("缓存删除完成.");
    }

+    @Command(commandName = "image")
+    public static String getImageById(
+            @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);
+    }
+
    /**
     * 举报某一作品
     * @param fromGroup 来源群(系统提供)
@ -717,176 +530,23 @@ public class BotCommandProcess {
     * @throws IOException 获取数据时发生异常时抛出
     * @throws NoSuchElementException 当作品不存在时抛出
     */
-    public static boolean isNoSafe(int illustId, Properties settingProp, boolean returnRaw) throws IOException, NoSuchElementException {
-        boolean rawValue = getIllustInfo(illustId, false).getAsJsonArray("tags").contains(new JsonPrimitive("R-18"));
-        return returnRaw || settingProp == null ? rawValue : rawValue && !settingProp.getProperty("image.allowR18", "false").equalsIgnoreCase("true");
-    }
-
-    /**
-     * 获取作品信息
-     * @param illustId 作品Id
-     * @param flushCache 强制刷新缓存
-     * @return 返回作品信息
-     * @throws IOException 当Http请求发生异常时抛出
-     * @throws NoSuchElementException 当作品未找到时抛出
-     */
-    private static JsonObject getIllustInfo(int illustId, boolean flushCache) throws IOException, NoSuchElementException {
-        String illustIdStr = buildSyncKey(Integer.toString(illustId));
-        JsonObject illustInfoObj = null;
-        if (!illustInfoCache.exists(illustIdStr) || flushCache) {
-            synchronized (illustIdStr) {
-                if (!illustInfoCache.exists(illustIdStr) || flushCache) {
-                    illustInfoObj = pixivDownload.getIllustInfoByIllustId(illustId);
-                    illustInfoCache.update(illustIdStr, illustInfoObj, null);
+    public static boolean isNoSafe(int illustId, Properties settingProp, boolean returnRaw)
+            throws IOException, NoSuchElementException {
+        JsonObject illustInfo = CacheStoreCentral.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");
+                if (current) {
+                    rawValue = true;
+                    break;
                }
            }
        }
-
-        if(Objects.isNull(illustInfoObj)) {
-            illustInfoObj = illustInfoCache.getCache(illustIdStr).getAsJsonObject();
-            log.debug("作品Id {} IllustInfo缓存命中.", illustId);
-        }
-        return illustInfoObj;
+        return returnRaw || settingProp == null ? rawValue :
+                rawValue && !settingProp.getProperty("image.allowR18", "false")
+                        .equalsIgnoreCase("true");
    }

-    /**
-     * 获取作品预加载数据.
-     * 可以获取作品的一些与用户相关的信息
-     * @param illustId 作品Id
-     * @param flushCache 是否刷新缓存
-     * @return 成功返回JsonObject对象
-     * @throws IOException 当Http请求处理发生异常时抛出
-     */
-    public static JsonObject getIllustPreLoadData(int illustId, boolean flushCache) throws IOException {
-        String illustIdStr = buildSyncKey(Integer.toString(illustId));
-        JsonObject result = null;
-        if (!illustPreLoadDataCache.exists(illustIdStr) || flushCache) {
-            synchronized (illustIdStr) {
-                if (!illustPreLoadDataCache.exists(illustIdStr) || flushCache) {
-                    log.debug("IllustId {} 缓存失效, 正在更新...", illustId);
-                    JsonObject preLoadDataObj = pixivDownload.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);
-                    }
-
-                    result = preLoadDataObj;
-                    illustPreLoadDataCache.update(illustIdStr, preLoadDataObj, expire);
-                    log.debug("作品Id {} preLoadData缓存已更新(有效时间: {})", illustId, expire);
-                }
-            }
-        }
-
-        if(Objects.isNull(result)) {
-            result = illustPreLoadDataCache.getCache(illustIdStr).getAsJsonObject();
-            log.debug("作品Id {} PreLoadData缓存命中.", illustId);
-        }
-        return result;
-    }
-
-    public static List<String> getIllustPages(int illustId, PixivDownload.PageQuality quality, boolean flushCache) throws IOException {
-        String pagesSign = buildSyncKey(Integer.toString(illustId), ".", quality.name());
-        List<String> result = null;
-        if (!pagesCache.exists(pagesSign) || flushCache) {
-            synchronized (pagesSign) {
-                if (!pagesCache.exists(pagesSign) || flushCache) {
-                    List<String> linkList = PixivDownload.getIllustAllPageDownload(pixivDownload.getHttpClient(), pixivDownload.getCookieStore(), illustId, quality);
-                    result = linkList;
-                    pagesCache.update(pagesSign, linkList, null);
-                }
-            }
-        }
-
-        if(Objects.isNull(result)) {
-            result = pagesCache.getCache(pagesSign);
-            log.debug("作品Id {} Pages缓存命中.", illustId);
-        }
-        return result;
-    }
-
-    /**
-     * 获取图片存储目录.
-     * <p>每次调用都会检查目录是否存在, 如不存在则会抛出异常</p>
-     * @return 返回File对象
-     * @throws RuntimeException 当目录创建失败时将包装{@link IOException}异常并抛出.
-     */
-    private static File getImageStoreDir() {
-        if(!imageStoreDir.exists() && !Files.isSymbolicLink(imageStoreDir.toPath())) {
-            if(!imageStoreDir.mkdirs()) {
-                log.warn("酷Q图片缓存目录失效！(Path: {} )", imageStoreDir.getAbsolutePath());
-                throw new RuntimeException(new IOException("文件夹创建失败!"));
-            }
-        }
-        return imageStoreDir;
-    }
-
-
-    private final static Random expireTimeFloatRandom = new Random();
-    /**
-     * 获取排行榜
-     * @param contentType 排行榜类型
-     * @param mode 排行榜模式
-     * @param queryDate 查询时间
-     * @param start 开始排名, 从1开始
-     * @param range 取范围
-     * @param flushCache 是否强制刷新缓存
-     * @return 成功返回有值List, 失败且无异常返回空
-     * @throws IOException 获取异常时抛出
-     */
-    public static List<JsonObject> getRankingInfoByCache(PixivURL.RankingContentType contentType, PixivURL.RankingMode mode, Date queryDate, int start, int range, boolean flushCache) throws IOException {
-        if(!contentType.isSupportedMode(mode)) {
-            log.warn("试图获取不支持的排行榜类型已拒绝.(ContentType: {}, RankingMode: {})", contentType.name(), mode.name());
-            if(log.isDebugEnabled()) {
-                try {
-                    Thread.dumpStack();
-                } catch(Exception e) {
-                    log.debug("本次非法请求的堆栈信息如下: \n{}", Throwables.getStackTraceAsString(e));
-                }
-            }
-            return new ArrayList<>(0);
-        }
-
-        String date = new SimpleDateFormat("yyyyMMdd").format(queryDate);
-        String requestSign = buildSyncKey(contentType.name(), ".", mode.name(), ".", date);
-        List<JsonObject> result = null;
-        if(!rankingCache.exists(requestSign) || flushCache) {
-            synchronized(requestSign) {
-                if(!rankingCache.exists(requestSign) || flushCache) {
-                    log.debug("Ranking缓存失效, 正在更新...(RequestSign: {})", requestSign);
-                    List<JsonObject> rankingResult = pixivDownload.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.debug("Ranking缓存更新完成.(RequestSign: {})", requestSign);
-                }
-            }
-        }
-
-        if (Objects.isNull(result)) {
-            result = rankingCache.getCache(requestSign, start - 1, range);
-            log.debug("RequestSign [{}] 缓存命中.", requestSign);
-        }
-        log.debug("Result-Length: {}", result.size());
-        return PixivDownload.getRanking(result, start - 1, range);
-    }
-
-    private static String buildSyncKey(String... keys) {
-        StringBuilder sb = new StringBuilder();
-        for (String string : keys) {
-            sb.append(string);
-        }
-        return sb.toString().intern();
-    }
 }
--- a/src/main/java/net/lamgc/cgj/bot/RandomRankingArtworksSender.java
+++ b/src/main/java/net/lamgc/cgj/bot/RandomRankingArtworksSender.java
@ -1,6 +1,7 @@
 package net.lamgc.cgj.bot;

 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;
@ -18,6 +19,7 @@ import java.util.Random;
 public class RandomRankingArtworksSender extends AutoSender {

    private final Logger log;
+    private final long groupId;
    private final int rankingStart;
    private final int rankingStop;
    private final PixivURL.RankingMode mode;
@ -34,8 +36,37 @@ public class RandomRankingArtworksSender extends AutoSender {
     * @param quality 图片质量, 详见{@link PixivDownload.PageQuality}
     * @throws IndexOutOfBoundsException 当 rankingStart > rankingStop时抛出
     */
-    public RandomRankingArtworksSender(MessageSender messageSender, int rankingStart, int rankingStop, PixivURL.RankingMode mode, PixivURL.RankingContentType contentType, PixivDownload.PageQuality quality) {
+    public RandomRankingArtworksSender(
+            MessageSender messageSender,
+            int rankingStart,
+            int rankingStop,
+            PixivURL.RankingMode mode,
+            PixivURL.RankingContentType contentType,
+            PixivDownload.PageQuality quality) {
+        this(messageSender, 0, rankingStart, rankingStop, mode, contentType, quality);
+    }
+
+    /**
+     * 构造一个推荐作品发送器
+     * @param messageSender 消息发送器
+     * @param groupId 群组Id, 如果发送目标为群组, 则可设置群组Id, 以使用群组配置.
+     * @param rankingStart 排行榜开始范围(从1开始, 名次)，如传入0或负数则为默认值，默认为1
+     * @param rankingStop 排名榜结束范围(包括该名次)，如传入0或负数则为默认值，默认为150
+     * @param mode 排行榜模式
+     * @param contentType 排行榜内容类型
+     * @param quality 图片质量, 详见{@link PixivDownload.PageQuality}
+     * @throws IndexOutOfBoundsException 当 rankingStart > rankingStop时抛出
+     */
+    public RandomRankingArtworksSender(
+            MessageSender messageSender,
+            long groupId,
+            int rankingStart,
+            int rankingStop,
+            PixivURL.RankingMode mode,
+            PixivURL.RankingContentType contentType,
+            PixivDownload.PageQuality quality) {
        super(messageSender);
+        this.groupId = groupId;
        this.mode = mode;
        this.contentType = contentType;
        log = LoggerFactory.getLogger(this.toString());
@ -61,7 +92,7 @@ public class RandomRankingArtworksSender extends AutoSender {

        int selectRanking = rankingStart + new Random().nextInt(rankingStop - rankingStart + 1);
        try {
-            List<JsonObject> rankingList = BotCommandProcess.getRankingInfoByCache(
+            List<JsonObject> rankingList = CacheStoreCentral.getRankingInfoByCache(
                    contentType,
                    mode,
                    queryDate,
@ -76,7 +107,8 @@ public class RandomRankingArtworksSender extends AutoSender {

            JsonObject rankingInfo = rankingList.get(0);
            int illustId = rankingInfo.get("illust_id").getAsInt();
-            if(BotCommandProcess.isNoSafe(illustId, SettingProperties.getProperties(SettingProperties.GLOBAL), false)) {
+            if(BotCommandProcess.isNoSafe(illustId,
+                    SettingProperties.getProperties(groupId), false)) {
                log.warn("作品为r18作品, 取消本次发送.");
                return;
            } else if(BotCommandProcess.isReported(illustId)) {
@ -84,13 +116,12 @@ public class RandomRankingArtworksSender extends AutoSender {
                return;
            }

-            StringBuilder message = new StringBuilder();
-            message.append("#美图推送 - 今日排行榜 第 ").append(rankingInfo.get("rank").getAsInt()).append(" 名\n");
-            message.append("标题：").append(rankingInfo.get("title").getAsString()).append("(").append(illustId).append(")\n");
-            message.append("作者：").append(rankingInfo.get("user_name").getAsString()).append("\n");
-            message.append(BotCommandProcess.getImageById(0, illustId, quality, 1));
-            message.append("\n如有不当作品，可使用\".cgj report -id ").append(illustId).append("\"向色图姬反馈。");
-            getMessageSender().sendMessage(message.toString());
+            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) +
+                    "\n如有不当作品，可使用\".cgj report -id " + illustId + "\"向色图姬反馈。";
+            getMessageSender().sendMessage(message);
        } catch (Exception e) {
            log.error("发送随机作品时发生异常", e);
        }
--- a/src/main/java/net/lamgc/cgj/bot/SettingProperties.java
+++ b/src/main/java/net/lamgc/cgj/bot/SettingProperties.java
@ -51,6 +51,10 @@ public final class SettingProperties {
            long groupId;
            try {
                groupId = Long.parseLong(name.substring(name.indexOf("group.") + 6, name.lastIndexOf(".properties")));
+                if(groupId <= 0) {
+                    log.warn("无效的群配置文件: {}", groupId);
+                    continue;
+                }
            } catch (NumberFormatException e) {
                log.error("非法的配置文件名: {}", name);
                continue;
@ -233,7 +237,7 @@ public final class SettingProperties {
     * @return 如果群组存在所属Properties, 则返回群组Properties, 否则返回GlobalProperties.
     */
    public static Properties getProperties(long groupId) {
-        if(groupPropMap.containsKey(groupId)) {
+        if(groupId > 0 && groupPropMap.containsKey(groupId)) {
            return groupPropMap.get(groupId);
        }
        return getGlobalProperties();
--- a/src/main/java/net/lamgc/cgj/bot/boot/BotGlobal.java
+++ b/src/main/java/net/lamgc/cgj/bot/boot/BotGlobal.java
@ -1,16 +1,23 @@
 package net.lamgc.cgj.bot.boot;

 import com.google.common.base.Strings;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import net.lamgc.cgj.pixiv.PixivDownload;
 import org.apache.http.HttpHost;
 import org.apache.http.client.CookieStore;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import redis.clients.jedis.Jedis;
 import redis.clients.jedis.JedisPool;
+import redis.clients.jedis.exceptions.JedisConnectionException;

 import java.io.File;
+import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URL;
+import java.nio.file.Files;

 public final class BotGlobal {

@ -38,15 +45,31 @@ public final class BotGlobal {

    private CookieStore cookieStore;

+    private final Gson gson = new GsonBuilder()
+            .serializeNulls()
+            .create();
+
+    private PixivDownload pixivDownload;
+
+    private final File imageStoreDir;
+
    private BotGlobal() {
        this.redisUri = URI.create("redis://" + System.getProperty("cgj.redisAddress"));
        this.redisServer = new JedisPool(
                getRedisUri().getHost(),
                getRedisUri().getPort() == -1 ? 6379 : getRedisUri().getPort());
+        try (Jedis jedis = this.redisServer.getResource()) {
+            log.warn("Redis连接状态(Ping): {}", jedis.ping().equalsIgnoreCase("pong"));
+        } catch(JedisConnectionException e) {
+            log.warn("Redis连接失败, 将会影响到后续功能运行.", e);
+        }
+
        String dataStoreDirPath = System.getProperty("cgj.botDataDir");
        this.dataStoreDir = new File((!dataStoreDirPath.endsWith("/") || !dataStoreDirPath.endsWith("\\")) ?
                dataStoreDirPath + System.getProperty("file.separator") : dataStoreDirPath);

+        this.imageStoreDir = new File(getDataStoreDir(), "data/image/cgj/");
+
        String proxyAddress = System.getProperty("cgj.proxy");
        HttpHost temp = null;
        if(!Strings.isNullOrEmpty(proxyAddress)) {
@ -80,12 +103,30 @@ public final class BotGlobal {
        return proxy;
    }

-
-    public CookieStore getCookieStore() {
-        return cookieStore;
+    public void setCookieStore(CookieStore cookieStore) {
+        if(this.cookieStore != null) {
+            throw new IllegalStateException("CookieStore set");
+        }
+        this.cookieStore = cookieStore;
+        this.pixivDownload =
+                new PixivDownload(cookieStore, proxy);
    }

-    public void setCookieStore(CookieStore cookieStore) {
-        this.cookieStore = cookieStore;
+    public Gson getGson() {
+        return gson;
+    }
+
+    public PixivDownload getPixivDownload() {
+        return pixivDownload;
+    }
+
+    public File getImageStoreDir() {
+        if(!imageStoreDir.exists() && !Files.isSymbolicLink(imageStoreDir.toPath())) {
+            if(!imageStoreDir.mkdirs()) {
+                log.warn("酷Q图片缓存目录失效！(Path: {} )", imageStoreDir.getAbsolutePath());
+                throw new RuntimeException(new IOException("文件夹创建失败!"));
+            }
+        }
+        return imageStoreDir;
    }
 }
--- a/src/main/java/net/lamgc/cgj/bot/cache/CacheStore.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/CacheStore.java
@ -13,7 +13,7 @@ public interface CacheStore<T> {
     * 更新或添加缓存项
     * @param key 缓存键名
     * @param value 缓存值
-     * @param expire 有效期, 单位为ms(毫秒), 如不过期传入0或赋值
+     * @param expire 有效期, 单位为ms(毫秒), 如不过期传入0或负数
     */
    void update(String key, T value, long expire);

--- a/src/main/java/net/lamgc/cgj/bot/cache/CacheStoreCentral.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/CacheStoreCentral.java
@ -0,0 +1,632 @@
+package net.lamgc.cgj.bot.cache;
+
+import com.google.common.base.Strings;
+import com.google.common.base.Throwables;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+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.pixiv.PixivDownload;
+import net.lamgc.cgj.pixiv.PixivSearchBuilder;
+import net.lamgc.cgj.pixiv.PixivURL;
+import net.lamgc.cgj.util.URLs;
+import net.lamgc.utils.encrypt.MessageDigestUtils;
+import net.lz1998.cq.utils.CQCode;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.util.EntityUtils;
+import org.apache.tomcat.util.http.fileupload.IOUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.text.SimpleDateFormat;
+import java.util.*;
+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 final static JsonRedisCacheStore imageChecksumCache =
+            new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(),
+                    "imageChecksum", BotGlobal.getGlobal().getGson());
+
+    /**
+     * 作品信息缓存 - 不过期
+     */
+    private final static CacheStore<JsonElement> illustInfoCache =
+            new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(),
+                    "illustInfo", BotGlobal.getGlobal().getGson());
+
+    /**
+     * 作品信息预加载数据 - 有效期 2 小时, 本地缓存有效期1 ± 0.25
+     */
+    private final static CacheStore<JsonElement> illustPreLoadDataCache =
+            CacheStoreUtils.hashLocalHotDataStore(
+                    new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(),
+                            "illustPreLoadData", BotGlobal.getGlobal().getGson()),
+                    3600000, 900000);
+    /**
+     * 搜索内容缓存, 有效期 2 小时
+     */
+    private final static CacheStore<JsonElement> searchBodyCache =
+            new JsonRedisCacheStore(BotGlobal.getGlobal().getRedisServer(),
+                    "searchBody", BotGlobal.getGlobal().getGson());
+
+    /**
+     * 排行榜缓存, 不过期
+     */
+    private final static CacheStore<List<JsonObject>> rankingCache =
+            new JsonObjectRedisListCacheStore(BotGlobal.getGlobal().getRedisServer(),
+                    "ranking", BotGlobal.getGlobal().getGson());
+
+    /**
+     * 作品页面下载链接缓存 - 不过期
+     */
+    private final static CacheStore<List<String>> pagesCache =
+            new StringListRedisCacheStore(BotGlobal.getGlobal().getRedisServer(), "imagePages");
+
+    /**
+     * 清空所有缓存
+     */
+    public static void clearCache() {
+        imageCache.clear();
+        illustInfoCache.clear();
+        illustPreLoadDataCache.clear();
+        searchBodyCache.clear();
+        rankingCache.clear();
+        pagesCache.clear();
+    }
+
+    /**
+     * 通过illustId获取作品图片
+     * @param fromGroup 来源群(系统提供)
+     * @param illustId 作品Id
+     * @param quality 图片质量
+     * @param pageIndex 指定页面索引, 从1开始
+     * @return 如果成功, 返回BotCode, 否则返回错误信息.
+     */
+    public static String getImageById(long fromGroup, int illustId, PixivDownload.PageQuality quality, int pageIndex) {
+        log.debug("IllustId: {}, Quality: {}, PageIndex: {}", illustId, quality.name(), pageIndex);
+        if(pageIndex <= 0) {
+            log.warn("指定的页数不能小于或等于0: {}", pageIndex);
+            return "指定的页数不能小于或等于0！";
+        }
+
+        try {
+            if (BotCommandProcess.isNoSafe(illustId, SettingProperties.getProperties(fromGroup), false)) {
+                log.warn("作品 {} 存在R-18内容且设置\"image.allowR18\"为false，将屏蔽该作品不发送.", illustId);
+                return "（根据设置，该作品已被屏蔽！）";
+            } else if(BotCommandProcess.isReported(illustId)) {
+                log.warn("作品Id {} 被报告, 正在等待审核, 跳过该作品.", illustId);
+                return "（该作品已被封印）";
+            }
+        } catch (IOException e) {
+            log.warn("作品信息无法获取!", e);
+            return "（发生网络异常，无法获取图片！）";
+        }
+
+        List<String> pagesList;
+        try {
+            pagesList = CacheStoreCentral.getIllustPages(illustId, quality, false);
+        } catch (IOException e) {
+            log.error("获取下载链接列表时发生异常", e);
+            return "发生网络异常，无法获取图片！";
+        }
+
+        if(log.isDebugEnabled()) {
+            StringBuilder logBuilder = new StringBuilder("作品Id " + illustId + " 所有页面下载链接: \n");
+            AtomicInteger index = new AtomicInteger();
+            pagesList.forEach(item ->
+                    logBuilder.append(index.incrementAndGet()).append(". ").append(item).append("\n"));
+            log.debug(logBuilder.toString());
+        }
+
+        if (pagesList.size() < pageIndex) {
+            log.warn("指定的页数超出了总页数({} / {})", pageIndex, pagesList.size());
+            return "指定的页数超出了范围(总共 " + pagesList.size() + " 页)";
+        }
+
+        String downloadLink = pagesList.get(pageIndex - 1);
+        String fileName = URLs.getResourceName(Strings.nullToEmpty(downloadLink));
+        File imageFile = new File(BotGlobal.getGlobal().getImageStoreDir(),
+                downloadLink.substring(downloadLink.lastIndexOf("/") + 1));
+        log.debug("FileName: {}, DownloadLink: {}", fileName, downloadLink);
+        if(!imageCache.containsKey(fileName)) {
+            if(imageFile.exists() && imageFile.isFile()) {
+                ImageChecksum imageChecksum = getImageChecksum(illustId, pageIndex);
+                if(imageChecksum != null) {
+                    try {
+                        log.debug("正在检查作品Id {} 第 {} 页图片文件 {} ...", illustId, pageIndex, imageFile.getName());
+                        if (ImageChecksum.checkFile(imageChecksum, Files.readAllBytes(imageFile.toPath()))) {
+                            imageCache.put(URLs.getResourceName(downloadLink), imageFile);
+                            log.debug("作品Id {} 第 {} 页缓存已补充.", illustId, pageIndex);
+                            return getImageToBotCode(imageFile, false).toString();
+                        } else {
+                            log.warn("图片文件 {} 校验失败, 重新下载图片...", imageFile.getName());
+                        }
+                    } catch(IOException e) {
+                        log.error("文件检验时读取失败, 重新下载文件...(file: {})", imageFile.getPath());
+                    }
+                } else {
+                    log.warn("图片存在但校验不存在, 重新下载图片...");
+                }
+            }
+
+            try {
+                Throwable throwable = ImageCacheStore.executeCacheRequest(
+                        new ImageCacheObject(imageCache, illustId, pageIndex, downloadLink, imageFile));
+                if(throwable != null) {
+                    throw throwable;
+                }
+            } catch (InterruptedException e) {
+                log.warn("图片缓存被中断", e);
+                return "(错误：图片获取超时)";
+            } catch (Throwable e) {
+                log.error("图片 {} 获取失败:\n{}", illustId + "p" + pageIndex, Throwables.getStackTraceAsString(e));
+                return "(错误: 图片获取出错)";
+            }
+        } else {
+            log.debug("图片 {} 缓存命中.", fileName);
+        }
+
+        return getImageToBotCode(imageCache.get(fileName), false).toString();
+    }
+
+    /**
+     * 通过文件获取图片的BotCode代码
+     * @param targetFile 图片文件
+     * @param updateCache 是否刷新缓存(只是让机器人重新上传, 如果上传接口有重复检测的话是无法处理的)
+     * @return 返回设定好参数的BotCode
+     */
+    @SuppressWarnings("SameParameterValue")
+    private static 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));
+        code.addParameter("absolutePath", targetFile.getAbsolutePath());
+        code.addParameter("imageName", fileName.substring(0, fileName.lastIndexOf(".")));
+        code.addParameter("updateCache", updateCache ? "true" : "false");
+        return code;
+    }
+
+    /**
+     * 获取作品信息
+     * @param illustId 作品Id
+     * @param flushCache 强制刷新缓存
+     * @return 返回作品信息
+     * @throws IOException 当Http请求发生异常时抛出
+     * @throws NoSuchElementException 当作品未找到时抛出
+     */
+    public static JsonObject getIllustInfo(int illustId, boolean flushCache)
+            throws IOException, NoSuchElementException {
+        String illustIdStr = buildSyncKey(Integer.toString(illustId));
+        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);
+                }
+            }
+        }
+
+        if(Objects.isNull(illustInfoObj)) {
+            illustInfoObj = illustInfoCache.getCache(illustIdStr).getAsJsonObject();
+            log.debug("作品Id {} IllustInfo缓存命中.", illustId);
+        }
+        return illustInfoObj;
+    }
+
+    /**
+     * 获取作品预加载数据.
+     * 可以获取作品的一些与用户相关的信息
+     * @param illustId 作品Id
+     * @param flushCache 是否刷新缓存
+     * @return 成功返回JsonObject对象
+     * @throws IOException 当Http请求处理发生异常时抛出
+     */
+    public static JsonObject getIllustPreLoadData(int illustId, boolean flushCache) throws IOException {
+        String illustIdStr = buildSyncKey(Integer.toString(illustId));
+        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));
+
+                    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.debug("作品Id {} preLoadData缓存已更新(有效时间: {})", illustId, expire);
+                }
+            }
+        }
+
+        if(Objects.isNull(result)) {
+            result = illustPreLoadDataCache.getCache(illustIdStr).getAsJsonObject();
+            log.debug("作品Id {} PreLoadData缓存命中.", illustId);
+        }
+        return result;
+    }
+
+    public static List<String> getIllustPages(int illustId, PixivDownload.PageQuality quality, boolean flushCache)
+            throws IOException {
+        String pagesSign = buildSyncKey(Integer.toString(illustId), ".", quality.name());
+        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);
+                }
+            }
+        }
+
+        if(Objects.isNull(result)) {
+            result = pagesCache.getCache(pagesSign);
+            log.debug("作品Id {} Pages缓存命中.", illustId);
+        }
+        return result;
+    }
+
+    private final static Random expireTimeFloatRandom = new Random();
+    /**
+     * 获取排行榜
+     * @param contentType 排行榜类型
+     * @param mode 排行榜模式
+     * @param queryDate 查询时间
+     * @param start 开始排名, 从1开始
+     * @param range 取范围
+     * @param flushCache 是否强制刷新缓存
+     * @return 成功返回有值List, 失败且无异常返回空
+     * @throws IOException 获取异常时抛出
+     */
+    public static List<JsonObject> getRankingInfoByCache(PixivURL.RankingContentType contentType,
+                                                         PixivURL.RankingMode mode,
+                                                         Date queryDate, int start, int range, boolean flushCache)
+            throws IOException {
+        if(!contentType.isSupportedMode(mode)) {
+            log.warn("试图获取不支持的排行榜类型已拒绝.(ContentType: {}, RankingMode: {})", contentType.name(), mode.name());
+            if(log.isDebugEnabled()) {
+                try {
+                    Thread.dumpStack();
+                } catch(Exception e) {
+                    log.debug("本次非法请求的堆栈信息如下: \n{}", Throwables.getStackTraceAsString(e));
+                }
+            }
+            return new ArrayList<>(0);
+        }
+
+        String date = new SimpleDateFormat("yyyyMMdd").format(queryDate);
+        String requestSign = buildSyncKey(contentType.name(), ".", mode.name(), ".", date);
+        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);
+                    }
+                    result = new ArrayList<>(rankingResult).subList(start - 1, start + range - 1);
+                    rankingCache.update(requestSign, rankingResult, expireTime);
+                    log.debug("Ranking缓存更新完成.(RequestSign: {})", requestSign);
+                }
+            }
+        }
+
+        if (Objects.isNull(result)) {
+            result = rankingCache.getCache(requestSign, start - 1, range);
+            log.debug("RequestSign [{}] 缓存命中.", requestSign);
+        }
+        log.debug("Result-Length: {}", result.size());
+        return PixivDownload.getRanking(result, start - 1, range);
+    }
+
+    /**
+     * 获取搜索结果
+     * @param content 搜索内容
+     * @param type 类型
+     * @param area 范围
+     * @param includeKeywords 包含关键词
+     * @param excludeKeywords 排除关键词
+     * @param contentOption 内容类型
+     * @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();
+        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);
+
+                    String responseBody = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
+                    log.debug("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());
+                    }
+
+                    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("搜索缓存命中.");
+                }
+            }
+        } else {
+            log.debug("搜索缓存命中.");
+        }
+
+        if(Objects.isNull(resultBody)) {
+            resultBody = searchBodyCache.getCache(requestUrl).getAsJsonObject().getAsJsonObject("body");
+        }
+        return resultBody;
+    }
+
+    protected static ImageChecksum getImageChecksum(int illustId, int pageIndex) {
+        String cacheKey = illustId + ":" + pageIndex;
+        if(!imageChecksumCache.exists(cacheKey)) {
+            return null;
+        } else {
+            return ImageChecksum.fromJsonObject(imageChecksumCache.getCache(cacheKey).getAsJsonObject());
+        }
+    }
+
+    protected static void setImageChecksum(ImageChecksum checksum) {
+        String cacheKey = checksum.getIllustId() + ":" + checksum.getPage();
+        imageChecksumCache.update(cacheKey, ImageChecksum.toJsonObject(checksum), 0);
+    }
+
+    /**
+     * 合并String并存取到常量池, 以保证对象一致
+     * @param keys String对象
+     * @return 合并后, 如果常量池存在合并后的结果, 则返回常量池中的对象, 否则存入常量池后返回.
+     */
+    private static String buildSyncKey(String... keys) {
+        StringBuilder sb = new StringBuilder();
+        for (String string : keys) {
+            sb.append(string);
+        }
+        return sb.toString().intern();
+    }
+
+    /**
+     * 图片检验信息
+     */
+    public static class ImageChecksum implements Serializable {
+        
+        private final static MessageDigestUtils.Algorithm ALGORITHM = MessageDigestUtils.Algorithm.SHA256;
+
+        private ImageChecksum() {}
+        
+        private int illustId;
+
+        private int page;
+
+        private String fileName;
+
+        private long size;
+
+        private byte[] checksum;
+
+        public long getSize() {
+            return size;
+        }
+
+        public void setSize(long size) {
+            this.size = size;
+        }
+
+        public byte[] getChecksum() {
+            return checksum;
+        }
+
+        public void setChecksum(byte[] checksum) {
+            this.checksum = checksum;
+        }
+
+        public int getIllustId() {
+            return illustId;
+        }
+
+        public void setIllustId(int illustId) {
+            this.illustId = illustId;
+        }
+
+        public String getFileName() {
+            return fileName;
+        }
+
+        public void setFileName(String fileName) {
+            this.fileName = fileName;
+        }
+
+        public int getPage() {
+            return page;
+        }
+
+        public void setPage(int page) {
+            this.page = page;
+        }
+
+        public static ImageChecksum buildImageChecksumFromStream(
+                int illustId, int pageIndex,
+                String fileName, InputStream imageStream) throws IOException {
+            ImageChecksum checksum = new ImageChecksum();
+            checksum.setIllustId(illustId);
+            checksum.setPage(pageIndex);
+            checksum.setFileName(fileName);
+            ByteArrayOutputStream bufferStream = new ByteArrayOutputStream();
+            checksum.setSize(IOUtils.copyLarge(imageStream, bufferStream));
+            checksum.setChecksum(
+                    MessageDigestUtils.encrypt(bufferStream.toByteArray(), ALGORITHM));
+            return checksum;
+        }
+
+        /**
+         * 将图片检验信息转换成JsonObject
+         * @param checksum 检验信息对象
+         * @return 转换后的JsonObject对象
+         */
+        public static JsonObject toJsonObject(ImageChecksum checksum) {
+            JsonObject result = new JsonObject();
+            result.addProperty("illustId", checksum.getIllustId());
+            result.addProperty("page", checksum.getPage());
+            result.addProperty("fileName", checksum.getFileName());
+            result.addProperty("size", checksum.getSize());
+            result.addProperty("checksum", Base64.getEncoder().encodeToString(checksum.getChecksum()));
+            return result;
+        }
+
+        /**
+         * 从JsonObject转换到图片检验信息
+         * @param checksumObject JsonObject对象
+         * @return 转换后的图片检验信息对象
+         */
+        public static ImageChecksum fromJsonObject(JsonObject checksumObject) {
+            ImageChecksum checksum = new ImageChecksum();
+            checksum.setIllustId(checksumObject.get("illustId").getAsInt());
+            checksum.setPage(checksumObject.get("page").getAsInt());
+            checksum.setFileName(checksumObject.get("fileName").getAsString());
+            checksum.setSize(checksumObject.get("size").getAsLong());
+            checksum.setChecksum(Base64.getDecoder().decode(checksumObject.get("checksum").getAsString()));
+            return checksum;
+        }
+
+        /**
+         * 比对图片文件是否完整.
+         * @param checksum 图片检验信息
+         * @param imageData 图片数据
+         * @return 如果检验成功, 则返回true
+         */
+        public static boolean checkFile(ImageChecksum checksum, byte[] imageData) {
+            byte[] sha256Checksum = MessageDigestUtils.encrypt(imageData, ALGORITHM);
+            return checksum.getSize() == imageData.length &&
+                   Arrays.equals(checksum.getChecksum(), sha256Checksum);
+        }
+
+        @Override
+        public String toString() {
+            return "ImageChecksum{" +
+                    "illustId=" + illustId +
+                    ", page=" + page +
+                    ", fileName='" + fileName + '\'' +
+                    ", size=" + size +
+                    ", checksum=" + Base64.getEncoder().encodeToString(getChecksum()) +
+                    '}';
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            ImageChecksum checksum1 = (ImageChecksum) o;
+            return illustId == checksum1.illustId &&
+                    page == checksum1.page &&
+                    size == checksum1.size &&
+                    Objects.equals(fileName, checksum1.fileName) &&
+                    Arrays.equals(checksum, checksum1.checksum);
+        }
+
+        @Override
+        public int hashCode() {
+            int result = Objects.hash(illustId, page, fileName, size);
+            result = 31 * result + Arrays.hashCode(checksum);
+            return result;
+        }
+    }
+}
--- a/src/main/java/net/lamgc/cgj/bot/cache/HotDataCacheStore.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/HotDataCacheStore.java
@ -39,7 +39,7 @@ public class HotDataCacheStore<T> implements CacheStore<T>, Cleanable {
            AutoCleanTimer.add(this);
        }

-        log.debug("HotDataCacheStore初始化完成. " +
+        log.trace("HotDataCacheStore初始化完成. " +
                        "(Parent: {}, Current: {}, expireTime: {}, expireFloatRange: {}, autoClean: {})",
                parent, current, expireTime, expireFloatRange, autoClean);
    }
@ -58,24 +58,24 @@ public class HotDataCacheStore<T> implements CacheStore<T>, Cleanable {
    @Override
    public T getCache(String key) {
        if(!exists(key)) {
-            log.debug("查询缓存键名不存在, 直接返回null.");
+            log.trace("查询缓存键名不存在, 直接返回null.");
            return null;
        }
        T result = current.getCache(key);
        if(Objects.isNull(result)) {
-            log.debug("Current缓存库未命中, 查询Parent缓存库");
+            log.trace("Current缓存库未命中, 查询Parent缓存库");
            T parentResult = parent.getCache(key);
            if(Objects.isNull(parentResult)) {
-                log.debug("Parent缓存库未命中, 缓存不存在");
+                log.trace("Parent缓存库未命中, 缓存不存在");
                return null;
            }
-            log.debug("Parent缓存命中, 正在更新Current缓存库...");
+            log.trace("Parent缓存命中, 正在更新Current缓存库...");
            current.update(key, parentResult,
                    expireTime + (expireFloatRange <= 0 ? 0 : random.nextInt(expireFloatRange)));
-            log.debug("Current缓存库更新完成.");
+            log.trace("Current缓存库更新完成.");
            result = parentResult;
        } else {
-            log.debug("Current缓存库缓存命中.");
+            log.trace("Current缓存库缓存命中.");
        }
        return result;
    }
--- a/src/main/java/net/lamgc/cgj/bot/cache/ImageCacheHandler.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/ImageCacheHandler.java
@ -13,9 +13,7 @@ import org.apache.http.impl.client.HttpClientBuilder;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
+import java.io.*;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
@ -69,8 +67,20 @@ public class ImageCacheHandler implements EventHandler {
            }

            log.debug("正在下载...(Content-Length: {}KB)", response.getEntity().getContentLength() / 1024);
-            try(FileOutputStream fos = new FileOutputStream(storeFile)) {
-                IOUtils.copy(response.getEntity().getContent(), fos);
+            ByteArrayOutputStream bufferOutputStream = new ByteArrayOutputStream();
+            try(FileOutputStream fileOutputStream = new FileOutputStream(storeFile)) {
+                IOUtils.copy(response.getEntity().getContent(), bufferOutputStream);
+                ByteArrayInputStream bufferInputStream = new ByteArrayInputStream(bufferOutputStream.toByteArray());
+                CacheStoreCentral.ImageChecksum imageChecksum = CacheStoreCentral.ImageChecksum
+                        .buildImageChecksumFromStream(
+                                event.getIllustId(),
+                                event.getPageIndex(),
+                                event.getStoreFile().getName(),
+                                bufferInputStream
+                            );
+                bufferInputStream.reset();
+                IOUtils.copy(bufferInputStream, fileOutputStream);
+                CacheStoreCentral.setImageChecksum(imageChecksum);
            } catch (IOException e) {
                log.error("下载图片时发生异常", e);
                throw e;
--- a/src/main/java/net/lamgc/cgj/bot/cache/ImageCacheObject.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/ImageCacheObject.java
@ -12,13 +12,16 @@ public class ImageCacheObject implements EventObject {

    private final int illustId;

+    private final int pageIndex;
+
    private final String downloadLink;

    private final File storeFile;

-    public ImageCacheObject(Map<String, File> imageCache, int illustId, String downloadLink, File storeFile) {
+    public ImageCacheObject(Map<String, File> imageCache, int illustId, int pageIndex, String downloadLink, File storeFile) {
        this.imageCache = imageCache;
        this.illustId = illustId;
+        this.pageIndex = pageIndex;
        this.downloadLink = downloadLink;
        this.storeFile = storeFile;
    }
@ -39,12 +42,17 @@ public class ImageCacheObject implements EventObject {
        return illustId;
    }

+    public int getPageIndex() {
+        return pageIndex;
+    }
+
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ImageCacheObject that = (ImageCacheObject) o;
        return illustId == that.illustId &&
+                pageIndex == that.pageIndex &&
                Objects.equals(imageCache, that.imageCache) &&
                Objects.equals(downloadLink, that.downloadLink) &&
                Objects.equals(storeFile, that.storeFile);
@ -52,13 +60,15 @@ public class ImageCacheObject implements EventObject {

    @Override
    public int hashCode() {
-        return Objects.hash(imageCache, illustId, downloadLink, storeFile);
+        return Objects.hash(imageCache, illustId, pageIndex, downloadLink, storeFile);
    }

    @Override
    public String toString() {
-        return "ImageCacheObject@" + Integer.toHexString(hashCode()) + "{" +
-                "illustId=" + illustId +
+        return "ImageCacheObject{" +
+                "imageCache=" + imageCache +
+                ", illustId=" + illustId +
+                ", pageIndex=" + pageIndex +
                ", downloadLink='" + downloadLink + '\'' +
                ", storeFile=" + storeFile +
                '}';
--- a/src/main/java/net/lamgc/cgj/bot/event/BotEventHandler.java
+++ b/src/main/java/net/lamgc/cgj/bot/event/BotEventHandler.java
@ -64,14 +64,13 @@ public class BotEventHandler implements EventHandler {
     */
    public synchronized static void initial() {
        if(initialled) {
-            Logger logger = LoggerFactory.getLogger("BotEventHandler@<init>");
-            logger.warn("BotEventHandler已经执行过初始化方法, 可能存在多次执行的问题, 堆栈信息: \n {}",
+            log.warn("BotEventHandler已经执行过初始化方法, 可能存在多次执行的问题, 堆栈信息: \n {}",
                    Throwables.getStackTraceAsString(new Exception()));
            return;
        }

        executor.setEventUncaughtExceptionHandler(new EventUncaughtExceptionHandler() {
-            private final Logger log = LoggerFactory.getLogger("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{}",
@ -88,7 +87,7 @@ public class BotEventHandler implements EventHandler {
            shutdownThread.setName("Thread-EventHandlerShutdown");
            Runtime.getRuntime().addShutdownHook(shutdownThread);
        } catch (IllegalAccessException e) {
-            LoggerFactory.getLogger("BotEventHandler@Static").error("添加Handler时发生异常", e);
+            log.error("添加Handler时发生异常", e);
        }

        try {
@ -120,20 +119,38 @@ public class BotEventHandler implements EventHandler {
     */
    @NotAccepted
    public static void executeMessageEvent(MessageEvent event) {
+        try {
+            executeMessageEvent(event, false);
+        } catch (InterruptedException e) {
+            log.error("执行时发生异常", e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * 投递消息事件
+     * @param event 事件对象
+     */
+    @NotAccepted
+    public static void executeMessageEvent(MessageEvent event, boolean sync) throws InterruptedException {
        String debuggerName = SettingProperties.getProperty(0, "debug.debugger");
        if(!event.getMessage().startsWith(ADMIN_COMMAND_PREFIX) &&
                !Strings.isNullOrEmpty(debuggerName)) {
            try {
                MessageEventExecutionDebugger debugger = MessageEventExecutionDebugger.valueOf(debuggerName.toUpperCase());
                debugger.debugger.accept(executor, event, SettingProperties.getProperties(SettingProperties.GLOBAL),
-                                MessageEventExecutionDebugger.getDebuggerLogger(debugger));
+                        MessageEventExecutionDebugger.getDebuggerLogger(debugger));
            } catch(IllegalArgumentException e) {
                log.warn("未找到指定调试器: '{}'", debuggerName);
            } catch (Exception e) {
                log.error("事件调试处理时发生异常", e);
            }
        } else {
-            BotEventHandler.executor.executor(event);
+            if(sync) {
+                BotEventHandler.executor.executorSync(event);
+            } else {
+                BotEventHandler.executor.executor(event);
+            }
        }
    }

--- a/src/main/java/net/lamgc/cgj/bot/framework/cli/ConsoleMain.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/cli/ConsoleMain.java
@ -2,19 +2,36 @@ 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.cli.message.ConsoleMessageEvent;
+import net.lamgc.cgj.bot.framework.cli.message.ConsoleMessageSenderFactory;
 import net.lamgc.cgj.bot.message.MessageSenderBuilder;
+import org.jline.reader.LineReader;
+import org.jline.reader.LineReaderBuilder;
+import org.jline.reader.impl.history.DefaultHistory;
+import org.jline.terminal.TerminalBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;

-import java.util.Scanner;
+import java.io.IOException;

 public class ConsoleMain {

-    public static void start() {
+    private final static Logger log = LoggerFactory.getLogger(ConsoleMain.class);
+
+    public static void start() throws IOException {
        MessageSenderBuilder.setCurrentMessageSenderFactory(new ConsoleMessageSenderFactory());
        ApplicationBoot.initialBot();
-        Scanner scanner = new Scanner(System.in);
+        LineReader lineReader = LineReaderBuilder.builder()
+                .appName("CGJ")
+                .history(new DefaultHistory())
+                .terminal(TerminalBuilder.terminal())
+                .build();
+
+        long qqId = Long.parseLong(lineReader.readLine("会话QQ: "));
+        long groupId = Long.parseLong(lineReader.readLine("会话群组号:"));
        boolean isGroup = false;
        do {
-            String input = scanner.nextLine();
+            String input = lineReader.readLine("App " + qqId + (isGroup ? "@" + groupId : "$private") + " >");
            if(input.equalsIgnoreCase("#exit")) {
                System.out.println("退出应用...");
                break;
@ -23,7 +40,11 @@ public class ConsoleMain {
                System.out.println("System: 群模式状态已变更: " + isGroup);
                continue;
            }
-            BotEventHandler.executeMessageEvent(new ConsoleMessageEvent(input, isGroup));
+            try {
+                BotEventHandler.executeMessageEvent(new ConsoleMessageEvent(isGroup ? groupId : 0, qqId, input), true);
+            } catch (InterruptedException e) {
+                log.error("执行时发生中断", e);
+            }
        } while(true);
    }

--- a/src/main/java/net/lamgc/cgj/bot/framework/cli/message/ConsoleMessageEvent.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/cli/message/ConsoleMessageEvent.java
@ -1,4 +1,4 @@
-package net.lamgc.cgj.bot.framework.cli;
+package net.lamgc.cgj.bot.framework.cli.message;

 import net.lamgc.cgj.bot.event.MessageEvent;

@ -6,8 +6,8 @@ import java.util.Date;

 public class ConsoleMessageEvent extends MessageEvent {

-    public ConsoleMessageEvent(String message, boolean isGroup) {
-        super(isGroup ? 1 : 0, 1, message);
+    public ConsoleMessageEvent(long groupId, long qqId, String message) {
+        super(groupId, qqId, message);
    }

    @Override
--- a/src/main/java/net/lamgc/cgj/bot/framework/cli/message/ConsoleMessageSender.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/cli/message/ConsoleMessageSender.java
@ -1,4 +1,4 @@
-package net.lamgc.cgj.bot.framework.cli;
+package net.lamgc.cgj.bot.framework.cli.message;

 import net.lamgc.cgj.bot.message.MessageSender;

--- a/src/main/java/net/lamgc/cgj/bot/framework/cli/message/ConsoleMessageSenderFactory.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/cli/message/ConsoleMessageSenderFactory.java
@ -1,4 +1,4 @@
-package net.lamgc.cgj.bot.framework.cli;
+package net.lamgc.cgj.bot.framework.cli.message;

 import net.lamgc.cgj.bot.message.MessageSender;
 import net.lamgc.cgj.bot.message.MessageSenderFactory;
--- a/src/main/java/net/lamgc/cgj/bot/framework/mirai/MiraiMain.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/mirai/MiraiMain.java
@ -4,15 +4,19 @@ 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.mirai.message.MiraiMessageEvent;
-import net.lamgc.cgj.bot.message.MessageSenderBuilder;
 import net.lamgc.cgj.bot.framework.mirai.message.MiraiMessageSenderFactory;
+import net.lamgc.cgj.bot.message.MessageSenderBuilder;
 import net.mamoe.mirai.Bot;
 import net.mamoe.mirai.BotFactoryJvm;
 import net.mamoe.mirai.event.events.BotMuteEvent;
 import net.mamoe.mirai.event.events.BotUnmuteEvent;
 import net.mamoe.mirai.japt.Events;
-import net.mamoe.mirai.message.*;
+import net.mamoe.mirai.message.FriendMessageEvent;
+import net.mamoe.mirai.message.GroupMessageEvent;
+import net.mamoe.mirai.message.MessageEvent;
+import net.mamoe.mirai.message.TempMessageEvent;
 import net.mamoe.mirai.utils.BotConfiguration;
+import net.mamoe.mirai.utils.Utils;
 import org.apache.commons.net.util.Base64;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@ -45,6 +49,7 @@ public class MiraiMain implements Closeable {
            return;
        }

+        Utils.setDefaultLogger(MiraiToSlf4jLoggerAdapter::new);
        BotConfiguration configuration = new BotConfiguration();
        configuration.setProtocol(BotConfiguration.MiraiProtocol.ANDROID_PAD);
        bot = BotFactoryJvm.newBot(Long.parseLong(botProperties.getProperty("bot.qq", "0")), Base64.decodeBase64(botProperties.getProperty("bot.password", "")), configuration);
--- a/src/main/java/net/lamgc/cgj/bot/framework/mirai/MiraiToSlf4jLoggerAdapter.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/mirai/MiraiToSlf4jLoggerAdapter.java
@ -0,0 +1,89 @@
+package net.lamgc.cgj.bot.framework.mirai;
+
+import net.mamoe.mirai.utils.MiraiLogger;
+import net.mamoe.mirai.utils.MiraiLoggerPlatformBase;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.Marker;
+import org.slf4j.MarkerFactory;
+
+/**
+ * MiraiLoggerToSlf4jLogger适配器
+ * <p>该Logger通过Slf4j的Marker进行标识, loggerName为{@code mirai.[identity]}</p>
+ * <p>由于适配器适配方式的原因, 日志输出的调用信息将不可用(调用指向了适配器内的方法);</p>
+ */
+public class MiraiToSlf4jLoggerAdapter extends MiraiLoggerPlatformBase {
+    
+    private final static Marker marker = MarkerFactory.getMarker("mirai");
+
+    private final Logger logger;
+
+    private final String identity;
+
+    public MiraiToSlf4jLoggerAdapter(String identity) {
+        this.identity = identity;
+        this.logger = LoggerFactory.getLogger("mirai." + identity);
+    }
+
+    @Override
+    protected void debug0(@Nullable String s) {
+        logger.debug(marker, s);
+    }
+
+    @Override
+    protected void debug0(@Nullable String s, @Nullable Throwable throwable) {
+        logger.debug(marker, s, throwable);
+    }
+
+    @Override
+    protected void error0(@Nullable String s) {
+        logger.error(marker, s);
+    }
+
+    @Override
+    protected void error0(@Nullable String s, @Nullable Throwable throwable) {
+        logger.error(marker, s, throwable);
+    }
+
+    @Override
+    protected void info0(@Nullable String s) {
+        logger.info(marker, s);
+    }
+
+    @Override
+    protected void info0(@Nullable String s, @Nullable Throwable throwable) {
+        logger.info(marker, s, throwable);
+    }
+
+    @Override
+    protected void verbose0(@Nullable String s) {
+        logger.trace(marker, s);
+    }
+
+    @Override
+    protected void verbose0(@Nullable String s, @Nullable Throwable throwable) {
+        logger.trace(marker, s, throwable);
+    }
+
+    @Override
+    protected void warning0(@Nullable String s) {
+        logger.warn(marker, s);
+    }
+
+    @Override
+    protected void warning0(@Nullable String s, @Nullable Throwable throwable) {
+        logger.warn(marker, s, throwable);
+    }
+
+    @Nullable
+    @Override
+    public String getIdentity() {
+        if(identity == null) {
+            MiraiLogger followerLogger = getFollower();
+            return followerLogger == null ? null : followerLogger.getIdentity();
+        } else {
+            return identity;
+        }
+    }
+}
--- a/src/main/java/net/lamgc/cgj/bot/framework/mirai/message/MiraiMessageSender.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/mirai/message/MiraiMessageSender.java
@ -134,6 +134,7 @@ public class MiraiMessageSender implements MessageSender {
     * @param code 图片BotCode
     * @return Image对象
     */
+    @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
    public Image uploadImage(BotCode code) {
        log.debug("传入BotCode信息:\n{}", code);
        String absolutePath = code.getParameter("absolutePath");
--- a/src/main/java/net/lamgc/cgj/bot/sort/PreLoadDataComparator.java
+++ b/src/main/java/net/lamgc/cgj/bot/sort/PreLoadDataComparator.java
@ -2,7 +2,7 @@ package net.lamgc.cgj.bot.sort;

 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
-import net.lamgc.cgj.bot.BotCommandProcess;
+import net.lamgc.cgj.bot.cache.CacheStoreCentral;

 import java.io.IOException;
 import java.util.Comparator;
@ -20,6 +20,15 @@ public class PreLoadDataComparator implements Comparator<JsonElement> {

    @Override
    public int compare(JsonElement o1, JsonElement o2) {
+        if(!o1.isJsonObject() || !o2.isJsonObject()) {
+            if(o1.isJsonObject()) {
+                return 1;
+            } else if(o2.isJsonObject()) {
+                return -1;
+            } else {
+                return 0;
+            }
+        }
        if(!o1.getAsJsonObject().has("illustId") || !o2.getAsJsonObject().has("illustId")) {
            if(o1.getAsJsonObject().has("illustId")) {
                return 1;
@ -30,9 +39,13 @@ public class PreLoadDataComparator implements Comparator<JsonElement> {
            }
        }
        try {
-            JsonObject illustPreLoadData1 = BotCommandProcess.getIllustPreLoadData(o1.getAsJsonObject().get("illustId").getAsInt(), false);
-            JsonObject illustPreLoadData2 = BotCommandProcess.getIllustPreLoadData(o2.getAsJsonObject().get("illustId").getAsInt(), false);
-            return Integer.compare(illustPreLoadData2.get(attribute.attrName).getAsInt(), illustPreLoadData1.get(attribute.attrName).getAsInt());
+            JsonObject illustPreLoadData1 =
+                    CacheStoreCentral.getIllustPreLoadData(o1.getAsJsonObject().get("illustId").getAsInt(), false);
+            JsonObject illustPreLoadData2 =
+                    CacheStoreCentral.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();
            return 0;
--- a/src/main/java/net/lamgc/cgj/pixiv/PixivUgoiraBuilder.java
+++ b/src/main/java/net/lamgc/cgj/pixiv/PixivUgoiraBuilder.java
@ -82,7 +82,33 @@ public final class PixivUgoiraBuilder {
        log.debug("IllustId: {}, UgoiraMeta: {}", this.illustId, this.ugoiraMeta);
    }

+    /**
+     * 获取动图元数据
+     * @return 动图元数据, 返回的对象不影响Builder中的meta对象
+     */
+    public JsonObject getUgoiraMeta() {
+        return this.ugoiraMeta.deepCopy();
+    }
+
+    /**
+     * 构建动图
+     * @param original 是否为原图画质
+     * @return 返回动图数据输入流
+     * @throws IOException 当获取数据发生异常时抛出
+     */
    public InputStream buildUgoira(boolean original) throws IOException {
+        ByteArrayOutputStream bufferOutput = new ByteArrayOutputStream();
+        buildUgoira(bufferOutput, original);
+        return new ByteArrayInputStream(bufferOutput.toByteArray());
+    }
+
+    /**
+     * 构建动图
+     * @param outputStream 动图输出流
+     * @param original 是否为原图画质
+     * @throws IOException 当获取数据发生异常时抛出
+     */
+    public void buildUgoira(OutputStream outputStream, boolean original) throws IOException {
        getUgoiraImageSize();
        log.debug("动图尺寸信息: Height: {}, Width: {}", height, width);

@ -95,7 +121,6 @@ public final class PixivUgoiraBuilder {
        HttpResponse response = httpClient.execute(request);
        log.trace("请求已发送, 正在处理响应...");
        ZipInputStream zipInputStream = new ZipInputStream(new BufferedInputStream(response.getEntity().getContent(), 64 * 1024));
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        ZipEntry entry;
        ByteArrayOutputStream cacheOutputStream = new ByteArrayOutputStream(512);
        HashMap<String, InputStream> frameMap = new HashMap<>(frames.size());
@ -140,7 +165,6 @@ public final class PixivUgoiraBuilder {
            }
        });
        encoder.finishEncoding();
-        return new ByteArrayInputStream(outputStream.toByteArray());
    }

    /**
--- a/src/main/resources/log4j2-test.xml
+++ b/src/main/resources/log4j2-test.xml
@ -3,26 +3,39 @@
    <properties>
        <property name="logStorePath">./logs</property>
        <property name="charset">UTF-8</property>
-        <property name="pattern">[%-d{HH:mm:ss.SSS} %5level][%logger.%method():%-3L][%thread]: %msg%n</property>
+        <property name="standard_pattern">[%-d{HH:mm:ss.SSS} %5level][%logger.%method():%-3L][%thread]: %msg%n</property>
+        <property name="mirai_pattern">[%-d{HH:mm:ss.SSS} %5level][%logger]: %msg%n</property>
        <property name="logsDir">${sys:cgj.logsPath:-logs}</property>
    </properties>

    <Appenders>
-        <Console name="CONSOLE_STDOUT" target="SYSTEM_OUT">
-            <PatternLayout pattern="${pattern}" charset="${charset}"/>
+        <Console name="STANDARD_STDOUT" target="SYSTEM_OUT">
+            <PatternLayout charset="${charset}">
+                <MarkerPatternSelector defaultPattern="${standard_pattern}">
+                    <PatternMatch key="mirai" pattern="${mirai_pattern}" />
+                </MarkerPatternSelector>
+            </PatternLayout>
            <Filters>
                <ThresholdFilter level="WARN" onMatch="DENY" onMismatch="ACCEPT"/>
            </Filters>
        </Console>
-        <Console name="CONSOLE_STDERR" target="SYSTEM_ERR">
-            <PatternLayout pattern="${pattern}" charset="${charset}"/>
+        <Console name="STANDARD_STDERR" target="SYSTEM_ERR">
+            <PatternLayout charset="${charset}">
+                <MarkerPatternSelector defaultPattern="${standard_pattern}">
+                    <PatternMatch key="mirai" pattern="${mirai_pattern}" />
+                </MarkerPatternSelector>
+            </PatternLayout>
            <Filters>
                <ThresholdFilter level="WARN" onMatch="ACCEPT" onMismatch="DENY"/>
            </Filters>
        </Console>

        <RollingFile name="rollingFile" fileName="${logsDir}/latest.log" filePattern="${logsDir}/running.%-d{yyyy-MM-dd_HH-mm-ss}.log.gz">
-            <PatternLayout pattern="${pattern}" charset="${charset}"/>
+            <PatternLayout charset="${charset}">
+                <MarkerPatternSelector defaultPattern="${standard_pattern}">
+                    <PatternMatch key="mirai" pattern="${mirai_pattern}" />
+                </MarkerPatternSelector>
+            </PatternLayout>
            <Policies>
                <OnStartupTriggeringPolicy />
            </Policies>
@ -32,8 +45,8 @@
    <Loggers>
        <Logger level="INFO" name="org.apache.http"/>
        <Root level="TRACE">
-            <AppenderRef ref="CONSOLE_STDOUT"/>
-            <AppenderRef ref="CONSOLE_STDERR"/>
+            <AppenderRef ref="STANDARD_STDOUT"/>
+            <AppenderRef ref="STANDARD_STDERR"/>
            <AppenderRef ref="rollingFile"/>
        </Root>
    </Loggers>
--- a/src/main/resources/log4j2.xml
+++ b/src/main/resources/log4j2.xml
@ -1,28 +1,44 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <configuration status="WARN">
+    <!--
+        测试版跟发布版在日志配置文件上的区别仅仅只有'Loggers'的不同, 'properties'和'Appenders'是一致的.
+     -->
    <properties>
        <property name="logStorePath">./logs</property>
        <property name="charset">UTF-8</property>
-        <property name="pattern">[%-d{HH:mm:ss.SSS} %5level][%logger.%method():%-3L][%thread]: %msg%n</property>
+        <property name="standard_pattern">[%-d{HH:mm:ss.SSS} %5level][%logger.%method():%-3L][%thread]: %msg%n</property>
+        <property name="mirai_pattern">[%-d{HH:mm:ss.SSS} %5level][%logger]: %msg%n</property>
        <property name="logsDir">${sys:cgj.logsPath:-logs}</property>
    </properties>

    <Appenders>
-        <Console name="CONSOLE_STDOUT" target="SYSTEM_OUT">
-            <PatternLayout pattern="${pattern}" charset="${charset}"/>
+        <Console name="STANDARD_STDOUT" target="SYSTEM_OUT">
+            <PatternLayout charset="${charset}">
+                <MarkerPatternSelector defaultPattern="${standard_pattern}">
+                    <PatternMatch key="mirai" pattern="${mirai_pattern}" />
+                </MarkerPatternSelector>
+            </PatternLayout>
            <Filters>
-                <LevelRangeFilter minLevel="INFO" maxLevel="INFO" />
+                <ThresholdFilter level="WARN" onMatch="DENY" onMismatch="ACCEPT"/>
            </Filters>
        </Console>
-        <Console name="CONSOLE_STDERR" target="SYSTEM_ERR">
-            <PatternLayout pattern="${pattern}" charset="${charset}"/>
+        <Console name="STANDARD_STDERR" target="SYSTEM_ERR">
+            <PatternLayout charset="${charset}">
+                <MarkerPatternSelector defaultPattern="${standard_pattern}">
+                    <PatternMatch key="mirai" pattern="${mirai_pattern}" />
+                </MarkerPatternSelector>
+            </PatternLayout>
            <Filters>
                <ThresholdFilter level="WARN" onMatch="ACCEPT" onMismatch="DENY"/>
            </Filters>
        </Console>

        <RollingFile name="rollingFile" fileName="${logsDir}/latest.log" filePattern="${logsDir}/running.%-d{yyyy-MM-dd_HH-mm-ss}.log.gz">
-            <PatternLayout pattern="${pattern}" charset="${charset}"/>
+            <PatternLayout charset="${charset}">
+                <MarkerPatternSelector defaultPattern="${standard_pattern}">
+                    <PatternMatch key="mirai" pattern="${mirai_pattern}" />
+                </MarkerPatternSelector>
+            </PatternLayout>
            <Policies>
                <OnStartupTriggeringPolicy />
            </Policies>
@ -30,10 +46,19 @@
    </Appenders>

    <Loggers>
-        <Logger level="INFO" name="org.apache.http"/>
+        <Logger level="INFO" name="org.apache.http">
+            <AppenderRef ref="STANDARD_STDOUT"/>
+            <AppenderRef ref="STANDARD_STDERR"/>
+        </Logger>
+        <Logger level="INFO" name="mirai">
+            <AppenderRef ref="STANDARD_STDOUT"/>
+            <AppenderRef ref="STANDARD_STDERR"/>
+        </Logger>
+        <Logger level="INFO" name="net.lamgc.cgj">
+            <AppenderRef ref="STANDARD_STDOUT"/>
+            <AppenderRef ref="STANDARD_STDERR"/>
+        </Logger>
        <Root level="TRACE">
-            <AppenderRef ref="CONSOLE_STDOUT"/>
-            <AppenderRef ref="CONSOLE_STDERR"/>
            <AppenderRef ref="rollingFile"/>
        </Root>
    </Loggers>
--- a/src/test/java/net/lamgc/cgj/pixiv/PixivUgoiraBuilderTest.java
+++ b/src/test/java/net/lamgc/cgj/pixiv/PixivUgoiraBuilderTest.java
@ -1,11 +1,12 @@
 package net.lamgc.cgj.pixiv;

 import org.apache.http.HttpHost;
-import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.client.HttpClient;
 import org.apache.http.impl.client.HttpClientBuilder;
 import org.bouncycastle.util.io.Streams;
 import org.junit.Ignore;
 import org.junit.Test;
+import org.slf4j.LoggerFactory;

 import java.io.File;
 import java.io.IOException;
@ -18,8 +19,9 @@ public class PixivUgoiraBuilderTest {
    @Test
    public void buildTest() throws IOException {
        File outputFile = new File("./output2.gif");
-        CloseableHttpClient httpClient = HttpClientBuilder.create().setProxy(new HttpHost("127.0.0.1", 1001)).build();
-        PixivUgoiraBuilder builder = new PixivUgoiraBuilder(httpClient, 80766493);
+        HttpClient httpClient = HttpClientBuilder.create().setProxy(new HttpHost("127.0.0.1", 1080)).build();
+        PixivUgoiraBuilder builder = new PixivUgoiraBuilder(httpClient, 81163967);
+        LoggerFactory.getLogger(PixivUgoiraBuilderTest.class).info("UgoiraMeta: {}", builder.getUgoiraMeta());
        InputStream inputStream = builder.buildUgoira(true);
        Files.write(outputFile.toPath(), Streams.readAll(inputStream));
    }
Author	SHA1	Message	Date
LamGC	4ccf2fafbc	[Version] 更新版本(2.5.2-20200609.2-SNAPSHOT -> 2.5.2-20200610.1-SNAPSHOT);	2020-06-10 09:21:27 +08:00
LamGC	f1e58d72ac	[Change] log4j2.xml 调整mirai日志在STANDARD_STD*的输出级别;	2020-06-10 09:20:35 +08:00
LamGC	9242a1d474	[Change] MiraiToSlf4jLoggerAdapter 调整类命名(MiraiToSlf4jLogger -> MiraiToSlf4jLoggerAdapter); [Change] MiraiMain 适配调整;	2020-06-10 09:13:12 +08:00
LamGC	065d21c4e4	[Update] MiraiToSlf4jLogger 补充类Javadoc;	2020-06-10 09:10:17 +08:00
LamGC	5eab94c429	[Change] Console* 调整包路径;	2020-06-10 09:09:54 +08:00
LamGC	2dd62bb6c8	[Version] 更新版本(2.5.2-20200609.1-SNAPSHOT -> 2.5.2-20200609.2-SNAPSHOT);	2020-06-09 16:02:03 +08:00
LamGC	21613fe3c0	[Update] net.mamoe:mirai-core 更新依赖项版本(1.0-RC2-1 -> 1.0.2); [Update] net.mamoe:mirai-core-qqandroid 更新依赖项版本(1.0-RC2-1 -> 1.0.2);	2020-06-09 15:51:33 +08:00
LamGC	ca56b2c9ba	[Change] MiraiToSlf4jLogger, log4j2.xml, log4j2-test.xml, MiraiMain 将Mirai框架的日志接入Slf4j(Log4j2); [Change] BotEventHandler 调整日志使用;	2020-06-09 15:35:43 +08:00
LamGC	e0f773639f	[Change] ConsoleMain 调整Terminal获取方式;	2020-06-09 14:16:26 +08:00
LamGC	75aa78a3d7	[Version] 更新版本(2.5.2-20200606.1-SNAPSHOT -> 2.5.2-20200609.1-SNAPSHOT);	2020-06-09 10:12:02 +08:00
LamGC	18a8ad95a1	[Change] PixivUgoiraBuilderTest 调整测试细节;	2020-06-09 10:07:54 +08:00
LamGC	438d0a95d3	[Add] pom.xml 增加JLine库; [Update] ConsoleMain 增强Cli使用体验; [Add] BotEventHandler 增加同步执行命令的方法'executeMessageEvent(MessageEvent, boolean)'; [Change] Main 适配ConsoleMain的更改;	2020-06-09 09:50:16 +08:00
LamGC	6789b5b7c5	[Change] CacheStoreCentral 调整'getImageById'方法中对'pageIndex'的参数值检查时机; [Change] MiraiMessageSender 增加警告忽略注释;	2020-06-08 19:13:51 +08:00
LamGC	ad289f952f	[Fix] log4j2.xml 修复SYSTEM_OUT级别限定错误的问题;	2020-06-08 18:47:53 +08:00
LamGC	3ae0e4cd8d	[Change] HotDataCacheStore 调整日志输出级别(DEBUG -> TRACE);	2020-06-08 16:08:13 +08:00
LamGC	5550c7aef1	[Clear] CacheStoreCentral 删除无用的运行器代码;	2020-06-08 15:57:38 +08:00
LamGC	d4d3432c76	[Add] PixivUgoiraBuilder 增加方法'buildUgoira(OutputStream, boolean)'以提供输出流给Builder输出已构建的动图数据; [Add] PixivUgoiraBuilder 增加方法'getUgoiraMeta():JsonObject'方法, 可通过该方法获取动图元数据;	2020-06-08 15:30:22 +08:00
LamGC	d1aeda012e	[Fix] BotCommandProcess 修复因'getImageById'迁移导致'image'命令不可用的问题; [Clear] CacheStoreCentral 清除无用代码;	2020-06-08 09:37:06 +08:00
LamGC	683a38bc17	[Add] BotGlobal BotGlobal在初始化时将检查Redis连通性; [Change] RandomRankingArtworksSender 支持外部设置groupId, 以使用群组配置; [Change] BotCommandProcess, BotAdminCommandProcess 适配RandomRankingArtworksSender更改;	2020-06-08 09:24:17 +08:00
LamGC	188309509b	[Change] BotCommandProcess 简化Search参数'ContentOption'的名称('contentOption' -> 'option');	2020-06-06 19:27:55 +08:00
LamGC	3915712337	[Delete] search.txt 删除旧文档;	2020-06-06 17:57:24 +08:00
LamGC	1e88ba70dd	[Version] 更新版本(2.5.2-20200604.3-SNAPSHOT -> 2.5.2-20200606.1-SNAPSHOT);	2020-06-06 17:54:09 +08:00
LamGC	e6b2544998	[Update] 更新接口文档;	2020-06-06 17:53:37 +08:00
LamGC	a2f6f1d140	[Clear] BotCommandProcess 整理代码;	2020-06-06 17:07:40 +08:00
LamGC	f54ed35a09	[Change] SettingProperties 增加群号检查, 防止出现非法群号;	2020-06-06 15:42:35 +08:00
LamGC	a426f80ec5	[Fix] BotCommandProcess 修复Search命令对作品限制的管理不受'image.allowR18'选项控制的问题;	2020-06-06 11:50:29 +08:00
LamGC	c1a21d1065	[Change] ConsoleMain, ConsoleMessageEvent 支持启动时设置会话群组Id和QQId;	2020-06-06 10:52:12 +08:00
LamGC	e570ddbb53	[Change] PreLoadDataComparator 增加对JsonElement是否为JsonObject的检查;	2020-06-06 10:51:24 +08:00
LamGC	223d78dbd6	[Change #5 ] 优化'getImageById'从文件读入缓存时, 检查图片完整性的速度;	2020-06-05 17:03:41 +08:00
LamGC	ef5651be47	[Fix] CacheStore 修正Javadoc中的错误描述;	2020-06-05 16:29:16 +08:00
LamGC	9a8aac1960	[Fix] BotGlobal 修复BotGlobal初始化失败的问题; [Fix] BotCommandProcess 修复Search命令未找到相关作品时提示语无法触发的问题; [Change] BotCommandProcess 调整'isNoSafe(int, Properties, boolean)'方法中对于作品限制的判断方式;	2020-06-05 16:23:13 +08:00
LamGC	4bbed5fd55	[Change] BotCommandProcess, CacheStoreCentral 将ImageFile缓存管理转移到CacheStoreCentral; [Change] RandomRankingArtworksSender 适配修改; [Change] BotCommandProcess, BotGlobal 将'imageStoreDir'由BotCommandProcess转移到BotGlobal;	2020-06-05 10:07:13 +08:00
LamGC	bcc21149b9	[Change #10 ] 将缓存存取部分从BotCommandProcess分离; [Change] 整理代码;	2020-06-05 09:53:30 +08:00
LamGC	e93c322c02	[Change] BotGlobal, BotCommandProcess 调整PixivDownload的初始化过程; [Change] BotCommandProcess 将'Search'所属缓存部分抽出到单独的方法('getSearchBody');	2020-06-04 20:14:57 +08:00
LamGC	feb51b8534	[Change] BotGlobal, BotCommandProcess 将'Gson'和'PixivDownload'对象纳入BotGlobal;	2020-06-04 19:47:20 +08:00