Observer-Pattern: Ereignisbenachrichtigung
Implementieren Sie Observer, um Ereigniserzeuger und -verbraucher in einem System für Aktienkurse zu entkoppeln.
Observer-Pattern: Ereignisbenachrichtigung ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Zweck des Observer-Musters
Das Observer-Muster (auch Publish-Subscribe genannt) definiert eine Eins-zu-viele-Abhängigkeit: Wenn sich der Zustand des Subjekts ändert, werden alle registrierten Beobachter automatisch benachrichtigt.
Schnittstellen von Subjekt und Beobachter
Das Subjekt verwaltet eine Liste von Beobachtern und benachrichtigt sie. Beobachter implementieren eine update-Methode, um auf Ereignisse zu reagieren.
public interface Observer {
void update(String event, Object data);
}
public interface Subject {
void addObserver(Observer o);
void removeObserver(Observer o);
void notifyObservers(String event, Object data);
}Konkretes Subjekt: Aktienticker
Das Subjekt enthält den Zustand und ruft notifyObservers auf, sobald sich der Zustand ändert. Es verwaltet die Beobachterliste.
public class StockTicker implements Subject {
private final List<Observer> observers = new ArrayList<>();
private double price;
public void addObserver(Observer o) { observers.add(o); }
public void removeObserver(Observer o) { observers.remove(o); }
public void setPrice(double p) {
this.price = p;
notifyObservers("PRICE_CHANGED", p);
}
public void notifyObservers(String ev, Object data) {
for (Observer o : observers) o.update(ev, data);
}
}Konkrete Beobachter
Jeder Beobachter reagiert anders auf dieselbe Benachrichtigung. Fügen Sie zur Laufzeit Beobachter hinzu, ohne das Subjekt zu ändern.
public class AlertSystem implements Observer {
public void update(String ev, Object data) {
if ((double) data < 100) System.out.println("ALERT: Low price!");
}
}
public class Logger implements Observer {
public void update(String ev, Object data) {
System.out.println("LOG: " + ev + " = " + data);
}
}Beobachter verbinden
Registrieren Sie Beobachter beim Subjekt. Sie reagieren alle, wenn sich das Subjekt ändert. Heben Sie die Registrierung auf, um keine Aktualisierungen mehr zu erhalten.
StockTicker ticker = new StockTicker();
ticker.addObserver(new AlertSystem());
ticker.addObserver(new Logger());
ticker.setPrice(95.5); // both observers notifiedjava.util.Observable – veraltet
Das JDK enthielt java.util.Observable und java.util.Observer, aber diese sind seit Java 9 veraltet. Implementieren Sie eine eigene Lösung oder verwenden Sie reaktive Bibliotheken wie RxJava oder Project Reactor.
PropertyChangeListener
JavaBeans stellen mit PropertyChangeSupport einen integrierten Beobachtermechanismus für Änderungen an Bean-Eigenschaften bereit, der intensiv in Swing und JavaFX verwendet wird.
public class Model {
private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);
private int value;
public void addPropertyChangeListener(PropertyChangeListener l) { pcs.addPropertyChangeListener(l); }
public void setValue(int v) {
int old = this.value; this.value = v;
pcs.firePropertyChange("value", old, v);
}
}Funktionaler Beobachter mit Consumer
Verwenden Sie Consumer<T> als leichtgewichtigen Beobachter anstelle einer eigenen Schnittstelle – ideal für einfache Event-Callbacks.
List<Consumer<Double>> listeners = new ArrayList<>();
listeners.add(p -> { if (p < 100) System.out.println("Low price"); });
listeners.add(p -> System.out.println("Price: " + p));
double newPrice = 95.5;
listeners.forEach(l -> l.accept(newPrice));Observer im Vergleich zum Event Bus
Ein Event Bus (wie Guava EventBus) entkoppelt Subjekt und Beobachter noch stärker: Das Subjekt veröffentlicht Ereignisse im Bus, ohne zu wissen, wer sie empfängt. Beobachter abonnieren Ereignisse über eine Methodenannotation.
// Guava EventBus example
EventBus bus = new EventBus();
bus.register(new Logger()); // subscribe
bus.post(new PriceEvent(95.5)); // publishThreadsicherheit beim Observer-Muster
Wenn Beobachter von mehreren Threads hinzugefügt oder entfernt werden können, schützen Sie die Liste mit synchronized oder verwenden Sie CopyOnWriteArrayList für Workloads mit vielen Benachrichtigungen.
private final List<Observer> observers = new CopyOnWriteArrayList<>();Speicherlecks vermeiden
Starke Referenzen in der Beobachterliste verhindern die Garbage Collection. Verwenden Sie WeakReference<Observer> oder heben Sie die Registrierung von Beobachtern immer auf, sobald sie nicht mehr benötigt werden.
Observer in realen Frameworks
Springs ApplicationEventPublisher, Android LiveData und JavaFX-Eigenschaften sind auf unterschiedlichen Abstraktionsebenen Implementierungen des Observer-Musters.
Kurze Überprüfung
Was ist der wichtigste Vorteil des Observer-Musters?
Zusammenfassung
Das Observer-Muster definiert eine Eins-zu-viele-Benachrichtigungskette. Implementieren Sie es über Schnittstellen oder funktionale Consumer. Verwenden Sie CopyOnWriteArrayList für Threadsicherheit und heben Sie die Registrierung von Beobachtern immer auf, um Speicherlecks zu verhindern.
Häufig gestellte Fragen
Ist die Lektion „Observer-Pattern: Ereignisbenachrichtigung“ kostenlos?
Ja — der vollständige Text von „Observer-Pattern: Ereignisbenachrichtigung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Observer-Pattern: Ereignisbenachrichtigung“?
Implementieren Sie Observer, um Ereigniserzeuger und -verbraucher in einem System für Aktienkurse zu entkoppeln. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Java Academy zu starten?
Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Observer-Pattern: Ereignisbenachrichtigung“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?
Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Observer-Pattern: Ereignisbenachrichtigung
- Strategy-Pattern: Austauschbare Algorithmen
- Command-Pattern: Aktionen kapseln
- Template Method: Algorithmusgerüste definieren