Les écouteurs d'événements de Symfony

Un événement listener dans Symfony est une fonctionnalité qui permet à une application d'écouter les événements déclenchés par le framework et de réagir en conséquence. Cela signifie que lorsqu'un événement spécifique se produit dans l'application (par exemple, lorsqu'un utilisateur soumet un formulaire), le listener associé peut être appelé pour effectuer une action (comme enregistrer les données du formulaire dans la base de données).

Les événements listeners sont une partie importante de la programmation orientée événement dans Symfony, et ils peuvent être utilisés pour améliorer l'organisation et la lisibilité du code de l'application. Ils permettent également de séparer les différentes parties d'une application en modules indépendants, ce qui peut faciliter le développement et la maintenance du code.

Pour utiliser des événements listeners dans une application Symfony, il faut d'abord définir le listener en implémentant l'interface EventSubscriberInterface. Cette interface exige que la classe contienne une méthode getSubscribedEvents() qui retourne un tableau associatif d'événements et de méthodes à appeler lorsque ces événements se produisent.

Voici un exemple de code Symfony qui montre comment utiliser la méthode getSubscribedEvents() pour enregistrer un écouteur d'évènements :

use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\KernelEvents;

class UserEventSubscriber implements EventSubscriberInterface
{
    public static function getSubscribedEvents()
    {
        return [
            KernelEvents::REQUEST => 'onUserRegistration',
        ];
    }

    public function onUserRegistration()
    {
        // Code qui sera exécuté lorsque l'évènement KernelEvents::REQUEST est déclenché
    }
}

Dans cet exemple, l'écouteur d'évènements UserEventSubscriber est enregistré pour écouter l'évènement KernelEvents::REQUEST et exécutera la méthode onUserRegistration() lorsque cet évènement sera déclenché.

Pour activer un écouteur d'évènements sur Symfony, vous devez d'abord enregistrer la classe de l'écouteur d'évènements en tant que service dans le fichier de configuration de votre application (généralement appelé services.yaml).

Voici un exemple de configuration pour enregistrer un écouteur d'évènements nommé UserEventSubscriber:

services:
    app.user_event_subscriber:
        class: App\EventSubscriber\UserEventSubscriber
        tags:
            - { name: kernel.event_subscriber }

Ensuite, vous devez définir les évènements auxquels l'écouteur d'évènements doit être enregistré en utilisant la méthode getSubscribedEvents() dans la classe de l'écouteur d'évènements. Vous pouvez consulter l'exemple de code ci-dessus pour voir comment faire cela.

Une fois que l'écouteur d'évènements est enregistré et configuré pour écouter les évènements, il sera automatiquement activé et exécutera le code défini dans la méthode onUserRegistration() lorsque l'évènement KernelEvents::REQUEST sera déclenché.

Les priorités

Les priorités des écouteurs d'événements dans Symfony sont des entiers qui indiquent l'ordre dans lequel les écouteurs d'événements sont appelés lorsqu'un événement donné est déclenché. Plus le nombre de priorités est élevé, plus tôt l'écouteur sera appelé par rapport aux autres écouteurs ayant une priorité plus basse. Cela permet aux développeurs de contrôler l'ordre dans lequel les différents écouteurs sont appelés pour un événement donné, ce qui peut être utile pour s'assurer que les différentes parties d'une application sont mises à jour de manière cohérente lorsqu'un événement se produit.

Voici un exemple de définition d'un écouteur d'événements avec une priorité spécifiée dans Symfony :

use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\KernelEvents;

class MyEventListener implements EventSubscriberInterface
{
    public static function getSubscribedEvents()
    {
        return [
            KernelEvents::REQUEST => ['onKernelRequest', 10],
        ];
    }

    public function onKernelRequest()
    {
        // Le code à exécuter lorsque l'événement KernelEvents::REQUEST est déclenché
    }
}

Dans cet exemple, l'écouteur d'événements MyEventListener est enregistré pour écouter l'événement KernelEvents::REQUEST, et il sera appelé avec une priorité de 10, ce qui signifie qu'il sera appelé avant les écouteurs d'événements ayant une priorité inférieure à 10, mais après ceux ayant une priorité supérieure à 10.

Attribut AsEventListener

L'attribut AsEventListener est une nouveauté de PHP 8 qui permet de définir une fonction comme étant un "écouteur d'événements". Cela signifie que la fonction sera appelée chaque fois qu'un événement spécifique se produit dans le code.

Voici un exemple de fonction qui utilise l'attribut AsEventListener :

namespace App\Listeners;

use App\Events\UserRegistered;

#[AsEventListener]
final class MyListener
{
    public function __invoke(UserRegistered $event)
    {
        // Code à exécuter lorsque l'événement UserRegistered se produit
    }
}

Dans cet exemple, la class MyListener() est définie en utilisant l'attribut AsEventListener. Cela signifie que chaque fois qu'un événement UserRegistered() se produit, la classe sera automatiquement appelée et recevra l'objet Event en tant que premier argument.

Il est important de noter que l'attribut AsEventListener ne peut être utilisé que sur des fonctions, et non sur des méthodes de classe, d'où l'utilisation de la méthode __invoke. De plus, la fonction doit prendre au moins un argument, qui sera l'objet Event qui a déclenché l'écouteur d'événements.