Observateur/Observé

Observateur (Observer, Dependents ou Publish-Subscribe)

OBJECTIFS :

Prévenir des objets observateurs, enregistrés auprès d'un objet observé, d'un événement.

RAISONS DE L'UTILISER :

Un objet doit connaitre les changements d'état d'un autre objet. L'objet doit être informé immédiatement.

Cela peut être le cas d'un tableau affichant des statistiques. Si une nouvelle donnée est entrée, les statistiques sont recalculées. Le tableau doit être informé du changement, afin qu'il soit rafraîchi.

L'objet devant connaître le changement (le tableau) est un observateur. Il s'enregistre en tant que tel auprès de l'objet dont l'état change. L'objet dont l'état change (les statistiques) est un "observe". Il informe ses observateurs en cas d'événement.

RESULTAT :

Le Design Pattern permet d'isoler un algorithme traitant un événement.

RESPONSABILITES :

  • Observe : est l'interface de l'objet à observer. Il possède une liste d'objets Observateur. Il fournit des méthodes pour ajouter ou supprimer des objets Observateur à la liste. Il fournit également un méthode pour avertir les objets Observateur.
  • ConcreteObserve : est l'implémentation de l'objet à observer. Lorsqu'une valeur est modifiée, la méthode notifier() de la classe Observe est appelée.
  • Observateur : définit l'interface de l'observateur. Il déclare la/les méthode(s) que l'objet Observe appelle en cas d'événements.
  • ConcreteObservateurA et ConcreteObservateurB : sont des sous-classes concrètes de Observateur. Ils implémentent des comportements de mise à jour en cas d'événements.
  • La partie cliente indique à l'objet Observe les objets Observateur qu'il avertira.
IMPLEMENTATION JAVA :
Observe.java
/**
* Interface d'objet observé
*/
public class Observe {

// Liste des observateurs
private List<Observateur> listeObservateurs =
new LinkedList<Observateur>();

/**
* Ajouter un observateur de la liste
* @param pObservateur
*/
public void ajouterObs(Observateur pObservateur) {
listeObservateurs.add(pObservateur);
}

/**
* Supprimer un observateur de la liste
* @param pObservateur
*/
public void supprimerObs(Observateur pObservateur) {
listeObservateurs.remove(pObservateur);
}

/**
* Notifier à tous les observateurs de la liste
* que l'objet à été mis à jour.
*/
protected void notifier() {
for(Observateur lObservateur : listeObservateurs) {
lObservateur.miseAJour();
}
}
}
ConcreteObserve.java
/**
* Implémentation d'un objet observé
*/
public class ConcreteObserve extends Observe {

int valeur = 0;

/**
* Modifie une valeur de l'objet
* et notifie la nouvelle valeur
* @param pValeur
*/
public void setValeur(int pValeur) {
valeur = pValeur;
notifier();
}

/**
* Retourne la valeur de l'objet
* @return La valeur
*/
public int getValeur() {
return valeur;
}
}
Observateur.java
/**
* Définit l'inteface d'un observateur
*/
public interface Observateur {

/**
* Méthode appelée par l'objet observé
* pour notifier une mise à jour
*/
public void miseAJour();
}
ConcreteObservateurA.java
/**
* Sous-classe concrète de "Observateur"
*/
public class ConcreteObservateurA implements Observateur {

private int valeur = 0;
private ConcreteObserve observe;

/**
* Fixe l'objet observé
* @param pObserve
*/
public void setObserve(ConcreteObserve pObserve) {
observe = pObserve;
}

/**
* Méthode appelée par l'objet observé
* pour notifier une mise à jour
*/
public void miseAJour() {
valeur = observe.getValeur();
}

/**
* Affiche la valeur
*/
public void afficher() {
System.out.println("ConcreteObservateurA contient " + valeur);
}
}
ConcreteObservateurB.java
/**
* Sous-classe concrète de "Observateur"
*/
public class ConcreteObservateurB implements Observateur {

private int valeur = 0;
private ConcreteObserve observe;

/**
* Fixe l'objet observé
* @param pObserve
*/
public void setObserve(ConcreteObserve pObserve) {
observe = pObserve;
}

/**
* Méthode appelée par l'objet observé
* pour notifier une mise à jour
*/
public void miseAJour() {
valeur = observe.getValeur();
}

/**
* Affiche la valeur
*/
public void afficher() {
System.out.println("ConcreteObservateurB contient " + valeur);
}
}
ObserverPatternMain.java
public class ObserverPatternMain {

public static void main(String[] args) {
// Création de l'objet observé
ConcreteObserve lObserve = new ConcreteObserve();

// Création de 2 observateurs
ConcreteObservateurA lConcreteObservateurA = new ConcreteObservateurA();
ConcreteObservateurB lConcreteObservateurB = new ConcreteObservateurB();

// Ajout des observateurs
// à la liste des observateurs
// de l'objet observé
lObserve.ajouterObs(lConcreteObservateurA);
lObserve.ajouterObs(lConcreteObservateurB);

// Fixe l'objet observé des observateurs
lConcreteObservateurA.setObserve(lObserve);
lConcreteObservateurB.setObserve(lObserve);

// Affiche l'état des deux observateurs
lConcreteObservateurA.afficher();
lConcreteObservateurB.afficher();

// Appel d'un méthode de mise à jour
// de l'objet observé
lObserve.setValeur(4);

// Affiche l'état des deux observateurs
lConcreteObservateurA.afficher();
lConcreteObservateurB.afficher();

// Affichage :
// ConcreteObservateurA contient 0
// ConcreteObservateurB contient 0
// ConcreteObservateurA contient 4
// ConcreteObservateurB contient 4
}
}
Comments