Observer Pattern

Definition

The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

Problem: Tight Coupling in Order Processing

namespace Vendor\Sales\Model;

class OrderProcessor
{
    public function placeOrder(OrderInterface $order): void
    {
        $this->saveOrder($order);
        $this->updateInventory($order);    // Direct dependency
        $this->sendEmail($order);           // Direct dependency
        $this->updateAnalytics($order);     // Direct dependency
        $this->notifyAdmin($order);          // Direct dependency
        // 5 direct dependencies — adding more = more coupling
    }
}

Solution: Observer Pattern

// Subject: dispatches events
namespace Vendor\Sales\Event;

class OrderEventDispatcher
{
    private array $listeners = [];

    public function attach(string $event, callable $listener): void
    {
        $this->listeners[$event][] = $listener;
    }

    public function dispatch(string $event, mixed $data): void
    {
        foreach ($this->listeners[$event] ?? [] as $listener) {
            $listener($data);
        }
    }
}

// Subject uses event dispatching
class OrderProcessor
{
    public function __construct(
        private OrderEventDispatcher $dispatcher
    ) {}

    public function placeOrder(OrderInterface $order): void
    {
        $this->saveOrder($order);
        $this->dispatcher->dispatch('order.placed', $order);
    }
}

// Observers: independent, decoupled
$this->dispatcher->attach('order.placed', function ($order) {
    $this->inventory->updateStock($order);
});

$this->dispatcher->attach('order.placed', function ($order) {
    $this->emailSender->sendConfirmation($order);
});

$this->dispatcher->attach('order.placed', function ($order) {
    $this->analytics->trackOrder($order);
});

// Adding new behavior = attaching new listener. Zero coupling.

The OrderProcessor doesn't know about inventory, email, or analytics. It just fires an event. Listeners subscribe independently.

How Magento Implements Events

Magento has a built-in event system using Magento\Framework\Event\Manager.

Dispatching Events

// In Magento core (simplified)
$eventManager = $this->eventManager;
$eventManager->dispatch('catalog_product_save_after', [
    'product' => $product,
    'object' => $product,
]);

$eventManager->dispatch('sales_order_place_after', [
    'order' => $order,
]);

Defining Observers

<!-- app/code/Vendor/Module/etc/events.xml -->
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="urn:magento:framework:Event/etc/events.xsd">

    <!-- Observe product save -->
    <event name="catalog_product_save_after">
        <observer name="vendor_product_sync"
                  instance="Vendor\Module\Observer\ProductSyncObserver"
                  disabled="false"/>
    </event>

    <!-- Observe order placement -->
    <event name="sales_order_place_after">
        <observer name="vendor_order_notification"
                  instance="Vendor\Module\Observer\OrderNotificationObserver"/>
    </event>
</config>

Observer Implementation

namespace Vendor\Module\Observer;

use Magento\Framework\Event\ObserverInterface;
use Magento\Framework\Event\Observer;

class ProductSyncObserver implements ObserverInterface
{
    public function __construct(
        private \Vendor\Sync\Api\ProductSyncInterface $syncService,
        private \Psr\Log\LoggerInterface $logger
    ) {}

    public function execute(Observer $observer): void
    {
        try {
            $product = $observer->getEvent()->getProduct();
            $this->syncService->sync($product);
        } catch (\Exception $e) {
            $this->logger->error('Product sync failed: ' . $e->getMessage());
        }
    }
}

Common Magento Events

Magento Plugins (Interceptors)

Plugins wrap specific methods on specific classes:

<type name="Magento\Catalog\Model\Product">
    <plugin name="vendor_product_validate"
            type="Vendor\Catalog\Plugin\ProductValidationPlugin"
            sortOrder="10"/>
</type>

Plugins are method-level interception.

Magento Events/Observers

Events are system-wide notifications:

<event name="catalog_product_save_after">
    <observer name="vendor_sync" instance="..."/>
</event>

Observers are event-level subscription.

Decision Guide

// Plugin: Modify Product::getName() behavior
public function beforeGetName($subject)
{
    // Runs before Product::getName()
}

// Observer: React to any product save
// catalog_product_save_after fires for ANY product save
// Your observer doesn't know or care which module saved it

Rule: If you need to modify one class's method → Plugin. If you need to react when something happens system-wide → Observer.