Kurs JavaScript i React · Moduł 15: Wzorce i architektura
Event-Driven Architecture w React - Luźna komunikacja
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:
- Emitowaniu zdarzeń: komponent ogłasza, że coś się stało
- Nasłuchiwaniu zdarzeń: inne komponenty reagują na te ogłoszenia
- 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
| Cecha | Props | Context API | Event-Driven |
|---|---|---|---|
| Kierunek | Rodzic -> dziecko | Przodek -> potomkowie | Dowolny |
| Powiązanie | Ścisłe | Średnie | Luźne |
| Rerendery | Bezpośrednie | Wszyscy konsumenci | Tylko subskrybenci |
| Komunikacja między gałęziami | Tylko przez wspólnego rodzica | Wymaga wspólnego przodka | Bezpośrednia |
| Debugowalność | Łatwa | Średnia | Wymaga 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. Jaki jest główny cel Event-Driven Architecture w aplikacji React?
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: