How to Trigger a Custom Business Event in Shopware 6.7

Shopware 6.7 introduces significant improvements to its event system, making it easier than ever to implement custom business events that can be consumed by other parts of your application or integrated with external systems. This technical deep dive will explore the various approaches to triggering custom business events in Shopware 6.7, from basic implementation to advanced patterns.

Understanding Shopware's Event System#

Before diving into implementation details, it's crucial to understand how Shopware's event system works. Events in Shopware are built on Symfony's EventDispatcher component and follow a robust pattern that allows for loose coupling between different parts of your application. In Shopware 6.7, the event system has been enhanced with better type safety, improved performance, and more intuitive APIs.

Events in Shopware can be categorized into three main types:

• Core events: Triggered by built-in Shopware functionality
• Custom business events: Implemented by developers for specific business logic
• System events: Related to infrastructure and system operations

Basic Custom Event Implementation#

The foundation of any custom event is creating an event class that extends Symfony's base event class. Here's how to implement a basic custom business event in Shopware 6.7:

<?php declare(strict_types=1);

namespace MyPlugin\Event;

use Shopware\Core\Framework\Event\BusinessEventInterface;
use Symfony\Contracts\EventDispatcher\Event;

class OrderProcessedEvent extends Event implements BusinessEventInterface
{
    public const NAME = 'my-plugin.order.processed';

    private string $orderId;
    private array $orderData;
    private \DateTime $processedAt;

    public function __construct(string $orderId, array $orderData)
    {
        $this->orderId = $orderId;
        $this->orderData = $orderData;
        $this->processedAt = new \DateTime();
    }

    public function getOrderId(): string
    {
        return $this->orderId;
    }

    public function getOrderData(): array
    {
        return $this->orderData;
    }

    public function getProcessedAt(): \DateTime
    {
        return $this->processedAt;
    }

    public static function getName(): string
    {
        return self::NAME;
    }
}

Triggering Events in Services#

Once your event class is defined, you need to trigger it from within your service. The recommended approach in Shopware 6.7 is to use the EventDispatcher service directly:

<?php declare(strict_types=1);

namespace MyPlugin\Service;

use MyPlugin\Event\OrderProcessedEvent;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

class OrderProcessingService
{
    private EventDispatcherInterface $eventDispatcher;

    public function __construct(EventDispatcherInterface $eventDispatcher)
    {
        $this->eventDispatcher = $eventDispatcher;
    }

    public function processOrder(string $orderId, array $orderData): void
    {
        // Your business logic here
        $this->performOrderProcessing($orderId, $orderData);
        
        // Trigger custom event
        $event = new OrderProcessedEvent($orderId, $orderData);
        $this->eventDispatcher->dispatch($event, OrderProcessedEvent::NAME);
    }

    private function performOrderProcessing(string $orderId, array $orderData): void
    {
        // Implementation details
    }
}

Advanced Event Patterns in Shopware 6.7#

Shopware 6.7 introduces several advanced patterns for event handling that enhance flexibility and maintainability:

1. Event with Payload Modification#

Sometimes you need to modify data during the event lifecycle. Here's how to implement an event that allows subscribers to modify the payload:

<?php declare(strict_types=1);

namespace MyPlugin\Event;

use Shopware\Core\Framework\Event\BusinessEventInterface;
use Symfony\Contracts\EventDispatcher\Event;

class OrderValidationEvent extends Event implements BusinessEventInterface
{
    public const NAME = 'my-plugin.order.validation';

    private string $orderId;
    private array $validationData;
    private bool $isValid = true;

    public function __construct(string $orderId, array $validationData)
    {
        $this->orderId = $orderId;
        $this->validationData = $validationData;
    }

    public function getOrderId(): string
    {
        return $this->orderId;
    }

    public function getValidationData(): array
    {
        return $this->validationData;
    }

    public function setValidationData(array $validationData): void
    {
        $this->validationData = $validationData;
    }

    public function isValid(): bool
    {
        return $this->isValid;
    }

    public function setValid(bool $valid): void
    {
        $this->isValid = $valid;
    }

    public static function getName(): string
    {
        return self::NAME;
    }
}

2. Event with Multiple Subscribers#

Shopware 6.7 supports multiple subscribers to the same event, which is particularly useful for complex business scenarios:

<?php declare(strict_types=1);

namespace MyPlugin\Subscriber;

use MyPlugin\Event\OrderProcessedEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

class OrderNotificationSubscriber implements EventSubscriberInterface
{
    public static function getSubscribedEvents(): array
    {
        return [
            OrderProcessedEvent::NAME => [
                ['sendEmailNotification', 10],
                ['updateAnalytics', 5],
                ['logProcessing', 1]
            ]
        ];
    }

    public function sendEmailNotification(OrderProcessedEvent $event): void
    {
        // Send email notification logic
    }

    public function updateAnalytics(OrderProcessedEvent $event): void
    {
        // Update analytics tracking
    }

    public function logProcessing(OrderProcessedEvent $event): void
    {
        // Log processing information
    }
}

Integration with Shopware's Core Events#

Shopware 6.7 allows seamless integration between custom business events and core events, enabling powerful event-driven architectures:

<?php declare(strict_types=1);

namespace MyPlugin\Subscriber;

use MyPlugin\Event\OrderProcessedEvent;
use Shopware\Core\Checkout\Order\Event\OrderStateChangeEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

class OrderProcessingIntegration implements EventSubscriberInterface
{
    public static function getSubscribedEvents(): array
    {
        return [
            OrderStateChangeEvent::NAME => 'onOrderStateChange',
            OrderProcessedEvent::NAME => 'onOrderProcessed'
        ];
    }

    public function onOrderStateChange(OrderStateChangeEvent $event): void
    {
        // Handle order state change
    }

    public function onOrderProcessed(OrderProcessedEvent $event): void
    {
        // Trigger additional business logic after processing
    }
}

Performance Considerations#

When implementing custom events in Shopware 6.7, several performance aspects should be considered:

Event Listener Priority Management#

<?php declare(strict_types=1);

namespace MyPlugin\Subscriber;

use MyPlugin\Event\OrderProcessedEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

class HighPrioritySubscriber implements EventSubscriberInterface
{
    public static function getSubscribedEvents(): array
    {
        return [
            OrderProcessedEvent::NAME => [
                ['criticalProcessing', 100], // Highest priority
                ['normalProcessing', 10],
                ['logging', -100] // Lowest priority
            ]
        ];
    }
}

Asynchronous Event Processing#

For resource-intensive operations, consider implementing asynchronous event processing:

<?php declare(strict_types=1);

namespace MyPlugin\Subscriber;

use MyPlugin\Event\OrderProcessedEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\Messenger\MessageBusInterface;

class AsyncProcessingSubscriber implements EventSubscriberInterface
{
    private MessageBusInterface $messageBus;

    public function __construct(MessageBusInterface $messageBus)
    {
        $this->messageBus = $messageBus;
    }

    public static function getSubscribedEvents(): array
    {
        return [
            OrderProcessedEvent::NAME => 'handleAsyncProcessing'
        ];
    }

    public function handleAsyncProcessing(OrderProcessedEvent $event): void
    {
        // Dispatch to message queue for async processing
        $this->messageBus->dispatch(new OrderProcessingMessage($event));
    }
}

Testing Custom Events#

Shopware 6.7 provides robust testing capabilities for custom events:

<?php declare(strict_types=1);

namespace MyPlugin\Test\Unit\Event;

use MyPlugin\Event\OrderProcessedEvent;
use PHPUnit\Framework\TestCase;
use Symfony\Component\EventDispatcher\EventDispatcher;

class OrderProcessedEventTest extends TestCase
{
    public function testEventDispatch(): void
    {
        $dispatcher = new EventDispatcher();
        $eventCalled = false;

        $dispatcher->addListener(OrderProcessedEvent::NAME, function(OrderProcessedEvent $event) use (&$eventCalled) {
            $eventCalled = true;
            $this->assertEquals('test-order-id', $event->getOrderId());
        });

        $event = new OrderProcessedEvent('test-order-id', []);
        $dispatcher->dispatch($event, OrderProcessedEvent::NAME);

        $this->assertTrue($eventCalled);
    }
}

Best Practices for Event Implementation#

1. Use Descriptive Names: Always use clear, descriptive event names that indicate the business context
2. Maintain Backward Compatibility: When modifying events, ensure existing subscribers continue to work
3. Implement Proper Error Handling: Include error handling in your event subscribers
4. Document Your Events: Provide clear documentation for event parameters and usage
5. Consider Event Payload Size: Be mindful of memory usage when passing large data sets through events

Conclusion#

Shopware 6.7's enhanced event system provides powerful capabilities for implementing custom business events that can significantly improve the modularity and maintainability of your e-commerce solutions. By following the patterns outlined in this article, you can create robust, performant, and well-integrated custom events that seamlessly work within Shopware's ecosystem.

The key to successful implementation lies in understanding when and how to use events, properly structuring your event classes, and considering performance implications. As you implement these patterns in your projects, remember that events should be used judiciously - they're most valuable for decoupling business logic rather than replacing direct method calls within your application.

With Shopware 6.7's improved event system, developers now have more flexibility and control over their custom business events, enabling them to build more sophisticated and maintainable e-commerce solutions that can adapt to changing business requirements while maintaining excellent performance characteristics.