The Observer pattern is a behavioral design pattern that defines a one-to-many dependency between objects. When the state of one object (the subject) changes, all its dependents (observers) are notified and updated automatically. This pattern is commonly used to implement distributed event handling systems.

Key Characteristics:

  • One-to-Many Dependency: Establishes a one-to-many relationship between the subject and its observers.
  • Automatic Notification: Observers are automatically notified and updated when the subject’s state changes.
  • Decoupling: Promotes loose coupling between the subject and observers.

How It Works:

  • Subject: Maintains a list of observers and provides methods to attach and detach observers. It also notifies all registered observers of changes.
  • Observer: Defines an interface or abstract class for updating itself when the subject changes.
  • Concrete Subject: Implements the subject interface and notifies observers of state changes.
  • Concrete Observer: Implements the observer interface and updates itself based on notifications from the subject.

Example in PHP: 

  // Observer Interface
interface Observer {
    public function update($state);
}

// Concrete Observer
class ConcreteObserver implements Observer {
    private $name;

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

    public function update($state) {
        echo "Observer {$this->name} received update: {$state}\n";
    }
}

// Subject Interface
interface Subject {
    public function attach(Observer $observer);
    public function detach(Observer $observer);
    public function notify();
}

// Concrete Subject
class ConcreteSubject implements Subject {
    private $observers = [];
    private $state;

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

    public function detach(Observer $observer) {
        $this->observers = array_filter($this->observers, function($obs) use ($observer) {
            return $obs !== $observer;
        });
    }

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

    public function setState($state) {
        $this->state = $state;
        $this->notify();
    }

    public function getState() {
        return $this->state;
    }
}

// Client Code
$subject = new ConcreteSubject();

$observer1 = new ConcreteObserver("Observer1");
$observer2 = new ConcreteObserver("Observer2");

$subject->attach($observer1);
$subject->attach($observer2);

$subject->setState("State1"); // Output: Observer Observer1 received update: State1
                               //         Observer Observer2 received update: State1

$subject->detach($observer1);

$subject->setState("State2"); // Output: Observer Observer2 received update: State2

Explanation:

  1. Observer Interface: Observer defines the update() method that observers must implement to receive updates.
  2. Concrete Observer: ConcreteObserver implements the Observer interface and updates itself based on notifications.
  3. Subject Interface: Subject defines methods for attaching, detaching, and notifying observers.
  4. Concrete Subject: ConcreteSubject implements the Subject interface. It manages observers and notifies them of state changes.
  5. Client Code: Demonstrates attaching observers to the subject, changing the subject’s state, and observing the notifications.

Benefits:

  • Decoupling: Reduces dependencies between the subject and observers, promoting loose coupling.
  • Dynamic Relationships: Observers can be added or removed dynamically at runtime.
  • Automatic Updates: Observers are automatically notified of changes, simplifying event handling.

Use Cases:

  • Event Handling Systems: For implementing event-driven architectures where multiple components need to react to changes in state.
  • User Interfaces: For updating UI components in response to model changes (e.g., updating a view when the underlying data changes).
  • Notification Systems: For broadcasting changes or notifications to multiple subscribers.

The Observer pattern is useful for managing state changes and communication between objects in a flexible and decoupled manner, making it ideal for implementing event-driven systems and updating multiple parts of a system in response to changes.