Symfony2 EventDispatcher组件

        一个插件系统中，A插件在不影响其它插件的前提下，添加新的方法，或者在一个方法运行前做一些准备工作，通过继承来实现扩展是很不容易的，由于插件之间的关联关系，A插件的改变也会使得关联的插件被动的修改。

        Symfony2的EventDispatcher组件实现了中介者（mediator）模式，实现了插件之间的解耦和关联的关系。

 

        举个栗子，在HttpKernel组件中，一旦Response被创建了，在Response发送给客户端的时候，允许系统的其它模块修改它是很有必要和很有用的（例如：在头部添加缓存字段）。Symfony2内核调度kernel.response事件，那么监听该事件的监听器就可以修改Response对象了：

        a) 监听器（PHP对象）告诉一个特定的dispatcher类，它要监听kernel.response事件；

 

        b) 在某一时刻，Symfony就会告诉dispatcher调度kernel.response事件，把一个包含Response对象的Event对象传入事件调度方法EventDispatcher::dispatch()

 

        c) dispatcher通知所有监听kernel.response事件的监听器运行，允许这些监听器修改Response对象。

 

使用方法

 

Events

 

        当一个事件被调度，该事件会有一个唯一的名称（例如：kernel.response），可以被任意多个监听器监听。同时实例化一个Event对象，并传入到所有的监听器中。在后面会看到，Event对象包含了被调度事件的数据。

 

命名规范

        事件名可以是任意的字符串，但是可以遵循以下几点命名规范：

 

        * 只使用小写字符、数字、点、下划线；

 

        * 前缀名使用带有点的命名；

 

        * 结束部分的名字使用一个能表达当前事件行为的动词；

 

事件名和事件对象

 

        dispatcher调度事件通知监听器时候，会把一个Event对象作为参数传入到监听器中。基类的Event非常简单，只有一个停止事件传递给下一个监听器的方法，没有太多别的了。

        通常，一个特定事件的数据都会保存到Event对象中，方便把数据传递给监听器。在kernel.response事件中，传入到监听器的Event对象是子类FliterResponseEvent的对象，FliterResponseEvent是Event的子类。FliterResponseEvent包含getReponse和setResponse方法，允许监听器获得或者修改Response对象。

        总的来说：创建一个监听特定事件的监听器的时候，Event的一个子类会传入到监听器中，监听器可以通过该子类的方法获得和修改信息。

 

事件调度器（dispatcher）

 

        dispatcher是事件调度系统的核心，一般来说，一个dispatcher内包含一个监听器的列表，当一个事件需要被调度的时候，dispatcher就会通知它包含的所有监听该事件的监听器。

1 use Symfony\Component\EventDispatcher\EventDispatcher;

2 

3 $dispatcher = new EventDispatcher();

 

关联监听器

 

        把监听器添加到dispatcher上，监听特定的事件，那么该事件被调度的时候，dispatcher就会通知监听器工作了。dispatcher使用addListener方法把一个监听器（PHP callable）添加到一个事件上。

1 $listener = new AcmeListener();

2 $dispatcher->addListener('foo.action', array($listener, 'onFooAction'));

 

addListener方法有三个参数：

        * 监听器需要监听是的事件的名称；

        * 监听器（一个PHP callable）；

        * 一个可选的表示优先级的整数（数值越高优先级越高，监听器就会更早的被触发），默认为0，如果优先级一样，那么谁先添加就先触发；

 

PHP callable是指能作为参数传入call_user_func()或者传入is_callable()函数执行后返回true的PHP 变量。PHP callable可以是 \Closure实例，一个实现了__invoke方法的对象，或者是表示一个函数的字符串，或者一个表示对象方法或者类方法的数组。

 

到目前为止，我们看过把一个PHP对象作为监听器，我们也可以把Closure对象作为监听器。

1 use Symfony\Component\EventDispatcher\Event;

2 

3 $dispatcher->addListener('foo.action', function (Event $event) {

4     // will be executed when the foo.action event is dispatched

5 });

 　　　　在上面的例子中，foo.action事件被调度，dispatcher就调用AcmeListener::onFooAction方法，并把Event对象作为唯一的参数传入方法中。

 1 use Symfony\Component\EventDispatcher\Event;

 2 

 3 class AcmeListener

 4 {

 5     // ...

 6 

 7     public function onFooAction(Event $event)

 8     {

 9         // ... do something

10     }

11 }

　　　　 在实际使用中，都是传入一个特定的Event子类的对象到监听器，例如FilterResponseEvent:

 

1 use Symfony\Component\HttpKernel\Event\FilterResponseEvent;

2 

3 public function onKernelResponse(FilterResponseEvent $event)

4 {

5     $response = $event->getResponse();

6     $request = $event->getRequest();

7 

8     // ...

9 }

创建和调度事件

 

        除了系统内置的事件，我们也可以创建和调度自定义的事件。这是很有好处的，当我们使用第三方类库的时，还有可以使不同的组件之间解耦，使系统更灵活健壮。

 

静态的Events类

 

        假如我们要创建一个事件——store.order——当订单被创建的时候就会被触发。

namespace Acme\StoreBundle;



final class StoreEvents

{

    /**

     * The store.order event is thrown each time an order is created

     * in the system.

     *

     * The event listener receives an

     * Acme\StoreBundle\Event\FilterOrderEvent instance.

     *

     * @var string

     */

    const STORE_ORDER = 'store.order';

}

        这个类并没有什么方法，也不做什么操作，只是定义了事件名称，方便管理和组织事件。监听这个事件的监听器都会被传入一个FilterOrderEvent对象。

 

创建一个Event对象

 

        接着，当你调度这个新的事件的时候，会创建一个Event对象传如到dispatcher的dispatch()方法，dispatcher就把这个Event对象传给所有的监听该事件的监听器。如果我们不需要向监听器传入任何信息，那么可以使用系统默认的Symfony\Component\EventDispatcher\Event  类。然而，很多时候，我们都需要传入特定的信息到监听器，那么我们可以创建一个类继承Symfony\Component\EventDispatcher\Event。

 

        例如，我们需要在所有的监听器中传入order对象：

 1 namespace Acme\StoreBundle\Event;

 2 

 3 use Symfony\Component\EventDispatcher\Event;

 4 use Acme\StoreBundle\Order;

 5 

 6 class FilterOrderEvent extends Event

 7 {

 8     protected $order;

 9 

10     public function __construct(Order $order)

11     {

12         $this->order = $order;

13     }

14 

15     public function getOrder()

16     {

17         return $this->order;

18     }

19 }

        所有监听器都可以通过FilterOrderEvent的getOrder方法获得order对象。

 

调度事件

 

        dispatcher的dispatch()方法通知监听给定的事件的所有监听器，有两个参数，一个是需要调度的事件名，另一个就是传给所有监听器的Event对象。

 1 use Acme\StoreBundle\StoreEvents;

 2 use Acme\StoreBundle\Order;

 3 use Acme\StoreBundle\Event\FilterOrderEvent;

 4 

 5 // the order is somehow created or retrieved

 6 $order = new Order();

 7 // ...

 8 

 9 // create the FilterOrderEvent and dispatch it

10 $event = new FilterOrderEvent($order);

11 $dispatcher->dispatch(StoreEvents::STORE_ORDER, $event);

　　　　FilterOrderEvent对象作为参数传入到dispatch方法，现在，任何监听store.order事件的监听器都会接收到FilterOrderEvent对象，并通过调用getOrder方法获得order对象。

1 // some listener class that's been registered for "store.order" event

2 use Acme\StoreBundle\Event\FilterOrderEvent;

3 

4 public function onStoreOrder(FilterOrderEvent $event)

5 {

6     $order = $event->getOrder();

7     // do something to or with the order

8 }

Event Subscribers  

 

        最普遍的监听事件的方法是注册一个监听器到dispatcher中，一个监听器可以监听一个或者多个事件。

 

        还有另一种监听事件的方法是使用Event SubScriber，Event SubScriber是一个PHP类，能够准确的告诉dispatcher它订阅了那些事件。实现EventSubscriberInterface接口，该接口有一个静态的方法getSubscriberdEvents。

namespace Acme\StoreBundle\Event;



use Symfony\Component\EventDispatcher\EventSubscriberInterface;

use Symfony\Component\HttpKernel\Event\FilterResponseEvent;



class StoreSubscriber implements EventSubscriberInterface

{

    public static function getSubscribedEvents()

    {

        return array(

            'kernel.response' => array(

                array('onKernelResponsePre', 10),

                array('onKernelResponseMid', 5),

                array('onKernelResponsePost', 0),

            ),

            'store.order'     => array('onStoreOrder', 0),

        );

    }



    public function onKernelResponsePre(FilterResponseEvent $event)

    {

        // ...

    }



    public function onKernelResponseMid(FilterResponseEvent $event)

    {

        // ...

    }



    public function onKernelResponsePost(FilterResponseEvent $event)

    {

        // ...

    }



    public function onStoreOrder(FilterOrderEvent $event)

    {

        // ...

    }

}

这个监听器类很简单，告诉了dispatcher监听了什么事件，还有监听的事件触发的方法。addSubscriber()方法把subscriber注册到dispatcher。

1 use Acme\StoreBundle\Event\StoreSubscriber;

2 

3 $subscriber = new StoreSubscriber();

4 $dispatcher->addSubscriber($subscriber);

        dispatcher准确的把Subscriber注册到EventSubscriberInterface::getSubscriberdEvents()返回的事件里，EventSubscriberInterface::getSubscriberdEvents()方法返回一个数组，数组的键对应Subscriber监听的事件，值对应这Subscriber处理该事件调用的一个方法或者一组方法。上面的例子中，一组监听器的方法对应这一个事件，同时我们也可以设置优先级来控制这组方法的执行先后顺序。当kernel.response事件被触 发 ， onKernelResponsePre ,  onKernelResponseMid , 和  onKernelResponsePost三个方法就会先后执行。

 

 

停止事件的传递

 

        在一些情况下，监听器可以停止事件传递下去，防止后续的监听器被调用，换句话说，监听器必须通知dispatcher停止传递事件给后续的监听器。在监听器里面实现stopPropagation()方法：

1 use Acme\StoreBundle\Event\FilterOrderEvent;

2 

3 public function onStoreOrder(FilterOrderEvent $event)

4 {

5     // ...

6 

7     $event->stopPropagation();

8 }

        那么，监听了store.order事件的还没有执行的监听器就不会在被执行。

        通过isPropagationStopped()方法可以判断一个事件是否被停止。

1 $dispatcher->dispatch('foo.event', $event);

2 if ($event->isPropagationStopped()) {

3     // ...

4 }