Kurs JavaScript i React · Moduł 11: Pobieranie danych i API
Cachowanie danych i Stale-While-Revalidate
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:
- Stale: natychmiast pokaż dane z cache (nawet jeśli mogą być nieaktualne)
- While-Revalidate: jednocześnie pobierz świeże dane z serwera w tle
- 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. Co oznacza nazwa wzorca 'Stale-While-Revalidate' (SWR)?
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: