Events Manager

    The purpose of this component is to intercept the execution of most of the other components of the framework by creating ‘hook points’. These hook points allow the developer to obtain status information, manipulate data or change the flow of execution during the process of a component.

    Naming Convention

    Phalcon events use namespaces to avoid naming collisions. Each component in Phalcon occupies a different event namespace and you are free to create your own as you see fit. Event names are formatted as . For example, as occupies the db namespace, its afterQuery event’s full name is db:afterQuery.

    When attaching event listeners to the events manager, you can use component to catch all events from that component (eg. db to catch all of the Phalcon\Db events) or component:event to target a specific event (eg. db:afterQuery).

    Usage Example

    In the following example, we will use the EventsManager to listen for the afterQuery event produced in a MySQL connection managed by Phalcon\Db:

    Now every time a query is executed, the SQL statement will be echoed out. The first parameter passed to the lambda function contains contextual information about the event that is running, the second is the source of the event (in this case the connection itself). A third parameter may also be specified which will contain arbitrary data specific to the event.

    Instead of using lambda functions, you can use event listener classes instead. Event listeners also allow you to listen to multiple events. In this example, we will implement the to detect the SQL statements that are taking longer to execute than expected:

    1. <?php
    3. use Phalcon\Db\Profiler;
    4. use Phalcon\Events\Event;
    5. use Phalcon\Logger;
    6. use Phalcon\Logger\Adapter\File;
    8. class MyDbListener
    9. {
    10.     protected $profiler;
    12.     protected $logger;
    14.     /**
    15.      * Creates the profiler and starts the logging
    16.      */
    17.     public function __construct()
    18.     {
    19.         $this->profiler = new Profiler();
    20.         $this->logger   = new Logger('../apps/logs/db.log');
    21.     }
    23.     /**
    24.      * This is executed if the event triggered is 'beforeQuery'
    25.      */
    26.     public function beforeQuery(Event $event, $connection)
    27.     {
    28.         $this->profiler->startProfile(
    29.             $connection->getSQLStatement()
    30.         );
    31.     }
    33.     /**
    34.      * This is executed if the event triggered is 'afterQuery'
    35.      */
    36.     public function afterQuery(Event $event, $connection)
    37.     {
    38.         $this->logger->log(
    39.             $connection->getSQLStatement(),
    40.             Logger::INFO
    41.         );
    43.         $this->profiler->stopProfile();
    44.     }
    46.     public function getProfiler()
    47.     {
    48.         return $this->profiler;
    49.     }
    50. }
    1. <?php
    3. // Create a database listener
    4. $dbListener = new MyDbListener();
    6. // Listen all the database events
    7. $eventsManager->attach(
    8.     'db',
    9.     $dbListener
    10. );

    The resulting profile data can be obtained from the listener:

    1. <?php
    3. $connection->execute(
    4.     'SELECT * FROM products p WHERE p.status = 1'
    5. );
    7. $profiler = $dbListener->getProfiler();
    9. $profiles = $profiler->getProfiles();
    11. foreach ($profiles as $profile) {
    12.     echo 'SQL Statement: ', $profile->getSQLStatement(), '\n';
    13.     echo 'Start Time: ', $profile->getInitialTime(), '\n';
    14.     echo 'Final Time: ', $profile->getFinalTime(), '\n';
    15.     echo 'Total Elapsed Time: ', $profile->getTotalElapsedSeconds(), '\n';
    16. }

    You can create components in your application that trigger events to an EventsManager. As a consequence, there may exist listeners that react to these events when generated. In the following example we’re creating a component called MyComponent. This component is EventsManager aware (it implements Phalcon\Events\EventsAwareInterface); when its someTask() method is executed it triggers two events to any listener in the EventsManager:

    1. <?php
    3. use Phalcon\Events\EventsAwareInterface;
    4. use Phalcon\Events\ManagerInterface;
    6. class MyComponent implements EventsAwareInterface
    7. {
    8.     protected $eventsManager;
    10.     public function setEventsManager(ManagerInterface $eventsManager)
    11.     {
    12.         $this->eventsManager = $eventsManager;
    13.     }
    15.     public function getEventsManager()
    16.     {
    17.         return $this->eventsManager;
    18.     }
    20.     public function someTask()
    21.     {
    24.         // Do some task
    25.         echo 'Here, someTask\n';
    27.         $this->eventsManager->fire('my-component:afterSomeTask', $this);
    28.     }
    29. }

    Notice that in this example, we’re using the my-component event namespace. Now we need to create an event listener for this component:

    Now let’s make everything work together:

    1. <?php
    3. use Phalcon\Events\Manager as EventsManager;
    5. // Create an Events Manager
    6. $eventsManager = new EventsManager();
    8. // Create the MyComponent instance
    9. $myComponent = new MyComponent();
    11. // Bind the eventsManager to the instance
    12. $myComponent->setEventsManager($eventsManager);
    14. // Attach the listener to the EventsManager
    15. $eventsManager->attach(
    16.     'my-component',
    17.     new SomeListener()
    18. );
    20. // Execute methods in the component
    21. $myComponent->someTask();

    As someTask() is executed, the two methods in the listener will be executed, producing the following output:

    1. Here, beforeSomeTask
    2. Here, someTask
    3. Here, afterSomeTask

    Additional data may also be passed when triggering an event using the third parameter of fire():

    1. <?php
    3. $eventsManager->fire('my-component:afterSomeTask', $this, $extraData);

    In a listener the third parameter also receives this data:

    1. <?php
    4. // Receiving the data in the third parameter
    5. $eventsManager->attach(
    6.     'my-component',
    7.     function (Event $event, $component, $data) {
    8.         print_r($data);
    9.     }
    10. );
    12. // Receiving the data from the event context
    13. $eventsManager->attach(
    14.     'my-component',
    15.     function (Event $event, $component) {
    16.         print_r($event->getData());
    17.     }
    18. );

    Using Services From The DI

    Event Propagation/Cancellation

    Many listeners may be added to the same event manager. This means that for the same type of event, many listeners can be notified. The listeners are notified in the order they were registered in the EventsManager. Some events are cancelable, indicating that these may be stopped preventing other listeners from being notified about the event:

    1. <?php
    3. use Phalcon\Events\Event;
    5. $eventsManager->attach(
    6.     'db',
    7.     function (Event $event, $connection) {
    8.         // We stop the event if it is cancelable
    9.         if ($event->isCancelable()) {
    10.             // Stop the event, so other listeners will not be notified about this
    11.             $event->stop();
    12.         }
    14.         // ...
    15.     }
    16. );

    By default, events are cancelable - even most of the events produced by the framework are cancelables. You can fire a not-cancelable event by passing false in the fourth parameter of fire():

    1. <?php
    3. $eventsManager->fire('my-component:afterSomeTask', $this, $extraData, false);

    When attaching listeners you can set a specific priority. With this feature you can attach listeners indicating the order in which they must be called:

    1. <?php
    3. $eventsManager->enablePriorities(true);
    5. $eventsManager->attach('db', new DbListener(), 150); // More priority
    6. $eventsManager->attach('db', new DbListener(), 100); // Normal priority
    7. $eventsManager->attach('db', new DbListener(), 50);  // Less priority

    Collecting Responses

    The events manager can collect every response returned by every notified listener. This example explains how it works:

    1. <?php
    3. use Phalcon\Events\Manager as EventsManager;
    5. $eventsManager = new EventsManager();
    7. // Set up the events manager to collect responses
    8. $eventsManager->collectResponses(true);
    10. // Attach a listener
    11. $eventsManager->attach(
    12.     'custom:custom',
    13.     function () {
    14.         return 'first response';
    15.     }
    16. );
    18. // Attach a listener
    19. $eventsManager->attach(
    20.     'custom:custom',
    21.     function () {
    22.         return 'second response';
    23.     }
    24. );
    27. $eventsManager->fire('custom:custom', null);
    29. // Get all the collected responses
    30. print_r($eventsManager->getResponses());

    The above example produces:

    Implementing your own EventsManager

    The interface must be implemented to create your own EventsManager replacing the one provided by Phalcon.

    The events available in Phalcon are: