TYPO3 Events ver­ständ­lich erklärt

TYPO3 Events sind spezielle Er­eig­nis­se innerhalb des Content-Ma­nage­ment-Systems (CMS), die es er­mög­li­chen, eine Vielzahl von Aktionen zu steuern. Events in TYPO3 werden durch Event-Klassen ausgelöst und gestatten es, Code zu ergänzen, seinen Verlauf ab­zu­än­dern oder ihn lediglich zu be­ob­ach­ten.

Was sind TYPO3 Events?

Bei TYPO3 Events handelt es sich um spezielle Er­eig­nis­se, die ausgelöst werden, um bestimmte Aktionen in Gang zu setzen oder Abläufe fest­zu­le­gen. Grund­sätz­lich kann jedes beliebige PHP-Objekt, das die er­for­der­li­chen Kriterien erfüllt, als Event fungieren. Zudem besteht sowohl die Mög­lich­keit, auf be­stehen­de Events zu reagieren als auch eigene zu kreieren. Diese Er­eig­nis­se stellen Si­gnal­punk­te dar, auf die TYPO3 reagiert – bei­spiels­wei­se, indem Inhalte nach ihrer Aus­füh­rung ge­spei­chert oder ein­ge­ge­be­ne Daten ver­ar­bei­tet werden.

TYPO3 Events erlauben es Ent­wick­le­rin­nen und Ent­wick­lern, be­nut­zer­de­fi­nier­te Funk­tio­nen und Er­wei­te­run­gen zu in­te­grie­ren, ohne den Kern des Systems ändern zu müssen. Dies macht es möglich, flexibel in be­stehen­de Abläufe ein­zu­grei­fen.

TYPO3 Events als Teil von PSR-14

Seitdem im Zuge des Releases von TYPO3 10 das Event-Dis­patcher-System hin­zu­ge­fügt wurde, arbeitet das CMS mit PSR-14. Dabei handelt es sich um eine schlanke Lösung, die auf weit ver­brei­te­ten Ansätzen für die Ein­bin­dung in be­stehen­den PHP-Code basiert und ty­pi­scher­wei­se aus vier Kom­po­nen­ten besteht:

• Der Event-Dis­patcher ist die ele­men­ta­re Kom­po­nen­te, um Er­eig­nis­se auslösen zu können.
• Der Listener Provider ist ein Objekt, das sämtliche Listener be­inhal­tet, die für die un­ter­schied­li­chen Er­eig­nis­se re­gis­triert wurden. TYPO3 verfügt über einen eigenen Listener Provider, der sämtliche Listener während des Kom­pi­lie­rens erfasst.
• Er­wei­te­run­gen und PHP-Paketen ist es möglich, Listener hin­zu­zu­fü­gen. Diese werden mittels YAML re­gis­triert und über die Klas­sen­na­men der je­wei­li­gen Events mit Er­eig­nis­ob­jek­ten verknüpft.
• TYPO3 Events sind beliebige PHP-Objekte, die vom TYPO3 Core oder von einer Extension auf­ge­ru­fen werden und die für die Listener re­le­van­ten In­for­ma­tio­nen be­reit­hal­ten. Liegt ein Ereignis vor, werden alle re­gis­trier­ten Listener ausgelöst. Es lässt sich al­ler­dings auch festlegen, dass ein Listener die Aus­füh­rung weiterer stoppt.

Wie werden Events in TYPO3 ausgelöst?

Das Auslösen von Events in TYPO3 erfolgt über das zuvor erwähnte Event-Dis­patcher-System. Der Event-Dis­patcher sorgt dafür, dass der TYPO3 Core oder eine ein­ge­setz­te Extension bestimmte Er­eig­nis­se re­gis­triert und auf diese reagiert. Wenn Sie kein bereits exis­tie­ren­des Event verwenden wollen, müssen Sie dafür ein spe­zi­fi­sches Ereignis de­fi­nie­ren, was sich in drei Schritten rea­li­sie­ren lässt.

Schritt 1: Er­eig­nis­klas­se erstellen

Zunächst ist es er­for­der­lich, eine Er­eig­nis­klas­se (Event Class) mit Ab­fra­ge­me­tho­den (Getter) für un­ver­än­der­li­che Ei­gen­schaf­ten und Än­de­rungs­me­tho­den (Setter) für ver­än­der­ba­re Ei­gen­schaf­ten zu de­fi­nie­ren. Die PHP Class be­inhal­tet unter anderem auch einen Kon­struk­tor für alle Ei­gen­schaf­ten:

<?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-Dis­patcher vor­be­rei­ten

Ist der Event-Dis­patcher noch nicht verfügbar, besteht die Not­wen­dig­keit, ihn zu in­ji­zie­ren. Dies funk­tio­niert fol­gen­der­ma­ß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 Er­eig­nis­ob­jekt mit den an die Listeners wei­ter­zu­ge­ben­den Daten gemäß Ihrer Ge­schäfts­lo­gik 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 ver­schie­de­nen Stellen des Systems ausgelöst werden und es Ent­wick­lungs­teams gestatten, auf wichtige Er­eig­nis­se 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 Con­trol­ler-Aktion in Extbase auf­ge­ru­fen wird, um not­wen­di­ge Vor­be­rei­tun­gen oder An­pas­sun­gen vor­zu­neh­men.
• AfterRequestDispatchedEvent (Extbase/MVC): Auslösung nach der voll­stän­di­gen Ver­ar­bei­tung einer Anfrage; wird ein­ge­setzt, um ab­schlie­ßen­de Ope­ra­tio­nen wie Logging oder An­pas­sun­gen an den er­hal­te­nen Daten vor­zu­neh­men
• EntityPersistedEvent (Extbase/Per­sis­tence): Die Auslösung dieses Events findet statt, nachdem eine Entität im Da­ten­bank­kon­text ge­spei­chert wurde. Auf diese Weise kann TYPO3 auf Än­de­run­gen reagieren, z. B. bei der Syn­chro­ni­sa­ti­on mit anderen Systemen.
• LoginConfirmedEvent (Frontend-Login): Dieses TYPO3 Event wird durch eine er­folg­rei­che Be­nut­zer­an­mel­dung im Frontend ge­trig­gert. Es er­mög­licht zu­sätz­li­che Aktionen wie Pro­to­kol­lie­run­gen oder die In­itia­li­sie­rung be­nut­zer­de­fi­nier­ter Sit­zungs­va­ria­blen.
• LogoutConfirmedEvent (Frontend-Login): Wird nach dem er­folg­rei­chen Logout im Frontend ausgelöst, um z. B. Sit­zungs­da­ten zu be­rei­ni­gen oder Si­cher­heits­ak­tio­nen durch­zu­füh­ren.
• SendRecoveryEmailEvent (Frontend-Login): Mit dem Event SendRecoveryEmailEvent lassen sich An­pas­sun­gen am E-Mail-Inhalt oder spezielle Be­nach­rich­ti­gun­gen vornehmen. Es wird ausgelöst, sobald eine E-Mail zur Pass­wort­wie­der­her­stel­lung an­ge­for­dert wird.
• AfterMailerInitializationEvent (Mail): Wird ausgelöst, nachdem der TYPO3 Mailer in­itia­li­siert wurde, um An­pas­sun­gen an den E-Mail-Pa­ra­me­tern oder an der Kon­fi­gu­ra­ti­on vor­zu­neh­men.
• ModifyHrefLangTagsEvent (Frontend): Dient der einfachen Anpassung der hreflang-Tags, die si­cher­stel­len, dass mehr­spra­chi­ge Seiten korrekt von Such­ma­schi­nen erkannt werden.
• ModifyUrlForCanonicalTagEvent (SEO): Dieses TYPO3 Event dient dem Zweck, die URL für den Canonical-Tag zu mo­di­fi­zie­ren, um doppelte Inhalte zu vermeiden.
• ModifyFileDumpEvent (Core): Dieses Event erlaubt die Anpassung des Da­tei­down­load-Prozesses im TYPO3 Core. Auf diese Weise lassen sich zum Beispiel zu­sätz­li­che Au­then­ti­fi­zie­rungs­me­cha­nis­men einführen oder die Ausgabe anpassen.