Description

Le pattern Observer a pour objectif de construire une dépendance entre un sujet et des observateurs de sorte que chaque modification du sujet soit notifiée aux observateurs afin qu’ils puissent mettre à jour leur état.

Exemple

Nous voulons mettre à jour l’affichage d’un catalogue de véhicules en temps réel. Chaque fois que les informations relatives à un véhicule sont modifiées, nous voulons mettre à jour l’affichage de celles-ci. Il peut y avoir plusieurs affichages simultanés.

La solution préconisée par le pattern Observer consiste à établir un lien entre chaque véhicule et ses vues pour que le véhicule puisse leur indiquer de se mettre à jour quand son état interne a été modifié. Cette solution est illustrée à la figure 4-8.1.

Figure 4-8.1 - Le pattern Observer appliqué à l’affichage de véhicules

Le diagramme contient les quatre classes suivantes :

Sujet est la classe abstraite qui introduit tout objet qui notifie d’autres objets des modifications de son état interne.
Véhicule est la sous-classe concrète de Sujet qui décrit les véhicules. Elle gère deux attributs : description et prix.
Observateur est l’interface de tout objet qui a besoin de recevoir des notifications de changement d’état provenant des objets auprès desquels il s’est préalablement inscrit.
VueVéhicule est la sous-classe concrète d’implantation de Observateur dont les instances affichent les informations...

Structure

1. Diagramme de classes

La figure 4-8.3 détaille la structure générique du pattern.

Figure 4-8.3 - Structure du pattern Observer

2. Participants

Les participants au pattern sont les suivants :

Sujet est la classe abstraite qui introduit l’association avec les observateurs ainsi que les méthodes pour ajouter ou retirer des observateurs.
Observateur est l’interface à implanter pour recevoir des notifications (méthode actualise).
SujetConcret (Véhicule) est une classe d’implantation d’un sujet. Un sujet envoie une notification quand son état est modifié.
ObservateurConcret (VueVéhicule) est une classe d’implantation d’un observateur. Celui-ci maintient une référence vers son sujet et implante la méthode actualise. Elle demande à son sujet des informations faisant partie de son état lors des mises à jour par invocation de la méthode getÉtat.

3. Collaborations

Le sujet concret notifie ses observateurs lorsque son état interne est modifié. Lorsqu’un observateur reçoit cette notification, il se met à jour en conséquence. Pour réaliser cette mise à jour, il peut invoquer des méthodes du sujet donnant accès à son état.

Domaines d’application

Le pattern est utilisé dans les cas suivants :

Une modification dans l’état d’un objet engendre des modifications dans d’autres objets qui sont déterminés dynamiquement.
Un objet veut prévenir d’autres objets sans devoir connaître leur type, c’est-à-dire sans être fortement couplé à ceux-ci.
On ne veut pas fusionner deux objets en un seul.

Exemple en Java

Nous reprenons l’exemple de la figure 4-8.1. Le code source de la classe Sujet est donné à la suite. Les observateurs sont gérés à l’aide d’une liste.

import java.util.*; 
public abstract class Sujet 
{ 
  protected List<Observateur> observateurs =  
    new ArrayList<Observateur>(); 
 
  public void ajoute(Observateur observateur) 
  { 
    observateurs.add(observateur); 
  } 
 
  public void retire(Observateur observateur) 
  { 
    observateurs.remove(observateur); 
  } 
 
  public void notifie() 
  { 
    for (Observateur observateur: observateurs) 
      observateur.actualise(); 
  } 
}

Le code source de l’interface Observateur est très simple car il ne contient que la signature de la méthode actualise.

public interface Observateur 
{ 
  void actualise(); 
}

Le code source de la classe Vehicule se trouve à la suite. Elle contient deux attributs et les accesseurs en lecture et écriture pour ces deux attributs. Les deux accesseurs en écriture invoquent la méthode...

Le pattern Observer