update to 2.2.3 version, I am tired

fix access_token not working fix waitMessage() not working in v2.2.2
update to 2.2.2 version finally
2026-07-02 22:35:38 +08:00 · 2021-01-30 00:06:42 +08:00 · 2021-01-29 23:34:34 +08:00 · 2021-01-29 22:32:29 +08:00 · 2021-01-29 22:27:10 +08:00 · 2021-01-29 21:37:02 +08:00
55 changed files with 1221 additions and 214 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,4 @@ composer.lock
 /bin/.phpunit.result.cache
 /resources/zhamao.service
 .phpunit.result.cache
+.daemon_pid
--- a/README.md
+++ b/README.md
@@ -60,7 +60,7 @@ public function index() {
 - 易用的上下文，模块内随处可用
 - 采用模块化编写，可单独拆装功能
 - 常驻内存，全局缓存变量随处使用
- 自带 MySQL、Refis 等数据库连接池等数据库连接方案
+- 自带 MySQL、Redis 等数据库连接池等数据库连接方案
 - 自带 HTTP 服务器、WebSocket 服务器可复用，可以构建属于自己的 HTTP API 接口
 - 静态文件服务器

--- a/bin/start
+++ b/bin/start
@@ -1,28 +1,14 @@
 #!/usr/bin/env php
 <?php

-use ZM\ConsoleApplication;
-
-// 这行是用于开发者自己电脑的调试功能
-
-$symbol = sha1(is_file("/flag2") ? file_get_contents("/flag2") : '1') == '6252c0ec7fcbd544c3d6f5f0a162f60407d7a896' || mb_strpos(getcwd(), "/private/tmp");
-
-// 首先得判断是直接从library模式启动的框架还是从composer引入library启动的框架
-// 判断方法：判断当前目录上面有没有 /vendor 目录，如果没有 /vendor 目录说明是从 composer 引入的
-//         否则就是直接从 framework 项目启动的
-if (!is_dir(__DIR__ . '/../vendor') || $symbol) {
+if (!is_dir(__DIR__ . '/../vendor')) {
    define("LOAD_MODE", 1); //composer项目模式
    define("LOAD_MODE_COMPOSER_PATH", getcwd());
    /** @noinspection PhpIncludeInspection */
    require_once LOAD_MODE_COMPOSER_PATH . "/vendor/autoload.php";
-} elseif (substr(__DIR__, 0, 7) == 'phar://') {
-    define("LOAD_MODE", 2); //phar模式
-    // 会废弃phar启动的方式，在2.0
 } else {
-    define("LOAD_MODE", 0);
+    define("LOAD_MODE", 0); //源码模式
    require_once __DIR__ . "/../vendor/autoload.php";
 }
-// 终端的命令行功能启动！！
-$application = new ConsoleApplication("zhamao-framework");
-$application->initEnv();
-$application->run();
+
+(new ZM\ConsoleApplication("zhamao-framework"))->initEnv()->run();
--- a/composer.json
+++ b/composer.json
@@ -3,7 +3,7 @@
    "description": "High performance QQ robot and web server development framework",
    "minimum-stability": "stable",
    "license": "Apache-2.0",
-    "version": "2.1.5",
+    "version": "2.2.3",
    "extra": {
        "exclude_annotate": [
            "src/ZM"
@@ -37,7 +37,8 @@
        "zhamao/config": "^1.0",
        "zhamao/request": "*@dev",
        "symfony/routing": "^5.1",
-        "symfony/polyfill-php80": "^1.20"
+        "symfony/polyfill-php80": "^1.20",
+        "ext-posix": "*"
    },
    "suggest": {
        "ext-ctype": "*",
--- a/config/global.php
+++ b/config/global.php
@@ -36,13 +36,19 @@ $config['swoole'] = [

 /** 轻量字符串缓存，默认开启 */
 $config['light_cache'] = [
-    'size' => 1024,                     //最多允许储存的条数（需要2的倍数）
-    'max_strlen' => 16384,               //单行字符串最大长度（需要2的倍数）
+    'size' => 512,                     //最多允许储存的条数（需要2的倍数）
+    'max_strlen' => 32768,               //单行字符串最大长度（需要2的倍数）
    'hash_conflict_proportion' => 0.6,   //Hash冲突率（越大越好，但是需要的内存更多）
    'persistence_path' => $config['zm_data'].'_cache.json',
    'auto_save_interval' => 900
 ];

+/** 大容量跨进程变量存储（2.2.0可用） */
+$config["worker_cache"] = [
+    "worker" => 0,
+    "transaction_timeout" => 30000
+];
+
 /** MySQL数据库连接信息，host留空则启动时不创建sql连接池 */
 $config['sql_config'] = [
    'sql_host' => '',
@@ -72,7 +78,7 @@ $config["access_token"] = '';

 /** HTTP服务器固定请求头的返回 */
 $config['http_header'] = [
-    'X-Powered-By' => 'zhamao-framework',
+    'Server' => 'zhamao-framework',
    'Content-Type' => 'text/html; charset=utf-8'
 ];

--- a/docs/advanced/connect-ws-client.md
+++ b/docs/advanced/connect-ws-client.md
@@ -0,0 +1,143 @@
+# 接入 WebSocket 客户端
+
+炸毛框架其实从本质上讲，就是一个 HTTP + WebSocket 服务器，所以框架也支持对接其他任何 HTTP 客户端和 WebSocket 客户端，实际上炸毛框架非常适合用 WebSocket 做在线的 IM 聊天通讯，也可以方便地进行 WS 通信。这里主要说明如何对接一个自定义的 WebSocket 客户端。
+
+## 类型指定
+
+由于 WebSocket 连接都具有同样的性质，没有状态，所以在建立 WebSocket 连接的时候，需要客户端表明自己的身份和类型。指定客户端连接类型的方式有两种：
+
+- `GET` 参数传递，在连接的时候，加上 GET 参数 `type` 即可。比如 js 中 WebSocket 建立时地址写：`ws://127.0.0.1:20001/?type=foo`，这时传入的连接就是 `foo` 类型。
+- `Header` 传递，用户需要在建立连接时指定 HTTP 的头部信息 `X-Client-Role`，例如 `X-Client-Role: foo`，这时传入的连接就是 `foo` 类型。
+
+以上两种方式，`Header` 方式比 `GET` 方式优先级要高，如果两者均没有指定，框架会将此连接当作 `default` 类型接入。
+
+!!! note "提示"
+
+	对于对接 OneBot 标准的机器人客户端，只要符合 OneBot 标准，即 `X-Client-Role` 会自动带上 `universal`、`qq` 等字样，就会自动标记为 `qq` 类型。
+
+## 逻辑编写
+
+传入连接后，我们就能通过注解事件绑定来做我们自己想做的事情了！比如下方是传入类型为 foo 连接要做的事情
+
+```php
+<?php
+namespace Module\Example;
+use ZM\Annotation\Swoole\OnOpenEvent;
+use ZM\Console\Console;
+use ZM\ConnectionManager\ConnectionObject;
+class Hello {
+	/**
+ 	 * @OnOpenEvent("foo")
+ 	 */
+	public function onFooConnect(ConnectionObject $conn) {
+	    Console::info($conn->getName()." 已连接！");
+	}
+```
+
+以上作用就是在终端输出 `foo 已连接！` 这个提示的。关于 `ConnectionObject` 对象，见下方。
+
+## WS 连接对象
+
+对于每一个 WebSocket 连接，框架内都有一个专属的操作类，有获取类型名称、保存链接参数和属性以及获取文件标识符等功能。
+
+### getFd()
+
+获取文件标示符，用于发送消息、接收消息等。这个参数获取的 `fd` 是 Swoole 指定的，用于发送信息等。
+
+```php
+$fd = $conn->getFd();
+server()->send($fd, "hello world");
+```
+
+> WebSocket 是全双工的，所以发送和接收其实是互不干扰的，你可以不仅仅在 WebSocket 相关的上下文中，还可以比如在 HTTP 或者机器人上下文中给别的 WebSocket 客户端发请求。
+
+### getName()
+
+获取连接对象绑定的连接类型，例如上方提到的 `foo`、`default` 等。
+
+```php
+Console::info("当前连接类型：".$conn->getName()); //当前连接类型：foo
+```
+
+### setName()
+
+改变连接对象绑定的连接类型，例如从 `foo` 改为 `bar`。
+
+```php
+$s = $conn->getName(); // foo
+$conn->setName("bar");
+$s = $conn->getName(); // bar
+```
+
+### getOptions()
+
+获取此连接存储的所有参数，以数组形式。存储内容见下方 `setOption()`。
+
+格式：`["参数1" => {参数1的值}, "参数2" => {参数2的值}]`
+
+### getOption()
+
+获取此连接存储的参数，获取指定名称的，此方法拥有一个参数 `$key`，指定即可获取。
+
+如果没有对应参数，则返回 `null`。
+
+我们在前面的机器人部分知道，框架主要是用于机器人的连接，那么机器人客户端在连接后，比如我们想知道这个机器人的 WS 连接对应的是哪个 QQ 号的机器人，我们就可以用 `getOption("connect_id")` 来获取。这个 `connect_id` 是 OneBot 标准的客户端接入后自动填入的一个参数。例如，我们想在机器人接入后打出接入机器人的 QQ 号：
+
+```php
+/**
+ * @OnOpenEvent("qq")
+ */
+public function onQQConnect($conn) {
+    Console::success("机器人 ".$conn->getOption("connect_id")." 已连接！"); // 机器人 123456 已连接！
+}
+```
+
+### setOption()
+
+设置连接存储的参数。参数：`setOption($key, $value)`。`$key` 限定为 `connect_id` 一种。（因为目前有了 LightCache，所以这里暂时不提供别的 key 设定）
+
+```php
+$conn->setOption("connect_id", "asdasdasd"); // $value 最长长度为 29
+```
+
+## 发送到 WebSocket 客户端
+
+很简单，从上面获取到 `fd` 后使用下面的方式就可以了～
+
+```php
+server()->push($conn->getFd(), "hello"); // 第二个为 string 类型的参数
+```
+
+## 从客户端接收
+
+接收消息必须从 `@OnMessageEvent` 注解事件下接收，使用上下文 `ctx()->getFrame()` 获取消息帧。
+
+从这里获取的 `Frame` 对象，见 [Swoole 文档 - Frame](https://wiki.swoole.com/#/websocket_server?id=swoolewebsocketframe)。
+
+Frame 对象有四个参数：
+
+- `$frame->fd`：获取发来帧的 fd
+- `$frame->data`：数据本体
+- `$frame->opcode`：数据类型 int 值，见 [Swoole 文档 - 数据帧类型](https://wiki.swoole.com/#/websocket_server?id=%e6%95%b0%e6%8d%ae%e5%b8%a7%e7%b1%bb%e5%9e%8b)
+- `$frame->finish`：是否发送完毕，bool
+
+下面以接收一个 json 字符串为例，并进行后续的解析：
+
+```php
+/**
+ * @OnMessageEvent("foo")
+ */
+public function onMessage() {
+    $frame = ctx()->getFrame();
+    $json_str = $frame->data; // 假设传入的是 {"key1":"value1","k2":"v2"}
+    $json = json_decode($json_str, true);
+    Console::info("key1 的值是:" . $json["key1"]);
+}
+```
+
+## 关闭连接
+
+```php
+server()->close($conn->getFd());
+```
+
--- a/docs/advanced/custom-start.md
+++ b/docs/advanced/custom-start.md
@@ -0,0 +1,119 @@
+# 框架高级启动
+
+## 框架下载方式
+
+从前面的几章中，我们了解到框架有多种下载到本地的方式。
+
+- Composer 依赖模式
+- Starter 从模板创建模式
+- 源码模式
+
+### Composer 依赖模式
+
+从 Composer 依赖加载框架是一种拉取框架的方式，这种方式的优点在于，你可以直观地感受到是如何使用框架从零开始一个完整的项目的过程。
+
+从 Composer 依赖的启动步骤：
+
+```bash
+mkdir my-bot # 新建一个空的文件夹
+cd my-bot/
+composer require zhamao/framework # 从 composer 拉取后会自动部署 autoload 和 composer.json 等内容
+
+# 使用命令初始化框架
+vendor/bin/start init
+
+# 启动框架
+vendor/bin/start server
+```
+
+注意：使用 `init` 命令时，会给当前目录解压以下文件：
+
+```php
+$extract_files = [
+    "/config/global.php",							// 全局配置文件
+    "/.gitignore",									// git 排除文件
+    "/config/file_header.json",						// HTTP 文件头
+    "/config/console_color.json",					// 终端颜色主题文件
+    "/config/motd.txt",								// 框架启动时自定义的 motd
+    "/src/Module/Example/Hello.php",				// 框架自带的示例模块
+    "/src/Module/Middleware/TimerMiddleware.php",	// 框架自带的函数运行时间监控中间件
+    "/src/Custom/global_function.php"				// 用户可在这里自定义编写自己的全局函数
+];
+```
+
+经过 init 解压这些文件后，你的框架就能正常运行且开始编写代码了！
+
+### Starter 模板模式
+
+从模板新建其实原理和 Composer 依赖模式完全一样，只不过，这个过程是使用模板仓库新建的项目，使用 Composer 自带的 `create-project` 方式创建的。starter 也是一个 GitHub 项目，见 [地址](https://github.com/zhamao-robot/zhamao-framework-starter)。
+
+```bash
+composer create-project zhamao/framework-starter my-bot/ # my-bot 是你自定义的文件夹名称，和上方相同
+cd my-bot
+vendor/bin/start server # 启动框架
+```
+
+Starter 模式相当于直接从 GitHub 拉取 `zhamao-framework-starter` 项目，然后执行 `composer update`。
+
+那和 Composer 依赖模式有什么区别呢？没区别！构建出来的框架和文件是一模一样的！使用 Composer 依赖模式，使用 `init` 命令后，文件会和 `zhamao-framework-starter` 仓库拉取回来的模板一模一样！（或者换句话说，这个仓库就是使用 `init` 命令生成的文件的）
+
+那使用哪种好呢？看你自己！如果你想给你自己的已有项目套上炸毛框架，那么就推荐使用 Composer 依赖模式，如果是从 0 开始编写框架模块，则推荐使用模板模式。
+
+### 源码模式
+
+源码模式和以上两种方案都不一样，源码模式允许你对框架本身进行一系列修改，框架本体就可以直接运行。
+
+Composer 依赖模式（以及模板模式）和源码模式的区别是：
+
+- 依赖模式和模板模式是通过 library 方式引入框架的，框架本身会放在 composer 的 `vendor/` 目录下，从 composer 引入的 library 相当于子集，vendor 目录下的文件最好不要手动修改（应该都知道吧），所以框架本身也只是加载了进来。
+- 源码模式相当于直接从框架源码目录运行框架和模块，框架源码都在 `src/ZM` 目录下，默认的示例模块都在 `src/Module` 下，是同级目录。而此时的 `vendor/` 目录只包含了框架依赖的外部组件，例如注解解析器和 psysh 等。
+
+源码模式可以方便地调试和修改框架本身，拉取方式很简单，用 `git clone` 或从 GitHub 下载最新版的源码包解压即可。
+
+```bash
+git clone https://github.com/zhamao-robot/zhamao-framework.git
+cd zhamao-framework/
+bin/start server # 第一次运行时会提示一个“框架源码模式需要在autoload文件中添加Module目录为自动加载”
+composer update # 更新 autoload 文件，应用刚才上一步添加的 `src/Module` 文件夹下的模块自动加载
+bin/start server # 通过源码模式启动框架
+```
+
+## 框架启动参数
+
+框架启动时可以根据实际情况指定启动参数。
+
+- `--debug-mode`：启用调试模式，调试模式的作用是关闭一键协程化和终端交互，减少 Swoole 本身对代码逻辑的干扰（比如执行 `shell_exec()` 报错的话可以开启这个进行调试）。
+- `--log-{mode}`：设置 log 等级。支持 `--log-debug`，`--log-verbose`，`--log-info`，`--log-warning`，`--log-error`。
+- `--log-theme`：设置终端信息的主题。这个选项适用于多种终端信息显示的兼容，例如白色终端和不支持颜色的终端。详见 [Console - 主题设置](/component/console/#_2)。
+- `--disable-console-input`：关闭终端交互，如果你使用的不是 tmux、screen 而是直接将进程使用 systemd 等方式运行到 init 守护进程下，则需要关闭终端交互输入，关闭后不可以使用 `stop, reload, logtest` 等交互命令。
+- `--disable-coroutine`：关闭一键协程化。
+- `--daemon`：以守护进程方式运行框架，此参数将直接在输出 motd 后将进程挂到 init 下运行，后台常驻。
+- `--watch`：监控 `src/` 目录下的文件变化，有变化则自动重新载入代码。开启监控需要安装 PHP 扩展：inotify。使用 pecl 就可以安装：`pecl install inotify`。
+- `--env`：设置运行环境，设置运行环境后将优先加载指定环境的配置文件，支持 `--env=production`，`--env=staging`，`--env=development`，见 [基本配置](/guide/basic-config/#_2)。
+
+## 守护进程操作命令
+
+守护进程在 2.2.0 版本开始，可以使用命令行快速操作，如重启、停止、查看状态等。
+
+注意，这里的守护进程操作命令是指 **使用 `--daemon` 方式启动的框架**，如使用 Docker、screen、tmux 等方式挂后台跑则此命令不可用！
+
+```bash
+vendor/bin/start daemon:status # 查看守护进程的状态
+vendor/bin/start daemon:reload # 重载框架
+vendor/bin/start daemon:stop # 停止运行守护进程的框架
+```
+
+## 独立启动其他组件
+
+框架默认不止启动框架的 `server` 命令，还有 `init` 命令和 `simple-http-server` 命令。`init` 命令在上方 Composer 依赖模式中提到过，就是初始化各个文件的。
+
+### 独立 HTTP 文件服务器
+
+如果你只需要一个静态文件服务器，类似 Nginx，那么框架也支持。
+
+```bash
+vendor/bin/start simple-http-server your-web-dir/ --host=0.0.0.0 --port=8080
+```
+
+-  `your-web-dir` 是必填的参数。
+- `--host` 和 `--port` 是可选参数，如果不填，则默认使用 `global.php` 配置文件中的配置。
--- a/docs/advanced/framework-structure.md
+++ b/docs/advanced/framework-structure.md
@@ -0,0 +1,6 @@
+# 框架剖析
+
+## 框架运行总结构图
+
+![](../assets/img/framework-structure.png)
+
--- a/docs/advanced/index.md
+++ b/docs/advanced/index.md
@@ -1,3 +1,9 @@
 # 进阶开发
-## 深入
-还没填坑，敬请期待！
+在本章，下面的部分将详细说明一些具体的案例和自定义框架的操作。
+
+- 如何自定义修改框架本身？- [框架启动方式](/advanced/custom-start/)
+- 如何接入一个自己的 WebSocket 客户端？- [接入 WebSocket 客户端](/advanced/connect-ws-client/)
+- 框架到底是怎么工作的？- [框架结构剖析](/advanced/framework-structure/)
+
+> 更多进阶教程敬请期待....（或者你可以选择提 Issue 到框架 GitHub，有需求就写入文档）
+
--- a/docs/assets/img/framework-structure.png
+++ b/docs/assets/img/framework-structure.png
--- a/docs/component/console.md
+++ b/docs/component/console.md
@@ -158,4 +158,20 @@ color green 我是绿色的字

 在 1.4 版本开始，框架支持启动时的 motd 内容修改。

-文件位置：`config/motd.txt`
+文件位置：`config/motd.txt`
+
+## 设置输出主题
+
+Console 组件支持为多种不同的终端设置不同的主题，比如有些人喜欢使用白色的终端，但是白色终端下 info 的颜色很浅，看不到，还有人使用不能显示颜色的黑白终端.....
+
+```bash
+vendor/bin/start server --log-theme={主题名}
+```
+
+现有支持的主题有：`default`，`white-term`，`no-color`
+
+```bash
+vendor/bin/start server --log-theme=white-term # 如果用的是白色终端，这个主题更友好
+vendor/bin/start server --log-theme=no-color   # 如果不想让 log 带有任何颜色，使用无色主题
+```
+
--- a/docs/component/context.md
+++ b/docs/component/context.md
@@ -114,7 +114,7 @@ public function ping() {

 ## getConnection() - WS 连接对象

-返回此上下文相关联的 WebSocket 连接对象。
+返回此上下文相关联的 WebSocket 连接对象。详见 [进阶 - 接入 WebSocket 客户端](/advanced/connect-ws-client)。

 可以使用的事件：所有 **getFrame()** 可以使用的都可以使用。

--- a/docs/component/light-cache.md
+++ b/docs/component/light-cache.md
@@ -224,3 +224,97 @@ public function test() {

 解决这一问题，就需要用到锁。这种情况下，我们首先考虑的是自旋锁，框架也因此内置了一个方便使用的自旋锁组件。详见下一章：自旋锁。

+## 如何临时缓存大变量
+
+由于 LightCache 需要提前声明最大大小，所以在某些情况下，比如第三方 API 接口结果临时缓存，可能不太适合使用，这时对于 2.x 版本的多进程炸毛框架是一个新的问题。
+
+解决方案有三种：
+
+- 将 `global.php` 中的 `swoole.worker_num` 调整为 `1` 即可，所有除所有主 handler 事件的用户类外其他类均可使用如 `Hello::$store` 类似的静态变量全局存取
+- 使用 WorkerCache（需要 2.2.0 以上版本）
+- 使用 Redis（需要安装 `redis` 扩展）
+
+以上，WorkerCache 是为了弥补 LightCache 的不足而诞生的，以下就是 WorkerCache 的具体内容。
+
+### WorkerCache 跨进程大缓存
+
+WorkerCache 和 LightCache 几乎完全不同，WorkerCache 存储的方式说白了就是 PHP 的静态变量，不过框架支持使用封装好的进程间通信进行跨进程读取。但由于需要设置一个存储变量的进程，所以配置文件必须先指定要将数据存到哪个 Worker/TaskWorker 进程中。关于框架内多进程的说明，请见 [进阶 - 多进程 Hack](/advanced/multi-process/)。
+
+定义：`ZM\Store\WorkerCache`。
+
+#### 配置
+
+见 [基本配置](/guide/basic-config/)。
+
+#### WorkerCache::get()
+
+定义：`get($key)`。
+
+`$key` 为指定要获取的键值对的值，如果不存在则返回 null。
+
+#### WorkerCache::set()
+
+定义：`set($key, $value, $async = false)`。
+
+设置变量，你懂的。
+
+注意，`$value` 可以是被无损 `json_encode` 和 `json_decode` 的变量，闭包（Closure）、资源（resource）等类型不支持存储。
+
+`$async` 默认为 false，当为 true 时候，不会返回是否成功设置与否，否则会协程等待是否目标进程存储成功。
+
+#### WorkerCache::unset()
+
+定义：`unset($key, $async = false)` 
+
+删除键对应的值。`$async` 的意义同上。
+
+#### WorkerCache::add()
+
+定义：`add($key, int $value, $async = false)`
+
+给 int 类型的值加一，如果值不存在，则默认为 0 且加上目标的 `$value`。
+
+#### WorkerCache::sub()
+
+定义：`sub($key, int $value, $async = false)`
+
+给 int 类型的值减一，如果值不存在，则默认为 0 且减去目标的 `$value`。
+
+```php
+<?php
+namespace Module\Example;
+
+use ZM\Store\WorkerCache;
+use ZM\Annotation\CQ\CQCommand;
+
+class Hello {
+    /**
+     * @CQCommand("set_store")
+     */
+    public function setStorage() {
+        $arg1 = ctx()->getFullArg("请输入要设置的内容名称");
+        $arg2 = ctx()->getFullArg("请输入要设置的内容");
+        WorkerCache::set($arg1, $arg2);
+        return "成功！";
+    }
+    
+    /**
+     * @CQCommand("get_store")
+     */
+    public function getStorage() {
+        $arg1 = ctx()->getFullArg("请输入要获取的内容名称");
+        $data = WorkerCache::get($arg1);
+        return $data ?? "内容不存在！";
+    }
+}
+```
+
+<chat-box>
+) set_store hello world
+( 成功！
+) get_store hello
+( world
+) get_store foo
+( 内容不存在！
+</chat-box>
+
--- a/docs/event/framework-annotations.md
+++ b/docs/event/framework-annotations.md
@@ -2,20 +2,171 @@

 框架核心注解事件区别于机器人和路由注解事件，这里框架注解事件都是**直接**或封装调用 Swoole 的回调事件的，所以对一些比较底层或者基础的操作都在这里做，例如收到 HTTP 或 WebSocket 连接后执行的事件函数。

-## OnSwooleEvent()
+## OnOpenEvent()

-绑定 Swoole 所相关的事件，例如 WebSocket 接入、收到 WS 消息、关闭 WS 连接，HTTP 请求到达等。这个是旧的统一的 Swoole 事件分发注解。请尽量使用上面几个新的注解。
+当有 WebSocket 连接接入框架时，触发注解事件。

 ### 属性

-| 类型         | 值                                         |
-| ------------ | ------------------------------------------ |
-| 名称         | `@OnSwooleEvent`                           |
-| 触发前提     | 当参数指定的 `type` 对应的事件被触发后激活 |
-| 命名空间     | `ZM\Annotation\Swoole\OnSwooleEvent`       |
-| 适用位置     | 方法                                       |
-| 返回值处理   | 无                                         |
-| 注解绑定参数 |                                            |
+| 类型       | 值                                          |
+| ---------- | ------------------------------------------- |
+| 名称       | `@OnOpenEvent`                              |
+| 触发前提   | 当有 WebSocket 连接接入框架时，触发注解事件 |
+| 命名空间   | `ZM\Annotation\Swoole\OnOpenEvent`          |
+| 适用位置   | 方法                                        |
+| 返回值处理 | 无                                          |
+
+### 参数
+
+| 参数名称     | 参数范围 | 用途                                                         | 默认 |
+| ------------ | -------- | ------------------------------------------------------------ | ---- |
+| connect_type | `string` | 限定连接的类型，通过炸毛框架支持的方式指定传入类型，详见 [进阶 - 接入 WebSocket 客户端](/advanced/connect-ws-client) |      |
+
+### 用法
+
+```java
+@OnOpenEvent("foo")
+@OnOpenEvent(connect_type="default")
+```
+
+### 事件绑定参数
+
+`$conn`: [ConnectionObject](/advanced/connect-ws-client/) 类型，返回一个当前 WS 连接的连接对象。
+
+## OnCloseEvent()
+
+当有 WebSocket 连接断开框架时，触发注解事件。
+
+### 属性
+
+| 类型       | 值                                          |
+| ---------- | ------------------------------------------- |
+| 名称       | `@OnCloseEvent`                             |
+| 触发前提   | 当有 WebSocket 连接断开框架时，触发注解事件 |
+| 命名空间   | `ZM\Annotation\Swoole\OnCloseEvent`         |
+| 适用位置   | 方法                                        |
+| 返回值处理 | 无                                          |
+
+### 参数
+
+| 参数名称     | 参数范围 | 用途                                                         | 默认 |
+| ------------ | -------- | ------------------------------------------------------------ | ---- |
+| connect_type | `string` | 限定连接的类型，通过炸毛框架支持的方式指定传入类型，详见 [进阶 - 接入 WebSocket 客户端](/advanced/connect-ws-client) |      |
+
+### 用法
+
+```java
+@OnCloseEvent("foo")
+@OnCloseEvent(connect_type="default")
+```
+
+### 事件绑定参数
+
+`$conn`: [ConnectionObject](/advanced/connect-ws-client/) 类型，返回一个当前 WS 连接的连接对象。
+
+## OnRequestEvent()
+
+当 HTTP 请求接入时，触发注解事件。
+
+### 属性
+
+| 类型       | 值                                    |
+| ---------- | ------------------------------------- |
+| 名称       | `@OnRequestEvent`                     |
+| 触发前提   | 当 HTTP 请求接入时，触发注解事件      |
+| 命名空间   | `ZM\Annotation\Swoole\OnRequestEvent` |
+| 适用位置   | 方法                                  |
+| 返回值处理 | 无                                    |
+
+### 参数
+
+| 参数名称 | 参数范围                                      | 用途                     | 默认             |
+| -------- | --------------------------------------------- | ------------------------ | ---------------- |
+| rule     | `string`，必须是可执行且返回 bool 的 PHP 代码 | 前置条件                 | 空，rule 为 true |
+| level    | `int`                                         | 事件优先级（越大越靠前） | 20               |
+
+## OnMessageEvent()
+
+当有 WebSocket 连接接入框架后发送过来消息，触发注解事件。
+
+### 属性
+
+| 类型       | 值                                                      |
+| ---------- | ------------------------------------------------------- |
+| 名称       | `@OnMessageEvent`                                       |
+| 触发前提   | 当有 WebSocket 连接接入框架后发送过来消息，触发注解事件 |
+| 命名空间   | `ZM\Annotation\Swoole\OnMessageEvent`                   |
+| 适用位置   | 方法                                                    |
+| 返回值处理 | 无                                                      |
+
+### 参数
+
+| 参数名称     | 参数范围 | 用途                                                         | 默认 |
+| ------------ | -------- | ------------------------------------------------------------ | ---- |
+| connect_type | `string` | 限定连接的类型，通过炸毛框架支持的方式指定传入类型，详见 [进阶 - 接入 WebSocket 客户端](/advanced/connect-ws-client) |      |
+
+### 用法
+
+```java
+@OnMessageEvent("foo")
+@OnMessageEvent(connect_type="default")
+```
+
+### 事件绑定参数
+
+`$conn`: [ConnectionObject](/advanced/connect-ws-client/) 类型，返回一个当前 WS 连接的连接对象。
+
+## OnPipeMessageEvent()
+
+当有 其他 Worker 进程通信发来指令，激活响应。（2.2.0 版本可用）
+
+### 属性
+
+| 类型       | 值                                                      |
+| ---------- | ------------------------------------------------------- |
+| 名称       | `@OnPipeMessageEvent`                                   |
+| 触发前提   | 当有 WebSocket 连接接入框架后发送过来消息，触发注解事件 |
+| 命名空间   | `ZM\Annotation\Swoole\OnPipeMessageEvent`               |
+| 适用位置   | 方法                                                    |
+| 返回值处理 | 无                                                      |
+
+### 参数
+
+| 参数名称 | 参数范围 | 用途         | 默认 |
+| -------- | -------- | ------------ | ---- |
+| action   | `string` | 限定动作名称 |      |
+
+### 用法
+
+```java
+@OnPipeMessageEvent("foo")
+@OnPipeMessageEvent(action="bar")
+```
+
+### 事件绑定参数
+
+`$data`: 数组，内容如下：
+
+```php
+[
+    "action" => "你的上面的名称",
+    ... //其他自己发送时随便定义，带什么都行
+]
+```
+
+## OnSwooleEvent()
+
+绑定 Swoole 所相关的事件，例如 WebSocket 接入、收到 WS 消息、关闭 WS 连接，HTTP 请求到达等。这个是旧的统一的 Swoole 事件分发注解。**请尽量使用上面几个新的注解**。
+
+### 属性
+
+| 类型       | 值                                         |
+| ---------- | ------------------------------------------ |
+| 名称       | `@OnSwooleEvent`                           |
+| 触发前提   | 当参数指定的 `type` 对应的事件被触发后激活 |
+| 命名空间   | `ZM\Annotation\Swoole\OnSwooleEvent`       |
+| 适用位置   | 方法                                       |
+| 返回值处理 | 无                                         |

 ### 注解参数

@@ -27,9 +178,70 @@

 ### 事件绑定参数

-`$conn`: [ConnectionObject](/advanced/inside-class/) 类型，返回一个当前 WS 连接的连接对象。
+`$conn`: [ConnectionObject](/advanced/connect-ws-client/) 类型，返回一个当前 WS 连接的连接对象。

-### 示例1（机器人连接框架后输出信息）
+## OnStart()
+
+在框架加载后执行的注解事件，用于初始化 Worker 进程，此注解事件会在 Worker 进程中执行，且可以指定在哪个 Worker 进程中执行。
+
+### 属性
+
+| 类型       | 值                             |
+| ---------- | ------------------------------ |
+| 名称       | `@OnStart`                     |
+| 触发前提   | 在框架加载后激活               |
+| 命名空间   | `ZM\Annotation\Swoole\OnStart` |
+| 适用位置   | 方法                           |
+| 返回值处理 | 无                             |
+
+### 注解参数
+
+| 参数名称  | 参数范围                                                     | 用途                     | 默认 |
+| --------- | ------------------------------------------------------------ | ------------------------ | ---- |
+| worker_id | `int`，要在哪个 Worker 进程上执行，默认为 0，范围是 0～{你设定的 Worker 数量-1}，如果是 -1 的话，则会在所有 Worker 进程上触发。 | 限定只执行的 Worker 进程 |      |
+
+## OnTick()
+
+在框架加载后创建毫秒计时器。
+
+### 属性
+
+| 类型       | 值                            |
+| ---------- | ----------------------------- |
+| 名称       | `@OnTick`                     |
+| 触发前提   | 在框架加载后激活              |
+| 命名空间   | `ZM\Annotation\Swoole\OnTick` |
+| 适用位置   | 方法                          |
+| 返回值处理 | 无                            |
+
+### 注解参数
+
+| 参数名称  | 参数范围                                                     | 用途                     | 默认 |
+| --------- | ------------------------------------------------------------ | ------------------------ | ---- |
+| tick_ms   | `int`，**必填**，间隔的毫秒数，例如 1 秒间隔为 `1000`，范围大于 0，小于 86400000。 |                          |      |
+| worker_id | `int`，要在哪个 Worker 进程上执行，默认为 0，范围是 0～{你设定的 Worker 数量-1}，如果是 -1 的话，则会在所有 Worker 进程上触发。 | 限定只执行的 Worker 进程 |      |
+
+## OnSetup()
+
+在框架加载前执行的代码。此部分代码是在主进程执行的，不可在此事件中使用任何协程相关的功能。
+
+比如我们要改变所有进程的 ini 设置，这时使用 `@OnStart(-1)` 这样只设置了 Worker 进程的内容，而主进程和管理进程无法被覆盖到。如果需要设置全局的一些配置，务必在此 `@OnSetup` 注解下执行。
+
+### 属性
+
+| 类型       | 值                             |
+| ---------- | ------------------------------ |
+| 名称       | `@OnSetup`                     |
+| 触发前提   | 在框架加载前激活               |
+| 命名空间   | `ZM\Annotation\Swoole\OnSetup` |
+| 适用位置   | 方法                           |
+| 返回值处理 | 无                             |
+
+### 注解参数
+
+无。
+
+## 示例1（机器人连接框架后输出信息）

 ```php
 <?php
@@ -40,7 +252,7 @@ use ZM\Console\Console;
 class Hello {
    /**
 	 * 在机器人客户端连接框架后向终端输出信息
- 	 * @OnSwooleEvent("open",rule="connectIsQQ()")
+ 	 * @OnOpenEvent("qq")
 	 * @param $conn
 	 */
 	public function onConnect(ConnectionObject $conn) {
@@ -51,7 +263,7 @@ class Hello {

 这里的 Console 是终端输出组件，详情见组件一栏对应的文档查询。

-### 示例2（阻断 Chrome 访问框架时多访问一次的问题）
+## 示例2（阻断 Chrome 访问框架时多访问一次的问题）

 ```php
 <?php
@@ -61,7 +273,7 @@ use ZM\Event\EventDispatcher;
 class Hello {
    /**
     * 阻止 Chrome 自动请求 /favicon.ico 导致的多条请求并发和干扰
-     * @OnSwooleEvent("request",rule="ctx()->getRequest()->server['request_uri'] == '/favicon.ico'",level=200)
+     * @OnRequestEvent(rule="ctx()->getRequest()->server['request_uri'] == '/favicon.ico'",level=200)
     */
    public function onRequest() {
        EventDispatcher::interrupt();
@@ -69,4 +281,107 @@ class Hello {
 }
 ```

-其中 EventDispatcher 为事件分发器，interrupt 是通用阻断方法，如果你平常只使用阻断，则只需掌握这一个方法即可，`EventDispatcher::interrupt()` 在所有事件内可用。
+其中 EventDispatcher 为事件分发器，interrupt 是通用阻断方法，如果你平常只使用阻断，则只需掌握这一个方法即可，`EventDispatcher::interrupt()` 在所有事件内可用。
+
+## 示例3（接收 WS 客户端发来的数据）
+
+见 [接入 WebSocket 客户端](/advanced/connect-ws-client/)。
+
+## 示例4（使用 OnStart 给所有 Worker 进程写入缓存提速）
+
+如果你有一些数据存到了文件、数据库中，且是只读不写的，那么就可以使用此方法将这个文件或者数据库的内容读入 Worker 进程的内存中进行使用来提速。
+
+假设我们有一个大文件 json，里面存着一份题库，例如：
+
+```json
+{
+    "0": {
+        "question": "法的调整对象是（ ）。",
+        "answer": {
+            "A": "行为关系",
+            "B": "思想关系",
+            "C": "利益关系",
+            "D": "各种社会资源"
+        },
+        "key": "A",
+        "answer_type": 0
+    },
+    "1": {
+        "question": "法律与其他社会规范的区别在于（ ）。",
+        "answer": {
+            "A": "是调整人们行为的规范",
+            "B": "有约束力",
+            "C": "由国家强制力保证执行",
+            "D": "规定制裁措施"
+        },
+        "key": "C",
+        "answer_type": 0
+    },
+    .....
+}
+```
+
+那么我们可以使用 OnStart 来实现一个，将此文件读取到每个 Worker 进程中，并且快速取用的功能（以下做了一个简单的查题功能）：
+
+```php
+<?php
+namespace Module\Example;
+use ZM\Annotation\Swoole\OnStart;
+use ZM\Annotation\CQ\CQCommand;
+use ZM\Console\Console;
+class Hello {
+    public static $tiku = [];
+    /**
+     * @OnStart(-1)
+     */
+    public function onStart() { // 注意，此函数将会在每个 Worker 执行一次
+        $file = file_get_contents("tiku.json"); //从文件读取json
+        $json = json_decode($file, true); //json解析
+        Hello::$tiku = $json; //将解析后的数组以静态变量的方式存到每个 Worker 的内存中
+        Console::success("加载题库完成！");
+    }
+    /**
+     * @CQCommand("找题")
+     */
+    public function findQuestion() {
+        $tiku_id = ctx()->getNumArg("请输入题目的序号");
+        if(!isset(Hello::$tiku[$tiku_id])) return "题目id为".$tiku_id."的题目不存在！";
+        $timu = Hello::$tiku[$tiku_id];
+        $msg = "题目名称：".$timu["question"];
+        foreach($timu["answer"] as $k => $v) {
+            $msg .= "\n".$k.". ".$v;
+        }
+        $msg .= "\n正确答案：".$timu["key"];
+        return $msg;
+    }
+}
+```
+
+终端效果：（我们假设运行框架的电脑是四核 CPU）
+
+```log
+[14:28:00] [S] [#0] 加载题库完成！
+[14:28:00] [S] [#2] 加载题库完成！
+[14:28:00] [S] [#1] 加载题库完成！
+[14:28:00] [S] [#3] 加载题库完成！
+```
+
+聊天效果：
+
+<chat-box>
+) 找题 1
+( 题目名称：法律与其他社会规范的区别在于（ ）。\nA. 是调整人们行为的规范\nB. 有约束力\nC. 由国家强制力保证执行\nD. 规定制裁措施\n正确答案：C
+</chat-box>
+
+## 示例5（创建每分钟自动执行的爬虫）
+
+```php
+/**
+ * @OnTick(tick_ms=60000,worker_id=0)
+ */
+public function onCrawl() {
+    $data = Foo::bar(); //这里是你自己写的要爬的接口等等一系列操作
+    LightCache::set("your_data_key_name", $data); //将爬虫数据存入 LightCache 轻量缓存
+}
+```
+
--- a/docs/guide/basic-config.md
+++ b/docs/guide/basic-config.md
@@ -20,6 +20,7 @@
 | `crash_dir`                  | 存放崩溃和运行日志的目录                         | `zm_data` 下的 `crash/`      |
 | `swoole`                     | 对应 Swoole server 中 set 的参数，参考Swoole文档 | 见子表 `swoole`              |
 | `light_cache`                | 轻量内置 key-value 缓存                          | 见字表 `light_cache`         |
+| `worker_cache`               | 跨进程变量级缓存                                 | 见子表 `worker_cache`        |
 | `sql_config`                 | MySQL 数据库连接信息                             | 见子表 `sql_config`          |
 | `redis_config`               | Redis 连接信息                                   | 见子表 `redis_config`        |
 | `access_token`               | OneBot 客户端连接约定的token，留空则无           | 空                           |
@@ -82,6 +83,12 @@
 | `document_root`  | 静态文件的根目录       | `{WORKING_DIR}/resources/html` |
 | `document_index` | 默认索引的文件名列表   | `["index.html"]`               |

+### 子表 worker_cache
+
+| 配置名称 | 说明                        | 默认值 |
+| -------- | --------------------------- | ------ |
+| `worker` | 跨进程缓存的存储工作进程 id | 0      |
+
 ## 多环境下的配置文件

 炸毛框架的配置文件模块支持不同环境下的配置文件，主要结构为 `global.{环境}.php`。在一般情况下，炸毛框架默认从教程引导方式根据指令 `vendor/bin/start server` 启动的框架是不带环境控制的。这章将讲述如何根据不同的环境（production / development / staging）来编写配置文件。
--- a/docs/index.md
+++ b/docs/index.md
@@ -33,7 +33,7 @@ public function index() {

 首先，你需要了解你需要知道哪些事情才能开始着手使用框架：

-1. Linux 命令行基础
+1. Linux 命令行（会跑 Linux 程序）
 2. php 7.2+ 开发环境
 3. HTTP 协议（可选）
 4. OneBot 机器人聊天接口标准（可选）
--- a/docs/javascripts/config.js
+++ b/docs/javascripts/config.js
@@ -75,13 +75,13 @@ setTimeout(() => {
            if(j === '') continue;
            if(j.substr(0, 2) === ') ') {
                final += '<div class="doc-chat-row">\n' +
-                    '    <div class="doc-chat-box">' + j.substr(2) + '</div>\n' +
+                    '    <div class="doc-chat-box">' + j.substr(2).replaceAll("\\n", "<br>") + '</div>\n' +
                    '    <img class="doc-chat-avatar" src="http://api.btstu.cn/sjtx/api.php"  alt=""/>\n' +
                    '  </div>';
            } else if (j.substr(0, 2) === '( ') {
                final += '<div class="doc-chat-row doc-chat-row-robot">\n' +
                    '    <img class="doc-chat-avatar" src="https://docs-v1.zhamao.xin/logo.png" alt=""/>\n' +
-                    '    <div class="doc-chat-box doc-chat-box-robot">' + j.substr(2) + '</div>\n' +
+                    '    <div class="doc-chat-box doc-chat-box-robot">' + j.substr(2).replaceAll("\\n", "<br>") + '</div>\n' +
                    '  </div>';
            } else if (j.substr(0, 2) === '^ ') {
                final += '<div class="doc-chat-row doc-chat-banner">' + j.substr(2) + '</div>';
--- a/docs/update/v2.md
+++ b/docs/update/v2.md
@@ -1,5 +1,49 @@
 # 更新日志（v2 版本）

+## v2.2.3
+
+> 更新时间：2021.1.30
+
+- 修复：waitMessage() 在 v2.2.2 版本中不可用的 bug
+- 修复：access_token 无效的问题
+
+## v2.2.2
+
+> 更新时间：2021.1.29
+
+- 修复：模块文件错误时避免循环报错
+- 优化：代码结构
+- 修复：在不同进程时调用机器人 API 无法返回且报错的 bug
+- **修复：机器人无法连接的问题（2.1.6 ~ 2.2.1 受影响）**
+
+## v2.2.1
+
+> 更新时间：2021.1.29
+
+- 修复：配置文件兼容性问题
+
+## v2.2.0
+
+> 更新时间：2021.1.29
+
+- 新增：`@OnPipeMessageEvent` 注解
+- 新增：进程管理器
+- 新增：`--daemon` 守护进程化后查看状态以及一系列操作的命令行
+- 新增：WorkerCache
+- 修复：路由问题
+- 修复：`http_header` 配置项不生效的 bug
+- 优化：框架内部所有异常全部基于 `ZMException`
+- 优化：SingletonTrait 支持扩展
+
+## v2.1.6
+
+> 更新时间：2021.1.18
+
+- 优化：代码结构
+- 增加：更多提示语
+- 修复：处理空格消息时的报错
+- 修复：上下文的bug
+
 ## v2.1.5

 > 更新时间：2021.1.13
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -89,8 +89,12 @@ nav:
      - Console 终端: component/console.md
  - 进阶开发:
      - 进阶开发: advanced/index.md
+      - 框架剖析: advanced/framework-structure.md
+      - 框架启动模式: advanced/custom-start.md
      - 从 v1 升级: advanced/to-v2.md
      - 内部类文件手册: advanced/inside-class.md
+      - 接入 WebSocket 客户端: advanced/connect-ws-client.md
+      - 框架多进程: advanced/multi-process.md
  - FAQ: FAQ.md
  - 更新日志:
      - 更新日志（v2）: update/v2.md
--- a/src/Custom/Command/CustomCommand.php
+++ b/src/Custom/Command/CustomCommand.php
@@ -1,31 +0,0 @@
-<?php
-
-
-namespace Custom\Command;
-
-
-use Symfony\Component\Console\Command\Command;
-use Symfony\Component\Console\Input\InputInterface;
-use Symfony\Component\Console\Output\OutputInterface;
-
-class CustomCommand extends Command
-{
-    // the name of the command (the part after "bin/console")
-    protected static $defaultName = 'custom';
-
-    protected function configure() {
-        $this->setDescription("custom description | 自定义命令的描述字段");
-        $this->addOption("failure", null, null, "以错误码为1返回结果");
-        // ...
-    }
-
-    protected function execute(InputInterface $input, OutputInterface $output) {
-        if ($input->getOption("failure")) {
-            $output->writeln("<error>Hello error! I am wrong message.</error>");
-            return Command::FAILURE;
-        } else {
-            $output->writeln("<comment>Hello world! I am successful message.</comment>");
-            return Command::SUCCESS;
-        }
-    }
-}
--- a/src/Custom/global_function.php
+++ b/src/Custom/global_function.php
@@ -1,4 +1,4 @@
-<?php #plain
+<?php /** @noinspection PhpFullyQualifiedNameUsageInspection */ #plain

 //这里写你的全局函数
 function pgo(callable $func, $name = "default") {
--- a/src/Module/Example/Hello.php
+++ b/src/Module/Example/Hello.php
@@ -55,9 +55,9 @@ class Hello
     */
    public function randNum() {
        // 获取第一个数字类型的参数
-        $num1 = ctx()->getArgs(ZM_MATCH_NUMBER, "请输入第一个数字");
+        $num1 = ctx()->getNumArg("请输入第一个数字");
        // 获取第二个数字类型的参数
-        $num2 = ctx()->getArgs(ZM_MATCH_NUMBER, "请输入第二个数字");
+        $num2 = ctx()->getNumArg("请输入第二个数字");
        $a = min(intval($num1), intval($num2));
        $b = max(intval($num1), intval($num2));
        // 回复用户结果
@@ -89,7 +89,7 @@ class Hello
     * @return string
     */
    public function paramGet($param) {
-        return "Your name: {$param["name"]}";
+        return "Hello, ".$param["name"];
    }

    /**
--- a/src/ZM/API/CQAPI.php
+++ b/src/ZM/API/CQAPI.php
@@ -3,17 +3,16 @@

 namespace ZM\API;

-use Co;
-use ZM\ConnectionManager\ConnectionObject;
 use ZM\Console\Console;
 use ZM\Store\LightCacheInside;
 use ZM\Store\Lock\SpinLock;
 use ZM\Store\ZMAtomic;
+use ZM\Utils\CoMessage;

 trait CQAPI
 {
    /**
-     * @param ConnectionObject $connection
+     * @param $connection
     * @param $reply
     * @param |null $function
     * @return bool|array
@@ -35,21 +34,20 @@ trait CQAPI
        $r[$api_id] = [
            "data" => $reply,
            "time" => microtime(true),
-            "self_id" => $connection->getOption("connect_id")
+            "self_id" => $connection->getOption("connect_id"),
+            "echo" => $api_id
        ];
-        if ($function === true) $r[$api_id]["coroutine"] = Co::getuid();
        LightCacheInside::set("wait_api", "wait_api", $r);
        SpinLock::unlock("wait_api");
        if (server()->push($connection->getFd(), json_encode($reply))) {
            if ($function === true) {
-                Co::suspend();
+                return CoMessage::yieldByWS($r[$api_id], ["echo"], 60);
+            } else {
                SpinLock::lock("wait_api");
                $r = LightCacheInside::get("wait_api", "wait_api");
-                $data = $r[$api_id];
                unset($r[$api_id]);
                LightCacheInside::set("wait_api", "wait_api", $r);
                SpinLock::unlock("wait_api");
-                return isset($data['result']) ? $data['result'] : null;
            }
            return true;
        } else {
--- a/src/ZM/API/ZMRobot.php
+++ b/src/ZM/API/ZMRobot.php
@@ -228,9 +228,9 @@ class ZMRobot
    /**
     * 群组单人禁言
     * @link https://github.com/howmanybots/onebot/blob/master/v11/specs/api/public.md#set_group_ban-%E7%BE%A4%E7%BB%84%E5%8D%95%E4%BA%BA%E7%A6%81%E8%A8%80
-     * @param int $group_id
-     * @param int $user_id
-     * @param int $duration
+     * @param $group_id
+     * @param $user_id
+     * @param $duration
     * @return array|bool|null
     */
    public function setGroupBan($group_id, $user_id, $duration = 1800) {
--- a/src/ZM/Annotation/AnnotationParser.php
+++ b/src/ZM/Annotation/AnnotationParser.php
@@ -9,11 +9,10 @@ use ZM\Console\Console;
 use ReflectionClass;
 use ReflectionException;
 use ReflectionMethod;
-use ZM\Annotation\Http\{HandleAfter, HandleBefore, Controller, HandleException, Middleware, MiddlewareClass, RequestMapping};
+use ZM\Annotation\Http\{HandleAfter, HandleBefore, HandleException, Middleware, MiddlewareClass, RequestMapping};
 use ZM\Annotation\Interfaces\Level;
 use ZM\Annotation\Module\Closed;
 use ZM\Http\RouteManager;
-use ZM\Utils\DataProvider;

 class AnnotationParser
 {
@@ -91,6 +90,7 @@ class AnnotationParser
                    if ($vs instanceof ErgodicAnnotation) {
                        foreach (($this->annotation_map[$v]["methods"] ?? []) as $method) {
                            $copy = clone $vs;
+                            /** @noinspection PhpUndefinedFieldInspection */
                            $copy->method = $method->getName();
                            $this->annotation_map[$v]["methods_annotations"][$method->getName()][] = $copy;
                        }
--- a/src/ZM/Annotation/CQ/CQMessage.php
+++ b/src/ZM/Annotation/CQ/CQMessage.php
@@ -3,7 +3,6 @@

 namespace ZM\Annotation\CQ;

-use Doctrine\Common\Annotations\Annotation\Required;
 use Doctrine\Common\Annotations\Annotation\Target;
 use ZM\Annotation\AnnotationBase;
 use ZM\Annotation\Interfaces\Level;
--- a/src/ZM/Annotation/Http/HandleAfter.php
+++ b/src/ZM/Annotation/Http/HandleAfter.php
@@ -4,7 +4,6 @@
 namespace ZM\Annotation\Http;


-use Doctrine\Common\Annotations\Annotation\Required;
 use Doctrine\Common\Annotations\Annotation\Target;
 use ZM\Annotation\AnnotationBase;

--- a/src/ZM/Annotation/Swoole/OnCloseEvent.php
+++ b/src/ZM/Annotation/Swoole/OnCloseEvent.php
@@ -5,7 +5,6 @@ namespace ZM\Annotation\Swoole;


 use Doctrine\Common\Annotations\Annotation\Target;
-use ZM\Annotation\Interfaces\Rule;

 /**
 * @Annotation
--- a/src/ZM/Annotation/Swoole/OnPipeMessageEvent.php
+++ b/src/ZM/Annotation/Swoole/OnPipeMessageEvent.php
@@ -0,0 +1,24 @@
+<?php
+
+
+namespace ZM\Annotation\Swoole;
+
+
+use Doctrine\Common\Annotations\Annotation\Required;
+use Doctrine\Common\Annotations\Annotation\Target;
+use ZM\Annotation\AnnotationBase;
+
+/**
+ * Class OnPipeMessageEvent
+ * @package ZM\Annotation\Swoole
+ * @Annotation
+ * @Target("METHOD")
+ */
+class OnPipeMessageEvent extends AnnotationBase
+{
+    /**
+     * @var string
+     * @Required()
+     */
+    public $action;
+}
--- a/src/ZM/Command/DaemonCommand.php
+++ b/src/ZM/Command/DaemonCommand.php
@@ -0,0 +1,31 @@
+<?php
+
+
+namespace ZM\Command;
+
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use ZM\Utils\DataProvider;
+
+abstract class DaemonCommand extends Command
+{
+    protected $daemon_file = null;
+
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        $pid_path = DataProvider::getWorkingDir() . "/.daemon_pid";
+        if (!file_exists($pid_path)) {
+            $output->writeln("<comment>没有检测到正在运行的守护进程！</comment>");
+            die();
+        }
+        $file = json_decode(file_get_contents($pid_path), true);
+        if ($file === null || posix_getsid(intval($file["pid"])) === false) {
+            $output->writeln("<comment>未检测到正在运行的守护进程！</comment>");
+            unlink($pid_path);
+            die();
+        }
+        $this->daemon_file = $file;
+        return Command::SUCCESS;
+    }
+}
--- a/src/ZM/Command/DaemonReloadCommand.php
+++ b/src/ZM/Command/DaemonReloadCommand.php
@@ -0,0 +1,24 @@
+<?php
+
+
+namespace ZM\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class DaemonReloadCommand extends DaemonCommand
+{
+    protected static $defaultName = 'daemon:reload';
+
+    protected function configure() {
+        $this->setDescription("重载守护进程下的用户代码（仅限--daemon模式可用）");
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        parent::execute($input, $output);
+        system("kill -USR1 " . intval($this->daemon_file["pid"]));
+        $output->writeln("<info>成功重载！</info>");
+        return Command::SUCCESS;
+    }
+}
--- a/src/ZM/Command/DaemonStatusCommand.php
+++ b/src/ZM/Command/DaemonStatusCommand.php
@@ -0,0 +1,30 @@
+<?php
+
+
+namespace ZM\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class DaemonStatusCommand extends DaemonCommand
+{
+    protected static $defaultName = 'daemon:status';
+
+    protected function configure() {
+        $this->setDescription("查看守护进程框架的运行状态（仅限--daemon模式可用）");
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        parent::execute($input, $output);
+        $output->writeln("<info>框架运行中，pid：" . $this->daemon_file["pid"] . "</info>");
+        $output->writeln("<comment>----- 以下是stdout内容 -----</comment>");
+        $stdout = file_get_contents($this->daemon_file["stdout"]);
+        $stdout = explode("\n", $stdout);
+        for ($i = 10; $i > 0; --$i) {
+            if (isset($stdout[count($stdout) - $i]))
+                echo $stdout[count($stdout) - $i] . PHP_EOL;
+        }
+        return Command::SUCCESS;
+    }
+}
--- a/src/ZM/Command/DaemonStopCommand.php
+++ b/src/ZM/Command/DaemonStopCommand.php
@@ -0,0 +1,26 @@
+<?php
+
+
+namespace ZM\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use ZM\Utils\DataProvider;
+
+class DaemonStopCommand extends DaemonCommand
+{
+    protected static $defaultName = 'daemon:stop';
+
+    protected function configure() {
+        $this->setDescription("停止守护进程下运行的框架（仅限--daemon模式可用）");
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        parent::execute($input, $output);
+        system("kill -TERM ".intval($this->daemon_file["pid"]));
+        unlink(DataProvider::getWorkingDir()."/.daemon_pid");
+        $output->writeln("<info>成功停止！</info>");
+        return Command::SUCCESS;
+    }
+}
--- a/src/ZM/Command/InitCommand.php
+++ b/src/ZM/Command/InitCommand.php
@@ -74,6 +74,7 @@ class InitCommand extends Command
                echo("Error occurred. Please check your updates.\n");
                return Command::FAILURE;
            }
+            $output->writeln("<info>Done!</info>");
            return Command::SUCCESS;
        } elseif (LOAD_MODE === 2) { //从phar启动的框架包，初始化的模式
            $phar_link = new Phar(__DIR__);
--- a/src/ZM/Command/RunServerCommand.php
+++ b/src/ZM/Command/RunServerCommand.php
@@ -11,7 +11,6 @@ use ZM\Framework;

 class RunServerCommand extends Command
 {
-    // the name of the command (the part after "bin/console")
    protected static $defaultName = 'server';

    protected function configure() {
@@ -31,27 +30,17 @@ class RunServerCommand extends Command
        ]);
        $this->setDescription("Run zhamao-framework | 启动框架");
        $this->setHelp("直接运行可以启动");
-
-        // ...
    }

    protected function execute(InputInterface $input, OutputInterface $output) {
-        if(($opt = $input->getOption("env")) !== null) {
-            if(!in_array($opt, ["production", "staging", "development", ""])) {
+        if (($opt = $input->getOption("env")) !== null) {
+            if (!in_array($opt, ["production", "staging", "development", ""])) {
                $output->writeln("<error> \"--env\" option only accept production, development, staging and [empty] ! </error>");
                return Command::FAILURE;
            }
        }
-        // ... put here the code to run in your command
-        // this method must return an integer number with the "exit status code"
-        // of the command. You can also use these constants to make code more readable
+        if (LOAD_MODE == 0) echo "* This is repository mode.\n";
        (new Framework($input->getOptions()))->start();
-        // return this if there was no problem running the command
-        // (it's equivalent to returning int(0))
        return Command::SUCCESS;
-
-        // or return this if some error happened during the execution
-        // (it's equivalent to returning int(1))
-        // return Command::FAILURE;
    }
 }
--- a/src/ZM/ConsoleApplication.php
+++ b/src/ZM/ConsoleApplication.php
@@ -5,6 +5,9 @@ namespace ZM;


 use Exception;
+use ZM\Command\DaemonReloadCommand;
+use ZM\Command\DaemonStatusCommand;
+use ZM\Command\DaemonStopCommand;
 use ZM\Command\InitCommand;
 use ZM\Command\PureHttpCommand;
 use ZM\Command\RunServerCommand;
@@ -40,7 +43,6 @@ class ConsoleApplication extends Application
             * @noinspection RedundantSuppression
             */
            require_once WORKING_DIR . "/vendor/autoload.php";
-            echo "* This is repository mode.\n";
            $composer = json_decode(file_get_contents(DataProvider::getWorkingDir() . "/composer.json"), true);
            if (!isset($composer["autoload"]["psr-4"]["Module\\"])) {
                echo "框架源码模式需要在autoload文件中添加Module目录为自动加载，是否添加？[Y/n] ";
@@ -64,6 +66,9 @@ class ConsoleApplication extends Application
        }

        $this->addCommands([
+            new DaemonStatusCommand(),
+            new DaemonReloadCommand(),
+            new DaemonStopCommand(),
            new RunServerCommand(), //运行主服务的指令控制器
            new InitCommand(), //初始化用的，用于项目初始化和phar初始化
            new PureHttpCommand() //纯HTTP服务器指令
@@ -75,6 +80,7 @@ class ConsoleApplication extends Application
            if (!($obj instanceof Command)) throw new TypeError("Command register class must be extended by Symfony\\Component\\Console\\Command\\Command");
            $this->add($obj);
        }*/
+        return $this;
    }

    /**
--- a/src/ZM/Context/Context.php
+++ b/src/ZM/Context/Context.php
@@ -145,7 +145,7 @@ class Context implements ContextInterface
        if ($prompt != "") $this->reply($prompt);

        try {
-            $r = CoMessage::yieldByWS($this->getData(), ["user_id", "self_id", "message_type", onebot_target_id_name($this->getMessageType())]);
+            $r = CoMessage::yieldByWS($this->getData(), ["user_id", "self_id", "message_type", onebot_target_id_name($this->getMessageType())], $timeout);
        } catch (Exception $e) {
            $r = false;
        }
--- a/src/ZM/Context/ContextInterface.php
+++ b/src/ZM/Context/ContextInterface.php
@@ -117,6 +117,8 @@ interface ContextInterface

    public function cloneFromParent();

+    public function getNumArg($prompt_msg = "");
+
    public function copy();

    public function getOption();
--- a/src/ZM/DB/DB.php
+++ b/src/ZM/DB/DB.php
@@ -31,7 +31,6 @@ class DB

    /**
     * @param $table_name
-     * @param bool $enable_cache
     * @return Table
     * @throws DbException
     */
@@ -95,6 +94,7 @@ class DB
            $ps = $conn->prepare($line);
            if ($ps === false) {
                SqlPoolStorage::$sql_pool->put(null);
+                /** @noinspection PhpUndefinedFieldInspection */
                throw new DbException("SQL语句查询错误，" . $line . "，错误信息：" . $conn->error);
            } else {
                if (!($ps instanceof PDOStatement) && !($ps instanceof PDOStatementProxy)) {
--- a/src/ZM/DB/Table.php
+++ b/src/ZM/DB/Table.php
@@ -47,7 +47,7 @@ class Table
        return new DeleteBody($this);
    }

-    public function statement($line){
+    public function statement(){
        $this->cache = [];
        //TODO: 无返回的statement语句
    }
--- a/src/ZM/Event/EventDispatcher.php
+++ b/src/ZM/Event/EventDispatcher.php
@@ -87,7 +87,6 @@ class EventDispatcher
    /**
     * @param mixed ...$params
     * @throws Exception
-     * @throws InterruptException
     */
    public function dispatchEvents(...$params) {
        try {
@@ -104,10 +103,7 @@ class EventDispatcher
        } catch (InterruptException $e) {
            $this->store = $e->return_var;
            $this->status = self::STATUS_INTERRUPTED;
-        } catch (Exception $e) {
-            $this->status = self::STATUS_EXCEPTION;
-            throw $e;
-        } catch (Error $e) {
+        } catch (Exception | Error $e) {
            $this->status = self::STATUS_EXCEPTION;
            throw $e;
        }
--- a/src/ZM/Event/EventManager.php
+++ b/src/ZM/Event/EventManager.php
@@ -38,7 +38,7 @@ class EventManager
    public static function registerTimerTick() {
        $dispatcher = new EventDispatcher(OnTick::class);
        foreach (self::$events[OnTick::class] ?? [] as $vss) {
-            if (server()->worker_id !== $vss->worker_id) return;
+            if (server()->worker_id !== $vss->worker_id && $vss->worker_id != -1) return;
            //echo server()->worker_id.PHP_EOL;
            $plain_class = $vss->class;
            Console::debug("Added Middleware-based timer: " . $plain_class . " -> " . $vss->method);
--- a/src/ZM/Event/ServerEventHandler.php
+++ b/src/ZM/Event/ServerEventHandler.php
@@ -1,4 +1,6 @@
-<?php /** @noinspection PhpComposerExtensionStubsInspection */
+<?php /** @noinspection PhpUnreachableStatementInspection */
+
+/** @noinspection PhpComposerExtensionStubsInspection */


 namespace ZM\Event;
@@ -14,12 +16,12 @@ use Swoole\Database\PDOConfig;
 use Swoole\Database\PDOPool;
 use Swoole\Event;
 use Swoole\Process;
-use Swoole\Timer;
 use ZM\Annotation\AnnotationParser;
 use ZM\Annotation\Http\RequestMapping;
 use ZM\Annotation\Swoole\OnCloseEvent;
 use ZM\Annotation\Swoole\OnMessageEvent;
 use ZM\Annotation\Swoole\OnOpenEvent;
+use ZM\Annotation\Swoole\OnPipeMessageEvent;
 use ZM\Annotation\Swoole\OnRequestEvent;
 use ZM\Annotation\Swoole\OnStart;
 use ZM\Annotation\Swoole\OnSwooleEvent;
@@ -42,6 +44,7 @@ use ZM\Module\QQBot;
 use ZM\Store\LightCacheInside;
 use ZM\Store\MySQL\SqlPoolStorage;
 use ZM\Store\Redis\ZMRedisPool;
+use ZM\Store\WorkerCache;
 use ZM\Store\ZMBuf;
 use ZM\Utils\DataProvider;
 use ZM\Utils\HttpUtil;
@@ -71,11 +74,18 @@ class ServerEventHandler
        }
        Process::signal(SIGINT, function () use ($r) {
            echo "\r";
-            Console::warning("Server interrupted by keyboard on Master.");
+            Console::warning("Server interrupted(SIGINT) on Master.");
            if ((Framework::$server->inotify ?? null) !== null)
                /** @noinspection PhpUndefinedFieldInspection */ Event::del(Framework::$server->inotify);
            ZMUtil::stop();
        });
+        if (Framework::$argv["daemon"]) {
+            $daemon_data = json_encode([
+                "pid" => \server()->master_pid,
+                "stdout" => ZMConfig::get("global")["swoole"]["log_file"]
+            ], 128 | 256);
+            file_put_contents(DataProvider::getWorkingDir() . "/.daemon_pid", $daemon_data);
+        }
        if (Framework::$argv["watch"]) {
            if (extension_loaded('inotify')) {
                Console::warning("Enabled File watcher, do not use in production.");
@@ -84,11 +94,11 @@ class ServerEventHandler
                $this->addWatcher(DataProvider::getWorkingDir() . "/src", $fd);
                Event::add($fd, function () use ($fd) {
                    $r = inotify_read($fd);
-                    var_dump($r);
+                    dump($r);
                    ZMUtil::reload();
                });
            } else {
-                Console::warning("You have not loaded inotify extension.");
+                Console::warning("You have not loaded \"inotify\" extension, please install first.");
            }
        }
    }
@@ -228,7 +238,7 @@ class ServerEventHandler
                Console::error("PHP Error: " . $e->getMessage() . " in " . $e->getFile() . " on line " . $e->getLine());
                Console::error("Maybe it caused by your own code if in your own Module directory.");
                Console::log($e->getTraceAsString(), 'gray');
-                ZMUtil::stop();
+                posix_kill($server->master_pid, SIGINT);
            }
        } else {
            // 这里是TaskWorker初始化的内容部分
@@ -245,7 +255,7 @@ class ServerEventHandler
                Console::error("PHP Error: " . $e->getMessage() . " in " . $e->getFile() . " on line " . $e->getLine());
                Console::error("Maybe it caused by your own code if in your own Module directory.");
                Console::log($e->getTraceAsString(), 'gray');
-                ZMUtil::stop();
+                posix_kill($server->master_pid, SIGINT);
            }
        }
    }
@@ -258,11 +268,12 @@ class ServerEventHandler
    public function onMessage($server, Frame $frame) {

        Console::debug("Calling Swoole \"message\" from fd=" . $frame->fd . ": " . TermColor::ITALIC . $frame->data . TermColor::RESET);
-        unset(Context::$context[\Swoole\Coroutine::getCid()]);
+        unset(Context::$context[Coroutine::getCid()]);
        $conn = ManagerGM::get($frame->fd);
        set_coroutine_params(["server" => $server, "frame" => $frame, "connection" => $conn]);
        $dispatcher1 = new EventDispatcher(OnMessageEvent::class);
        $dispatcher1->setRuleFunction(function ($v) {
+            /** @noinspection PhpUnreachableStatementInspection */
            return ctx()->getConnection()->getName() == $v->connect_type && eval("return " . $v->getRule() . ";");
        });

@@ -303,6 +314,9 @@ class ServerEventHandler
     */
    public function onRequest(?Request $request, ?\Swoole\Http\Response $response) {
        $response = new Response($response);
+        foreach (ZMConfig::get("global")["http_header"] as $k => $v) {
+            $response->setHeader($k, $v);
+        }
        unset(Context::$context[Co::getCid()]);
        Console::debug("Calling Swoole \"request\" event from fd=" . $request->fd);
        set_coroutine_params(["request" => $request, "response" => $response]);
@@ -386,7 +400,15 @@ class ServerEventHandler
    public function onOpen($server, Request $request) {
        Console::debug("Calling Swoole \"open\" event from fd=" . $request->fd);
        unset(Context::$context[Co::getCid()]);
-        $type = strtolower($request->get["type"] ?? $request->header["x-client-role"] ?? "");
+        $type = strtolower($request->header["x-client-role"] ?? $request->get["type"] ?? "");
+        $access_token = explode(" ", $request->header["authorization"] ?? $request->get["token"] ?? "")[1] ?? "";
+        if (($a = ZMConfig::get("global", "access_token")) != "") {
+            if ($access_token !== $a) {
+                $server->close($request->fd);
+                Console::warning("Unauthorized access_token: ".$access_token);
+                return;
+            }
+        }
        $type_conn = ManagerGM::getTypeClassName($type);
        ManagerGM::pushConnect($request->fd, $type_conn);
        $conn = ManagerGM::get($request->fd);
@@ -477,9 +499,10 @@ class ServerEventHandler

    /**
     * @SwooleHandler("pipeMessage")
-     * @param $server
+     * @param Server $server
     * @param $src_worker_id
     * @param $data
+     * @throws Exception
     */
    public function onPipeMessage(Server $server, $src_worker_id, $data) {
        //var_dump($data, $server->worker_id);
@@ -490,28 +513,75 @@ class ServerEventHandler
                $obj = $data["data"];
                Co::resume($obj["coroutine"]);
                break;
-            case "stop":
-                Console::verbose('正在清理 #' . $server->worker_id . ' 的计时器');
-                Timer::clearAll();
+            case "getWorkerCache":
+                $r = WorkerCache::get($data["key"]);
+                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
+                $server->sendMessage(json_encode($action, 256), $src_worker_id);
                break;
-            case "terminate":
-                $server->stop();
+            case "setWorkerCache":
+                $r = WorkerCache::set($data["key"], $data["value"]);
+                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
+                $server->sendMessage(json_encode($action, 256), $src_worker_id);
                break;
-            case 'echo':
-                Console::success('接收到来自 #' . $src_worker_id . ' 的消息');
+            case "unsetWorkerCache":
+                $r = WorkerCache::unset($data["key"]);
+                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
+                $server->sendMessage(json_encode($action, 256), $src_worker_id);
                break;
-            case 'send':
-                $server->sendMessage(json_encode(["action" => "echo"]), $data["target"]);
+            case "asyncAddWorkerCache":
+                WorkerCache::add($data["key"], $data["value"], true);
+                break;
+            case "asyncSubWorkerCache":
+                WorkerCache::sub($data["key"], $data["value"], true);
+                break;
+            case "asyncSetWorkerCache":
+                WorkerCache::set($data["key"], $data["value"], true);
+                break;
+            case "asyncUnsetWorkerCache":
+                WorkerCache::unset($data["key"], true);
+                break;
+            case "addWorkerCache":
+                $r = WorkerCache::add($data["key"], $data["value"]);
+                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
+                $server->sendMessage(json_encode($action, 256), $src_worker_id);
+                break;
+            case "subWorkerCache":
+                $r = WorkerCache::sub($data["key"], $data["value"]);
+                $action = ["action" => "returnWorkerCache", "cid" => $data["cid"], "value" => $r];
+                $server->sendMessage(json_encode($action, 256), $src_worker_id);
+                break;
+            case "returnWorkerCache":
+                WorkerCache::$transfer[$data["cid"]] = $data["value"];
+                zm_resume($data["cid"]);
                break;
            default:
-                echo $data . PHP_EOL;
+                $dispatcher = new EventDispatcher(OnPipeMessageEvent::class);
+                $dispatcher->setRuleFunction(function (OnPipeMessageEvent $v) use ($data) {
+                    return $v->action == $data["action"];
+                });
+                $dispatcher->dispatchEvents($data);
+                break;
        }
    }

    /**
     * @SwooleHandler("task")
+     * @param Server|null $server
+     * @param Server\Task $task
+     * @return mixed
+     * @noinspection PhpUnusedParameterInspection
     */
-    public function onTask() {
+    public function onTask(?Server $server, Server\Task $task) {
+        $data = $task->data;
+        switch ($data["action"]) {
+            case "runMethod":
+                $c = $data["class"];
+                $ss = new $c();
+                $method = $data["method"];
+                $ps = $data["params"];
+                $task->finish($ss->$method(...$ps));
+        }
+        return null;
    }

    /**
--- a/src/ZM/Framework.php
+++ b/src/ZM/Framework.php
@@ -250,6 +250,7 @@ class Framework
                case 'daemon':
                    if ($y) {
                        $this->server_set["daemonize"] = 1;
+                        Console::$theme = "no-color";
                        Console::log("已启用守护进程，输出重定向到 " . $this->server_set["log_file"]);
                        $terminal_id = null;
                    }
--- a/src/ZM/Http/Response.php
+++ b/src/ZM/Http/Response.php
@@ -4,8 +4,6 @@
 namespace ZM\Http;


-use ZM\Console\Console;
-
 class Response
 {

--- a/src/ZM/Http/RouteManager.php
+++ b/src/ZM/Http/RouteManager.php
@@ -8,6 +8,7 @@ use Symfony\Component\Routing\Route;
 use Symfony\Component\Routing\RouteCollection;
 use ZM\Annotation\Http\Controller;
 use ZM\Annotation\Http\RequestMapping;
+use ZM\Console\Console;

 class RouteManager
 {
@@ -25,8 +26,9 @@ class RouteManager
                break;
            }
        }
-
-        $route_name = $prefix."/".$vss->route;
+        $tail = trim($vss->route, "/");
+        $route_name = $prefix.($tail === "" ? "" : "/").$tail;
+        Console::debug("添加路由：".$route_name);
        $route = new Route($route_name, ['_class' => $class, '_method' => $method]);
        $route->setMethods($vss->request_method);

--- a/src/ZM/Module/QQBot.php
+++ b/src/ZM/Module/QQBot.php
@@ -3,7 +3,7 @@

 namespace ZM\Module;

-use Swoole\Coroutine;
+use Exception;
 use ZM\Annotation\CQ\CQAPIResponse;
 use ZM\Annotation\CQ\CQBefore;
 use ZM\Annotation\CQ\CQCommand;
@@ -14,8 +14,6 @@ use ZM\Annotation\CQ\CQRequest;
 use ZM\Event\EventDispatcher;
 use ZM\Exception\InterruptException;
 use ZM\Exception\WaitTimeoutException;
-use ZM\Store\LightCacheInside;
-use ZM\Store\Lock\SpinLock;
 use ZM\Utils\CoMessage;

 /**
@@ -26,27 +24,27 @@ class QQBot
 {
    /**
     * @throws InterruptException
+     * @throws Exception
     */
    public function handle() {
        try {
            $data = json_decode(context()->getFrame()->data, true);
+            set_coroutine_params(["data" => $data]);
            if (isset($data["post_type"])) {
                //echo TermColor::ITALIC.json_encode($data, 128|256).TermColor::RESET.PHP_EOL;
-                set_coroutine_params(["data" => $data]);
                ctx()->setCache("level", 0);
                //Console::debug("Calling CQ Event from fd=" . ctx()->getConnection()->getFd());
                if ($data["post_type"] != "meta_event") {
                    $r = $this->dispatchBeforeEvents($data); // before在这里执行，元事件不执行before为减少不必要的调试日志
                    if ($r->store === "block") EventDispatcher::interrupt();
                }
-                if (CoMessage::resumeByWS()) {
-                    EventDispatcher::interrupt();
-                }
                //Console::warning("最上数据包：".json_encode($data));
-                $this->dispatchEvents($data);
-            } else {
-                $this->dispatchAPIResponse($data);
            }
+            if (isset($data["echo"]) || isset($data["post_type"])) {
+                if (CoMessage::resumeByWS()) EventDispatcher::interrupt();
+            }
+            if (isset($data["post_type"])) $this->dispatchEvents($data);
+            else $this->dispatchAPIResponse($data);
        } /** @noinspection PhpRedundantCatchClauseInspection */ catch (WaitTimeoutException $e) {
            $e->module->finalReply($e->getMessage());
        }
@@ -55,7 +53,7 @@ class QQBot
    /**
     * @param $data
     * @return EventDispatcher
-     * @throws InterruptException
+     * @throws Exception
     */
    public function dispatchBeforeEvents($data) {
        $before = new EventDispatcher(CQBefore::class);
@@ -78,6 +76,7 @@ class QQBot
        switch ($data["post_type"]) {
            case "message":
                $word = explodeMsg(str_replace("\r", "", context()->getMessage()));
+                if (empty($word)) $word = [""];
                if (count(explode("\n", $word[0])) >= 2) {
                    $enter = explode("\n", context()->getMessage());
                    $first = split_explode(" ", array_shift($enter));
@@ -176,45 +175,16 @@ class QQBot
        }
    }

+    /**
+     * @param $req
+     * @throws Exception
+     */
    private function dispatchAPIResponse($req) {
-        $status = $req["status"];
-        $retcode = $req["retcode"];
-        $data = $req["data"];
-        if (isset($req["echo"]) && is_numeric($req["echo"])) {
-            $r = LightCacheInside::get("wait_api", "wait_api");
-            if (isset($r[$req["echo"]])) {
-                $origin = $r[$req["echo"]];
-                $self_id = $origin["self_id"];
-                $response = [
-                    "status" => $status,
-                    "retcode" => $retcode,
-                    "data" => $data,
-                    "self_id" => $self_id,
-                    "echo" => $req["echo"]
-                ];
-                set_coroutine_params(["cq_response" => $response]);
-                $dispatcher = new EventDispatcher(CQAPIResponse::class);
-                $dispatcher->setRuleFunction(function (CQAPIResponse $response) {
-                    return $response->retcode == ctx()->getCQResponse()["retcode"];
-                });
-                $dispatcher->dispatchEvents($response);
-
-                $origin_ctx = ctx()->copy();
-                set_coroutine_params($origin_ctx);
-                if (($origin["coroutine"] ?? false) !== false) {
-                    SpinLock::lock("wait_api");
-                    $r = LightCacheInside::get("wait_api", "wait_api");
-                    $r[$req["echo"]]["result"] = $response;
-                    LightCacheInside::set("wait_api", "wait_api", $r);
-                    SpinLock::unlock("wait_api");
-                    Coroutine::resume($origin['coroutine']);
-                }
-                SpinLock::lock("wait_api");
-                $r = LightCacheInside::get("wait_api", "wait_api");
-                unset($r[$req["echo"]]);
-                LightCacheInside::set("wait_api", "wait_api", $r);
-                SpinLock::unlock("wait_api");
-            }
-        }
+        set_coroutine_params(["cq_response" => $req]);
+        $dispatcher = new EventDispatcher(CQAPIResponse::class);
+        $dispatcher->setRuleFunction(function (CQAPIResponse $response) {
+            return $response->retcode == ctx()->getCQResponse()["retcode"];
+        });
+        $dispatcher->dispatchEvents($req);
    }
 }
--- a/src/ZM/Store/LightCache.php
+++ b/src/ZM/Store/LightCache.php
@@ -7,6 +7,7 @@ namespace ZM\Store;
 use Exception;
 use Swoole\Table;
 use ZM\Console\Console;
+use ZM\Exception\ZMException;

 class LightCache
 {
@@ -19,6 +20,11 @@ class LightCache

    public static $last_error = '';

+    /**
+     * @param $config
+     * @return bool|mixed
+     * @throws Exception
+     */
    public static function init($config) {
        self::$config = $config;
        self::$kv_table = new Table($config["size"], $config["hash_conflict_proportion"]);
@@ -50,11 +56,11 @@ class LightCache

    /**
     * @param string $key
-     * @return null|string
-     * @throws Exception
+     * @return null|mixed
+     * @throws ZMException
     */
    public static function get(string $key) {
-        if (self::$kv_table === null) throw new Exception("not initialized LightCache");
+        if (self::$kv_table === null) throw new ZMException("not initialized LightCache");
        self::checkExpire($key);
        $r = self::$kv_table->get($key);
        return $r === false ? null : self::parseGet($r);
@@ -63,10 +69,10 @@ class LightCache
    /**
     * @param string $key
     * @return mixed|null
-     * @throws Exception
+     * @throws ZMException
     */
    public static function getExpire(string $key) {
-        if (self::$kv_table === null) throw new Exception("not initialized LightCache");
+        if (self::$kv_table === null) throw new ZMException("not initialized LightCache");
        self::checkExpire($key);
        $r = self::$kv_table->get($key, "expire");
        return $r === false ? null : $r - time();
@@ -77,10 +83,10 @@ class LightCache
     * @param string|array|int $value
     * @param int $expire
     * @return mixed
-     * @throws Exception
+     * @throws ZMException
     */
    public static function set(string $key, $value, int $expire = -1) {
-        if (self::$kv_table === null) throw new Exception("not initialized LightCache");
+        if (self::$kv_table === null) throw new ZMException("not initialized LightCache");
        if (is_array($value)) {
            $value = json_encode($value, JSON_UNESCAPED_UNICODE);
            if (strlen($value) >= self::$config["max_strlen"]) return false;
@@ -93,7 +99,7 @@ class LightCache
            $data_type = "bool";
            $value = json_encode($value);
        } else {
-            throw new Exception("Only can set string, array and int");
+            throw new ZMException("Only can set string, array and int");
        }
        try {
            return self::$kv_table->set($key, [
@@ -110,10 +116,10 @@ class LightCache
     * @param string $key
     * @param $value
     * @return bool|mixed
-     * @throws Exception
+     * @throws ZMException
     */
    public static function update(string $key, $value) {
-        if (self::$kv_table === null) throw new Exception("not initialized LightCache.");
+        if (self::$kv_table === null) throw new ZMException("not initialized LightCache.");
        if (is_array($value)) {
            $value = json_encode($value, JSON_UNESCAPED_UNICODE);
            if (strlen($value) >= self::$config["max_strlen"]) return false;
@@ -123,7 +129,7 @@ class LightCache
        } elseif (is_int($value)) {
            $data_type = "int";
        } else {
-            throw new Exception("Only can set string, array and int");
+            throw new ZMException("Only can set string, array and int");
        }
        try {
            if (self::$kv_table->get($key) === false) return false;
--- a/src/ZM/Store/LightCacheInside.php
+++ b/src/ZM/Store/LightCacheInside.php
@@ -23,9 +23,10 @@ class LightCacheInside
        $result = self::$kv_table["wait_api"]->create() && self::$kv_table["connect"]->create();
        if ($result === false) {
            self::$last_error = '系统内存不足，申请失败';
-            return $result;
+            return false;
+        } else {
+            return true;
        }
-        return $result;
    }

    /**
--- a/src/ZM/Store/WorkerCache.php
+++ b/src/ZM/Store/WorkerCache.php
@@ -0,0 +1,86 @@
+<?php
+
+
+namespace ZM\Store;
+
+
+use ZM\Config\ZMConfig;
+
+class WorkerCache
+{
+    public static $config = null;
+
+    public static $store = [];
+
+    public static $transfer = [];
+
+    public static function get($key) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache") ?? ["worker" => 0];
+        if ($config["worker"] === server()->worker_id) {
+            return self::$store[$key] ?? null;
+        } else {
+            $action = ["action" => "getWorkerCache", "key" => $key, "cid" => zm_cid()];
+            server()->sendMessage(json_encode($action, JSON_UNESCAPED_UNICODE), $config["worker"]);
+            zm_yield();
+            $p = self::$transfer[zm_cid()] ?? null;
+            unset(self::$transfer[zm_cid()]);
+            return $p;
+        }
+    }
+
+    public static function set($key, $value, $async = false) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache");
+        if ($config["worker"] === server()->worker_id) {
+            self::$store[$key] = $value;
+            return true;
+        } else {
+            $action = ["action" => $async ? "asyncSetWorkerCache" : "setWorkerCache", "key" => $key, "value" => $value, "cid" => zm_cid()];
+            return self::processRemote($action, $async, $config);
+        }
+    }
+    
+    private static function processRemote($action, $async, $config) {
+        $ss = server()->sendMessage(json_encode($action, JSON_UNESCAPED_UNICODE), $config["worker"]);
+        if(!$ss) return false;
+        if ($async) return true;
+        zm_yield();
+        $p = self::$transfer[zm_cid()] ?? null;
+        unset(self::$transfer[zm_cid()]);
+        return $p;
+    }
+
+    public static function unset($key, $async = false) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache");
+        if ($config["worker"] === server()->worker_id) {
+            unset(self::$store[$key]);
+            return true;
+        } else {
+            $action = ["action" => $async ? "asyncUnsetWorkerCache" : "unsetWorkerCache", "key" => $key, "cid" => zm_cid()];
+            return self::processRemote($action, $async, $config);
+        }
+    }
+
+    public static function add($key, int $value, $async = false) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache");
+        if ($config["worker"] === server()->worker_id) {
+            if(!isset(self::$store[$key])) self::$store[$key] = 0;
+            self::$store[$key] += $value;
+            return true;
+        } else {
+            $action = ["action" => $async ? "asyncAddWorkerCache" : "addWorkerCache", "key" => $key, "value" => $value, "cid" => zm_cid()];
+            return self::processRemote($action, $async, $config);
+        }
+    }
+
+    public static function sub($key, int $value, $async = false) {
+        $config = self::$config ?? ZMConfig::get("global", "worker_cache");
+        if ($config["worker"] === server()->worker_id) {
+            if(!isset(self::$store[$key])) self::$store[$key] = 0;
+            self::$store[$key] -= $value;
+            return true;
+        } else {
+            $action = ["action" => $async ? "asyncSubWorkerCache" : "subWorkerCache", "key" => $key, "value" => $value, "cid" => zm_cid()];
+            return self::processRemote($action, $async, $config);
+        }
+    }
+}
--- a/src/ZM/Utils/CoMessage.php
+++ b/src/ZM/Utils/CoMessage.php
@@ -16,7 +16,7 @@ class CoMessage
     * @param array $hang
     * @param array $compare
     * @param int $timeout
-     * @return bool
+     * @return mixed
     * @throws Exception
     */
    public static function yieldByWS(array $hang, array $compare, $timeout = 600) {
@@ -57,7 +57,8 @@ class CoMessage
        foreach ($all as $k => $v) {
            if(!isset($v["compare"])) continue;
            foreach ($v["compare"] as $vs) {
-                if ($v[$vs] != ($dat[$vs] ?? null)) {
+                if (!isset($v[$vs], $dat[$vs])) continue 2;
+                if ($v[$vs] != $dat[$vs]) {
                    continue 2;
                }
            }
@@ -68,7 +69,7 @@ class CoMessage
            LightCacheInside::set("wait_api", "wait_api", $all);
            SpinLock::unlock("wait_api");
            if ($all[$last]["worker_id"] != server()->worker_id) {
-                ZMUtil::sendActionToWorker($all[$k]["worker_id"], "resume_ws_message", $all[$last]);
+                ZMUtil::sendActionToWorker($all[$last]["worker_id"], "resume_ws_message", $all[$last]);
            } else {
                Co::resume($all[$last]["coroutine"]);
            }
--- a/src/ZM/Utils/ProcessManager.php
+++ b/src/ZM/Utils/ProcessManager.php
@@ -0,0 +1,17 @@
+<?php
+
+
+namespace ZM\Utils;
+
+
+class ProcessManager
+{
+    public static function runOnTask($param, $timeout = 0.5, $dst_worker_id = -1) {
+        return server()->taskwait([
+            "action" => "runMethod",
+            "class" => $param["class"],
+            "method" => $param["method"],
+            "params" => $param["params"]
+        ], $timeout, $dst_worker_id);
+    }
+}
--- a/src/ZM/Utils/SingletonTrait.php
+++ b/src/ZM/Utils/SingletonTrait.php
@@ -11,6 +11,8 @@ trait SingletonTrait
     */
    private static $instance;

+    protected static $cached = [];
+
    /**
     * @return self
     */
--- a/src/ZM/global_functions.php
+++ b/src/ZM/global_functions.php
@@ -24,6 +24,7 @@ function phar_classloader($p) {
        return;
    }
    try {
+        /** @noinspection PhpIncludeInspection */
        require_once $filepath;
    } catch (Exception $e) {
        echo "Error when finding class: " . $p . PHP_EOL;
@@ -75,7 +76,7 @@ function unicode_decode($str) {
 /**
 * 获取模块文件夹下的每个类文件的类名称
 * @param $dir
- * @param string $indoor_name
+ * @param $indoor_name
 * @return array
 */
 function getAllClasses($dir, $indoor_name) {
@@ -95,6 +96,7 @@ function getAllClasses($dir, $indoor_name) {
                    continue 2;
                }
            }
+            if ($v == "global_function.php") continue;
            $class_name = $indoor_name . "\\" . mb_substr($v, 0, -4);
            $classes [] = $class_name;
        }
--- a/test/usage_test.php
+++ b/test/usage_test.php
@@ -0,0 +1,10 @@
+<?php
+
+use ZM\Exception\ZMException;
+use ZM\Store\LightCache;
+
+LightCache::getMemoryUsage();
+try {
+    LightCache::getExpire('1');
+} catch (ZMException $e) {
+}
Author	SHA1	Message	Date
jerry	517d258d61	update to 2.2.3 version, I am tired fix access_token not working fix waitMessage() not working in v2.2.2	2021-01-30 00:06:42 +08:00
jerry	61e3818563	update to 2.2.2 version finally clean redundant code fix API reply in @OnTick for multi-process fix loop error reporting	2021-01-29 23:34:34 +08:00
jerry	776ec98a3e	fix waitMessage timeout bug	2021-01-29 22:32:29 +08:00
jerry	f3e844bb0a	update to 2.2.2 version fix QQBot error clean code	2021-01-29 22:27:10 +08:00
jerry	a55cd4ed05	update docs	2021-01-29 21:37:02 +08:00
jerry	8a985620f9	update to 2.2.1 version fix a compatibility bug	2021-01-29 21:36:14 +08:00
jerry	484ddf9dfa	update Hello.php update docs	2021-01-29 21:30:19 +08:00
jerry	b611b4aad6	add DaemonCommand for daemon players adjust http_header available	2021-01-29 20:47:00 +08:00
jerry	b9f973c718	add unset for WorkerCache.php	2021-01-20 18:43:22 +08:00
jerry	cd6c971547	update Singleton	2021-01-20 16:45:50 +08:00
jerry	c68083484a	update to 2.2.0 version add OnPipeMessageEvent.php add ProcessManager.php add WorkerCache component fix route bug correct Exception to ZMException	2021-01-20 16:11:04 +08:00
jerry	f999e689bf	update docs	2021-01-18 18:09:33 +08:00
jerry	187a08a621	update to 2.1.6 version 优化代码结构增加更多提示语修复处理空格消息时的报错修复上下文的bug	2021-01-18 18:08:29 +08:00
Whale	c208298937	Update README.md	2021-01-14 18:32:54 +08:00