Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Wzorzec Observer i Pub/Sub

7 min czytania ·
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ć?

CechaObserverPub/Sub
PowiązanieSubject zna obserwatorówNadawca i odbiorca się nie znają
KomunikacjaBezpośredniaPrzez kanał/temat
Użyj gdyJeden obiekt powiadamia kilkuWiele obiektów komunikuje się luźno
PrzykładFormularz powiadamia walidatoryMikroserwisy 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ą:"

  1. Observer - obiekt (Subject) powiadamia zarejestrowanych obserwatorów o zmianach
  2. EventEmitter - implementacja Observera z metodami on(), emit(), off()
  3. Pub/Sub - luźniejsze powiązanie przez kanały/tematy, nadawca nie zna odbiorców
  4. 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. 1. Jaka jest główna zaleta wzorca Observer w porównaniu z bezpośrednim wywoływaniem funkcji?

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

  1. PytanieWzorzec Observer - podstawy
  2. PytanieMetody EventEmitter
  3. PytaniePub/Sub vs Observer
  4. Zadanie z kodemPraktyka: EventEmitter i Pub/Sub
  5. Kliknij w kolejnościKolejność operacji we wzorcu Observer

Przydatne artykuły