这篇文章主要介绍了PHP的Laravel框架中的event事件操作,其中重点讲解了Laravel 5.1之中新加入了事件广播的功能,需要的朋友可以参考下。

有时候当我们单纯的看 Laravel 手册的时候会有一些疑惑，比如说系统服务下的授权和事件，这些功能服务的应用场景是什么，其实如果没有经历过一定的开发经验有这些疑惑是很正常的事情，但是当我们在工作中多加思考会发现有时候这些服务其实我们一直都见过。下面就事件、事件监听举一个很简单的例子你就会发现。

这个例子是关于文章的浏览数的实现，当用户查看文章的时候文章的浏览数会增加1，用户查看文章就是一个事件，有了事件，就需要一个事件监听器，对监听的事件发生后执行相应的操作（文章浏览数加1），其实这种监听机制在 Laravel 中是通过观察者模式实现的.

注册事件以及监听器

首先我们需要在 app/Providers/目录下的EventServiceProvider.php中注册事件监听器映射关系，如下：

1. protected $listen = [
2.     'App\Events\BlogView' => [
3.       'App\Listeners\BlogViewListener',
4.     ],
5.   ];

然后项目根目录下执行如下命令

php artisan event:generate

该命令完成后，会分别自动在 app/Events和app/Listensers目录下生成 BlogView.php和BlogViewListener.php文件。

定义事件

1. <?php
3. namespace App\Events;
5. use App\Events\Event;
6. use App\Post;
7. use Illuminate\Queue\SerializesModels;
8. use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
10. class BlogView extends Event
11. {
12.   use SerializesModels;
14.   /**
15.    * Create a new event instance.
16.    *
17.    * @return void
18.    */
19.   public function __construct(Post $post)
20.   {
21.     $this->post = $post;
22.   }
24.   /**
25.    * Get the channels the event should be broadcast on.
26.    *
27.    * @return array
28.    */
29.   public function broadcastOn()
30.   {
31.     return [];
32.   }
33. }

其实看到这些你会发现该事件类只是注入了一个 Post实例罢了，并没有包含多余的逻辑。

定义监听器

事件监听器在handle方法中接收事件实例，event:generate命令将会自动在handle方法中导入合适的事件类和类型提示事件，在handle方法内，你可以执行任何需要的逻辑以响应事件，我们的代码实现如下：

1. <?php
3. namespace App\Listeners;
5. use App\Events\BlogView;
6. use Illuminate\Queue\InteractsWithQueue;
7. use Illuminate\Contracts\Queue\ShouldQueue;
8. use Illuminate\Session\Store;
10. class BlogViewListener
11. {
12.   protected $session;
13.   /**
14.    * Create the event listener.
15.    *
16.    * @return void
17.    */
18.   public function __construct(Store $session)
19.   {
20.     $this->session = $session;
21.   }
23.   /**
24.    * Handle the event.
25.    *
26.    * @param BlogView $event
27.    * @return void
28.    */
29.   public function handle(BlogView $event)
30.   {
31.     $post = $event->post;
32.      //先进行判断是否已经查看过
33.     if (!$this->hasViewedBlog($post)) {
34.        //保存到数据库
35.       $post->view_cache = $post->view_cache + 1;
36.       $post->save();
37.        //看过之后将保存到 Session 
38.       $this->storeViewedBlog($post);
39.     }
40.   }
42.   protected function hasViewedBlog($post)
43.   {
44.     return array_key_exists($post->id, $this->getViewedBlogs());
45.   }
47.   protected function getViewedBlogs()
48.   {
49.     return $this->session->get('viewed_Blogs', []);
50.   }
52.   protected function storeViewedBlog($post)
53.   {
54.     $key = 'viewed_Blogs.'.$post->id;
56.     $this->session->put($key, time());
57.   }
59. }

注释中也已经说明了一些逻辑。

触发事件

事件和事件监听完成后，我们要做的就是实现整个监听，即触发用户打开文章事件在此我们使用和 Event提供的 fire方法，如下：

1. <?php
3. namespace App\Http\Controllers;
5. use Illuminate\Http\Request;
6. use App\Post;
7. use Illuminate\Support\Facades\Event;
8. use App\Http\Requests;
9. use App\Events\BlogView;
10. use App\Http\Controllers\Controller;
12. class BlogController extends Controller
13. {
15.   public function showPost($slug)
16.   {
17.     $post = Post::whereSlug($slug)->firstOrFail();
18.     Event::fire(new BlogView($post));
19.     return view('home.blog.content')->withPost($post);
20.   }
22. }

现在打开页面发现数据库中的`view_cache已经正常加1了，这样整个就完成了。

事件广播

简介：

Laravel 5.1 之中新加入了事件广播的功能，作用是把服务器中触发的事件通过websocket服务通知客户端，也就是浏览器，客户端js根据接受到的事件，做出相应动作。本文会用简单的代码展示一个事件广播的过程。

依赖：

redis

nodejs, socket.io

laravel 5.1

配置：

config/broadcasting.php中，如下配置'default' => env('BROADCAST_DRIVER', 'redis'),，使用redis作为php和js的通信方式。

config/database.php中配置redis的连接。

定义一个被广播的事件：

根据Laravel文档的说明，想让事件被广播，必须让Event类实现一个Illuminate\Contracts\Broadcasting\ShouldBroadcast接口，并且实现一个方法broadcastOn。broadcastOn返回一个数组，包含了事件发送到的channel(频道)。如下：

1. namespace App\Events;
3. use App\Events\Event;
4. use Illuminate\Queue\SerializesModels;
5. use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
7. class SomeEvent extends Event implements ShouldBroadcast
8. {
9.   use SerializesModels;
11.   public $user_id;
13.   /**
14.    * Create a new event instance.
15.    *
16.    * @return void
17.    */
18.   public function __construct($user_id)
19.   {
20.     $this->user_id = $user_id;
21.   }
23.   /**
24.    * Get the channels the event should be broadcast on.
25.    *
26.    * @return array
27.    */
28.   public function broadcastOn()
29.   {
30.     return ['test-channel'];
31.   }
32. }

被广播的数据：

默认情况下，Event中的所有public属性都会被序列化后广播，上面的例子中就是$user_id这个属性。你也可以使用broadcastWith这个方法，明确的指出要广播什么数据，例如：

1. public function broadcastWith()
2. {
3.   return ['user_id' => $this->user_id];
4. }

Redis和Websocket服务器：

需要启动一个Redis，事件广播主要依赖的就是redis的sub/pub功能，具体可以看redis文档

需要启动一个websocket服务器来和client通信，建议使用socket.io，代码如下:

1. var app = require('http').createServer(handler);
2. var io = require('socket.io')(app);
4. var Redis = require('ioredis');
5. var redis = new Redis('6379', '192.168.1.106');
7. app.listen(6001, function() {
8.   console.log('Server is running!');
9. });
11. function handler(req, res) {
12.   res.writeHead(200);
13.   res.end('');
14. }
16. io.on('connection', function(socket) {
17.   console.log('connected');
18. });
20. redis.psubscribe('*', function(err, count) {
21.   console.log(count);
22. });
24. redis.on('pmessage', function(subscribed, channel, message) {
25.   console.log(subscribed);
26.   console.log(channel);
27.   console.log(message);
29.   message = JSON.parse(message);
30.   io.emit(channel + ':' + message.event, message.data);
31. });

这里需要注意的是redis.on方法的定义,接收到消息后，给client发送一个事件，事件名称为channel + ':' + message.event。

客户端代码：

客户端我们也使用socket.io，作为测试，代码尽量简化，仅仅打印一个接受到的数据即可，如下：

1. var socket = io('http://localhost:6001');
2. socket.on('connection', function (data) {
3.   console.log(data);
4. });
5. socket.on('test-channel:App\\Events\\SomeEvent', function(message){
6.   console.log(message);
7. });
8. console.log(socket);

服务器触发事件：

直接在router中定义个事件触发即可，如下：

1. Route::get('/event', function(){
2.   Event::fire(new \App\Events\SomeEvent(3));
3.   return "hello world";
4. });

测试：

启动redis

启动websocket

打开带有客户端代码的页面，可以看到websocket已经连接成功。

触发事件,打开另一个页面 localhost/event。

这时就可以发现，第一个页面的console中打印出了Object{user_id: 3}，说明广播成功。