ThinkPHP6 源码阅读(十):事件

说明

前面1-9篇分析完一个请求的简单生命周期,其中涵盖了依赖注入、中间件的分析,这些不在单独分析。接下来将分析框架的事件机制。

事件配置文件的载入

准备工作

项目根目录命令行运行:php think make:listen ShowAppInit创建一个监听器,这将在app\listener目录下生成一个ShowAppInit.php文件(如果没有listener目录则创建之)。接着简单修改ShowAppInit.php文件的代码如下:

<?php
namespace app\listener;
class ShowAppInit
{
    public function handle($event)
    {
        echo "App 初始化啦" .PHP_EOL;
    }    
}

监听器创建完成后,将其添加到app目录下的event.php文件:

return [
    'bind'      => [
    ],

    'listen'    => [
        'AppInit'  => [ 'app\listener\ShowAppInit' ], //添加在这里
        'HttpRun'  => [],
        'HttpEnd'  => [],
        'LogLevel' => [],
        'LogWrite' => [],
    ],

    'subscribe' => [
    ],
];

这样就绑定了一个监听器(观察者)到AppInit事件,一旦该事件被触发,监听器将开始工作——执行其handle方法下的代码。

配置载入

上面绑定监听器后,系统是在哪里载入了这些配置呢?
顺着一个请求的生命周期:Http::run()→Http::runWithRequest()→Http::initialize()->App::initialize()→App::load(),发现在load方法有这样几行:

if (is_file($appPath . 'event.php')) {
    $this->loadEvent(include $appPath . 'event.php');
}

就是在这个位置,执行loadEvent方法加载事件的配置——该方法代码如下:

public function loadEvent(array $event): void
{
    if (isset($event['bind'])) {
        // 将事件标识到事件(操作,比如一个控制器操作)的映射合并到「Event」类「$bing」成员变量中
        // 比如 'UserLogin' => 'app\event\UserLogin',
        $this->event->bind($event['bind']);
    }

    if (isset($event['listen'])) {
        // 合并所有观察者(监听者)到Event类的listener数组
        // 其形式为实际事件(被观察者)到观察者的映射
        $this->event->listenEvents($event['listen']);
    }

    if (isset($event['subscribe'])) {
        // 订阅,实际上是一个批量的监听
        // 就像一个人他同时订阅天气预报、股市行情、小花上QQ了……
        // 一个订阅器,里面可以实现多个事件的监听
        // 比如,我在一个订阅器中,同时监听用户登录,用户退出等操作
        $this->event->subscribe($event['subscribe']);
    }
}

最终得到的Event类对象大概如下:

ThinkPHP6 源码阅读(十):事件

监听器执行

事件监听器绑定到事件之后,框架在初始化过程中,将这些配置加载到Event类的对象(当然也可以在程序中手动绑定监听器),接下来就可以决定在何时触发事件。AppInit事件是在App::initialize()方法中触发的,其代码如下:

$this->event->trigger('AppInit');

接着,我们看看trigger方法是如何触发事件的(如何调用监听器的handle方法)——其代码如下:

public function trigger($event, $params = null, bool $once = false)
{
    // A 如果设置了关闭事件,则直接返回,不再执行任何监听器
    if (!$this->withEvent) {
        return;
    }
    // B
    // 如果是一个对象,解析出对象的类
    if (is_object($event)) {
        //将对象实例作为传入参数
        $params = $event;
        $event  = get_class($event);
    }
    //根据事件标识解析出实际的事件
    if (isset($this->bind[$event])) {
        $event = $this->bind[$event];
    }

    $result    = [];
    // 解析出事件的监听者(可多个)
    $listeners = $this->listener[$event] ?? [];

    foreach ($listeners as $key => $listener) {
            // C
            // 执行监听器的操作
            $result[$key] = $this->dispatch($listener, $params);
            // 如果返回false,或者没有返回值且 $once 为 true,直接中断,不再执行后面的监听器
            if (false === $result[$key] || (!is_null($result[$key]) && $once)) {
                break;
            }
        }
        // 是否返回多个监听器的结果
        // $once 为 false 则返回最后一个监听器的结果
        return $once ? end($result) : $result;
}

A 决定是否继续执行监听器

trigger方法首先通过$this->withEvent判断监听器是否要执行,如果为否,则直接终止该方法。
withEvent的值可以通过如下方法设定:

  • 配置文件中,通过设置app.with_event的值。该值在Http::runWithRequest()方法中读取进来:

    $this->app->event->withEvent($this->app->config->get('app.with_event', true));

    由此,我们可以在配置文件中全局开启或者关闭事件机制。

  • 通过Event::withEvent方法设置。由此也可以得知,我们在执行完一个监听器之后,可以通过Event::withEvent方法设置后面的监听器是否还要执行。

B 事件标识解析

这里传给trigger方法的是一个字符串(事件标识)AppInit,通过$event = $this->bind[$event] 得到$event的值为think\event\AppInit,再将该值作为键,$listeners = $this->listener[$event],从listener 数组中获取实际的监听器,这里将得到$listeners[app\listener\ShowAppInit]

C 执行监听器

这里主要看dispatch方法:

protected function dispatch($event, $params = null)
{
    // 如果不是字符串,比如,一个闭包
    if (!is_string($event)) {
        $call = $event;
        //一个类的静态方法
    } elseif (strpos($event, '::')) {
        $call = $event;
    } else {
        $obj  = $this->app->make($event);
        $call = [$obj, 'handle'];
    }
     return $this->app->invoke($call, [$params]);
}

不管是闭包、静态类方法,还是监听器的handle方法,都是通过invoke方法来执行,invoke方法实现如下:

public function invoke($callable, array $vars = [], bool $accessible = false)
{
    // 如果$callable是闭包
    if ($callable instanceof Closure) {
        return $this->invokeFunction($callable, $vars);
    }
    // $callable不是闭包的情况
    return $this->invokeMethod($callable, $vars, $accessible);
}

最终通过PHP反射类来执行对应的方法。

D 是否中断和返回结果

从代码实现可以看出,如果一个监听器方法最终返回false,或者没有返回值且 $once 为 true,则不再执行后面的监听器。trigger方法是返回多个监4听器的执行结果还是最后一个,由最后一个参数$once决定,$oncetrue,只返回最后一个监听器执行结果,反之,返回所有结果组成的数组。

监听器参数传递以及事件类

注意到监听器的handle方法还可以接收一个参数,从上面的分析可知,trigger方法的第二个参数最终将传给handle方法。

那么,在什么情况下需要用到这个参数呢?举个例子,假如要监听一个用户登录,我们可以新建一个监听器,绑定事件标识,在handle方法中实现业务逻辑——例如,输出:「有用户登录啦」,然后在登录代码的后面trigger这个事件标识。但如果我们又要知道是谁登录的话,这时我们可以把用户名作为trigger的第二个参数传入,在监听器的handle方法可以这样使用:echo $event . 用户登录啦

当然,这里的$event也可以是一个事件类对象。

订阅

这里的订阅,本质上一种「复合」的监听器,比如,小明同时要监听小花跑、跳、吃饭、睡觉,这时,就可以把小明要针对这些动作做出的反应都放在一个类里面,方便管理。

从代码的实现看,订阅是依赖于监听器存在的,订阅类的中实现的方法,会先被添加为监听器——所以对应的事件标识需要先有,最后,需要你trigger需要的事件标识,才会执行订阅类中对应的方法。

举个例子以及分析

准备工作

  • app目录下的event.php文件中的listen键添加两个事件标识,如下所示:

    'listen'    => [
        'UserLogin'    => [],
        'UserLogout'   => [],
    ],

    如果没有这两个事件标识,订阅类的方法将无法被添加到Event类的$listener 数组,导致最后无法执行到订阅类的方法的。

  • 创建一个订阅类
    项目根目录下,命令行运行:php think make:subscribe User,会在app/subscribe目录下创建一个订阅类,在该类中添加以下方法(如代码所示):

    class User
    {
    public function onUserLogin(){
        echo '我知道用户登录了,因为我订阅了<br>';
    }
    public function onUserLogout(){
        echo '我知道用户退出了,因为我订阅了<br>';
    }
    }
  • 创建控制器
    app/controller目录下创建一个User控制器,添加代码如下:

    class User
    {
    public function __construct(){
        //添加一个订阅类
        Event::subscribe(\app\subscribe\User::class);
    }
    public function login(){
        echo "用户登录了<br>   ";
        Event::trigger('UserLogin');
    }
    
    public function logout(){
        echo "用户退出了<br>   ";
        Event::trigger('UserLogout');
    }
    }

分析

假如访问User控制器的login操作,调试运行代码到Event::subscrible()方法,该方法代码如下:

public function subscribe($subscriber)
{
    if (!$this->withEvent) {
        return $this;
    }
    // 强制转换为数组
    $subscribers = (array) $subscriber;

    foreach ($subscribers as $subscriber) {
        if (is_string($subscriber)) {
            //实例化事件订阅类
            $subscriber = $this->app->make($subscriber);
        }
        // 如果该事件订阅类存在'subscribe'方法,执行该方法
        if (method_exists($subscriber, 'subscribe')) {
            // 手动订阅
            $subscriber->subscribe($this);
        } else {
            // 智能订阅
            $this->observe($subscriber);
        }
    }

    return $this;
}

这里关键看observe方法:

public function observe($observer)
{
    if (!$this->withEvent) {
        return $this;
    }

    //如果是字符串,实例化对应的类
    if (is_string($observer)) {
        $observer = $this->app->make($observer);
    }
    // 获取listener数组所有的KEY
    $events = array_keys($this->listener);

    foreach ($events as $event) {
        // 如果存在「\」,获取「\」后面的字符
        $name   = false !== strpos($event, '\\') ? substr(strrchr($event, '\\'), 1) : $event;
        //事件订阅类中的方法,命名规则是on+事件类名/事件标识
        $method = 'on' . $name;
        // 如果方法存在,则添加到$listen数组,且入口方法为$method
        if (method_exists($observer, $method)) {
            $this->listen($event, [$observer, $method]);
        }
    }

    return $this;
}

运行过程见上面的注释。该方法主要逻辑:取出Event::listener数组的所有KEY(这些KEY可以来自app/event.php文件和Event::listen()方法添加的事件监听),逐个循环,用每个KEY前面加上on构造出一个方法名,如果$observer对应的类存在该方法名,则将该事件订阅类及其方法添加到Event::listener数组。最后的结果大概是这样的:

ThinkPHP6 源码阅读(十):事件
UserLoginUserLogout事件标识下,分别添加了对应的监听器,分别是事件订阅类app\subscribe\UseronUserLoginonUserLogout

监听器添加完成后,接着是等待事件触发。login操作中,执行了Event::trigger('UserLogin');,这将执行app\subscribe\UseronUserLogin,其执行过程跟前面分析的执行事件监听器是一样的,结果输出如下:

用户登录了
我知道用户登录了,因为我订阅了

同理,访问User控制器的logout操作,得到:

用户退出了
我知道用户退出了,因为我订阅了

事件订阅分析完毕。总结一下,事件订阅就是一种「复合」的监听器,可以同时监听多个事件。从其实现过程来看,本质和事件监听器是一样的,个人认为,使用事件订阅的好处是仅仅集中管理代码,把对某个对象(被观察者)的多个动作的监听,都写在一个事件订阅类里面,因而就不用另外写相应多个动作的监听器类。

关于观察者模式

事件的实现机制,实际上是使用观察者模式实现的。观察者模式的好处是实现类的松耦合,被观察者不需要知道观察者到底做了什么,只需要触发事件就够了;另外,观察者的数量可以灵活地增加、减少,而不用修改被观察者。深入理解观察者模式,可以参考这篇:学好事件,先学学观察者模式

Was mich nicht umbringt, macht mich stärker

讨论数量: 0
(= ̄ω ̄=)··· 暂无内容!

请勿发布不友善或者负能量的内容。与人为善,比聪明更重要!