Kurs JavaScript i React · Moduł 16: Obsługa błędów i Suspense

Graceful Degradation i Resilient UI

6 min czytania ·
W tej lekcji6

Serwer ze statystykami misji nie odpowiada. Co powinien zobaczyć astronauta: pusty ekran z komunikatem "Błąd 500" czy pulpit, na którym działa wszystko poza jednym kafelkiem z informacją, że statystyki wrócą za chwilę? Odpowiedź jest oczywista, a mimo to wiele aplikacji wybiera pierwszą opcję. Na stacji kosmicznej awaria jednego systemu nie może oznaczać końca misji. Każdy krytyczny system ma kopie zapasowe, a załoga jest przeszkolona do pracy w trybie awaryjnym. Twoja aplikacja React powinna działać tak samo - nawet jeśli coś pójdzie nie tak, użytkownik powinien móc kontynuować pracę.

Czym jest Graceful Degradation?

Graceful degradation (łagodna degradacja) to filozofia projektowania, w której aplikacja kontynuuje działanie nawet, gdy niektóre jej części zawiodą - po prostu z obniżonym poziomem funkcjonalności. Statek z uszkodzonym teleskopem nadal leci, tylko widzi mniej.

Pełna funkcjonalność vs. Degradacja

Porównaj dwie aplikacje. Pierwsza przy awarii pokazuje biały ekran, druga zamyka awarię w jednym przedziale dzięki Error Boundary z poprzednich lekcji:

// Zamiast: awaria całej strony
function BrokenApp() {
  return <WhiteScreenOfDeath />; // Użytkownik nie może nic zrobić
}

// Graceful degradation: części aplikacji nadal działają
function ResilientApp() {
  return (
    <div>
      <Navigation />                    {/* Zawsze działa */}
      <ErrorBoundary fallback={<FallbackContent />}>
        <MainContent />                 {/* Może się zepsuć */}
      </ErrorBoundary>
      <Footer />                        {/* Zawsze działa */}
    </div>
  );
}

Navigation i Footer stoją poza granicą, więc awaria MainContent ich nie dotyczy. Użytkownik może przejść na inną stronę, zamiast odświeżać całą aplikację.

Wzorzec Retry (ponowna próba)

Gdy operacja się nie powiedzie, daj użytkownikowi możliwość ponownej próby. Z react-error-boundary wystarczy podpiąć resetErrorBoundary pod przycisk:

import { ErrorBoundary } from 'react-error-boundary';

function ErrorFallbackWithRetry({ error, resetErrorBoundary }) {
  return (
    <div className="error-panel">
      <h3>Awaria modułu</h3>
      <p>Błąd: {error.message}</p>
      <button onClick={resetErrorBoundary}>
        Ponowna próba
      </button>
    </div>
  );
}

function App() {
  return (
    <ErrorBoundary
      FallbackComponent={ErrorFallbackWithRetry}
      onReset={() => {
        // Wyczyść cache, zresetuj stan itp.
      }}
    >
      <DataPanel />
    </ErrorBoundary>
  );
}

Kliknięcie czyści granicę i React renderuje DataPanel od nowa. Jeśli przyczyna awarii była chwilowa, moduł wraca do pracy, a jeśli nie, fallback pojawi się ponownie. Dlatego w onReset warto wyczyścić stan, który mógł ją spowodować.

Wzorzec Fallback Content

Zamiast pokazywać błąd, pokaż alternatywną treść. Widżet pogody nie jest krytyczny, więc przy awarii wystarczy uczciwa informacja:

function WeatherWidget() {
  const [data, setData] = useState(null);
  const [error, setError] = useState(false);

  useEffect(() => {
    fetchWeather()
      .then(setData)
      .catch(() => setError(true));
  }, []);

  if (error) {
    // Zamiast błędu, pokaż statyczne dane
    return (
      <div className="weather-widget offline">
        <p>Dane pogodowe niedostępne</p>
        <p>Ostatnia aktualizacja: 2h temu</p>
        <small>Pracujemy nad przywróceniem połączenia</small>
      </div>
    );
  }

  if (!data) return <WeatherSkeleton />;
  return <WeatherDisplay data={data} />;
}

Tu nie ma żadnej granicy błędów: błąd asynchroniczny łapie .catch(), a komponent sam decyduje, co pokazać. W prawdziwej aplikacji czas "2h temu" wyliczysz z zapisanej daty ostatniego udanego pobrania.

Partial Failure Handling

Obsługuj częściowe awarie - gdy niektórych danych nie można pobrać. Kluczem jest Promise.allSettled, które czeka na wszystkie obietnice i zwraca dla każdej obiekt ze status równym 'fulfilled' albo 'rejected'. Promise.all przerwałoby wszystko przy pierwszym błędzie:

function MissionDashboard() {
  const [missions, setMissions] = useState([]);
  const [stats, setStats] = useState(null);
  const [statsError, setStatsError] = useState(false);

  useEffect(() => {
    // Pobierz dane równolegle
    Promise.allSettled([
      fetch('/api/missions').then(r => r.json()),
      fetch('/api/stats').then(r => r.json())
    ]).then(([missionsResult, statsResult]) => {
      if (missionsResult.status === 'fulfilled') {
        setMissions(missionsResult.value);
      }
      if (statsResult.status === 'fulfilled') {
        setStats(statsResult.value);
      } else {
        setStatsError(true);
      }
    });
  }, []);

  return (
    <div>
      <h2>Panel misji</h2>

      {/* Statystyki - mogą być niedostępne */}
      {statsError ? (
        <p className="warning">Statystyki chwilowo niedostępne</p>
      ) : stats ? (
        <StatsPanel data={stats} />
      ) : (
        <StatsSkeleton />
      )}

      {/* Lista misji - zawsze próbujemy wyświetlić */}
      <MissionList missions={missions} />
    </div>
  );
}

Awaria statystyk nie rusza listy misji: każde źródło ma własną ścieżkę sukcesu i porażki. Jedna uwaga: fetch nie odrzuca obietnicy przy statusie 500, więc w produkcji sprawdź też r.ok, tak jak w pierwszej lekcji tej lokacji.

Retry z exponential backoff

Dla krytycznych danych implementuj automatyczne ponowne próby z rosnącymi opóźnieniami. Exponential backoff oznacza, że każda kolejna przerwa jest dwa razy dłuższa: 1 s, 2 s, 4 s, 8 s i tak dalej. Dzięki temu nie zasypujesz przeciążonego serwera żądaniami. Najpierw sama funkcja pomocnicza:

async function fetchWithRetry(url, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url);
      if (!response.ok) throw new Error('Request failed');
      return await response.json();
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
      // Exponential backoff: 1s, 2s (przy kolejnych próbach 4s, 8s...)
      const delay = Math.pow(2, attempt) * 1000;
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

Przy maxRetries = 3 funkcja wykona trzy próby, a między nimi odczeka 1 s i 2 s. Po ostatniej porażce nie czeka już, tylko rzuca błąd dalej. Teraz komponent, który z niej korzysta i daje użytkownikowi ręczny przycisk, gdy automat się podda:

function CriticalData() {
  const [data, setData] = useState(null);
  const [error, setError] = useState(null);
  const [retrying, setRetrying] = useState(false);

  const loadData = async () => {
    setRetrying(true);
    setError(null);
    try {
      const result = await fetchWithRetry('/api/critical-data');
      setData(result);
    } catch (err) {
      setError(err);
    } finally {
      setRetrying(false);
    }
  };

  useEffect(() => { loadData(); }, []);

  if (error) return (
    <div>
      <p>Nie udało się pobrać danych po 3 próbach</p>
      <button onClick={loadData}>Spróbuj ponownie</button>
    </div>
  );
  if (retrying) return <p>Ponawiam próbę połączenia...</p>;
  if (!data) return <LoadingSkeleton />;
  return <DataDisplay data={data} />;
}

Kolejność warunków w return ma znaczenie: najpierw błąd, potem trwająca próba, na końcu szkielet. Moja rada: automatyczny retry stosuj tylko dla operacji bezpiecznych do powtórzenia, takich jak odczyt danych, nigdy dla wysłania płatności czy rozkazu startu.

Łączenie Error Boundary z Suspense

Najlepsza praktyka to łączenie obu mechanizmów. Granica błędów stoi na zewnątrz, Suspense w środku:

<ErrorBoundary FallbackComponent={ErrorUI}>
  <Suspense fallback={<LoadingSkeleton />}>
    <LazyComponent />
  </Suspense>
</ErrorBoundary>

Error Boundary przechwytuje błędy, a Suspense obsługuje ładowanie. Razem tworzą kompletny system bezpieczeństwa. Jeśli pobranie kodu LazyComponent się nie uda, na przykład przez zerwane połączenie, błąd trafi do zewnętrznej granicy zamiast zostawić wieczny szkielet. W następnej lekcji dołożysz do tego monitoring i strategie automatycznego odzyskiwania.

Pamiętaj: odporna stacja traci pojedyncze moduły, ale nigdy całej misji.

Kod do tej lekcji: App.jsx
import React, { useState, useEffect } from 'react';
import './styles.css';

// Error Boundary z retry
class RetryBoundary extends React.Component {
  constructor(props) {
    super(props);
    this.state = { hasError: false, error: null };
  }
  static getDerivedStateFromError(error) {
    return { hasError: true, error };
  }
  handleRetry = () => {
    this.setState({ hasError: false, error: null });
  };
  render() {
    if (this.state.hasError) {
      return (
        <div className="error-box">
          <h4>{this.props.label} - Awaria</h4>
          <p>{this.state.error.message}</p>
          <button onClick={this.handleRetry} className="retry-btn">
            Ponow probe
          </button>
        </div>
      );
    }
    return this.props.children;
  }
}

// Symulacja fetchWithRetry
async function fetchWithRetry(shouldFail, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    await new Promise(r => setTimeout(r, 500));
    if (!shouldFail || attempt === maxRetries - 1) {
      return { status: 'ok', data: 'Dane pobrane pomyslnie' };
    }
  }
  throw new Error('Nie udalo sie po wielu probach');
}

// Widget z fallback content
function DataWidget({ title, failChance = 0.3 }) {
  const [data, setData] = useState(null);
  const [error, setError] = useState(false);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    setTimeout(() => {
      if (Math.random() < failChance) {
        setError(true);
      } else {
        setData({ value: Math.floor(Math.random() * 100), unit: '%' });
      }
      setLoading(false);
    }, 800 + Math.random() * 1200);
  }, []);

  if (loading) return <div className="widget loading">Ladowanie {title}...</div>;
  if (error) return (
    <div className="widget offline">
      <strong>{title}</strong>
      <p>Dane niedostepne</p>
    </div>
  );
  return (
    <div className="widget online">
      <strong>{title}</strong>
      <p className="value">{data.value}{data.unit}</p>
    </div>
  );
}

// Modul z mozliwoscia awarii
function UnstableModule({ name }) {
  if (Math.random() < 0.4) {
    throw new Error(name + ' - blad krytyczny');
  }
  return (
    <div className="module-ok">
      <span className="dot" /> {name}: Online
    </div>
  );
}

export default function App() {
  const [key, setKey] = useState(0);

  return (
    <div className="app">
      <h1>Graceful Degradation</h1>
      <p className="subtitle">Czesciowe awarie nie niszcza calej stacji</p>
      <button onClick={() => setKey(k => k + 1)} className="reset-btn">
        Restart stacji
      </button>

      <div key={key}>
        <section>
          <h2>Widgety z fallback (Promise.allSettled)</h2>
          <div className="widget-grid">
            <DataWidget title="Tlen" failChance={0.3} />
            <DataWidget title="Energia" failChance={0.3} />
            <DataWidget title="Cisnienie" failChance={0.3} />
            <DataWidget title="Temp." failChance={0.3} />
          </div>
        </section>

        <section>
          <h2>Moduly z Error Boundary + Retry</h2>
          <div className="modules">
            <RetryBoundary label="Silnik">
              <UnstableModule name="Silnik glowny" />
            </RetryBoundary>
            <RetryBoundary label="Nawigacja">
              <UnstableModule name="Nawigacja" />
            </RetryBoundary>
            <RetryBoundary label="Lacznosc">
              <UnstableModule name="Lacznosc" />
            </RetryBoundary>
          </div>
        </section>
      </div>
    </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. Czym jest graceful degradation w kontekście aplikacji React?

  2. 2. Czym różni się Promise.allSettled od Promise.all?

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

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj retry z backoff

  • Układanie w pionie

    Uporządkuj czasy oczekiwania w exponential backoff (base 1s):

  • Edytor kodu

    Zaimplementuj partial failure handling

  • Układanie w pionie

    Ułóż poprawną kolejność opakowywania (od zewnętrznego do wewnętrznego):

  • Edytor kodu

    Zaimplementuj SafeLazyLoader

  1. Zadanie z kodemPraktyka: Retry Pattern
  2. PytanieGraceful degradation - definicja
  3. Ułóż w kolejnościExponential backoff - rosnące opóźnienia
  4. Zadanie z kodemPraktyka: Graceful Degradation z Promise.allSettled
  5. PytaniePromise.allSettled vs Promise.all
  6. Ułóż w kolejnościŁączenie Error Boundary z Suspense
  7. Zadanie z kodemPraktyka: ErrorBoundary + Suspense
  8. PytanieCentralizacja obsługi błędów

Przydatne artykuły