Zend Framework 2.0 Event Manager (Der EventManager) Erste Schritte-Tutorial

Übersicht

EventManger ist eine Komponente, die für die folgenden Anwendungsfälle entwickelt wurde:

Implementierung eines einfachen Subjekt-/Beobachtermusters
Implementierung eines aspektorientierten Designs
Implementierung einer ereignisgesteuerten Architektur

Die Grundarchitektur ermöglicht es Ihnen, Listener für bestimmte Ereignisse hinzuzufügen und zu entfernen, entweder auf Instanzbasis oder in einer gemeinsam genutzten Sammlung, und die Ausführung von Listenern zu beenden.

Schnellstart

Normalerweise erstellen Sie einen EventManager innerhalb einer Klasse.

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;
    }
}

Mit dem obigen Code kann der Benutzer auf die EventManager-Instanz zugreifen oder sie mit einer neuen zurücksetzen, wenn sie nicht vorhanden ist. Sie wird bei Verwendung langsam instanziiert.

EventManager interessiert nur, ob es einige Ereignisse ausgelöst hat. Der Basistrigger akzeptiert drei Parameter: den Namen des Ereignisses, bei dem es sich normalerweise um den aktuellen Funktions-/Methodennamen handelt; den Kontext, bei dem es sich normalerweise um die aktuelle Objektinstanz handelt, und die Parameter, bei denen es sich normalerweise um die für die aktuelle Funktion/Methode bereitgestellten Parameter handelt; .

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

Das Auslösen eines Ereignisses ist nur dann von Bedeutung, wenn etwas auf das Ereignis wartet. Dem EventManager wird ein Listener hinzugefügt, der ein bestimmtes Ereignis und den zu benachrichtigenden Rückruf angibt. Der Rückruf akzeptiert ein Event-Objekt, das über Accessoren zum Abrufen des Ereignisnamens, des Kontexts und der Parameter verfügt. Fügen wir einen Listener hinzu und lösen das Ereignis aus.

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"}"

Beachten Sie, dass das zweite Argument für attachment() ein beliebiger gültiger Rückruf ist. Das Beispiel zeigt eine anonyme Funktion, um das Beispiel in sich geschlossen zu halten. Sie können jedoch auch einen gültigen Funktionsnamen, ein Funktionsobjekt, eine Zeichenfolge, die auf eine statische Methode verweist, oder ein Callback-Array mit einer bestimmten statischen Methode oder Instanzmethode verwenden. Auch hier ist jeder PHP-Rückruf gültig.

Manchmal möchten Sie möglicherweise einen Listener angeben, ohne eine Objektinstanz der EventManager-Klasse zu erstellen. Zend Framework implementiert es durch das Konzept von SharedEventCollection. Einfach ausgedrückt können Sie eine bekannte SharedEventCollection verwenden, um eine eigenständige EventManager-Instanz einzufügen, und die EventManager-Instanz wird nach weiteren Listenern abgefragt. Einer SharedEventCollection hinzugefügte Listener sind in etwa die gleichen wie bei normalen Event-Managern. Der Aufruf von „attach“ ist genau derselbe wie bei „EventManager“, erfordert jedoch einen zusätzlichen Parameter am Anfang: eine angegebene Instanz. Denken Sie daran, wie wir beim Erstellen einer EventManager-Instanz __CLASS__ übergeben haben? Bei Verwendung einer SharedEventCollection kann dieser Wert oder eine beliebige Zeichenfolge im Array, das Sie dem Konstruktor bereitstellen, zur Identifizierung einer Instanz verwendet werden. Angenommen, wir haben eine SharedEventManager-Instanz, von der wir wissen, dass sie in unsere EventManager-Instanz eingefügt wurde (z. B. durch Abhängigkeitsinjektion), können wir das obige Beispiel ändern, um sie über eine gemeinsam genutzte Sammlung hinzuzufügen:

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"}"

Hinweis: StaticEventManager

In 2.0.0beta3 können Sie den StaticEventManager-Singleton als SharedEventCollection verwenden. Auf diese Weise müssen Sie sich keine Gedanken darüber machen, wo oder wie Sie auf die SharedEventCollection zugreifen können; sie ist global verfügbar, indem Sie einfach StaticEventManager::getInstance() aufrufen.

Beachten Sie jedoch, dass das Framework seine Verwendung ablehnt und Sie es in 2.0.0beta4 ersetzen werden, indem Sie eine SharedEventManager-Instanz konfigurieren und sie in eine separate EventManager-Instanz einfügen.

Platzhalter-Listener

Manchmal möchten Sie möglicherweise denselben Listener für viele oder alle Ereignisse einer bestimmten Instanz hinzufügen oder vielleicht eine gemeinsame Ereignissammlung, viel Kontext und viele Ereignisse verwenden . Die EventManager-Komponente ermöglicht dies.

Mehrere Ereignisse gleichzeitig hinzufügen

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

Über Platzhalter hinzufügen

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

Beachten Sie, dass, wenn Sie eine Priorität angeben, diese Priorität für diese Erkennung verwendet wird. Jedes Ereignis ausgelöst durch den Zuhörer.

Der obige Code gibt an, dass jedes Mal, wenn ein Trigger ausgelöst wird, eine Benachrichtigung für diesen bestimmten Listener erfolgt.

Mehrere Ereignisse gleichzeitig über einen SharedEventManager hinzufügen

$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);

Beachten Sie, dass bei Angabe einer Priorität diese Priorität für alle angegebenen Ereignisse verwendet wird.

Alle Ereignisse auf einmal über einen SharedEventManager hinzufügen

$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);

Beachten Sie, dass, wenn Sie eine Priorität angeben, diese Priorität für alle angegebenen Ereignisse verwendet wird.

Der obige Code gibt die Kontexte „foo“ und „bar“ an und der angegebene Listener wird benachrichtigt, wenn ein Ereignis ausgelöst wird.

Konfigurationsoptionen

EventManager-Optionen

Identifikatoren

Die angegebene EventManager-Instanz kann auf eine Zeichenfolge oder ein Array von Zeichenfolgen antworten, wenn über eine SharedEventManager-Stunde darauf zugegriffen wird.

event_class

Der Name einer alternativen Ereignisklasse, die zur Darstellung von Ereignissen verwendet wird, die an Listener übergeben werden.

shared_collections

Eine SharedEventCollection-Instanz, wenn das Ereignis ausgelöst wird.

Verfügbare Methoden

__construct

__construct(null|string|int Sidentifier)

Erstellt eine neue EventManager-Instanz unter Verwendung des angegebenen Bezeichners, falls angegeben, für der Zweck der Weitergabe der Sammlung.

setEventClass

setEventClass(string $class)

Stellt einen Ersatz-Ereignisklassennamen bereit, der beim Erstellen von Ereignissen verwendet wird, die an ausgelöste Listener übergeben werden.

setSharedCollections

setSharedCollections(SharedEventCollection $collections=null)

Eine SharedEventCollection-Instanz, die verwendet wird, wenn ein Ereignis ausgelöst wird.

getSharedCollections

getSharedCollections()

Gibt die aktuell hinzugefügte SharedEventCollection-Instanz zurück. Wenn keine Sammlung hinzugefügt wird, wird leer oder eine SharedEventCollection-Instanz zurückgegeben.

trigger

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

Triggert alle Listener für das angegebene Ereignis aus. Es wird empfohlen, für $event den aktuellen Funktions-/Methodennamen zu verwenden, gefolgt von „.pre“, „.post“ usw., falls erforderlich. $context sollte eine Instanz des aktuellen Objekts oder der Name der Funktion sein, wenn sie nicht über ein Objekt ausgelöst wird. $params sollte normalerweise ein assoziatives Array oder eine ArrayAccess-Instanz sein; wir empfehlen die Verwendung von Parametern, die an Funktionen/Methoden übergeben werden (compact() ist hier oft nützlich). Diese Methode kann auch einen Rückruf akzeptieren und verhält sich genauso wie triggerUntil(). Die

-Methode gibt eine Instanz von ResponseCollection zurück, die zur Selbstprüfung der von verschiedenen Listenern zurückgegebenen Werte, zum Testen auf Kurzschlüsse und mehr verwendet werden kann.

triggerUntil

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

Alle Listener für das angegebene Ereignis auslösen, genau wie Trigger( ) , zusätzlich wird der Rückgabewert jedes Listeners an $callback übergeben; wenn $callback einen booleschen wahren Wert zurückgibt, wird die Ausführung des Listeners beendet. Sie können dies mit $result->stopped() testen.

attach

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

$callback zur EventManager-Instanz hinzufügen und auf das Ereignis $event warten. Wenn eine $priorität angegeben wird, wird der Listener mit dieser Priorität in den internen Listener-Stack eingefügt; höhere Werte werden zuerst ausgeführt. (Die Standardpriorität ist „1“ und wird mit negativen Werten ausgeführt.) Die Methode

gibt eine Instanz von ZendStdlibCallbackHandler zurück; dieser Wert kann später bei Bedarf an detach() übergeben werden.

attachAggregate

attachAggregate(string|ListenerAggregate $aggregate)

Wenn eine Zeichenfolge als $aggregate übergeben wird, instanziieren Sie diese Klasse. $aggregate wird dann an die Methode attachment() der EventManager-Instanz übergeben, damit diese den Listener registrieren kann.

Gibt die ListenerAggregate-Instanz zurück.

detach

detach(CallbackHandler $listener)

Scannen Sie alle Listener und trennen Sie alle Listener, die mit $listener übereinstimmen, damit sie nicht mehr ausgelöst werden.

Gibt einen wahren booleschen Wert zurück, wenn ein Listener zugewiesen und abgemeldet wurde, andernfalls wird ein falscher boolescher Wert zurückgegeben.

detachAggregate

detachAggregate(ListenerAggregate $aggregate)

Durchlaufen Sie alle Ereignisse, um den von der Sammlung dargestellten Listener zu ermitteln. Bei allen Übereinstimmungen wird der Listener entfernt.

Gibt einen wahren booleschen Wert zurück, wenn ein Zuhörer identifiziert und abgemeldet wird, andernfalls wird ein falscher boolescher Wert zurückgegeben.

getEvents

getEvent()

Gibt ein Array mit den Namen aller vom Listener angehängten Ereignisse zurück.

getListeners

getListeners(string $event)

Gibt eine ZendStdlibPriorityQueue-Instanz für alle zu $event hinzugefügten Listener zurück

clearListeners

clearListeners (string $event)

Entfernt alle zu $event hinzugefügten Listener.

prepareArgs

prepareArgs(array $args)

Erstellt ein ArrayObject aus den bereitgestellten $args. Dies ist nützlich, wenn Sie möchten, dass Ihr Listener Parameter ändern kann, damit spätere Listener oder ausgelöste Methoden diese Änderungen sehen können.

Weitere Artikel zum Einführungs-Tutorial zum Zend Framework 2.0 Event Manager (The EventManager) finden Sie auf der chinesischen PHP-Website!