Patron Observateur

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy — leçon 92 sur 110.

Le patron Observateur établit une relation de un à plusieurs entre les objets : lorsqu'un objet (le sujet) change d'état, tous ses dépendants (observateurs) sont automatiquement notifiés. C'est parfait pour des scénarios tels que les mises à jour de l'interface utilisateur, les systèmes d'événements ou toute situation où plusieurs parties de votre application doivent réagir aux changements.

Le patron implique deux rôles clés : un Subject qui maintient une liste d'observateurs et les informe des changements, et des Observers qui s'enregistrent eux-mêmes et répondent aux mises à jour :

abstract class Observer {
  void update(String message);
}

class NewsAgency {
  final List<Observer> _observers = [];
  String _latestNews = '';

  void subscribe(Observer observer) {
    _observers.add(observer);
  }

  void unsubscribe(Observer observer) {
    _observers.remove(observer);
  }

  void publishNews(String news) {
    _latestNews = news;
    for (var observer in _observers) {
      observer.update(_latestNews);
    }
  }
}

class NewsChannel implements Observer {
  final String name;
  NewsChannel(this.name);

  @override
  void update(String message) {
    print('$name received: $message');
  }
}

void main() {
  var agency = NewsAgency();
  var cnn = NewsChannel('CNN');
  var bbc = NewsChannel('BBC');

  agency.subscribe(cnn);
  agency.subscribe(bbc);

  agency.publishNews('Breaking news!');
  // CNN a reçu : Breaking news!
  // BBC a reçu : Breaking news!
}

Lorsque publishNews est appelée, l'agence parcourt tous les observateurs abonnés et appelle leur méthode update. Les observateurs peuvent s'abonner ou se désabonner à tout moment, ce qui rend le système flexible et faiblement couplé - le sujet n'a pas besoin de connaître les types spécifiques de ses observateurs.

Défi

Facile

Construisons un système d'alerte de prix d'actions en utilisant le pattern Observer ! Vous allez créer un système où un téléscripteur d'actions (stock ticker) informe plusieurs investisseurs chaque fois que le prix change, permettant à chaque investisseur de réagir aux mises à jour du marché à sa manière.

Vous organiserez votre code en deux fichiers :

stock_system.dart : Créez votre système d'observateur ici :
- Une classe abstraite Investor avec une méthode void onPriceChange(String stockName, double price)
- Une classe DayTrader qui implémente Investor. Elle possède un champ name et sa méthode onPriceChange affiche : [name] sees [stockName] at $[price] - Making quick trade!
- Une classe LongTermInvestor qui implémente Investor. Elle possède un champ name et sa méthode onPriceChange affiche : [name] notes [stockName] at $[price] - Holding steady.
- Une classe StockTicker (le sujet) avec :
  - Un champ String stockName
  - Une liste privée pour stocker les investisseurs abonnés
  - Une méthode subscribe(Investor investor) pour ajouter un investisseur
  - Une méthode unsubscribe(Investor investor) pour supprimer un investisseur
  - Une méthode updatePrice(double newPrice) qui notifie tous les investisseurs abonnés du nouveau prix
main.dart : Importez votre système d'actions et démontrez le pattern Observer en action :
- Créez un StockTicker pour une action nommée DART
- Créez un DayTrader nommé Alice et un LongTermInvestor nommé Bob
- Abonnez les deux investisseurs au téléscripteur
- Mettez à jour le prix à 150.50 (les deux investisseurs doivent être notifiés)
- Affichez une ligne vide
- Désabonnez Alice du téléscripteur
- Mettez à jour le prix à 155.75 (seul Bob doit être notifié maintenant)

Cela démontre comment le pattern Observer crée un système lâchement couplé - le StockTicker n'a pas besoin de savoir s'il notifie des traders de jour ou des investisseurs à long terme, il appelle simplement onPriceChange sur quiconque est abonné !

Sortie attendue :

Alice sees DART at $150.5 - Making quick trade!
Bob notes DART at $150.5 - Holding steady.

Bob notes DART at $155.75 - Holding steady.

Aide-mémoire

Le pattern Observer (ou Observateur) établit une relation un-à-plusieurs où un sujet notifie tous ses observateurs lorsque son état change.

Le pattern comporte deux rôles clés :

Sujet (Subject) : Maintient une liste d'observateurs et les informe des changements
Observateur (Observer) : S'inscrit auprès du sujet et réagit aux mises à jour

Implémentation de base :

abstract class Observer {
  void update(String message);
}

class Subject {
  final List<Observer> _observers = [];

  void subscribe(Observer observer) {
    _observers.add(observer);
  }

  void unsubscribe(Observer observer) {
    _observers.remove(observer);
  }

  void notifyObservers(String data) {
    for (var observer in _observers) {
      observer.update(data);
    }
  }
}

class ConcreteObserver implements Observer {
  final String name;
  ConcreteObserver(this.name);

  @override
  void update(String message) {
    print('$name received: $message');
  }
}

Principaux avantages :

Couplage faible entre le sujet et les observateurs
Les observateurs peuvent s'abonner/se désabonner dynamiquement
Le sujet n'a pas besoin de connaître les types spécifiques d'observateurs

Essayez vous-même

import 'stock_system.dart';

void main() {
  // TODO: Créer un StockTicker pour une action nommée 'DART'
  
  // TODO: Créer un DayTrader nommé 'Alice'
  
  // TODO: Créer un LongTermInvestor nommé 'Bob'
  
  // TODO: Abonner les deux investisseurs au ticker
  
  // TODO: Mettre à jour le prix à 150.50 (les deux investisseurs doivent être notifiés)
  
  // TODO: Afficher une ligne vide
  
  // TODO: Désabonner Alice du ticker
  
  // TODO: Mettre à jour le prix à 155.75 (seul Bob doit être notifié maintenant)
}