Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Wzorzec Observer i Pub/Sub
W tej lekcji7
W centrum kontroli Parku Jurajskiego, Robert Muldoon obserwuje dziesiątki monitorów jednocześnie. "Problem polega na tym," wyjaśnia, "że każdy system - ogrodzenia, kamery, czujniki ruchu - musi natychmiast reagować na zmiany statusu dinozaura. Ale nie mogą ciągle sprawdzać (pollować) stanu bazy danych!" Rozwiązaniem jest wzorzec Observer - mechanizm, w którym obiekty automatycznie powiadamiają zainteresowanych o zmianach.
Problem: Ścisłe powiązanie komponentów
Bez wzorca Observer komponenty muszą się bezpośrednio znać i wywoływać. Funkcja reagująca na ucieczkę staje się wtedy centralą, która ręcznie obdzwania każdy system:
// Problem: system alarmowy zna WSZYSTKIE inne systemy
function onDinosaurEscaped(dinosaur) {
// Musi ręcznie wywołać każdy system
fenceSystem.activateEmergency(dinosaur);
cameraSystem.trackDinosaur(dinosaur);
alarmSystem.soundAlert(dinosaur);
gateSystem.lockAllGates();
evacuationSystem.startEvacuation();
// Co jeśli dodamy nowy system? Trzeba zmodyfikować tę funkcję!
}Każdy nowy system wymaga modyfikacji istniejącego kodu. To łamie zasadę otwarte-zamknięte (Open-Closed Principle), według której kod powinien być otwarty na rozszerzenia, ale zamknięty na modyfikacje.
Wzorzec Observer - podstawy
We wzorcu Observer mamy dwa typy obiektów:
- Subject (Observable) - obiekt, który emituje zdarzenia (powiadamia o zmianach)
- Observer - obiekt, który nasłuchuje na zdarzenia i reaguje
Subject to syrena parku, a obserwatorzy to strażnicy, którzy sami zgłosili, że chcą ją słyszeć. Najprostsza implementacja to EventEmitter, który trzyma listę funkcji zwrotnych dla każdej nazwy zdarzenia:
// Prosty EventEmitter - serce wzorca Observer
class EventEmitter {
constructor() {
this.listeners = {};
}
// Rejestracja obserwatora (subskrypcja)
on(event, callback) {
if (!this.listeners[event]) {
this.listeners[event] = [];
}
this.listeners[event].push(callback);
return this; // Umożliwia chaining
}
// Emisja zdarzenia (powiadomienie obserwatorów)
emit(event, ...args) {
const callbacks = this.listeners[event];
if (callbacks) {
callbacks.forEach(callback => callback(...args));
}
return this;
}
// Usunięcie obserwatora
off(event, callback) {
if (this.listeners[event]) {
this.listeners[event] = this.listeners[event].filter(
cb => cb !== callback
);
}
return this;
}
// Jednorazowa subskrypcja
once(event, callback) {
const wrapper = (...args) => {
callback(...args);
this.off(event, wrapper);
};
this.on(event, wrapper);
return this;
}
}Obiekt listeners to rejestr: nazwa zdarzenia prowadzi do tablicy funkcji. on() dopisuje funkcję, a emit() wywołuje wszystkie synchronicznie, w kolejności rejestracji. off() porównuje funkcje po referencji, więc anonimowej strzałki podanej wprost do on() nie odepniesz. once() owija callback w funkcję, która po pierwszym wywołaniu sama się wyrejestrowuje.
Zastosowanie w Parku Jurajskim
DinosaurMonitor dziedziczy po EventEmitter, więc dostaje on(), emit() i off() za darmo. Sam zajmuje się tylko danymi dinozaurów i ogłaszaniem zmian:
// System monitoringu dinozaurów oparty na EventEmitter
class DinosaurMonitor extends EventEmitter {
constructor() {
super();
this.dinosaurs = new Map();
}
registerDinosaur(id, data) {
this.dinosaurs.set(id, { ...data, status: "contained" });
this.emit("dinosaur:registered", { id, ...data });
}
updateStatus(id, newStatus) {
const dino = this.dinosaurs.get(id);
if (!dino) return;
const oldStatus = dino.status;
dino.status = newStatus;
this.emit("status:changed", { id, name: dino.name, oldStatus, newStatus });
// Emitujemy specjalne zdarzenie dla ucieczki
if (newStatus === "escaped") {
this.emit("dinosaur:escaped", { id, name: dino.name, species: dino.species });
}
}
}Monitor nie wie nic o ogrodzeniach, kamerach ani ewakuacji - wie tylko, że ma ogłosić zdarzenie. Przy ucieczce emituje dwa: ogólne status:changed i specjalne dinosaur:escaped.
Teraz każdy system sam podłącza się do monitora, a my symulujemy ucieczkę T-Reksa:
// Tworzenie systemu
const monitor = new DinosaurMonitor();
// Rejestracja obserwatorów - każdy system sam się podłącza
monitor.on("dinosaur:escaped", (data) => {
console.log(`ALARM OGRODZENIA: ${data.name} uciekł! Aktywuję elektryczne ogrodzenie.`);
});
monitor.on("dinosaur:escaped", (data) => {
console.log(`ALARM KAMERY: Śledzę ${data.name} (${data.species}) na kamerach.`);
});
monitor.on("dinosaur:escaped", (data) => {
console.log(`ALARM EWAKUACJI: Rozpoczynam ewakuację z powodu ucieczki ${data.name}!`);
});
monitor.on("status:changed", (data) => {
console.log(`LOG: ${data.name} zmienił status z "${data.oldStatus}" na "${data.newStatus}"`);
});
// Rejestracja i symulacja
monitor.registerDinosaur("TREX-001", { name: "Rexy", species: "T-Rex" });
monitor.registerDinosaur("RAPTOR-01", { name: "Blue", species: "Velociraptor" });
// Symulacja ucieczki
monitor.updateStatus("TREX-001", "escaped");
// LOG: Rexy zmienił status z "contained" na "escaped"
// ALARM OGRODZENIA: Rexy uciekł! Aktywuję elektryczne ogrodzenie.
// ALARM KAMERY: Śledzę Rexy (T-Rex) na kamerach.
// ALARM EWAKUACJI: Rozpoczynam ewakuację z powodu ucieczki Rexy!Kolejność wydruków odpowiada kolejności emit() w updateStatus(): najpierw log, potem trzy alarmy w kolejności rejestracji. Nowy system, na przykład drony, dopiszesz jednym monitor.on(...), bez dotykania klasy monitora. To właśnie główna zaleta wzorca: mniejsze powiązanie (coupling) między komponentami.
Wzorzec Publish/Subscribe (Pub/Sub)
Pub/Sub to rozszerzenie wzorca Observer, gdzie komunikacja odbywa się przez kanały/tematy (topics) zamiast bezpośrednich referencji. Nadawca publikuje na temat, a odbiorcy subskrybują tematy, nie wiedząc nic o sobie nawzajem:
class PubSub {
constructor() {
this.topics = {};
this.subscriptionId = 0;
}
// Subskrypcja tematu
subscribe(topic, callback) {
if (!this.topics[topic]) {
this.topics[topic] = {};
}
const id = ++this.subscriptionId;
this.topics[topic][id] = callback;
// Zwracamy funkcję do anulowania subskrypcji
return () => {
delete this.topics[topic][id];
};
}
// Publikacja wiadomości
publish(topic, data) {
if (!this.topics[topic]) return;
Object.values(this.topics[topic]).forEach(callback => {
callback(data);
});
}
}Każda subskrypcja dostaje własny numer, a subscribe() zwraca funkcję, która ją anuluje. Nie trzeba więc przechowywać referencji do callbacku, jak przy off().
Centralna szyna parku obsługuje dwa tematy - alerty bezpieczeństwa i harmonogram karmienia:
// Centralny system komunikacji parku
const parkBus = new PubSub();
// Systemy subskrybują tematy, które ich interesują
const unsubFence = parkBus.subscribe("security:alert", (data) => {
console.log(`Ogrodzenie: Otrzymano alert - ${data.message}`);
});
parkBus.subscribe("security:alert", (data) => {
console.log(`Centrum dowodzenia: Alert poziomu ${data.level} - ${data.message}`);
});
parkBus.subscribe("feeding:schedule", (data) => {
console.log(`Kuchnia: Przygotować ${data.food} dla ${data.dinosaur}`);
});
// Publikacja zdarzeń - nadawca nie wie kto nasłuchuje
parkBus.publish("security:alert", {
level: "HIGH",
message: "Wykryto ruch przy ogrodzeniu sektora C"
});
parkBus.publish("feeding:schedule", {
dinosaur: "Rexy",
food: "200kg wołowiny",
time: "14:00"
});
// Anulowanie subskrypcji
unsubFence(); // Ogrodzenie przestaje nasłuchiwaćAlert trafia do ogrodzenia i centrum dowodzenia, a wiadomość o karmieniu tylko do kuchni. Po unsubFence() ogrodzenie przestaje dostawać alerty, a centrum słucha dalej. Nazwy w stylu security:alert to tylko konwencja, która porządkuje tematy w grupy.
Praktyczny przykład: System powiadomień
Oba pomysły można połączyć. ParkNotificationSystem rozszerza EventEmitter o historię i kanał *, który słyszy wszystko:
class ParkNotificationSystem extends EventEmitter {
constructor() {
super();
this.history = [];
}
notify(channel, message, priority = "normal") {
const notification = {
channel,
message,
priority,
timestamp: new Date().toISOString()
};
this.history.push(notification);
this.emit(channel, notification);
this.emit("*", notification); // Wildcard - wszystkie powiadomienia
}
getHistory(channel) {
if (channel) {
return this.history.filter(n => n.channel === channel);
}
return [...this.history];
}
}Metoda notify() emituje każde powiadomienie dwa razy: na kanale docelowym i na kanale *. getHistory() bez argumentu zwraca kopię historii, więc nikt z zewnątrz nie wyczyści jej przypadkiem.
Panel administratora podpina się pod gwiazdkę, a systemy bezpieczeństwa i konserwacji pod własne kanały:
const notifications = new ParkNotificationSystem();
// Panel administratora - nasłuchuje wszystko
notifications.on("*", (n) => {
console.log(`[ADMIN] [${n.priority.toUpperCase()}] ${n.channel}: ${n.message}`);
});
// System bezpieczeństwa - tylko alerty
notifications.on("security", (n) => {
if (n.priority === "critical") {
console.log(`CZERWONY ALARM: ${n.message}`);
}
});
// Logowanie
notifications.on("maintenance", (n) => {
console.log(`Konserwacja: ${n.message}`);
});
// Użycie
notifications.notify("security", "Awaria kamery w sektorze B", "normal");
notifications.notify("security", "T-Rex przerwał ogrodzenie!", "critical");
notifications.notify("maintenance", "Wymiana żarówek w laboratorium", "low");
console.log("Historia alertów:", notifications.getHistory("security"));Panel admina wypisze wszystkie trzy powiadomienia, czerwony alarm pojawi się tylko przy priorytecie critical, a historia alertów zawiera dwa wpisy z kanału security.
Observer vs Pub/Sub - kiedy używać?
| Cecha | Observer | Pub/Sub |
|---|---|---|
| Powiązanie | Subject zna obserwatorów | Nadawca i odbiorca się nie znają |
| Komunikacja | Bezpośrednia | Przez kanał/temat |
| Użyj gdy | Jeden obiekt powiadamia kilku | Wiele obiektów komunikuje się luźno |
| Przykład | Formularz powiadamia walidatory | Mikroserwisy wymieniają wiadomości |
Kluczowa różnica to pośrednik: w Observerze subject sam trzyma listę obserwatorów, a w Pub/Sub strony spotykają się tylko na kanale. Żaden z wzorców nie jest z definicji synchroniczny ani asynchroniczny - nasze implementacje wołają callbacki synchronicznie, a w systemach rozproszonych wiadomości Pub/Sub zwykle płyną asynchronicznie przez brokera.
Podsumowanie
Muldoon podsumowuje: "Wzorzec Observer to jak system alarmowy parku - nie musisz ciągle sprawdzać każdego czujnika. Czujniki same Cię powiadomią:"
- Observer - obiekt (Subject) powiadamia zarejestrowanych obserwatorów o zmianach
- EventEmitter - implementacja Observera z metodami
on(),emit(),off() - Pub/Sub - luźniejsze powiązanie przez kanały/tematy, nadawca nie zna odbiorców
- Odsprzęganie - komponenty nie muszą się bezpośrednio znać, komunikują się przez zdarzenia
Te wzorce są fundamentem wielu bibliotek i frameworków - od Node.js (EventEmitter) przez React (state management) po architektury mikroserwisowe.
W prawdziwym projekcie nie pisz emitera od zera: Node.js ma gotowy EventEmitter w module node:events, a przeglądarka EventTarget z addEventListener(). Obserwatory wbudowane w przeglądarkę, takie jak IntersectionObserver, poznasz jeszcze w tej lokacji. W laboratorium poniżej rozszerzysz PubSub o metodę once().
Pamiętaj: w Observerze to czujniki wołają strażników, a nie strażnicy obchodzą wybiegi z latarką.
Kod do tej lekcji: index.js
// Wzorzec Observer i Pub/Sub
// Park Jurajski - System powiadomien
console.log("=== EVENT EMITTER ===");
// Prosta implementacja EventEmitter
class EventEmitter {
constructor() {
this.listeners = {};
}
on(event, callback) {
if (!this.listeners[event]) {
this.listeners[event] = [];
}
this.listeners[event].push(callback);
return this;
}
emit(event, ...args) {
const callbacks = this.listeners[event];
if (callbacks) {
callbacks.forEach(callback => callback(...args));
}
return this;
}
off(event, callback) {
if (this.listeners[event]) {
this.listeners[event] = this.listeners[event].filter(
cb => cb !== callback
);
}
return this;
}
once(event, callback) {
const wrapper = (...args) => {
callback(...args);
this.off(event, wrapper);
};
this.on(event, wrapper);
return this;
}
}
console.log("\n=== SYSTEM MONITORINGU ===");
// System monitoringu dinozaurow
class DinosaurMonitor extends EventEmitter {
constructor() {
super();
this.dinosaurs = new Map();
}
register(id, data) {
this.dinosaurs.set(id, { ...data, status: "contained" });
this.emit("registered", { id, ...data });
}
updateStatus(id, newStatus) {
const dino = this.dinosaurs.get(id);
if (!dino) return;
const oldStatus = dino.status;
dino.status = newStatus;
this.emit("status:changed", { id, name: dino.name, oldStatus, newStatus });
if (newStatus === "escaped") {
this.emit("dinosaur:escaped", { id, name: dino.name, species: dino.species });
}
}
}
const monitor = new DinosaurMonitor();
// Rejestracja obserwatorow
monitor.on("dinosaur:escaped", (data) => {
console.log(`ALARM: ${data.name} uciekl! Aktywuje ogrodzenie.`);
});
monitor.on("dinosaur:escaped", (data) => {
console.log(`KAMERY: Sledze ${data.name} (${data.species}).`);
});
monitor.on("status:changed", (data) => {
console.log(`LOG: ${data.name}: "${data.oldStatus}" -> "${data.newStatus}"`);
});
monitor.register("TREX-001", { name: "Rexy", species: "T-Rex" });
monitor.register("RAPTOR-01", { name: "Blue", species: "Velociraptor" });
console.log("\n--- Symulacja ucieczki ---");
monitor.updateStatus("TREX-001", "escaped");
console.log("\n=== PUB/SUB ===");
// Wzorzec Publish/Subscribe
class PubSub {
constructor() {
this.topics = {};
this.subId = 0;
}
subscribe(topic, callback) {
if (!this.topics[topic]) this.topics[topic] = {};
const id = ++this.subId;
this.topics[topic][id] = callback;
return () => { delete this.topics[topic][id]; };
}
publish(topic, data) {
if (!this.topics[topic]) return;
Object.values(this.topics[topic]).forEach(cb => cb(data));
}
}
const parkBus = new PubSub();
parkBus.subscribe("security:alert", (data) => {
console.log(`Ogrodzenie: Alert - ${data.message}`);
});
parkBus.subscribe("security:alert", (data) => {
console.log(`Centrum: Poziom ${data.level} - ${data.message}`);
});
const unsubFeeding = parkBus.subscribe("feeding", (data) => {
console.log(`Kuchnia: ${data.food} dla ${data.dinosaur}`);
});
parkBus.publish("security:alert", {
level: "HIGH",
message: "Ruch przy ogrodzeniu sektora C"
});
parkBus.publish("feeding", {
dinosaur: "Rexy",
food: "200kg wolowiny"
});
// Anulowanie subskrypcji
unsubFeeding();
console.log("\nPo anulowaniu subskrypcji feeding:");
parkBus.publish("feeding", { dinosaur: "Blue", food: "50kg miesa" });
// Nic sie nie wyswietli
// TODO: Dodaj metode once() do PubSub
// TODO: Stworz system powiadomien z historia zdarzen
console.log("\n=== Cwiczenie ===");
console.log("Rozszerz PubSub o metode once() - patrz TODO");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Jaka jest główna zaleta wzorca Observer w porównaniu z bezpośrednim wywoływaniem funkcji?
2. Która metoda EventEmitter służy do rejestracji obserwatora (nasłuchiwania zdarzenia)?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Stwórz EventEmitter z metodami on(), emit(), off() i system powiadomień parku.
- Klikanie w kolejności
Ułóż kolejność operacji we wzorcu Observer: