Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura

Architektura event-driven i systemy czasowe w JavaScript

6 min czytania ·
W tej lekcji9

Po opanowaniu wzorców projektowych, zasad SOLID, programowania funkcyjnego i optymalizacji bundli, czas połączyć tę wiedzę w praktyce. W tym rozdziale zbudujemy system oparty na zdarzeniach (event-driven architecture) z symulacją czasu - wzorzec powszechnie stosowany w grach, symulacjach i systemach monitoringu.

Czym jest architektura event-driven?

Architektura event-driven to podejście, w którym przepływ programu jest sterowany przez zdarzenia - akcje użytkownika, sygnały z sensorów, upływ czasu czy komunikaty z innych systemów. Zamiast liniowego wykonywania kodu, system reaguje na zdarzenia w momencie ich wystąpienia.

// Tradycyjne podejście - liniowe
function checkPark() {
  checkFences();
  feedDinosaurs();
  updateVisitors();
  generateReport();
}

// Event-driven - reaktywne
const eventBus = new EventEmitter();

eventBus.on('fence:alarm', handleFenceAlarm);
eventBus.on('dinosaur:hungry', scheduleFeedingRun);
eventBus.on('visitor:entered', updateVisitorCount);
eventBus.on('hour:changed', generateHourlyReport);

W podejściu event-driven każdy komponent działa niezależnie i reaguje tylko na zdarzenia, które go dotyczą. To prowadzi do luźnego powiązania (loose coupling) - celu, któremu służą też poznane wcześniej zasady SOLID, zwłaszcza zasada odwrócenia zależności.

Wzorzec EventEmitter

Sercem architektury event-driven jest EventEmitter - implementacja wzorca Observer, który poznaliśmy w pierwszej lekcji tego modułu.

class EventEmitter {
  constructor() {
    this.listeners = new Map();
  }

  on(event, callback) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, []);
    }
    this.listeners.get(event).push(callback);
    return this; // Fluent interface
  }

  off(event, callback) {
    if (!this.listeners.has(event)) return this;
    const callbacks = this.listeners.get(event);
    const index = callbacks.indexOf(callback);
    if (index > -1) callbacks.splice(index, 1);
    return this;
  }

  emit(event, ...args) {
    if (!this.listeners.has(event)) return false;
    // Kopia tablicy, bo once() usuwa listener w trakcie pętli
    [...this.listeners.get(event)].forEach(callback => {
      callback(...args);
    });
    return true;
  }

  once(event, callback) {
    const wrapper = (...args) => {
      this.off(event, wrapper); // najpierw wyrejestruj, potem wywołaj
      callback(...args);
    };
    return this.on(event, wrapper);
  }
}

Metoda once to elegancki przykład wzorca Decorator - opakowuje oryginalny callback w wrapper, który automatycznie się wyrejestrowuje po pierwszym wywołaniu.

Symulacja czasu - cykl dzień/noc

W systemach symulacyjnych czas jest kluczowym elementem. W Parku Jurajskim cykl dzień/noc wpływa na zachowanie dinozaurów, harmonogram karmienia, godziny odwiedzin i protokoły bezpieczeństwa.

class TimeSimulation extends EventEmitter {
  constructor() {
    super();
    this.currentHour = 6; // Start o 6:00
    this.day = 1;
    this.scheduledEvents = [];
    this.isRunning = false;
  }

  advanceHour() {
    this.currentHour++;

    if (this.currentHour >= 24) {
      this.currentHour = 0;
      this.day++;
      this.emit('day:changed', this.day);
    }

    this.emit('hour:changed', this.currentHour, this.day);

    // Sprawdź zaplanowane zdarzenia
    this.checkScheduledEvents();

    // Emituj zdarzenie tylko przy zmianie pory dnia
    const timeOfDay = this.getTimeOfDay();
    if (timeOfDay !== this.timeOfDay) {
      this.timeOfDay = timeOfDay;
      this.emit('timeOfDay:changed', timeOfDay);
    }
  }

  getTimeOfDay() {
    if (this.currentHour >= 6 && this.currentHour < 12) return 'rano';
    if (this.currentHour >= 12 && this.currentHour < 18) return 'dzien';
    if (this.currentHour >= 18 && this.currentHour < 22) return 'wieczor';
    return 'noc';
  }

  scheduleEvent(hour, callback, options = {}) {
    const event = {
      hour,
      callback,
      recurring: options.recurring || false,
      label: options.label || 'unnamed'
    };
    this.scheduledEvents.push(event);
    return event;
  }

  checkScheduledEvents() {
    this.scheduledEvents = this.scheduledEvents.filter(event => {
      if (event.hour === this.currentHour) {
        event.callback(this.currentHour, this.day);
        return event.recurring; // Zachowaj tylko cykliczne
      }
      return true;
    });
  }
}

Zwróć uwagę, jak klasa TimeSimulation dziedziczy po EventEmitter - to zastosowanie zasady Open/Closed z SOLID. Możemy rozszerzać zachowanie symulacji przez dodawanie nowych listenerów, bez modyfikacji samej klasy.

Planowanie zdarzeń cyklicznych

W realnym systemie wiele zdarzeń powtarza się cyklicznie - karmienie dinozaurów, patrole bezpieczeństwa, raporty statusu.

const sim = new TimeSimulation();

// Karmienie mięsożerców - codziennie o 7:00 i 17:00
sim.scheduleEvent(7, (hour, day) => {
  console.log(`Dzień ${day}, ${hour}:00 - Karmienie mięsożerców`);
}, { recurring: true, label: 'karmienie-miesozerce' });

sim.scheduleEvent(17, (hour, day) => {
  console.log(`Dzień ${day}, ${hour}:00 - Drugie karmienie mięsożerców`);
}, { recurring: true, label: 'karmienie-miesozerce-2' });

// Patrole bezpieczeństwa - co godzinę w nocy (22:00-5:00)
for (const h of [22, 23, 0, 1, 2, 3, 4, 5]) {
  sim.scheduleEvent(h, (hour, day) => {
    console.log(`Dzień ${day}, ${hour}:00 - Patrol nocny`);
  }, { recurring: true, label: `patrol-${h}` });
}

// Raport dzienny - o 8:00
sim.scheduleEvent(8, (hour, day) => {
  console.log(`Dzień ${day} - Generowanie raportu dziennego`);
}, { recurring: true, label: 'raport-dzienny' });

Reakcja na pory dnia

Architektura event-driven pozwala różnym podsystemom reagować niezależnie na tę samą zmianę:

// System oświetlenia
sim.on('timeOfDay:changed', (timeOfDay) => {
  const lightingProfiles = {
    rano: { brightness: 70, color: 'warm-white' },
    dzien: { brightness: 100, color: 'daylight' },
    wieczor: { brightness: 40, color: 'amber' },
    noc: { brightness: 10, color: 'red' } // Czerwone, by nie płoszyć dinozaurów
  };
  const profile = lightingProfiles[timeOfDay];
  console.log(`Oświetlenie: ${profile.brightness}% (${profile.color})`);
});

// System bezpieczeństwa
sim.on('timeOfDay:changed', (timeOfDay) => {
  if (timeOfDay === 'noc') {
    console.log('Aktywacja nocnych protokołów bezpieczeństwa');
    console.log('Zwiększenie napięcia ogrodzeń o 20%');
    console.log('Włączenie kamer termowizyjnych');
  } else if (timeOfDay === 'rano') {
    console.log('Dezaktywacja nocnych protokołów');
    console.log('Przywrócenie standardowego napięcia ogrodzeń');
  }
});

// System odwiedzających
sim.on('hour:changed', (hour) => {
  if (hour === 9) console.log('Park otwarty dla odwiedzających');
  if (hour === 18) console.log('Ostatnie wejście dla odwiedzających');
  if (hour === 20) console.log('Park zamknięty - ewakuacja gości');
});

Łączenie z programowaniem funkcyjnym

Architekturę event-driven można wzbogacić o techniki funkcyjne, które poznaliśmy wcześniej w module:

// Funkcje czyste do transformacji danych
const calculateFeedingAmount = (species, weight, hour) => {
  const baseAmount = weight * 0.02; // 2% masy ciała
  const timeMultiplier = hour < 12 ? 1.2 : 0.8; // Więcej rano
  return Math.round(baseAmount * timeMultiplier);
};

// Kompozycja funkcji do przetwarzania zdarzeń
const pipe = (...fns) => (x) => fns.reduce((v, f) => f(v), x);

const processAlert = pipe(
  (alert) => ({ ...alert, timestamp: Date.now() }),
  (alert) => ({ ...alert, severity: alert.level > 7 ? 'critical' : 'warning' }),
  (alert) => ({ ...alert, notified: true })
);

// Użycie z systemem zdarzeń
sim.on('alert:triggered', (rawAlert) => {
  const processedAlert = processAlert(rawAlert);
  console.log(`Alert [${processedAlert.severity}]: ${processedAlert.message}`);
});

Zarządzanie stanem symulacji

Łączymy wzorzec zarządzania stanem (exercise_9_4) z systemem zdarzeń:

class SimulationState {
  constructor(simulation) {
    this.state = {
      parkStatus: 'operational',
      activeAlerts: 0,
      dinosaursCount: 0,
      visitorsCount: 0,
      fencesStatus: 'all-operational'
    };
    this.history = [];

    // Reaguj na zdarzenia symulacji
    simulation.on('hour:changed', (hour) => {
      this.updateState({ lastUpdate: hour });
    });

    simulation.on('alert:triggered', () => {
      this.updateState({
        activeAlerts: this.state.activeAlerts + 1
      });
    });
  }

  updateState(changes) {
    // Niemutowalność - nowy obiekt stanu
    const previousState = { ...this.state };
    this.state = { ...this.state, ...changes };
    this.history.push({
      timestamp: Date.now(),
      previous: previousState,
      current: { ...this.state }
    });
  }

  getState() {
    return Object.freeze({ ...this.state });
  }
}

Testowanie systemów event-driven

Systemy oparte na zdarzeniach są łatwe do testowania dzięki luźnemu powiązaniu komponentów:

// Test symulacji czasu
function testTimeSimulation() {
  const sim = new TimeSimulation();
  const events = [];

  sim.on('hour:changed', (hour) => events.push({ type: 'hour', hour }));
  sim.on('day:changed', (day) => events.push({ type: 'day', day }));

  // Symuluj 25 godzin (przejście przez cały dzień)
  for (let i = 0; i < 25; i++) {
    sim.advanceHour();
  }

  console.log(`Zarejestrowane zdarzenia: ${events.length}`);
  console.log(`Zmiana dnia: ${events.filter(e => e.type === 'day').length}`);
  console.log(`Aktualny dzień: ${sim.day}, godzina: ${sim.currentHour}`);
}

testTimeSimulation();

Podsumowanie

Architektura event-driven łączy w sobie wiele wzorców i zasad, które poznałeś w tym module:

  1. Observer (exercise 9_1) - fundament systemu zdarzeń
  2. SOLID (exercise 9_2) - luźne powiązanie, otwartość na rozszerzenia
  3. Programowanie funkcyjne (exercise 9_3) - czyste funkcje do przetwarzania zdarzeń
  4. Zarządzanie stanem (exercise 9_4) - reaktywne aktualizacje stanu
  5. Optymalizacja (exercise 9_5-9_7) - mały bundle i podsystemy ładowane dopiero wtedy, gdy są potrzebne

To przygotowanie do projektu końcowego, w którym zintegrujesz wszystkie te elementy w kompletny system zarządzania Parkiem Jurajskim.

Kod do tej lekcji: index.js
// Symulacja czasu w parku
// Ćwiczenie: Zaimplementuj symulację cyklu dzień/noc

class TimeSimulation {
  constructor() {
    this.currentHour = 6;
    this.day = 1;
    this.events = [];
    this.isRunning = false;
  }

  // Zaimplementuj metody:
  // advanceHour() - przesuń czas o godzinę
  // scheduleEvent(hour, callback) - zaplanuj zdarzenie
  // getTimeOfDay() - zwróć porę dnia (rano/dzień/wieczór/noc)

  advanceHour() {
    // Twój kod tutaj
  }

  scheduleEvent(hour, callback) {
    // Twój kod tutaj
  }

  getTimeOfDay() {
    // Twój kod tutaj
  }
}

const sim = new TimeSimulation();
console.log("Symulacja: Dzień", sim.day, "Godzina:", sim.currentHour);

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. Czym charakteryzuje się architektura event-driven?

  2. 2. Jakie trzy podstawowe metody powinien implementować EventEmitter?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż elementy wywołania EventEmitter.on w odpowiedniej kolejności:

  • Edytor kodu

    W pliku index.js jest EventEmitter z lekcji o architekturze event-driven i klasa ParkTimeSystem, która symuluje godziny w parku. Uzupełnij luki: ___BLANK1___ to metoda tablicy, która w off() usuwa z listy jeden listener pod znalezionym indeksem, ___BLANK2___ to klasa, po której dziedziczy ParkTimeSystem, żeby mieć metody on, off i emit, a ___BLANK3___ to metoda tablicy, która z zaplanowanych wydarzeń wybiera tylko te na bieżącą godzinę. Co godzinę advanceHour() emituje 'hour:changed' z godziną i dniem, po północy najpierw 'day:changed' z numerem dnia, a każde wydarzenie zaplanowane metodą schedule(hour, name) na tę godzinę wywołuje 'event:triggered' z nazwą i godziną. start(intervalMs) uruchamia pętlę setInterval, a stop() ją zatrzymuje.

  • Układanie w pionie

    Uporządkuj etapy budowania systemu event-driven:

  • Klikanie w kolejności

    Ułóż poziomy testowania od najniższego do najwyższego.

  1. PytanieArchitektura event-driven
  2. PytanieEventEmitter - metody
  3. Ułóż w kolejnościSkładnia EventEmitter.on
  4. Zadanie z kodemPraktyka: EventEmitter z symulacją czasu
  5. Ułóż w kolejnościEtapy implementacji systemu event-driven
  6. PytanieFaza MVP w projekcie
  7. Kliknij w kolejnościSortowanie: Strategia testowania

Przydatne artykuły