Introduzione

L’Observer Design Pattern è un design pattern comportamentale per la gestione degli eventi che definisce una relazione uno-a-molti tra oggetti.
L’ Observer Design Pattern definisce una relazione uno-a-molti tra oggetti: quando l’oggetto osservato (detto Subject) cambia stato, notifica automaticamente tutti i suoi osservatori (detti Observers).

Il pattern è composto da:

• Subject: l’oggetto osservato, che mantiene una lista degli osservatori e li notifica di eventuali modifiche.
• Observer: un’interfaccia o classe che deve essere implementata da chi desidera osservare il Subject.

Diagramma UML

Il seguente diagramma mostra la struttura del pattern:

Nota: L’immagine rappresenta le relazioni tra le principali classi e interfacce:
Subject, ConcreteSubject, Observer e ConcreteObserver.

Esempio pratico in PHP

Implementiamo un esempio in PHP che simula un sistema di notifiche con due tipi di eventi: user registration
e order placement, ciascuno con relativi listener.

Codice PHP

// Interfaccia Observer
interface Observer {
    public function update(string $event, mixed $data): void;
}

// Classe Subject
class Subject {
    private array $observers = [];

    public function attach(string $event, Observer $observer): void {
        $this->observers[$event][] = $observer;
    }

    public function detach(string $event, Observer $observer): void {
        if (!isset($this->observers[$event])) return;

        $this->observers[$event] = array_filter(
            $this->observers[$event],
            fn($o) => $o !== $observer
        );
    }

    public function notify(string $event, mixed $data): void {
        if (!isset($this->observers[$event])) return;

        foreach ($this->observers[$event] as $observer) {
            $observer->update($event, $data);
        }
    }
}

// Listener per la registrazione utenti
class UserRegistrationListener implements Observer {
    public function update(string $event, mixed $data): void {
        echo "Notifica ricevuta per evento '$event': Nuovo utente registrato con email {$data['email']}.\\n";
    }
}

// Listener per l'invio di ordini
class OrderPlacementListener implements Observer {
    public function update(string $event, mixed $data): void {
        echo "Notifica ricevuta per evento '$event': Ordine effettuato con ID {$data['orderId']}.\\n";
    }
}

// Simulazione
$subject = new Subject();

// Creazione di listener
$userListener = new UserRegistrationListener();
$orderListener = new OrderPlacementListener();

// Registrazione ai rispettivi eventi
$subject->attach('user_registered', $userListener);
$subject->attach('order_placed', $orderListener);

// Generazione di eventi
$subject->notify('user_registered', ['email' => 'example@example.com']);
$subject->notify('order_placed', ['orderId' => '12345']);
                

Diagramma UML dell’implementazione

Il diagramma sopra rappresenta le classi e le interazioni nel nostro esempio.

Conclusione

L’Observer Design Pattern è un approccio potente per implementare notifiche reattive tra oggetti,
consentendo una separazione delle responsabilità. È ampiamente utilizzato in sistemi di eventi, interfacce grafiche e molto altro.

Riferimenti

• Observer Design Pattern – Refactoring Guru
• Documentazione ufficiale di PHP