最近一直在思考如何利用 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》一书），主要包括四个部分：
Subject 被观察者。是一个接口或者是抽象类，定义被观察者必须实现的职责，它必须能偶动态地增加、取消观察者，管理观察者并通知观察者。
Observer 观察者。观察者接收到消息后，即进行 update 更新操作，对接收到的信息进行处理。
ConcreteSubject 具体的被观察者。定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。
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 的事件系统是一个值得研究的案例。
下一步让我们来扒一扒这背后的代码实现原理。
来自 https://segmentfault.com/a/1190000014082263?utm_source=tag-newest
评论
来自 https://www.jianshu.com/p/485cae4b7a19