Effektive Nutzung von Event-Subscriber in Shopware 6

10.  Deine Event-Strategie entwickeln

Montag früh, 9:00 Uhr: Dein Kunde ruft an und wünscht sich eine spezielle Funktion. Sobald ein Produkt in den Warenkorb gelegt wird, soll automatisch eine E-Mail an das Lager verschickt werden. Ein anderer Kunde möchte, dass bei jedem Bestellabschluss zusätzliche Daten an sein ERP-System übertragen werden. Wieder ein anderer benötigt individuelle Produktdaten in der Listing-Ansicht. All diese Anforderungen haben eines gemeinsam: Sie lassen sich elegant über Shopware Events lösen – wenn du weißt, wie.

Das Shopware Event-System ist wie ein unsichtbares Nervensystem, das durch deinen gesamten Online-Shop verläuft. Es informiert dich über jeden wichtigen Moment: "Gerade wurde ein Produkt aufgerufen", "Ein Kunde hat sich registriert", "Die Warenkorb-Seite wird geladen". Du kannst auf diese Ereignisse reagieren und deine eigene Logik einbauen, ohne den Shopware-Core zu verändern.

Was macht Events so besonders?

Stell dir vor, du betreibst einen physischen Laden. Jedes Mal, wenn ein Kunde die Tür öffnet, klingelt eine Glocke. Diese Glocke ist ein Event – sie signalisiert: "Achtung, ein Kunde kommt!" Du könntest auf dieses Signal reagieren, indem du ihn begrüßt, ihm Hilfe anbietest oder ein spezielles Angebot machst.

Genau so funktionieren Shopware Events: Sie sind Signale, die an bestimmten Stellen im Code ausgelöst werden. Der entscheidende Vorteil: Der Code, der das Event auslöst, muss nicht wissen, wer darauf reagiert. Shopware kann ein "ORDER_FINISHED"-Event mit Informationen wie Bestellsumme und Produkten aussenden. Dein Plugin kann darauf reagieren und diese Daten automatisch an dein ERP-System weiterleiten.

Die verschiedenen Event-Typen verstehen

Shopware unterscheidet zwischen vier grundlegenden Event-Typen, die jeweils unterschiedliche Möglichkeiten bieten:

Notify Events – Reine Information

$this->container->get('events')->notify(
    'SwagEvent_Product_Added_To_Cart',
    [
        'productId' => 123,
        'quantity' => 2,
        'customerId' => 456
    ]
);

Notify Events informieren dich lediglich über ein Ereignis. Du kannst die übertragenen Daten lesen und basierend darauf eigene Aktionen ausführen – zum Beispiel eine Benachrichtigung versenden oder Statistiken aktualisieren.

NotifyUntil Events – Kontrollierte Unterbrechung

Diese Events ermöglichen es dir, Shopware-Prozesse zu stoppen. Perfekt für Validierungen oder Sicherheitsprüfungen:

public function onValidateCheckout(\Enlight_Event_EventArgs $args)
{
    $customer = $args->get('customer');
   
    // Sperre den Checkout für gesperrte Kunden
    if ($customer->isBlocked()) {
        return 'Ihr Konto ist gesperrt. Bitte kontaktieren Sie uns.';
    }
   
    // Null zurückgeben = Shopware soll normal fortfahren
    return null;
}

Filter Events – Daten modifizieren

Filter Events sind deine Werkzeuge für Datenmanipulation. Sie ermöglichen es, Ergebnisse zu verändern, bevor sie verwendet werden:

public function onFilterProductData(\Enlight_Event_EventArgs $args)
{
    $products = $args->getReturn();
   
    // Zusätzliche Bewertungsdaten hinzufügen
    foreach ($products as &$product) {
        $product['customRating'] = $this->calculateCustomRating($product['id']);
        $product['deliveryTime'] = $this->getDeliveryTime($product['id']);
    }
   
    return $products;
}

Collect Events – Komponenten sammeln

Collect Events sammeln verschiedene Komponenten oder Handler. Ideal für Plugin-Architekturen:

public function onCollectPaymentHandlers(\Enlight_Event_EventArgs $args)
{
    return new ArrayCollection([
        new CustomPaymentHandler(),
        new AnotherPaymentHandler()
    ]);
}

Event Subscriber richtig einsetzen

Die professionelle Art, mit Shopware Events zu arbeiten, sind Event Subscriber. Sie kapseln deine Event-Logik in eigene Klassen und machen deinen Code wartbarer. Ein Shopware Subscriber implementiert das SubscriberInterface und definiert seine Shopware Event Listener zentral:

<?php
namespace SwagCustomExtension\Subscriber;

use Enlight\Event\SubscriberInterface;

class ProductSubscriber implements SubscriberInterface
{
    public static function getSubscribedEvents()
    {
        return [
            'Enlight_Controller_Action_PostDispatchSecure_Frontend_Detail' => 'onProductDetail',
            'Shopware_Modules_Basket_AddArticle_Start' => 'onAddToCart',
            'sOrder::saveOrder::after' => 'onOrderComplete'
        ];
    }
   
    public function onProductDetail(\Enlight_Event_EventArgs $args)
    {
        $controller = $args->getSubject();
        $view = $controller->View();
       
        // Zusätzliche Produktinformationen laden
        $productId = (int) $controller->Request()->getParam('sArticle');
        $customData = $this->loadCustomProductData($productId);
       
        $view->assign('customProductData', $customData);
    }
   
    public function onAddToCart(\Enlight_Event_EventArgs $args)
    {
        $productId = $args->get('id');
        $quantity = $args->get('quantity');
       
        // Lagerbenachrichtigung versenden
        $this->notifyWarehouse($productId, $quantity);
    }
}

Registrierung in der `services.xml`:

<service id="swag_custom_extension.subscriber.product_subscriber"
         class="SwagCustomExtension\Subscriber\ProductSubscriber">
    <tag name="shopware.event_subscriber" />
</service>

Die wichtigsten Events im Überblick

Eine Shopware Events List der wichtigsten Event-Kategorien:

Shopware Controller Events sind besonders nützlich für Frontend-Anpassungen, während Shopware Backend Events administrative Funktionen erweitern. Für moderne Shopware-Versionen bietet die Shopware 6 Events List zusätzliche Business Events, die als Shopware 6 Business Events bezeichnet werden.

Praktisches Beispiel: Automatische ERP-Integration

Ein häufiger Anwendungsfall ist die automatische Übertragung von Bestelldaten an ein ERP-System:

<?php
namespace SwagERPIntegration\Subscriber;

class OrderSubscriber implements SubscriberInterface
{
    private $erpService;
   
    public function __construct($erpService)
    {
        $this->erpService = $erpService;
    }
   
    public static function getSubscribedEvents()
    {
        return [
            'sOrder::saveOrder::after' => 'onOrderSaved'
        ];
    }
   
    public function onOrderSaved(\Enlight_Hook_HookArgs $args)
    {
        $orderId = $args->getReturn();
        $orderData = $this->loadOrderData($orderId);
       
        try {
            $this->erpService->transferOrder($orderData);
            $this->logTransfer($orderId, 'success');
        } catch (\Exception $e) {
            $this->logTransfer($orderId, 'failed', $e->getMessage());
            // Optional: Retry-Mechanismus oder Admin-Benachrichtigung
        }
    }
   
    private function loadOrderData($orderId)
    {
        // Bestelldaten aus der Datenbank laden
        $sql = '
            SELECT o.*, od.*, c.email, c.customernumber
            FROM s_order o
            LEFT JOIN s_order_details od ON o.id = od.orderID
            LEFT JOIN s_user c ON o.userID = c.id
            WHERE o.id = ?
        ';
       
        return Shopware()->Db()->fetchAll($sql, [$orderId]);
    }
}

Events finden und debuggen

Das Finden der richtigen Events kann anfangs herausfordernd sein. Hier sind bewährte Strategien:

1. Code-Analyse

Schaue dir den Controller oder die Klasse an, die du erweitern möchtest. Suche nach `notify`, `filter`, `collect` oder Hook-Aufrufen:

// In der sBasket-Klasse findest du:
$this->eventManager->notifyUntil(
    'Shopware_Modules_Basket_AddArticle_Start',
    array(
        'subject' => $this,
        'id' => $id,
        'quantity' => $quantity
    )
);

2. Event-Logging einrichten

Erstelle einen universellen Event-Listener für Debugging:

class DebugSubscriber implements SubscriberInterface
{
    public static function getSubscribedEvents()
    {
        return [
            'Enlight_Controller_Action_PostDispatchSecure' => 'logEvent'
        ];
    }
   
    public function logEvent(\Enlight_Event_EventArgs $args)
    {
        $eventName = $args->getName();
        $controller = get_class($args->getSubject());
       
        error_log("Event: $eventName, Controller: $controller");
    }
}

3. Browser-Entwicklertools nutzen

Im Shopware-Backend siehst du unter dem Symfony Profiler alle gefeuerten Events einer Request. Für eine vollständige Shopware 6 Event List kannst du auch die Dokumentation konsultieren.

Häufige Fallstricke vermeiden

Performance beachten

Events werden bei jedem Request ausgeführt. Schwere Operationen solltest du in Queues auslagern:

public function onOrderComplete(\Enlight_Event_EventArgs $args)
{
    $orderId = $args->get('orderId');
   
    // Schwere ERP-Übertragung in Queue einreihen
    $this->queueService->addJob('erp_transfer', ['orderId' => $orderId]);
   
    // Leichte Operationen sofort ausführen
    $this->updateOrderStatus($orderId);
}

Fehlerbehandlung implementieren

Events können die User Experience beeinträchtigen, wenn sie fehlschlagen:

public function onCriticalEvent(\Enlight_Event_EventArgs $args)
{
    try {
        $this->performCriticalOperation($args);
    } catch (\Exception $e) {
        // Fehler loggen, aber nicht den Shop lahmlegen
        $this->logger->error('Critical operation failed', [
            'exception' => $e->getMessage(),
            'event' => $args->getName()
        ]);
       
        // Optional: Admin benachrichtigen
        $this->notifyAdmin($e);
    }
}

Event-Reihenfolge berücksichtigen

Wenn mehrere Plugins auf dasselbe Event hören, kann die Reihenfolge wichtig sein:

<service id="my.subscriber" class="My\Subscriber">
    <tag name="shopware.event_subscriber" priority="100" />
</service>

Moderne Alternativen und Best Practices

Hooks als letzter Ausweg

Wenn kein passendes Event existiert, kannst du Hooks verwenden. Sie sind mächtiger, aber auch fehleranfälliger. Ein Shopware Hook Example:

class BasketHook extends \Enlight_Plugin_Bootstrap
{
    public function afterInit()
    {
        $this->subscribeEvent(
            'Enlight_Bootstrap_InitResource_Modules',
            'onInitResourceModules'
        );
    }
   
    public function onInitResourceModules()
    {
        $modules = Shopware()->Modules();
        $modules->addHook('sBasket', 'sGetBasket', $this);
    }
   
    public function sGetBasket($args)
    {
        $result = $args->getReturn();
       
        // Warenkorb-Daten modifizieren
        $result['customData'] = $this->addCustomData($result);
       
        return $result;
    }
}

Event-driven Architecture fördern

Entwerfe deine Plugin-Architektur event-getrieben:

class OrderService
{
    private $eventManager;
   
    public function processOrder($orderData)
    {
        // Before-Event für Validierungen
        $this->eventManager->notifyUntil('order.before_process', [
            'orderData' => $orderData
        ]);
       
        $order = $this->createOrder($orderData);
       
        // After-Event für Integrationen
        $this->eventManager->notify('order.processed', [
            'order' => $order
        ]);
       
        return $order;
    }
}

Wichtige Event-Methoden verstehen

Beim Arbeiten mit Events sind bestimmte Methoden essentiell. Die getSubscribedEvents Shopware-Methode definiert, welche Events ein Subscriber Shopware abhört. Das Shopware Add to Basket Event ist ein häufig genutztes Event für E-Commerce-Anpassungen, während das Shopware subscribeEvent in älteren Plugin-Versionen verwendet wurde.

Deine Event-Strategie entwickeln

Events sind das Fundament für saubere, erweiterbare Shopware-Lösungen. Sie ermöglichen es dir, komplexe Anpassungen zu realisieren, ohne den Core zu berühren. Beginne mit einfachen Notify Events, um Abläufe zu verstehen. Entwickle dann schrittweise komplexere Lösungen mit Filter und Collect Events.

Denke immer daran: Ein gut platziertes Event kann dir Stunden der Entwicklungszeit sparen und macht deine Lösung zukunftssicher. Shopware Events sind nicht nur ein technisches Feature – sie sind dein Schlüssel zu individuellen, professionellen E-Commerce-Lösungen, die genau das tun, was deine Kunden brauchen.

Das Event-System verwandelt Shopware von einer starren Software in eine flexible Plattform, die sich an jeden Geschäftsprozess anpassen lässt. Mit dem richtigen Verständnis der Events hast du das mächtigste Werkzeug in der Hand, um aus Shopware genau den Online-Shop zu machen, den dein Kunde sich vorstellt.