[Version] 更新版本(2.5.1 -> 2.5.2-20200517.1-SNAPSHOT);

[Add] MiraiMessageSender 增加对默认表情的支持;
Merge branch 'mirai'
2025-07-01 21:07:25 +00:00 · 2020-05-17 17:45:06 +08:00 · 2020-05-12 15:25:29 +08:00 · 2020-05-12 15:14:58 +08:00 · 2020-05-12 15:14:28 +08:00 · 2020-05-12 15:03:08 +08:00
39 changed files with 1592 additions and 298 deletions
--- a/Dockerfile.sample
+++ b/Dockerfile.sample
@ -1,8 +1,10 @@
 FROM openjdk:8u252-jre

 ENV jarFileName=ContentGrabbingJi-exec.jar
-COPY ${jarFileName} /program/CGJ.jar
-RUN mkdir /program/data
+ENV CGJ_REDIS_URI="127.0.0.1:6379"
+ENV CGJ_PROXY=""
+RUN mkdir /data/

-WORKDIR /program/data
-CMD java -jar /program/CGJ.jar botMode
+COPY ${jarFileName} /CGJ.jar
+
+CMD ["java", "-Dcgj.logsPath=/data/logs", "-jar", "/CGJ.jar", "botMode", "-botDataDir=/data"]
--- a/165
+++ b/165
@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
--- a/documents/interfaces/Pixiv接口标准返回格式.md
+++ b/documents/interfaces/Pixiv接口标准返回格式.md
@ -0,0 +1,18 @@
+## Pixiv接口标准返回格式 ##
+Pixiv大部分接口在返回数据时都会遵循以下格式：
+```json
+{
+    "error": false,
+    "message": "",
+    "body": {
+
+    }
+}
+```
+大部分是如此(部分接口比较特别, 不是这个格式)  
+
+属性|类型|说明
+---|---|---
+error|Boolean|如果接口返回错误信息, 该属性为`true`
+message|String|如果`error`属性为`true`, 则该属性不为空字符串
+body|Object/Array|如果`error`不为`true`, 该属性有数据, 否则属性可能不存在
--- a/documents/interfaces/Pixiv搜索接口.md
+++ b/documents/interfaces/Pixiv搜索接口.md
@ -0,0 +1,16 @@
+## Pixiv内容搜索接口 ##
+接口地址: 
+```
+GET https://www.pixiv.net/ajax/search/{Type}/{Content}?{参数...}
+```
+变量名:
+- `Type`: 内容类型
+    - illustrations(插画)
+    - top(推荐)
+    - manga(漫画)
+    - novels(小说)
+- `Content`: 搜索内容
+
+
+参数列表:
+- `word`
--- a/documents/interfaces/Pixiv首页数据接口.md
+++ b/documents/interfaces/Pixiv首页数据接口.md
@ -0,0 +1,127 @@
+## Pixiv首页数据接口 ##
+
+说明：  
+该接口涉及用户账户隐私, 不要尝试对该接口返回数据做不安全云端存储, 或未经用户允许的发送出去.
+
+接口地址：
+```
+GET https://www.pixiv.net/ajax/top/{type}?mode={mode}&lang={lang}
+```
+
+参数：
+- `type`: 首页类型
+    - `illust`: 插画
+    - `manga`: 漫画
+    - `novel`: 小说
+- `mode`: 内容类型
+    - `all`: 不限类型
+    - `r18`: 成人内容
+- `lang`: 语言(只写几个)
+    - `zh`: 中文
+
+> 是否需要登录: `是`  
+> 是否为Pixiv接口标准返回格式: `是`  
+> 是否需要Referer请求头: `未知`
+
+请求Url示例:
+```
+GET https://www.pixiv.net/ajax/top/illust?mode=all&lang=zh
+```
+
+响应示例:
+```
+(内容过长, 略)
+```
+
+返回内容(Json):
+- `page`: 网页相关内容
+    - `tags`: (`Object[]`) 热门标签
+        - `tag`: (`String`) 标签名
+        - `count`: (`Number`) 作品数量?
+        - `lev`: (`Number`) 不明?
+        - `ids`: (`Number[]`) 作品数组
+    - `follow`: (`Number[]`) 已关注作者的作品推荐
+    - `mypixiv`: (`?[]`) 不明
+    - `recommend`: (`String[]`  -> `Number[]`) 推荐作品的Id?
+    - `recommendByTag`: (`Object[]`) 标签的推荐作品
+        - `tag`: (`String`) 标签名
+        - `ids`: ((`String[]`  -> `Number[]`) 作品Id数组
+    - `ranking`: (`Object`) 排行榜前100名数据
+        - `date`: (`String`) 排行榜日期(`yyyyMMdd`)
+        - `items`: (`Object[]`) 排行榜简略数据
+            - `rank`: (`String` -> `Number`) 排行榜名次
+            - `id`: (`String` -> `Number`) 作品Id 
+    - `pixivision`: (`Object[]`) Pixiv的推荐文章
+        - `id`: (`String` -> `Number`) 文章Id
+        - `title`: (`String`) 文章标题
+        - `thumbnailUrl`: (`String`) 文章封面图的Url地址
+        - `abtestId`: (`String` -> `Number`) pixivision文章地址的参数`utm_content`的值
+    - `recommendUser`: (`Object[]`) 推荐用户及其作品
+        - `id`: (`Number`) 用户Id
+        - `illustIds`: (`String[]` -> `Number[]`) 插画作品Id
+        - `novelIds`: (`String[]` -> `Number[]`) 小说作品Id
+    - `contestOngoing`: (`Object[]`) 进行中的比赛活动(没找到更多信息了, 先这么说着)
+        - (待完善)
+    - `contestResult`: (`Object[]`) 比赛结果信息
+        - `slug`: (`String`) 比赛代号?
+        - `type`: (`String`) 比赛作品类型?
+        - `name`: (`String`) 比赛名
+        - `url`: (`String`) 结果公布链接
+        - `iconUrl`: (`String`) 图标链接(不明意义的图标)
+    - `editorRecommend`: (`Object[]`) 编辑推荐(小说), 后续可能会删除, 这个应该是配合活动出的数据
+        - (待完善)
+    - `boothFollowItemIds`: (`String[]` -> `Number[]`) 已关注用户的最新商品
+    - `sketchLiveFollowIds`: (`?[]`) 不明?
+    - `sketchLivePopularIds`: (`String[]` -> `Number[]`) 不明?
+    - `myFavoriteTags`: (`?[]`) 关注的标签
+    - `newPost`: (`String[]` -> `Number[]`) 不明?
+- `thumbnails`: (`Object`) 已关注用户的作品
+    - `illust`: (`Object[]`) 插画作品
+        - `illustId`: (`String` -> `Number`) 作品Id(或者准确来讲是 插画Id?)
+        - `illustTitle`: (`String`) 插画标题
+        - `id`: (`String` -> `Number`) 作品Id
+        - `title`: (`String`) 作品标题
+        - `illustType`: (`Number`) 作品类型
+        - `xRestrict`: (`Number`) 不明?
+        - `restrict`: (`Number`) 不明?
+        - `sl`: (`Number`) 不明?
+        - `url`: (`String`) 作品在主页的封面图Url
+        - `description`: (`String`) 作品说明?
+        - `tags`: (`String[]`) 标签原始名数组(不带翻译的原始名称)
+        - `userId`: (`String` -> `Number`) 用户Id
+        - `userName`: (`String`) 用户名
+        - `width`: (`Number`) 作品宽度
+        - `height`: (`Number`) 作品高度
+        - `pageCount`: (`Number`) 作品页数
+        - `isBookmarkable`: (`Boolean`) 不明?
+        - `bookmarkData`: (`?`) 不明?
+        - `alt`: (`String`) 简略信息
+        - `isAdContainer`: (`Boolean`) 广告标识?
+        - `titleCaptionTranslation`: (`Object`) 不明?
+            - (待完善)
+        - `urls`: (`Object`) 其他封面图尺寸的链接
+            - (略)
+        - `seriesId`: (`?`) 不明?
+        - `seriesTitle`: (`?`) 不明?
+        - `profileImageUrl`: (`String`) 用户头像图链接
+    - `users`: (`Object[]`) 用户信？
+        - `userId`: (`String` -> `Number`) 用户Id
+        - `name`: (`String`) 用户名
+        - `image`: (`String`) 用户头像图链接
+        - `imageBig`: (`String`) 用户大尺寸头像图链接
+        - `premium`: (`Boolean`) 是否为Pixiv高级会员
+        - `isFollowed`: (`Boolean`) 是否关注
+        - `isMypixiv`: (`Boolean`) 不明?
+        - `isBlocking`: (`Boolean`) 是否为黑名单?
+        - `background`: (`?`) 不明?
+        - `partial`: (`Number`) 不明?
+    - `tagTranslation`: 标签翻译名
+        - `key=${标签原始名}`: (`Object`) 标签翻译信息
+            - `${语言代码}`: (`String`) 对应语言代码的翻译, 不一定有
+    - `boothItems`: (`Object[]`) 商品信息
+        - (待完善)
+    - `sketchLives`: (`Object[]`) 不明?
+        - (待完善)
+    - `zoneConfig`: (`Object`) 不明?
+        - (待完善)
+
--- a/documents/interfaces/search.txt
+++ b/documents/interfaces/search.txt
--- a/pom.xml
+++ b/pom.xml
@ -6,7 +6,7 @@

    <groupId>net.lamgc</groupId>
    <artifactId>ContentGrabbingJi</artifactId>
-    <version>2.4.0</version>
+    <version>2.5.2-20200517.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>0.39.4</mirai.CoreVersion>
+        <mirai.CoreVersion>1.0-RC2-1</mirai.CoreVersion>
        <mirai.JaptVersion>1.1.1</mirai.JaptVersion>
        <kotlin.version>1.3.71</kotlin.version>
        <ktor.version>1.3.2</ktor.version>
@ -86,7 +86,7 @@
        <dependency>
            <groupId>net.lamgc</groupId>
            <artifactId>java-utils</artifactId>
-            <version>1.1.0_5-SNAPSHOT</version>
+            <version>1.2.0_20200514.1-SNAPSHOT</version>
        </dependency>
        
        <dependency>
@ -172,7 +172,7 @@
        <dependency>
            <groupId>net.lamgc</groupId>
            <artifactId>PixivLoginProxyServer</artifactId>
-            <version>1.1.0</version>
+            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>com.squareup</groupId>
--- a/src/main/java/net/lamgc/cgj/Main.java
+++ b/src/main/java/net/lamgc/cgj/Main.java
@ -42,7 +42,7 @@ import java.util.zip.ZipOutputStream;
@SpringBootApplication
 public class Main {

-    private final static Logger log = LoggerFactory.getLogger("Main");
+    private final static Logger log = LoggerFactory.getLogger(Main.class.getName());

    private final static File storeDir = new File("store/");

@ -52,10 +52,18 @@ public class Main {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        log.trace("ContentGrabbingJi 正在启动...");
+        log.debug("Args: {}, LogsPath: {}", Arrays.toString(args), System.getProperty("cgj.logsPath"));
        log.debug("运行目录: {}", System.getProperty("user.dir"));
        ArgumentsProperties argsProp = new ArgumentsProperties(args);
-        if(argsProp.containsKey("proxy")) {
-            URL proxyUrl = new URL(argsProp.getValue("proxy"));
+
+
+        if(!getSettingToSysProp(argsProp, "proxy", null)) {
+            getEnvSettingToSysProp("CGJ_PROXY", "proxy", null);
+        }
+
+        String proxyAddress = System.getProperty("cgj.proxy");
+        if(!Strings.isNullOrEmpty(proxyAddress)) {
+            URL proxyUrl = new URL(proxyAddress);
            proxy = new HttpHost(proxyUrl.getHost(), proxyUrl.getPort());
            log.info("已启用Http协议代理：{}", proxy.toHostString());
        } else {
@ -66,28 +74,20 @@ public class Main {
            log.error("创建文件夹失败!");
        }

-        // TODO: 需要修改参数名了, 大概改成类似于 workerDir这样的吧
-        if(argsProp.containsKey("cqRootDir")) {
-            log.info("cqRootDir: {}", argsProp.getValue("cqRootDir"));
-            System.setProperty("cgj.cqRootDir", argsProp.getValue("cqRootDir"));
-        } else {
-            log.warn("未设置cqRootDir, 当前运行目录将作为酷Q机器人所在目录.");
-            System.setProperty("cgj.cqRootDir", "./");
+        if(!getSettingToSysProp(argsProp, "botDataDir", "./") &&
+                !getEnvSettingToSysProp("CGJ_BOT_DATA_DIR", "botDataDir", "./")) {
+            log.warn("未设置botDataDir, 当前运行目录将作为酷Q机器人所在目录.");
+        }
+        if(!getSettingToSysProp(argsProp, "redisAddress", "127.0.0.1") &&
+                !getEnvSettingToSysProp("CGJ_REDIS_URI", "redisAddress", "127.0.0.1")) {
+            log.warn("未设置RedisAddress, 将使用默认值连接Redis服务器(127.0.0.1:6379)");
        }

-        if(argsProp.containsKey("redisAddr")) {
-            log.info("redisAddress: {}", argsProp.getValue("redisAddr"));
-            System.setProperty("cgj.redisAddress", argsProp.getValue("redisAddr"));
-        } else {
-            log.info("未设置RedisAddress, 将使用默认值连接Redis服务器(127.0.0.1:6379)");
-            System.setProperty("cgj.redisAddress", "127.0.0.1");
-        }
-
-        File cookieStoreFile = new File("cookies.store");
+        File cookieStoreFile = new File(System.getProperty("cgj.botDataDir"), "cookies.store");
        if(!cookieStoreFile.exists()) {
-            log.error("未找到cookies.store文件, 是否启动PixivLoginProxyServer? (yes/no)");
+            log.warn("未找到cookies.store文件, 是否启动PixivLoginProxyServer? (yes/no)");
            Scanner scanner = new Scanner(System.in);
-            if(scanner.nextLine().equalsIgnoreCase("yes")) {
+            if(scanner.nextLine().trim().equalsIgnoreCase("yes")) {
                startPixivLoginProxyServer();
            } else {
                System.exit(1);
@ -104,6 +104,37 @@ public class Main {
        ArgumentsRunner.run(Main.class, args);
    }

+    /**
+     * 从ArgumentsProperties获取设置项到System Properties
+     * @param prop ArgumentsProperties对象
+     * @param key 设置项key
+     * @param defaultValue 默认值
+     * @return 如果成功从ArgumentsProperties获得设置项, 返回true, 如未找到(使用了defaultValue或null), 返回false;
+     */
+    private static boolean getSettingToSysProp(ArgumentsProperties prop, String key, String defaultValue) {
+        if(prop.containsKey(key)) {
+            log.info("{}: {}", key, prop.getValue(key));
+            System.setProperty("cgj." + key, prop.getValue(key));
+            return true;
+        } else {
+            if(defaultValue != null) {
+                System.setProperty("cgj." + key, defaultValue);
+            }
+            return false;
+        }
+    }
+
+    private static boolean getEnvSettingToSysProp(String envKey, String sysPropKey, String defaultValue) {
+        String env = System.getenv(envKey);
+        if(env != null) {
+            System.setProperty("cgj." + sysPropKey, env);
+            return true;
+        } else if(defaultValue != null) {
+            System.setProperty("cgj." + sysPropKey, defaultValue);
+        }
+        return false;
+    }
+
    @Command
    public static void botMode(@Argument(name = "args", force = false) String argsStr) {
        new MiraiMain().init();
@ -111,10 +142,10 @@ public class Main {

    @Command
    public static void pluginMode(@Argument(name = "args", force = false) String argsStr) {
-        if(!System.getProperty("cgj.cqRootDir").endsWith("\\") && !System.getProperty("cgj.cqRootDir").endsWith("/")) {
-            System.setProperty("cgj.cqRootDir", System.getProperty("cgj.cqRootDir") + "/");
+        if(!System.getProperty("cgj.botDataDir").endsWith("\\") && !System.getProperty("cgj.botDataDir").endsWith("/")) {
+            System.setProperty("cgj.botDataDir", System.getProperty("cgj.botDataDir") + "/");
        }
-        log.info("酷Q机器人根目录: {}", System.getProperty("cgj.cqRootDir"));
+        log.info("酷Q机器人根目录: {}", System.getProperty("cgj.botDataDir"));
        CQConfig.init();
        Pattern pattern = Pattern.compile("/\\s*(\".+?\"|[^:\\s])+((\\s*:\\s*(\".+?\"|[^\\s])+)|)|(\".+?\"|[^\"\\s])+");
        Matcher matcher = pattern.matcher(Strings.nullToEmpty(argsStr));
@ -366,8 +397,8 @@ public class Main {

    private static void saveCookieStoreToFile() throws IOException {
        log.info("正在保存CookieStore...");
-        File outputFile = new File("./cookies.store");
-        if(!outputFile.exists() && !outputFile.delete() && !outputFile.createNewFile()){
+        File outputFile = new File(System.getProperty("cgj.botDataDir"), "cookies.store");
+        if(!outputFile.exists() && !outputFile.createNewFile()){
            log.error("保存CookieStore失败.");
            return;
        }
--- a/src/main/java/net/lamgc/cgj/bot/BotAdminCommandProcess.java
+++ b/src/main/java/net/lamgc/cgj/bot/BotAdminCommandProcess.java
@ -20,11 +20,9 @@ import java.util.*;

 public class BotAdminCommandProcess {

-    private final static Logger log = LoggerFactory.getLogger(BotAdminCommandProcess.class.getSimpleName());
+    private final static Logger log = LoggerFactory.getLogger(BotAdminCommandProcess.class.getName());

-    private final static File globalPropFile = new File("global.properties");
-
-    private final static File pushListFile = new File("pushList.json");
+    private final static File pushListFile = new File(System.getProperty("cgj.botDataDir"), "pushList.json");

    private final static Hashtable<Long, JsonObject> pushInfoMap = new Hashtable<>();

@ -39,59 +37,47 @@ public class BotAdminCommandProcess {
    }

    @Command
-    public static String setGlobalProperty(@Argument(name = "key") String key, @Argument(name = "value") String value, @Argument(name = "save", force = false) boolean saveNow) {
-        String lastValue = BotCommandProcess.globalProp.getProperty(key);
-        BotCommandProcess.globalProp.setProperty(key, Strings.nullToEmpty(value));
-        if(saveNow) {
-            saveGlobalProperties();
+    public static String setProperty(
+            @Argument(name = "group", force = false) long groupId,
+            @Argument(name = "key") String key,
+            @Argument(name = "value") String value
+    ) {
+        if(Strings.isNullOrEmpty(key)) {
+            return "未选择配置项key.";
        }
-        return "全局配置项 " + key + " 现已设置为: " + value + " (设置前的值: " + lastValue + ")";
+        String lastValue = SettingProperties.setProperty(groupId, key, value.equals("null") ? null : value);
+        return (groupId <= 0 ? "已更改全局配置 " : "已更改群组 " + groupId + " 配置 ") +
+                key + " 的值: '" + value + "' (原配置值: '" + lastValue + "')";
    }

    @Command
-    public static String getGlobalProperty(@Argument(name = "key") String key) {
-        return "全局配置项 " + key + " 当前值: " + BotCommandProcess.globalProp.getProperty(key, "(Empty)");
+    public static String getProperty(
+            @Argument(name = "group", force = false) long groupId,
+            @Argument(name = "key") String key
+    ) {
+        if(Strings.isNullOrEmpty(key)) {
+            return "未选择配置项key.";
+        }
+        return (groupId <= 0 ? "全局配置 " : "群组 " + groupId + " 配置 ") +
+                key + " 设定值: '" + SettingProperties.getProperty(groupId, key, "(empty)") + "'";
    }

    @Command
-    public static String saveGlobalProperties() {
-        log.info("正在保存全局配置文件...");
-
-        try {
-            if(!globalPropFile.exists()) {
-                if(!globalPropFile.createNewFile()) {
-                    log.error("全局配置项文件保存失败！({})", "文件创建失败");
-                    return "全局配置项文件保存失败！";
-                }
-            }
-            BotCommandProcess.globalProp.store(new FileOutputStream(globalPropFile), "");
-            log.info("全局配置文件保存成功！");
-            return "保存全局配置文件 - 操作已完成.";
-        } catch (IOException e) {
-            log.error("全局配置项文件保存失败！", e);
-            return "全局配置项文件保存失败！";
-        }
+    public static String saveProperties() {
+        log.info("正在保存配置文件...");
+        SettingProperties.saveProperties();
+        log.info("配置文件保存操作已完成.");
+        return "保存配置 - 操作已完成.";
    }

    @Command
-    public static String loadGlobalProperties(@Argument(name = "reload", force = false) boolean reload) {
-        Properties cache = new Properties();
-        if(!globalPropFile.exists()) {
-            return "未找到全局配置文件, 无法重载";
-        }
-
-        try(Reader reader = new BufferedReader(new FileReader(globalPropFile))) {
-            cache.load(reader);
-        } catch (IOException e) {
-            log.error("重载全局配置文件时发生异常", e);
-            return "加载全局配置文件时发生错误!";
-        }
-
+    public static String loadProperties(@Argument(name = "reload", force = false) boolean reload) {
        if(reload) {
-            BotCommandProcess.globalProp.clear();
+            SettingProperties.clearProperties();
        }
-        BotCommandProcess.globalProp.putAll(cache);
-        return "全局配置文件重载完成.";
+
+        SettingProperties.loadProperties();
+        return "操作已完成.";
    }

    @Command
@ -125,6 +111,30 @@ public class BotAdminCommandProcess {
            @Argument(name = "type", force = false, defaultValue = "ILLUST") String rankingContentType,
            @Argument(name = "original", force = false, defaultValue = "false") boolean original
    ) {
+        if(minTime <= 0 || floatTime <= 0) {
+            return "时间不能为0或负数！";
+        } else if(rankingStart <= 0 || rankingStop - rankingStart <= 0) {
+            return "排行榜范围选取错误！";
+        }
+
+        PixivURL.RankingContentType type;
+        PixivURL.RankingMode mode;
+        try {
+            type = PixivURL.RankingContentType.valueOf("TYPE_" + rankingContentType.toUpperCase());
+        } catch(IllegalArgumentException e) {
+            return "无效的排行榜类型参数！";
+        }
+
+        try {
+            mode = PixivURL.RankingMode.valueOf("MODE_" + rankingMode.toUpperCase());
+        } catch(IllegalArgumentException e) {
+            return "无效的排行榜模式参数！";
+        }
+
+        if(!type.isSupportedMode(mode)) {
+            return "不兼容的排行榜模式与类型！";
+        }
+
        long group = groupId <= 0 ? fromGroup : groupId;
        JsonObject setting = new JsonObject();
        setting.addProperty(RANKING_SETTING_TIME_MIN, minTime);
@ -141,7 +151,8 @@ public class BotAdminCommandProcess {
            removePushGroup(fromGroup, groupId);
        }

-        log.info("正在增加Timer...(Setting: {})", setting);
+        log.info("群组 {} 新推送配置: {}", group, setting);
+        log.info("正在增加Timer...");
        pushInfoMap.put(group, setting);
        addPushTimer(group, setting);
        return "已在 " + group + " 开启定时推送功能。";
--- a/src/main/java/net/lamgc/cgj/bot/BotCommandProcess.java
+++ b/src/main/java/net/lamgc/cgj/bot/BotCommandProcess.java
@ -2,7 +2,6 @@ package net.lamgc.cgj.bot;

 import com.google.common.base.Strings;
 import com.google.common.base.Throwables;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import com.google.gson.*;
 import io.netty.handler.codec.http.HttpHeaderNames;
 import net.lamgc.cgj.Main;
@ -15,7 +14,6 @@ import net.lamgc.cgj.pixiv.PixivURL;
 import net.lamgc.cgj.util.URLs;
 import net.lamgc.utils.base.runner.Argument;
 import net.lamgc.utils.base.runner.Command;
-import net.lamgc.utils.event.EventExecutor;
 import net.lz1998.cq.utils.CQCode;
 import org.apache.http.HttpResponse;
 import org.apache.http.client.methods.HttpGet;
@ -25,75 +23,71 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import java.io.File;
-import java.io.FileInputStream;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.text.SimpleDateFormat;
 import java.util.*;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;

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

    private final static PixivDownload pixivDownload = new PixivDownload(Main.cookieStore, Main.proxy);

-    private final static Logger log = LoggerFactory.getLogger(BotCommandProcess.class.getSimpleName());
+    private final static Logger log = LoggerFactory.getLogger(BotCommandProcess.class.getName());

-    private final static File imageStoreDir = new File(System.getProperty("cgj.cqRootDir"), "data/image/cgj/");
-    public final static Properties globalProp = new Properties();
+    private final static File imageStoreDir = new File(System.getProperty("cgj.botDataDir"), "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(BotEventHandler.redisServer, "illustInfo", gson);
-    private final static CacheStore<JsonElement> illustPreLoadDataCache = new HotDataCacheStore<>(
-            new JsonRedisCacheStore(BotEventHandler.redisServer, "illustPreLoadData", gson),
-            new LocalHashCacheStore<>(), 3600000, 900000);
-    private final static CacheStore<JsonElement> searchBodyCache = new JsonRedisCacheStore(BotEventHandler.redisServer, "searchBody", gson);
-    private final static CacheStore<List<JsonObject>> rankingCache = new JsonObjectRedisListCacheStore(BotEventHandler.redisServer, "ranking", gson);
-    private final static CacheStore<List<String>> pagesCache = new StringListRedisCacheStore(BotEventHandler.redisServer, "imagePages");
-    public final static CacheStore<JsonElement> reportStore = new JsonRedisCacheStore(BotEventHandler.redisServer, "report", gson);

    /**
-     * 图片异步缓存执行器
+     * 作品信息缓存 - 不过期
     */
-    private final static EventExecutor imageCacheExecutor = new EventExecutor(new ThreadPoolExecutor(
-            Runtime.getRuntime().availableProcessors() >= 2 ? 2 : 1,
-            (int) Math.ceil(Runtime.getRuntime().availableProcessors() / 2F),
-            5L, TimeUnit.SECONDS,
-            new LinkedBlockingQueue<>(128),
-            new ThreadFactoryBuilder()
-                    .setNameFormat("imageCacheThread-%d")
-                    .build(),
-            new ThreadPoolExecutor.DiscardOldestPolicy()
-    ));
+    private final static CacheStore<JsonElement> illustInfoCache =
+            new JsonRedisCacheStore(BotEventHandler.redisServer, "illustInfo", gson);
+
+    /**
+     * 作品信息预加载数据 - 有效期 2 小时, 本地缓存有效期1 ± 0.25
+     */
+    private final static CacheStore<JsonElement> illustPreLoadDataCache =
+            CacheStoreUtils.hashLocalHotDataStore(
+                new JsonRedisCacheStore(BotEventHandler.redisServer, "illustPreLoadData", gson),
+                3600000, 900000);
+    /**
+     * 搜索内容缓存, 有效期 2 小时
+     */
+    private final static CacheStore<JsonElement> searchBodyCache =
+            new JsonRedisCacheStore(BotEventHandler.redisServer, "searchBody", gson);
+
+    /**
+     * 排行榜缓存, 不过期
+     */
+    private final static CacheStore<List<JsonObject>> rankingCache =
+            new JsonObjectRedisListCacheStore(BotEventHandler.redisServer, "ranking", gson);
+
+    /**
+     * 作品页面下载链接缓存 - 不过期
+     */
+    private final static CacheStore<List<String>> pagesCache =
+            new StringListRedisCacheStore(BotEventHandler.redisServer, "imagePages");
+
+    /**
+     * 作品报告存储 - 不过期
+     */
+    public final static CacheStore<JsonElement> reportStore =
+            new JsonRedisCacheStore(BotEventHandler.redisServer, "report", gson);

    private final static RankingUpdateTimer updateTimer = new RankingUpdateTimer();

    public static void initialize() {
        log.info("正在初始化...");

-        File globalPropFile = new File("./global.properties");
-        if(globalPropFile.exists() && globalPropFile.isFile()) {
-            log.info("正在加载全局配置文件...");
-            try {
-                globalProp.load(new FileInputStream(globalPropFile));
-                log.info("全局配置文件加载完成.");
-            } catch (IOException e) {
-                log.error("加载全局配置文件时发生异常", e);
-            }
-        } else {
-            log.info("未找到全局配置文件，跳过加载.");
-        }
-
-        try {
-            imageCacheExecutor.addHandler(new ImageCacheHandler());
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
+        SettingProperties.loadProperties();

        updateTimer.schedule(null);
        log.info("初始化完成.");
@ -141,30 +135,38 @@ public class BotCommandProcess {
        return helpStrBuilder.toString();
    }

+    /**
+     * 作品信息查询
+     * @param fromGroup 来源群(系统提供)
+     * @param illustId 作品Id
+     * @return 返回作品信息
+     */
    @Command(commandName = "info")
-    public static String artworkInfo(@Argument(name = "id") int illustId) {
+    public static String artworkInfo(@Argument(name = "$fromGroup") long fromGroup, @Argument(name = "id") int illustId) {
        if(illustId <= 0) {
            return "错误的作品id！";
        }

        try {
-            if(isNoSafe(illustId, globalProp, false) || isReported(illustId)) {
+            if(isNoSafe(illustId, SettingProperties.getProperties(fromGroup), false) || isReported(illustId)) {
                return "阅览禁止：该作品已被封印！！";
            }

            JsonObject illustPreLoadData = getIllustPreLoadData(illustId, false);
-            StringBuilder builder = new StringBuilder("---------------- 作品信息 ----------------\n");
-            builder.append("作品Id: ").append(illustId).append("\n");
-            builder.append("作品标题：").append(illustPreLoadData.get("illustTitle").getAsString()).append("\n");
-            builder.append("作者(作者Id)：").append(illustPreLoadData.get("userName").getAsString())
-                    .append("(").append(illustPreLoadData.get("userId").getAsInt()).append(")\n");
-            builder.append("点赞数：").append(illustPreLoadData.get(PreLoadDataComparator.Attribute.LIKE.attrName).getAsInt()).append("\n");
-            builder.append("收藏数：").append(illustPreLoadData.get(PreLoadDataComparator.Attribute.BOOKMARK.attrName).getAsInt()).append("\n");
-            builder.append("围观数：").append(illustPreLoadData.get(PreLoadDataComparator.Attribute.VIEW.attrName).getAsInt()).append("\n");
-            builder.append("评论数：").append(illustPreLoadData.get(PreLoadDataComparator.Attribute.COMMENT.attrName).getAsInt()).append("\n");
-            builder.append("页数：").append(illustPreLoadData.get(PreLoadDataComparator.Attribute.PAGE.attrName).getAsInt()).append("页\n");
+            StringBuilder builder = new StringBuilder("色图姬帮你了解了这个作品的信息！\n");
+            builder.append("---------------- 作品信息 ----------------");
+            builder.append("\n作品Id: ").append(illustId);
+            builder.append("\n作品标题：").append(illustPreLoadData.get("illustTitle").getAsString());
+            builder.append("\n作者(作者Id)：").append(illustPreLoadData.get("userName").getAsString())
+                    .append("(").append(illustPreLoadData.get("userId").getAsInt()).append(")");
+            builder.append("\n点赞数：").append(illustPreLoadData.get(PreLoadDataComparator.Attribute.LIKE.attrName).getAsInt());
+            builder.append("\n收藏数：").append(illustPreLoadData.get(PreLoadDataComparator.Attribute.BOOKMARK.attrName).getAsInt());
+            builder.append("\n围观数：").append(illustPreLoadData.get(PreLoadDataComparator.Attribute.VIEW.attrName).getAsInt());
+            builder.append("\n评论数：").append(illustPreLoadData.get(PreLoadDataComparator.Attribute.COMMENT.attrName).getAsInt());
+            builder.append("\n页数：").append(illustPreLoadData.get(PreLoadDataComparator.Attribute.PAGE.attrName).getAsInt()).append("页");
+            builder.append("\n作品链接：").append(artworksLink(fromGroup, illustId)).append("\n");
            builder.append("---------------- 作品图片 ----------------\n");
-            builder.append(getImageById(illustId, PixivDownload.PageQuality.REGULAR, 1)).append("\n");
+            builder.append(getImageById(fromGroup, illustId, PixivDownload.PageQuality.REGULAR, 1)).append("\n");
            builder.append("使用 \".cgj image -id ")
                    .append(illustId)
                    .append("\" 获取原图。\n如有不当作品，可使用\".cgj report -id ")
@ -176,9 +178,20 @@ public class BotCommandProcess {
        return "尚未支持";
    }

+    /**
+     * 排行榜命令
+     * @param fromGroup 来源群(系统提供)
+     * @param queryTime 查询时间, 格式: 年-月-日
+     * @param force 是否强制查询, 当主动提供的时间不在查询范围时, 是否强制查询, 仅系统可用
+     * @param contentMode 内容模式
+     * @param contentType 排行榜类型
+     * @return 返回排行榜信息
+     */
    @Command
    public static String ranking(
+            @Argument(name = "$fromGroup") long fromGroup,
            @Argument(force = false, name = "date") Date queryTime,
+            @Argument(force = false, name = "force") boolean force,
            @Argument(force = false, name = "mode", defaultValue = "DAILY") String contentMode,
            @Argument(force = false, name = "type", defaultValue = "ILLUST") String contentType
    ) {
@ -195,7 +208,7 @@ public class BotCommandProcess {
            }
            queryDate = gregorianCalendar.getTime();
        } else {
-            if(new Date().before(queryDate)) {
+            if(new Date().before(queryDate) && !force) {
                log.warn("查询的日期过早, 无法查询排行榜.");
                return "查询日期过早, 暂未更新指定日期的排行榜!";
            }
@ -229,9 +242,10 @@ public class BotCommandProcess {
        try {
            int index = 0;
            int itemLimit = 10;
-            String itemLimitPropertyKey = "ranking.ItemCountLimit";
+            String itemLimitPropertyKey = "ranking.itemCountLimit";
            try {
-                itemLimit = Integer.parseInt(globalProp.getProperty(itemLimitPropertyKey, "10"));
+                itemLimit = Integer.parseInt(SettingProperties
+                        .getProperty(fromGroup, itemLimitPropertyKey, "10"));
            } catch(NumberFormatException e) {
                log.warn("配置项 {} 的参数值格式有误!", itemLimitPropertyKey);
            }
@ -239,12 +253,12 @@ public class BotCommandProcess {
            int imageLimit = 3;
            String imageLimitPropertyKey = "ranking.imageCountLimit";
            try {
-                imageLimit = Integer.parseInt(globalProp.getProperty(imageLimitPropertyKey, "3"));
+                imageLimit = Integer.parseInt(
+                        SettingProperties.getProperty(fromGroup, imageLimitPropertyKey, "3"));
            } catch(NumberFormatException e) {
                log.warn("配置项 {} 的参数值格式有误!", imageLimitPropertyKey);
            }

-            //TODO(LamGC, 2020.4.11): 将JsonRedisCacheStore更改为使用Redis的List集合, 以提高性能
            List<JsonObject> rankingInfoList = getRankingInfoByCache(type, mode, queryDate, 1, Math.max(0, itemLimit), false);
            if(rankingInfoList.isEmpty()) {
                return "无法查询排行榜，可能排行榜尚未更新。";
@ -261,7 +275,7 @@ public class BotCommandProcess {
                resultBuilder.append(rank).append(". (id: ").append(illustId).append(") ").append(title)
                        .append("(Author: ").append(authorName).append(",").append(authorId).append(") ").append(pagesCount).append("p.\n");
                if (index <= imageLimit) {
-                    resultBuilder.append(getImageById(illustId, PixivDownload.PageQuality.REGULAR, 1)).append("\n");
+                    resultBuilder.append(getImageById(fromGroup, illustId, PixivDownload.PageQuality.REGULAR, 1)).append("\n");
                }
            }
        } catch (IOException e) {
@ -271,6 +285,10 @@ public class BotCommandProcess {
        return resultBuilder.append("如查询当前时间获取到昨天时间，则今日排名榜未更新。\n如有不当作品，可使用\".cgj report -id 作品id\"向色图姬反馈。").toString();
    }

+    /**
+     * 查询指定作者的作品(尚未完成)
+     * @return 返回作者信息和部分作品
+     */
    @Command(commandName = "userArt")
    public static String userArtworks() {

@ -279,6 +297,7 @@ public class BotCommandProcess {

    /**
     * 搜索命令
+     * @param fromGroup 来源群(系统提供)
     * @param content 搜索内容
     * @param type 搜索类型
     * @param area 搜索区域
@ -290,13 +309,15 @@ public class BotCommandProcess {
     * @throws IOException 当搜索发生异常时抛出
     */
    @Command
-    public static String search(@Argument(name = "content") String content,
-                                @Argument(name = "type", force = false) String type,
-                                @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 = "page", force = false, defaultValue = "1") int pagesIndex
+    public static String search(
+            @Argument(name = "$fromGroup") long fromGroup,
+            @Argument(name = "content") String content,
+            @Argument(name = "type", force = false) String type,
+            @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 = "page", force = false, defaultValue = "1") int pagesIndex
    ) throws IOException {
        log.info("正在执行搜索...");
        PixivSearchBuilder searchBuilder = new PixivSearchBuilder(Strings.isNullOrEmpty(content) ? "" : content);
@ -360,7 +381,8 @@ public class BotCommandProcess {
                    }

                    long expire = 7200 * 1000;
-                    String propValue = globalProp.getProperty("cache.searchBody.expire", "7200000");
+                    String propValue = SettingProperties
+                            .getProperty(SettingProperties.GLOBAL, "cache.searchBody.expire", "7200000");
                    try {
                        expire = Long.parseLong(propValue);
                    } catch (Exception e) {
@ -385,7 +407,8 @@ public class BotCommandProcess {
        log.debug("正在处理信息...");
        int limit = 8;
        try {
-            limit = Integer.parseInt(globalProp.getProperty("search.ItemCountLimit", "8"));
+            limit = Integer.parseInt(SettingProperties.
+                    getProperty(fromGroup, "search.itemCountLimit", "8"));
        } catch (Exception e) {
            log.warn("参数转换异常!将使用默认值(" + limit + ")", e);
        }
@ -414,7 +437,7 @@ 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(),
@ -429,8 +452,8 @@ public class BotCommandProcess {

                //pageCount

-                String imageMsg = getImageById(illustId, PixivDownload.PageQuality.REGULAR, 1);
-                if (isNoSafe(illustId, globalProp, true)) {
+                String imageMsg = getImageById(fromGroup, illustId, PixivDownload.PageQuality.REGULAR, 1);
+                if (isNoSafe(illustId, SettingProperties.getProperties(fromGroup), true)) {
                    log.warn("作品Id {} 为R-18作品, 跳过.", illustId);
                    continue;
                } else if(isReported(illustId)) {
@ -438,10 +461,20 @@ public class BotCommandProcess {
                    continue;
                }

-                result.append(searchArea.name()).append(" (").append(count).append(" / ").append(limit).append(")\n\t作品id: ").append(illustId)
+                JsonObject illustPreLoadData = getIllustPreLoadData(illustId, false);
+                result.append(searchArea.name()).append(" (").append(count).append(" / ")
+                        .append(limit).append(")\n\t作品id: ").append(illustId)
                        .append(", \n\t作者名: ").append(illustObj.get("userName").getAsString())
                        .append("\n\t作品标题: ").append(illustObj.get("illustTitle").getAsString())
-                        .append("\n\t作品页数: ").append(illustObj.get("pageCount").getAsInt())
+                        .append("\n\t作品页数: ").append(illustObj.get("pageCount").getAsInt()).append("页")
+                        .append("\n\t点赞数：")
+                        .append(illustPreLoadData.get(PreLoadDataComparator.Attribute.LIKE.attrName).getAsInt())
+                        .append("\n\t收藏数：")
+                        .append(illustPreLoadData.get(PreLoadDataComparator.Attribute.BOOKMARK.attrName).getAsInt())
+                        .append("\n\t围观数：")
+                        .append(illustPreLoadData.get(PreLoadDataComparator.Attribute.VIEW.attrName).getAsInt())
+                        .append("\n\t评论数：")
+                        .append(illustPreLoadData.get(PreLoadDataComparator.Attribute.COMMENT.attrName).getAsInt())
                        .append("\n").append(imageMsg).append("\n");
                count++;
            }
@ -452,9 +485,22 @@ public class BotCommandProcess {
        return Strings.nullToEmpty(result.toString()) + "预览图片并非原图，使用“.cgj image -id 作品id”获取原图\n如有不当作品，可使用\".cgj report -id 作品id\"向色图姬反馈。";
    }

+    /**
+     * 获取作品页面的下载链接
+     * @param illustId 作品Id
+     * @param quality 画质类型
+     * @return 返回作品所有页面在Pixiv的下载链接(有防盗链, 考虑要不要设置镜像站)
+     */
    @Command(commandName = "pages")
-    public static String getPagesList(@Argument(name = "id") int illustId, @Argument(name = "quality", force = false) PixivDownload.PageQuality quality) {
+    public static String getPagesList(
+            @Argument(name = "$fromGroup") long fromGroup,
+            @Argument(name = "id") int illustId,
+            @Argument(name = "quality", force = false) PixivDownload.PageQuality quality) {
        try {
+            if(isNoSafe(illustId, SettingProperties.getProperties(fromGroup), false)) {
+                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");
            int index = 0;
@ -468,10 +514,16 @@ public class BotCommandProcess {
        }
    }

+    /**
+     * 获取作品链接
+     * @param fromGroup 来源群(系统提供)
+     * @param illustId 作品Id
+     * @return 返回作品在Pixiv的链接
+     */
    @Command(commandName = "link")
-    public static String artworksLink(@Argument(name = "id") int illustId) {
+    public static String artworksLink(@Argument(name = "$fromGroup") long fromGroup, @Argument(name = "id") int illustId) {
        try {
-            if (isNoSafe(illustId, globalProp, false)) {
+            if (isNoSafe(illustId, SettingProperties.getProperties(fromGroup), false)) {
                log.warn("作品Id {} 已被屏蔽.", illustId);
                return "由于相关设置，该作品已被屏蔽！";
            } else if(isReported(illustId)) {
@ -487,38 +539,22 @@ public class BotCommandProcess {

    /**
     * 通过illustId获取作品图片
+     * @param fromGroup 来源群(系统提供)
     * @param illustId 作品Id
     * @param quality 图片质量
     * @param pageIndex 指定页面索引, 从1开始
     * @return 如果成功, 返回BotCode, 否则返回错误信息.
     */
    @Command(commandName = "image")
-    public static String getImageById(@Argument(name = "id") int illustId,
-                                                   @Argument(name = "quality", force = false) PixivDownload.PageQuality quality,
-                                                   @Argument(name = "page", force = false, defaultValue = "1") int pageIndex) {
+    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);
-        List<String> pagesList;
-        try {
-            pagesList = getIllustPages(illustId, quality, false);
-        } catch (IOException e) {
-            log.error("获取下载链接列表时发生异常", e);
-            return "发生网络异常，无法获取图片！";
-        }
-
-        if(log.isDebugEnabled()) {
-            StringBuilder logBuilder = new StringBuilder("作品Id {} 所有页面下载链接: \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() + " 页)";
-        }

        try {
-            if (isNoSafe(illustId, globalProp, false)) {
+            if (isNoSafe(illustId, SettingProperties.getProperties(fromGroup), false)) {
                log.warn("作品 {} 存在R-18内容且设置\"image.allowR18\"为false，将屏蔽该作品不发送.", illustId);
                return "（根据设置，该作品已被屏蔽！）";
            } else if(isReported(illustId)) {
@ -530,6 +566,26 @@ public class BotCommandProcess {
            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));
@ -554,12 +610,11 @@ public class BotCommandProcess {
                }
            }

-            ImageCacheObject taskObject = new ImageCacheObject(imageCache, illustId, downloadLink, imageFile);
            try {
-                imageCacheExecutor.executorSync(taskObject);
+                ImageCacheStore.executeCacheRequest(new ImageCacheObject(imageCache, illustId, downloadLink, imageFile));
            } catch (InterruptedException e) {
-                log.error("等待图片下载时发生中断", e);
-                return "图片获取失败!";
+                log.warn("图片缓存被中断", e);
+                return "(错误：图片获取超时)";
            }
        } else {
            log.debug("图片 {} 缓存命中.", fileName);
@ -590,7 +645,7 @@ public class BotCommandProcess {
        illustPreLoadDataCache.clear();
        pagesCache.clear();
        searchBodyCache.clear();
-        File imageStoreDir = new File(System.getProperty("cgj.cqRootDir") + "data/image/cgj/");
+        File imageStoreDir = new File(System.getProperty("cgj.botDataDir") + "data/image/cgj/");
        File[] listFiles = imageStoreDir.listFiles();
        if (listFiles == null) {
            log.debug("图片缓存目录为空或内部文件获取失败!");
@ -605,12 +660,18 @@ public class BotCommandProcess {

    /**
     * 举报某一作品
+     * @param fromGroup 来源群(系统提供)
     * @param illustId 需要举报的作品id
     * @param reason 举报原因
     * @return 返回提示信息
     */
    @Command
-    public static String report(@Argument(name = "$fromGroup") long fromGroup, @Argument(name = "$fromQQ") long fromQQ, @Argument(name = "id") int illustId, @Argument(name = "msg", force = false) String reason) {
+    public static String report(
+            @Argument(name = "$fromGroup") long fromGroup,
+            @Argument(name = "$fromQQ") long fromQQ,
+            @Argument(name = "id") int illustId,
+            @Argument(name = "msg", force = false) String reason
+    ) {
        log.warn("收到作品反馈(IllustId: {}, 原因: {})", illustId, reason);
        JsonObject reportJson = new JsonObject();
        reportJson.addProperty("illustId", illustId);
@ -655,7 +716,7 @@ public class BotCommandProcess {
        String illustIdStr = buildSyncKey(Integer.toString(illustId));
        JsonObject illustInfoObj = null;
        if (!illustInfoCache.exists(illustIdStr) || flushCache) {
-            synchronized (illustIdStr) { // TODO: 这里要不做成HashMap存储key而避免使用常量池?
+            synchronized (illustIdStr) {
                if (!illustInfoCache.exists(illustIdStr) || flushCache) {
                    illustInfoObj = pixivDownload.getIllustInfoByIllustId(illustId);
                    illustInfoCache.update(illustIdStr, illustInfoObj, null);
@ -690,7 +751,8 @@ public class BotCommandProcess {
                            .getAsJsonObject(Integer.toString(illustId));

                    long expire = 7200 * 1000;
-                    String propValue = globalProp.getProperty("cache.illustPreLoadData.expire", "7200000");
+                    String propValue = SettingProperties.
+                            getProperty(SettingProperties.GLOBAL, "cache.illustPreLoadData.expire", "7200000");
                    log.debug("PreLoadData有效时间设定: {}", propValue);
                    try {
                        expire = Long.parseLong(propValue);
--- a/src/main/java/net/lamgc/cgj/bot/MessageEventExecutionDebugger.java
+++ b/src/main/java/net/lamgc/cgj/bot/MessageEventExecutionDebugger.java
@ -0,0 +1,77 @@
+package net.lamgc.cgj.bot;
+
+import net.lamgc.cgj.bot.event.MessageEvent;
+import net.lamgc.cgj.bot.event.VirtualLoadMessageEvent;
+import net.lamgc.utils.event.EventExecutor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Properties;
+
+/**
+ * 消息事件处理调试器.
+ * <p>当启用了消息事件处理调试后, 将会根据调试器代号调用指定调试器</p>
+ */
+@SuppressWarnings("unused")
+public enum MessageEventExecutionDebugger {
+
+    /**
+     * PM - 压力测试
+     */
+    PM ((executor, event, properties, log) -> {
+        MessageEvent virtualLoadEvent = VirtualLoadMessageEvent.toVirtualLoadMessageEvent(event, false);
+        int rotation = 5;
+        int number = 50;
+        int interval = 2500;
+
+        try {
+            rotation = Integer.parseInt(properties.getProperty("debug.pm.rotation", "5"));
+        } catch(NumberFormatException ignored) {}
+        try {
+            number = Integer.parseInt(properties.getProperty("debug.pm.number", "50"));
+        } catch(NumberFormatException ignored) {}
+        try {
+            interval = Integer.parseInt(properties.getProperty("debug.pm.interval", "2500"));
+        } catch(NumberFormatException ignored) {}
+
+        boolean interrupted = false;
+        Thread currentThread = Thread.currentThread();
+        for(int rotationCount = 0; rotationCount < rotation && !interrupted; rotationCount++) {
+            for(int sendCount = 0; sendCount < number; sendCount++) {
+                if(currentThread.isInterrupted()) {
+                    interrupted = true;
+                    break;
+                }
+                executor.executor(virtualLoadEvent);
+            }
+            try {
+                Thread.sleep(interval);
+            } catch (InterruptedException e) {
+                break;
+            }
+        }
+    });
+
+    public final MessageExecuteDebugger debugger;
+
+    MessageEventExecutionDebugger(MessageExecuteDebugger debugger) {
+        this.debugger = debugger;
+    }
+
+    public static Logger getDebuggerLogger(MessageEventExecutionDebugger debugger) {
+        return LoggerFactory.getLogger(MessageEventExecutionDebugger.class.getName() + "." + debugger.name());
+    }
+
+    @FunctionalInterface
+    public interface MessageExecuteDebugger {
+        /**
+         * 接收事件并根据指定需求处理
+         * @param executor 事件执行器
+         * @param event 消息事件对象
+         * @param properties 配置项, 调试器应按'debug.[debuggerName].'为前缀存储相应调试信息
+         * @throws Exception 当抛出异常则打断调试, 并输出至日志
+         */
+        void accept(EventExecutor executor, MessageEvent event, Properties properties, Logger logger) throws Exception;
+    }
+
+}
--- a/src/main/java/net/lamgc/cgj/bot/RandomIntervalSendTimer.java
+++ b/src/main/java/net/lamgc/cgj/bot/RandomIntervalSendTimer.java
@ -5,8 +5,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import java.lang.reflect.Field;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;

@ -16,7 +14,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
 public class RandomIntervalSendTimer extends TimerTask {

    private final static Timer timer = new Timer("Thread-RIST");
-    private final static Logger log = LoggerFactory.getLogger("RandomIntervalSendTimer");
+    private final static Logger log = LoggerFactory.getLogger(RandomIntervalSendTimer.class.getName());
    private final static Map<Long, RandomIntervalSendTimer> timerMap = new HashMap<>();

    private final long timerId;
@ -26,6 +24,8 @@ public class RandomIntervalSendTimer extends TimerTask {
    private final int floatTime;
    private AtomicBoolean loop = new AtomicBoolean();
    private final AtomicBoolean start = new AtomicBoolean();
+    private final String hashId = Integer.toHexString(this.hashCode());
+

    /**
     * 创建一个随机延迟发送器
@ -92,8 +92,6 @@ public class RandomIntervalSendTimer extends TimerTask {
        start(this.loop.get());
    }

-    private final static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-ss HH:mm:ss");
-
    /**
     * 启动定时器
     * @param loop 是否循环, 如果为true, 则任务完成后会自动调用start方法继续循环, 直到被调用{@code #}或总定时器被销毁;
@ -103,7 +101,7 @@ public class RandomIntervalSendTimer extends TimerTask {
        long nextDelay = time + timeRandom.nextInt(floatTime);
        Date nextDate = new Date();
        nextDate.setTime(nextDate.getTime() + nextDelay);
-        log.info("定时器 {} 下一延迟: {}ms ({})", Integer.toHexString(this.hashCode()), nextDelay, dateFormat.format(nextDate));
+        log.info("定时器 {} 下一延迟: {}ms ({})", hashId, nextDelay, nextDate);
        if(start.get()) {
            try {
                Field state = this.getClass().getSuperclass().getDeclaredField("state");
--- a/src/main/java/net/lamgc/cgj/bot/RandomRankingArtworksSender.java
+++ b/src/main/java/net/lamgc/cgj/bot/RandomRankingArtworksSender.java
@ -39,7 +39,7 @@ public class RandomRankingArtworksSender extends AutoSender {
        super(messageSender);
        this.mode = mode;
        this.contentType = contentType;
-        log = LoggerFactory.getLogger("RecommendArtworksSender@" + Integer.toHexString(this.hashCode()));
+        log = LoggerFactory.getLogger(this.toString());
        this.rankingStart = rankingStart > 0 ? rankingStart : 1;
        this.rankingStop = rankingStop > 0 ? rankingStop : 150;
        if(this.rankingStart > this.rankingStop) {
@ -77,7 +77,7 @@ public class RandomRankingArtworksSender extends AutoSender {

            JsonObject rankingInfo = rankingList.get(0);
            int illustId = rankingInfo.get("illust_id").getAsInt();
-            if(BotCommandProcess.isNoSafe(illustId, BotCommandProcess.globalProp, false)) {
+            if(BotCommandProcess.isNoSafe(illustId, SettingProperties.getProperties(SettingProperties.GLOBAL), false)) {
                log.warn("作品为r18作品, 取消本次发送.");
                return;
            } else if(BotCommandProcess.isReported(illustId)) {
@ -89,7 +89,7 @@ public class RandomRankingArtworksSender extends AutoSender {
            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(illustId, quality, 1));
+            message.append(BotCommandProcess.getImageById(0, illustId, quality, 1));
            message.append("\n如有不当作品，可使用\".cgj report -id ").append(illustId).append("\"向色图姬反馈。");
            getMessageSender().sendMessage(message.toString());
        } catch (IOException e) {
--- a/src/main/java/net/lamgc/cgj/bot/RankingUpdateTimer.java
+++ b/src/main/java/net/lamgc/cgj/bot/RankingUpdateTimer.java
@ -1,12 +1,12 @@
 package net.lamgc.cgj.bot;

-import com.google.common.base.Throwables;
 import net.lamgc.cgj.bot.event.BotEventHandler;
 import net.lamgc.cgj.bot.event.VirtualLoadMessageEvent;
 import net.lamgc.cgj.pixiv.PixivURL;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

+import java.text.SimpleDateFormat;
 import java.time.LocalDate;
 import java.util.Calendar;
 import java.util.Date;
@ -27,21 +27,23 @@ public class RankingUpdateTimer {
        Calendar cal = Calendar.getInstance();
        cal.setTime(firstRunDate == null ? new Date() : firstRunDate);
        LocalDate currentLocalDate = LocalDate.now();
-        if(cal.get(Calendar.DAY_OF_YEAR) <= currentLocalDate.getDayOfYear() && cal.get(Calendar.HOUR_OF_DAY) >= 12) {
-            cal.set(Calendar.DAY_OF_YEAR, cal.get(Calendar.DAY_OF_YEAR) + 1);
+        if(cal.get(Calendar.DAY_OF_YEAR) <= currentLocalDate.getDayOfYear() &&
+                cal.get(Calendar.HOUR_OF_DAY) >= 11 && cal.get(Calendar.MINUTE) >= 30) {
+            cal.set(Calendar.DAY_OF_YEAR, currentLocalDate.getDayOfYear() + 1);
        }
-        cal.set(Calendar.HOUR_OF_DAY, 12);
+        cal.set(Calendar.HOUR_OF_DAY, 11);
        cal.set(Calendar.MINUTE, 30);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);

-        log.warn("已设置排行榜定时更新, 首次运行时间: {}", cal.getTime());
+        long delay = cal.getTime().getTime() - (System.currentTimeMillis());
+        log.warn("已设置排行榜定时更新, 首次运行时间: {} ({}min)", cal.getTime(), delay / 1000 / 60);
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                now(null);
            }
-        }, cal.getTime(), 86400000); // 1 Day
+        }, delay, 86400000); // 1 Day
    }

    public void now(Date queryDate) {
@ -52,13 +54,14 @@ public class RankingUpdateTimer {
        LocalDate currentLocalDate = LocalDate.now();
        if(calendar.get(Calendar.DAY_OF_YEAR) == currentLocalDate.getDayOfYear() ||
                calendar.get(Calendar.DAY_OF_YEAR) == currentLocalDate.getDayOfYear() - 1) {
-            if(calendar.get(Calendar.HOUR_OF_DAY) < 12) {
+            if(calendar.get(Calendar.HOUR_OF_DAY) < 11) {
                calendar.add(Calendar.DAY_OF_YEAR, -2);
            } else {
                calendar.add(Calendar.DAY_OF_YEAR, -1);
            }
        }

+        String dateStr = new SimpleDateFormat("yyyy-MM-dd").format(calendar.getTime());
        log.info("正在获取 {} 期排行榜数据...", calendar.getTime());
        for (PixivURL.RankingMode rankingMode : PixivURL.RankingMode.values()) {
            for (PixivURL.RankingContentType contentType : PixivURL.RankingContentType.values()) {
@ -66,15 +69,9 @@ public class RankingUpdateTimer {
                    log.debug("不支持的类型, 填空值跳过...(类型: {}.{})", rankingMode.name(), contentType.name());
                }
                log.info("当前排行榜类型: {}.{}, 正在更新...", rankingMode.name(), contentType.name());
-                try {
-                    //BotCommandProcess.getRankingInfoByCache(contentType, rankingMode, calendar.getTime(), 1, 0, true);
-                    BotEventHandler.executor.executorSync(
-                            new VirtualLoadMessageEvent(0,0,
-                                    ".cgj ranking -type=" + contentType.name() + " -mode=" + rankingMode.name()));
-                    log.info("排行榜 {}.{} 更新完成.", rankingMode.name(), contentType.name());
-                } catch (InterruptedException e) {
-                    log.error("排行榜 {}.{} 更新时发生异常. \n{}", rankingMode.name(), contentType.name(), Throwables.getStackTraceAsString(e));
-                }
+                BotEventHandler.executeMessageEvent(new VirtualLoadMessageEvent(0,0,
+                                ".cgj ranking -type=" + contentType.name() + " -mode=" + rankingMode.name() + " -force -date " + dateStr));
+                log.info("排行榜 {}.{} 负载指令已投递.", rankingMode.name(), contentType.name());
            }
        }
        log.warn("定时任务更新完成.");
--- a/src/main/java/net/lamgc/cgj/bot/SettingProperties.java
+++ b/src/main/java/net/lamgc/cgj/bot/SettingProperties.java
@ -0,0 +1,241 @@
+package net.lamgc.cgj.bot;
+
+import com.google.common.base.Throwables;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+
+public final class SettingProperties {
+
+    private final static Logger log = LoggerFactory.getLogger(SettingProperties.class.getName());
+
+    private final static File globalPropFile = new File(getPropertiesDir(), "global.properties");
+    private final static Properties globalProp = new Properties();
+
+    private final static Map<Long, Properties> groupPropMap = new HashMap<>();
+
+    private final static Set<Long> changeList = Collections.synchronizedSet(new HashSet<>());
+
+    /**
+     * 全局配置项
+     */
+    public final static long GLOBAL = 0;
+
+    /**
+     * 清空所有Properties.
+     */
+    public static void clearProperties() {
+        groupPropMap.clear();
+        globalProp.clear();
+    }
+
+    /**
+     * 加载配置文件
+     */
+    public static void loadProperties() {
+        loadGlobalProperties();
+
+        File[] files = getPropertiesDir()
+                .listFiles((dir, fileName) -> fileName.startsWith("group.") && fileName.endsWith(".properties"));
+        if(files == null) {
+            log.error("检索群组配置文件失败, 可能是被拒绝访问.");
+            return;
+        }
+
+        for (File file : files) {
+            String name = file.getName();
+            long groupId;
+            try {
+                groupId = Long.parseLong(name.substring(name.indexOf("group.") + 6, name.lastIndexOf(".properties")));
+            } catch (NumberFormatException e) {
+                log.error("非法的配置文件名: {}", name);
+                continue;
+            }
+            if(!groupPropMap.containsKey(groupId)) {
+                groupPropMap.put(groupId, new Properties(globalProp));
+            }
+
+            loadGroupProperties(groupId, groupPropMap.get(groupId));
+        }
+
+    }
+
+    /**
+     * 保存配置项
+     */
+    public static void saveProperties() {
+        log.info("正在保存所有配置...");
+        saveGlobalProperties();
+
+        for (Long groupId : groupPropMap.keySet()) {
+            if(!changeList.contains(groupId)) {
+                log.debug("群组 {} 配置无改动, 忽略保存.", groupId);
+                return;
+            }
+            log.debug("正在保存群组 {} 配置文件...", groupId);
+            saveGroupProperties(groupId);
+        }
+        log.info("配置保存完成.");
+    }
+
+    /**
+     * 保存指定群组的配置文件
+     * @param groupId 要保存配置的群组Id
+     */
+    private static void saveGroupProperties(long groupId) {
+        try {
+            saveGroupProperties(groupId, getGroupProperties(groupId));
+        } catch (IOException e) {
+            log.error("群组 {} 配置保存失败\n{}", groupId, Throwables.getStackTraceAsString(e));
+        }
+    }
+
+    private static void saveGroupProperties(Long groupId, Properties properties) throws IOException {
+        File groupPropFile = new File(getPropertiesDir(), "group." + groupId + ".properties");
+        if(!groupPropFile.exists() && !groupPropFile.createNewFile()) {
+            log.error("群组 {} 配置文件创建失败!", groupId);
+            return;
+        }
+
+        saveProperties(properties, new FileOutputStream(groupPropFile));
+    }
+
+    private static void loadGlobalProperties() {
+        if(globalPropFile.exists() && globalPropFile.isFile()) {
+            log.info("正在加载全局配置文件...");
+            try (Reader reader = new InputStreamReader(new FileInputStream(globalPropFile), StandardCharsets.UTF_8)) {
+                globalProp.load(reader);
+                log.info("全局配置文件加载完成.");
+            } catch (IOException e) {
+                log.error("加载全局配置文件时发生异常", e);
+            }
+        } else {
+            log.info("未找到全局配置文件，跳过加载.");
+        }
+    }
+
+    /**
+     * 保存全局配置项
+     */
+    private static void saveGlobalProperties() {
+        try {
+            if(!globalPropFile.exists() && !globalPropFile.createNewFile()) {
+                log.error("创建全局配置文件失败.");
+                return;
+            }
+
+            saveProperties(globalProp, new FileOutputStream(globalPropFile));
+        } catch (IOException e) {
+            log.error("全局配置文件保存时发生异常", e);
+        }
+    }
+
+    private static void loadGroupProperties(long groupId, Properties properties) {
+        File propFile = new File(getPropertiesDir(), "group." + groupId + ".properties");
+        Properties groupProp = Objects.requireNonNull(properties);
+        if(!propFile.exists() || !propFile.isFile()) {
+            log.warn("群组 {} 配置文件不存在, 或不是一个文件.({})", groupId, propFile.getAbsolutePath());
+            return;
+        }
+
+        try (Reader reader = new InputStreamReader(new FileInputStream(propFile), StandardCharsets.UTF_8)) {
+            groupProp.load(reader);
+        } catch (IOException e) {
+            log.error("读取群组 {} 群配置文件时发生异常:\n{}", groupId, Throwables.getStackTraceAsString(e));
+        }
+    }
+
+    private static void saveProperties(Properties properties, OutputStream stream) throws IOException {
+        properties.store(new OutputStreamWriter(stream, StandardCharsets.UTF_8), null);
+    }
+
+    /**
+     * 获取配置文件目录
+     * @return 返回目录File对象.
+     */
+    private static File getPropertiesDir() {
+        File propDir = new File(System.getProperty("cgj.botDataDir"), "/setting/");
+        if(!propDir.exists() && !propDir.mkdirs()) {
+            log.warn("Setting文件夹创建失败!");
+        }
+        return propDir;
+    }
+
+    public static String getProperty(long groupId, String key) {
+        return getProperty(groupId, key, null);
+    }
+
+    public static String getProperty(long groupId, String key, String defaultValue) {
+        if(groupId <= 0) {
+            return globalProp.getProperty(key, defaultValue);
+        } else {
+            Properties properties = groupPropMap.get(groupId);
+            return properties == null ? defaultValue : properties.getProperty(key, defaultValue);
+        }
+    }
+
+    /**
+     * 设置配置项
+     * @param groupId 群组Id, 如为0或负数则为全局配置
+     * @param key 配置项key名
+     * @param value 欲设置的新值, 如为null则删除该配置项
+     * @return 返回上一次设定值
+     */
+    public static String setProperty(long groupId, String key, String value) {
+        Objects.requireNonNull(key);
+        Properties targetProperties;
+        if(groupId <= 0) {
+            targetProperties = globalProp;
+        } else {
+            changeList.add(groupId);
+            targetProperties = getGroupProperties(groupId);
+        }
+        String lastValue = targetProperties.getProperty(key);
+        if(value != null) {
+            targetProperties.setProperty(key, value);
+        } else {
+            targetProperties.remove(key);
+        }
+        return lastValue;
+    }
+
+    /**
+     * 获取GlobalProperties
+     * @return 全局Properties
+     */
+    private static Properties getGlobalProperties() {
+        return globalProp;
+    }
+
+    /**
+     * 获取群组Properties
+     * @param groupId 群组Id
+     * @return 如果存在, 返回Properties, 不存在返回null.
+     * @throws IllegalArgumentException 当群组Id 小于或等于0 时抛出.
+     */
+    private static Properties getGroupProperties(long groupId) {
+        if (groupId <= 0) {
+            throw new IllegalArgumentException("Group number cannot be 0 or negative: " + groupId);
+        }
+        if(!groupPropMap.containsKey(groupId)) {
+            groupPropMap.put(groupId, new Properties(globalProp));
+        }
+        return groupPropMap.get(groupId);
+    }
+
+    /**
+     * 获取群组 Properties, 如果指定群组没有 Properties, 则使用GlobalProperties.
+     * @param groupId 指定群组Id
+     * @return 如果群组存在所属Properties, 则返回群组Properties, 否则返回GlobalProperties.
+     */
+    public static Properties getProperties(long groupId) {
+        if(groupPropMap.containsKey(groupId)) {
+            return groupPropMap.get(groupId);
+        }
+        return getGlobalProperties();
+    }
+
+}
--- a/src/main/java/net/lamgc/cgj/bot/cache/AutoCleanTimer.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/AutoCleanTimer.java
@ -0,0 +1,52 @@
+package net.lamgc.cgj.bot.cache;
+
+import com.google.common.base.Throwables;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Set;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+public class AutoCleanTimer extends TimerTask {
+
+    private final static Set<Cleanable> cleanSet = new CopyOnWriteArraySet<>();
+
+    private final static Timer cleanTimer = new Timer("Thread-AutoClean", true);
+
+    private final static Logger log = LoggerFactory.getLogger(AutoCleanTimer.class.getName());
+
+    static {
+        cleanTimer.schedule(new AutoCleanTimer(), 100L);
+    }
+
+    /**
+     * 增加需要定时执行清理的缓存库
+     * @param store 已实现Cleanable的对象
+     */
+    public static void add(Cleanable store) {
+        cleanSet.add(store);
+    }
+
+    /**
+     * 移除已添加的缓存库
+     * @param store 需要从AutoCleanTimer移除的对象
+     */
+    public static void remove(Cleanable store) {
+        cleanSet.remove(store);
+    }
+
+    private AutoCleanTimer() {}
+
+    @Override
+    public void run() {
+        cleanSet.forEach(cleanable -> {
+            try {
+                cleanable.clean();
+            } catch (Exception e) {
+                log.error("{} 执行清理动作时发生异常:\n{}", cleanable.toString(), Throwables.getStackTraceAsString(e));
+            }
+        });
+    }
+}
--- a/src/main/java/net/lamgc/cgj/bot/cache/CacheStoreUtils.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/CacheStoreUtils.java
@ -0,0 +1,35 @@
+package net.lamgc.cgj.bot.cache;
+
+public final class CacheStoreUtils {
+
+    private CacheStoreUtils() {}
+
+    /**
+     * 将 CacheStore 转换成 基于 {@link LocalHashCacheStore} 的 {@link HotDataCacheStore}
+     * <p>通过该方法转换, 会自动启用 自动清理</p>
+     * @param cacheStore 上游缓存库
+     * @param expireTime 热点缓存最小有效期
+     * @param floatRange 缓存浮动最大范围
+     * @param <T> 缓存库数据类型
+     * @return 返回 {@link HotDataCacheStore}
+     */
+    public static <T> CacheStore<T> hashLocalHotDataStore(CacheStore<T> cacheStore, long expireTime, int floatRange) {
+        return hashLocalHotDataStore(cacheStore, expireTime, floatRange, true);
+    }
+
+    /**
+     * 将 CacheStore 转换成 基于 {@link LocalHashCacheStore} 的 {@link HotDataCacheStore}
+     * @param cacheStore 上游缓存库
+     * @param expireTime 热点缓存最小有效期
+     * @param floatRange 缓存浮动最大范围
+     * @param autoClean 是否启用自动清理
+     * @param <T> 缓存库数据类型
+     * @return 返回 {@link HotDataCacheStore}
+     */
+    public static <T> CacheStore<T> hashLocalHotDataStore(CacheStore<T> cacheStore,
+                                                          long expireTime, int floatRange, boolean autoClean) {
+        return new HotDataCacheStore<>(cacheStore, new LocalHashCacheStore<>(), expireTime, floatRange, autoClean);
+    }
+
+
+}
--- a/src/main/java/net/lamgc/cgj/bot/cache/Cleanable.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/Cleanable.java
@ -0,0 +1,10 @@
+package net.lamgc.cgj.bot.cache;
+
+/**
+ * 可清理接口, 实现该接口代表该类拥有清理动作.
+ */
+public interface Cleanable {
+
+    void clean() throws Exception;
+
+}
--- a/src/main/java/net/lamgc/cgj/bot/cache/HotDataCacheStore.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/HotDataCacheStore.java
@ -10,31 +10,36 @@ import java.util.*;
 * @param <T> 存储类型
 * @author LamGC
 */
-public class HotDataCacheStore<T> implements CacheStore<T> {
+public class HotDataCacheStore<T> implements CacheStore<T>, Cleanable {

    private final CacheStore<T> parent;
    private final CacheStore<T> current;
    private final long expireTime;
    private final int expireFloatRange;
    private final Random random = new Random();
-    private final Logger log = LoggerFactory.getLogger(HotDataCacheStore.class.getSimpleName() + "@" + Integer.toHexString(this.hashCode()));
+    private final Logger log = LoggerFactory.getLogger(this.toString());

    /**
     * 构造热点缓存存储对象
     * @param parent 上级缓存存储库
     * @param current 热点缓存存储库, 最好使用本地缓存(例如 {@linkplain LocalHashCacheStore LocalHashCacheStore})
     * @param expireTime 本地缓存库的缓存项过期时间, 单位毫秒;
-     *                   该时间并不是所有缓存项的最终过期时间, 还需要根据expireFloatRange的设定随机设置, 公式:
-     *                   {@code expireTime + new Random().nextInt(expireFloatRange)}
+ *                   该时间并不是所有缓存项的最终过期时间, 还需要根据expireFloatRange的设定随机设置, 公式:
+ *                   {@code expireTime + new Random().nextInt(expireFloatRange)}
     * @param expireFloatRange 过期时间的浮动范围(单位毫秒), 用于防止短时间内大量缓存项失效导致的缓存雪崩
+     * @param autoClean 是否交由{@link AutoCleanTimer}自动执行清理
     */
-    public HotDataCacheStore(CacheStore<T> parent, CacheStore<T> current, long expireTime, int expireFloatRange) {
+    public HotDataCacheStore(CacheStore<T> parent, CacheStore<T> current, long expireTime, int expireFloatRange, boolean autoClean) {
        this.parent = parent;
        this.current = current;
        this.expireTime = expireTime;
        this.expireFloatRange = expireFloatRange;
-        log.debug("HotDataCacheStore初始化完成. (Parent: {}, Current: {}, expireTime: {}, expireFloatRange: {})",
-                parent, current, expireTime, expireFloatRange);
+        if(autoClean) {
+            AutoCleanTimer.add(this);
+        }
+
+        log.debug("HotDataCacheStore初始化完成. (Parent: {}, Current: {}, expireTime: {}, expireFloatRange: {}, autoClean: {})",
+                parent, current, expireTime, expireFloatRange, autoClean);
    }

    @Override
@ -121,4 +126,13 @@ public class HotDataCacheStore<T> implements CacheStore<T> {
    public boolean supportedList() {
        return false;
    }
+
+    @Override
+    public void clean() {
+        for(String key : this.current.keys()) {
+            if(current.exists(key)) {
+                current.remove(key);
+            }
+        }
+    }
 }
--- a/src/main/java/net/lamgc/cgj/bot/cache/ImageCacheHandler.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/ImageCacheHandler.java
@ -21,16 +21,16 @@ import java.util.Set;

 public class ImageCacheHandler implements EventHandler {

-    private final static Logger log = LoggerFactory.getLogger("ImageCacheHandler");
+    private final static Logger log = LoggerFactory.getLogger(ImageCacheHandler.class.getName());

    private final static HttpClient httpClient = HttpClientBuilder.create().setProxy(Main.proxy).build();

    private final static Set<ImageCacheObject> cacheQueue = Collections.synchronizedSet(new HashSet<>());

    @SuppressWarnings("unused")
-    public void getImageToCache(ImageCacheObject event) {
+    public void getImageToCache(ImageCacheObject event) throws Exception {
        if(cacheQueue.contains(event)) {
-            log.debug("图片 {} 已存在相同缓存任务, 跳过.", event.getStoreFile().getName());
+            log.warn("图片 {} 已存在相同缓存任务, 跳过.", event.getStoreFile().getName());
            return;
        } else {
            cacheQueue.add(event);
@ -43,11 +43,11 @@ public class ImageCacheHandler implements EventHandler {
            try {
                if(!storeFile.exists() && !storeFile.createNewFile()) {
                    log.error("无法创建文件(Path: {})", storeFile.getAbsolutePath());
-                    return;
+                    throw new IOException("Failed to create file");
                }
            } catch (IOException e) {
                log.error("无法创建文件(Path: {})", storeFile.getAbsolutePath());
-                e.printStackTrace();
+                throw e;
            }

            HttpGet request = new HttpGet(event.getDownloadLink());
@ -57,11 +57,11 @@ public class ImageCacheHandler implements EventHandler {
                response = httpClient.execute(request);
            } catch (IOException e) {
                log.error("Http请求时发生异常", e);
-                return;
+                throw e;
            }
            if(response.getStatusLine().getStatusCode() != 200) {
                log.warn("Http请求异常：{}", response.getStatusLine());
-                return;
+                throw new IOException("Http Response Error: " + response.getStatusLine());
            }

            log.debug("正在下载...(Content-Length: {}KB)", response.getEntity().getContentLength() / 1024);
@ -69,7 +69,7 @@ public class ImageCacheHandler implements EventHandler {
                IOUtils.copy(response.getEntity().getContent(), fos);
            } catch (IOException e) {
                log.error("下载图片时发生异常", e);
-                return;
+                throw e;
            }
            event.getImageCache().put(URLs.getResourceName(event.getDownloadLink()), storeFile);
        } finally {
--- a/src/main/java/net/lamgc/cgj/bot/cache/ImageCacheStore.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/ImageCacheStore.java
@ -0,0 +1,109 @@
+package net.lamgc.cgj.bot.cache;
+
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Hashtable;
+import java.util.Map;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
+
+public final class ImageCacheStore {
+
+    private final static Logger log = LoggerFactory.getLogger(ImageCacheStore.class.getName());
+
+    private final static Map<ImageCacheObject, Task> cacheMap = new Hashtable<>();
+
+    private final static ThreadPoolExecutor imageCacheExecutor = new ThreadPoolExecutor(
+            4, 6,
+            30L,
+            TimeUnit.SECONDS,
+            new LinkedBlockingQueue<>(100),
+            new ThreadFactoryBuilder()
+                    .setNameFormat("ImageCacheThread-%d")
+                    .build()
+    );
+
+    private final static ImageCacheHandler handler = new ImageCacheHandler();
+
+    private ImageCacheStore() {}
+
+    /**
+     * 传递图片缓存任务, 并等待缓存完成.
+     * @param cacheObject 缓存任务组
+     */
+    public static void executeCacheRequest(ImageCacheObject cacheObject) throws InterruptedException {
+        Task task = getTaskState(cacheObject);
+        if(task.taskState.get() == TaskState.COMPLETE) {
+            return;
+        }
+
+        boolean locked = false;
+        try {
+            if(task.taskState.get() == TaskState.COMPLETE) {
+                return;
+            }
+            task.lock.lock();
+            locked = true;
+            // 双重检查
+            if(task.taskState.get() == TaskState.COMPLETE) {
+                return;
+            }
+
+            // 置任务状态
+            task.taskState.set(TaskState.RUNNING);
+
+            try {
+                Throwable throwable = imageCacheExecutor.submit(() -> {
+                    try {
+                        handler.getImageToCache(cacheObject);
+                    } catch (Throwable e) {
+                        return e;
+                    }
+                    return null;
+                }).get();
+
+                if(throwable == null) {
+                    task.taskState.set(TaskState.COMPLETE);
+                } else {
+                    task.taskState.set(TaskState.ERROR);
+                }
+            } catch (ExecutionException e) {
+                log.error("执行图片缓存任务时发生异常", e);
+            }
+        } finally {
+            if(locked) {
+                task.lock.unlock();
+            }
+        }
+
+    }
+
+    private static Task getTaskState(ImageCacheObject cacheObject) {
+        if(!cacheMap.containsKey(cacheObject)) {
+            cacheMap.put(cacheObject, new Task());
+        }
+        return cacheMap.get(cacheObject);
+    }
+
+    /**
+     * 任务状态
+     */
+    private enum TaskState {
+        READY, RUNNING, COMPLETE, ERROR
+    }
+
+    private static class Task {
+
+        public final ReentrantLock lock = new ReentrantLock(true);
+
+        public final AtomicReference<TaskState> taskState = new AtomicReference<>(TaskState.READY);
+
+        public final Condition condition = lock.newCondition();
+
+    }
+
+}
--- a/src/main/java/net/lamgc/cgj/bot/cache/RedisPoolCacheStore.java
+++ b/src/main/java/net/lamgc/cgj/bot/cache/RedisPoolCacheStore.java
@ -13,7 +13,7 @@ import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Function;

-public abstract class RedisPoolCacheStore<T> implements CacheStore<T> {
+abstract class RedisPoolCacheStore<T> implements CacheStore<T> {

    private final JedisPool jedisPool;
    private final String keyPrefix;
@ -36,7 +36,7 @@ public abstract class RedisPoolCacheStore<T> implements CacheStore<T> {
        if(jedisPool.isClosed()) {
            throw new IllegalStateException("JedisPool is closed");
        }
-        log = LoggerFactory.getLogger(this.getClass().getSimpleName() + "@" + Integer.toHexString(jedisPool.hashCode()));
+        log = LoggerFactory.getLogger(this.getClass().getName() + "@" + Integer.toHexString(jedisPool.hashCode()));
        if(!Strings.isNullOrEmpty(keyPrefix)) {
            this.keyPrefix = keyPrefix.endsWith(".") ? keyPrefix : keyPrefix + ".";
        } else {
--- a/src/main/java/net/lamgc/cgj/bot/event/BotEventHandler.java
+++ b/src/main/java/net/lamgc/cgj/bot/event/BotEventHandler.java
@ -5,17 +5,18 @@ import com.google.common.base.Throwables;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
 import net.lamgc.cgj.bot.BotAdminCommandProcess;
 import net.lamgc.cgj.bot.BotCommandProcess;
+import net.lamgc.cgj.bot.MessageEventExecutionDebugger;
+import net.lamgc.cgj.bot.SettingProperties;
 import net.lamgc.cgj.util.DateParser;
 import net.lamgc.cgj.util.PagesQualityParser;
+import net.lamgc.cgj.util.TimeLimitThreadPoolExecutor;
 import net.lamgc.utils.base.runner.ArgumentsRunner;
 import net.lamgc.utils.base.runner.ArgumentsRunnerConfig;
 import net.lamgc.utils.base.runner.exception.DeveloperRunnerException;
 import net.lamgc.utils.base.runner.exception.NoSuchCommandException;
 import net.lamgc.utils.base.runner.exception.ParameterNoFoundException;
-import net.lamgc.utils.event.EventExecutor;
-import net.lamgc.utils.event.EventHandler;
+import net.lamgc.utils.event.*;
 import net.lamgc.utils.event.EventObject;
-import net.lamgc.utils.event.EventUncaughtExceptionHandler;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import redis.clients.jedis.JedisPool;
@ -25,7 +26,6 @@ import java.net.URI;
 import java.text.SimpleDateFormat;
 import java.util.*;
 import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.regex.Matcher;
@ -39,7 +39,9 @@ public class BotEventHandler implements EventHandler {
    private final ArgumentsRunner processRunner;
    private final ArgumentsRunner adminRunner;

-    private final static Logger log = LoggerFactory.getLogger("BotEventHandler");
+    private final static Logger log = LoggerFactory.getLogger(BotEventHandler.class.getName());
+
+    private final static Map<Long, AtomicBoolean> muteStateMap = new Hashtable<>();

    /**
     * 所有缓存共用的JedisPool
@ -50,9 +52,10 @@ public class BotEventHandler implements EventHandler {
    /**
     * 消息事件执行器
     */
-    public final static EventExecutor executor = new EventExecutor(new ThreadPoolExecutor(
-            (int) Math.ceil(Runtime.getRuntime().availableProcessors() / 2F),
-            Runtime.getRuntime().availableProcessors(),
+    private final static EventExecutor executor = new EventExecutor(new TimeLimitThreadPoolExecutor(
+            0,
+            Math.max(Runtime.getRuntime().availableProcessors(), 4),
+            Math.max(Math.max(Runtime.getRuntime().availableProcessors() * 2, 4), 32),
            30L,
    TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1536),
@ -124,6 +127,29 @@ public class BotEventHandler implements EventHandler {
        BotCommandProcess.initialize();
    }

+    /**
+     * 投递消息事件
+     * @param event 事件对象
+     */
+    @NotAccepted
+    public static void executeMessageEvent(MessageEvent event) {
+        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));
+            } catch(IllegalArgumentException e) {
+                log.warn("未找到指定调试器: '{}'", debuggerName);
+            } catch (Exception e) {
+                log.error("事件调试处理时发生异常", e);
+            }
+        } else {
+            BotEventHandler.executor.executor(event);
+        }
+    }
+
    /**
     * 以事件形式处理消息事件
     * @param event 消息事件对象
@ -134,6 +160,9 @@ public class BotEventHandler implements EventHandler {
        log.debug(event.toString());
        if(!match(msg)) {
            return;
+        } else if(isMute(event.getFromGroup())) {
+            log.debug("机器人已被禁言, 忽略请求.");
+            return;
        }

        Pattern pattern = Pattern.compile("/\\s*(\".+?\"|[^:\\s])+((\\s*:\\s*(\".+?\"|[^\\s])+)|)|(\".+?\"|[^\"\\s])+");
@ -172,7 +201,8 @@ public class BotEventHandler implements EventHandler {
        Object result;
        try {
            if(msg.toLowerCase().startsWith(ADMIN_COMMAND_PREFIX)) {
-                if(!String.valueOf(event.getFromQQ()).equals(BotCommandProcess.globalProp.getProperty("admin.adminId"))) {
+                if(!String.valueOf(event.getFromQQ())
+                        .equals(SettingProperties.getProperty(0, "admin.adminId"))) {
                    result = "你没有执行该命令的权限！";
                } else {
                    result = adminRunner.run(args.length <= 1 ? new String[0] : Arrays.copyOfRange(args, 1, args.length));
@ -185,18 +215,28 @@ public class BotEventHandler implements EventHandler {
        } catch(ParameterNoFoundException e) {
            result = "命令缺少参数: " + e.getParameterName();
        } catch(DeveloperRunnerException e) {
-            log.error("执行命令时发生异常", e);
-            result = "命令执行时发生错误，无法完成！";
+            if (!(e.getCause() instanceof InterruptedException)) {
+                log.error("执行命令时发生异常", e);
+                result = "色图姬在执行命令时遇到了一个错误！";
+            } else {
+                log.error("命令执行超时, 终止执行.");
+                result = "色图姬发现这个命令的处理时间太久了！所以打断了这个命令。";
+            }
        }
-        log.info("命令处理完成.(耗时: {}ms)", System.currentTimeMillis() - time);
-        if(Objects.requireNonNull(result) instanceof String) {
+        long processTime = System.currentTimeMillis() - time;
+        if(Objects.requireNonNull(result) instanceof String && !isMute(event.getFromGroup())) {
            try {
                event.sendMessage((String) result);
            } catch (Exception e) {
                log.error("发送消息时发生异常", e);
            }
+        } else if(isMute(event.getFromGroup())) {
+            log.warn("命令反馈时机器人已被禁言, 跳过反馈.");
        }
-        log.info("命令反馈完成.(耗时: {}ms)", System.currentTimeMillis() - time);
+        long totalTime = System.currentTimeMillis() - time;
+        log.info("命令反馈完成.(事件耗时: {}ms, P: {}%({}ms), R: {}%({}ms))", totalTime,
+                String.format("%.3f", ((double) processTime / (double)totalTime) * 100F), processTime,
+                String.format("%.3f", ((double) (totalTime - processTime) / (double)totalTime) * 100F), totalTime - processTime);
    }

    /**
@ -208,4 +248,40 @@ public class BotEventHandler implements EventHandler {
        return message.startsWith(COMMAND_PREFIX) || message.startsWith(ADMIN_COMMAND_PREFIX);
    }

+    private static boolean isMute(long groupId) {
+        Boolean mute = isMute(groupId, false);
+        return mute != null && mute;
+    }
+
+    /**
+     * 查询某群是否被禁言.
+     * @param groupId 群组Id
+     * @param rawValue 是否返回原始值(当没有该群状态, 且本参数为true时, 将返回null)
+     * @return 返回状态值, 如无该群禁言记录且rawValue = true, 则返回null
+     */
+    public static Boolean isMute(long groupId, boolean rawValue) {
+        if(groupId <= 0) {
+            return false;
+        }
+        AtomicBoolean state = muteStateMap.get(groupId);
+        if(state == null && rawValue) {
+            return null;
+        }
+        return state != null && state.get();
+    }
+
+    /**
+     * 设置机器人禁言状态.
+     * <p>设置该项可防止因机器人在禁言期间反馈请求导致被封号.</p>
+     * @param mute 如果被禁言, 传入true
+     */
+    public static void setMuteState(long groupId, boolean mute) {
+        if(!muteStateMap.containsKey(groupId)) {
+            muteStateMap.put(groupId, new AtomicBoolean(mute));
+        } else {
+            muteStateMap.get(groupId).set(mute);
+        }
+        log.warn("群组 {} 机器人禁言状态已变更: {}", groupId, mute ? "已禁言" : "已解除");
+    }
+
 }
--- a/src/main/java/net/lamgc/cgj/bot/event/MessageEvent.java
+++ b/src/main/java/net/lamgc/cgj/bot/event/MessageEvent.java
@ -12,7 +12,7 @@ public abstract class MessageEvent implements EventObject, MessageSender {
    public MessageEvent(long fromGroup, long fromQQ, String message) {
        this.fromGroup = fromGroup;
        this.fromQQ = fromQQ;
-        this.message = message;
+        this.message = message.trim();
    }

    /**
--- a/src/main/java/net/lamgc/cgj/bot/event/VirtualLoadMessageEvent.java
+++ b/src/main/java/net/lamgc/cgj/bot/event/VirtualLoadMessageEvent.java
@ -5,6 +5,28 @@ package net.lamgc.cgj.bot.event;
 */
 public class VirtualLoadMessageEvent extends MessageEvent {

+    /**
+     * 将任意消息事件转换为假负载消息事件.
+     * <p>转换之后, 除了fromGroup, fromQQ, message外其他信息不会保留</p>
+     * @param event 待转换的消息事件
+     * @param inheritImpl 是否继承除 sendMessage 外的其他 MessageEvent 实现
+     * @return 转换后的消息事件
+     */
+    public static VirtualLoadMessageEvent toVirtualLoadMessageEvent(MessageEvent event, boolean inheritImpl) {
+        if(event instanceof VirtualLoadMessageEvent) {
+            return (VirtualLoadMessageEvent) event;
+        } else if(!inheritImpl) {
+            return new VirtualLoadMessageEvent(event.getFromGroup(), event.getFromQQ(), event.getMessage());
+        } else {
+            return new VirtualLoadMessageEvent(event.getFromGroup(), event.getFromQQ(), event.getMessage()) {
+                @Override
+                public String getImageUrl(String image) {
+                    return event.getImageUrl(image);
+                }
+            };
+        }
+    }
+
    public VirtualLoadMessageEvent(long fromGroup, long fromQQ, String message) {
        super(fromGroup, fromQQ, message);
    }
--- a/src/main/java/net/lamgc/cgj/bot/framework/coolq/CQPluginMain.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/coolq/CQPluginMain.java
@ -18,7 +18,7 @@ public class CQPluginMain extends CQPlugin implements EventHandler {
    public CQPluginMain() {
        // TODO(LamGC, 2020.04.21): SpringCQ无法适配MessageSenderBuilder
        BotEventHandler.preLoad();
-        LoggerFactory.getLogger(this.toString())
+        LoggerFactory.getLogger(CQPluginMain.class.getName())
                .info("BotEventHandler.COMMAND_PREFIX = {}", BotEventHandler.COMMAND_PREFIX);
    }

@ -41,7 +41,7 @@ public class CQPluginMain extends CQPlugin implements EventHandler {
        if(!BotEventHandler.match(event.getMessage())) {
            return MESSAGE_IGNORE;
        }
-        BotEventHandler.executor.executor(new SpringCQMessageEvent(cq, event));
+        BotEventHandler.executeMessageEvent(new SpringCQMessageEvent(cq, event));
        return MESSAGE_BLOCK;
    }

--- a/src/main/java/net/lamgc/cgj/bot/framework/mirai/MiraiMain.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/mirai/MiraiMain.java
@ -6,9 +6,10 @@ import net.lamgc.cgj.bot.message.MessageSenderBuilder;
 import net.lamgc.cgj.bot.framework.mirai.message.MiraiMessageSenderFactory;
 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.FriendMessage;
-import net.mamoe.mirai.message.GroupMessage;
+import net.mamoe.mirai.message.*;
 import net.mamoe.mirai.utils.BotConfiguration;
 import org.apache.commons.net.util.Base64;
 import org.slf4j.Logger;
@ -19,7 +20,7 @@ import java.util.Properties;

 public class MiraiMain implements Closeable {

-    private final Logger log = LoggerFactory.getLogger(this.toString());
+    private final Logger log = LoggerFactory.getLogger(MiraiMain.class.getName());

    private Bot bot;

@ -34,7 +35,7 @@ public class MiraiMain implements Closeable {
            return;
        }

-        File botPropFile = new File("./bot.properties");
+        File botPropFile = new File(System.getProperty("cgj.botDataDir"), "./bot.properties");
        try (Reader reader = new BufferedReader(new FileReader(botPropFile))) {
            botProperties.load(reader);
        } catch (IOException e) {
@ -42,18 +43,46 @@ public class MiraiMain implements Closeable {
            return;
        }

-        bot = BotFactoryJvm.newBot(Long.parseLong(botProperties.getProperty("bot.qq", "0")), Base64.decodeBase64(botProperties.getProperty("bot.password", "")), new BotConfiguration());
-        Events.subscribeAlways(GroupMessage.class, (msg) -> BotEventHandler.executor.executor(new MiraiMessageEvent(msg)));
-        Events.subscribeAlways(FriendMessage.class, (msg) -> BotEventHandler.executor.executor(new MiraiMessageEvent(msg)));
+        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);
+        Events.subscribeAlways(GroupMessageEvent.class, this::executeMessageEvent);
+        Events.subscribeAlways(FriendMessageEvent.class, this::executeMessageEvent);
+        Events.subscribeAlways(BotMuteEvent.class,
+                event -> BotEventHandler.setMuteState(event.getGroup().getId(), true));
+        Events.subscribeAlways(BotUnmuteEvent.class,
+                event -> BotEventHandler.setMuteState(event.getGroup().getId(), false));
        bot.login();
        MessageSenderBuilder.setCurrentMessageSenderFactory(new MiraiMessageSenderFactory(bot));
        BotEventHandler.preLoad();
        bot.join();
    }

+    /**
+     * 处理消息事件
+     * @param message 消息事件对象
+     */
+    private void executeMessageEvent(MessageEvent message) {
+        if(message instanceof GroupMessageEvent) {
+            GroupMessageEvent GroupMessageEvent = (GroupMessageEvent) message;
+            if(BotEventHandler.isMute(GroupMessageEvent.getGroup().getId(), true) == null) {
+                BotEventHandler.setMuteState(GroupMessageEvent.getGroup().getId(),
+                        ((GroupMessageEvent) message).getGroup().getBotMuteRemaining() != 0);
+            }
+        }
+        BotEventHandler.executeMessageEvent(new MiraiMessageEvent(message));
+    }
+
+    /**
+     * 关闭机器人
+     */
    public void close() {
+        if(bot == null) {
+            return;
+        }
        log.warn("正在关闭机器人...");
        bot.close(null);
+        bot = null;
        log.warn("机器人已关闭.");
    }

--- a/src/main/java/net/lamgc/cgj/bot/framework/mirai/message/MiraiMessageEvent.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/mirai/message/MiraiMessageEvent.java
@ -1,29 +1,40 @@
 package net.lamgc.cgj.bot.framework.mirai.message;

-import net.lamgc.cgj.bot.event.MessageEvent;
 import net.lamgc.cgj.bot.message.MessageSender;
 import net.lamgc.cgj.bot.message.MessageSource;
-import net.mamoe.mirai.message.ContactMessage;
-import net.mamoe.mirai.message.GroupMessage;
+import net.mamoe.mirai.message.GroupMessageEvent;
+import net.mamoe.mirai.message.MessageEvent;
 import net.mamoe.mirai.message.data.MessageUtils;

 import java.util.Objects;

-public class MiraiMessageEvent extends MessageEvent {
+public class MiraiMessageEvent extends net.lamgc.cgj.bot.event.MessageEvent {

-    private final ContactMessage messageObject;
+    private final MessageEvent messageObject;
    private final MessageSender messageSender;

-    public MiraiMessageEvent(ContactMessage message) {
-        super(message instanceof GroupMessage ? ((GroupMessage) message).getGroup().getId() : 0,
-                message.getSender().getId(), message.getMessage().contentToString());
+    public MiraiMessageEvent(MessageEvent message) {
+        super(message instanceof GroupMessageEvent ? ((GroupMessageEvent) message).getGroup().getId() : 0,
+                message.getSender().getId(), getMessageBodyWithoutSource(message.getMessage().toString()));
        this.messageObject = Objects.requireNonNull(message);
-        if(message instanceof GroupMessage) {
-            messageSender = new MiraiMessageSender(((GroupMessage) message).getGroup(), MessageSource.Group);
+        if(message instanceof GroupMessageEvent) {
+            messageSender = new MiraiMessageSender(((GroupMessageEvent) message).getGroup(), MessageSource.Group);
        } else {
            messageSender = new MiraiMessageSender(message.getSender(), MessageSource.Private);
        }
+    }

+    /**
+     * 将ContactMessage获得的消息内容删除 Mirai:source 并返回.
+     * <p>该做法比较保守, 防止Mirai:source位置出现变动.</p>
+     * @param message ContactMessage的消息内容;
+     * @return 返回删除了Mirai:source的消息
+     */
+    private static String getMessageBodyWithoutSource(String message) {
+        StringBuilder builder = new StringBuilder(message);
+        int startIndex = builder.indexOf("[mirai:source:");
+        int endIndex = builder.indexOf("]", startIndex) + 1;
+        return builder.delete(startIndex, endIndex).toString();
    }

    @Override
--- 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
@ -11,10 +11,7 @@ import net.lamgc.cgj.bot.message.MessageSender;
 import net.lamgc.cgj.bot.message.MessageSource;
 import net.mamoe.mirai.Bot;
 import net.mamoe.mirai.contact.Contact;
-import net.mamoe.mirai.message.data.Image;
-import net.mamoe.mirai.message.data.Message;
-import net.mamoe.mirai.message.data.MessageChain;
-import net.mamoe.mirai.message.data.MessageUtils;
+import net.mamoe.mirai.message.data.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

@ -29,11 +26,11 @@ public class MiraiMessageSender implements MessageSender {

    private final Contact member;
    private final MessageSource source;
-    private final static Logger log = LoggerFactory.getLogger("MiraiMessageSender");
+    private final static Logger log = LoggerFactory.getLogger(MiraiMessageSender.class.getName());
    private final static CacheStore<String> imageIdCache = new HotDataCacheStore<>(
            new StringRedisCacheStore(BotEventHandler.redisServer, "mirai.imageId"),
            new LocalHashCacheStore<>(),
-            5400000, 1800000);
+            5400000, 1800000, true);

    /**
     * 使用id构造发送器
@ -60,7 +57,7 @@ public class MiraiMessageSender implements MessageSender {
    public int sendMessage(final String message) {
        log.debug("处理前的消息内容:\n{}", message);
        Message msgBody = processMessage(Objects.requireNonNull(message));
-        log.debug("处理后的消息内容(可能出现乱序的情况, 但实际上顺序是没问题的):\n{}", msgBody);
+        log.debug("处理后的消息内容(可能出现乱序的情况, 但实际上顺序是没问题的):\n{}", msgBody.contentToString());
        member.sendMessage(msgBody);
        return 0;
    }
@ -117,6 +114,15 @@ public class MiraiMessageSender implements MessageSender {
                } else {
                    return img;
                }
+            case "face":
+                if(!code.containsParameter("id")) {
+                    return MessageUtils.newChain("(无效的表情Id)");
+                }
+                int faceId = Integer.parseInt(code.getParameter("id"));
+                if(faceId <= 0) {
+                    return MessageUtils.newChain("(无效的表情Id)");
+                }
+                return new Face(faceId);
            default:
                log.warn("解析到不支持的BotCode: {}", code);
                return MessageUtils.newChain("(不支持的BotCode)");
--- a/src/main/java/net/lamgc/cgj/bot/framework/mirai/message/MiraiMessageSenderFactory.java
+++ b/src/main/java/net/lamgc/cgj/bot/framework/mirai/message/MiraiMessageSenderFactory.java
@ -5,6 +5,8 @@ import net.lamgc.cgj.bot.message.MessageSenderFactory;
 import net.lamgc.cgj.bot.message.MessageSource;
 import net.mamoe.mirai.Bot;

+import java.util.Objects;
+
 public class MiraiMessageSenderFactory implements MessageSenderFactory {

    private final Bot bot;
@ -14,15 +16,11 @@ public class MiraiMessageSenderFactory implements MessageSenderFactory {
    }

    @Override
-    public MessageSender createMessageSender(MessageSource source, long id) throws Exception {
-        switch(source) {
-            case Group:
-            case Discuss:
-                return new MiraiMessageSender(bot.getGroup(id), source);
-            case Private:
-                return new MiraiMessageSender(bot.getFriend(id), source);
-            default:
-                throw new NoSuchFieldException(source.toString());
+    public MessageSender createMessageSender(MessageSource source, long id) {
+        Objects.requireNonNull(source);
+        if(id <= 0) {
+            throw new IllegalArgumentException("id cannot be 0 or negative: " + id);
        }
+        return new MiraiMessageSender(bot, source, id);
    }
 }
--- a/src/main/java/net/lamgc/cgj/pixiv/PixivDownload.java
+++ b/src/main/java/net/lamgc/cgj/pixiv/PixivDownload.java
@ -33,7 +33,7 @@ import java.util.function.BiConsumer;

 public class PixivDownload {

-    private final static Logger log = LoggerFactory.getLogger("PixivDownload");
+    private final static Logger log = LoggerFactory.getLogger(PixivDownload.class.getName());

    private final HttpClient httpClient;

@ -285,7 +285,8 @@ public class PixivDownload {
    }

    /**
-     * 获取排行榜
+     * 获取排行榜.
+     * <p>注意: 如果范围实际上没超出, 但返回排行榜不足, 会导致与实际请求的数量不符, 需要检查</p>
     * @param contentType 排行榜类型
     * @param mode 排行榜模式
     * @param time 查询时间
@ -316,7 +317,8 @@ public class PixivDownload {
        int count = 0;
        Gson gson = new Gson();
        ArrayList<JsonObject> results = new ArrayList<>(range);
-        for (int pageIndex = startPages; pageIndex <= endPages && count < range; pageIndex++) {
+        boolean canNext = true;
+        for (int pageIndex = startPages; canNext && pageIndex <= endPages && count < range; pageIndex++) {
            HttpGet request = createHttpGetRequest(PixivURL.getRankingLink(contentType, mode, time, pageIndex, true));
            log.debug("RequestUri: {}", request.getURI());
            HttpResponse response = httpClient.execute(request);
@ -326,10 +328,13 @@ public class PixivDownload {
                throw new IOException("Http Response Error: '" + response.getStatusLine() + "', ResponseBody: '" + responseBody + '\'');
            }

-            JsonArray resultArray = gson.fromJson(responseBody, JsonObject.class).getAsJsonArray("contents");
+            JsonObject resultObject = gson.fromJson(responseBody, JsonObject.class);
+            canNext = resultObject.get("next").getAsJsonPrimitive().isNumber();
+            JsonArray resultArray = resultObject.getAsJsonArray("contents");
            for (int resultIndex = startIndex; resultIndex < resultArray.size() && count < range; resultIndex++, count++) {
                results.add(resultArray.get(resultIndex).getAsJsonObject());
            }
+
            // 重置索引
            startIndex = 0;
        }
--- a/src/main/java/net/lamgc/cgj/pixiv/PixivURL.java
+++ b/src/main/java/net/lamgc/cgj/pixiv/PixivURL.java
@ -53,10 +53,10 @@ public class PixivURL {

    /**
     * P站用户插图列表获取API
+     * <p>所需数据在 body属性内的 illusts(属性名,属性值不重要), manga(多图) pickup(精选)</p>
     * 需要替换的文本:
     * {userId} - 用户ID
     */
-    //TODO: 所需数据在 body属性内的 illusts(属性名,属性值不重要), manga(多图) pickup(精选)
    //{"error":false,"message":"","body":{"illusts":{"74369837":null,"70990542":null,"70608653":null,"69755191":null,"69729450":null,"69729416":null,"69503608":null,"69288766":null,"69083882":null,"69051458":null,"68484200":null,"68216927":null,"68216866":null,"68192333":null,"67915106":null,"67914932":null,"67854803":null,"67854745":null,"67854670":null,"67787211":null,"67772199":null,"67770637":null,"67754861":null,"67754804":null,"67754726":null,"67740486":null,"67740480":null,"67740450":null,"67740434":null,"67726337":null,"67499196":null,"67499163":null,"67499145":null,"67499111":null,"67499085":null,"67499038":null,"67498987":null,"67473178":null,"66271465":null,"63682753":null,"63682697":null,"59385148":null,"59383265":null,"59383240":null,"59383227":null,"59383173":null},"manga":[],"novels":[],"mangaSeries":[],"novelSeries":[],"pickup":[],"bookmarkCount":{"public":{"illust":1,"novel":0},"private":{"illust":0,"novel":0}}}}
    public static final String PIXIV_USER_ILLUST_LIST_URL = "https://www.pixiv.net/ajax/user/{userId}/profile/all";

--- a/src/main/java/net/lamgc/cgj/pixiv/PixivUgoiraBuilder.java
+++ b/src/main/java/net/lamgc/cgj/pixiv/PixivUgoiraBuilder.java
@ -30,7 +30,7 @@ import java.util.zip.ZipInputStream;
 */
 public final class PixivUgoiraBuilder {

-    private final Logger log = LoggerFactory.getLogger(PixivUgoiraBuilder.class.getSimpleName() + "@" + Integer.toHexString(this.hashCode()));
+    private final Logger log = LoggerFactory.getLogger(this.toString());

    private final HttpClient httpClient;
    private final JsonObject ugoiraMeta;
--- a/src/main/java/net/lamgc/cgj/proxy/PixivAccessProxyServer.java
+++ b/src/main/java/net/lamgc/cgj/proxy/PixivAccessProxyServer.java
@ -27,7 +27,7 @@ import java.util.List;
 */
 public class PixivAccessProxyServer {

-    private final Logger log = LoggerFactory.getLogger(this.getClass().getSimpleName());
+    private final Logger log = LoggerFactory.getLogger(PixivAccessProxyServer.class.getName());

    private final HttpProxyServer proxyServer;

--- a/src/main/java/net/lamgc/cgj/util/TimeLimitThreadPoolExecutor.java
+++ b/src/main/java/net/lamgc/cgj/util/TimeLimitThreadPoolExecutor.java
@ -0,0 +1,151 @@
+package net.lamgc.cgj.util;
+
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * 带有时间限制的线程池.
+ * 当线程超出了限制时间时, 将会对该线程发出中断.
+ */
+public class TimeLimitThreadPoolExecutor extends ThreadPoolExecutor {
+
+    /**
+     * 执行时间限制, 单位毫秒.
+     * 默认30s.
+     */
+    private final AtomicLong executeTimeLimit = new AtomicLong();
+
+    /**
+     * 检查间隔时间.
+     * 默认100ms.
+     */
+    private final AtomicLong timeoutCheckInterval = new AtomicLong(100);
+
+    private final Map<Thread, AtomicLong> workerThreadMap = new Hashtable<>();
+
+    private final Thread timeoutCheckThread = createTimeoutCheckThread();
+
+    public TimeLimitThreadPoolExecutor(long executeLimitTime, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
+        setInitialTime(0, executeLimitTime);
+        timeoutCheckThread.start();
+    }
+
+    public TimeLimitThreadPoolExecutor(long executeLimitTime, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
+        setInitialTime(0, executeLimitTime);
+        timeoutCheckThread.start();
+    }
+
+    public TimeLimitThreadPoolExecutor(long executeLimitTime, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
+        setInitialTime(0, executeLimitTime);
+        timeoutCheckThread.start();
+    }
+
+    public TimeLimitThreadPoolExecutor(long executeLimitTime, int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
+        setInitialTime(0, executeLimitTime);
+        timeoutCheckThread.start();
+    }
+
+    private void setInitialTime(long checkInterval, long executeLimitTime) {
+        if(checkInterval > 0) {
+            timeoutCheckInterval.set(checkInterval);
+        }
+        if(executeLimitTime > 0) {
+            executeTimeLimit.set(executeLimitTime);
+        }
+    }
+
+    /**
+     * 设置执行时间.
+     * <p>注意: 该修改仅在线程池完全停止后才有效</p>
+     * @see #isTerminated()
+     * @param time 新的限制时间(ms)
+     */
+    public void setExecuteTimeLimit(long time) {
+        if(time <= 0) {
+            throw new IllegalArgumentException("Time is not allowed to be set to 0 or less");
+        }
+        if(this.isTerminated()) {
+            executeTimeLimit.set(time);
+        }
+    }
+
+    /**
+     * 设置超时检查间隔.
+     * <p>该方法仅会在当前检查后生效.</p>
+     * @param time 新的检查间隔(ms)
+     */
+    public void setTimeoutCheckInterval(long time) {
+        if(time <= 0) {
+            throw new IllegalArgumentException("Time is not allowed to be set to 0 or less");
+        }
+        timeoutCheckInterval.set(time);
+    }
+
+    /**
+     * 获取当前设置的执行时间限制.
+     * @return 执行时间限制(ms).
+     */
+    public long getExecuteTimeLimit() {
+        return executeTimeLimit.get();
+    }
+
+    /**
+     * 获取当前设定的超时检查间隔
+     * @return 间隔时间(ms).
+     */
+    public long getTimeoutCheckInterval() {
+        return timeoutCheckInterval.get();
+    }
+
+    private Thread createTimeoutCheckThread() {
+        Thread checkThread = new Thread(() -> {
+            if(executeTimeLimit.get() <= 0) {
+                return;
+            }
+            while (true) {
+                try {
+                    long interval = this.timeoutCheckInterval.get();
+                    Thread.sleep(interval);
+
+                    // 检查是否存在超时的任务
+                    workerThreadMap.forEach((thread, time) -> {
+                        long currentTime = time.getAndAdd(interval);
+                        if(currentTime > executeTimeLimit.get()) {
+                            if(!thread.isInterrupted()) {
+                                thread.interrupt();
+                            }
+                        }
+                    });
+                } catch(InterruptedException ignored) {
+                    break;
+                }
+            }
+        });
+
+        checkThread.setName("ThreadPool-" + Integer.toHexString(this.hashCode()) +"-TimeoutCheck");
+        return checkThread;
+    }
+
+    @Override
+    protected void beforeExecute(Thread t, Runnable r) {
+        workerThreadMap.put(t, new AtomicLong());
+        super.beforeExecute(t, r);
+    }
+
+    @Override
+    protected void afterExecute(Runnable r, Throwable t) {
+        workerThreadMap.remove(Thread.currentThread());
+        super.afterExecute(r, t);
+    }
+
+    @Override
+    protected void terminated() {
+        this.timeoutCheckThread.interrupt();
+        super.terminated();
+    }
+}
--- a/src/main/resources/log4j2-test.xml
+++ b/src/main/resources/log4j2-test.xml
@ -4,6 +4,7 @@
        <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="logsDir">${sys:cgj.logsPath:-logs}</property>
    </properties>

    <Appenders>
@ -20,7 +21,7 @@
            </Filters>
        </Console>

-        <RollingFile name="rollingFile" fileName="logs/latest.log" filePattern="logs/running.%-d{yyyy-MM-dd_HH-mm-ss}.log.gz">
+        <RollingFile name="rollingFile" fileName="${logsDir}/latest.log" filePattern="${logsDir}/running.%-d{yyyy-MM-dd_HH-mm-ss}.log.gz">
            <PatternLayout pattern="${pattern}" charset="${charset}"/>
            <Policies>
                <OnStartupTriggeringPolicy />
--- a/src/main/resources/log4j2.xml
+++ b/src/main/resources/log4j2.xml
@ -4,6 +4,7 @@
        <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="logsDir">${sys:cgj.logsPath:-logs}</property>
    </properties>

    <Appenders>
@ -20,7 +21,7 @@
            </Filters>
        </Console>

-        <RollingFile name="rollingFile" fileName="logs/latest.log" filePattern="logs/running.%-d{yyyy-MM-dd_HH-mm-ss}.log.gz">
+        <RollingFile name="rollingFile" fileName="${logsDir}/latest.log" filePattern="${logsDir}/running.%-d{yyyy-MM-dd_HH-mm-ss}.log.gz">
            <PatternLayout pattern="${pattern}" charset="${charset}"/>
            <Policies>
                <OnStartupTriggeringPolicy />
--- a/src/test/java/net/lamgc/cgj/pixiv/PixivDownloadTest.java
+++ b/src/test/java/net/lamgc/cgj/pixiv/PixivDownloadTest.java
@ -31,7 +31,7 @@ public class PixivDownloadTest {

    private static CookieStore cookieStore;

-    private final static Logger log = LoggerFactory.getLogger("PixivDownloadTest");
+    private final static Logger log = LoggerFactory.getLogger(PixivDownloadTest.class.getName());

    private static HttpHost proxy = new HttpHost("127.0.0.1", 1001);
    
@ -180,9 +180,8 @@ public class PixivDownloadTest {

        log.info("正在调用方法...");
        try {
-            pixivDownload.getRankingAsInputStream(null, null, queryDate, 5, 50, PixivDownload.PageQuality.ORIGINAL, (rank, link, rankInfo, inputStream) -> {
-                log.info("空操作");
-            });
+            pixivDownload.getRankingAsInputStream(null, null, queryDate, 5, 50,
+                    PixivDownload.PageQuality.ORIGINAL, (rank, link, rankInfo, inputStream) -> log.info("空操作"));
        } finally {
            zos.finish();
            zos.flush();
--- a/src/test/java/net/lamgc/cgj/util/TimeLimitThreadPoolExecutorTest.java
+++ b/src/test/java/net/lamgc/cgj/util/TimeLimitThreadPoolExecutorTest.java
@ -0,0 +1,30 @@
+package net.lamgc.cgj.util;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+public class TimeLimitThreadPoolExecutorTest {
+
+    @Test
+    public void timeoutTest() throws InterruptedException {
+        TimeLimitThreadPoolExecutor executor = new TimeLimitThreadPoolExecutor(1000, 1, 1, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(50));
+        System.out.println(executor.isTerminated());
+        System.out.println(executor.isShutdown());
+
+        executor.setTimeoutCheckInterval(150);
+        System.out.println("当前设定: ETL: " + executor.getExecuteTimeLimit() + "ms, TCI: " + executor.getTimeoutCheckInterval() + "ms");
+        executor.execute(() -> {
+            try {
+                Thread.sleep(5 * 1000);
+            } catch (InterruptedException e) {
+                System.out.println("线程 " + Thread.currentThread().getName() + " 被中断");
+            }
+        });
+        executor.shutdown();
+        Assert.assertTrue(executor.awaitTermination(5 * 1000, TimeUnit.MILLISECONDS));
+    }
+
+}
Author	SHA1	Message	Date
LamGC	04c1753c22	[Version] 更新版本(2.5.1 -> 2.5.2-20200517.1-SNAPSHOT);	2020-05-17 17:45:06 +08:00
LamGC	d993e9d719	[Add] MiraiMessageSender 增加对默认表情的支持;	2020-05-12 15:25:29 +08:00
LamGC	60e91987d1	Merge branch 'mirai'	2020-05-12 15:14:58 +08:00
LamGC	65392fc2fe	[Fix] net.mamoe:mirai-core, net.mamoe:mirai-core-qqandroid 更新Mirai-Core版本号以修复VerifyError问题(1.0-RC2 -> 1.0-RC2-1); [Fix] MiraiMessageSender 调整日志输出, 以修复日志打印处理后消息顺序混乱的问题;	2020-05-12 15:14:28 +08:00
LamGC	d38934a0f4	[Change] RankingUpdateTimer 调整时间补齐的阀值(12:00 -> 11:30); [Add] documents/interfaces/* 整理部分Pixiv接口的文档;	2020-05-12 15:03:08 +08:00
LamGC	7943357d96	[Fix] MiraiMain 修复未登录时异常退出, 抛出NPE的问题;	2020-05-11 12:16:35 +08:00
LamGC	a170ff040b	[Update] net.mamoe:mirai-core, net.mamoe:mirai-core-qqandroid 更新依赖项版本(0.39.4 -> 1.0-RC2); [Update] MiraiMain, MiraiMessageEvent 适配mirai新版本; [Change] MiraiMessageSenderFactory 增加参数检查并优化过程; [Change] MiraiMain 显性指定Mirai所用协议为'BotConfiguration.MiraiProtocol.ANDROID_PAD';	2020-05-11 11:36:37 +08:00
LamGC	cb2ebfdb73	[Change] MessageEvent 对消息内容删除首尾空格以提高用户体验性;	2020-05-09 23:13:53 +08:00
LamGC	66b22c543a	[Fix] SettingProperties 修复了配置文件无法创建, 导致无法保存配置的问题; [Fix] Main 修复了潜在的文件创建失败的问题;	2020-05-09 22:54:32 +08:00
LamGC	6bace4b048	[Version] 更新版本(2.5.0 -> 2.5.1);	2020-05-09 22:35:46 +08:00
LamGC	597aac4e95	[Fix] BotCommandProcess 修复部分指令无法使用群组配置的问题;	2020-05-09 22:35:21 +08:00
LamGC	181d60285b	[Version] 更新版本(2.5.0-20200509.1-SNAPSHOT -> 2.5.0);	2020-05-09 22:20:07 +08:00
LamGC	c06b8717c3	[Add] CacheStoreUtils 增加用于缓存库的工具类; [Update] BotCommandProcess 补充注释, 优化"info"命令输出内容的格式;	2020-05-09 22:19:29 +08:00
LamGC	b4a28b6735	[Version] 更新版本(2.5.0-20200506.1-SNAPSHOT -> 2.5.0-20200509.1-SNAPSHOT);	2020-05-09 18:16:54 +08:00
LamGC	40057c3683	[Fix] Issue #1 修复了ImageCache对重复缓存请求的策略(忽略并返回)导致的后续处理发生NPE的问题; [Update] ImageCache 更新了ImageCache, 将该部分单独分离到 ImageCacheStore; [Update] BotCommandProcess 适配新的ImageCache, 调整内容检查的时机以减少不必要的API访问;	2020-05-09 18:16:16 +08:00
LamGC	4beb4d78fb	[Fix] BotCommandProcess 修复Search命令格式不正确的问题;	2020-05-09 12:52:15 +08:00
LamGC	d9edaa681f	[Add] BotAdminCommandProcess 为 addPushGroup 增加参数检查;	2020-05-09 10:10:48 +08:00
LamGC	7b52abde60	[Change] BotCommandProcess 增加Search命令的反馈内容(可能必须要QQ支持长文本才能使用);	2020-05-08 23:31:24 +08:00
LamGC	2cb4fe1dbc	[Fix] SettingProperties 修复无法设置全局配置项的问题;	2020-05-08 12:23:43 +08:00
LamGC	5830327dad	[Add] BotEventHandler 增加禁言记录, 防止应用因过多的在禁言状态反馈导致被封号; [Update] MiraiMain 适配禁言记录功能;	2020-05-07 19:46:54 +08:00
LamGC	cbd10ff281	[Fix] Issue #4 修复因Mirai API变动导致应用无法从消息获取ImageId的问题;	2020-05-07 18:24:09 +08:00
LamGC	84b8006f89	[Change] RankingUpdateTimer 将定时更新时间调整为"+8 11:30", 并增加日期指定;	2020-05-07 15:21:05 +08:00
LamGC	d32d891ad7	[Update] BotCommandProcess 补充Javadoc内容; [Add] BotCommandProcess 在Ranking命令增加force参数以允许强制查询预计不在排行榜范围的日期;	2020-05-07 11:29:31 +08:00
LamGC	aabd35ce71	[Add] AutoCleanTimer, Cleanable 增加缓存库自动清理; [Update] HotDataCacheStore 增加对自动清理的支持; [Change] RedisPoolCacheStore 将Redis缓存库抽象类设为default(原public); [Change] MiraiMessageSender, BotCommandProcess 适配HotDataCacheStore的修改; [Change] BotCommandProcess 调整ranking命令的输出格式;	2020-05-07 10:26:11 +08:00
LamGC	a36eb713d7	[Version] 更新版本(2.5.0-20200505.1-SNAPSHOT -> 2.5.0-20200506.1-SNAPSHOT);	2020-05-06 11:09:18 +08:00
LamGC	f452c1c128	Merge branch 'add-MultiProperties'	2020-05-06 11:08:16 +08:00
LamGC	cb42aadb15	[Fix] SettingProperties 修复在初次设置群组配置时未创建该群组所属Properties导致NPE的问题; [Update] BotAdminCommandProcess 更新日志内容及命令返回信息; [Change] BotCommandProcess 调整配置项key格式;	2020-05-06 10:55:32 +08:00
LamGC	b969bb29b2	Merge branch 'master' into add-MultiProperties	2020-05-06 10:18:00 +08:00
LamGC	0d74007a98	[Change] search.txt 整理接口相关文档的存储目录;	2020-05-06 09:42:34 +08:00
LamGC	edade24883	[Change] Issue #2 调整Logger Name以统一Logger Name格式;	2020-05-06 09:34:28 +08:00
LamGC	34f57404ca	[Update] 重构Setting Properties, 使其支持分群配置;	2020-05-06 00:57:48 +08:00
LamGC	99b6e14ff7	[Change] RandomIntervalSendTimer 调整日志输出内容;	2020-05-05 17:09:45 +08:00
LamGC	c8fe2c3fdd	[Version] 更新版本(2.5.0-20200504.2-SNAPSHOT -> 2.5.0-20200505.1-SNAPSHOT); [Update] net.lamgc:java-utils 更新依赖版本(1.1.0 -> 1.2.0_20200505.1-SNAPSHOT);	2020-05-05 01:29:11 +08:00
LamGC	49a33d4078	[Add] MessageEventExecutionDebugger 添加对消息处理的调试器Enum; [Add] BotEventHandler 添加对 MessageEventExecutionDebugger 的支持; [Add] VirtualLoadMessageEvent 增加 toVirtualLoadMessageEvent(MessageEvent) 方法;	2020-05-05 01:27:10 +08:00
LamGC	cd1d2316ee	[Add] BotEventHandler 添加executeMessageEvent(MessageEvent)方法; [Change] BotEventHandler 将BotEventHandler.executor设为private; [Change] MiraiMain, CQPluginMain, RankingUpdateTimer 适配BotEventHandler的调整	2020-05-04 23:06:07 +08:00
LamGC	cf08353ed9	[Change] BotEventHandler 调整事件处理线程池的线程数(min: 4, Max: 32);	2020-05-04 22:52:47 +08:00
LamGC	bef6a684b9	[Change] BotEventHandler 调整事件处理线程池的线程数;	2020-05-04 22:46:06 +08:00
LamGC	04960889b4	[Version] 更新版本(2.5.0-20200504.01-SNAPSHOT -> 2.5.0-20200504.2-SNAPSHOT); [Update] net.lamgc:java-utils 更新依赖版本(1.1.0_5-SNAPSHOT -> 1.1.0); [Update] net.lamgc:PixivLoginProxyServer 更新依赖版本(1.1.0 -> 1.1.1);	2020-05-04 19:44:11 +08:00
LamGC	0dc8fc78b4	[Version] 更新版本(2.4.0 -> 2.5.0-20200504.01-SNAPSHOT);	2020-05-04 17:07:47 +08:00
LamGC	40c5284be2	[Change] Dockerfile.sample 调整构建指令顺序以充分利用构建缓存; [Fix] Main 修复SystemProperties设置null抛出NPE的问题;	2020-05-04 17:07:39 +08:00
Rua! (LamGC)	46cb47c7d1	[Add] LICENSE 添加开源许可证(LGPLv3);	2020-05-04 16:55:16 +08:00
LamGC	fe213deecb	[Change] Main 调整参数的接收形式; [Fix] Dockerfile.sample 修复Java应用无法接收stop命令发送信号的问题; [Change] RankingUpdateTimer 调整更新投递形式, 将同步更新调整为异步更新; [Change] BotEventHandler 实装TimeLimitThreadPoolExecutor;	2020-05-04 02:07:46 +08:00
LamGC	f279d99fda	[Add] TimeLimitThreadPoolExecutor 增加一个带有执行时间限制的线程池及对应单元测试类;	2020-05-04 02:04:59 +08:00
LamGC	a09aef5be2	[Delete] 删除已完成或已经没有存在意义的TODO;	2020-05-02 10:40:11 +08:00
LamGC	766411fa09	[Fix] Dockerfile.sample 修复应用无法接收容器退出信号的问题(现在应用将可以接受信号主动退出, 即使ExitCode不为0);	2020-05-02 00:56:05 +08:00
LamGC	84b544cea9	[Change] Main 调整日志输出级别, 补充日志输出内容; [Change] Dockerfile.sample 调整镜像内应用运行路径;	2020-05-01 22:28:15 +08:00
LamGC	2f492f5b03	[Add] log4j2.xml, log4j2-test.xml 添加允许指定日志存储目录的功能(sys:cgj.logsPath);	2020-05-01 13:19:08 +08:00
LamGC	15af939c3f	[Fix] PixivDownload 修复因排行榜总量的不确定导致排行榜获取异常的问题; [Change] BotEventHandler 调整事件处理完成后的日志输出形式;	2020-04-30 19:08:34 +08:00
LamGC	a28cb142b4	[Change] 调整数据存储的路径设置及存储目录参数名;	2020-04-30 17:51:57 +08:00