Observer Pattern

Kurz & Gut
Observer-Pattern
von Tim Rademacher
Einführung
Das Observer-Pattern in Java
Design Pattern sind Beschreibungen von
Lösungen für oft vorkommende Software-Design
Probleme. Design Pattern müssen den Kontext,
das Problem und die Lösung darstellen. Sie
können ein Ziel beim Refactoring sein, unflexible
Software wird umorganisiert.
Das Interface Observer wird von Beobachtern
implementiert enthält nur die MethodenDeklaration für die update-Methode.
Die Klasse Observable ist die Superklasse von
Beobachteten. Sie speichert ihre Beobachter in
einem Vector und besitzt Methoden zum
Design Patterns beinhalten Erfahrung von Design hinzufügen, entfernen von Beobachtern.
Experten. Durch ein gemeinsames Design
Innerhalb der notifyObservers-Methode werden
Vokabular wird einfache Kommunikation und
die update-Methoden der Beobachter aufgerufen.
Dokumentation ermöglicht.
Die Änderung des Objekt-Zustands wird nach
außen hin mitgeteilt.
Ein Beispiel, der Vortrag
public class Erzaehler extends Observable {
V
public void erzaehle(String info){
if(countObservers()>0){
setChanged();
notifyObservers(info);
}
}
Vortragender
}
Zuhörer 1
Zuhörer 2
Zuhörer 3
public class Zuhoerer implements Observer {
Zuhörer x
public void update(Observable o,
Object info) {
if(isNeuigkeit(info)){
merken(info);
}
}
Es gibt einen aktiven Erzähler, dieser ist ist
beobachtbar (engl. Observable), er macht keine
Unterscheidung zwischen den Zuhörern und hört
auf, wenn keiner zuhört.
Dazu kommt eine Anzahl passiver Zuhörer oder
Beobachter (engl. Observer), diese sind
interessiert an Informationen des Erzählers und
reagieren auf diese Informationen.
Observable
«interface»
observers
Attach(Observer)
Detach(Observer)
Notify()
Erzaehler
Observer
Update()
for all o in observers {
o->Update()
}
observable
Zuhoerer
subjectState
GetState()
SetState()
oberverState
return subjectState
Update()
observerState = observable->getState()
http://www.se.uni-hannover.de
}
Events beim Java AWT
Bei der Interaktion des Benutzers mit den
Komponenten der grafischen Oberfläche werden
Events/Ereignisse gesendet. Die Applikation
reagiert auf die Events.
Alle Events der grafischen Oberfläche sind eine
Unterklasse der abstrakten Klasse AWTEvent.
Um die Anzahl der Event-Klassen klein zu halten
werden ähnliche Ereignissen zu Gruppen
zusammengefasst.
Ereignisquellen (z.B. JButton) können Events
aussenden. Die EventListener sind an den
Events interessiert und melden sich bei der
EventSource an.
Stand: 11.02.2005
Kurz & Gut: Observer-Pattern
Bei auftretenden Events Informiert die
EventSource alle registrierten EventListener. Es
gibt für jedes Event eine eigene Listener Klasse.
Delegates und Events in .NET
.NET bietet die eigenen Programmkonstrukte
Delegates und Events, zum Benutzen des
Observer-Patterns.
Delegates übermitteln Funktionszeiger von
Ereignis-Konsumenten zu -Produzenten.
Die Delegate-Felder sind zur besseren
Kapselung als event deklariert. Nur die Klasse,
die das Event deklariert, kann es auslösen. Der
Zugriff von außen ist nur mit += oder -= möglich.
Konvention für Event-Handling Delegates:
Kein Rückgabewert (void)
1. Parameter, Sender des Events, Typ object
2. Parameter, Event-Parameter, Subklasse von
System.EventArgs (wird im Beispiel nicht
beachtet)
// Erzähler
public delegate void ChangeEvent(
object src, string s);
von Tim Rademacher
Ein Signal wird mit einem Slot mit Hilfe der
Methode Qobject::connect verbunden.
Der 'Meta Object Compiler', ein zusätzlicher
Preprozessor, extrahiert die Informationen über
Signale und Slots und erzeugt den
Verbindungscode.
//Erzähler
signals: erzaehleInformation(string s);
public void erzaehle(string s){
emit erzaehleInformation(s);
}
//Zuhörer
slots: empfangeInformation(string s);
public void empfangeInformation(string s){
if(isNeuigkeit(s)){
merken(s);
}
}
//Die Verbindung
Qobject::connect(erzaehler,
SIGNAL(erzaehleInformation(string)),
zuhoerer,
SLOT(empfangeInformation(string)));
Qt vs. Java vs. .NET
public event ChangeEvent onChangeEvent;
public void Erzaehle(string information){
if (onChangeEvent != null)
onChangeEvent(this, information);
}
//Zuhörer
instanzErzaehler.onChangeEvent +=
new ChangeEvent(Hoere);
public void Hoere(object src, string
information) {
if(IsNeuigkeit(information)){
Merken(information);
}
}
Signale und Slots in Qt
Qt ist eine C++ Klassenbibliothek und ein GUIToolkit, sie stellt zwei Schlüsselwörter zur
Benutzung des Observer-Patterns bereit.
Das Schlüsselwort signals wird zur Deklaration
der Signale benutzt, die Signale müssen nicht
Implementiert werden. Sie werden mit emit
ausgesendet. Das Schlüsselwort slots dient zur
Deklaration der Slots.
http://www.se.uni-hannover.de
Java
.NET
Qt
Implementierung
EventListener
Signale und
Slots
Delegates
und Events
Codelesbarkeit
+,
-, da nicht
da vertraut vertraut
Flexibilität
(-), wegen
Hierachie
+, da simpel
+, nur
+, nur
Konventionen Parameter
beachten
einhalten
Literatur:
•
Gamma, Helm, Johnson, Vlissides: Design Patterns
•
http://wwwai.wu-wien.ac.at/~hahsler/research/
diplomarbeit/dipl/node5.html
•
http://www.dofactory.com/Patterns/PatternObserver.asp
x
•
http://www.galileocomputing.de/openbook/javainsel2/
java_110014.htm
•
http://www.heise.de/ix/artikel/2002/01/130/
•
http://www.fh-wedel.de/~si/seminare/ws99/
Ausarbeitung/kde/kde4.htm
•
http://www.kde.gr.jp/help/doc/kdevelop/doc/kde_libref/
HTML/event-handling.html
Stand: 11.02.2005