Tutoriel de démarrage de Zend Framework 2.0 Event Manager (The EventManager)

Présentation

EventManger est un composant conçu pour les cas d'utilisation suivants :

Implémentation d'un modèle simple sujet/observateur
Implémentation d'une conception orientée aspect
Implémentation d'une architecture événementielle

L'architecture de base vous permet d'ajouter et de supprimer des écouteurs pour des événements spécifiques, soit sur une base d'instance, soit dans une collection partagée ; et de mettre fin à l'exécution des écouteurs ;

Démarrage rapide

En général, vous créerez un EventManager au sein d'une classe.

use Zend\EventManager\EventManagerInterface;
use Zend\EventManager\EventManager;
use Zend\EventManager\EventManagerAwareInterface;
 
class Foo implements EventManagerAwareInterface
{
    protected $events;
 
    public function setEventManager(EventManagerInterface $events)
    {
        $events->setIdentifiers(array(
            __CLASS__,
            get_called_class(),
        ));
        $this->events = $events;
        return $this;
    }
 
    public function getEventManager()
    {
        if (null === $this->events) {
            $this->setEventManager(new EventManager());
        }
        return $this->events;
    }
}

Le code ci-dessus permet à l'utilisateur d'accéder à l'instance EventManager, ou de la réinitialiser avec une nouvelle si elle n'existe pas, elle sera instanciée paresseusement lorsqu'elle sera utilisée.

EventManager s'intéresse uniquement à savoir s'il a déclenché certains événements. Le déclencheur de base accepte trois paramètres : le nom de l'événement, qui est généralement le nom de la fonction/méthode actuelle ; le contexte, qui est généralement l'instance d'objet actuelle et les paramètres, qui sont généralement les paramètres fournis à la fonction/méthode actuelle ; .

class Foo
{
    // ... assume events definition from above
 
    public function bar($baz, $bat = null)
    {
        $params = compact('baz', 'bat');
        $this->getEventManager()->trigger(__FUNCTION__, $this, $params);
    }
}

Dans l'ordre, le déclenchement d'un événement ne se soucie que de savoir si quelque chose écoute l'événement. Un écouteur est ajouté à EventManager, spécifiant un événement spécifique et le rappel à notifier. Le rappel accepte un objet Event, qui possède des accesseurs pour obtenir le nom de l'événement, le contexte et les paramètres. Ajoutons un auditeur et déclenchons l'événement.

use Zend\Log\Factory as LogFactory;
 
$log = LogFactory($someConfig);
$foo = new Foo();
$foo->getEventManager()->attach('bar', function ($e) use ($log) {
    $event  = $e->getName();
    $target = get_class($e->getTarget());
    $params = json_encode($e->getParams());
 
    $log->info(sprintf(
        '%s called on %s, using params %s',
        $event,
        $target,
        $params
    ));
});
 
// Results in log message:
$foo->bar('baz', 'bat');
// reading: bar called on Foo, using params {"baz" : "baz", "bat" : "bat"}"

Notez que le deuxième argument de attach() est n'importe quel rappel valide ; l'exemple montre une fonction anonyme pour garder l'exemple autonome. Cependant, vous pouvez également utiliser un nom de fonction valide, un objet fonction, une chaîne faisant référence à une méthode statique ou un tableau de rappel avec une méthode statique ou une méthode d'instance spécifique. Encore une fois, tout rappel PHP est valide.

Parfois, vous souhaiterez peut-être spécifier un écouteur sans créer d'instance d'objet de la classe EventManager. Zend Framework l'implémente à travers le concept de SharedEventCollection. En termes simples, vous pouvez utiliser un SharedEventCollection bien connu pour injecter une instance EventManager autonome, et l'instance EventManager sera interrogée pour des écouteurs supplémentaires. Les écouteurs ajoutés à SharedEventCollection sont à peu près les mêmes que les gestionnaires d'événements normaux ; l'appel de attach est exactement le même que EventManager, mais nécessite un paramètre supplémentaire au début : une instance spécifiée. Rappelez-vous lors de la création d'une instance d'EventManager, comment l'avons-nous transmis __CLASS__ ? Lorsque vous utilisez SharedEventCollection, cette valeur, ou toute chaîne du tableau que vous fournissez au constructeur, peut être utilisée pour identifier une instance. À titre d'exemple, en supposant que nous ayons une instance SharedEventManager dont nous savons qu'elle a été injectée dans notre instance EventManager (par exemple, via l'injection de dépendances), nous pouvons modifier l'exemple ci-dessus pour l'ajouter via une collection partagée :

use Zend\Log\Factory as LogFactory;
 
// Assume $events is a Zend\EventManager\SharedEventManager instance
 
$log = LogFactory($someConfig);
$events->attach('Foo', 'bar', function ($e) use ($log) {
    $event  = $e->getName();
    $target = get_class($e->getTarget());
    $params = json_encode($e->getParams());
 
    $log->info(sprintf(
        '%s called on %s, using params %s',
        $event,
        $target,
        $params
    ));
});
 
// Later, instantiate Foo:
$foo = new Foo();
$foo->getEventManager()->setSharedEventCollection($events);
 
// And we can still trigger the above event:
$foo->bar('baz', 'bat');
// results in log message:
// bar called on Foo, using params {"baz" : "baz", "bat" : "bat"}"

Remarque : StaticEventManager

Dans la version 2.0.0beta3, vous pouvez utiliser le singleton StaticEventManager comme SharedEventCollection. De cette façon, vous n'avez pas à vous soucier de savoir où et comment accéder à SharedEventCollection ; il est disponible globalement en appelant simplement StaticEventManager::getInstance().

Sachez cependant que le framework déprécie son utilisation, et dans la version 2.0.0beta4, vous le remplacerez en configurant une instance SharedEventManager et en l'injectant dans une instance EventManager distincte.

Écouteurs génériques

Parfois, vous souhaiterez peut-être ajouter le même écouteur pour plusieurs ou tous les événements d'une instance donnée, ou peut-être utiliser une collection d'événements partagée, beaucoup de contexte et de nombreux événements. . Le composant EventManager le permet.

Ajouter plusieurs événements à la fois

$events = new EventManager();
$events->attach(array('these', 'are', 'event', 'names'), $callback);

Ajouter via des caractères génériques

$events = new EventManager();
$events->attach('*', $callback);

Notez que si vous spécifiez une priorité, cette priorité sera utilisée pour cette détection. Tout événement déclenché par l'auditeur.

Le code ci-dessus précise que chaque fois qu'un déclencheur est déclenché, une notification sera envoyée à cet auditeur spécifique.

Ajoutez plusieurs événements à la fois via un SharedEventManager

$events = new SharedEventManager();
// Attach to many events on the context "foo"
$events->attach('foo', array('these', 'are', 'event', 'names'), $callback);
 
// Attach to many events on the contexts "foo" and "bar"
$events->attach(array('foo', 'bar'), array('these', 'are', 'event', 'names'), $callback);

Notez que si vous spécifiez une priorité, cette priorité sera utilisée pour tous les événements spécifiés.

Ajoutez tous les événements à la fois via un SharedEventManager

$events = new SharedEventManager();
// Attach to all events on the context "foo"
$events->attach('foo', '*', $callback);
 
// Attach to all events on the contexts "foo" and "bar"
$events->attach(array('foo', 'bar'), '*', $callback);

Notez que si vous spécifiez une priorité, cette priorité sera utilisée pour tous les événements spécifiés.

Le code ci-dessus spécifie le contexte "foo" et "bar", et l'écouteur spécifié sera averti lorsqu'un événement est déclenché.

Options de configuration

Options d'EventManager

Identifiants

L'instance EventManager donnée peut répondre à une chaîne ou à un tableau de chaînes, lorsqu'elle est accessible via une heure SharedEventManager.

event_class

Le nom d'une classe Event alternative utilisée pour représenter les événements transmis aux auditeurs.

shared_collections

Une instance de SharedEventCollection lorsque l'événement est déclenché.

Méthodes disponibles

__construct

__construct(null|string|int Sidentifier)

Construit une nouvelle instance EventManager en utilisant l'identifiant donné, s'il est fourni, pour le but de partager la collection.

setEventClass

setEventClass(string $class)

Fournit un nom de classe d'événement de remplacement à utiliser lors de la création d'événements qui sont transmis aux écouteurs déclenchés.

setSharedCollections

setSharedCollections(SharedEventCollection $collections=null)

Instance SharedEventCollection utilisée lorsque l'événement est déclenché.

getSharedCollections

getSharedCollections()

Renvoie l'instance SharedEventCollection actuellement ajoutée. Si aucune collection n’est ajoutée, renvoie une instance vide ou SharedEventCollection.

trigger

trigger(string $event, Mixed $target, Mixed $argv, callback $callback)

Déclenche tous les écouteurs pour l'événement spécifié. Il est recommandé d'utiliser le nom actuel de la fonction/méthode pour $event, suivi de ".pre", ".post", etc., si nécessaire. $context doit être une instance de l'objet actuel, ou le nom de la fonction si elle n'est pas déclenchée à l'aide d'un objet. $params doit généralement être un tableau associatif ou une instance ArrayAccess ; nous vous recommandons d'utiliser les paramètres passés aux fonctions/méthodes (compact() est souvent utile ici). Cette méthode peut également accepter un rappel et se comporte de la même manière que triggerUntil(). La méthode

renvoie une instance de ResponseCollection, qui peut être utilisée pour introspecter les valeurs renvoyées par divers auditeurs, tester les courts-circuits, etc.

triggerUntil

triggerUntil(string $event, Mixed $context, Mixed $argv, callback $callback)

Déclenche tous les écouteurs pour l'événement spécifié, tout comme trigger( ) , de plus, il transmet la valeur de retour de chaque écouteur à $callback ; si $callback renvoie une valeur booléenne vraie, l'exécution de l'écouteur sera terminée. Vous pouvez utiliser $result->stopped() pour tester cela.

attach

attach(string $event, callback $callback, int $priority)

Ajoutez $callback à l'instance EventManager et écoutez l'événement $event. Si une priorité $ est fournie, l'écouteur sera inséré dans la pile d'écoute interne en utilisant cette priorité, les valeurs plus élevées seront exécutées en premier ; (La priorité par défaut est "1" et s'exécute avec des valeurs négatives.) La méthode

renvoie une instance de ZendStdlibCallbackHandler ; cette valeur peut ensuite être transmise à detach(), si nécessaire.

attachAggregate

attachAggregate(string|ListenerAggregate $aggregate)

Si une chaîne est passée en tant que $aggregate, instanciez cette classe. $aggregate est ensuite transmis à la méthode attach() de l'instance EventManager afin qu'elle puisse enregistrer l'écouteur.

Renvoie l'instance ListenerAggregate.

détacher

detach(CallbackHandler $listener)

Analysez tous les auditeurs et détachez tous les auditeurs correspondant à $listener afin qu'ils ne soient plus déclenchés.

Renvoie un vrai booléen si un écouteur a été attribué et désabonné, sinon renvoie un faux booléen.

detachAggregate

detachAggregate(ListenerAggregate $aggregate)

Parcourez tous les événements pour déterminer l'auditeur représenté par la collection pour toutes les correspondances, l'auditeur sera Remove.

Renvoie un vrai booléen si un auditeur est identifié et désabonné, sinon renvoie un faux booléen.

getEvents

getEvent()

Renvoie un tableau avec les noms de tous les événements attachés par l'écouteur.

getListeners

getListeners(string $event)

Renvoie une instance de ZendStdlibPriorityQueue pour tous les écouteurs ajoutés à $event

clearListeners

clearListeners (string $event)

Supprime tous les écouteurs ajoutés à $event.

prepareArgs

prepareArgs(array $args)

Crée un ArrayObject à partir des $args fournis. Ceci est utile si vous souhaitez que votre écouteur puisse modifier les paramètres afin que les écouteurs ultérieurs ou les méthodes déclenchées puissent voir ces modifications.

Pour plus d'articles liés au didacticiel d'introduction à Zend Framework 2.0 Event Manager (The EventManager), veuillez prêter attention au site Web PHP chinois !