Implémentation du Modèle Observer en Ruby

Le modèle Observer est un patron de conception comportemental qui permet à un objet (appelé sujet) de notifier d'autres objets (appelés observateurs) des changements d'état. Ce modèle est particulièrement utile dans les applications où plusieurs composants doivent réagir à des événements ou à des changements d'état d'un objet. Dans cet article, nous allons explorer comment implémenter le modèle Observer en Ruby de manière simple et efficace.

Qu'est-ce que le Modèle Observer ?

Le modèle Observer est basé sur le principe de la publication et de l'abonnement. Lorsqu'un sujet change d'état, il notifie tous ses observateurs afin qu'ils puissent réagir en conséquence. Cela permet de découpler les composants d'une application, rendant le code plus modulaire et plus facile à maintenir.

Les Composants du Modèle Observer

Le modèle Observer se compose de deux principaux types de composants :

Sujet (Subject) : L'objet qui maintient une liste d'observateurs et notifie ces observateurs des changements d'état.
Observateur (Observer) : L'objet qui s'abonne au sujet pour recevoir des notifications lorsque l'état du sujet change.

Implémentation du Modèle Observer en Ruby

Voyons maintenant comment nous pouvons implémenter le modèle Observer en Ruby. Nous allons créer une classe `Subject` qui gère les observateurs et une classe `Observer` qui réagit aux notifications.

Étape 1 : Création de la classe Subject

La classe `Subject` doit permettre d'ajouter, de supprimer et de notifier les observateurs. Voici comment nous pouvons le faire :

class Subject
  def initialize
    @observers = []
  end

  def add_observer(observer)
    @observers << observer
  end

  def remove_observer(observer)
    @observers.delete(observer)
  end

  def notify_observers
    @observers.each { |observer| observer.update(self) }
  end

  def state_changed
    notify_observers
  end
end

Dans cette classe, nous avons :

initialize : Initialise une liste vide d'observateurs.
add_observer : Ajoute un observateur à la liste.
remove_observer : Supprime un observateur de la liste.
notify_observers : Notifie tous les observateurs en appelant leur méthode update.
state_changed : Méthode qui simule un changement d'état et notifie les observateurs.

Étape 2 : Création de la classe Observer

Maintenant, créons une classe `Observer` qui implémente la méthode `update`. Cette méthode sera appelée lorsque le sujet notifie ses observateurs.

class Observer
  def update(subject)
    puts "L'état du sujet a changé : #{subject.state}"
  end
end

Dans cette classe, nous avons :

update : Méthode qui sera appelée par le sujet pour notifier l'observateur d'un changement d'état.

Étape 3 : Intégration de l'état dans le Sujet

Pour que notre exemple soit plus complet, ajoutons un état au sujet. Nous allons modifier la classe `Subject` pour inclure un attribut d'état et une méthode pour le modifier.

class Subject
  attr_accessor :state

  def initialize
    @observers = []
    @state = nil
  end

  # ... (autres méthodes restent inchangées)

  def change_state(new_state)
    @state = new_state
    state_changed
  end
end

Nous avons ajouté :

attr_accessor :state : Permet d'accéder et de modifier l'état du sujet.
change_state : Méthode pour changer l'état et notifier les observateurs.

Exemple Complet

Voici un exemple complet qui montre comment utiliser nos classes `Subject` et `Observer` :

# Création d'un sujet
subject = Subject.new

# Création d'observateurs
observer1 = Observer.new
observer2 = Observer.new

# Ajout des observateurs au sujet
subject.add_observer(observer1)
subject.add_observer(observer2)

# Changement d'état
subject.change_state("État 1")
subject.change_state("État 2")

Lorsque nous exécutons ce code, nous devrions voir les notifications des observateurs chaque fois que l'état du sujet change :

L'état du sujet a changé : État 1
L'état du sujet a changé : État 1
L'état du sujet a changé : État 2
L'état du sujet a changé : État 2

Conclusion

Le modèle Observer est un excellent moyen de gérer les communications entre différents composants d'une application. En utilisant Ruby, nous avons pu créer une implémentation simple et efficace de ce modèle. Grâce à cette approche, nous pouvons facilement ajouter ou supprimer des observateurs sans affecter le sujet lui-même, ce qui rend notre code plus modulaire et maintenable.

Nous espérons que cet article vous a aidé à comprendre le modèle Observer et comment l'implémenter en Ruby. N'hésitez pas à expérimenter avec votre propre code et à explorer d'autres applications de ce modèle dans vos projets !