Observer Pattern

The Observer Pattern is a Behavioral Design Pattern where one object (Subject) notifies multiple dependent objects (Observers) automatically whenever its state changes.

It follows a one-to-many relationship.

---

Simple Definition

When one object changes, all subscribed objects get notified automatically.

---

Real-Life Example

Think about a YouTube channel:

When a creator uploads a new video:

• Subscribers receive notifications

• Email alerts are sent

• Mobile push notifications appear

YouTube Channel → Subscribers

The channel is the Subject, and subscribers are the Observers.

---

Why Use Observer Pattern?

Without Observer Pattern:

class OrderService {

    public function placeOrder()
    {
        // send email
        // send SMS
        // update inventory
        // create invoice
        // push notification
    }
}

Problems

❌ Tightly coupled code ❌ Difficult to maintain ❌ Hard to extend ❌ One class handles everything

---

Observer Pattern Structure

Subject
   ↓
Observers

---

Real-World Use Cases

✅ Event systems ✅ Notifications ✅ Real-time updates ✅ Laravel Events & Listeners ✅ Stock market systems ✅ Chat applications

---

Example: Order Notification System

When an order is placed:

• Send Email

• Send SMS

• Send Push Notification

---

Step 1: Create Observer Interface

interface Observer
{
    public function update($message);
}

All observers must implement this method.

---

Step 2: Create Concrete Observers

Email Notification Observer

class EmailNotification implements Observer
{
    public function update($message)
    {
        echo "Email Sent: {$message}\n";
    }
}

---

SMS Notification Observer

class SMSNotification implements Observer
{
    public function update($message)
    {
        echo "SMS Sent: {$message}\n";
    }
}

---

Push Notification Observer

class PushNotification implements Observer
{
    public function update($message)
    {
        echo "Push Notification: {$message}\n";
    }
}

---

Step 3: Create Subject Class

The Subject manages observers.

class Order
{
    protected $observers = [];

    // Attach observer
    public function attach(Observer $observer)
    {
        $this->observers[] = $observer;
    }

    // Notify all observers
    public function notify($message)
    {
        foreach ($this->observers as $observer) {
            $observer->update($message);
        }
    }

    // Business logic
    public function placeOrder()
    {
        echo "Order Placed Successfully\n";

        $this->notify("New Order Created");
    }
}

---

Step 4: Use Observer Pattern

$order = new Order();

$order->attach(new EmailNotification());
$order->attach(new SMSNotification());
$order->attach(new PushNotification());

$order->placeOrder();

---

Output

Order Placed Successfully

Email Sent: New Order Created
SMS Sent: New Order Created
Push Notification: New Order Created

---

Full Working Example

<?php

interface Observer
{
    public function update($message);
}

class EmailNotification implements Observer
{
    public function update($message)
    {
        echo "Email Sent: {$message}\n";
    }
}

class SMSNotification implements Observer
{
    public function update($message)
    {
        echo "SMS Sent: {$message}\n";
    }
}

class PushNotification implements Observer
{
    public function update($message)
    {
        echo "Push Notification: {$message}\n";
    }
}

class Order
{
    protected $observers = [];

    public function attach(Observer $observer)
    {
        $this->observers[] = $observer;
    }

    public function notify($message)
    {
        foreach ($this->observers as $observer) {
            $observer->update($message);
        }
    }

    public function placeOrder()
    {
        echo "Order Placed Successfully\n";

        $this->notify("New Order Created");
    }
}

$order = new Order();

$order->attach(new EmailNotification());
$order->attach(new SMSNotification());
$order->attach(new PushNotification());

$order->placeOrder();

---

Observer Pattern Flow

Order Placed
      ↓
Subject Notifies Observers
      ↓
Email Sent
SMS Sent
Push Notification Sent

---

Advantages

✅ Loose Coupling

Subject does not know observer details.

---

✅ Easy to Extend

Add new observers easily.

class SlackNotification implements Observer
{
    public function update($message)
    {
        echo "Slack Alert: {$message}";
    }
}

---

✅ Event-Driven Architecture

Perfect for scalable systems.

---

✅ Reusable Components

Observers are reusable across applications.

---

Disadvantages

❌ Too many observers can slow the system ❌ Debugging becomes difficult in complex event chains ❌ Notification order may matter sometimes

---

Real Laravel Examples

Laravel Feature	Observer Pattern
Events & Listeners	User Registered
Model Observers	created, updated
Notifications	Mail/SMS
Broadcasting	Real-time events

Laravel has built-in Observer and Event systems.

---

Laravel Observer Example

Create Observer

php artisan make:observer UserObserver --model=User

---

Observer Class

class UserObserver
{
    public function created(User $user)
    {
        Mail::to($user)->send(
            new WelcomeMail($user)
        );
    }
}

---

Register Observer

User::observe(UserObserver::class);

---

When to Use Observer Pattern

Use when:

✅ Multiple systems react to one event ✅ Event-driven architecture needed ✅ Loose coupling required ✅ Notifications are involved

---

When NOT to Use

❌ Very simple systems ❌ Only one dependent action exists ❌ Performance-critical synchronous operations

---

Observer vs Strategy Pattern

Observer	Strategy
One-to-many notifications	One selected algorithm
Event-driven	Behavior-driven
Multiple listeners	Single strategy
Subject notifies observers	Context uses strategy