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

Neben publish-subscribe (kurz pub/sub) erfährt das Beobachter-Muster mit dem Signal-Slot-Konzept eine weitere Ausprägung.

Verwendung

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.

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. Außerdem 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.

Typischerweise ist im Quellcode des Subjektes nicht erkennbar, welche Beobachter genau informiert werden. Es wird dadurch häufig schwer nachvollziehbar, welche Zustände das Programm bei einem Ereignis insgesamt durchläuft.

Beispiel in C++

Diese C++14 Implementierung basiert auf der vor C++98 Implementierung im Buch Entwurfsmuster.

#include <iostream>
#include <list>
#include <memory>

class Beobachter; // Beobachter Deklaration

class Subjekt {
public:
  Subjekt() :beobachtern() {}
  // kennt seine Beobachter. Eine beliebige Anzahl von Beobachtern kann ein Subjekt beobachten.
  void benachrichtige();
  // bietet eine Schnittstelle zum An- und Abmelden von Beobachtern.
  void meldeAn(Beobachter* beobachter) {
    beobachtern.push_front(beobachter);
  }
  void meldeAb(Beobachter* beobachter) {
    beobachtern.remove(beobachter);
  }
private:
  std::list<Beobachter*> beobachtern; // braucht Beobachter Deklaration
};

class Beobachter {  // Beobachter Definition
public:
  // definiert eine Aktualisierungsschnittstelle für Objekte, die über Änderungen eines Subjekts benachrichtigt werden sollen.
  virtual void aktualisiere(Subjekt*) = 0;
  virtual ~Beobachter() = default;
};

void Subjekt::benachrichtige() {
  for (const auto& x:beobachtern) {
    x->aktualisiere(this);  // braucht Beobachter Definition
  }
}

class KonkretesSubjekt: public Subjekt {
public:
  KonkretesSubjekt() :subjektZustand(0) {}
  int getZustand() {
    return subjektZustand;
  }
  void setZustand(int subjektZustand_) {
    subjektZustand = subjektZustand_;
    std::cout << "this=" << this << " subjektZustand=" << subjektZustand << '\n';
    // benachrichtigt seine Beobachter, wenn sich sein Zustand ändert.
    benachrichtige();
  }
private:
  // speichert den für KonkreterBeobachter relevanten Zustand.
  int subjektZustand;
};

class KonkreterBeobachter: public Beobachter {
public:
  KonkreterBeobachter(std::shared_ptr<KonkretesSubjekt> konkretesSubjekt_)
    :beobachterZustand(0),
     konkretesSubjekt(konkretesSubjekt_.get()) {
    konkretesSubjekt->meldeAn(this);
  }
  KonkreterBeobachter(const KonkreterBeobachter&) = delete; // Dreierregel
  KonkreterBeobachter& operator=(const KonkreterBeobachter&) = delete;
  // implementiert die Aktualisierungsschnittstelle der Beobachterklasse, um seinen Zustand mit dem des Subjekts konsistent zu halten.
  void aktualisiere(Subjekt* subjekt) {
    if (subjekt == konkretesSubjekt) {
      beobachterZustand = konkretesSubjekt->getZustand();
      std::cout << "this=" << this << " beobachterZustand=" << beobachterZustand <<
        '\n';
    }
  }
  virtual ~KonkreterBeobachter() {
    konkretesSubjekt->meldeAb(this);
  }
private:
  // speichert den Zustand, der mit dem des Subjekts in Einklang stehen soll.
  int beobachterZustand;
  // verwaltet eine Referenz auf ein KonkretesSubjekt.
  KonkretesSubjekt* konkretesSubjekt;
};

int main() {
  // Dynamic (Heap) Speicher. Smart pointers verhindern Memory Leaks.
  std::shared_ptr<KonkretesSubjekt> ks = std::make_shared<KonkretesSubjekt>();
  std::unique_ptr<KonkreterBeobachter> kb1 =
    std::make_unique<KonkreterBeobachter>(ks);
  std::unique_ptr<KonkreterBeobachter> kb2 =
    std::make_unique<KonkreterBeobachter>(ks);
  ks->setZustand(42);
}

Die Programmausgabe ist ähnlich zu:

this=0xad4e80 subjektZustand=42
this=0xad4ef0 beobachterZustand=42
this=0xad4eb0 beobachterZustand=42

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. 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

• Observer-Muster inkl. Implementierung Java-Implementierung sowohl mit Hilfe der Java API wie auch ohne derselben, Lösungen der Probleme des Observer-Musters mit AOP

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 am 3. Juni 2015.