Beobachter (Entwurfsmuster) - LinkFang.de





Beobachter (Entwurfsmuster)


Das Beobachter-Muster (englisch observer pattern, auch listener pattern) ist ein Entwurfsmuster aus dem Bereich der Softwareentwicklung. Es gehört zur Kategorie der Verhaltensmuster (englisch behavioural patterns) und dient der Weitergabe von Änderungen an einem Objekt an von diesem Objekt abhängige Strukturen.[1] Das Muster ist eines der sogenannten GoF-Muster (Gang of Four; siehe Viererbande).

Neben publish-subscribe erfährt das Beobachter-Muster mit dem Signal-Slot-Konzept eine weitere Ausprägung.

Verwendung

Allgemeine Anwendungssituationen

Allgemein finden Beobachter-Muster Anwendung, wenn eine Abstraktion mehrere Aspekte hat, die von einem anderen Aspekt derselben Abstraktion abhängen, die Änderung eines Objekts Änderungen an anderen Objekten nach sich zieht oder ein Objekt andere Objekte benachrichtigen soll, ohne diese im Detail zu kennen.

Anwendungsbeispiel

Eine oder auch mehrere Komponenten stellen den Zustand eines Objektes grafisch dar. Sie kennen die gesamte Schnittstelle dieses Objektes. Ändert sich der Zustand des Objektes, müssen die Komponenten darüber informiert werden. Andererseits soll das Objekt aber von den Komponenten unabhängig bleiben, ihre Schnittstelle also nicht kennen.

Beispiel: Messergebnisse werden gleichzeitig in einem Balkendiagramm, einem Liniendiagramm und einer Tabelle dargestellt. Messwerte ändern sich permanent. Die Komponenten der Diagramme sollen diese Änderungen permanent darstellen, das gemessene Objekt soll dabei aber keine Kenntnis über die Struktur dieser Komponenten besitzen.

Lösung

Das beobachtete Objekt bietet einen Mechanismus, um Beobachter an- und abzumelden und diese über Änderungen zu informieren. Es kennt alle seine Beobachter nur über die (überschaubare) Schnittstelle Beobachter. Änderungen werden völlig unspezifisch zwischen dem beobachteten Objekt und jedem angemeldeten Beobachter ausgetauscht. Dieses braucht also die weitere Struktur dieser Komponenten nicht zu kennen. Die Beobachter implementieren ihrerseits eine (spezifische) Methode, um auf die Änderung zu reagieren.

Man unterscheidet drei verschiedene Arten, das Beobachter-Muster umzusetzen:[2]

  • Push Notification: Jedes Mal wenn sich das beobachtete Objekt ändert, werden alle Beobachter benachrichtigt. Es werden jedoch keine Daten mitgeschickt, weshalb diese Form besonders schnell ist.
  • Push-Update Notification: Jedes Mal wenn sich das beobachtete Objekt ändert, werden alle Beobachter benachrichtigt. Zusätzlich kann das beobachtete Objekt die Update-Daten, die die Änderungen beschreiben, an die Beobachter weiterleiten.
  • Pull Notification: Der Beobachter fragt selbstständig nach dem Zustand des beobachteten Objekts nach.

UML-Diagramm

Das folgende Klassendiagramm zeigt die am Entwurfsmuster beteiligten Rollen. Das Subjekt kann mehrere Beobachter haben, die unterschiedlichen konkreten Klassen angehören können.

Akteure

Ein Subjekt (beobachtbares Objekt, auf englisch publisher, also „Veröffentlicher“, genannt) hat eine Liste von Beobachtern, ohne deren konkrete Typen zu kennen. Es bietet eine Schnittstelle zur An- und Abmeldung von Beobachtern und eine Schnittstelle zur Benachrichtigung von Beobachtern über Änderungen an. Ein konkretes Subjekt (konkretes, beobachtbares Objekt) speichert den relevanten Zustand und benachrichtigt alle Beobachter bei Zustandsänderungen über deren Aktualisierungsschnittstelle. Es verfügt über eine Schnittstelle zur Erfragung des aktuellen Zustands.

Die Beobachter (auf englisch auch subscriber, also „Abonnent“, genannt) definieren eine Aktualisierungsschnittstelle.

Konkrete Beobachter verwalten die Referenz auf ein konkretes Subjekt, dessen Zustand sie beobachten und speichern und dessen Zustand konsistent ist. Sie implementieren eine Aktualisierungsschnittstelle unter Verwendung der Abfrageschnittstelle des konkreten Subjekts.

Vorteile

Subjekte und Beobachter können unabhängig variiert werden. Subjekt und Beobachter sind auf abstrakte und minimale Art lose gekoppelt. Das beobachtete Objekt braucht keine Kenntnis über die Struktur seiner Beobachter zu besitzen, sondern kennt diese nur über die Beobachter-Schnittstelle. Ein abhängiges Objekt erhält die Änderungen automatisch. Es werden auch Multicasts unterstützt.

Nachteile

Änderungen am Subjekt führen bei großer Beobachteranzahl zu hohen Änderungskosten. Einerseits informiert das Subjekt jeden Beobachter, auch wenn dieser die Änderungsinformation nicht benötigt. Zusätzlich können die Änderungen weitere Änderungen nach sich ziehen und so einen unerwartet hohen Aufwand haben.

Der Mechanismus liefert keine Information darüber, was sich geändert hat. Die daraus resultierende Unabhängigkeit der Komponenten kann sich allerdings auch als Vorteil herausstellen.

Ruft ein Beobachter während der Bearbeitung einer gemeldeten Änderung wiederum Änderungsmethoden des Subjektes auf, kann es zu Endlosschleifen kommen.

Beispiel in C++

#include <iostream>
#include <memory>
 
class AbstrSubjekt {
public:
    void Beobachter_registrieren(std::shared_ptr<AbstrBeobachter> beobachter) = 0;
    void Beobachter_deregistrieren(std::shared_ptr<AbstrBeobachter> beobachter) = 0;
    void Beobachter_informieren() = 0;
};
 
class KonkretesSubjekt : public AbstrSubjekt {
    std::vector<std::shared_ptr<AbstrBeobachter>> _beobachter;
    int   _wert;
public:
    KonkretesSubjekt() : _wert(0) {}
 
    void Beobachter_registrieren(std::shared_ptr<AbstrBeobachter> beobachter) {
        _beobachter.add(beobachter);
    }
    void Beobachter_deregistrieren(std::shared_ptr<AbstrBeobachter> beobachter) {
        auto pos = std::find_if(_beobachter.begin(), _beobachter.end(), [&](std::shared_ptr<AbstrBeobachter> const& b) { return *b == *beobachter; });
        if (pos != _beobachter.end()) _beobachter.erase(pos);
    }
    void Beobachter_informieren() {
        for (auto& beo : _beobachter) {
            beo->setzen(_wert);
        }
    }
 
    void WertSetzen(int wert) {
        _wert = wert;
        Beobachter_informieren();
    }
};
 
class AbstrBeobachter {
    void setzen(int wert) = 0;
};
 
class KonkreterBeobachterA : public AbstrBeobachter {
public:
    void setzen(int wert) {
        std::out << "Dies ist Beobachter A mit dem Wert " << wert << "\n";
    }
};
 
class KonkreterBeobachterB : public AbstrBeobachter {
public:
    void setzen(int wert) {
        std::out << "Dies ist Beobachter B mit dem Wert " << wert << "\n";
    }
};
 
int main() {
    std::shared_ptr<AbstrSubjekt>    konkretesSubj(new KonkretesSubjekt());
    std::shared_ptr<AbstrBeobachter> konkreterBeoA(new KonkreterBeobachterA());
    std::shared_ptr<AbstrBeobachter> konkreterBeoB(new KonkreterBeobachterB());
 
    konkretesSubj->Beobachter_registrieren(konkreterBeoA);
    konkretesSubj->Beobachter_registrieren(konkreterBeoB);
 
    konkretesSubj->WertSetzen(1);
    konkretesSubj->Beobachter_deregistrieren(konkreterBeoA);
    konkretesSubj->WertSetzen(2);
    konkretesSubj->Beobachter_deregistrieren(konkreterBeoB);
}

Ausgabe:

Dies ist Beobachter A mit dem Wert 1
Dies ist Beobachter B mit dem Wert 1
Dies ist Beobachter B mit dem Wert 2

Sonstiges

Bei der gerade durchgeführten Beobachtung eines Objektzustands kann es notwendig sein, einen konsistenten Subjektzustand zu garantieren. Dies kann durch synchrone Aufrufe der Notifizierungsmethode des Beobachters sichergestellt werden. (In einem Multithreading-System sind eventuell Synchronisationsmechanismen wie Sperren oder Warteschlangen zur Benachrichtigung der Beobachter erforderlich.)

Manche Programmiersprachen (wie beispielsweise Java) bieten eine Standard-Implementierung zum Beobachter-Muster an.[3] Allerdings führt eine solche Implementierung bei einer Programmiersprache, die keine multiple Vererbung von Klassen unterstützt, dazu, dass das Subjekt keine weiteren Klassen beerben kann, da es schon die Implementierung des Observer-Patterns erbt.

Verwandte Entwurfsmuster

Ein Vermittler kann zwischen Subjekten und Beobachtern vermitteln.

Weblinks

 Wikibooks: Muster: Observer – Lern- und Lehrmaterialien

Einzelnachweise

  1. Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides: Entwurfsmuster. 5. Auflage. Addison-Wesley, 1996, ISBN 3-8273-1862-9, S. 287.
  2. Bernd Brügge, Allen H. Dutoit: Objektorientierte Softwaretechnik: mit UML, Entwurfsmustern und Java. 2., überarbeitete Auflage. Addison-Wesley Verlag, 2004, ISBN 3-8273-7082-5.
  3. Observer Interface Javadoc. docs.oracle.com, abgerufen 3. Juni 2015

Kategorien: Verhaltensmuster (Software) | Viererbande-Entwurfsmuster

Quelle: Wikipedia - http://de.wikipedia.org/wiki/Beobachter (Entwurfsmuster) (Vollständige Liste der Autoren des Textes [Versionsgeschichte])    Lizenz: CC-by-sa-3.0

Änderungen: Alle Bilder mit den meisten Bildunterschriften wurden entfernt. Ebenso alle zu nicht-existierenden Artikeln/Kategorien gehenden internen Wikipedia-Links (Bsp. Portal-Links, Redlinks, Bearbeiten-Links). Entfernung von Navigationsframes, Geo & Normdaten, Mediadateien, gesprochene Versionen, z.T. ID&Class-Namen, Style von Div-Containern, Metadaten, Vorlagen, wie lesenwerte Artikel. Ansonsten sind keine Inhaltsänderungen vorgenommen worden. Weiterhin kann es durch die maschinelle Bearbeitung des Inhalts zu Fehlern gerade in der Darstellung kommen. Darum würden wir jeden Besucher unserer Seite darum bitten uns diese Fehler über den Support mittels einer Nachricht mit Link zu melden. Vielen Dank!

Stand der Informationen: August 201& - Wichtiger Hinweis: Da die Inhalte maschinell von Wikipedia übernommen wurden, ist eine manuelle Überprüfung nicht möglich. Somit garantiert LinkFang.de nicht die Richtigkeit und Aktualität der übernommenen Inhalte. Sollten die Informationen mittlerweile fehlerhaft sein, bitten wir Sie darum uns per Support oder E-Mail zu kontaktieren. Wir werden uns dann innerhalb von spätestens 10 Tagen um Ihr Anliegen kümmern. Auch ohne Anliegen erfolgt mindestens alle drei Monate ein Update der gesamten Inhalte.