简述 Laravel Model Events 的使用

最近一直在思考如何利用 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 时，creating 和 created 两个事件被调用；同理，如果数据库中存在，执行 save 方法时，updating 和 updated 两个事件被调用。

下面通过创建 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 的事件系统是一个值得研究的案例。

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

「未完待续」