Vous êtes sur la page 1sur 12

Le patron Observateur

• Intention :
– Définir une dépendance un<->plusieurs entre des
objets de façon à que lorsqu’un objet change
d’état, tout ses dépendants soient notifiés et mis à
jour automatiquement.
• Aussi connu sous le nom de
– Dépendants ou de Publication/Inscription
• Motivation :
– La nécessité de maintenir la consistance entre des objets
reliés sans pour autant trop coupler les classes.
Le patron observateur
• Motivation :
trois observateurs

sujet observé
Le patron observateur
• Applicabilité :
Utiliser ce patron dans les situations suivantes :
– Quand une abstraction a deux aspect, l’un
dépendant de l’autre. Les encapsuler dans des
objets séparés permet de les varier et de les
réutiliser indépendamment l’un de l’autre
– Quand le changement d’un objet demande le
changement d’autres objets
– Quand un objet doit notifier d’autres objets sans
faire d’hypothèse sur la nature de ces autres
objets.
Le patron observateur
• Structure :
Structure du patron
observateur

• Participants :
– Le sujet :
• Garde une trace de ses observateurs
• Propose une interface pour ajouter ou
enlever des observateurs
– L’observateur :
• Définit une interface pour la notification
de mises à jour
Structure du patron
observateur
– Le sujet concrêt :
• C’est l’objet observé
• Enregistre son état intéressant les observateurs
• Envoie une notification à ces observateurs quand il
change d’état
– L’observateur concrêt :
• Il observe l’objet cconrêt
• Il stocke l’état qui doit rester consistent avec celui de
l’objet observé
• Il implémente l’interface de mise à jour permettant à son
état de rester consistent avec celui de l’objet observé
Diagramme temporel pour le
patron observateur
• Collaboration
Le patron observateur
• Conséquences :
Bénéfices :
– Couplage minimal entre le sujet et l’observateur
– On peut réutiliser les sujets sans leurs
observateurs et vice-versa
– Tout ce que le sujet connaît c’est la liste de ses
observateurs
– Le sujet n’a pas besoin de connaître la classe
concrête de ses observateurs
– Des observateurs peuvent être ajoutés/enlevés
dynamiquement (à n’importe quel moment)
Ecriture en java du patron de conception
Observateur

• On pourrait implémenter ce patron “from scratch” en Java


• Mais Java fournit les classes Observable/Observer comme support pour
coder ce patron.

• La classe java.util.Observable est la classe de base pour coder le sujet. Toute


classe qui veut être observée étend cette classe de base.
– Elle fournit les méthodes pour ajouter / oter des observateurs
– Elle fournit des méthodes pour notifier les observateurs des changements
– Une sous-classe a juste besoin d’assurer que les observateurs sont
notifiés dans les méthodes changeant l’état de l’objet observé.
– Utilise un Vector pour stocker les références aux observateurs.

•L’interface java.util.Observer est l’interface qui doit être implémentée par les
classes qui veulent être des observateurs.
La classe java.util.Observable
• public Observable()
– Construit un objet observable avec initialement 0 observateurs

• public synchronized void addObserver(Observer obs)


– Ajoute un observateur à l’ensemble des observateurs de cet objet

• public synchronized void removeObserver(Observer obs)


– Ote un observateur de l’ensemble des observateurs de cet objet

• protected synchronized void setChanged()


• Indique que cet objet a changé

• protected synchronized void clearChanged()


– Indique que cet objet n’a plus changé, ou qu’il a déjà notifié ses observateurs
des derniers changements. Cette méthode est appelée automatiquement par
notifyObservers()
La classe java.util.Observable (suite)
• public synchronized boolean hasChanged ()
– Test si l’objet a changé. Renvoie vrai si setChanged() a été appelé plus
récemment que clearChanged() sur cet objet. Faux sinon.

• public void notifyObservers(Object arg)


– Si l’objet a changé, comme indiqué par la méthode hasChanged(), alors
notifie tous les observateurs et ensuite appel clearChanged(). Chaque
observateur reçoit une demande d’exécution de sa méthode update() avec
deux arguments : l’objet observable qui a changé, et l’argument arg. Ce
dernier peut être utilisé pour indiquer quel attribut de l’objet observé a
changé.

• public void notifyObservers()


– Idem que ci-dessus, mais le paramètre arg est positionné à null. C’est-à-dire
que l’observateur ne reçoit aucune information sur ce qui a changé dans
l’objet observé.
L’interface java.util.Observer
• Public abstract void update(Observable o, Object arg)
– Cette méthode est appelée à chaque fois que l’état de l’objet
observé est changé. Une application appelle la méthode
notifyObservers de l’objet observé pour permettre à tous ses
observateurs d’être notifiés du changement