Shopware 6 Subscriber Events – so funktioniert das System

Shopware 6 basiert auf einem mächtigen Event-System, das es Entwicklern ermöglicht, in nahezu jeden Prozess der Shop-Software einzugreifen. Durch Shopware 6 Subscriber Events kannst du Bestellprozesse modifizieren, Produktdaten anpassen oder Custom Business Logic implementieren – ohne den Core zu verändern.

In diesem Artikel zeige ich dir, wie Shopware 6 Subscriber Events funktionieren, wie du eigene Event-Subscriber erstellst und welche wichtigen Events du kennen solltest.

Was sind Shopware 6 Subscriber Events?

Shopware 6 nutzt das Event-Dispatcher-Pattern aus Symfony. Das bedeutet: Zu bestimmten Zeitpunkten im Code werden Events gefeuert – zum Beispiel beim Speichern einer Entity, beim Checkout oder beim Login eines Kunden.

Ein Event-Subscriber ist eine PHP-Klasse, die auf diese Events reagiert. Du registrierst den Subscriber im Dependency-Injection-Container, gibst an, auf welche Events er hören soll, und definierst, was passieren soll, wenn das Event gefeuert wird.

Der Vorteil: Du musst keinen Core-Code anfassen. Deine Änderungen sind sauber gekapselt und Update-sicher.

Event-Subscriber vs. Event-Listener – was ist der Unterschied?

In Symfony – und damit auch in Shopware 6 – gibt es zwei Konzepte:

Event-Listener: Werden in der services.xml mit einem Tag registriert. Jeder Listener hat eine einzige Methode pro Event.
Event-Subscriber: Implementieren ein Interface und geben selbst an, auf welche Events sie hören. Flexibler und übersichtlicher bei mehreren Events.

In der Praxis sind Shopware 6 Subscriber Events meist die bessere Wahl, weil sie selbstdokumentierend sind und die Registrierung im Service-Container automatisch erfolgt.

Einen einfachen Event-Subscriber erstellen

Angenommen, du möchtest bei jeder Produktänderung eine Log-Nachricht ausgeben. Das Event dafür heißt ProductWrittenEvent.

Schritt 1: Subscriber-Klasse anlegen

<?php declare(strict_types=1);

namespace MyPlugin\Subscriber;

use Shopware\Core\Content\Product\ProductEvents;
use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Psr\Log\LoggerInterface;

class ProductSubscriber implements EventSubscriberInterface
{
    private LoggerInterface $logger;

    public function __construct(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    public static function getSubscribedEvents(): array
    {
        return [
            ProductEvents::PRODUCT_WRITTEN_EVENT => 'onProductWritten',
        ];
    }

    public function onProductWritten(EntityWrittenEvent $event): void
    {
        $this->logger->info('Ein Produkt wurde geändert', [
            'ids' => $event->getIds(),
        ]);
    }
}

Schritt 2: Service registrieren

In deiner src/Resources/config/services.xml:

<?xml version="1.0" ?>
<container xmlns="http://symfony.com/schema/dic/services"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://symfony.com/schema/dic/services 
           http://symfony.com/schema/dic/services/services-1.0.xsd">

    <services>
        <service id="MyPlugin\Subscriber\ProductSubscriber">
            <argument type="service" id="logger"/>
            <tag name="kernel.event_subscriber"/>
        </service>
    </services>
</container>

Das kernel.event_subscriber-Tag sorgt dafür, dass Symfony den Subscriber automatisch registriert.

Wichtige Shopware 6 Subscriber Events im Überblick

Shopware 6 feuert hunderte von Events. Hier sind die wichtigsten Kategorien:

Entity-Events

Diese Events werden beim Erstellen, Aktualisieren oder Löschen von Entities gefeuert:

EntityWrittenEvent – nach dem Schreiben
EntityDeletedEvent – nach dem Löschen
EntityLoadedEvent – nach dem Laden aus der Datenbank

Beispiel für Bestellungen:

use Shopware\Core\Checkout\Order\OrderEvents;

public static function getSubscribedEvents(): array
{
    return [
        OrderEvents::ORDER_WRITTEN_EVENT => 'onOrderWritten',
    ];
}

Checkout-Events

Für Warenkorb und Bestellprozess:

CheckoutOrderPlacedEvent – nach erfolgter Bestellung
CartCreatedEvent – neuer Warenkorb
CheckoutRegisterEvent – Kundenregistrierung während Checkout

Customer-Events

CustomerLoginEvent – Login
CustomerLogoutEvent – Logout
CustomerChangedPaymentMethodEvent – Zahlungsart geändert

Mail-Events

Bevor Shopware eine E-Mail versendet:

MailSentEvent – nach dem Versenden
MailBeforeValidateEvent – vor Validierung der Mail-Daten

Praxis-Beispiel: Bestellbestätigung erweitern

Ein häufiger Use-Case: Du möchtest nach jeder Bestellung automatisch eine Benachrichtigung an ein externes System senden.

<?php declare(strict_types=1);

namespace MyPlugin\Subscriber;

use Shopware\Core\Checkout\Order\Event\OrderStateMachineStateChangeEvent;
use Shopware\Core\Checkout\Order\OrderEntity;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use GuzzleHttp\Client;

class OrderNotificationSubscriber implements EventSubscriberInterface
{
    private Client $httpClient;

    public function __construct()
    {
        $this->httpClient = new Client();
    }

    public static function getSubscribedEvents(): array
    {
        return [
            'state_machine.order.state_changed' => 'onOrderStateChange',
        ];
    }

    public function onOrderStateChange(OrderStateMachineStateChangeEvent $event): void
    {
        $order = $event->getOrder();
        
        if ($event->getNextState()->getTechnicalName() === 'completed') {
            $this->sendToExternalSystem($order);
        }
    }

    private function sendToExternalSystem(OrderEntity $order): void
    {
        $this->httpClient->post('https://api.example.com/orders', [
            'json' => [
                'order_number' => $order->getOrderNumber(),
                'total' => $order->getAmountTotal(),
            ],
        ]);
    }
}

Hier nutzen wir das State-Machine-Event, das gefeuert wird, wenn sich der Bestellstatus ändert – ein mächtiges Konzept in Shopware 6.

Best Practices für Shopware 6 Subscriber Events

1. Sei spezifisch

Höre nur auf die Events, die du wirklich brauchst. EntityWrittenEvent wird bei jedem Schreibvorgang gefeuert – das kann Performance-Probleme verursachen.

2. Fehlerbehandlung

Events werden synchron ausgeführt. Ein Fehler in deinem Subscriber kann den gesamten Request abbrechen:

public function onProductWritten(EntityWrittenEvent $event): void
{
    try {
        // Deine Logik
    } catch (\Exception $e) {
        $this->logger->error('Fehler im ProductSubscriber', [
            'exception' => $e->getMessage(),
        ]);
    }
}

3. Performance beachten

Lange laufende Tasks (API-Calls, große Datenbank-Queries) gehören nicht in Event-Subscriber. Nutze stattdessen die Message-Queue:

use Shopware\Core\Framework\MessageQueue\MessageQueueInterface;

$this->messageQueue->dispatch(new MyCustomMessage($order->getId()));

4. Event-Priorität nutzen

Du kannst die Reihenfolge steuern, in der Subscriber ausgeführt werden:

public static function getSubscribedEvents(): array
{
    return [
        ProductEvents::PRODUCT_WRITTEN_EVENT => ['onProductWritten', 100],
    ];
}

Höhere Zahlen = frühere Ausführung.

Debugging von Shopware 6 Subscriber Events

Welche Events werden überhaupt gefeuert? Mit dem Symfony Profiler siehst du das in der Debug-Toolbar. In der CLI kannst du Events auch loggen:

bin/console debug:event-dispatcher

Oder du nutzt einen Catch-All-Subscriber zum Debuggen:

public static function getSubscribedEvents(): array
{
    return [
        'kernel.request' => 'onKernelRequest',
    ];
}

public function onKernelRequest(): void
{
    // Breakpoint hier setzen
}

Fazit: Shopware 6 Subscriber Events sind unverzichtbar

Das Event-System ist das Rückgrat der Erweiterbarkeit in Shopware 6. Mit Shopware 6 Subscriber Events kannst du sauber und update-sicher in Geschäftsprozesse eingreifen, ohne Core-Dateien anzutassen.

Die wichtigsten Takeaways:

Event-Subscriber implementieren EventSubscriberInterface
Registrierung erfolgt über das kernel.event_subscriber-Tag
Hunderte Events stehen zur Verfügung – von Entity-Änderungen bis State-Machine-Übergängen
Achte auf Performance und Fehlerbehandlung
Nutze die Message-Queue für aufwändige Tasks

Du arbeitest an einem Shopware 6 Projekt mit komplexer Business Logic? Ich helfe dir gerne bei der Implementierung sauberer Event-Subscriber und Plugin-Architekturen.