简述 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 的事件系统是一个值得研究的案例。

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

「未完待续」