« Patrons de conception/Observateur » : différence entre les versions

Contenu supprimé Contenu ajouté
m 71 versions depuis w:Observateur (patron de conception) : Patrons de conception/Observateur
+
Ligne 1 :
<noinclude>{{Patrons de conception}}
Le [[patron de conception]] '''observateur'''/'''observable''' est utilisé en [[Programmation informatique |programmation]] pour envoyer un signal à des [[Module (programmation) |modules]] qui jouent le rôle d''''observateur'''. En cas de notification, les '''observateurs''' effectuent alors l'action adéquate en fonction des informations qui parviennent depuis les modules qu'ils observent (les "observables").
{{Patron de conception|Observateur|Observer|Intercepter un évènement pour le traiter}}</noinclude>
 
Le [[../|patron de conception]] '''observateur'''/'''observable''' est utilisé en programmation pour envoyer un signal à des modules qui jouent le rôle d''''observateur'''.
Le [[patron de conception]] '''observateur'''/'''observable''' est utilisé en [[Programmation informatique |programmation]] pour envoyer un signal à des [[Module (programmation) |modules]] qui jouent le rôle d''''observateur'''. En cas de notification, les '''observateurs''' effectuent alors l'action adéquate en fonction des informations qui parviennent depuis les modules qu'ils observent (les "observables").
 
== Utilité ==
 
La notion d''''observateur/observable''' permet de couplerdécoupler des modules de façon à réduire les dépendances aux seuls phénomènes observés.
 
== Utilisation ==
 
Dès que l'on a besoin de gérer des événements, quand une classe déclenche l'exécution d'une ou plusieurs autres.
 
Dans une interface graphique utilisant MVC (Modèle-Vue-Contrôleur), le patron Observateur et utilisé pour associer Modèle et Vue.
 
Par exemple, en Java Swing, le modèle est censé notifier la vue de toute modification en utilisant PropertyChangeNotification.
Les Java beans sont les observés, les éléments de la vue sont les observateurs.
Tout changement dans le modèle est alors visible sur l'interface graphique.
 
== Illustration ==
 
Prenons comme exemple une [[Classe (informatique) |classe]] qui produit des signaux (données observables), visualisée à travers des panneaux ('''observateurs''') d'une interface graphique.
On souhaite que la mise à jour d'un signal modifie le panneau qui l'affiche.
Afin d'éviter l'utilisation de [[Processus léger |thread]]threads ou encore d'inclure la notion de panneau dans les signaux il suffit d'utiliser le [[../|patron de conception]] '''observateur/observable'''.
 
Le principe est que chaque classe observable contient une liste d''''observateurs''', ainsi à l'aide d'une méthode de notification l'ensemble des '''observateurs''' est prévenu.
La classe observée hérite de "Observable" qui gère la liste des '''observateurs'''.
La classe '''Observateur''' est quant à elle purement [[Classe abstraite |abstraite]], la fonction de mise à jour ne pouvant être définie que par une classe spécialisée.
 
== Exemples ==
=== Un exemple en langage Java ===
=== [[Programmation Java|Java]] ===
 
L'exemple ci-dessous montre comment utiliser l'[[Interface de programmation |API]] du langage [[Programmation Java (langage) |Java]] qui propose des interfaces et des objets abstraits liées à ce [[patron de conception]].
 
* On crée une classe qui étend ''java.util.Observable'' et dont la méthode de mise à jour des données ''setData'' lance une notification des observateurs (1) :
 
<source lang="java">
class Signal extends Observable
{
void setData(byte[] lbData){
 
{
void setData(byte[] lbData){
setChanged(); // Positionne son indicateur de changement
notifyObservers(); // (1) notification
}
}
</source>
Ligne 34 ⟶ 50 :
 
<source lang="java">
class JPanelSignal extends JPanel implements Observer
{
void init(Signal lSigAObserver) {
 
{
void init(Signal lSigAObserver) {
lSigAObserver.addObserver(this); // (2) ajout d'observeur
}
void update(Observable observable, Object objectConcerne) {
{
repaint(); // (3) traitement de l'observation
}
}
</source>
 
=== Un exemple en langage[[Programmation C++|C++]] ===
 
Dans cet exemple en [[Programmation C++|C++]], on veut afficher les événements qui se produisent dans une classe Exemple.
 
<source lang="cpp">
Ligne 59 ⟶ 77 :
{
public:
virtual void update(string data) = 0;
};
 
Ligne 65 ⟶ 83 :
{
private:
list<IObserver*> list_observers;
 
public:
void notify(string data)
{
{
// Notifier tout les observers
for ( list<IObserver*>::iterator it = this->list_observers.begin() ;
it != this->list_observers.end() ; ++it)
++it )
(*it)->update(data);
}
}
 
void addObserver(IObserver* observer)
{
{
// Ajouter un observer a la liste
this->list_observers.push_back(observer);
}
}
};
 
class Display : public IObserver
{
void update(string data)
{
{
cout << "EvenementÉvénement : " << data << endl;
}
}
};
 
Ligne 93 ⟶ 113 :
{
public:
void message(string message)
{
{
// Lancer un evenementévénement lors de la receptionréception d'un message
this->notify(message);
}
}
};
 
int main()
{
Display display;
Exemple exemple;
 
// On veut que "Display" soit prevenuprévenu aà chaque receptionréception d'un message dans "Exemple"
exemple.addObserver(&display);
 
// On envoie un message a Exemple
exemple.message("receptionréception d'un message"); // Sera affiché par Display
 
return (0);
}
</source>
 
=== Un[[Programmation exemple en langageC sharp|C#]] ===
 
Tout comme [[Iterateur (patron de conception)../Itérateur|IterateurItérateur]], Observateur est implémenté en [[Programmation C sharp|C#]] par l'intermédiaire du mot clé event.
La syntaxe a été simplifiée pour l'abonnement ou appel d'une méthode sur levée d'un événement.
Un événement possède une signature : le type de la méthode que doit lever l'évènement.
Dans cet exemple c'est EventHandler.
<source lang="csharp">event EventHandler observable; </source>
Ligne 124 ⟶ 146 :
<source lang="csharp">
using System;
 
///<summary> un observateur </summary>
class Kevin
{
public void Reception(object sender, EventArgs e) {
{
Console.WriteLine("Kevin a reçu : {1} de : {0}", sender.ToString(), e.ToString());
}
}
 
class Program {
{
///<summary> la liste d'abonnés </summary>
static event EventHandler observable;
 
static void Main() {
{
var kevin = new Kevin();
 
// enregistrement de Kevin dans la liste d'abonnés
observable += new EventHandler(kevin.Reception);
 
// si la liste n'est pas vide, prévenir les abonnés
Ligne 145 ⟶ 173 :
}
}
 
/// <summary> que du fonctionnel </summary>
class BeerEventArgs : EventArgs
{
public uint Bottles;
public override string ToString() {
{
return string.Format("{0} bottle{1}",
(Bottles > 0) ? Bottles.ToString() : "no more",
Ligne 155 ⟶ 186 :
}
</source>
 
{{Portail |Informatique}}
 
[[Catégorie:Patron de conception]]
 
[[bg:Наблюдател (шаблон)]]
[[ca:Patró observador]]
[[de:Observer (Entwurfsmuster)]]
[[en:Observer pattern]]
[[es:Observer (patrón de diseño)]]
[[it:Observer pattern]]
[[ja:Observer パターン]]
[[ko:옵저버 패턴]]
[[nl:Observer]]
[[pl:Obserwator (wzorzec projektowy)]]
[[pt:Observer]]
[[ru:Наблюдатель (шаблон проектирования)]]
[[th:อ็อบเซิร์ฟเวอร์แพตเทิร์น]]
[[zh:观察者模式]]