Frontend-Caching mit TYPO3 13.4: Architektur, Auto-Tagging und Best Practices

Schritt 1: Prüfen, ob Auto-Tagging aktiviert ist

In config/system/settings.php oder im Install Tool nachsehen:

'SYS' => [
	'features' => [
		'frontend.cache.autoTagging' => true,
	],
], 

Cache-Verhalten testen

• Einfache Extbase-Listen- oder Detail-Views mit DB-Datensätzen aufsetzen.
• Seite aufrufen → im Backend Datensatz ändern → prüfen, ob der Seitencache geleert wird (z.B. indem sich der Inhalt ohne manuelles Cache-Löschen ändert).

Wenn das schon bei „einfachen“ Fällen nicht funktioniert, prüfe zunächst die Konfiguration und korrigiere sie, bevor du weitere Schritte unternimmst.

Hinweis: Denk daran, dass du in einem anderen Browser oder im Incognito-Modus das Frontend testen musst. Frontend-Requests, die bei gleichzeitig aktiver Backend-Session abgerufen werden, werden niemals gecached.

Schritt 2: Eigenes Tagging mit dem Frontend Cache Collector ergänzen

Für alle Daten, die Auto-Tagging nicht abdeckt, benutzt du den frontend.cache.collector direkt, um die CacheTags manuell zu setzen.

Collector Instanz aus dem aktuellen Request holen

In einer PSR-15 Middleware oder sonstigem Code mit Request-Parameter:

use Psr\Http\Message\ServerRequestInterface;
use TYPO3\CMS\Core\Cache\CacheTag;

public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{
    $collector = $request->getAttribute('frontend.cache.collector');

    // Beispiel: externer API-Datensatz mit ID $itemId
    $collector->addCacheTags(
        new CacheTag('external_item_' . $itemId),
    );

    return $handler->handle($request);
}

In Kontexten ohne direkten Request-Parameter (z.B. DataProcessor, Hooks) kannst du als Fallback das globale Request-Objekt nutzen:

use Psr\Http\Message\ServerRequestInterface;
use TYPO3\CMS\Core\Cache\CacheTag;

/** @var ServerRequestInterface $request */
$request = $GLOBALS['TYPO3_REQUEST'];
$collector = $request->getAttribute('frontend.cache.collector');

$collector->addCacheTags(
    new CacheTag('external_item_' . $itemId),
);

Mehrere Tags / Lifetime setzen

Beispiel

$collector->addCacheTags(
    new CacheTag('tx_myext_article_123', 3600),      // 1 Stunde
    new CacheTag('tx_myext_category_45', 86400),     // 1 Tag
);

Der Collector berechnet dann auf Seiten, denen diese Tags zugewiesen sind, automatisch die minimale Lifetime anhand der geringsten Lifetime. In diesem Beispiel wären das 3600 Sekunden.

Schritt 3: Sinnvolle Tag-Namenskonvention wählen

Bewährt ist ein Schema wie bei der Extension News von Georg Ringer. Hier wird z.B. tx_news_pid_<PID> als Tag genutzt: Seite(n) mit News-Listen werden damit gekennzeichnet, beim Ändern einer News im entsprechenden Storage-Folder wird über diesen Tag der Cache geleert.

Für eigene Daten:

• Pro Datensatz tx_myext_domain_model_foo_<uid>
• Pro Container / Ordner / Filter tx_myext_foo_pid_<pid>, tx_myext_foo_category_<catUid>

So kannst du bei Änderungen die Cache-Einträge einer Detailseite eines Datensatzes über den „Einzel-Tag“ sowie für Listen/Übersichten über die „Container“-Tags (PID, Kategorie etc.) invalidieren.

Schritt 4: Cache beim Ändern der Daten per Tag löschen

Auto-Tagging kümmert sich nur zuverlässig um TYPO3-DB-Records, die vom System erkannt werden. Für andere Datenquellen musst du das Löschen selbst anstoßen. Dazu nutzt du den CacheManager:

use TYPO3\CMS\Core\Cache\CacheManager;
use TYPO3\CMS\Core\Utility\GeneralUtility;

// z.B. nach Import eines externen Datensatzes
$cacheManager = GeneralUtility::makeInstance(CacheManager::class);

// Alle Caches mit diesem Tag leeren
$cacheManager->flushCachesByTag('external_item_' . $itemId);

// Oder nur Caches in der Gruppe "pages" leeren (Seitencache)
$cacheManager->flushCachesInGroupByTag('pages', 'external_item_' . $itemId);

Typische Orte für diesen Code:

• Scheduler-Task, der externe Daten importiert/aktualisiert
• Webhook-/Reactions-Handler (z.B. wenn externe Systeme TYPO3 informieren)
• Backend-Modul oder DataHandler-Hook, wenn deine Daten als TYPO3-Records gepflegt werden

Schritt 5: Prüfen, ob dein Cache-Backend Tagging unterstützt

Für Page/Content-Caches ist das standardmäßig der Fall. Falls du aber eigene Caches definierst, achte darauf, einen Backend-Typ zu verwenden, der TaggableBackendInterface implementiert (z.B. DB-, Redis- oder File-Backend, nicht SimpleFileBackend).

Sonst können Tags zwar gesammelt, aber nie gezielt geleert werden.