最近一直在思考如何利用 Laravel,更进一步做出一套较为不一样的开发框架出来。反复看了很多有关 Laravel 框架的资料和文档,最后还是落在 Laravel Model 层上来。

发现 Model 还有很多值得学习的地方,其中 Events 让人眼前一亮。

下面从「观察者模式」到「Laravel 事件系统」,再到 「Model Events」,简述 Model Events 的使用。

观察者模式

Define a one-to-many dependency between objects so that when one object changes state, all its dependents aer notified and updated automatically.

定义对象间一种一对多的依赖关系,使得当一个对象改变状态,则所有依赖于它的对象都会得到通知并被自动更新。

如上图所示(截取自《Head First Design Patterns》一书),主要包括四个部分:

  1. Subject 被观察者。是一个接口或者是抽象类,定义被观察者必须实现的职责,它必须能偶动态地增加、取消观察者,管理观察者并通知观察者。

  2. Observer 观察者。观察者接收到消息后,即进行 update 更新操作,对接收到的信息进行处理。

  3. ConcreteSubject 具体的被观察者。定义被观察者自己的业务逻辑,同时定义对哪些事件进行通知。

  4. ConcreteObserver 具体观察者。每个观察者在接收到信息后处理的方式不同,各个观察者有自己的处理逻辑。

观察者模式优势

观察者和被观察者之间是抽象耦合的,不管是增加观察者还是被观察者都非常容易扩展。

根据单一职责原则,每个类的职责是单一的,那么怎么把各个单一的职责串联成真实的复杂的逻辑关系呢,观察者模式可以起到桥梁作用。

观察者模式是松耦合的典型。

Laravel 的事件系统

在 Laravel 框架中,存在事件机制这种很好的应用解耦方式,因为一个事件可以拥有多个互不依赖的监听器。例如,如果你希望每次生成订单,或者订单状态由「未支付转为支付」时,向用户或者运营人员发送一个短信或者钉钉通知。你可以简单地发起一个 OrderSaving 事件,让监听器接收之后转化成一个短信或者钉钉通知,这样你就可以不用把「订单的业务代码」和「消息通知」的代码耦合在一起了,起到「解耦」的效果。

Laravel 的事件提供了一个简单的观察者实现,能够订阅和监听应用中发生的各种事件。事件类保存在 app/Events 目录中,而这些事件的的监听器则被保存在 app/Listeners 目录下。这些目录可以使用 Artisan 命令来生成。

根据 ServiceProvider 的作用,程序执行时,会自动加载,所以在 Laravel 的事件系统中,EventServiceProvider 充当 Events 和 Listeners 的桥接器,也就是说,利用 EventServiceProvider 可以将 Events 和 Listeners 的关联加载到系统中。

从这也可以看出,一个 Event 对应着多个 Listeners,意味着可以被多个 Listeners 监听。

同样的,也可以在 boot 方法中注册基于事件的闭包

/**
 * 注册应用程序中的任何其他事件。
 *
 * @return void
 */
public function boot()
{
    parent::boot();

    Event::listen('event.name', function ($foo, $bar) {
        //
    });
}

下面拿 Model Event 来举例,因为 Model Event 基于 Laravel Event 系统之上。

而且相比较 Laravel Event,在常规逻辑处理时,主要是利用全局函数 event() 来触发事件,属于手动触发机制。

在 Model Event,则可以自定义在 Model 生命周期节点上「自动」触发事件。

Model Events

一个 Model 操作主要包含以下这几个生命节点:

节点 节点 节点
retrieved creating created
updating updated saving
saved deleting deleted
restoring restored

The retrieved event will fire when an existing model is retrieved from the database. When a new model is saved for the first time, the creating and created events will fire. If a model already existed in the database and the save method is called, the updating / updated events will fire. However, in both cases, the saving / saved events will fire.

相信这个比较好理解,但数据库中不存在,第一次 save 时,creatingcreated 两个事件被调用;同理,如果数据库中存在,执行 save 方法时,updatingupdated 两个事件被调用。

下面通过创建 Order Model 来举例说明,怎么使用 Laravel Event。

php artisan make:model Order -m

事件和监听器

1. 注册 Event 和 Listener

同样的,在 EventServiceProvider 注册关联:

<?php

namespace App\Providers;

use Illuminate\Support\Facades\Event;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;

class EventServiceProvider extends ServiceProvider
{
    /**
     * The event listener mappings for the application.
     *
     * @var array
     */
    protected $listen = [
        'App\Events\OrderSavingEvent' => [
            'App\Listeners\OrderSavingListener',
        ],
    ];

    /**
     * Register any events for your application.
     *
     * @return void
     */
    public function boot()
    {
        parent::boot();

        //
    }
}

2. 在 Order Model 分派 Saving Event

<?php

namespace App;

use App\Events\OrderSavingEvent;
use Illuminate\Database\Eloquent\Model;

class Order extends Model
{
    protected $dispatchesEvents = [
        'saving' => OrderSavingEvent::class,
    ];
}

3. 创建 Event 和 Listener 类

php artisan event:generate

在 Saving Event 中绑定 Order

<?php

namespace App\Events;

use App\Order;
use Illuminate\Broadcasting\Channel;
use Illuminate\Queue\SerializesModels;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Broadcasting\PresenceChannel;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;

class OrderSavingEvent
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public $order;
    /**
     * Create a new event instance.
     *
     * @return void
     */
    public function __construct(Order $order) {
        $this->order = $order;
    }

    /**
     * Get the channels the event should broadcast on.
     *
     * @return \Illuminate\Broadcasting\Channel|array
     */
    public function broadcastOn()
    {
        return new PrivateChannel('channel-name');
    }
}

4. 编写 Listener 类,处理监听逻辑

<?php

namespace App\Listeners;

use App\Events\OrderSavingEvent;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;

class OrderSavingListener
{
    /**
     * Create the event listener.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }

    /**
     * Handle the event.
     *
     * @param  OrderSavingEvent  $event
     * @return void
     */
    public function handle(OrderSavingEvent $event) {
        info($event->order);
    }
}

5. 测试

$order = new Order();
$order->name = 'good_name_2';

$order->save();

运行结果:

[2018-03-29 12:30:24] testing.INFO: {"name":"good_name_2"}

观察者模式

如果在同一个 Model 下监听多个 Events,总不能每个 Event 都需要创建对应的 Listener 类吧。Laravel 提供了一个便捷的方法:创建 observer 类,把所有 Events 聚合到这个类中,然后还在 AppServiceProvider 的 boot 中,注册这个观察类:

<?php

namespace App\Providers;

use App\Observers\OrderObserver;
use App\Order;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap any application services.
     *
     * @return void
     */
    public function boot()
    {
        Order::observe(OrderObserver::class);
    }

    /**
     * Register any application services.
     *
     * @return void
     */
    public function register()
    {
        //
    }
}

具体 observer 类:

<?php

namespace App\Observers;


use App\Order;

class OrderObserver {

    /**
     * 监听订单创建事件
     * @param Order $order
     */
    public function creating(Order $order) {
        info('creating');
        info($order);
    }

    public function created(Order $order) {
        info('created');
        info($order);
    }

    /**
     * 监听订单保存事件
     * @param Order $order
     */
    public function saving(Order $order) {
        info('saving');
        info($order);
    }

    public function saved(Order $order) {
        info('saved');
        info($order);
    }
}

测试:

$order = new Order();
$order->name = 'good_name';

$order->save();

运行效果:

[2018-03-27 15:04:02] testing.INFO: saving
[2018-03-27 15:04:02] testing.INFO: {"name":"good_name"}  
[2018-03-27 15:04:02] testing.INFO: creating  
[2018-03-27 15:04:02] testing.INFO: {"name":"good_name"}  
[2018-03-27 15:04:02] testing.INFO: created  
[2018-03-27 15:04:02] testing.INFO: {"name":"good_name","updated_at":"2018-03-27 15:04:02","created_at":"2018-03-27 15:04:02","id":1}  
[2018-03-27 15:04:02] testing.INFO: saved  
[2018-03-27 15:04:02] testing.INFO: {"name":"good_name","updated_at":"2018-03-27 15:04:02","created_at":"2018-03-27 15:04:02","id":1}

再次更新 order:

$order = Order::find(1);
$order->name = 'good_name3';

$order->save();

这时候,就不会触发 creating 和 created 事件了。运行效果:

[2018-03-27 15:11:11] testing.INFO: saving  
[2018-03-27 15:11:11] testing.INFO: {"id":1,"name":"good_name3","created_at":"2018-03-27 15:04:02","updated_at":"2018-03-27 15:04:02"}  
[2018-03-27 15:11:11] testing.INFO: saved  
[2018-03-27 15:11:11] testing.INFO: {"id":1,"name":"good_name3","created_at":"2018-03-27 15:04:02","updated_at":"2018-03-27 15:11:11"}

总结

观察者模式的作用在于:观察者和被观察者之间是抽象耦合的,当一个对象改变状态,则所有依赖于它的观察者们都会得到通知并做对应的逻辑处理。Laravel 的事件系统是一个值得研究的案例。

下一步让我们来扒一扒这背后的代码实现原理。

「未完待续」

Copyright © coding01 2018 all right reserved,powered by Gitbook该文件修订时间: 2020-02-01 22:20:20

results matching ""

    No results matching ""