TYPO3 Events verständlich erklärt

TYPO3 Events sind spezielle Ereignisse innerhalb des Content-Management-Systems (CMS), die es ermöglichen, eine Vielzahl von Aktionen zu steuern. Events in TYPO3 werden durch Event-Klassen ausgelöst und gestatten es, Code zu ergänzen, seinen Verlauf abzuändern oder ihn lediglich zu beobachten.

Was sind TYPO3 Events?

Bei TYPO3 Events handelt es sich um spezielle Ereignisse, die ausgelöst werden, um bestimmte Aktionen in Gang zu setzen oder Abläufe festzulegen. Grundsätzlich kann jedes beliebige PHP-Objekt, das die erforderlichen Kriterien erfüllt, als Event fungieren. Zudem besteht sowohl die Möglichkeit, auf bestehende Events zu reagieren als auch eigene zu kreieren. Diese Ereignisse stellen Signalpunkte dar, auf die TYPO3 reagiert – beispielsweise, indem Inhalte nach ihrer Ausführung gespeichert oder eingegebene Daten verarbeitet werden.

TYPO3 Events erlauben es Entwicklerinnen und Entwicklern, benutzerdefinierte Funktionen und Erweiterungen zu integrieren, ohne den Kern des Systems ändern zu müssen. Dies macht es möglich, flexibel in bestehende Abläufe einzugreifen.

TYPO3 Events als Teil von PSR-14

Seitdem im Zuge des Releases von TYPO3 10 das Event-Dispatcher-System hinzugefügt wurde, arbeitet das CMS mit PSR-14. Dabei handelt es sich um eine schlanke Lösung, die auf weit verbreiteten Ansätzen für die Einbindung in bestehenden PHP-Code basiert und typischerweise aus vier Komponenten besteht:

• Der Event-Dispatcher ist die elementare Komponente, um Ereignisse auslösen zu können.
• Der Listener Provider ist ein Objekt, das sämtliche Listener beinhaltet, die für die unterschiedlichen Ereignisse registriert wurden. TYPO3 verfügt über einen eigenen Listener Provider, der sämtliche Listener während des Kompilierens erfasst.
• Erweiterungen und PHP-Paketen ist es möglich, Listener hinzuzufügen. Diese werden mittels YAML registriert und über die Klassennamen der jeweiligen Events mit Ereignisobjekten verknüpft.
• TYPO3 Events sind beliebige PHP-Objekte, die vom TYPO3 Core oder von einer Extension aufgerufen werden und die für die Listener relevanten Informationen bereithalten. Liegt ein Ereignis vor, werden alle registrierten Listener ausgelöst. Es lässt sich allerdings auch festlegen, dass ein Listener die Ausführung weiterer stoppt.

Wie werden Events in TYPO3 ausgelöst?

Das Auslösen von Events in TYPO3 erfolgt über das zuvor erwähnte Event-Dispatcher-System. Der Event-Dispatcher sorgt dafür, dass der TYPO3 Core oder eine eingesetzte Extension bestimmte Ereignisse registriert und auf diese reagiert. Wenn Sie kein bereits existierendes Event verwenden wollen, müssen Sie dafür ein spezifisches Ereignis definieren, was sich in drei Schritten realisieren lässt.

Schritt 1: Ereignisklasse erstellen

Zunächst ist es erforderlich, eine Ereignisklasse (Event Class) mit Abfragemethoden (Getter) für unveränderliche Eigenschaften und Änderungsmethoden (Setter) für veränderbare Eigenschaften zu definieren. Die PHP Class beinhaltet unter anderem auch einen Konstruktor für alle Eigenschaften:

<?php
declare(strict_types=1);
namespace MyVendor\MyExtension\Event;
final class DoingThisAndThatEvent
{
    private string $mutableProperty;
    public readonly int $immutableProperty;
    public function __construct(string $mutableProperty, int $immutableProperty)
    {
        $this->mutableProperty = $mutableProperty;
        $this->immutableProperty = $immutableProperty;
    }
    public function getMutableProperty(): string
    {
        return $this->mutableProperty;
    }
    public function setMutableProperty(string $mutableProperty): void
    {
        $this->mutableProperty = $mutableProperty;
    }
    public function getImmutableProperty(): int
    {
        return $this->immutableProperty;
    }
}

Schritt 2: Event-Dispatcher vorbereiten

Ist der Event-Dispatcher noch nicht verfügbar, besteht die Notwendigkeit, ihn zu injizieren. Dies funktioniert folgendermaßen:

<?php
declare(strict_types=1);
namespace MyVendor\MyExtension;
use Psr\EventDispatcher\EventDispatcherInterface;
final class SomeClass
{
    private readonly EventDispatcherInterface $eventDispatcher;
    public function __construct(EventDispatcherInterface $eventDispatcher)
    {
        $this->eventDispatcher = $eventDispatcher;
    }
}

Schritt 3: Ereignis entsenden

Legen Sie das Ereignisobjekt mit den an die Listeners weiterzugebenden Daten gemäß Ihrer Geschäftslogik an:

<?php
declare(strict_types=1);
namespace MyVendor\MyExtension;
use MyVendor\MyExtension\Event\DoingThisAndThatEvent;
use Psr\EventDispatcher\EventDispatcherInterface;
final class SomeClass
{
    private readonly EventDispatcherInterface $eventDispatcher;
    public function __construct(EventDispatcherInterface $eventDispatcher)
    {
        $this->eventDispatcher = $eventDispatcher;
    }
    public function doSomething(): void
    {
        $event = new DoingThisAndThatEvent('foo', 2);
        $event = $this->eventDispatcher->dispatch($event);
        $someChangedValue = $event->getMutableProperty();
    }
}

Beispiele für TYPO3 Events

Es gibt in TYPO3 eine Vielzahl von Events, die an verschiedenen Stellen des Systems ausgelöst werden und es Entwicklungsteams gestatten, auf wichtige Ereignisse zu reagieren. Im Folgenden finden Sie eine Liste mit einigen TYPO3 Events, die in Projekten häufig genutzt werden:

• BeforeActionCallEvent (Extbase/MVC): Dieses TYPO3 Event wird ausgelöst, bevor eine Controller-Aktion in Extbase aufgerufen wird, um notwendige Vorbereitungen oder Anpassungen vorzunehmen.
• AfterRequestDispatchedEvent (Extbase/MVC): Auslösung nach der vollständigen Verarbeitung einer Anfrage; wird eingesetzt, um abschließende Operationen wie Logging oder Anpassungen an den erhaltenen Daten vorzunehmen
• EntityPersistedEvent (Extbase/Persistence): Die Auslösung dieses Events findet statt, nachdem eine Entität im Datenbankkontext gespeichert wurde. Auf diese Weise kann TYPO3 auf Änderungen reagieren, z. B. bei der Synchronisation mit anderen Systemen.
• LoginConfirmedEvent (Frontend-Login): Dieses TYPO3 Event wird durch eine erfolgreiche Benutzeranmeldung im Frontend getriggert. Es ermöglicht zusätzliche Aktionen wie Protokollierungen oder die Initialisierung benutzerdefinierter Sitzungsvariablen.
• LogoutConfirmedEvent (Frontend-Login): Wird nach dem erfolgreichen Logout im Frontend ausgelöst, um z. B. Sitzungsdaten zu bereinigen oder Sicherheitsaktionen durchzuführen.
• SendRecoveryEmailEvent (Frontend-Login): Mit dem Event SendRecoveryEmailEvent lassen sich Anpassungen am E-Mail-Inhalt oder spezielle Benachrichtigungen vornehmen. Es wird ausgelöst, sobald eine E-Mail zur Passwortwiederherstellung angefordert wird.
• AfterMailerInitializationEvent (Mail): Wird ausgelöst, nachdem der TYPO3 Mailer initialisiert wurde, um Anpassungen an den E-Mail-Parametern oder an der Konfiguration vorzunehmen.
• ModifyHrefLangTagsEvent (Frontend): Dient der einfachen Anpassung der hreflang-Tags, die sicherstellen, dass mehrsprachige Seiten korrekt von Suchmaschinen erkannt werden.
• ModifyUrlForCanonicalTagEvent (SEO): Dieses TYPO3 Event dient dem Zweck, die URL für den Canonical-Tag zu modifizieren, um doppelte Inhalte zu vermeiden.
• ModifyFileDumpEvent (Core): Dieses Event erlaubt die Anpassung des Dateidownload-Prozesses im TYPO3 Core. Auf diese Weise lassen sich zum Beispiel zusätzliche Authentifizierungsmechanismen einführen oder die Ausgabe anpassen.