Kurs JavaScript i React · Moduł 15: Wzorce i architektura

Event-Driven Architecture w React - Luźna komunikacja

7 min czytania ·
W tej lekcji8

Panel silnika zmienia prędkość, a dowiedzieć się o tym muszą wyświetlacz na mostku i dziennik pokładowy, leżące w innych gałęziach drzewa komponentów. Propsy przekazywane przez pięć poziomów szybko zamieniają kod w plątaninę kabli. Na statku kosmicznym systemy nie znają się nawzajem: silnik, osłony i nawigacja komunikują się przez centralny system zdarzeń. To właśnie Event-Driven Architecture: wzorzec, w którym komponenty komunikują się przez zdarzenia zamiast bezpośrednich zależności.

Czym jest Event-Driven Architecture?

Event-Driven Architecture (EDA) polega na:

  1. Emitowaniu zdarzeń: komponent ogłasza, że coś się stało
  2. Nasłuchiwaniu zdarzeń: inne komponenty reagują na te ogłoszenia
  3. Luźnym powiązaniu: nadawca nie wie, kto nasłuchuje, a odbiorca nie wie, kto emituje

To klasyczny wzorzec Observer, nazywany też publish/subscribe (pub/sub): nadawca publikuje, subskrybenci reagują.

EventBus - centralna magistrala zdarzeń

Sercem systemu jest EventBus, czyli przekaźnik. Przechowuje mapę, w której każda nazwa zdarzenia ma zbiór czekających na nie funkcji. Metoda on zapisuje słuchacza i od razu zwraca funkcję, która go wypisze:

// Prosty EventBus z nazwanymi zdarzeniami
class EventBus {
  constructor() {
    this.listeners = new Map();
  }

  on(event, callback) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event).add(callback);

    // Zwróć funkcję cleanup
    return () => {
      this.listeners.get(event)?.delete(callback);
    };
  }

Set sprawia, że ta sama funkcja nie zapisze się dwa razy. Zostały dwie metody: emit wywołuje wszystkich słuchaczy danego zdarzenia, a off usuwa jednego ręcznie. Na końcu tworzymy jedną instancję dla całej aplikacji:

  emit(event, payload) {
    if (this.listeners.has(event)) {
      this.listeners.get(event).forEach(cb => cb(payload));
    }
  }

  off(event, callback) {
    this.listeners.get(event)?.delete(callback);
  }
}

// Singleton - jeden bus dla całej aplikacji
const eventBus = new EventBus();

Nazwy w stylu engine:speedChanged to tylko konwencja: przedrostek mówi, który moduł nadaje, a reszta, co się stało. Sam EventBus to zwykła klasa JavaScript, bez React.

Custom hooki do obsługi zdarzeń

Komponent nie powinien sam pamiętać o zapisie i wypisaniu. Ukrywamy to w hooku useEventListener, który zapisuje słuchacza po zamontowaniu i wypisuje go przy odmontowaniu:

// Hook do nasłuchiwania zdarzeń
function useEventListener(event, handler) {
  const savedHandler = useRef(handler);

  useEffect(() => {
    savedHandler.current = handler;
  }, [handler]);

  useEffect(() => {
    const listener = (payload) => savedHandler.current(payload);
    const unsubscribe = eventBus.on(event, listener);
    return unsubscribe; // Cleanup przy unmount
  }, [event]);
}

Sprytny szczegół to useRef: hook zawsze woła najnowszą wersję handler, a subskrypcję odnawia tylko wtedy, gdy zmieni się nazwa zdarzenia. W React 19.2 ten sam problem rozwiązuje wbudowany hook useEffectEvent. Nadawanie jest prostsze, bo nie wymaga sprzątania:

// Hook do emitowania zdarzeń
function useEventEmitter() {
  return useCallback((event, payload) => {
    eventBus.emit(event, payload);
  }, []);
}

Cykl życia słuchacza wygląda więc tak: komponent się montuje, useEffect zapisuje go przez eventBus.on(), każde emit() go wywołuje, a przy odmontowaniu funkcja sprzątająca wypisuje go z magistrali.

Praktyczny przykład: System alertów statku

Czas na prawdziwe moduły. Panel silnika to nadawca (publisher): po każdym kliknięciu emituje dwa zdarzenia, zmianę prędkości i wpis do dziennika:

// Komponent silnika - emituje zdarzenia
function EnginePanel() {
  const emit = useEventEmitter();

  const setSpeed = (speed) => {
    emit('engine:speedChanged', { speed, timestamp: Date.now() });
    emit('ship:log', { source: 'Silnik', message: `Prędkość: ${speed}` });
  };

  return (
    <div className="panel">
      <h3>Silnik</h3>
      <button onClick={() => setSpeed('MAX')}>MAX</button>
      <button onClick={() => setSpeed('CRUISE')}>CRUISE</button>
      <button onClick={() => setSpeed('STOP')}>STOP</button>
    </div>
  );
}

Wyświetlacz prędkości to odbiorca (subscriber). Nasłuchuje tylko jednego zdarzenia i zapisuje otrzymaną prędkość we własnym stanie:

// Komponent wyświetlacza - nasłuchuje zdarzeń
function SpeedDisplay() {
  const [speed, setSpeed] = useState('IDLE');

  useEventListener('engine:speedChanged', (data) => {
    setSpeed(data.speed);
  });

  return <div className="display">Prędkość: {speed}</div>;
}

Dziennik pokładowy nasłuchuje wszystkich wpisów ship:log, bez względu na to, który moduł je nadał, i trzyma dziesięć najnowszych:

// Komponent logu - nasłuchuje wszystkich logów
let nextEntryId = 0;

function ShipLog() {
  const [entries, setEntries] = useState([]);

  useEventListener('ship:log', (data) => {
    const entry = { ...data, id: nextEntryId++, time: new Date().toLocaleTimeString() };
    setEntries(prev => [entry, ...prev].slice(0, 10));
  });

  return (
    <ul className="log">
      {entries.map(entry => (
        <li key={entry.id}>[{entry.time}] {entry.source}: {entry.message}</li>
      ))}
    </ul>
  );
}

Każdy wpis dostaje własne id z licznika, bo nowe wpisy lądują na początku listy, a klucz oparty na indeksie przesuwałby się przy każdym zdarzeniu. Zwróć uwagę: EnginePanel nie importuje SpeedDisplay ani ShipLog. Komponenty są całkowicie niezależne. Możesz usunąć ShipLog z drzewa, a EnginePanel dalej działa bez zmian. Gdy dołożysz sterowanie osłonami, wystarczy, że też będzie emitować ship:log, a dziennik pokaże jego wpisy.

Natywne EventTarget API

Zamiast własnego EventBusa możesz użyć natywnego API EventTarget, wbudowanego w przeglądarkę. Dane zdarzenia wędrują w polu detail obiektu CustomEvent:

// EventTarget - wbudowany w przeglądarkę
const shipEvents = new EventTarget();

function useNativeEventListener(eventName, handler) {
  useEffect(() => {
    const listener = (e) => handler(e.detail);
    shipEvents.addEventListener(eventName, listener);
    return () => shipEvents.removeEventListener(eventName, listener);
  }, [eventName, handler]);
}

function emitNativeEvent(eventName, detail) {
  shipEvents.dispatchEvent(new CustomEvent(eventName, { detail }));
}

Efekt jest ten sam, a klasy nie trzeba pisać. Tu jednak handler jest w zależnościach efektu, więc nowa funkcja przy każdym renderze oznacza ponowny zapis słuchacza. Działa to poprawnie, ale lepiej przekazać stabilną funkcję albo użyć triku z useRef.

Zaawansowany EventBus z middleware

EventBus można rozszerzyć o middleware, czyli funkcje przechwytujące zdarzenia przed dostarczeniem. Każda dostaje nazwę i dane, a zwraca dane dalej albo null, żeby zatrzymać zdarzenie:

class AdvancedEventBus extends EventBus {
  constructor() {
    super();
    this.middleware = [];
  }

  use(middlewareFn) {
    this.middleware.push(middlewareFn);
  }

  emit(event, payload) {
    // Przepuść przez middleware
    let finalPayload = payload;
    for (const mw of this.middleware) {
      finalPayload = mw(event, finalPayload);
      if (finalPayload === null) return; // Middleware zablokowało zdarzenie
    }
    super.emit(event, finalPayload);
  }
}

Klasa niczego nie robi, dopóki nie stworzymy instancji i nie podepniemy funkcji. Pierwsza loguje każde zdarzenie, druga prosi o potwierdzenie przed pełną mocą:

const advancedBus = new AdvancedEventBus();

// Middleware: logowanie
advancedBus.use((event, payload) => {
  console.log(`[Event] ${event}`, payload);
  return payload;
});

// Middleware: walidacja
advancedBus.use((event, payload) => {
  if (event === 'engine:speedChanged' && payload.speed === 'MAX') {
    if (!window.confirm('Na pewno pełna moc?')) return null; // Zablokuj!
  }
  return payload;
});

Middleware działają w kolejności dodania, a gdy walidacja zwróci null, zdarzenie nie dotrze do żadnego słuchacza. Ten sam pomysł znajdziesz w Reduksie i Expressie.

EDA vs Context API vs Props

CechaPropsContext APIEvent-Driven
KierunekRodzic -> dzieckoPrzodek -> potomkowieDowolny
PowiązanieŚcisłeŚrednieLuźne
RerenderyBezpośrednieWszyscy konsumenciTylko subskrybenci
Komunikacja między gałęziamiTylko przez wspólnego rodzicaWymaga wspólnego przodkaBezpośrednia
DebugowalnośćŁatwaŚredniaWymaga logowania

Gdy zmienia się wartość kontekstu, React renderuje ponownie każdy komponent, który ją czyta. Przy EventBusie renderują się tylko subskrybenci, którzy w reakcji zmienią własny stan.

Kiedy używać Event-Driven Architecture?

  • Komunikacja między odległymi komponentami: nie chcesz przekazywać propsów przez 5 poziomów
  • System powiadomień/alertów: wiele źródeł generuje eventy, jeden komponent je wyświetla
  • Logowanie i analityka: zdarzenia użytkownika emitowane raz, nasłuchiwane przez wiele systemów
  • Aktualizacje na żywo: dane aktualizowane w czasie rzeczywistym (WebSocket -> EventBus -> komponenty)

Moja rada: EventBus służy do ogłaszania, że coś się stało, a nie do przechowywania danych. Stan, który ekran musi pokazać, trzymaj w React, w kontekście albo w bibliotece stanu, gdzie łatwo prześledzić każdą zmianę. EDA to centralny system komunikacji statku, a klucz do sukcesu to cleanup przy odmontowaniu, inaczej powstaną wycieki pamięci, jak uszkodzony przekaźnik, który nadal zużywa energię. W następnej lekcji uporządkujemy same moduły wzorcem Atomic Design.

Pamiętaj: nadawca ogłasza, co się stało, i nie obchodzi go, kto słucha.

Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useRef, useCallback } from 'react';

// === MAGISTRALA ZDARZEŃ (EVENT BUS) ===
class EventBus {
  constructor() { this.listeners = new Map(); }

  on(event, callback) {
    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
    this.listeners.get(event).add(callback);
    return () => this.listeners.get(event)?.delete(callback);
  }

  emit(event, payload) {
    if (this.listeners.has(event)) {
      this.listeners.get(event).forEach(cb => cb(payload));
    }
  }
}

const eventBus = new EventBus();

// === CUSTOM HOOKI ===
function useEventListener(event, handler) {
  const saved = useRef(handler);
  useEffect(() => { saved.current = handler; }, [handler]);
  useEffect(() => {
    const listener = (p) => saved.current(p);
    return eventBus.on(event, listener);
  }, [event]);
}

function useEventEmitter() {
  return useCallback((event, payload) => eventBus.emit(event, payload), []);
}

// === NADAWCA (PUBLISHER): panel silnika ===
function EnginePanel() {
  const emit = useEventEmitter();
  const setSpeed = (speed) => {
    emit('engine:speedChanged', { speed });
    emit('ship:log', { source: 'Silnik', message: 'Prędkość: ' + speed });
  };
  return (
    <div className="panel publisher">
      <h3>Sterowanie silnikiem</h3>
      <span className="tag">Nadawca</span>
      <div className="btn-group">
        <button className="btn btn-danger" onClick={() => setSpeed('MAX')}>MAX</button>
        <button className="btn btn-primary" onClick={() => setSpeed('CRUISE')}>CRUISE</button>
        <button className="btn btn-default" onClick={() => setSpeed('STOP')}>STOP</button>
      </div>
    </div>
  );
}

// === NADAWCA (PUBLISHER): panel osłon ===
function ShieldPanel() {
  const emit = useEventEmitter();
  const [level, setLevel] = useState(100);
  const update = (v) => {
    setLevel(v);
    emit('shields:level', { level: v });
    emit('ship:log', { source: 'Osłony', message: v + '%' });
  };
  return (
    <div className="panel publisher">
      <h3>Sterowanie osłonami</h3>
      <span className="tag">Nadawca</span>
      <input type="range" min="0" max="100" value={level} onChange={e => update(Number(e.target.value))} />
      <span className="value">{level}%</span>
    </div>
  );
}

// === ODBIORCA (SUBSCRIBER): wyświetlacz prędkości ===
function SpeedDisplay() {
  const [speed, setSpeed] = useState('IDLE');
  useEventListener('engine:speedChanged', (data) => setSpeed(data.speed));
  const colors = { MAX: '#f44336', CRUISE: '#4fc3f7', STOP: '#666', IDLE: '#999' };
  return (
    <div className="panel subscriber">
      <h3>Prędkość</h3>
      <span className="tag sub-tag">Odbiorca</span>
      <div className="big-value" style={{ color: colors[speed] }}>{speed}</div>
    </div>
  );
}

// === ODBIORCA (SUBSCRIBER): wyświetlacz osłon ===
function ShieldDisplay() {
  const [level, setLevel] = useState(100);
  useEventListener('shields:level', (data) => setLevel(data.level));
  const color = level > 60 ? '#4caf50' : level > 30 ? '#ff9800' : '#f44336';
  return (
    <div className="panel subscriber">
      <h3>Osłony</h3>
      <span className="tag sub-tag">Odbiorca</span>
      <div className="bar"><div className="bar-fill" style={{ width: level + '%', background: color }} /></div>
      <span className="value">{level}%</span>
    </div>
  );
}

// === ODBIORCA (SUBSCRIBER): dziennik pokładowy ===
let nextEntryId = 0;

function ShipLog() {
  const [entries, setEntries] = useState([]);
  useEventListener('ship:log', (data) => {
    const entry = { ...data, id: nextEntryId++, time: new Date().toLocaleTimeString() };
    setEntries(prev => [entry, ...prev].slice(0, 10));
  });
  return (
    <div className="panel subscriber log-panel">
      <h3>Dziennik pokładowy</h3>
      <span className="tag sub-tag">Odbiorca (wszystkie zdarzenia)</span>
      {entries.length === 0 ? <p className="empty">Brak zdarzeń</p> : (
        <ul>{entries.map(e => <li key={e.id}>[{e.time}] {e.source}: {e.message}</li>)}</ul>
      )}
    </div>
  );
}

// === GŁÓWNY KOMPONENT ===
export default function App() {
  return (
    <div className="app">
      <h1>Event-Driven Architecture</h1>
      <p className="subtitle">Nadawcy emitują zdarzenia, odbiorcy reagują niezależnie</p>
      <div className="grid">
        <div className="col">
          <EnginePanel />
          <ShieldPanel />
        </div>
        <div className="col">
          <SpeedDisplay />
          <ShieldDisplay />
        </div>
      </div>
      <ShipLog />
    </div>
  );
}

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. Jaki jest główny cel Event-Driven Architecture w aplikacji React?

  2. 2. Która cecha ODRÓŻNIA Event-Driven Architecture od Context API w React?

Zadania praktyczne w grze

  • Edytor kodu

    Dokończ magistralę zdarzeń i hooki, przez które rozmawiają dwa niezależne komponenty. ___BLANK1___: funkcja zwrócona przez on usuwa ze zbioru słuchaczy zdarzenia event tylko ten jeden callback. ___BLANK2___: emit wywołuje każdego słuchacza z danymi payload. ___BLANK3___: w useEffect zapisz słuchacza listener w eventBus i zwróć funkcję wypisującą jako cleanup efektu. ___BLANK4___: EnginePanel po kliknięciu emituje zdarzenie engine:speedChanged z obiektem { speed }, a SpeedDisplay pokazuje otrzymaną prędkość.

  • Układanie w pionie

    Ułóż kroki implementacji Event-Driven Architecture w React:

  • Edytor kodu

    EventBus i hooki są gotowe, dokończ dwóch nadawców i dwóch odbiorców. ___BLANK1___: ShieldControl po przesunięciu suwaka emituje shields:level z nowym poziomem jako liczbą (next, nie stara wartość ze stanu). ___BLANK2___: AlertSystem po kliknięciu emituje alert:status z poziomem alarmu (alert.level: green, yellow albo red). ___BLANK3___: StatusDashboard nasłuchuje zdarzenia, które zmienia stan alarmu. ___BLANK4___: ShipLog dopisuje nowy wpis na początek listy i zostawia najwyżej 8 najnowszych wpisów.

  • Układanie w pionie

    Ułóż warstwy Event-Driven Architecture od najniższej do najwyższej:

  1. Zadanie z kodemPraktyka: EventBus i useEventListener
  2. PytanieCel Event-Driven Architecture
  3. Ułóż w kolejnościKroki implementacji EventBus
  4. Zadanie z kodemPraktyka: system z wieloma nadawcami i odbiorcami
  5. Ułóż w kolejnościWarstwy Event-Driven Architecture
  6. PytanieEDA vs Context API vs Props

Przydatne artykuły