Kurs JavaScript i React · Moduł 11: Pobieranie danych i API

Cachowanie danych i Stale-While-Revalidate

7 min czytania ·
W tej lekcji8

Wyobraź sobie, że Twój statek kosmiczny wielokrotnie pyta Centrum Dowodzenia o te same dane o planetach. Za każdym razem czekasz na odpowiedź, nawet jeśli dane się nie zmieniły. To marnotrawstwo! Rozwiązaniem jest cachowanie, czyli przechowywanie danych lokalnie w pamięci podręcznej (cache) i odświeżanie ich w tle.

Dlaczego cachowanie jest ważne?

Porównajmy dwa pokłady tego samego statku.

Bez cache:

  • Każda nawigacja = nowe zapytanie = spinner
  • Użytkownik widzi "Ładowanie..." nawet dla danych, które już widział
  • Zbędne obciążenie serwera i sieci

Z cache:

  • Dane wyświetlane natychmiast z pamięci
  • Odświeżanie w tle (bez spinnera)
  • Lepsze doświadczenie użytkownika

Cache ma jednak cenę: dane w pamięci mogą być nieaktualne. Cała sztuka polega na tym, żeby wiedzieć, kiedy im ufać, a kiedy zapytać ponownie.

Wzorzec Stale-While-Revalidate (SWR)

SWR to strategia cachowania znana z HTTP (dyrektywa stale-while-revalidate w nagłówku Cache-Control) i używana przez biblioteki takie jak SWR czy TanStack Query. Nazwa mówi wszystko:

  1. Stale: natychmiast pokaż dane z cache (nawet jeśli mogą być nieaktualne)
  2. While-Revalidate: jednocześnie pobierz świeże dane z serwera w tle
  3. Po otrzymaniu świeżych danych zaktualizuj widok

Ten sam przepływ rozpisany na kroki wygląda tak:

// Wizualizacja SWR:
// Krok 1: Użytkownik wchodzi na stronę
//   -> Cache istnieje? TAK -> Pokaż dane z cache (natychmiast!)
//   -> Jednocześnie: wysyłaj zapytanie do serwera

// Krok 2: Serwer odpowiada
//   -> Dane się zmieniły? TAK -> Zaktualizuj widok i cache
//   -> Dane takie same? -> Nic nie rób

// Krok 3: Użytkownik wraca na stronę
//   -> Powtórz od Kroku 1 (natychmiastowe wyświetlenie!)

Użytkownik nie czeka ani przy pierwszym powrocie, ani przy kolejnych, a serwer i tak zostaje zapytany. SWR nie oszczędza więc zapytań, tylko czas oczekiwania.

Prosty cache z Map

Najprostszy cache można zbudować z obiektu Map, czyli słownika klucz-wartość. Kluczem będzie adres URL, a wartością dane razem ze znacznikiem czasu. Mapa leży poza komponentem, więc przeżywa jego odmontowanie. Oto custom hook, który ją wykorzystuje:

// Globalny cache - żyje poza komponentami
const cache = new Map();

function useFetchWithCache(url, ttl = 60000) {
  const [data, setData] = useState(() => {
    const cached = cache.get(url);
    if (cached && Date.now() - cached.timestamp < ttl) {
      return cached.data; // Natychmiastowe dane z cache!
    }
    return null;
  });
  const [loading, setLoading] = useState(!cache.has(url));
  const [error, setError] = useState(null);

  useEffect(() => {
    const controller = new AbortController();

    async function fetchData() {
      try {
        // Jeśli mamy cache - nie pokazuj spinnera
        if (!cache.has(url)) setLoading(true);
        setError(null);

        const response = await fetch(url, {
          signal: controller.signal,
        });
        if (!response.ok) {
          throw new Error(`HTTP ${response.status}`);
        }
        const result = await response.json();

        // Zapisz w cache z timestampem
        cache.set(url, {
          data: result,
          timestamp: Date.now(),
        });
        setData(result);
      } catch (err) {
        if (err.name !== 'AbortError') {
          setError(err.message);
        }
      } finally {
        setLoading(false);
      }
    }

    fetchData();
    return () => controller.abort();
  }, [url, ttl]);

  return { data, loading, error };
}

Funkcja przekazana do useState (leniwa inicjalizacja) wykona się tylko przy pierwszym renderze i od razu wyciąga dane z cache. Efekt mimo to zawsze pyta serwer, i to jest właśnie "revalidate". Reszta, czyli AbortController, response.ok i stany, pochodzi wprost z poprzednich lekcji.

TTL (Time To Live) - czas życia cache

TTL określa, jak długo dane w cache są uznawane za aktualne. W naszym hooku decyduje on o tym, czy przy montowaniu pokazać dane z pamięci od razu. Świeże zapytanie w tle i tak wyrusza zawsze:

// TTL = 60000ms (1 minuta)
// Dane starsze niż 1 minuta zostaną pobrane ponownie

// Krótki TTL (5-30s) - często zmieniające się dane
// np. ceny kryptowalut, status misji
const liveData = useFetchWithCache('/api/status', 5000);

// Średni TTL (1-5 min) - umiarkowanie zmienne dane
// np. lista planet, katalog statków
const catalog = useFetchWithCache('/api/planets', 60000);

// Długi TTL (10-60 min) - rzadko zmieniające się dane
// np. konfiguracja, statyczne listy
const config = useFetchWithCache('/api/config', 600000);

Dobór TTL to decyzja biznesowa, nie techniczna. Zadaj sobie pytanie, jak bardzo zaszkodzi użytkownikowi widok danych sprzed minuty.

Invalidacja cache - wymuszenie odświeżenia

Czasem wiemy na pewno, że dane w cache są nieaktualne, na przykład zaraz po dodaniu nowej misji. Wtedy usuwamy wpis ręcznie, czyli invalidujemy cache:

// Prosta invalidacja - usuń z cache
function invalidateCache(url) {
  cache.delete(url);
}

// Po dodaniu nowej misji - invaliduj listę misji
async function createMission(data) {
  await fetch('/api/missions', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(data),
  });

  // Wymuś odświeżenie listy misji
  invalidateCache('/api/missions');
}

Zasada jest prosta: każda mutacja (POST, PUT, DELETE), która zmienia dane na serwerze, powinna invalidować cache tych danych.

Optimistic Updates - aktualizacja przed odpowiedzią

Zamiast czekać na serwer, możemy zaktualizować UI natychmiast i cofnąć zmianę tylko wtedy, gdy serwer odmówi. Kluczowe jest zapamiętanie poprzedniego stanu, żeby mieć do czego wrócić:

function MissionList() {
  const [missions, setMissions] = useState([]);

  const deleteMission = async (id) => {
    // 1. OPTYMISTYCZNIE usuń z UI (natychmiast!)
    const previousMissions = [...missions];
    setMissions(prev => prev.filter(m => m.id !== id));

    try {
      // 2. Wysyłaj zapytanie DELETE do serwera
      const response = await fetch(`/api/missions/${id}`, {
        method: 'DELETE',
      });
      // fetch nie rzuca dla 4xx/5xx - sprawdzamy sami
      if (!response.ok) throw new Error(`HTTP ${response.status}`);
      // Sukces - UI już zaktualizowany!
    } catch (error) {
      // 3. BŁĄD - przywróć poprzedni stan (rollback)
      setMissions(previousMissions);
      alert('Nie udało się usunąć misji');
    }
  };

  return (
    <ul>
      {missions.map(m => (
        <li key={m.id}>
          {m.name}
          <button onClick={() => deleteMission(m.id)}>
            Usuń
          </button>
        </li>
      ))}
    </ul>
  );
}

Sprawdzenie response.ok jest tu niezbędne: bez niego odpowiedź 500 nie trafiłaby do catch i rollback nigdy by się nie wykonał. Optimistic updates polecam przy operacjach, które prawie zawsze się udają, jak polubienie czy usunięcie z listy.

TanStack Query -- profesjonalne cachowanie

W dużych projektach zamiast pisać własny cache, używamy biblioteki TanStack Query (dawniej React Query, obecnie wersja 5). To jak zaawansowany komputer pokładowy, który automatycznie zarządza całą komunikacją. Aplikację owijamy w QueryClientProvider, a dane pobieramy hookiem useQuery:

import {
  useQuery,
  useMutation,
  useQueryClient,
  QueryClient,
  QueryClientProvider,
} from '@tanstack/react-query';

const queryClient = new QueryClient();

function App() {
  return (
    <QueryClientProvider client={queryClient}>
      <PlanetList />
    </QueryClientProvider>
  );
}

function PlanetList() {
  // useQuery - automatyczny cache, SWR, retry, refetch
  const { data, isLoading, error } = useQuery({
    queryKey: ['planets'],
    queryFn: () =>
      fetch('https://swapi.dev/api/planets/')
        .then(res => res.json()),
    staleTime: 60000, // Dane świeże przez 1 minutę
    gcTime: 300000, // Usuń z cache po 5 minutach
  });

  if (isLoading) return <p>Skanowanie galaktyki...</p>;
  if (error) return <p>Błąd: {error.message}</p>;

  return (
    <ul>
      {data.results.map(planet => (
        <li key={planet.name}>{planet.name}</li>
      ))}
    </ul>
  );
}

Nie ma tu ani jednego useState ani useEffect: stany ładowania i błędu oraz cache daje biblioteka. Jedno zastrzeżenie z dokumentacji: queryFn musi rzucić błąd, żeby zapytanie trafiło w stan error, a fetch() nie rzuca dla 4xx/5xx. W produkcji dopisz więc sprawdzenie res.ok.

TanStack Query - kluczowe koncepcje

Poniżej najważniejsze opcje w jednym miejscu. queryKey identyfikuje dane w cache, staleTime mówi, jak długo są świeże, a gcTime (w wersji 4 nazywało się cacheTime) kiedy nieużywane dane zostaną usunięte:

// 1. queryKey - unikalny identyfikator danych w cache
//    Zmiana klucza = nowe zapytanie
const planets = useQuery({
  queryKey: ['planets', page],
  queryFn: () => fetchPlanets(page),
});

// 2. staleTime - jak długo dane są świeże
//    staleTime: 0 - zawsze odświeżaj (domyślnie)
//    staleTime: 60000 - świeże przez 1 minutę
//    staleTime: Infinity - nigdy nie odświeżaj

// 3. gcTime (garbage collection) - kiedy usunąć z cache
//    gcTime: 300000 - usuń po 5 min nieaktywności

// 4. Automatyczny refetch:
//    - Gdy okno wraca do fokusu
//    - Gdy sieć wraca po rozłączeniu
//    - W regularnych odstępach (refetchInterval)

// 5. useMutation - operacje zapisu z invalidacją
const mutation = useMutation({
  mutationFn: (newMission) =>
    fetch('/api/missions', {
      method: 'POST',
      body: JSON.stringify(newMission),
    }),
  onSuccess: () => {
    // Po dodaniu misji - invaliduj cache listy misji
    queryClient.invalidateQueries({
      queryKey: ['missions']
    });
  },
});

Domyślne staleTime to 0, a gcTime to 5 minut. staleTime: Infinity wyłącza tylko automatyczne odświeżanie, ręczna invalidacja nadal działa. Wewnątrz komponentu klienta pobierasz przez const queryClient = useQueryClient(), a w prawdziwym POST dodaj nagłówek Content-Type z poprzedniej lekcji. Zwróć uwagę, że invalidateQueries to dokładnie nasza ręczna invalidacja, tylko wykonana za Ciebie.

Pamiętaj: cache to pamięć komputera pokładowego, pokazuje to, co już wiesz, a w tle sprawdza, czy galaktyka się nie zmieniła.

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

// Globalny cache z Map
const cache = new Map();
let fetchCount = 0;

function useFetchWithCache(url, ttl = 30000) {
  const [data, setData] = useState(() => {
    const cached = cache.get(url);
    if (cached && Date.now() - cached.timestamp < ttl) {
      return cached.data;
    }
    return null;
  });
  const [loading, setLoading] = useState(!cache.has(url));
  const [error, setError] = useState(null);
  const [source, setSource] = useState('');

  useEffect(() => {
    const controller = new AbortController();

    // Sprawdz cache
    const cached = cache.get(url);
    if (cached && Date.now() - cached.timestamp < ttl) {
      setData(cached.data);
      setSource('cache (TTL: ' + Math.round((ttl - (Date.now() - cached.timestamp)) / 1000) + 's left)');
      setLoading(false);
      // SWR: pobierz w tle mimo cache
    }

    async function fetchData() {
      try {
        if (!cached) setLoading(true);
        setError(null);
        fetchCount++;
        const currentFetch = fetchCount;

        const response = await fetch(url, { signal: controller.signal });
        if (!response.ok) throw new Error(`HTTP ${response.status}`);
        const result = await response.json();

        cache.set(url, { data: result, timestamp: Date.now() });
        setData(result);
        setSource('serwer (fetch #' + currentFetch + ')');
      } catch (err) {
        if (err.name !== 'AbortError') setError(err.message);
      } finally {
        setLoading(false);
      }
    }

    fetchData();
    return () => controller.abort();
  }, [url, ttl]);

  const invalidate = () => {
    cache.delete(url);
    setSource('cache invalidated - refetching...');
    setData(null);
    setLoading(true);
  };

  return { data, loading, error, source, invalidate };
}

function PlanetPanel() {
  const { data, loading, error, source, invalidate } = useFetchWithCache(
    'https://swapi.dev/api/planets/', 30000
  );

  return (
    <div className="panel">
      <h3>Planety</h3>
      <div className="source-badge">{source || 'loading...'}</div>
      <button className="btn" onClick={invalidate}>Invaliduj cache</button>
      {loading && <div className="mini-loading"><div className="spinner"></div></div>}
      {error && <p className="error-text">{error}</p>}
      {data && data.results.slice(0, 5).map(p => (
        <div key={p.name} className="item">{p.name} - {p.climate}</div>
      ))}
    </div>
  );
}

function PeoplePanel() {
  const { data, loading, error, source, invalidate } = useFetchWithCache(
    'https://swapi.dev/api/people/', 30000
  );

  return (
    <div className="panel">
      <h3>Postacie</h3>
      <div className="source-badge">{source || 'loading...'}</div>
      <button className="btn" onClick={invalidate}>Invaliduj cache</button>
      {loading && <div className="mini-loading"><div className="spinner"></div></div>}
      {error && <p className="error-text">{error}</p>}
      {data && data.results.slice(0, 5).map(p => (
        <div key={p.name} className="item">{p.name} - {p.birth_year}</div>
      ))}
    </div>
  );
}

function CacheStatus() {
  const [, forceUpdate] = useState(0);
  useEffect(() => {
    const interval = setInterval(() => forceUpdate(n => n + 1), 1000);
    return () => clearInterval(interval);
  }, []);

  return (
    <div className="cache-status">
      <h3>Stan Cache (Map)</h3>
      <p>Entries: {cache.size}</p>
      {Array.from(cache.entries()).map(([key, val]) => (
        <div key={key} className="cache-entry">
          <span className="cache-key">{key.replace('https://swapi.dev/api/', '/')}</span>
          <span className="cache-age">{Math.round((Date.now() - val.timestamp) / 1000)}s temu</span>
        </div>
      ))}
      <button className="btn danger" onClick={() => { cache.clear(); forceUpdate(n => n + 1); }}>Wyczysc caly cache</button>
    </div>
  );
}

function App() {
  const [showPanels, setShowPanels] = useState(true);

  return (
    <div className="dashboard">
      <h1>Cache & SWR Demo</h1>
      <p>Odmontuj panele i zamontuj ponownie - dane pojawia sie natychmiast z cache!</p>
      <button className="btn toggle" onClick={() => setShowPanels(!showPanels)}>
        {showPanels ? 'Odmontuj panele' : 'Zamontuj panele (dane z cache!)'}
      </button>
      {showPanels && (
        <div className="grid">
          <PlanetPanel />
          <PeoplePanel />
        </div>
      )}
      <CacheStatus />
    </div>
  );
}

export default App;

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. Co oznacza nazwa wzorca 'Stale-While-Revalidate' (SWR)?

  2. 2. Kiedy należy 'zinwalidować' (usunąć/odświeżyć) cache w aplikacji React?

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kolejność kroków wzorca Stale-While-Revalidate:

  • Edytor kodu

    Implementacja cache z TTL

  • Edytor kodu

    Optimistic updates z rollback

  • Klikanie w kolejności

    Kliknij elementy w kolejności konfiguracji useQuery z TanStack Query:

  1. Ułóż w kolejnościCykl życia wzorca SWR
  2. PytanieWzorzec Stale-While-Revalidate
  3. Zadanie z kodemPraktyka: Cache z Map i TTL
  4. Zadanie z kodemPraktyka: Optimistic Updates
  5. PytanieInvalidacja cache
  6. Kliknij w kolejnościKonfiguracja useQuery w TanStack Query

Przydatne artykuły